Files
memoryweave/go/internal/distill/write_ops.go
T
小唯 d8c525b544 feat(write-ops): A2 真矛盾判据门 + MarkConflict 双向指针(t_e3f5cb79)
- SameAttrValueConflict:同主体+同属性+不同取值(ASCII/CJK 属性-取值对 +
  governance.IsContradiction 否定对立复用),判不出=假,宁漏勿误
- JudgeWriteOp 出口:任何来源 CONFLICT-MARK 必须过门,不过门降级
  UPDATE(sim≥更新阈值)/ ADD(幻觉 TargetID 同样拦下)
- MarkConflict(oldID,newID):旧行 freshness=superseded + superseded_by=[新id];
  新行插入带 supersedes=[旧id](沿用既有字段,禁造新字段;不置 is_deleted)
- 回归 AC-1.3:testdata/conflict_stock_20261102.json(24 条 conflict 存量 +
  top3 对手句,人工判读 0/24 真矛盾)→ 72 对新判据真矛盾计数=0;
  正例对照 3/3(防恒 false 作弊)
- 依据:2026-10-31 方案 11-02 验证节;旧判据=相似检测器 100% 误报
2026-11-03 02:02:00 +08:00

492 lines
20 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 织忆 MemoryWeave — 写时四操作 + 写前哈希去重(t_3e98b65a,血统 Mem0 + MemoryFabric-v2 §3.1 Layer3)
//
// 背景(2026-10-14):遗忘机制研究方案B「写时四操作」悬置至今。现状痛点:
// · 无写前去重:731 条完全重复靠事后 /admin/dedup 清,新重复持续进(源头没堵)
// · 写时矛盾只 warning 不自动处理 → 矛盾记忆堆积(Mem0 issue #4956 失败模式:
// 「3个月前辞职」和「现在新工作」同时被检索 → 模型答错)
//
// 设计源:MemoryFabric-v2-自优化设计方案.md §3.1 Layer3(dedup_or_upgrade:
// sim>0.92 → ignore/upgrade;contradictory → flag conflict)
//
// 本文件实现两个写侧门:
// 1) 写前哈希去重:commit/写入前对【归一化】内容取 hash,完全重复 → 拒绝写入 + 记 log
// 2) 写时四操作:蒸馏产出候选事实后,对照 top-N 相似现有记忆判定:
// ADD 无语义等价 → 新建
// UPDATE 互补/更新 → 并入现有,旧条标 superseded_by(历史保留可追溯,不删)
// NOOP 无新增价值 → 丢弃(记 shadow log)
// CONFLICT-MARK 矛盾 → 双方标记 conflict,交人工(DELETE 保守:永不自动删除)
//
// ── 门控(默认 shadow ⇒ 零行为变化,硬要求)──────────────────────────
// 门控**只决定标记动作**(supersede/conflict),**不得拦基础 InsertMemory**
// (基础插入是 pre-feature 基线行为,必须无条件执行;2026-10-15 t_a0831457 P0
// 教训:旧实现让 shadow/off 恒不插入 ⇒ 10-14 起蒸馏事实全丢 2120 条)。
// 三模式语义表:
// · shadow(默认) ⇒ 插入新条 ✓ + 不做任何标记 ✓ + 记 shadow log ✓
// (= 注释里"零行为变化"的**字面**含义:等价于特性不存在)
// · apply ⇒ 插入新条 ✓ + 做标记 ✓(NOOP 丢弃;UPDATE 标 supersede;
// CONFLICT-MARK 标 conflict)
// · off ⇒ 插入新条 ✓ + 不跑判定 ✓(零开销)
//
// env(t_a0831457 AC10 改名,旧名兼容一档 + 弃用日志):
// ZHIYI_WRITE_SEMANTIC_OPS=shadow(默认)/apply/off
// 旧名 ZHIYI_WRITE_OPS 仍认(新名未设时兜底),日志提示弃用。
//
// 影子观察 48h → 出四操作判定分布 → 转 apply 走生产变更纪律
// (停→备份→改→启→验,db 备份走门禁)。
//
// 设计约束:
// · 零新依赖(只用 stdlib + internal/models)
// · 判定函数可注入(JudgeFunc),单测用确定性假实现,不依赖真实 LLM
// · 不碰 state.db:只写独立影子日志文件,不改存储常驻结构
package distill
import (
"crypto/md5"
"encoding/hex"
"encoding/json"
"fmt"
"log"
"math"
"os"
"sort"
"strings"
"sync"
"time"
"github.com/xiaoxue/memoryweave/internal/models"
)
// WriteOp 写时四操作
type WriteOp string
const (
OpAdd WriteOp = "ADD" // 无语义等价 → 新建
OpUpdate WriteOp = "UPDATE" // 互补/更新 → 并入现有(supersede)
OpNoop WriteOp = "NOOP" // 无新增价值 → 丢弃
OpConflictMark WriteOp = "CONFLICT-MARK" // 矛盾 → 双方标记 conflict,交人工
)
// WriteVerdict 单条候选事实的四操作判定结果
type WriteVerdict struct {
Op WriteOp `json:"op"`
Reason string `json:"reason"`
Candidate string `json:"candidate"`
// TargetID 命中被取代/冲突的现有记忆 ID(ADD 为空)
TargetID string `json:"target_id,omitempty"`
Similarity float64 `json:"similarity"`
Timestamp string `json:"timestamp"`
}
// SimilarMemory 候选事实的相似现有记忆(供判定对照)
type SimilarMemory struct {
ID string
Content string
Similarity float64
}
// cosineSim 计算两个向量的余弦相似度(局部实现,避免跨包依赖)。
func cosineSim(a, b []float32) float64 {
var dot, na, nb float64
n := len(a)
if len(b) < n {
n = len(b)
}
for i := 0; i < n; i++ {
dot += float64(a[i]) * float64(b[i])
na += float64(a[i]) * float64(a[i])
nb += float64(b[i]) * float64(b[i])
}
if na == 0 || nb == 0 {
return 0
}
return dot / (math.Sqrt(na) * math.Sqrt(nb))
}
// SimilarMemoryList 相似记忆列表(含按相似度排序 + 取 top-N)
type SimilarMemoryList []SimilarMemory
func (s SimilarMemoryList) Len() int { return len(s) }
func (s SimilarMemoryList) Less(i, j int) bool { return s[i].Similarity > s[j].Similarity }
func (s SimilarMemoryList) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
// TopN 返回相似度最高的前 n 条(稳定排序后截断)
func (s SimilarMemoryList) TopN(n int) SimilarMemoryList {
cp := make(SimilarMemoryList, len(s))
copy(cp, s)
sort.Sort(cp)
if n > len(cp) {
n = len(cp)
}
return cp[:n]
}
// FromMemoryRecords 把召回结果转成 SimilarMemoryList(用余弦相似度,需要向量)
func FromMemoryRecords(recs []models.MemoryRecord, queryVec []float32) SimilarMemoryList {
out := make(SimilarMemoryList, 0, len(recs))
for _, r := range recs {
sim := 0.0
if queryVec != nil && len(r.Vector) == len(queryVec) {
sim = cosineSim(queryVec, r.Vector)
}
out = append(out, SimilarMemory{ID: r.ID, Content: r.Content, Similarity: sim})
}
return out
}
// JudgeFunc 判定函数签名。生产走 LLM(JudgementJudge);单测注入确定性假实现。
type JudgeFunc func(candidate string, similar []SimilarMemory) WriteVerdict
// writeOpsMode 读取写时四操作模式(shadow 默认 / apply / off)。
// t_a0831457 AC10:env 改名 ZHIYI_WRITE_OPS → ZHIYI_WRITE_SEMANTIC_OPS(明确只控
// 语义增量操作,防基础写功能被误挂进此门控)。旧名保留兼容一档:新名未设时
// 回退旧名,且首次读到旧名时打一条弃用日志(只打一次,不刷)。
var writeOpsDeprecationOnce sync.Once
func writeOpsMode() string {
switch v := os.Getenv("ZHIYI_WRITE_SEMANTIC_OPS"); v {
case "apply", "off":
return v
case "":
// 新名未设 → 旧名兜底(兼容一档)
old := os.Getenv("ZHIYI_WRITE_OPS")
if old != "" {
writeOpsDeprecationOnce.Do(func() {
log.Printf("[write-ops] DEPRECATED: env ZHIYI_WRITE_OPS 已弃用,请改用 ZHIYI_WRITE_SEMANTIC_OPS(当前值=%s,语义不变,下版本移除旧名)", old)
})
}
switch old {
case "apply", "off":
return old
default:
return "shadow"
}
default:
// 非 apply/off 的值(含拼写错误)→ 默认 shadow(安全默认,零行为变化)
return "shadow"
}
}
// writeOpsEnabled 是否跑判定(off=完全不跑)
func writeOpsEnabled() bool {
return writeOpsMode() != "off"
}
// WriteOpsEnabled 导出版:供 server.go 等外部包在写路径入口判断是否开启。
func WriteOpsEnabled() bool {
return writeOpsEnabled()
}
// WriteOpsMode 导出版:返回当前模式(shadow/apply/off),供诊断/测试断言。
func WriteOpsMode() string {
return writeOpsMode()
}
// writeOpsApply 是否真改库(apply 模式)。
//
// 2026-10-25 硬保护:apply **强制要求 LLM 判定**。理由(离线回放实测,非推测):
// 规则基 defaultJudge 以 ZHIYI_WRITE_SIM_UPDATE=0.70 判 UPDATE,17179 条影子日志里
// 84%(14435 条)被判「应覆盖旧事实」;人工抽检低相似度样本 15/15 不是真覆盖
// (「用户查看知乎链接」vs「用户查看微信文章」都被判成覆盖)。放行 apply 会把上万条
// 记忆错误标记 superseded_by —— 规模是 2026-09-07 误删事故(67 条)的 200 倍。
// 因此未设 ZHIYI_WRITE_JUDGE=llm 时**降级为 shadow 并留痕**,不静默执行。
func writeOpsApply() bool {
if writeOpsMode() != "apply" {
return false
}
if LLMJudgeMode() != "llm" {
log.Printf("[write-ops] 拒绝 apply:ZHIYI_WRITE_JUDGE != llm(规则基判定精度实测≈0%%,会误覆盖上万条)→ 本次按 shadow 处理")
return false
}
return true
}
// writeOpsLogPath 影子日志路径(env 可覆盖)
func writeOpsLogPath() string {
if p := os.Getenv("ZHIYI_WRITE_OPS_LOG"); p != "" {
return p
}
return "/var/lib/memoryweave/write-ops-shadow.log"
}
var writeOpsLogMu sync.Mutex
// appendWriteOpsLog 追加一条判定记录到影子日志(JSONL)。
// 幂等:写失败只 log 不 panic;日志文件不存在自动创建。
func appendWriteOpsLog(v WriteVerdict) {
line, err := json.Marshal(v)
if err != nil {
log.Printf("[write-ops] shadow log marshal failed: %v", err)
return
}
writeOpsLogMu.Lock()
defer writeOpsLogMu.Unlock()
f, err := os.OpenFile(writeOpsLogPath(), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o644)
if err != nil {
log.Printf("[write-ops] shadow log open failed (%s): %v", writeOpsLogPath(), err)
return
}
defer f.Close()
if _, err := f.Write(append(line, '\n')); err != nil {
log.Printf("[write-ops] shadow log write failed: %v", err)
}
}
// ─── 归一化 + 哈希去重 ─────────────────────────────────────────
// NormalizeContent 归一化内容:去首尾空白、折叠连续空白、去句尾标点。
// 用于哈希去重的「完全重复」判定 —— 语义相同但排版不同(多句号/多空格)判为重复。
func NormalizeContent(s string) string {
s = strings.TrimSpace(s)
// 折叠连续空白(空格/Tab/换行)为单个空格
fields := strings.Fields(s)
s = strings.Join(fields, " ")
// 去句尾标点(。.!!??,,;;::)—— "工作。" 与 "工作" 视为同一事实
s = strings.TrimRight(s, "。.!!??,,;;::")
return s
}
// ContentHash 对归一化内容取 MD5 前 12 字符(与 models.ContentMD5 同口径,精确保存去重)。
func ContentHash(s string) string {
sum := md5.Sum([]byte(NormalizeContent(s)))
return hex.EncodeToString(sum[:])[:12]
}
// WriteOpHashDedup 写前哈希去重:候选内容归一化取 hash,与存量记忆的
// content_md5(或归一化后 hash)比对,完全重复 → 返回命中记忆(拒绝写入)。
// 返回 (dupID, true) 表示重复;nil 表示无重复可写入。
// existing 是候选内容编码后的相似召回(内存里做哈希比对,不额外编码)。
func WriteOpHashDedup(candidate string, existing []models.MemoryRecord) (string, bool) {
h := ContentHash(candidate)
for _, m := range existing {
if m.ContentMD5 != "" && m.ContentMD5 == h {
return m.ID, true
}
// 存量可能没存 ContentMD5 → 归一化后直接比(兜底)
if NormalizeContent(m.Content) == NormalizeContent(candidate) {
return m.ID, true
}
}
return "", false
}
// ─── 判定(规则基 + LLM 可选)────────────────────────────────────
// RuleThresholds 规则判定的阈值(MemoryFabric-v2 §3.1 Layer3 血统,env 可调)
var (
// ruleSimNoop:相似度 ≥ 此值且语义等价 → NOOP(无新增价值)
ruleSimNoop = envFloat("ZHIYI_WRITE_SIM_NOOP", 0.95)
// ruleSimUpdate:相似度在此区间且互补 → UPDATE(supersede)
ruleSimUpdate = envFloat("ZHIYI_WRITE_SIM_UPDATE", 0.70)
// ruleSimConflict:低于此值视为语义无关(不可能矛盾,走 ADD)
ruleSimConflictFloor = envFloat("ZHIYI_WRITE_SIM_CONFLICT_FLOOR", 0.45)
)
// ContradictionFunc 矛盾检测函数(可注入:默认用 ruleContradiction 启发式;
// 生产可接 governance.IsContradiction / ConflictDetector.Scan)。
type ContradictionFunc func(candidate string, similar SimilarMemory) bool
// ruleContradiction 规则基矛盾启发式:候选与相似记忆存在显式否定对立
// (如 "在招商局" vs "不在招商局" / "离职" vs "入职" / true vs false)。
// 保守:判不出明确对立 → 返回 false(宁可 UPDATE 也不误判 CONFLICT)。
// 注意:只判「同一事实域的对立词」,不判无关事实 —— 无关性由调用方
// 先按相似度 ≥ ruleSimConflictFloor 的门槛排除(不会拿无关记忆进来比)。
func ruleContradiction(candidate string, s SimilarMemory) bool {
negPairs := [][2]string{
{"不在", "在"}, {"没", "有"}, {"离职", "入职"}, {"辞职", "就职"},
{"false", "true"}, {"False", "True"}, {"FALSE", "TRUE"},
{"否", "是"}, {"关", "开"}, {"停", "启"}, {"结束", "开始"},
{"离开", "加入"}, {"卖出", "买入"}, {"减", "增"}, {"退出", "进入"},
}
for _, pair := range negPairs {
// 候选含否定词、存量含肯定词(或反之)→ 对立
if strings.Contains(candidate, pair[0]) && strings.Contains(s.Content, pair[1]) {
return true
}
if strings.Contains(candidate, pair[1]) && strings.Contains(s.Content, pair[0]) {
return true
}
}
return false
}
// defaultJudge 规则基判定(无 LLM 兜底,可测可跑)。比对 top-1 最相似记忆:
// · 相似度 ≥ ruleSimNoop 且归一化等价 → NOOP
// · 矛盾 → CONFLICT-MARK
// · 相似度 ≥ ruleSimUpdate(互补/更新)→ UPDATE(supersede 最相似那条)
// · 否则 → ADD
func defaultJudge(candidate string, similar []SimilarMemory, contradict ContradictionFunc) WriteVerdict {
v := WriteVerdict{
Op: OpAdd,
Candidate: candidate,
Reason: "无语义等价 → 新建",
Timestamp: time.Now().Format(time.RFC3339),
}
if len(similar) == 0 {
return v
}
top := similar[0] // 调用方已按相似度排序(TopN)
v.Similarity = top.Similarity
// 1) 完全重复(归一化等价)→ NOOP
if NormalizeContent(top.Content) == NormalizeContent(candidate) {
v.Op = OpNoop
v.TargetID = top.ID
v.Reason = "语义等价/完全重复 → 无新增价值,丢弃"
return v
}
// 2) 矛盾 → CONFLICT-MARK(共享锚 + 显式否定对立)
if contradict != nil && contradict(candidate, top) && top.Similarity >= ruleSimConflictFloor {
v.Op = OpConflictMark
v.TargetID = top.ID
v.Reason = "与现有记忆矛盾 → 双方标记 conflict,交人工"
return v
}
// 3) 高相似 + 互补 → UPDATE(supersede)
if top.Similarity >= ruleSimUpdate {
v.Op = OpUpdate
v.TargetID = top.ID
v.Reason = "互补/更新 → 并入现有,旧条标 superseded_by"
return v
}
// 4) 相似度不足 → ADD
return v
}
// JudgeWriteOp 写时四操作判定入口。mode=shadow 只记日志不改库;
// mode=apply 返回 verdict 供调用方 apply。
// judge 为 nil 时用规则基 defaultJudge;contradict 为 nil 时用 ruleContradiction。
// 返回 verdict;若完全关闭(off)返回 nil。
func JudgeWriteOp(candidate string, similar []SimilarMemory, judge JudgeFunc, contradict ContradictionFunc) *WriteVerdict {
if !writeOpsEnabled() {
return nil
}
var v WriteVerdict
if judge != nil {
v = judge(candidate, similar)
} else if writeOpsApply() || LLMJudgeMode() == "llm" {
// 2026-10-25:LLM 三分类判定。规则基 defaultJudge 的 UPDATE 精度实测约 0%
// (17179 条影子日志 84% 判 UPDATE,人工抽检 15/15 误判)⇒ apply 强制 llm;
// shadow 下也可用 ZHIYI_WRITE_JUDGE=llm 先观察新判定质量。judge 显式注入时优先注入。
v = LLMJudge(candidate, similar)
} else {
if contradict == nil {
contradict = ruleContradiction
}
v = defaultJudge(candidate, similar, contradict)
}
// ── AC-1(t_e3f5cb79):CONFLICT-MARK 出口判据门 ──────────────────
// 任何来源(rule / llm / 注入 judge)判出的 CONFLICT-MARK 必须过
// 「同主体 + 同属性 + 不同取值」确定性门(conflict_gate.go)才算真矛盾。
// 依据:24 条 conflict 存量人工判读 0/24 真矛盾(100% 误报,旧判据是相似
// 检测器)。不过门 ⇒ 降级:sim≥更新阈值按 UPDATE 走(supersede 语义仍成立),
// 否则按 ADD(两条都留,不造指针)。TargetID 指不到候选行(注入 judge 幻觉)
// 同样按不过门处理。
if v.Op == OpConflictMark {
targetContent := ""
for _, s := range similar {
if s.ID == v.TargetID {
targetContent = s.Content
break
}
}
if ev, ok := SameAttrValueConflict(v.Candidate, targetContent); ok {
v.Reason = v.Reason + " [gate:" + ev + "]"
} else {
if v.Similarity >= ruleSimUpdate {
v.Op = OpUpdate
v.Reason = v.Reason + " [gate:非同属性不同取值 → 降级 UPDATE]"
} else {
v.Op = OpAdd
v.TargetID = ""
v.Reason = v.Reason + " [gate:非同属性不同取值 → 降级 ADD]"
}
}
}
if v.Timestamp == "" {
v.Timestamp = time.Now().Format(time.RFC3339)
}
// 影子日志:always 记(shadow 和 apply 都记,供 48h 分布统计)
appendWriteOpsLog(v)
if !writeOpsApply() {
log.Printf("[write-ops][shadow] op=%s target=%s sim=%.3f reason=%s candidate=%.40s",
v.Op, v.TargetID, v.Similarity, v.Reason, candidate)
return &v
}
log.Printf("[write-ops][apply] op=%s target=%s sim=%.3f reason=%s candidate=%.40s",
v.Op, v.TargetID, v.Similarity, v.Reason, candidate)
return &v
}
// WriteOpsStore 写操作要触碰的存储接口(apply 模式用;便于单测注入内存实现)。
type WriteOpsStore interface {
// MarkSuperseded 把旧记忆标记为「被 targetNewID 取代」(写 superseded_by + is_active=false)
MarkSuperseded(oldID, targetNewID string) error
// MarkConflict 把「同主体+同属性+不同取值」确认成立的旧记忆标记为冲突(t_e3f5cb79):
// 必须同写双向指针 —— 旧行 superseded_by=[newID] + freshness 置 superseded;
// 新行 supersedes=[oldID] 由调用方在插入记录上带(同一批字段,禁造新字段)。
MarkConflict(oldID, newID string) error
}
// ApplyWriteOp 应用四操作判定到存储。返回是否应插入新记忆 + 错误。
//
// t_a0831457 P0 解耦修复:门控**只决定标记动作**(supersede/conflict),
// **不得拦基础 InsertMemory** —— 基础插入是 pre-feature 基线行为("特性不存在
// 之前"插入总是发生),"零行为变化"的硬要求 ⇒ 默认态(shadow)必须等价于
// 特性不存在。旧实现在 shadow/off 恒返回 shouldInsert=false,调用点据此
// `continue` 跳过基础插入 ⇒ 2026-10-14 起每日蒸馏事实 2053/1094/1559 → 384 → 0
// 全丢(2120 条判定被弃),属实现违背自身注释声明的 bug。
//
// 三模式语义表(与文件头部门控节一致):
// · shadow(默认)⇒ 本函数对所有判定返回 shouldInsert=true:插入新条 ✓
// + 不做任何标记(MarkSuperseded/MarkConflict 零调用)✓ + 判定已由
// JudgeWriteOp 记入 shadow log ✓
// · off ⇒ 不跑判定(JudgeWriteOp 返回 nil,调用点不进本函数);
// 即使误调本函数也返回 true(基础插入照跑,零开销)
// · apply ⇒ 按判定执行标记 + 插入:
// · ADD → 插入新记忆(返回 true)
// · UPDATE → 旧条标 superseded_by(历史保留)+ 插入新记忆(新条 active)
// · NOOP → 不插入(丢弃,特性的预期去重行为)
// · CONFLICT-MARK→ 旧条标 conflict + 新记忆供人工复核,仍插入(不静默丢)
// 返回 shouldInsert:true = 调用方应继续 InsertMemory;false = 丢弃
// (**只有 apply + NOOP / 标记失败** 才返回 false)。
func ApplyWriteOp(v WriteVerdict, store WriteOpsStore, newID string) (shouldInsert bool, err error) {
if !writeOpsApply() {
// shadow/off:门控不参与插入决策、不做任何标记 —— 基础插入无条件执行。
return true, nil
}
if v.Op == OpNoop {
return false, nil
}
switch v.Op {
case OpAdd:
return true, nil
case OpUpdate:
if v.TargetID != "" && store != nil {
if err := store.MarkSuperseded(v.TargetID, newID); err != nil {
return false, err
}
}
return true, nil
case OpConflictMark:
// AC-1.2(t_e3f5cb79):真矛盾(已过 SameAttrValueConflict 门)→ 旧行打标
// + 双向指针(旧行 superseded_by=[newID] 在 store 内写;新行 supersedes=[oldID]
// 由调用方插入时带上)。仍插入新条供召回对照(不静默丢)。
if v.TargetID != "" && store != nil {
if err := store.MarkConflict(v.TargetID, newID); err != nil {
return false, err
}
}
return true, nil
default:
return true, nil
}
}
// dedupNote 给 commit/distill 写路径用的统一去重提示(日志 + 响应可读)
func dedupNote(dupID, candidate string) string {
return fmt.Sprintf("write-ops dedup: 完全重复命中 %s,拒绝写入(candidate=%.40s)", dupID, candidate)
}
// DedupNote 导出版(供 server.go 日志使用)。
func DedupNote(dupID, candidate string) string {
return dedupNote(dupID, candidate)
}