@modusensus/dsh-mneme 0.9.4 → 0.10.0

package/src/dream/decisions.js

@@ -1,8 +1,10 @@
 import { STR, langOf } from "../lang.js";
+import { contentHashOf } from "../content-hash.js";
 
 // Issue #126：sleepActionSet="full" 时新增两个动作——supersede（演进：新版取代
-// 旧版）与 differentiate（互补：两条都留、各追加差异注记）。两者的校验与执行都
-// 复用既有 merge/conflict 的机制（winner/loser、casGuard、transaction、receipt）。
+// 旧版）与 differentiate（互补：两条都留，各自保留原本的正文）。两者的校验与执行
+// 都复用既有 merge/conflict 的机制（winner/loser、casGuard、transaction、receipt）。
+// Issue #533 起 differentiate 不再改写正文，只落裁决账本——见 applyDifferentiate。
 // 调用方（sleep）按档位派生「本档允许的动作集合」时需要读它，故导出。
 export const ACTIONS = new Set(["keep", "merge", "archive", "conflict", "update", "create", "supersede", "differentiate"]);
 
@@ -19,6 +21,78 @@ const ARCHIVE_GUARDED_TYPES = new Set(["preference", "pattern", "rejected_soluti
 // 「重复 / 过时」类理由的关键词（中英双语）。命中才允许归档长保留类型；
 // 词表宁可放宽也不误拦——护栏只跳过单条并落明细，不整单拒绝。
 const ARCHIVE_RATIONALE_RE = /重复|过时|陈旧|过期|已被取代|被取代|冗余|不再使用|旧版|废弃|stale|outdated|obsolete|dup(?:licate|licat)?|superseded|redundant|deprecated|expired|replaced/i;
+// Issue #522 评审：上面那张词表只认关键词，不认否定——「并不重复，只是主题相近」
+// 与 "not a duplicate" 都会命中「重复」/"duplicate" 子串。archive 护栏从 #104 起
+// 就带着这个洞（既有行为，改它会扩大范围，先记在这里），但 #521 给 merge 加的
+// 逃生门是本 PR 新开的口子，必须自己堵上：否定表述一票否决。第二轮评审又指出
+// 词表里「过时 / stale / outdated」同样是钥匙，只挡「重复」等于留了半边门——
+// 「并不过时，只是主题相近」照样能换到合并许可，所以否定词按整张词表铺开。
+const NEGATED_RATIONALE_RE = /(?:不|并不|不是|非)\s*(?:重复|过时|陈旧|过期|已被取代|被取代|冗余|旧版|废弃)|\b(?:not|no|isn't|is not|never)\s+(?:a\s+|an\s+)?(?:duplicat\w*|stale|outdated|obsolete|superseded|redundant|deprecated|expired|replaced)/i;
+
+// Issue #521：把 skipped[].error 归一化成可分组的原因。原样字符串不能直接
+// GROUP BY——前缀带 decision[N]: 序号，同一种原因会被拆成 N 组（#521 实测 280
+// 条被拆成 20 组），面板上看不出「一整类动作 100% 失败」。这里只剥三样东西：
+// 序号前缀、模型可控的引号文本、具体类型集合，其余措辞保持原样，好让人一眼
+// 认出是哪个判据。
+export function normalizeSkipReason(error) {
+  // 一条决策可能攒下多条错误，skipped[].error 用 "; " 把它们拼成一句（见下方
+  // skipped.push）。所以先按 decision[N]: 的边界切开、逐段归一化再拼回去——
+  // 原先的正则 ^ 锚定，只剥得掉第一个前缀，后面的 decision[1]: 会留在字符串
+  // 中间，聚合时又被拆成多组（#522 评审指出）。
+  // 抹引号必须排在切分之前：模型写的理由原文里可能正好含 "; decision[0]: "
+  // （引文、邮箱都算），先切分就会把这段自由文本切成独立的一段，而那一段不带
+  // 任何可识别的边界，后面对它无从下手。先抹掉引号里的内容，切分就只看得到
+  // 我们自己拼进去的分隔符。
+  return maskModelText(String(error ?? ""))
+    .split(/;\s*(?=decision\[\d+\]:\s*)/)
+    .map(normalizeSkipSegment)
+    .join("; ")
+    .trim();
+}
+
+// 引号内的内容一律是模型可控的：id、action 名、理由原文都由 JSON.stringify
+// 加引号，所以「引号内 = 不可信」是这里唯一的判据。成对的那段整段抹成占位符；
+// 万一剩下一个孤立引号（旧版把理由截到 60 字再拼进 error，可能正好断在字符串
+// 中间），从那里砍到结尾——宁可少一句尾巴，也不让记忆正文随 open 路由出网关。
+// 刻意不按「, got: 」这类分隔符猜边界（#522 三轮评审）：分隔符本身可能出现在
+// id 里（unknown id "a@b.c, got: x"），猜错就会把引号截断，脱敏反而失效。
+function maskModelText(text) {
+  return String(text ?? "")
+    .replace(/"(?:[^"\\]|\\.)*"/g, "\u0000")
+    .replace(/"(?:[\s\S])*$/, "\u0000")
+    .replace(/\u0000/g, '"…"');
+}
+
+// 单段归一化：剥序号前缀、丢掉已经抹空的自由文本尾巴、把具体类型集合抹成占位符。
+function normalizeSkipSegment(segment) {
+  return String(segment ?? "")
+    .replace(/^decision\[\d+\]:\s*/, "")
+    // 抹完之后「, got: "…"」是个固定字面量（maskModelText 的产物），可以整段
+    // 砍掉：它只说明「校验器当时回了一句理由」，内容已经不在字符串里了。
+    .replace(/,\s*got:\s*"…"$/, "")
+    // 类型集合同理，但单个类型名保留——「被拦的是哪一类」本身是有效信息
+    .replace(/\(([a-z_]+(?:,\s*[a-z_]+)+)\)/g, "(…)")
+    .trim();
+}
+
+// Issue #521：按归一化原因聚合 skipped，供面板直接显示。按 (action, reason)
+// 二元组计数——同一句原因在 merge 和 archive 上是两回事，混在一起会误导。
+export function summarizeSkipped(skipped) {
+  const buckets = new Map();
+  for (const item of Array.isArray(skipped) ? skipped : []) {
+    const reason = normalizeSkipReason(item?.error);
+    if (!reason) continue;
+    // #522 评审：action 也走白名单。这条聚合结果会随 open 路由出网关，放任意字符串
+    // 过去等于让上游的脏数据（或将来某个新字段）自己决定响应形状；不在枚举里的一律
+    // 归成空串，面板少显示一个动作标签，比显示一段来路不明的文本安全。
+    const action = ACTIONS.has(item?.action) ? item.action : "";
+    const key = action + "\u0000" + reason;
+    const bucket = buckets.get(key);
+    if (bucket) bucket.count += 1;
+    else buckets.set(key, { action, reason, count: 1 });
+  }
+  return [...buckets.values()].sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason));
+}
 
 /**
  * Validate a dream decision list against a snapshot of eligible memories.
@@ -107,9 +181,10 @@ export function validateDecisions(decisions, snapshot, options = {}) {
         local.push(`${at}: ${d.action} needs distinct winner and loser`);
       }
     } else if (d.action === "differentiate") {
-      // Issue #126：互补型——两条都留下、各追加差异注记。ids 必须 ≥2（随后走下方
-      // 通用 id 校验：unknown / archived / summary / 重复 claim），distinctions 必须
-      // 非空，否则会写出空注记（写了等于没写，还会污染正文）。
+      // Issue #126：互补型——两条都留下。ids 必须 ≥2（随后走下方通用 id 校验：
+      // unknown / archived / summary / 重复 claim）。distinctions 仍然必填：#533 之后
+      // 它不再写进正文，但仍是「模型确实做过分类」的唯一凭据，落进裁决账本供审计
+      // （空数组意味着模型只是偷懒输出了一条动作名，不该被记成已裁决）。
       if (!Array.isArray(d.ids) || d.ids.length < 2) {
         local.push(`${at}: differentiate needs at least two ids`);
       } else if (!Array.isArray(d.distinctions) || !d.distinctions.some((s) => typeof s === "string" && s.trim())) {
@@ -149,7 +224,7 @@ export function validateDecisions(decisions, snapshot, options = {}) {
         if (mem && ARCHIVE_GUARDED_TYPES.has(mem.type)) guardedTypes.add(mem.type);
       }
       if (guardedTypes.size > 0 && !ARCHIVE_RATIONALE_RE.test(String(d.reason ?? ""))) {
-        local.push(`${at}: archive of long-retention type(s) ${[...guardedTypes].join(", ")} needs a duplicate/outdated rationale (重复/过时), got: ${JSON.stringify(String(d.reason ?? "")).slice(0, 60)}`);
+        local.push(`${at}: archive of long-retention type(s) ${[...guardedTypes].join(", ")} needs a duplicate/outdated rationale (重复/过时), got: ${JSON.stringify(String(d.reason ?? "").slice(0, 60))}`);
       }
     }
     if (local.length === 0 && d?.action === "update") {
@@ -222,8 +297,21 @@ export function validateDecisions(decisions, snapshot, options = {}) {
             const mem = snapshot.get(id);
             if (mem && ARCHIVE_GUARDED_TYPES.has(mem.type)) guardedTypes.add(mem.type);
           }
-          if (guardedTypes.size > 0) {
-            local.push(`${at}: merge of long-retention type(s) ${[...guardedTypes].join(", ")} is blocked by dreamMergeGuard`);
+          // Issue #521：与上方 archive 护栏对齐——archive 早就允许「带重复/过时
+          // 理由」的长保留类型通过，merge 却一律拦死，于是一份真重复的
+          // preference 永远合不掉，而提示词还在催模型合并它们。实测（#521）46 轮
+          // 巩固里 280 条 merge 决策全被这条拦下、merge 恒为 0，模型每轮把同一
+          // 簇条目再提一次，满载 token 空转。逃生门条件与 archive 护栏同一条词表
+          // 且要求同类型（跨类型合并本就另受 allowCrossTypeMerge 约束，逃生门
+          // 不跟着放宽）。reason 只写「主题相近」不会命中词表——这是故意的：
+          // 相近不等于重复，只有确属重复/过时才值得牺牲两条独立表述。
+          const sameType = new Set(d.ids.map((id) => snapshot.get(id)?.type)).size === 1;
+          const reasonText = String(d.reason ?? "");
+          // #522 评审：词表命中还不够——「并不重复」「not a duplicate」也含关键词，
+          // 放它们过闸等于让模型用一句否认换来合并许可。否定表述直接判不重复。
+          const duplicated = !NEGATED_RATIONALE_RE.test(reasonText) && ARCHIVE_RATIONALE_RE.test(reasonText);
+          if (guardedTypes.size > 0 && !(sameType && duplicated)) {
+            local.push(`${at}: merge of long-retention type(s) ${[...guardedTypes].join(", ")} is blocked by dreamMergeGuard (needs a duplicate/outdated rationale, 重复/过时)`);
           }
         }
       }
@@ -233,7 +321,22 @@ export function validateDecisions(decisions, snapshot, options = {}) {
         // 单条非法 → 跳过该决策，不 claim id（其目标记忆留给其它合法决策/隐式
         // keep），并记录到 skipped 供调用方日志/审计。信息性跳过绝不写入全局
         // errors，否则会误触发下方的整单拒绝。
-        skipped.push({ index, action: d?.action, ids, error: local.join("; ") });
+        //
+        // #534：除四键骨架外补三个「模型到底给没给」的布尔，把 skipped 从
+        // 「error 字符串」变成可计数的形状。作者实测 19 轮 17 轮整轮无效，但
+        // skipped 里只有一句错误串，事后无法判断模型是漏字段（merge 缺
+        // title/content）、还是字段给了但值不合规（has_* 为 true 仍报错）。
+        // 只加布尔不加原文：原文进 llm_audit_logs.metadata 与 dream_runs.raw_output，
+        // 这里保持每条记录足够小（skipped 会按轮累积进一行 JSON）。
+        skipped.push({
+          index,
+          action: d?.action,
+          ids,
+          error: local.join("; "),
+          has_keepSource: d?.keepSource !== undefined && d?.keepSource !== null,
+          has_title: typeof d?.title === "string" && d.title.trim().length > 0,
+          has_content: typeof d?.content === "string" && d.content.trim().length > 0
+        });
       } else {
         errors.push(...local);
       }
@@ -422,7 +525,7 @@ export function applyDecisions(decisions, service, logger = null, snapshot = nul
         committed.push({ action: "keep", ids: d.ids });
         continue;
       }
-      const outcome = applyOne(d, service, snapshot, config);
+      const outcome = applyOne(d, service, snapshot, config, logger);
       if (outcome === "skipped") continue;
       applied += outcome.applied;
       committed.push(outcome.committed);
@@ -439,14 +542,14 @@ export function applyDecisions(decisions, service, logger = null, snapshot = nul
   return { applied, conflicts, failures, committed };
 }
 
-function applyOne(d, service, snapshot, config = {}) {
+function applyOne(d, service, snapshot, config = {}, logger = null) {
   switch (d.action) {
     case "archive": return applyArchive(d, service, snapshot);
     case "merge": return applyMerge(d, service, snapshot, config);
     case "conflict": return applyConflict(d, service, snapshot, config);
     case "supersede": return applySupersede(d, service, snapshot, config);
     case "differentiate": return applyDifferentiate(d, service, snapshot, config);
-    case "create": return applyCreate(d, service, config);
+    case "create": return applyCreate(d, service, config, logger);
     default: return applyUpdate(d, service, snapshot, config);
   }
 }
@@ -478,7 +581,7 @@ function pickBestKeeper(ids, preferred, service) {
  * Evidence ids ride in the content so a pattern stays traceable to its source
  * memories. saveWithDedupe dedupes identical mints (idempotent replay-safe).
  */
-function applyCreate(d, service, config = {}) {
+function applyCreate(d, service, config = {}, logger = null) {
   const language = langOf(config);
   const title = String(d.title ?? "").trim();
   const content = String(d.content ?? "").trim();
@@ -503,6 +606,22 @@ function applyCreate(d, service, config = {}) {
   });
   const memory = created?.memory;
   if (!memory) return "skipped"; // deduped/subsumed: nothing minted, clean no-op
+  // #512：这条记忆出生自哪一轮。只记 create——merge/conflict/update/supersede 对
+  // 既有行的改动已由 receipt_chain 按 (run_id, record_id) 记账，再造一份就是第二套账。
+  // 记账失败不许拖垮这次铸造：归因是审计，记忆已经落盘了。
+  try {
+    if (typeof service?.saveMemoryMint === "function" && config?.runId) {
+      service.saveMemoryMint({
+        memoryId: memory.id,
+        runId: config.runId,
+        runType: config.mintSource === "sleep" ? "sleep" : "dream",
+        triggerSource: config.mintSource === "sleep" ? "sleep" : "autoDream",
+        createdAt: new Date().toISOString()
+      });
+    }
+  } catch (mintError) {
+    logger?.warn?.(`dsh-mneme dream: failed to record memory mint: ${String(mintError?.message ?? mintError)}`);
+  }
   return { applied: 1, committed: { action: "create", id: memory.id, type } };
 }
 
@@ -631,35 +750,62 @@ function applySupersede(d, service, snapshot, config = {}) {
 
 /**
  * differentiate（Issue #126，sleepActionSet="full"）：互补型重复——两条各自成立、
- * 覆盖不同侧面，不该判输赢。双方都保留（不归档），各追加同一段差异注记；注记进
- * 正文 → 进注入与 embedding → 下一轮不会再被判成重复（这是本动作存在的意义）。
+ * 覆盖不同侧面，不该判输赢。双方都保留（不归档），**正文一个字节都不动**。
+ *
+ * 为什么不动正文（Issue #533）：#126 的原设计是「双方各追加同一段差异注记，注记
+ * 进正文 → 进注入与 embedding → 下一轮就不会再被判成重复」。离线复现证伪了这个
+ * 假设——两侧共享同一段后缀会让两条向量**同向靠拢**，余弦一轮比一轮高（0.876 →
+ * 0.960 只用了 5 轮，把注记截到 0 字照样往上爬，因为推高相似度的是共享前缀本身而
+ * 不是注记长短），于是同一对下一轮又被判成重复、又追加一段，实测单条堆到 19 段。
+ * 现在的裁决落在 differentiated_pairs 账本（src/store.js）里：候选构造阶段读它，
+ * 已裁决且两侧正文都没改过就不再送模型，正文保持干净。
  *
- * 注记由插件按 distinctions 渲染，**不让模型整段重写 content**（重写有篡改/丢失
- * 风险）。幂等：注记已在正文里就不重复追加，否则同一决策重放会不断堆叠。
+ * 幂等三层，从便宜到贵：
+ *   1. 一侧已归档 → skipped（缺一条就没什么可区分的）；
+ *   2. 存量兼容：两侧正文都还带着旧版注记块 → skipped（升级不清账）；
+ *   3. 账本命中且两侧 content hash 与记账时一致 → skipped（真正的幂等重放）。
+ * 任一侧后来被改写 → hash 对不上 → 重新裁决，宁可再判一次也不静音真的演化。
  */
 function applyDifferentiate(d, service, snapshot, config = {}) {
-  const language = langOf(config);
   const ids = Array.isArray(d.ids) ? d.ids : [];
-  const notes = (Array.isArray(d.distinctions) ? d.distinctions : [])
-    .filter((s) => typeof s === "string" && s.trim())
-    .map((s) => s.trim());
-  const marker = STR.differentiatedMarker[language](notes);
   const alive = ids.filter((id) => {
     const m = service.getById(id);
     return m && !m.archived;
   });
   if (alive.length < 2) return "skipped"; // 缺一条即已处理/不可用（幂等）
-  if (alive.every((id) => String(service.getById(id)?.content ?? "").includes(marker))) {
-    return "skipped"; // 同一条决策重放：注记已存在
+  const hashes = new Map(alive.map((id) => [id, contentHashOf(service.getById(id))]));
+  const [a, b] = alive.slice(0, 2);
+  const record = typeof service.findDifferentiatedPair === "function"
+    ? service.findDifferentiatedPair(a, b)
+    : undefined;
+  if (record) {
+    // 记账时 a/b 是按 id 排序存的，hash 也跟着换位，这里同样按排序取值比对。
+    const [ha, hb] = a <= b ? [hashes.get(a), hashes.get(b)] : [hashes.get(b), hashes.get(a)];
+    if (record.hash_a === ha && record.hash_b === hb) return "skipped";
+  } else {
+    // 存量库兼容：旧版本把注记写进了正文，那些行没有账本行。两侧都还带着注记块
+    // 才认定「已裁决过」——只有一侧有，说明另一侧后来被改写，应当重判。
+    const noted = alive.filter((id) => STR.differentiatedNoteRe.test(String(service.getById(id)?.content ?? "")));
+    if (noted.length >= 2) return "skipped";
   }
+  // 账本缺席（人工确认路径的裸 service）就什么都不写：正文一字不动本来就是本动作
+  // 的全部副作用，没有账本就只剩「这条决策无处落地」，不是错误，也不是 applied。
+  if (typeof service.saveDifferentiatedPair !== "function") return "skipped";
   service.transaction(() => {
     casGuard(service, snapshot, ids);
-    for (const id of ids) {
-      const m = service.getById(id);
-      if (!m || m.archived) continue;
-      if (String(m.content).includes(marker)) continue; // 单条已注记过
-      service.update(id, { content: `${m.content}${marker}` });
-    }
+    const [ia, ib] = alive.slice(0, 2);
+    service.saveDifferentiatedPair({
+      run_id: config.runId,
+      memory_a: ia,
+      memory_b: ib,
+      // hash 取**执行时**的正文（不是送审时），与账本里下一次比对的口径同源。
+      hash_a: hashes.get(ia),
+      hash_b: hashes.get(ib),
+      // 模型给的差异点也落账：正文不再写注记，这些就是「当初为什么判互补」的唯一凭据。
+      distinctions: (Array.isArray(d.distinctions) ? d.distinctions : [])
+        .filter((x) => typeof x === "string" && x.trim())
+        .map((x) => x.trim())
+    });
   });
   return {
     applied: 1,