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

package/lib/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/lib/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 项）镜像到巩固：错峰时段解析与「最近的高峰结束时刻」从独立的
@@ -164,6 +165,17 @@ export function buildOutcome(decisions) {
       byId[d.loser] = "superseded-archived";
     } else if (d.action === "differentiate") {
       for (const id of d.ids ?? []) byId[id] = "differentiated";
+    } else if (d.action === "create") {
+      // #619：create 铸出新行——记下「这一条是这一轮新生的」。它此前特意不派
+      // disposition，好让 receipt_chain 不为它产行（新行的改动无处可记，只有
+      // memory_mints 记出生）。这里补上的是审计面能读懂的那句话，不改 receipt_chain。
+      if (d.id) byId[d.id] = "created";
+    } else if (d.action === "create_merged") {
+      // #619 / Ephor 第七轮 ②：create 撞上同题活跃行时走原地刷新，没有新条目。
+      // 这条动作原本在 if 链里缺席，`outcome.byId` 就是空对象——一个只刷新不铸造
+      // 的轮，审计行看不出任何目标被处置过（#126 review 在 supersede 上踩过同一个
+      // 坑）。刷新有自己的名字，不冒充 created。
+      if (d.id) byId[d.id] = "created-refreshed";
     }
   }
   return { byId };
@@ -956,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 分开——两者
   // 语义不同（一个是「马上要跑」，一个是「等出高峰再跑」），合成一个变量会让
@@ -995,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 };
@@ -1172,6 +1205,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // manual review instead of auto-adjudicated. Read once up front so the
     // prompt hint and the apply-split agree on the same gate.
     const freezeEnabled = config.conflictFreezeEnabled === true;
+    // reflectionUpdateEnabled（默认 true，「关」= 旧记忆永不被自动改写）。同样先读
+    // 一次，prompt 后缀与校验器选项用同一个值，避免两处各读一次 cfg 后彼此不一致。
+    const updateEnabled = config.reflectionUpdateEnabled !== false;
     // Every exit (success or failure) funnels through `finish`, which writes
     // the audit row + receipt. A record failure is logged, never thrown —
     // auditing must not break the consolidation path. Failed runs still
@@ -1222,14 +1258,16 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           // input can be rebuilt offline from the audit row alone — the
           // digest + decisions + outcome triple makes silent errors locatable
           // even after the store has moved on.
-          input: [...snapshot.values()].map((m) => ({
-            id: m.id,
-            type: m.type,
-            title: m.title,
-            content: m.content,
-            importance: m.importance,
-            updated_at: m.updated_at
-          })),
+          // #557（dreamInputSummaryEnabled，opt-in 默认关）：瘦身只动这里的落库
+          // 副本——LLM 输入在下方由内存快照现算、snapshot_hash 在内存里对含
+          // content 的快照计算，两者都不经过这行，prompt 与 receipt 完整性不受
+          // 影响。organize 轮的重放载荷走 organize.js 自己的 saveDreamRun，
+          // 不经过这里，与 reclaim 的 run_type != 'organize' 同一条边界。
+          input: [...snapshot.values()].map((m) => (
+            config.dreamInputSummaryEnabled === true
+              ? { id: m.id, type: m.type, title: m.title, importance: m.importance, updated_at: m.updated_at }
+              : { id: m.id, type: m.type, title: m.title, content: m.content, importance: m.importance, updated_at: m.updated_at }
+          )),
           decisions: result.decisions,
           outcome: result.outcome,
           applied,
@@ -1264,6 +1302,12 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     }
 
     let listText;
+    // Issue #603 第 2 层：把预分组阶段算出的向量相似度留下来，供停车入队时落列。
+    // 这是**本进程内唯一**真实的相似度来源——LLM 裁决给出的只有理由文本，从文本
+    // 里回收数字是猜测。键与 conflict_pending 的对序归一化一致（sort 后的 id 对）。
+    // 拿不到（无向量、跨进程重放、模型自由裁决）就写 NULL，排序按「未知」处理。
+    const pairSimilarity = new Map();
+    const similarityKey = (x, y) => (x < y ? `${x}\u0000${y}` : `${y}\u0000${x}`);
     if (semantic?.embedder && semantic?.vectorIndex) {
       try {
         const vectors = await collectVectors(memories, semantic);
@@ -1272,6 +1316,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           const clusters = clusterMemories(memories, vectors, k);
           const conflicts = findPotentialConflicts(memories, vectors, 0.85);
           const conflictIds = new Set(conflicts.flatMap((c) => [c.a.id, c.b.id]));
+          for (const c of conflicts) pairSimilarity.set(similarityKey(c.a.id, c.b.id), c.similarity);
           const parts = [];
           clusters.forEach((cluster, ci) => {
             parts.push(STR.clusterHeader[language](ci + 1));
@@ -1301,6 +1346,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     const consolidationPrompt = freezeEnabled
       ? STR.prompts.consolidation[language] + STR.prompts.freezeSuffix[language]
       : STR.prompts.consolidation[language];
+    // 两个后缀可以叠加：冻结管冲突怎么处理，关闭改写管 update 能不能用，互不相干。
+    const promptWithUpdateGate = updateEnabled
+      ? consolidationPrompt
+      : consolidationPrompt + STR.prompts.noUpdateSuffix[language];
     let decisionText;
     // 加固（v0.8.1）：配置的 reasoningEffort 被 provider 拒收时回退重试一次
     // （不带该字段），避免 thinking 模型配置 low/medium 直接整单失败。解析放
@@ -1335,7 +1384,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       maxTokens: tokens,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
-        { role: "system", content: [{ type: "text", text: consolidationPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
+        { role: "system", content: [{ type: "text", text: promptWithUpdateGate }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
         { role: "user", content: [{ type: "text", text: fenceListBody(language, listText) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } }
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
@@ -1371,6 +1420,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     }
     const { ok, errors, skipped, resolvedShortIds, coverageShortfall } = validateDecisions(decisions, snapshot, {
       maxUpdatePerRun: config.reflectionUpdateMaxPerRun,
+      // reflectionUpdateEnabled=false 时校验器单条跳过所有 update（不是整单拒绝）。
+      allowUpdate: updateEnabled,
       // Issue #104 方向 2：archive 批量上限（全局闸门，超限整单拒绝）。
       maxArchivePerRun: config.dreamMaxArchivePerRun,
       // #135 成本审计派生：merge 批量上限（merge 是唯一回吐正文的动作，同款全局闸门）。
@@ -1458,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
@@ -1470,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) {
@@ -1488,8 +1625,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
             try {
               // 返回 undefined = 该对已被人工裁决且两侧内容未变（issue #170 复核
               // 项 4：内容变了才重新入队）——不算停车、不进 frozenIds。
-              const parked = service.saveConflictPending({ run_id: runId, memory_a: d.winner, memory_b: d.loser, reason: d.reason });
-              if (parked == null) continue;
+              const parked = service.saveConflictPending({ run_id: runId, memory_a: d.winner, memory_b: d.loser, reason: d.reason, similarity: pairSimilarity.get(similarityKey(d.winner, d.loser)) });
+              // 只有真的新插了一行才算停车：这一对已在队列里时返回的是旧行
+              // （fresh=false），旧代码把它也算进 frozen，虚报由此而来（#603）。
+              if (parked?.fresh !== true) continue;
               frozenCount++;
               frozenIds.push(d.winner, d.loser);
             } catch (error) {
@@ -1500,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 {
@@ -1510,9 +1651,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
             run_id: runId,
             memory_a: d.winner,
             memory_b: d.loser,
-            reason: STR.scopeConflictParkReason[language](d.reason)
+            reason: STR.scopeConflictParkReason[language](d.reason),
+            similarity: pairSimilarity.get(similarityKey(d.winner, d.loser))
           });
-          if (parked != null) {
+          if (parked?.fresh === true) {
             frozenCount++;
             frozenIds.push(d.winner, d.loser);
           }
@@ -1574,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)}`);
       }
@@ -1714,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,

package/lib/dsh-go/host.js

@@ -0,0 +1,162 @@
+// In-process call into the mneme HTTP API.
+//
+// The panel runs inside the engine process, exactly where mneme registered its
+// routes. Going through real HTTP would hit the dsh-go bridge guard (401 unless
+// the request carries the process launch token, which is never written to disk),
+// so we dispatch the registered route handler directly and never leave the
+// process. Everything stays on the local web server table: no sockets.
+//
+// Auth is not skipped: mneme's route registrar wraps every route with a policy
+// check, so a write route answers 401 unless the request carries the configured
+// apiToken. We forward it as the x-dsh-mneme-token header (one of the two the
+// registrar accepts) instead of weakening the policy for in-process callers.
+import { EventEmitter } from "node:events";
+
+const PREFIX = "/api/dsh-mneme";
+const DEFAULT_TIMEOUT = 5000;
+
+function makeRequest(url, method, body, apiToken) {
+  const req = new EventEmitter();
+  req.url = url;
+  req.method = method;
+  req.headers = {
+    host: "127.0.0.1",
+    "content-type": "application/json",
+    "content-length": String(body === undefined ? 0 : Buffer.byteLength(body)),
+  };
+  if (typeof apiToken === "string" && apiToken.length > 0) {
+    req.headers["x-dsh-mneme-token"] = apiToken;
+  }
+  req.socket = { remoteAddress: "127.0.0.1", encrypted: false };
+  req.resume = () => {};
+  req.pause = () => {};
+  req.setEncoding = () => {};
+  // The handler attaches its body listeners synchronously when invoked, so the
+  // body is only released afterwards by flushRequest(); emitting during
+  // construction would fire 'data'/'end' with no listener attached and the
+  // handler's readBody() would wait forever.
+  req.flush = () => {
+    queueMicrotask(() => {
+      if (body !== undefined) req.emit("data", Buffer.from(body));
+      req.emit("end");
+    });
+  };
+  return req;
+}
+
+function makeResponse() {
+  const chunks = [];
+  let settled;
+  const done = new Promise((resolve) => {
+    settled = resolve;
+  });
+  const headers = {};
+  const res = {
+    statusCode: 200,
+    headersSent: false,
+    done,
+    writeHead(status, extra) {
+      res.statusCode = status;
+      res.headersSent = true;
+      if (extra !== undefined && extra !== null) {
+        for (const key of Object.keys(extra)) headers[key.toLowerCase()] = extra[key];
+      }
+      return res;
+    },
+    setHeader(key, value) {
+      headers[key.toLowerCase()] = value;
+      return res;
+    },
+    getHeader(key) {
+      return headers[key.toLowerCase()];
+    },
+    removeHeader(key) {
+      delete headers[key.toLowerCase()];
+    },
+    write(chunk) {
+      if (chunk !== undefined && chunk !== null && typeof chunk !== "function") {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      }
+      return true;
+    },
+    end(chunk) {
+      if (chunk !== undefined && chunk !== null && typeof chunk !== "function") {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      }
+      settled();
+      return res;
+    },
+    flushHeaders() {},
+  };
+  res.text = () => Buffer.concat(chunks).toString("utf8");
+  res.bytes = () => Buffer.concat(chunks);
+  return res;
+}
+
+// 超时定时器不能被 unref()：handler 永不响应时，它是唯一还挂在事件循环上的
+// 东西；unref 之后 node 22 的 test runner 会判定循环已空，把用例记成 cancelled
+// （CI 的 node22 两腿就是这么红的）。改成显式 cancel —— 成功路径也不白挂 5 秒。
+function timeout(ms) {
+  let timer;
+  const promise = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error("mneme 接口超时")), ms);
+  });
+  return { promise, cancel: () => clearTimeout(timer) };
+}
+
+/**
+ * Resolve the mneme route handler and run it in-process.
+ * @param {object} ctx - the plugin context (must expose get()).
+ * @param {{apiToken?: string}} [options] - the host's configured API token; the
+ *   route registrar requires it for every token / token-write route.
+ */
+export function createHostCall(ctx, options = {}) {
+  const apiToken = options.apiToken;
+  return async function callMneme(path, options = {}) {
+    const method = (options.method ?? "GET").toUpperCase();
+    const body = options.body === undefined ? undefined : JSON.stringify(options.body);
+    const url = new URL(PREFIX + path, "http://127.0.0.1");
+    const webServer = ctx.get?.("webServer") ?? ctx.reflect?.get?.("webServer");
+    if (webServer === undefined || typeof webServer.match !== "function") {
+      throw new Error("宿主 webServer 不可用");
+    }
+    const route = webServer.match(url.pathname);
+    if (route === undefined || route === null) throw new Error(`mneme 未注册 ${url.pathname}`);
+    const req = makeRequest(url.pathname + url.search, method, body, apiToken);
+    const res = makeResponse();
+    let run;
+    try {
+      run = Promise.resolve(route.handler(req, res));
+    } finally {
+      req.flush();
+    }
+    // Wait for both: most routes return a promise and end the response inside it,
+    // but a few (version-check) return undefined and end later from a callback.
+    // Racing the three would return the moment the synchronous call returns and
+    // hand an empty body to the caller, which then looks like a failed fetch.
+    const guard = timeout(options.timeoutMs ?? DEFAULT_TIMEOUT);
+    try {
+      await Promise.race([
+        Promise.all([run, res.done]).then(() => undefined),
+        guard.promise,
+      ]);
+    } finally {
+      guard.cancel();
+    }
+    const text = res.text();
+    if (res.statusCode >= 400) {
+      const detail = text.length > 200 ? `${text.slice(0, 200)}…` : text;
+      const error = new Error(`mneme ${method} ${path} → ${res.statusCode} ${detail}`);
+      error.status = res.statusCode;
+      error.body = text;
+      throw error;
+    }
+    if (options.raw === true) return text;
+    if (text === "") return {};
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { text };
+    }
+  };
+}