- 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% 误报
492 lines
20 KiB
Go
492 lines
20 KiB
Go
// 织忆 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)
|
||
} |