@modusensus/dsh-mneme 0.9.5 → 0.10.0

package/src/store.js

@@ -76,7 +76,13 @@ CREATE TABLE IF NOT EXISTS dream_runs (
   -- 写入就绕过阈值开跑整轮（#291 只持久化了 lastRunAt 那半边）。成功轮才落这两列，
   -- 失败/降级不推进基线的既有语义不变；两列同时有值或同时为 NULL。
   store_count    INTEGER,
-  store_chars    INTEGER
+  store_chars    INTEGER,
+  -- #534：失败轮（拿得到模型输出，但解析或校验没过）的原始输出截断副本。
+  -- 此前失败轮只留一行 logger.warn，进程一退现场就没了——#534 实测 19 轮里
+  -- 17 轮整轮无效，事后一条模型原文都查不到。做成独立列而不是塞进 decisions：
+  -- 那一列的语义是「可重放的决策数组」，失败轮已被 _validationFailed 哨兵占着，
+  -- 塞原文进去会污染按决策数组消费的下游（重放、面板）。
+  raw_output     TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_dream_runs_created ON dream_runs(created_at);
 
@@ -180,6 +186,51 @@ CREATE TABLE IF NOT EXISTS conflict_pending (
 );
 CREATE INDEX IF NOT EXISTS idx_conflict_pending_unresolved ON conflict_pending(resolved_at);
 
+-- differentiated_pairs: 「这一对已经判过 differentiate」的裁决账本（issue #533）。
+-- 起因：#126 的 differentiate 把同一段差异注记同时追加到两侧正文，指望「注记进
+-- embedding 后下一轮就不再判重复」；离线复现证伪了这个假设——两侧共享同一段
+-- 后缀时向量同向靠拢（0.876→0.960/5 轮，注记截到 0 字也一样），而字面 includes
+-- 幂等在措辞漂移下失效，于是同一对每轮都被追加一段，单条堆到 19 段。
+-- 这里记的是「(a,b) 已裁决」这件事本身，正文一个字节都不动；hash_a/hash_b 是
+-- 裁决当时两侧正文的 content_hash，任一侧后来被改写就让该对重新进入候选（宁可
+-- 再判一次，不静音真的演化）。与 conflict_pending 同款的 bookkeeping 表：只做
+-- 裁决记账，不触发 write hooks。
+CREATE TABLE IF NOT EXISTS differentiated_pairs (
+  id           TEXT PRIMARY KEY,
+  memory_a     TEXT NOT NULL,
+  memory_b     TEXT NOT NULL,
+  hash_a       TEXT,
+  hash_b       TEXT,
+  -- 模型给出的差异点（JSON 数组）。不再写进正文，留在这里只为了让「当初为什么
+  -- 判它们互补」事后查得到——裁决本身必须可审计，否则和静音丢弃没有区别。
+  distinctions TEXT,
+  run_id       TEXT,
+  created_at   TEXT NOT NULL
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_differentiated_pairs_pair ON differentiated_pairs(memory_a, memory_b);
+
+-- conflict_reviewed: 机器侧裁决台账（issue #529）。冲突相位真正送给 LLM 的每一对
+-- 都在这里留一行，连同最后拿到的结果——判 keep 的对因此不会在下一轮被原样再送。
+--
+-- 为什么不复用 conflict_pending：那张表是**人工**待审队列，countConflictPending()
+-- 与 listConflictPending() 的口径直接喂面板的待确认徽标。机器记账混进去，用户打开
+-- 面板看到的就是几百条自己从没要求审的条目，人工裁决会被淹掉。两者的生命周期也相反：
+-- pending 是「等人来」，reviewed 是「人不用来了」。
+--
+-- 主键就是归一化后的对（sort 过，与 saveConflictPending 同一口径），同一对只留最新
+-- 一次判决，INSERT OR REPLACE 天然幂等。「是否还需重判」不靠本表自身判定，而是比
+-- 两侧 updated_at 与 judged_at（宽松代理，与 conflict_pending 复核项 4 同一条约定：
+-- 任何字段更新都算「值得再看一眼」，宁可多看一眼，不静音真冲突）。
+CREATE TABLE IF NOT EXISTS conflict_reviewed (
+  memory_a  TEXT NOT NULL,
+  memory_b  TEXT NOT NULL,
+  judged_at TEXT NOT NULL,
+  outcome   TEXT,
+  run_id    TEXT,
+  PRIMARY KEY (memory_a, memory_b)
+);
+CREATE INDEX IF NOT EXISTS idx_conflict_reviewed_judged ON conflict_reviewed(judged_at);
+
 -- scope_changes: v0.8.1 底座（issue #170）scope 归属的人工修正审计。显式声明
 -- （memory_save/memory_update 的 scope 参数、面板编辑）每次改变某条记忆的
 -- agent/workspace 归属都落一行：改动前后值 + 来源 + actor（tool=模型侧 /
@@ -300,6 +351,77 @@ CREATE INDEX IF NOT EXISTS idx_memory_provenance_session ON memory_provenance(se
 CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_provenance_link
   ON memory_provenance(memory_id, session_id, seq_start, seq_end);
 
+-- #512 蒸馏运行（run）：一次 autoSummarize 调用就是一轮。此前这条链路只在
+-- llm_audit_logs 里留一条计费痕迹，记忆侧的链接却只记到「会话 + seq 区间」——
+-- 「这条记忆是哪一次蒸馏带进来的」答不上，同一个区间重跑两次更分不出前后。
+-- 与 llm_audit_logs 的关系是**归因主体与它的开销读数**：run 是被归因的那一轮，
+-- audit 行是那一轮的开销；两边靠 distill_runs.audit_id 直接连，不靠时间戳猜。
+-- 为什么不复用 llm_audit_logs 的行 id 当 run id：audit 表按 llmAudit.retentionDays
+-- 到期裁剪（index.js 启动即调 deleteOldLlmAudits），归因会悬空；而 memory_provenance
+-- 与蒸馏窗口刻意活得更久（见 clearDistillRecords 注释）。归因不能挂在会被删掉的表上。
+-- 为什么不复用 dream_runs：那张表的每一列（snapshot_hash / input_count / decisions /
+-- outcome / receipt）都是巩固的语义，硬塞一个 run_type='autoSummarize' 会让
+-- 「dream_runs 的每一行都能回放一次巩固」这条契约失效。两张表各自的形状才是真的。
+-- audit_id 可空：llmAudit 关掉时那一轮没有 audit 行，run 仍然成立（归因不该依赖计费开关）。
+CREATE TABLE IF NOT EXISTS distill_runs (
+  id             TEXT PRIMARY KEY,
+  created_at     TEXT NOT NULL,
+  status         TEXT NOT NULL,   -- ok | degraded | noop | failed | aborted
+  error          TEXT,
+  -- 只放**有窗口**的蒸馏（autoSummarize，以及将来手动的 manual）。dream / sleep 的
+  -- 轮次不进这张表：它们是 dream_runs 的行，把同一轮复制成两行会让「哪张表是事实源」
+  -- 这个问题永远没有答案；那些记忆的归因走 memory_mints（见下）。
+  run_type       TEXT NOT NULL,   -- autoSummarize | manual
+  trigger_source TEXT NOT NULL,   -- autoSummarize | manual
+  session_id     TEXT,
+  seq_start      INTEGER,
+  seq_end        INTEGER,
+  memory_count   INTEGER NOT NULL DEFAULT 0,
+  provider       TEXT,
+  model          TEXT,
+  audit_id       INTEGER          -- llm_audit_logs.id（NULL = 那一轮没有 audit 行）
+);
+CREATE INDEX IF NOT EXISTS idx_distill_runs_created ON distill_runs(created_at);
+
+-- #512 记忆级「出生自哪一轮」。为什么它不是 memory_provenance 的一列：那张表的
+-- 粒度是 (记忆, 会话, seq 区间)，能表达的只有**窗口派生**的归因；而 dream / sleep
+-- 铸造的记忆根本没有窗口（session 与 seq 都不存在），硬塞一个合成区间就是
+-- 「看起来能追、实际是编的」。所以归因分两层，各自只记它真知道的事：
+--   · memory_provenance（+ distill_run_id）= 窗口级，「这段原文是哪一轮蒸出来的」；
+--   · 本表 = 行级，「这条记忆出生自哪一轮」，覆盖没有窗口的铸造路径。
+-- 只填 **create** 一种动作：merge/conflict/update/supersede 对既有行的改动，receipt_chain
+-- 已经按 (run_id, record_id) 记过了——再造一份就是第二套账。create 是那边唯一的洞
+-- （buildOutcome 刻意不给 create 派 disposition，receipt_chain 也就不产行）。
+-- run_type / trigger_source 就地冗余：run_id 在 dream_runs 与 distill_runs 两张表里
+-- 各有自己的主键域，读侧不该为了显示一个类型去 union 两张审计表。
+-- ON DELETE CASCADE：记忆行没了，归因没有指代对象；remove() 仍显式清（与
+-- memory_provenance 同一口径，不把清理挂在驱动默认上）。
+CREATE TABLE IF NOT EXISTS memory_mints (
+  memory_id      TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+  run_id         TEXT NOT NULL,
+  run_type       TEXT NOT NULL,   -- dream | sleep
+  trigger_source TEXT NOT NULL,   -- autoDream | sleep
+  created_at     TEXT NOT NULL,
+  PRIMARY KEY (memory_id, run_id)
+);
+CREATE INDEX IF NOT EXISTS idx_memory_mints_run ON memory_mints(run_id);
+
+-- #493 补充 §②：连续解析失败的**跨进程**计数（失败护栏 summarizeParseFailureMaxRetries
+-- 的判据）。原先只活在 summarize.js 的进程内 Map 里，于是重启即清零——而这条护栏要
+-- 防的恰恰是「确定性失败反复重试」，重启一次就绕过去了。
+-- 独立成表、不并进 distill_cursors 的三条理由：
+-- 1) 写 streak 不必先有游标行（窗口可能还没成功消费过任何一个 seq）；
+-- 2) 成功即归零是 DELETE，而游标那句 UPSERT 是 last_seq = MAX(...)（单调），
+--    两种语义塞进同一句会把「归零」写成「保留最大值」，护栏永远不解除；
+-- 3) 失效判据要读时间戳，就地一行更省事。
+-- 失效由读侧判（streakStaleAfterMs）：超过窗口没更新就当作 0，**不在写侧定时清**——
+-- 停了几周的会话再开跑时，若拿旧 streak 直接触发熔断，护栏本身就成了新的误伤路径。
+CREATE TABLE IF NOT EXISTS distill_parse_failures (
+  session_id TEXT PRIMARY KEY,
+  streak     INTEGER NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
 -- entity gene (v0.3.0): named entities mentioned across memories, with
 -- time-boxed attributes (valid_from → valid_until) and typed relations.
 -- Attributes follow the snapshot style: saveAttr invalidates the previous
@@ -410,6 +532,10 @@ export const TYPES = new Set(["preference", "project", "decision", "history", "s
 // 截断上限（continuity.js）是两件事。
 const MAX_CONTINUITY_PENDING = 200;
 
+// dream_runs.run_type 的取值域（schema 注释同款）。既是白名单也是下推条件的护栏：
+// listDreamRuns 的 excludeRunType 会拼进 SQL 的 != 比较，非白名单值一律忽略。
+const DREAM_RUN_TYPES = ["auto", "sleep", "organize"];
+
 // Epistemic status: what kind of evidence a memory rests on. Defaults to
 // 'subjective' so legacy rows (and rows without any signal) stay compatible.
 const EPISTEMIC_STATUSES = new Set(["observation", "subjective", "inferred"]);
@@ -590,7 +716,29 @@ function toDreamRun(row) {
     skipped: row.skipped ? JSON.parse(row.skipped) : undefined,
     // Issue #89（基线半边）：成功轮落下的阈值基线（NULL = 该轮没有推进基线）。
     store_count: row.store_count ?? undefined,
-    store_chars: row.store_chars ?? undefined
+    store_chars: row.store_chars ?? undefined,
+    // #534：失败轮的模型原始输出截断副本（NULL = 该轮没留下，或该轮是历史行）。
+    raw_output: row.raw_output ? JSON.parse(row.raw_output) : undefined
+  };
+}
+
+function toDistillRun(row) {
+  if (!row) return undefined;
+  return {
+    id: row.id,
+    created_at: row.created_at,
+    status: row.status,
+    error: row.error ?? undefined,
+    run_type: row.run_type,
+    trigger_source: row.trigger_source,
+    session_id: row.session_id ?? undefined,
+    seq_start: row.seq_start ?? undefined,
+    seq_end: row.seq_end ?? undefined,
+    memory_count: row.memory_count ?? 0,
+    provider: row.provider ?? undefined,
+    model: row.model ?? undefined,
+    // NULL = 那一轮没有 audit 行（llmAudit 关着，或还没写回）。
+    audit_id: row.audit_id ?? undefined
   };
 }
 
@@ -628,6 +776,20 @@ function toConflictPending(row) {
   };
 }
 
+function toDifferentiatedPair(row) {
+  if (!row) return undefined;
+  return {
+    id: row.id,
+    memory_a: row.memory_a,
+    memory_b: row.memory_b,
+    hash_a: row.hash_a ?? undefined,
+    hash_b: row.hash_b ?? undefined,
+    distinctions: row.distinctions ? JSON.parse(row.distinctions) : undefined,
+    run_id: row.run_id ?? undefined,
+    created_at: row.created_at
+  };
+}
+
 function toScopeChange(row) {
   if (!row) return undefined;
   return {
@@ -962,6 +1124,9 @@ export function createStore(path) {
   // 成功轮之前播种端拿不到基线，行为与升级前一致；跑过一轮之后闸门即跨重启生效。
   addColumn("dream_runs", "store_count", "ALTER TABLE dream_runs ADD COLUMN store_count INTEGER");
   addColumn("dream_runs", "store_chars", "ALTER TABLE dream_runs ADD COLUMN store_chars INTEGER");
+  // #534：失败轮的模型原始输出。存量行两列皆 NULL——历史失败轮反推不出原文
+  // （那正是这条要补的口子），升级后新失败轮才有值。
+  addColumn("dream_runs", "raw_output", "ALTER TABLE dream_runs ADD COLUMN raw_output TEXT");
 
   // Legacy mirror_state without v0.3.6 generation columns → add each missing
   // column idempotently (old DBs open cleanly, no data loss).
@@ -976,6 +1141,14 @@ export function createStore(path) {
   addColumn("llm_audit_logs", "session_key", "ALTER TABLE llm_audit_logs ADD COLUMN session_key TEXT");
   db.exec("CREATE INDEX IF NOT EXISTS idx_llm_audit_session ON llm_audit_logs(session_key);");
 
+  // #512：把每条溯源链接指回产出它的那一轮蒸馏（distill_runs.id）。
+  // 存量链接一律留 NULL——那是**本次改造之前的历史**，按 (session, 区间, created_at)
+  // 反推一个合成 id 会得到「读数正常、实际是猜的」归因，比不填更坏（与 #534
+  // raw_output「历史失败轮反推不出原文」同一口径：补不出的就承认补不出）。
+  // 索引建在加列之后：老库打开时列还不存在（SCHEMA 的 CREATE TABLE 只对新建库生效）。
+  addColumn("memory_provenance", "distill_run_id", "ALTER TABLE memory_provenance ADD COLUMN distill_run_id TEXT");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_memory_provenance_run ON memory_provenance(distill_run_id);");
+
   // Audit peer F: a legacy DB may hold a non-integer generation/applied_generation
   // (pre-v0.3.9 the JS gate truncated with Math.trunc and SQLite's CHECK only
   // enforced >= 0). Such a value is ambiguous — it cannot map to a real applied
@@ -1080,6 +1253,59 @@ export function createStore(path) {
     return getDistillCursor(sessionId);
   }
 
+  /**
+   * 读指定会话的连续解析失败计数。
+   *
+   * `staleAfterMs` 是**读侧**失效窗口（#493 补充 §②）：超过这么久没更新就把计数
+   * 当作 0，而不是拿几周前攒下的值去触发熔断。劣化方向选得很明确——宁可多试一次
+   * （多花一次 LLM 调用），也不要因为「会话停了很久」而误判一个其实健康的窗口。
+   * 传 0 或负数表示不判失效（照原样返回），测试用它构造边界。
+   * @returns {number} 0 表示没有在途失败（含「已失效」与「从未记录」两种）
+   */
+  function getDistillParseFailureStreak(sessionId, { staleAfterMs = 0, nowMs = Date.now() } = {}) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) return 0;
+    const row = db.prepare(
+      "SELECT streak, updated_at FROM distill_parse_failures WHERE session_id = ?"
+    ).get(sessionId);
+    if (!row) return 0;
+    if (staleAfterMs > 0) {
+      const stamp = Date.parse(row.updated_at);
+      // 时间戳读不出来时按「已失效」处理：一个解析不了的 updated_at 不能当作「刚刚
+      // 失败过」，否则坏数据会永久钉住一道护栏（fail-open，与整条护栏的默认关一致）。
+      if (!Number.isFinite(stamp) || nowMs - stamp > staleAfterMs) return 0;
+    }
+    return Number(row.streak) || 0;
+  }
+
+  /**
+   * 记一次解析失败（+1 并刷新时间戳）。返回写后的计数。
+   *
+   * 先按 staleAfterMs 读一遍再**覆写**，而不是在 SQL 里做 streak + 1——失效判断只
+   * 许有一份（就是上面那个读函数）。写成 + 1 的话，一条几周前的旧行会把「新的第一
+   * 次失败」直接加成 2，等于失效窗口在这条路径上完全不生效（本块实现的首版就是
+   * 这么写的，被回归用例抓出来）。
+   */
+  function bumpDistillParseFailureStreak(sessionId, { staleAfterMs = 0, nowMs = Date.now() } = {}) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      throw new TypeError("bumpDistillParseFailureStreak: sessionId must be a non-empty string");
+    }
+    const next = getDistillParseFailureStreak(sessionId, { staleAfterMs, nowMs }) + 1;
+    db.prepare(`
+      INSERT INTO distill_parse_failures (session_id, streak, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(session_id) DO UPDATE SET
+        streak = excluded.streak,
+        updated_at = excluded.updated_at
+    `).run(sessionId, next, nowIso());
+    return next;
+  }
+
+  /** 清零（不是写 0）：没有在途失败时不该留一行，否则「有没有失败过」变得不可区分。 */
+  function clearDistillParseFailureStreak(sessionId) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) return 0;
+    return db.prepare("DELETE FROM distill_parse_failures WHERE session_id = ?").run(sessionId).changes;
+  }
+
   function count(type, { minImportance = null, source = null, includeForgotten = false, includeArchived = false, onlyArchived = false, depositedOnly = false, updatedFrom = null, updatedTo = null, occurredFrom = null, occurredTo = null, visibility = null } = {}) {
     const clauses = [];
     const params = [];
@@ -1406,6 +1632,8 @@ export function createStore(path) {
       // 只有这一条挡得住。记录本身（distill_records）不删——删掉一条派生记忆
       // 不该让整个窗口的原文凭证消失。
       db.prepare("DELETE FROM memory_provenance WHERE memory_id = ?").run(id);
+      // #512：铸造记录同理——它也只是指着记忆行的索引，行没了索引就没有指代对象。
+      db.prepare("DELETE FROM memory_mints WHERE memory_id = ?").run(id);
       db.prepare("DELETE FROM memories WHERE id = ?").run(id);
       // Mirror sync must reflect the deletion; bump desired generation so a
       // crash between the delete and syncMirror leaves a recoverable debt.
@@ -1424,7 +1652,8 @@ export function createStore(path) {
    * 这个包」与「收起一个从来没导入过的包」都该是这个答案；早退也不 bump generation：
    * 什么都没删就别记一笔镜像债（remove() 每次必 bump，那是它的既有行为，不在这里扩大）。
    *
-   * side table 清理口径 = remove() 的口径（#399）：显式同事务清 memory_provenance。
+   * side table 清理口径 = remove() 的口径（#399 / #512）：显式同事务清 memory_provenance
+   * 与 memory_mints。
    * 这条是双保险，不是「FK 没开所以必须手写」：memory_provenance 挂着 ON DELETE CASCADE，
    * 而 node:sqlite 默认就把 foreign_keys 开成 1（实测 PRAGMA foreign_keys = 1），今天删行
    * 确实另有级联兜底；显式清理的存在是为了不依赖这份没人钉过的驱动默认，同时跟 remove()
@@ -1466,6 +1695,7 @@ export function createStore(path) {
         const chunk = ids.slice(start, start + DELETE_ID_CHUNK);
         const marks = chunk.map(() => "?").join(", ");
         db.prepare(`DELETE FROM memory_provenance WHERE memory_id IN (${marks})`).run(...chunk);
+        db.prepare(`DELETE FROM memory_mints WHERE memory_id IN (${marks})`).run(...chunk);
         deleted += db.prepare(`DELETE FROM memories WHERE id IN (${marks})`).run(...chunk).changes;
       }
       incrementGeneration();
@@ -2130,18 +2360,22 @@ export function createStore(path) {
       Number.isInteger(run.store_chars) && run.store_chars >= 0;
     const storeCount = baselineKnown ? run.store_count : null;
     const storeChars = baselineKnown ? run.store_chars : null;
+    // #534：失败轮的模型原始输出（对象：kind/raw_len/raw_head/raw_tail?/parsed?）。
+    // 未提供落 NULL 而不是 "{}"——读侧靠「有没有值」区分「这轮没留」与「留了个空」。
+    const rawOutput = run.raw_output !== undefined ? JSON.stringify(run.raw_output) : null;
     db.prepare(
       `INSERT INTO dream_runs (id, created_at, status, error, provider, model, snapshot_hash,
         input_count, input, decisions, outcome, applied, summary_stored, receipt, policy_epoch, run_type, skipped,
-        store_count, store_chars)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        store_count, store_chars, raw_output)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(id) DO UPDATE SET
          created_at=excluded.created_at, status=excluded.status, error=excluded.error,
          provider=excluded.provider, model=excluded.model, snapshot_hash=excluded.snapshot_hash,
          input_count=excluded.input_count, input=excluded.input, decisions=excluded.decisions,
          outcome=excluded.outcome, applied=excluded.applied, summary_stored=excluded.summary_stored,
          receipt=excluded.receipt, policy_epoch=excluded.policy_epoch, run_type=excluded.run_type,
-         skipped=excluded.skipped, store_count=excluded.store_count, store_chars=excluded.store_chars`
+         skipped=excluded.skipped, store_count=excluded.store_count, store_chars=excluded.store_chars,
+         raw_output=excluded.raw_output`
     ).run(
       id,
       run.created_at ?? now,
@@ -2161,7 +2395,8 @@ export function createStore(path) {
       runType,
       skipped,
       storeCount,
-      storeChars
+      storeChars,
+      rawOutput
     );
     return getDreamRun(id);
   }
@@ -2171,11 +2406,16 @@ export function createStore(path) {
     return toDreamRun(row);
   }
 
-  function listDreamRuns({ limit = 50, offset = 0 } = {}) {
+  // #495：excludeRunType 是可选下推条件，默认不过滤——审计面（面板的最近运行、
+  // 回放脚本、各测试的 `listDreamRuns()` 无参调用）本来就该看全量，过滤只在
+  // 「最近一次真·巩固」这种需要排除 agent 主动整理的场合由调用方显式指定。
+  // 值走白名单：这个参数会拼进 SQL 的 != 条件，不接受任意字符串。
+  function listDreamRuns({ limit = 50, offset = 0, excludeRunType = null } = {}) {
     const { limit: lim, offset: off } = sanitizePage(limit, offset, 50);
+    const excluded = DREAM_RUN_TYPES.includes(excludeRunType) ? excludeRunType : null;
     const rows = db.prepare(
-      "SELECT * FROM dream_runs ORDER BY created_at DESC, id LIMIT ? OFFSET ?"
-    ).all(lim, off);
+      "SELECT * FROM dream_runs WHERE (? IS NULL OR run_type != ?) ORDER BY created_at DESC, id LIMIT ? OFFSET ?"
+    ).all(excluded, excluded, lim, off);
     return rows.map(toDreamRun);
   }
 
@@ -2455,7 +2695,7 @@ export function createStore(path) {
     const now = nowIso();
     const inTokens = Number.isFinite(entry.input_tokens) ? entry.input_tokens : 0;
     const outTokens = Number.isFinite(entry.output_tokens) ? entry.output_tokens : 0;
-    db.prepare(
+    const info = db.prepare(
       `INSERT INTO llm_audit_logs (timestamp, trigger_source, operation_type, model_id,
         input_tokens, output_tokens, total_tokens, cost_usd, duration_ms, status,
         error_message, related_memory_ids, metadata, session_key)
@@ -2478,7 +2718,38 @@ export function createStore(path) {
         : null,
       entry.session_key ?? null
     );
-    return toLlmAudit(db.prepare("SELECT * FROM llm_audit_logs ORDER BY id DESC LIMIT 1").get());
+    // #534 / CodeRabbit on #535：回读必须用**这一次插入**的 rowid，不能用
+    // `ORDER BY id DESC LIMIT 1`。库支持多进程共用（见 AGENTS.md 的
+    // busy_timeout + WAL 约定），另一个写者在这两条语句之间插入就会把这行
+    // 读成别人的调用——调用方拿它去 annotate 校验判决时，会把本轮结论写到
+    // 另一轮头上。lastInsertRowid 是连接内的事实，不受并发写影响。
+    return toLlmAudit(db.prepare("SELECT * FROM llm_audit_logs WHERE id = ?").get(info.lastInsertRowid));
+  }
+
+  /**
+   * #534 建议 3：给已落库的审计行补一层「事后才知道」的读数。
+   *
+   * 两套账的根源是时序：审计行在 LLM 调用返回的那一刻就写死了（状态、token、
+   * 耗时都是调用层事实），而决策校验发生在调用之后——一轮「调用成功、输出却被
+   * 校验整单拒绝」在审计表里永远是 success，于是聚合出来的成功率与 dream_runs
+   * 的真实成功率对不上（作者实测 95% vs 10.5%）。
+   *
+   * 只合并 metadata（表里写明是 free-form extras），绝不改 status / token /
+   * timestamp：那些是调用层的事实，改写它们等于伪造账本。metadata 是「这一轮还
+   * 有什么值得记的」的垃圾桶，把校验判决放进去既补上了分账，又不制造第二张表。
+   *
+   * patch 是浅合并：已有键保留，同名键覆盖。行不存在（被清理/删除）静默返回
+   * undefined——补注失败不该把一轮巩固变成异常。
+   */
+  function annotateLlmAudit(id, patch) {
+    if (id == null || !patch || typeof patch !== "object") return undefined;
+    const row = db.prepare("SELECT * FROM llm_audit_logs WHERE id = ?").get(id);
+    if (!row) return undefined;
+    const current = toLlmAudit(row)?.metadata;
+    const base = current && typeof current === "object" && !Array.isArray(current) ? current : {};
+    const merged = { ...base, ...patch };
+    db.prepare("UPDATE llm_audit_logs SET metadata = ? WHERE id = ?").run(JSON.stringify(merged), id);
+    return toLlmAudit(db.prepare("SELECT * FROM llm_audit_logs WHERE id = ?").get(id));
   }
 
   function listLlmAudits({ limit = 50, offset = 0, source, sessionKey } = {}) {
@@ -2641,22 +2912,101 @@ export function createStore(path) {
    * 重跑的重复链接（否则幂等测试锁会挂）。
    * @returns {number} 实际插入行数
    */
-  function saveMemoryProvenance({ memoryId, sessionId, seqStart, seqEnd, createdAt }) {
+  function saveMemoryProvenance({ memoryId, sessionId, seqStart, seqEnd, createdAt, distillRunId }) {
+    // #512：distill_run_id 是「这条链接由哪一轮蒸馏写下」的可选归因。缺省落 NULL，
+    // 且**不回填**——存量链接没有第二轮真相可查，反推一个合成 id 比留空更坏。
     return db.prepare(
-      `INSERT INTO memory_provenance (memory_id, session_id, seq_start, seq_end, created_at)
-       VALUES (?, ?, ?, ?, ?)
+      `INSERT INTO memory_provenance (memory_id, session_id, seq_start, seq_end, created_at, distill_run_id)
+       VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT DO NOTHING`
-    ).run(memoryId, sessionId, seqStart, seqEnd, createdAt).changes;
+    ).run(memoryId, sessionId, seqStart, seqEnd, createdAt, distillRunId ?? null).changes;
   }
 
-  /** 一条记忆的全部溯源链接（#399 面板/CLI 读取面）。 */
+  /** 一条记忆的全部溯源链接（#399 面板/CLI 读取面；#512 起带 distill_run_id）。 */
   function provenanceFor(memoryId) {
     return db.prepare(
-      `SELECT memory_id, session_id, seq_start, seq_end, created_at
+      `SELECT memory_id, session_id, seq_start, seq_end, created_at, distill_run_id
          FROM memory_provenance WHERE memory_id = ? ORDER BY created_at, session_id, seq_start`
     ).all(memoryId);
   }
 
+  /**
+   * 落盘一轮蒸馏运行（#512）。写入幂等（同 id replay 覆写、绝不重复），与
+   * saveDreamRun 同一口径，让同一逻辑轮可以重放核对。
+   *
+   * audit_id 是入参而不是在这里顺手写 audit：audit 行在 summarize.js 的 finally 里
+   * 落盘，而且**可能压根不存在**（llmAudit 关着）。run 先落、audit 后补再回填这一列，
+   * 比把两件事塞进一个事务诚实——归因不该依赖计费开关。
+   */
+  function saveDistillRun(run) {
+    const id = run.id ?? randomUUID();
+    const now = nowIso();
+    db.prepare(
+      `INSERT INTO distill_runs (id, created_at, status, error, run_type, trigger_source,
+         session_id, seq_start, seq_end, memory_count, provider, model, audit_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         created_at=excluded.created_at, status=excluded.status, error=excluded.error,
+         run_type=excluded.run_type, trigger_source=excluded.trigger_source,
+         session_id=excluded.session_id, seq_start=excluded.seq_start, seq_end=excluded.seq_end,
+         memory_count=excluded.memory_count, provider=excluded.provider, model=excluded.model,
+         audit_id=excluded.audit_id`
+    ).run(
+      id,
+      run.created_at ?? now,
+      run.status,
+      run.error ?? null,
+      run.run_type,
+      run.trigger_source,
+      run.session_id ?? null,
+      Number.isInteger(run.seq_start) ? run.seq_start : null,
+      Number.isInteger(run.seq_end) ? run.seq_end : null,
+      Number.isInteger(run.memory_count) ? run.memory_count : 0,
+      run.provider ?? null,
+      run.model ?? null,
+      Number.isInteger(run.audit_id) ? run.audit_id : null
+    );
+    return getDistillRun(id);
+  }
+
+  /** #512：事后补注某一轮的开销读数 id（audit 行在 run 之后才落盘）。 */
+  function attachDistillRunAudit(id, auditId) {
+    if (!id || !Number.isInteger(auditId)) return 0;
+    return db.prepare("UPDATE distill_runs SET audit_id = ? WHERE id = ?").run(auditId, id).changes;
+  }
+
+  function getDistillRun(id) {
+    return toDistillRun(db.prepare("SELECT * FROM distill_runs WHERE id = ?").get(id));
+  }
+
+  function listDistillRuns({ limit = 50, offset = 0 } = {}) {
+    const { limit: lim, offset: off } = sanitizePage(limit, offset, 50);
+    return db.prepare(
+      "SELECT * FROM distill_runs ORDER BY created_at DESC, id LIMIT ? OFFSET ?"
+    ).all(lim, off).map(toDistillRun);
+  }
+
+  /**
+   * 记一条「这条记忆出生自哪一轮」（#512）。只记 create：既有行的改动由
+   * receipt_chain 按 (run_id, record_id) 记，两套账不能有第二份。
+   * INSERT OR IGNORE 让重放幂等——同一 run 重放不该重复记一次铸造。
+   */
+  function saveMemoryMint({ memoryId, runId, runType, triggerSource, createdAt }) {
+    if (!memoryId || !runId || !runType || !triggerSource) return 0;
+    return db.prepare(
+      `INSERT OR IGNORE INTO memory_mints (memory_id, run_id, run_type, trigger_source, created_at)
+       VALUES (?, ?, ?, ?, ?)`
+    ).run(memoryId, runId, runType, triggerSource, createdAt ?? nowIso()).changes;
+  }
+
+  /** 一条记忆的铸造记录（#512 读侧；通常 0 或 1 条，跨轮重放才会多）。 */
+  function mintsFor(memoryId) {
+    return db.prepare(
+      `SELECT memory_id, run_id, run_type, trigger_source, created_at
+         FROM memory_mints WHERE memory_id = ? ORDER BY created_at, run_id`
+    ).all(memoryId);
+  }
+
   /**
    * 一个 (session, seq 区间) 的蒸馏原文行（#399 写入、#421 读出口）。
    *
@@ -2673,6 +3023,40 @@ export function createStore(path) {
     ).all(sessionId, seqStart, seqEnd);
   }
 
+  /**
+   * 一个会话产出的蒸馏窗口（#524 方向 2 的存储侧）。
+   *
+   * #421 把溯源读出口拆成两个方向：方向 1（记忆 → 窗口）由 #509 落地，走
+   * provenanceFor；这是方向 2（会话 → 窗口）。两个方向读的是同一张表，只是索引不
+   * 同（idx_memory_provenance_session 就是为这一条建的，早已存在——所以这不是
+   * schema 变更）。
+   *
+   * **必须带 limit**：一个会话可能有几十个窗口，每个窗口接着就是整段逐字原文，
+   * 不限量等于「按会话导出全量转录」（#524 第 2 条前置）。上限的口径在协议层
+   * （provenance-http.js 的 PROVENANCE_MAX_WINDOWS），这一层只照参数取。
+   *
+   * 一行 = 一个窗口（同一 (session, seq_start, seq_end) 的多条链接 GROUP BY 成一行）
+   * ——一条蒸馏窗口通常产出多条记忆，逐链接返回会让「这个会话蒸了几次」这个唯一
+   * 有意义的计数被重复行淹没。link_count 说明该窗口派生出几条记忆，是按窗口看的
+   * 第二维；**刻意不回 memory_id 列表**：方向 1 已经是「记忆 → 窗口」，把 id 也塞进
+   * 这一侧会让两个方向不再正交（同一份映射有两条读法就得有两处维护），而真要逐条
+   * 查仍是按方向 1 走。
+   *
+   * ORDER BY seq_start：seq 是事件序号，就是会话内的先后；窗口按它排才是「这个会话
+   * 按时间蒸了哪几段」，按 created_at 排会把同一批重跑的行打散。
+   */
+  function distillWindowsFor(sessionId, limit) {
+    return db.prepare(
+      `SELECT session_id, seq_start, seq_end, MIN(created_at) AS created_at,
+              COUNT(*) AS link_count
+         FROM memory_provenance
+        WHERE session_id = ?
+        GROUP BY session_id, seq_start, seq_end
+        ORDER BY seq_start, seq_end
+        LIMIT ?`
+    ).all(sessionId, limit);
+  }
+
   // --- 存储生命周期：无损回收（#275 第一批）--------------------------------
   //
   // 两项都零价值判断、零条数变化：行数不变，只把不可重建/不可达的内容丢掉。
@@ -2888,6 +3272,108 @@ export function createStore(path) {
     ).get().c;
   }
 
+  // --- differentiate adjudication ledger (issue #533) ----------------------
+
+  /**
+   * Record that the pair (a, b) has already been adjudicated as "different
+   * enough to both stay" — the differentiate decision itself. Nothing is
+   * written to either memory: #533 的复现证明「把同一段注记追加到两侧」会
+   * 把两条向量越推越近（共享后缀同向拉高余弦），所以裁决只记账、不动正文。
+   *
+   * hash_a/hash_b are the content hashes captured at adjudication time; the
+   * sleep candidate builder uses them to decide whether the verdict still
+   * stands (any later edit to either side re-opens the pair). Sorting the pair
+   * keeps one row per unordered pair, same normalization as saveConflictPending.
+   */
+  function saveDifferentiatedPair({ run_id, memory_a, memory_b, hash_a, hash_b, distinctions }) {
+    const [a, b] = [memory_a, memory_b].sort();
+    // hashes travel with their side; sort the (id, hash) tuples so hash_a
+    // always belongs to memory_a after normalization.
+    const [ha, hb] = memory_a <= memory_b ? [hash_a, hash_b] : [hash_b, hash_a];
+    db.prepare(
+      `INSERT INTO differentiated_pairs (id, memory_a, memory_b, hash_a, hash_b, distinctions, run_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(memory_a, memory_b) DO UPDATE SET
+         hash_a = excluded.hash_a,
+         hash_b = excluded.hash_b,
+         distinctions = excluded.distinctions,
+         run_id = excluded.run_id,
+         created_at = excluded.created_at`
+    ).run(
+      randomUUID(), a, b, ha ?? null, hb ?? null,
+      // 没有 distinctions 就落 NULL 而不是 "[]"——空数组会被读成「判过、理由是空」，
+      // NULL 才是「这条账本行没记理由」的诚实写法（与 dream_runs.skipped 同口径）。
+      Array.isArray(distinctions) && distinctions.length ? JSON.stringify(distinctions) : null,
+      run_id ?? null, nowIso()
+    );
+    return findDifferentiatedPair(a, b);
+  }
+
+  /** The adjudication row for an unordered pair, or undefined. */
+  function findDifferentiatedPair(memory_a, memory_b) {
+    const [a, b] = [memory_a, memory_b].sort();
+    return toDifferentiatedPair(
+      db.prepare("SELECT * FROM differentiated_pairs WHERE memory_a = ? AND memory_b = ?").get(a, b)
+    );
+  }
+
+  /** Adjudicated pairs, newest first (audit view / tests). */
+  function listDifferentiatedPairs({ limit = 50, offset = 0 } = {}) {
+    const { limit: lim, offset: off } = sanitizePage(limit, offset, 50);
+    const rows = db.prepare(
+      "SELECT * FROM differentiated_pairs ORDER BY created_at DESC, id LIMIT ? OFFSET ?"
+    ).all(lim, off);
+    return rows.map(toDifferentiatedPair);
+  }
+
+  // --- conflict adjudication ledger (issue #529) ---------------------------
+
+  /**
+   * Record that the conflict phase adjudicated a pair, whatever the verdict was
+   * — including a bare "keep". This is the machine-side ledger that stops a
+   * no-op verdict from being re-sent forever; it is deliberately NOT
+   * conflict_pending (see the schema comment: that one is the human queue).
+   *
+   * 幂等靠主键：同一对（sort 归一化后）只留最新一次判决。多次写是常态——
+   * 一对被重判说明它确实值得重判，旧判决没有留存价值。
+   */
+  function saveConflictReviewed({ run_id, memory_a, memory_b, outcome, judged_at }) {
+    const [a, b] = [memory_a, memory_b].sort();
+    db.prepare(
+      `INSERT INTO conflict_reviewed (memory_a, memory_b, judged_at, outcome, run_id)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(memory_a, memory_b) DO UPDATE SET
+         judged_at = excluded.judged_at,
+         outcome   = excluded.outcome,
+         run_id    = excluded.run_id`
+    ).run(a, b, judged_at ?? nowIso(), outcome ?? null, run_id ?? null);
+  }
+
+  /**
+   * Load the ledger as a Map keyed by the normalized pair, for the conflict
+   * phase's pre-filter. Bounded by the number of distinct pairs ever judged,
+   * which is at most the number of pairs the phase can form — the same ceiling
+   * the candidate list itself has.
+   */
+  function loadConflictReviewed() {
+    const map = new Map();
+    for (const row of db.prepare("SELECT * FROM conflict_reviewed").all()) {
+      map.set(`${row.memory_a}\u0000${row.memory_b}`, {
+        judged_at: row.judged_at,
+        outcome: row.outcome ?? undefined,
+        run_id: row.run_id ?? undefined
+      });
+    }
+    return map;
+  }
+
+  /** Test/ops visibility: the raw ledger rows, newest first. */
+  function listConflictReviewed({ limit = 200 } = {}) {
+    return db.prepare(
+      "SELECT * FROM conflict_reviewed ORDER BY judged_at DESC, rowid DESC LIMIT ?"
+    ).all(Math.max(1, Math.min(5000, limit | 0)));
+  }
+
   /**
    * v0.8.1 底座（issue #170）：scope 归属人工修正的审计行。record 描述「一次
    * 决策后的完整状态」（prev_* 为改前、next_* 为改后，NULL=global/未标注），
@@ -3646,8 +4132,14 @@ export function createStore(path) {
     getRecallEval,
     listRecallEvals,
     saveLlmAudit,
+    annotateLlmAudit,
     getDistillCursor,
     setDistillCursor,
+    // #493 补充 §②：解析失败计数跨进程持久化（读侧带失效窗口）。单独成表，
+    // 不并进 distill_cursors——那句 UPSERT 是单调的，归零语义会打架。
+    getDistillParseFailureStreak,
+    bumpDistillParseFailureStreak,
+    clearDistillParseFailureStreak,
     listLlmAudits,
     countLlmAudits,
     getLlmAuditStats,
@@ -3659,6 +4151,15 @@ export function createStore(path) {
     saveMemoryProvenance,
     provenanceFor,
     distillRecordsFor,
+    distillWindowsFor,
+    // #512 蒸馏运行与铸造归因：run 是归因主体，audit 行只是它的开销读数。
+    // 写入幂等（replay 覆写），读侧只读——两处都不触发 write hooks（bookkeeping）。
+    saveDistillRun,
+    attachDistillRunAudit,
+    getDistillRun,
+    listDistillRuns,
+    saveMemoryMint,
+    mintsFor,
     // 存储生命周期（#275 第一批）：无损回收的统计、清理与体积口径。
     dreamRunInputStats,
     clearDreamRunInputs,
@@ -3674,6 +4175,13 @@ export function createStore(path) {
     listConflictPending,
     resolveConflictPending,
     countConflictPending,
+    saveDifferentiatedPair,
+    findDifferentiatedPair,
+    listDifferentiatedPairs,
+    // #529：机器侧裁决台账（与上面四条人工队列的函数刻意分开，见 schema 注释）。
+    saveConflictReviewed,
+    loadConflictReviewed,
+    listConflictReviewed,
     saveScopeChange,
     listScopeChanges,
     // 政策轴（issue #471）：按下/松开一个作用域。纯 bookkeeping，不调