@modusensus/dsh-mneme 0.9.4 → 0.10.0

package/lib/config.js

@@ -586,6 +586,16 @@ export const Config = z.object({
   // Minimum gap between two sleep runs (hours) — a second idle window within
   // this interval does not retrigger.
   sleepMinIntervalHours: z.natural().min(1).max(168).default(8),
+  // Issue #529（C 项的替代实现）：sleep 连续失败退避（默认关 = 行为逐字节不变）。
+  // 基数是 sleepMinIntervalHours，有效间隔 = 基数 × 2^连续失败数（成功清零），
+  // 封顶 max(基数, 24 小时)——不是硬 24 小时：这个键允许配到 168，用户配 48 就是
+  // 明说「两天跑一次」，退避只能放宽间隔、不该把用户自己的基数压小。
+  // 为什么不按 issue 原案用 snapshot_hash 判据：sleep 的
+  // snapshot_hash 是**跑完之后**对 phases 结果算的哈希（dream/sleep.js 的
+  // createHash(JSON.stringify(phases))），不是输入快照；同一批输入跑两次结果不同
+  // 就会得到不同哈希，用它当「同一输入又在失败」的判据不成立。退避与 #292 的
+  // autoDreamFailureBackoff 同构：只放大既有的最小间隔闸，不新增状态面。
+  sleepFailureBackoff: z.boolean().default(false),
   // Conflict adjudication strictness:
   //   gentle    only high-confidence conflicts (threshold 0.92) are resolved
   //   normal    standard dream-level (threshold 0.85)
@@ -653,6 +663,22 @@ export const Config = z.object({
   // 增长）；流式计费按实际用量，不按上限。
   sleepMaxTokens: z.natural().min(256).max(131072).default(8192).description("sleep 冲突消解与模式发现阶段的 LLM 输出预算上限（token）。原为硬编码 2048，sleepActionSet=full 实测需约 7000 导致裁决被截断而整轮失败；流式计费按实际用量，调大不增加成本。"),
 
+  // Issue #529：冲突阶段此前没有任何输入侧预算——同 scope 的全部相似对被一次性
+  // 拼进一个 prompt，实测单请求 163,054 输入 token（服务端 --ctx-size 163,840，
+  // 占 99.5%），449 对的池子必然撞墙；而失败的轮次不落 pairs、判 keep 又是
+  // no-op，下一轮冷却结束再送**完全相同的输入**，于是 23 轮连续 llm failed。
+  // 输出侧早有 sleepMaxTokens（#257），输入侧这一半一直是空的。
+  //
+  // 每批上限：0 = 不设上限（严格回退到旧的一次性全送，用于排查"是不是分批
+  // 引入的差异"）。取 12 是因为实测单对约 112~168 输入 token、12 对落在
+  // 1.5K~2K 区间，远低于任何服务商的上下文窗口，也不至于让 LLM 在长清单里
+  // 走神。
+  sleepConflictMaxPairs: z.natural().min(0).max(500).default(12).description("sleep 冲突阶段每批送给 LLM 的候选对上限（0 = 不设上限，回退旧的一次性全送）。实测单对约 112~168 输入 token，默认 12 对约 1.5K~2K。"),
+  // 每轮总上限：分批之后仍要有个总闸，否则一个 449 对的池子会拆成 38 批、
+  // 每批一次 LLM 往返，单轮跑上几小时（本身也没比撞墙好）。0 = 不设上限。
+  // 未入选的对不是"被丢弃"——它们留在 conflict_pending 与下一轮的候选池里。
+  sleepConflictMaxPairsPerRun: z.natural().min(0).max(5000).default(60).description("sleep 冲突阶段单轮累计裁定的候选对上限（0 = 不设上限）。默认 60 对 ≈ 5 批，约 10K 输入 token。"),
+
   // --- epistemic trust: memory source credibility (v0.4.5) -----------------
   // Distinguish memories by source: observation (measured / witnessed),
   // subjective (opinion / guess) and inferred (derived from other evidence).
@@ -966,7 +992,13 @@ export const Config = z.object({
   // 显式保存，画像正文必须是用户手写的原文，不给模型改写权。
   // 进 LIGHT_MODE_OFF：一次调用要读上百行记忆 + 一轮模型生成，与低资源档互斥（同
   // preInjectGate.enabled 的定性）；是预设不是强制，用户显式勾选仍然赢。
-  profileExtractEnabled: z.boolean().default(false)
+  profileExtractEnabled: z.boolean().default(false),
+
+  // #539 逐会话无痕：总开关默认关，保持旧用户行为；子代理选择器默认开，但总开关
+  // 未开时不生效。手动名单是精确的 session id 匹配。
+  sessionGateEnabled: z.boolean().default(false),
+  sessionGateSubagents: z.boolean().default(true),
+  sessionGateSessions: z.array(z.string()).default([])
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here

package/lib/continuity.js

@@ -173,10 +173,10 @@ function noticeAlreadyInSurface(session, text) {
  * 挂两条监听（#249 §7 的 `agent/pre-step` 触发位 + 压缩事件面），返回 { dispose }。
  *
  * `store` 直接注入：本模块只写提案表、不碰检索/嵌入，没有用到 service 的任何能力。
- * 调用方负责父／子闸门（`autoInject` + `continuityRescueEnabled`）；本函数不做开关判定，
- * 保持"挂上就是开"的单一口径。
+ * 调用方负责父／子开关（`autoInject` + `continuityRescueEnabled`），本函数另检查逐会话
+ * 无痕闸门；保持"挂上就是开、命中会话就不处理"的单一口径。
  */
-export function createContinuityRescue(ctx, store) {
+export function createContinuityRescue(ctx, store, sessionGate = null) {
   // 待处理的边缘：sessionId → 压缩事件序号。**真落地**的压缩事件到达时置位，下一次 pre-step 消费后
   // 删除（同一个边缘绝不注入第二次）。只留序号、不留 Session：插件在宿主进程里只 apply
   // 一次、服务所有会话，握着 Session 就是握着它的全量日志不放——压缩完就收工、不再有
@@ -184,6 +184,10 @@ export function createContinuityRescue(ctx, store) {
   const edge = new Map();
 
   const unsubscribe = ctx.on("session/event", (session, event) => {
+    if (sessionGate?.isOff(session)) {
+      if (session?.id) edge.delete(session.id);
+      return;
+    }
     if (!isCompactionEdge(event)) return;
     if (!session?.id) return;
     if (!edge.has(session.id) && edge.size >= MAX_TRACKED_EDGES) {
@@ -200,6 +204,10 @@ export function createContinuityRescue(ctx, store) {
     // reject 是"这一步不该发生"，往里面塞消息没有意义；未知形状原样放行。
     if (decision?.kind !== "enter") return decision;
     const session = payload?.agent?.session;
+    if (sessionGate?.isOff(session)) {
+      if (session?.id) edge.delete(session.id);
+      return decision;
+    }
     const sessionId = session?.id;
     if (!sessionId) return decision;
     if (!edge.has(sessionId)) return decision;

package/lib/document.js

@@ -16,6 +16,7 @@ import { homedir } from "node:os";
 import { isAbsolute, resolve, sep } from "node:path";
 import { scopeKeyOf } from "./scope.js";
 import { cosineSimilarity } from "./dream/clustering.js";
+import { isImportedRow } from "./memory-source.js";
 
 // C2 vector 档阈值（#164 拍板 0.92，与 findSessionDuplicate 的 vector 档同源）。
 // 刻意不做 24h 时间窗：那个窗是会话去重的「近邻界」（findSessionDuplicate 注释），
@@ -82,7 +83,7 @@ const ABSORB_EXEMPT_TYPES = new Set(["document", "summary"]);
  *
  * @returns {(payload: object, opts?: object) => Promise<object>}
  *   `{ action: "created"|"superseded", memory, superseded?, evidence_kept,
- *      evidence_dropped, evidence_archived, degraded }`
+ *      evidence_dropped, evidence_archived, evidence_skipped, degraded }`
  * @throws flag 关 / 路径非法或文件缺失 / title 或 summary 为空 / evidence 全部
  *   捏造 / 仅 vector 近重复（疑似重复外档，交 agent 裁决而不是静默二选一）。
  */
@@ -262,6 +263,10 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
       let superseded;
       const loser = explicitTarget ? store.getById(explicitTarget.id) : null;
       if (loser && !loser.archived) {
+        // 这里不挂 isImportedRow：loser 只会是 document 行（scopeMatched 全来自
+        // store.list({ type: "document" })），而 document 行永远不可能是外来行——
+        // 分享包格式排除 document，存储层的 document 只由 saveDocument 从这里铸造。
+        // 加谓词是空转，还会让下一个读者误以为 document 行有外来形态。
         store.update(loser.id, {
           content: `${loser.content}${supersededByPointer(created.id)}`,
           content_history: pushContentHistory(loser, "superseded")
@@ -276,18 +281,25 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
       // ABSORB_EXEMPT_TYPES）不吸收，吸收的是原子条；④只翻标志位、内容与审计全留
       // （可恢复），opt-out 走 archiveEvidence。
       // pinnedTypes 拿不到就不做这一步：宁可少做，也不能把保真池当普通行收走。
+      // 外来行不吸收（spec §15 一，车道 C8）：这条旁路不经任何 service.all() 行池，
+      // 车道 B 的九池静态锁看不见它；证据 id 由调用方给，循环里的 setArchived 是
+      // 机器发起的批量归档——正是「本库模型不改写别人的记忆」要禁的动作类。
+      // 引用本身照旧落库（文档合法地为它背书），只是不替别人撤下活跃面，
+      // 跳过条数走 evidence_skipped 报出来，不做静默跳过。
       let evidenceArchived = 0;
+      let evidenceSkipped = 0;
       if (archiveEvidence && pinnedTypes && typeof pinnedTypes.has === "function") {
         for (const id of kept) {
           // 事务内重读：期间被别的进程归档/遗忘的行不重复计数，也不误伤 pinned。
           const row = store.getById(id);
           if (!row || row.archived || row.forgotten) continue;
+          if (isImportedRow(row)) { evidenceSkipped += 1; continue; }
           if (pinnedTypes.has(row.type) || ABSORB_EXEMPT_TYPES.has(row.type)) continue;
           store.setArchived(id, true);
           evidenceArchived += 1;
         }
       }
-      return { created, superseded, evidenceArchived };
+      return { created, superseded, evidenceArchived, evidenceSkipped };
     });
     finalize(result.superseded ? [result.created, result.superseded] : [result.created]);
     return {
@@ -297,6 +309,7 @@ export function createDocumentRegistrar({ store, config, embedQuery, pushContent
       evidence_kept: kept.length,
       evidence_dropped: dropped.length,
       evidence_archived: result.evidenceArchived,
+      evidence_skipped: result.evidenceSkipped,
       degraded: dropped.length > 0
     };
   };

package/lib/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,