@modusensus/dsh-mneme 0.13.0 → 0.14.0-beta.1

package/src/config.js

@@ -595,6 +595,33 @@ export const Config = z.object({
   conflictAutoResolveEnabled: z.boolean().default(false),
   conflictAutoResolveMinSimilarity: z.number().min(0.85).max(1).default(0.95),
 
+  // --- conflict ledger（issue #641，beta）-----------------------------------
+  // 冲突分诊账本的档位。真实库 788 对人审队列的全量分类：46% 近重复 + 20% 跨作用域
+  // 重复 + 5% 时序演进，真矛盾只有 ~27%——现行窄 prompt 把前 71% 全逼成了「输赢」，
+  // 再由人逐对裁决（≈30 条/天，且 92% 的对从未两侧同场）。分诊把「谁该机械处理、
+  // 谁才是真矛盾」从 LLM 手里拿回来（E13b：winner-take-all 裁决 P(毒胜出)=86.8%）。
+  //
+  //   "off"     默认。不分类、不记账，conflict 相位与本键引入前逐字节一致。
+  //   "shadow"  只分类 + 落 conflict_ledger 账本（bookkeeping，不触发 write hooks），
+  //             freeze/LLM 路径零变化——beta 实验的测量期：shadow 一周拿真实分诊
+  //             分布，验证是否复现 46/20/5/27。
+  //   "enforce" 确定性处置：T1（dup）走信息量优先 supersede（supersedeInfoFirstPair，
+  //             败者归档、胜者正文不动、可追溯注记在被归档侧）；T2（跨作用域重复）
+  //             与 T4（真矛盾）只记账——不停车、不送 LLM、不动正文；T3（时序演进）
+  //             落取代链：旧行 superseded_by/superseded_at 指向新行，两行都留着、
+  //             正文都不动，检索侧按降权处理。人审队列与 LLM 裁决都不再消费冲突
+  //             候选；与 conflictFreezeEnabled 同开时 freeze 让位（降级 shadow
+  //             + warn，#616 父子绑定不继承）。
+  //
+  // 判据唯一实现在 src/dream/triage.js；处置共享实现在 decisions.js 的
+  // supersedeInfoFirstPair。每个档位的行为都真实存在——#616 的「假成功」教训
+  // （autoMin 0.95 在现库覆盖为 0，开了等于没开）。
+  conflictLedgerMode: z.union([z.const("off"), z.const("shadow"), z.const("enforce")]).default("off"),
+  // T1（dup）档的相似度下限。检测阈值（normal 0.85）与自动档 autoMin（0.95）之间
+  // 的空带由它接管：真实库 reason 相似度回声集中在 0.85-0.93，正好落在两个阈值
+  // 之间、自动档开了也接不住的那一段。下界与检测阈值同源。
+  conflictLedgerDupMinSimilarity: z.number().min(0.85).max(1).default(0.9),
+
   // --- entity gene (v0.3.0) -----------------------------------------------
   // Opt-in: when false (default) nothing in the pipeline extracts entities.
   // The storage layer (entities/entity_attrs/entity_relations tables + CRUD)

package/src/dream/decisions.js

@@ -11,7 +11,7 @@ export const ACTIONS = new Set(["keep", "merge", "archive", "conflict", "update"
 // Epistemic trust (v0.4.5): when config.trustEpistemicWeighting is on, merge
 // keepSource and conflict winners prefer the higher-trust memory. Higher value
 // = preferred. observation (measured) > inferred (derived) > subjective (guess).
-const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
+export const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
 
 // Issue #104 方向 2：archive 类型护栏的长保留类型集合——这些类型的存在意义
 // 就是长期保存（踩坑记录、约束、用户偏好、挖掘出的模式），LLM 以「价值判断」
@@ -766,6 +766,44 @@ function applyConflict(d, service, snapshot, config = {}) {
   return { applied: 1, committed: { action: "conflict", winner: d.winner, loser: d.loser, count_before: 2, count_after: 1 } };
 }
 
+/**
+ * 确定性信息量优先 supersede（issue #641 enforce 档的 T1 处置，供 sleep/dream
+ * 两条链路共用）。与冻结分支自动裁决档（#603 第 4 层，sleep.js 内联实现）同一
+ * 条契约，本函数是它的共享出口：
+ *   · 保留**信息量更大**的那条，不是更新的——#616 实测 55-57% 的新条反而更短
+ *     （蒸馏压缩过的一版常常更新），留新条等于把更完整的那条归档掉；
+ *   · 长度相同才退回 updated_at，再退回 id——三级兜底保证同一对每次判出同一个
+ *     赢家（重放不翻面）；
+ *   · trustEpistemicWeighting 显式关：自动处置的承诺必须是确定的，可信度换位
+ *     不让结果随 epistemic_status 数据漂移；
+ *   · 赢家正文一字不动——supersede 的可追溯注记落在被归档侧（#126 原设计）。
+ *     E13b 证明 conflict 动作的「败者前 100 字追加进赢家」是值级泄漏通道，
+ *     确定性处置一律走 supersede、不走 conflict。
+ * CAS 快照 + 事务 + 幂等（败者已归档 → applied 0）全部沿用 applyDecisions，
+ * 不另写第二份裁决路径。
+ *
+ * @param {{a: object, b: object}} p 候选对（完整记忆行：id/title/content/updated_at）
+ * @returns {{applied: boolean, winnerId: string, loserId: string, winner: object, loser: object}}
+ */
+export function supersedeInfoFirstPair(p, service, logger = null, config = {}) {
+  const an = p.a.content?.length ?? 0;
+  const bn = p.b.content?.length ?? 0;
+  const [winner, loser] = an !== bn
+    ? (an > bn ? [p.a, p.b] : [p.b, p.a])
+    : (p.a.updated_at ?? "") !== (p.b.updated_at ?? "")
+      ? ((p.a.updated_at ?? "") > (p.b.updated_at ?? "") ? [p.a, p.b] : [p.b, p.a])
+      : (p.a.id > p.b.id ? [p.a, p.b] : [p.b, p.a]);
+  const snapshot = new Map();
+  for (const m of [winner, loser]) {
+    snapshot.set(m.id, { updated_at: m.updated_at, content: m.content, title: m.title });
+  }
+  const { applied } = applyDecisions(
+    [{ action: "supersede", winner: winner.id, loser: loser.id }],
+    service, logger, snapshot, { ...config, trustEpistemicWeighting: false }
+  );
+  return { applied: applied > 0, winnerId: winner.id, loserId: loser.id, winner, loser };
+}
+
 /**
  * supersede（Issue #126，sleepActionSet="full"）：演进型重复——新版本取代旧版本。
  * 与 conflict 的关键差别：**注记追加到 loser（被取代方）而不是 winner**。conflict

package/src/dream/sleep.js

@@ -23,6 +23,8 @@ import { STR, langOf } from "../lang.js";
 import { randomUUID, createHash } from "node:crypto";
 import { validateDecisions, applyDecisions, ACTIONS } from "./decisions.js";
 import { findPotentialConflicts, cosineSimilarity } from "./clustering.js";
+import { triagePair, recordLedgerTriage } from "./triage.js";
+import { supersedeInfoFirstPair } from "./decisions.js";
 import { scopeKeyOf } from "../scope.js";
 import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, withMaxTokensFallback, maintainIndexAfterDream, fenceListBody, parseFailureMeta } from "../dream.js";
 import { computeHeat } from "../heat.js";
@@ -376,7 +378,18 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     if (!rec?.judged_at) return false;
     return (p.a.updated_at ?? "") <= rec.judged_at && (p.b.updated_at ?? "") <= rec.judged_at;
   };
-  const selectionPairs = config.conflictFreezeEnabled === true
+  // Issue #641（beta 第二阶段）：分诊账本的档位。#616 点名的父子绑定不继承——
+  // enforce 与 freeze 同开时 freeze 让位（本相位降级 shadow + warn）：freeze 照常
+  // 停车（shadow 语义 = 只记账零处置），绝不出现两套处置语义同时生效。宁可少处置，
+  // 不在打架的配置下跑。
+  let ledgerMode = config.conflictLedgerMode ?? "off";
+  if (ledgerMode === "enforce" && config.conflictFreezeEnabled === true) {
+    logger?.warn?.("dsh-mneme sleep: conflictLedgerMode=enforce coexists with conflictFreezeEnabled — degrading to shadow; disable one of them");
+    ledgerMode = "shadow";
+  }
+  // alreadyJudged 预筛只为省 LLM：freeze 与 enforce 都不走 LLM，筛不筛不影响成本，
+  // 不筛还能让 T2/T3/T4 的每轮观察持续刷新账本（tier 可能随内容更新而变）。
+  const selectionPairs = config.conflictFreezeEnabled === true || ledgerMode === "enforce"
     ? fresh
     : fresh.filter((p) => isCrossScopePair(p) || !alreadyJudged(p));
   const ledgerSkipped = fresh.length - selectionPairs.length;
@@ -390,6 +403,115 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     selected.push(p);
   }
 
+  // Issue #641（beta 第一阶段，shadow 档）：分诊账本。对 selected 全量做确定性
+  // 分诊（dup / cross-scope-dup / evolution / conflict，判据唯一实现见 triage.js）
+  // 并落 conflict_ledger。shadow = 只记账零处置：下面 freeze/LLM 路径一个字节都
+  // 不变——shadow 的存在意义就是让「分诊分布是否复现真实库 46/20/5/27」在真实
+  // 运行里可测，作为切 enforce 前的预注册证据。记账失败只 warn 计数，绝不反噬
+  // 相位（与 conflict_reviewed 同一条 best-effort 纪律）。
+  // 记账时点在 used 去重之后：被去重压掉的那半边对（同一条记忆配给了更高相似的
+  // 对手）本来就不是这一轮的候选，观察它们只会让分母虚高。
+  const ledgerTriage = ledgerMode !== "off"
+    ? await recordLedgerTriage(service, runId, selected, {
+        dupMinSimilarity: config.conflictLedgerDupMinSimilarity,
+        logger,
+        // 分块记账的取消检查：用户活动打断时停止记账，余下的对下一轮重见
+        signal
+      })
+    : null;
+
+  // Issue #641（beta 第二阶段，enforce 档）：确定性处置接线。T1（dup）走
+  // supersedeInfoFirstPair（与冻结分支自动档同一条契约，decisions.js 共享实现）；
+  // T1 走信息量优先 supersede、T3 走取代链（superseded_by 指向，不归档）、
+  // T2/T4 记账即处置——不停车、不送 LLM。人审队列与 LLM 裁决在本档下都不再
+  // 消费冲突候选，conflict_pending 恒空。每轮上限沿用
+  // sleepConflictMaxPairsPerRun：处置虽不走 LLM，归档/落链仍是写动作，写预算
+  // 与 freeze/auto 两档同口径。T4 的检索时消解（fuseRecall 矛盾感知 + 注入
+  // 标注）是后续 PR，本档先把人审摘出去。
+  if (ledgerMode === "enforce") {
+    const perRunCap = config.sleepConflictMaxPairsPerRun ?? 60;
+    const pool = perRunCap > 0 ? selected.slice(0, perRunCap) : selected;
+    let t1Resolved = 0;
+    let t1Failed = 0;
+    let t3Chained = 0;
+    const t1VectorFixups = [];
+    for (const p of pool) {
+      const verdict = triagePair(p.a, p.b, p.similarity, { dupMinSimilarity: config.conflictLedgerDupMinSimilarity });
+      if (verdict.tier === "evolution") {
+        // T3 取代链（beta 第三阶段）：旧行 superseded_by → 新行，检索降权，
+        // **不归档**——演进不是输赢，旧值仍是「曾经为真」的可追溯历史（与
+        // supersede 动作的归档语义不同）。新者胜对演进成立：间隔 ≥7 天的
+        // 同主题对，新记载才反映现状（服务器时钟，内容声称的时间不做键）。
+        const newer = (p.a.created_at ?? "") >= (p.b.created_at ?? "") ? p.a : p.b;
+        const older = newer === p.a ? p.b : p.a;
+        try {
+          if (service.supersedeChain(older.id, newer.id)) {
+            t3Chained += 1;
+            // 先落观察行再推进状态（#650 评审）：enforce 档下 recordLedgerTriage 只会
+            // 把这一对写成 open，UPDATE 于此才有行可命中；顺序反了就是静默落空。
+            service.saveConflictLedgerEntry({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, tier: verdict.tier, similarity: p.similarity, signals: verdict.signals });
+            service.setConflictLedgerStatus(p.a.id, p.b.id, "superseded");
+          }
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme sleep: ledger T3 chain failed for ${p.a.id}/${p.b.id}: ${String(error)}`);
+        }
+        continue;
+      }
+      if (verdict.tier !== "dup") continue;
+      let res = null;
+      try {
+        res = supersedeInfoFirstPair(p, service, logger, config);
+      } catch (error) {
+        logger?.warn?.(`dsh-mneme sleep: ledger T1 supersede failed for ${p.a.id}/${p.b.id}: ${String(error)}`);
+      }
+      if (res?.applied) {
+        t1Resolved += 1;
+        // winner/loser 用 helper 判定的真实方向（信息量优先可能翻转 p.a/p.b）
+        t1VectorFixups.push({ action: "supersede", winner: res.winnerId, loser: res.loserId });
+        try {
+          // 账本状态推进 + 机器台账照记（与自动档同款 outcome 口径）——自动处置
+          // 也要能事后回答「这一对什么时候、被谁判的」。先落观察行（#650 评审）：
+          // 这一对未必已在账本里，直接 UPDATE 会命中 0 行而静默失记。
+          service.saveConflictLedgerEntry({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, tier: verdict.tier, similarity: p.similarity, signals: verdict.signals });
+          service.setConflictLedgerStatus(p.a.id, p.b.id, "superseded");
+          service.saveConflictReviewed?.({ run_id: runId, memory_a: p.a.id, memory_b: p.b.id, outcome: "supersede", judged_at: new Date().toISOString() });
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme sleep: ledger bookkeeping after T1 supersede failed for ${p.a.id}/${p.b.id}: ${String(error)}`);
+        }
+      } else {
+        t1Failed += 1;
+      }
+    }
+    // 败者向量清理：T1 的 supersede 不在下面 LLM 通路的 maintainIndexAfterDream
+    // 清单里（enforce 已早退），必须在早退前自己清——已归档行留向量等于检索
+    // 层「看得见摸不着」。
+    if (t1VectorFixups.length > 0 && semantic?.embedder && semantic?.vectorIndex) {
+      try {
+        await maintainIndexAfterDream(t1VectorFixups, service, semantic);
+      } catch (error) {
+        logger?.warn?.(`dsh-mneme sleep: ledger T1 index maintenance failed: ${String(error)}`);
+      }
+    }
+    if (selected.length > pool.length) {
+      logger?.warn?.(`dsh-mneme sleep: conflict ledger enforce capped at ${pool.length}/${selected.length} pairs this run`);
+    }
+    return {
+      status: t1Failed > 0 ? "degraded" : t1Resolved > 0 || t3Chained > 0 ? "ok" : "noop",
+      clean: t1Failed === 0,
+      frozen: 0,
+      scopeCandidates: 0,
+      pairs: selected.length,
+      batches: 0,
+      ledgerSkipped,
+      // applied 是整轮回执的唯一写库口径（runSleep 的 totalApplied 只认这个键）。
+      // 缺了它，本档真实发生的 T1 归档与 T3 落链在 receipt / dream_runs.applied
+      // 里全是 0 ——「本相位说改了、整轮说没改」（#650 评审，#619 同族）。
+      applied: t1Resolved + t3Chained,
+      enforced: { t1Resolved, t1Failed, t3Chained },
+      ...(ledgerTriage ? { ledgerTriage } : {})
+    };
+  }
+
   // v0.8.1（issue #170 第 2 步）：跨 scope 相似对分流。同一内容落在两个归属下
   // （任一维标注键不等即算，NULL=未标注=全局也参与比较——「全局副本 + 专属副本
   // 并存」正是收窄/提升裁决的典型候选）不能自动裁决：归档败者可能销毁该内容在
@@ -583,7 +705,10 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
       batches: 0,
       ledgerSkipped,
       perRunSkipped,
-      pendingSkipped
+      pendingSkipped,
+      // #641 shadow：分诊分布随相位结果透出（dream phases 与审计行都能看到），
+      // 面板消费在 beta 第二批接。
+      ...(ledgerTriage ? { ledgerTriage } : {})
     };
   }
 
@@ -601,13 +726,14 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
       scopeCandidates: scopeParked,
       pairs: selected.length,
       batches: 0,
-      ledgerSkipped
+      ledgerSkipped,
+      ...(ledgerTriage ? { ledgerTriage } : {})
     };
   }
 
   // LLM adjudication（仅同 scope 对）。
   const route = resolveSleepRoute(ctx, config, logger);
-  if (!route) return { status: "skipped", reason: "no llm route", scopeCandidates: scopeParked, pairs: selected.length, batches: 0, ledgerSkipped };
+  if (!route) return { status: "skipped", reason: "no llm route", scopeCandidates: scopeParked, pairs: selected.length, batches: 0, ledgerSkipped, ...(ledgerTriage ? { ledgerTriage } : {}) };
   // 每轮总上限：分批解决的是单请求撞墙，不是"一个 449 对的池子该在一轮里跑完"。
   // 没进这一轮的对留在下一轮（它们既没被丢弃，也不在台账里）。
   const perRunCap = config.sleepConflictMaxPairsPerRun ?? 60;
@@ -907,7 +1033,10 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     conflicts,
     // Issue #126：#104 同向——被跳过的逐对明细要进审计行，否则事后无法判断
     // 是哪一对、因何被跳过（此前只进 logger.warn，splice 后就地消失）。
-    skipped
+    skipped,
+    // #641 shadow：分诊分布随相位结果透出（四个出口都要带——freeze/空池/无路由/
+    // LLM 全路径，缺一个出口 shadow 期就有部分轮次查不到分布）。
+    ...(ledgerTriage ? { ledgerTriage } : {})
   };
 }
 
@@ -1169,7 +1298,18 @@ async function phaseAffective(ctx, service, config, logger, runId, signal = null
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); })
   );
   const text = await withMaxTokensFallback(ctx, config.sleepMaxTokens ?? 2048, runAffective, () => streamFailure);
-  if (text === undefined) return { status: "failed", error: "llm failed" };
+  if (text === undefined) {
+    // #619 可见化 A：失败原因不能只写成 "llm failed"。conflict 相位
+    // （src/dream/sleep.js 的 adjudicateBatch 调用处）早就把 stream 层的原文写进
+    // warn 并挂在返回值的 `failure` 上，理由写在它旁边的注释里：只写 "llm failed"
+    // 的话，运维分不清是上下文超限、模型拒收还是用户活动打断。affective 相位漏了
+    // 这一步，实测 2026-11-10T16:09 那一轮审计行只有 {"status":"failed",
+    // "error":"llm failed"}，502 原文只能去 llm_audit_logs 里捞。
+    // 相位自身不重试 5xx（withMaxTokensFallback 只处理 max_tokens 被拒、
+    // withEffortFallback 只处理 effort 被拒），所以这里记的就是一次性失败的真因。
+    if (streamFailure) logger?.warn?.(`dsh-mneme sleep: affective stream aborted or errored (${streamFailure})`);
+    return { status: "failed", error: "llm failed", failure: streamFailure || undefined };
+  }
   const items = parseJsonArray(text) ?? [];
   if (items.length === 0) return { status: "skipped", reason: "no attributions found" };
   const relations = [];

package/src/dream/triage.js

@@ -0,0 +1,139 @@
+// 冲突分诊（issue #641 beta 第一阶段，shadow 档）：把 findPotentialConflicts 送进
+// 冲突相位的每一对，先过确定性分诊，落进 conflict_ledger 账本。
+//
+// 为什么分诊先行：真实库 788 对人审队列的全量分类（只读挖掘，口径见 #641 正文）
+// ——46% 近重复 + 20% 跨作用域重复 + 5% 时序演进，真矛盾只有 ~27%。前 71% 是该被
+// 机械处置（merge / 去重 / 取代链）的工作量，现行窄 prompt（conflict/keep 二选一）
+// 把它们全逼成了「输赢」，再由人来逐对裁决（≈30 条/天，且 92% 的对从未两侧同场）。
+// 分诊把「谁该机械处理、谁才是真矛盾」从 LLM 手里拿回来：E13b 实测 winner-take-all
+// 裁决 P(毒胜出)=86.8%，LLM 在这条链上只允许降级为分类器。
+//
+// 四档判据（全部确定性，本文件是唯一实现；enforce 阶段的处置接线另有 PR，本文件
+// 在 shadow 档只产分类与信号，不做任何记忆行处置）：
+//   cross-scope-dup  任一 scope 维键不同——同一内容落两个归属（#170 scopeReason 口径，
+//                    真实库占 20%）
+//   dup              同 scope + sim ≥ dupMin + created_at 差 < 24h——同日双录
+//                    （真实库 76% 的对两侧差 <1 天；#616 实测 55-57% 的新条反而更短，
+//                    新鲜度对这类对无区分力，后续处置按信息量裁决）
+//   evolution        同 scope + created_at 差 ≥ 7 天——时序演进展期（T3 superseded_by
+//                    取代链的候选池，enforce 阶段接线；entity_attrs 失效信号并入也在
+//                    那一步，见 #585）
+//   conflict         其余——真矛盾残余（真实库 ~27%；账本标记，消解推迟到检索时/
+//                    会话纠正/巩固重蒸馏三时刻）
+//
+// 「未标注 scope」不算跨作用域：scopeKeyOf 把 NULL 归一成 null，两条都未标注时
+// null !== null 为 false、判同档——#616 指出这个判据用于**自动归档**是洞（归属未知
+// ≠归属相同），但在 shadow 分诊里零处置、无害；signals.annotated=false 显式落账，
+// 让分析时能把「未标注」切出来，而不是让它静默混进同 scope 桶。
+import { scopeKeyOf } from "../scope.js";
+
+const DAY_MS = 86_400_000;
+
+// T1（dup）与 T3（evolution）的时间界。24h 来自真实库分布（76% 的对 <1 天，且
+// 1-7 天区间的「疑似同日双录」残留在 1-7 天档里很难与快速演进区分，宁保守归
+// conflict——分诊错档在 shadow 期只是统计噪音，enforce 后错档会错杀）；7 天是
+// 演进展期的保守下限，真实库 7 天以上的对仅 0.5%（4/788）。
+export const DUP_MAX_AGE_MS = DAY_MS;
+export const EVOLUTION_MIN_AGE_MS = 7 * DAY_MS;
+
+export const LEDGER_TIERS = ["dup", "cross-scope-dup", "evolution", "conflict"];
+
+/**
+ * Classify one candidate pair into a ledger tier. Pure function — no I/O, no
+ * config dependency beyond the tunables passed in, so the same verdict is
+ * reproducible from the recorded signals alone.
+ *
+ * @param {object} a candidate side A (needs agent_scope, workspace_scope, created_at)
+ * @param {object} b candidate side B
+ * @param {number} similarity detector cosine similarity (pair already passed the
+ *        detection threshold, so ≥ ~0.75-0.92 depending on strictness)
+ * @param {{dupMinSimilarity?: number, now?: number}} opts dupMin 默认 0.90（#616
+ *        重测：0.95 在现库覆盖为 0，真实库 reason 相似度回声集中在 0.85-0.93，
+ *        0.90 是把回声带接进 dup 档的落点）；now 仅测试注入
+ * @returns {{tier: string, signals: object}}
+ */
+export function triagePair(a, b, similarity, opts = {}) {
+  const dupMin = typeof opts.dupMinSimilarity === "number" ? opts.dupMinSimilarity : 0.9;
+  const now = typeof opts.now === "number" ? opts.now : Date.now();
+
+  const crossScope =
+    scopeKeyOf(a.agent_scope) !== scopeKeyOf(b.agent_scope) ||
+    scopeKeyOf(a.workspace_scope) !== scopeKeyOf(b.workspace_scope);
+  const annotated = (a.agent_scope != null || a.workspace_scope != null) &&
+    (b.agent_scope != null || b.workspace_scope != null);
+
+  // created_at 缺失不下结论：宁归 conflict（账本里最保守的一档），也不编造时间信号。
+  const createdA = Date.parse(a.created_at ?? "");
+  const createdB = Date.parse(b.created_at ?? "");
+  const gapKnown = Number.isFinite(createdA) && Number.isFinite(createdB);
+  const gapDays = gapKnown ? Math.abs(createdA - createdB) / DAY_MS : null;
+
+  let tier;
+  if (crossScope) {
+    tier = "cross-scope-dup";
+  } else if (gapKnown && typeof similarity === "number" && similarity >= dupMin && gapDays < DUP_MAX_AGE_MS / DAY_MS) {
+    tier = "dup";
+  } else if (gapKnown && gapDays * DAY_MS >= EVOLUTION_MIN_AGE_MS) {
+    tier = "evolution";
+  } else {
+    tier = "conflict";
+  }
+
+  return {
+    tier,
+    signals: {
+      crossScope,
+      annotated,
+      gapDays: gapDays == null ? null : Math.round(gapDays * 1000) / 1000,
+      dupMin,
+      similarity: typeof similarity === "number" ? similarity : null
+    }
+  };
+}
+
+/**
+ * Triage + record every selected pair into the conflict_ledger. Bookkeeping
+ * only: a store failure on one pair must never fail the phase (same
+ * best-effort discipline as saveConflictReviewed / saveDifferentiatedPair —
+ * 记账本身绝不能反过来把巩固打断）。
+ *
+ * 分块 + 让出（#643 review）：候选池大时同步写完全部对会连续占用事件循环、
+ * 延迟用户活动与取消信号的处理——每块之间 setImmediate 让出一次，并在每块
+ * 开始前检查 signal.aborted。取消后停止记账，余下的对下一轮自然重见；**不用
+ * 固定上限裁剪观察样本**（shadow 的分母必须完整，截断只来自取消，且在
+ * tally.truncatedAt 可见——静默截断会让分布失真，比没有数据更糟）。
+ *
+ * @returns Promise<tally> {dup, cross-scope-dup, evolution, conflict, recorded,
+ *          failed, truncatedAt} — truncatedAt 非 null 表示取消点（已处理的对数）
+ */
+export async function recordLedgerTriage(service, runId, pairs, opts = {}) {
+  const tally = { dup: 0, "cross-scope-dup": 0, evolution: 0, conflict: 0, recorded: 0, failed: 0, truncatedAt: null };
+  const CHUNK = 50;
+  for (let start = 0; start < pairs.length; start += CHUNK) {
+    // 块间让出事件循环（首块前不用——pairs 为空或单块时零额外宏任务）
+    if (start > 0) await new Promise((resolve) => setImmediate(resolve));
+    if (opts.signal?.aborted) {
+      tally.truncatedAt = start;
+      break;
+    }
+    for (const p of pairs.slice(start, start + CHUNK)) {
+      try {
+        const verdict = triagePair(p.a, p.b, p.similarity, opts);
+        service.saveConflictLedgerEntry({
+          run_id: runId,
+          memory_a: p.a.id,
+          memory_b: p.b.id,
+          tier: verdict.tier,
+          similarity: p.similarity,
+          signals: verdict.signals
+        });
+        tally[verdict.tier] += 1;
+        tally.recorded += 1;
+      } catch (error) {
+        tally.failed += 1;
+        opts.logger?.warn?.(`dsh-mneme sleep: failed to record ledger triage for ${p.a?.id}/${p.b?.id}: ${String(error)}`);
+      }
+    }
+  }
+  return tally;
+}

package/src/dream.js

@@ -1,5 +1,6 @@
-import { validateDecisions, applyDecisions } from "./dream/decisions.js";
+import { validateDecisions, applyDecisions, supersedeInfoFirstPair } from "./dream/decisions.js";
 import { clusterMemories, findPotentialConflicts, cosineSimilarity } from "./dream/clustering.js";
+import { triagePair } from "./dream/triage.js";
 import { clusterByTag, intersectEvidence } from "./dream/narratives.js";
 import { scopeKeyOf } from "./scope.js";
 // Issue #239（第 4 项）镜像到巩固：错峰时段解析与「最近的高峰结束时刻」从独立的
@@ -967,7 +968,7 @@ export async function maintainIndexAfterDream(decisions, service, semantic) {
 // 用户配得比这更大的 dreamMinIntervalMinutes 基数压小（见 effectiveMinIntervalMs）。
 const FAILURE_BACKOFF_CAP_MS = 30 * 60 * 1000;
 
-export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChars = 5000, delayMs = 2000, minIntervalMs = 0, failureBackoff = false, logger, semantic = null, lastRunAtSeed = 0, baselineSeed = null, peakHours = "", peakMaxDeferMinutes = 120, auditPeakSkip = null, now = () => Date.now(), setTimeoutFn = setTimeout, clearTimeoutFn = clearTimeout }) {
+export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChars = 5000, delayMs = 2000, minIntervalMs = 0, failureBackoff = false, logger, semantic = null, lastRunAtSeed = 0, baselineSeed = null, peakHours = "", peakMaxDeferMinutes = 120, auditPeakSkip = null, auditBaselineClamp = null, now = () => Date.now(), setTimeoutFn = setTimeout, clearTimeoutFn = clearTimeout }) {
   let pendingTimer = null;
   // Issue #239（第 4 项）镜像到巩固：高峰顺延定时器。与 pendingTimer 分开——两者
   // 语义不同（一个是「马上要跑」，一个是「等出高峰再跑」），合成一个变量会让
@@ -1006,6 +1007,27 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
 
   function shouldTrigger(service) {
     const { count, chars } = activeStoreSize(service);
+    // Issue #634（基线夹回）：基线只在成功轮前进（见下方 startRun 与 #89 注释），
+    // 而归档/删除/合并把活跃量压下去——活跃量一旦跌破基线，overBase 恒为假，
+    // 从此再也不会巩固，且全程静默（#634 实测停摆 13 天 / 22 小时零轮）。修法：
+    // 判定前把基线夹回当前活跃量（每轴取 min），阈值从新的低点重新起算，归掉的
+    // 量不必重新长回来。只动闭包内存、不落库：下一次成功轮本来就会把当时的规模
+    // 写成新基线（startRun 的 result.baseline / 现场计算），重启后种子若仍是旧峰值，
+    // 第一次判定在这里同样被夹回——所以不需要新的持久化形状。收缩的来源不止归档
+    // （删除、合并、暂停作用域、外来行占比变化同效果），且归档路径不触发
+    // notifyWrite（service.notifyWrite：状态开关不算内容写入），逐写路径维护基线
+    // 碰的面大、漏面也大——只在判定口一处收敛。夹回是罕见事件（每次「收缩→再触发」
+    // 周期至多一次：夹回后基线 == 活跃量，直到下一轮成功把基线抬高），审计照
+    // auditPeakSkip 的 fail-safe 口径走，记的是「这次收缩把阈值起点拉下来了」。
+    if (count < baseline.count || chars < baseline.chars) {
+      const previous = baseline;
+      baseline = { count: Math.min(baseline.count, count), chars: Math.min(baseline.chars, chars) };
+      try {
+        auditBaselineClamp?.({ previous, count: baseline.count, chars: baseline.chars });
+      } catch (error) {
+        logger?.warn?.(`dsh-mneme dream: baseline-clamp audit failed: ${String(error)}`);
+      }
+    }
     const overBase = count >= baseline.count + thresholdCount || chars >= baseline.chars + thresholdChars;
     const overAbs = count >= thresholdCount || chars >= thresholdChars;
     return { trigger: overAbs && overBase, count, chars };
@@ -1487,6 +1509,11 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // bounds the review queue; overflow is skipped with a warning.
     let frozenCount = 0;
     const frozenIds = [];
+    // Issue #641（enforce 档）：T1 supersede 的实质产出计数与向量清理清单。声明在
+    // freeze/enforce 两个分支外层——noChange 判定与 maintainIndexAfterDream 都在
+    // 它们之后、函数作用域里消费。
+    let ledgerApplied = 0;
+    let ledgerVectorFixups = [];
     // v0.8.1（issue #170 复核项 3）：跨 scope 的 conflict 决策两种模式都一律
     // 停车人工裁决、绝不自动归档——否则普通 dream 的 LLM 能归档别的 scope 的
     // 唯一副本，sleep 路径（scope-candidate-queue）的保护在这里缺位。同 scope
@@ -1499,9 +1526,90 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         || scopeKeyOf(a.workspace_scope) !== scopeKeyOf(b.workspace_scope)
       );
     };
-    const applyList = freezeEnabled
+    // Issue #641（beta 第二阶段，enforce 档）：dream 主链路的 conflict 决策改为
+    // 确定性处置。LLM 判出的 conflict 对先经 triagePair 再分诊：判为 dup 的走
+    // supersedeInfoFirstPair（与 sleep 自动档同一条契约）；其余（cross-scope-dup /
+    // evolution / conflict）只落 conflict_ledger 账本（tier + 信号），不停车、
+    // 不归档。#616 的父子绑定不继承：enforce 与 freeze 同开时 freeze 让位——
+    // 本段降级 shadow（conflict 照旧停车），绝不两套处置语义同时生效。
+    const ledgerEnforce = (config.conflictLedgerMode ?? "off") === "enforce" && !freezeEnabled;
+    if ((config.conflictLedgerMode ?? "off") === "enforce" && freezeEnabled) {
+      logger?.warn?.("dsh-mneme dream: conflictLedgerMode=enforce coexists with conflictFreezeEnabled — degrading to freeze; disable one of them");
+    }
+    if (ledgerEnforce) {
+      let t1Resolved = 0;
+      let t3Chained = 0;
+      let marked = 0;
+      for (const d of decisions.filter((x) => x.action === "conflict")) {
+        const a = snapshot.get(d.winner);
+        const b = snapshot.get(d.loser);
+        if (!a || !b) continue;
+        try {
+          // 判据必须与 sleep 侧同源（#650 评审）：sleep enforce 传的是
+          // config.conflictLedgerDupMinSimilarity，这里不传就会退回 triage.js 的
+          // 死默认 0.9 —— 用户把阈值调高/调低后，同一对在两条路径上可能分到不同
+          // tier（一侧判 dup 去归档，另一侧判 conflict 只记账）。
+          const verdict = triagePair(a, b, pairSimilarity.get(similarityKey(d.winner, d.loser)), {
+            dupMinSimilarity: config.conflictLedgerDupMinSimilarity
+          });
+          if (verdict.tier === "dup") {
+            const res = supersedeInfoFirstPair({ a, b }, service, logger, config);
+            if (res.applied) {
+              t1Resolved += 1;
+              ledgerApplied += 1;
+              // 败者向量清理走下面的 maintainIndexAfterDream：T1 的 supersede 是
+              // 本 helper 独立落地的，不在 applyList 里，必须显式补进维护清单
+              // （否则索引里留一行已归档记忆的向量，「清得掉才检索得到」失衡）。
+              ledgerVectorFixups.push({ action: "supersede", winner: res.winnerId, loser: res.loserId });
+              // 先落观察行再推进状态（#650 评审）：dream 路径不像 sleep 那样先跑
+              // recordLedgerTriage，账本里可能根本没有这一对；此处若直接 UPDATE，
+              // 命中 0 行、changes=0 被静默丢弃，于是「处置成功」与「账本有记录」
+              // 长期背离。upsert 一次拿到确定的行，状态推进才有落点。
+              service.saveConflictLedgerEntry({ run_id: runId, memory_a: a.id, memory_b: b.id, tier: verdict.tier, similarity: verdict.signals.similarity, signals: verdict.signals });
+              service.setConflictLedgerStatus(a.id, b.id, "superseded");
+              try {
+                service.saveConflictReviewed?.({ run_id: runId, memory_a: a.id, memory_b: b.id, outcome: "supersede", judged_at: new Date().toISOString() });
+              } catch (error) {
+                logger?.warn?.(`dsh-mneme dream: conflict_reviewed bookkeeping failed for ${a.id}/${b.id}: ${String(error)}`);
+              }
+            } else {
+              // CAS 没过（两侧在快照后被改过）：不冒险自动处置，落账本留观察。
+              service.saveConflictLedgerEntry({ run_id: runId, memory_a: a.id, memory_b: b.id, tier: verdict.tier, similarity: verdict.signals.similarity, signals: verdict.signals });
+            }
+          } else if (verdict.tier === "evolution") {
+            // T3 取代链（与 sleep enforce 同款）：旧行 superseded_by → 新行，
+            // 不归档、不进 applyList。快照行可能缺 created_at（老决策），缺了
+            // 就退回纯记账——宁可少处置，不编造时间方向。
+            const newer = (a.created_at ?? "") >= (b.created_at ?? "") ? a : b;
+            const older = newer === a ? b : a;
+            try {
+              if (service.supersedeChain(older.id, newer.id)) {
+                t3Chained += 1;
+                service.saveConflictLedgerEntry({ run_id: runId, memory_a: a.id, memory_b: b.id, tier: verdict.tier, similarity: verdict.signals.similarity, signals: verdict.signals });
+                service.setConflictLedgerStatus(a.id, b.id, "superseded");
+              } else {
+                service.saveConflictLedgerEntry({ run_id: runId, memory_a: a.id, memory_b: b.id, tier: verdict.tier, similarity: verdict.signals.similarity, signals: verdict.signals });
+              }
+            } catch (error) {
+              logger?.warn?.(`dsh-mneme dream: ledger T3 chain failed for ${a.id}/${b.id}: ${String(error)}`);
+            }
+          } else {
+            service.saveConflictLedgerEntry({ run_id: runId, memory_a: a.id, memory_b: b.id, tier: verdict.tier, similarity: verdict.signals.similarity, signals: verdict.signals });
+          }
+          marked += 1;
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme dream: ledger conflict mark failed for ${d.winner}/${d.loser}: ${String(error)}`);
+        }
+      }
+      if (marked > 0) {
+        logger?.info?.(`[dsh-mneme] dream: ledger enforce marked ${marked} conflict decision(s), ${t1Resolved} superseded, ${t3Chained} chained`);
+      }
+    }
+    const applyList = ledgerEnforce
       ? decisions.filter((d) => d.action !== "conflict")
-      : decisions.filter((d) => d.action !== "conflict" || !isCrossScopeDecision(d));
+      : freezeEnabled
+        ? decisions.filter((d) => d.action !== "conflict")
+        : decisions.filter((d) => d.action !== "conflict" || !isCrossScopeDecision(d));
     if (freezeEnabled) {
       const conflictsToFreeze = decisions.filter((d) => d.action === "conflict");
       if (conflictsToFreeze.length > 0) {
@@ -1531,9 +1639,11 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           logger?.warn?.(`dsh-mneme dream: conflict freeze lookup failed: ${String(error)}`);
         }
       }
-    } else {
+    } else if (!ledgerEnforce) {
       // 非 freeze：跨 scope conflict 停车（绝不进 applyDecisions）。带专属
       // reason + 模型给出的裁决理由，队列里读起来是「归属裁决」而非重复项。
+      // ledger enforce 档不进这里：conflict 决策已在上面落账本（tier 含
+      // cross-scope-dup），零停车零归档（#641）。
       const crossScope = decisions.filter((d) => d.action === "conflict" && isCrossScopeDecision(d));
       for (const d of crossScope) {
         try {
@@ -1606,12 +1716,14 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // happened and the scheduler refreshes the baseline on a false positive.
     // Frozen conflicts are substantive output (parked for review), so a run
     // that only froze conflicts is not a noop.
-    const noChange = frozenCount === 0 && applied === 0 && committed.every((c) => c.action === "keep");
+    // Issue #641：ledger enforce 的 T1 supersede 是独立于 applyList 落地的实质产出，
+    // 计入「本轮有没有干活」，否则有归档产出的轮会被当 noop 刷基线（#634 同族误报）。
+    const noChange = frozenCount === 0 && applied === 0 && ledgerApplied === 0 && committed.every((c) => c.action === "keep");
 
     // Keep the vector index consistent with the post-dream store state.
     if (semantic?.embedder && semantic?.vectorIndex) {
       try {
-        await maintainIndexAfterDream(applyList, service, semantic);
+        await maintainIndexAfterDream(ledgerVectorFixups.length ? [...applyList, ...ledgerVectorFixups] : applyList, service, semantic);
       } catch (error) {
         logger?.warn?.(`[dsh-mneme] dream index maintenance failed: ${String(error)}`);
       }
@@ -1746,7 +1858,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     return finish({
       ok: okResult,
       status,
-      applied,
+      // ledgerApplied 是 ledger enforce 档下 T1 supersede 的独立产出，不在 applyList
+      // 里（#650 评审）。只把它算进 noChange 会让 receipt 与 dream_runs.applied 仍
+      // 报 0：库真被改了，回执说没改——#619 同族假成功。计入 applied 才是唯一口径。
+      applied: applied + ledgerApplied,
       decisions: auditDecisions,
       outcome,
       conflicts,