From daab83337b54778bb1cb446c0ac6e98563e8cab5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E5=94=AF?= Date: Sun, 20 Sep 2026 17:54:40 +0800 Subject: [PATCH] =?UTF-8?q?feat(governance):=20=E5=86=B2=E7=AA=81=E6=8C=81?= =?UTF-8?q?=E4=B9=85=E5=8C=96=20+=20=E7=A6=81=E6=AD=A2=E9=9D=99=E9=BB=98?= =?UTF-8?q?=20dismiss=EF=BC=88=E9=93=BE=E8=B7=AF=E7=A9=BA=E8=BD=AC?= =?UTF-8?q?=E4=BF=AE=E5=A4=8D=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 问题(2026-09-20 实测): 1) ConflictDetector.active 是纯内存 map,zhiyid 重启即清零 (17:17 重启后原先 pending 的 5 条冲突全部消失) 2) server.go 的 conflict_muchen 处理器把未匹配策略的冲突改写成 dismiss 再 Resolve, 且记成 RecordConflictResolved(true) —— 每条 pending 最多活 10 分钟即消失、 auto_resolve_rate 虚高、冲突从不进入任何人视野 (实测 17:19 建的冲突,同进程几分钟后 pending:0,未重启) 3) Conflict 不留两侧原文 ⇒ 事后无法核实真假矛盾(上一 commit 已加字段) 改动: - governance:ConflictDetector 增 path + load/persistLocked(全量原子落盘 tmp+rename); 新增 NewPersistentConflictDetector(path);NewConflictDetector() 保持纯内存(测试安全) - Scan/Resolve 变更后落盘 - server.go:检测器改用持久化构造(落盘失败降级内存 + 记日志) - server.go:禁止无脑 dismiss —— 72h 内保留 pending 供人工处置,超期才 latest_wins 自动收敛(真裁决才记指标) - 新增 conflict_persist_test.go:round-trip / resolve 落盘 / 纯内存不碰盘 未用 SQLite:冲突量级小,引 sqlite driver 需 cgo 新依赖(worker 曾在该方向崩溃 并留下锁重入死锁)。JSON 全量落盘零依赖、无锁重入。 --- go/internal/api/server.go | 24 +++- .../governance/conflict_persist_test.go | 112 ++++++++++++++++++ go/internal/governance/governance.go | 84 +++++++++++++ 3 files changed, 216 insertions(+), 4 deletions(-) create mode 100644 go/internal/governance/conflict_persist_test.go diff --git a/go/internal/api/server.go b/go/internal/api/server.go index 24725b3..462a273 100644 --- a/go/internal/api/server.go +++ b/go/internal/api/server.go @@ -70,7 +70,12 @@ func NewServer() http.Handler { routes.RegisterLDBGetter(func() storage.LanceDB { return ldb }) // 冲突检测器(E4.1: Commit 时矛盾检测依赖此实例) - conflictDetector := governance.NewConflictDetector() + // 2026-09-20:改用带持久化的构造 —— 此前 active 是纯内存 map,zhiyid 重启即丢 + // (实测 17:17 重启后 pending 冲突全部消失)。落盘失败不致命,降级为内存模式并记日志。 + conflictDetector, cdErr := governance.NewPersistentConflictDetector("/var/lib/memoryweave/conflicts.json") + if cdErr != nil { + log.Printf("[conflict] 持久化加载失败,降级为内存模式: %v", cdErr) + } // 注册全局实例,供 selfoptimize 触发器执行器读取(TConflict 判据) governance.SetGlobalConflictDetector(conflictDetector) @@ -1305,11 +1310,22 @@ func NewServer() http.Handler { if c.Status != "pending" { continue } - // 按策略自动裁决:latest_wins / primary_wins / dismiss + // 按策略自动裁决:latest_wins / primary_wins resolution := conflictAPI.Detector.AutoResolve(c) if resolution == "pending" { - // 低信任差异(两记忆 trust 差 < 0.2)→ dismiss - resolution = "dismiss" + // 2026-09-20 修复(链路空转):**不再静默 dismiss**。 + // + // 原实现把未匹配策略的冲突改写成 "dismiss" 再 Resolve,且记成 + // RecordConflictResolved(true) —— 后果是每条 pending 冲突最多活 10 分钟 + // 即消失、auto_resolve_rate 指标虚高,冲突从不进入任何人视野 + // (实测:17:19 新建冲突,同进程几分钟后 pending:0,未重启)。 + // + // 现改为:72 小时内保留 pending 供人工处置;超期才按 latest_wins 自动收敛 + // (这是真裁决,才记指标)。保留窗口内不再有任何自动处置。 + if time.Since(c.CreatedAt) < 72*time.Hour { + continue + } + resolution = "latest_wins" } if err := conflictAPI.Detector.Resolve(c.ID, resolution, ""); err == nil { selfoptimize.Dash.RecordConflictResolved(true) diff --git a/go/internal/governance/conflict_persist_test.go b/go/internal/governance/conflict_persist_test.go new file mode 100644 index 0000000..52561c8 --- /dev/null +++ b/go/internal/governance/conflict_persist_test.go @@ -0,0 +1,112 @@ +package governance + +import ( + "os" + "path/filepath" + "testing" +) + +// 2026-09-20 新增:冲突持久化回归测试 +// +// 背景:`ConflictDetector.active` 原本是纯内存 map(NewConflictDetector 只 make), +// zhiyid 重启即清零 —— 实测 17:17 重启后原先 pending 的 5 条冲突全部消失。 +// +// ⚠️ 必须用 t.TempDir():生产路径 /var/lib/memoryweave/conflicts.json 不许被测试碰。 +// (worker 版本把路径硬编码进 NewConflictDetector,会让单测写生产目录。) +func TestConflictPersistence_RoundTrip(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "conflicts.json") + + cd, err := NewPersistentConflictDetector(path) + if err != nil { + t.Fatalf("构造失败: %v", err) + } + + // 产生一条真冲突 + existing := []map[string]interface{}{ + {"content": "牧尘在招商局工作", "entities": []string{"招商局"}}, + } + conflicts := cd.Scan("牧尘不在招商局工作", []string{"招商局"}, existing) + if len(conflicts) == 0 { + t.Fatalf("期望检出冲突,实际 0 条") + } + id := conflicts[0].ID + + // 文件应已落盘 + data, err := os.ReadFile(path) + if err != nil { + t.Fatalf("落盘文件不可读: %v", err) + } + if len(data) == 0 { + t.Fatalf("落盘文件为空") + } + t.Logf("落盘 %d 字节,冲突 id=%s", len(data), id) + + // 模拟进程重启:新建 detector 从同一路径加载 + cd2, err := NewPersistentConflictDetector(path) + if err != nil { + t.Fatalf("重启加载失败: %v", err) + } + active := cd2.ListActive() + if len(active) != 1 { + t.Fatalf("重启后应仍有 1 条 pending,实际 %d 条", len(active)) + } + if active[0].ID != id { + t.Errorf("重启后冲突 id 不匹配: got %s want %s", active[0].ID, id) + } + if active[0].LeftContent != "牧尘在招商局工作" || active[0].RightContent != "牧尘不在招商局工作" { + t.Errorf("重启后原文留档丢失: left=%q right=%q", active[0].LeftContent, active[0].RightContent) + } + if active[0].Status != "pending" { + t.Errorf("重启后状态应为 pending,实际 %q", active[0].Status) + } +} + +// TestConflictPersistence_ResolveIsPersisted resolve 后也要落盘(否则重启后"复活") +func TestConflictPersistence_ResolveIsPersisted(t *testing.T) { + path := filepath.Join(t.TempDir(), "conflicts.json") + cd, _ := NewPersistentConflictDetector(path) + + existing := []map[string]interface{}{ + {"content": "牧尘在招商局工作", "entities": []string{"招商局"}}, + } + conflicts := cd.Scan("牧尘不在招商局工作", []string{"招商局"}, existing) + if len(conflicts) == 0 { + t.Fatalf("期望检出冲突") + } + id := conflicts[0].ID + + if err := cd.Resolve(id, "latest_wins", ""); err != nil { + t.Fatalf("Resolve 失败: %v", err) + } + + // 重启后应是 resolved,不再出现在 ListActive + cd2, _ := NewPersistentConflictDetector(path) + if got := len(cd2.ListActive()); got != 0 { + t.Errorf("resolved 冲突重启后不应再是 active,实际 %d 条", got) + } +} + +// TestNewConflictDetector_DoesNotTouchDisk 纯内存构造不得创建任何文件 +// (回归防护:worker 实现把生产路径硬编码进 NewConflictDetector) +func TestNewConflictDetector_DoesNotTouchDisk(t *testing.T) { + probe := "/var/lib/memoryweave/conflicts.json" + before, _ := os.Stat(probe) + + cd := NewConflictDetector() + if cd.path != "" { + t.Errorf("纯内存构造不应设置 path,实际 %q", cd.path) + } + existing := []map[string]interface{}{ + {"content": "牧尘在招商局工作", "entities": []string{"招商局"}}, + } + cd.Scan("牧尘不在招商局工作", []string{"招商局"}, existing) + + after, err := os.Stat(probe) + if before == nil && err == nil { + t.Fatalf("纯内存构造不应创建 %s(测试污染生产路径)", probe) + } + if before != nil && after != nil && before.ModTime() != after.ModTime() { + t.Fatalf("纯内存构造不应修改 %s", probe) + } +} diff --git a/go/internal/governance/governance.go b/go/internal/governance/governance.go index 7bbbb28..b251279 100644 --- a/go/internal/governance/governance.go +++ b/go/internal/governance/governance.go @@ -2,7 +2,11 @@ package governance import ( + "encoding/json" + "log" "math" + "os" + "path/filepath" "strconv" "strings" "sync" @@ -37,12 +41,90 @@ type Conflict struct { type ConflictDetector struct { mu sync.RWMutex active map[string]*Conflict + // path 非空时启用持久化:每次变更全量原子落盘(tmp + rename)。 + // 2026-09-20 新增:此前 active 是纯内存 map,进程重启即清零 + // (实测 zhiyid 重启后 pending 冲突全部消失)。 + path string } +// NewConflictDetector 返回纯内存检测器(**不碰磁盘**)。 +// 单测必须用这个:避免测试污染生产路径 /var/lib/memoryweave。 func NewConflictDetector() *ConflictDetector { return &ConflictDetector{active: make(map[string]*Conflict)} } +// NewPersistentConflictDetector 返回带持久化的检测器。 +// path 指向 JSON 落盘文件;加载失败不致命(返回可用实例 + err 供调用方记录)。 +// +// 为什么用 JSON 而不是 SQLite:冲突量级小(个位到几十条), +// 且引入 sqlite driver 需要 cgo 新依赖(worker 曾因之崩溃)。 +func NewPersistentConflictDetector(path string) (*ConflictDetector, error) { + cd := &ConflictDetector{active: make(map[string]*Conflict), path: path} + if path == "" { + return cd, nil + } + if err := cd.load(); err != nil { + return cd, err + } + return cd, nil +} + +// load 从磁盘载入冲突(含已 resolved 的,便于审计)。 +func (cd *ConflictDetector) load() error { + data, err := os.ReadFile(cd.path) + if err != nil { + if os.IsNotExist(err) { + return nil // 首次运行,无文件是正常的 + } + return err + } + if len(data) == 0 { + return nil + } + var list []*Conflict + if err := json.Unmarshal(data, &list); err != nil { + return err + } + cd.mu.Lock() + defer cd.mu.Unlock() + for _, c := range list { + if c != nil && c.ID != "" { + cd.active[c.ID] = c + } + } + return nil +} + +// persistLocked 全量原子落盘。**调用方必须已持有 cd.mu**(避免锁重入死锁)。 +func (cd *ConflictDetector) persistLocked() { + if cd.path == "" { + return + } + list := make([]*Conflict, 0, len(cd.active)) + for _, c := range cd.active { + list = append(list, c) + } + data, err := json.MarshalIndent(list, "", " ") + if err != nil { + log.Printf("[conflict] persist marshal failed: %v", err) + return + } + if dir := filepath.Dir(cd.path); dir != "" { + if err := os.MkdirAll(dir, 0o755); err != nil { + log.Printf("[conflict] persist mkdir failed: %v", err) + return + } + } + tmp := cd.path + ".tmp" + if err := os.WriteFile(tmp, data, 0o644); err != nil { + log.Printf("[conflict] persist write failed: %v", err) + return + } + if err := os.Rename(tmp, cd.path); err != nil { + log.Printf("[conflict] persist rename failed: %v", err) + } +} + // Scan 扫描新记忆与已有记忆的冲突 func (cd *ConflictDetector) Scan(newContent string, newEntities []string, existing []map[string]interface{}) []*Conflict { var conflicts []*Conflict @@ -80,6 +162,7 @@ func (cd *ConflictDetector) Scan(newContent string, newEntities []string, existi for _, c := range conflicts { cd.active[c.ID] = c } + cd.persistLocked() // 2026-09-20:新增即落盘(重启不丢) cd.mu.Unlock() } @@ -480,6 +563,7 @@ func (cd *ConflictDetector) Resolve(id, resolution, winner string) error { if c, ok := cd.active[id]; ok { c.Status = "resolved" c.Strategy = resolution + cd.persistLocked() // 2026-09-20:状态变更即落盘 } return nil }