@modusensus/dsh-mneme 0.9.5 → 0.10.1

package/test/store.test.js

@@ -476,6 +476,31 @@ test("countConflictPending counts unresolved rows only; resolve unknown id is un
   store.close();
 });
 
+// Issue #533：differentiate 的裁决账本。正文不再追加注记，改由这张表记住「这一对
+// 已经判过、两条都留」，候选构造阶段读它避免同一对每轮重判。
+test("Issue #533: differentiated_pairs survives a reopen and normalizes pair order", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-diffpair-"));
+  const path = join(dir, "memory.db");
+  const s1 = createStore(path);
+  // 送审顺序与存储顺序相反也要落到同一行（账本按 id 排序归一）。
+  s1.saveDifferentiatedPair({ run_id: "r1", memory_a: "mb", memory_b: "ma", hash_a: "hb", hash_b: "ha", distinctions: ["只看甲", "只看乙"] });
+  assert.equal(s1.listDifferentiatedPairs().length, 1);
+  s1.close();
+  const s2 = createStore(path);
+  const found = s2.findDifferentiatedPair("ma", "mb");
+  assert.ok(found, "lookups work in either argument order");
+  assert.equal(found.memory_a, "ma", "the row is stored sorted");
+  assert.equal(found.hash_a, "ha", "hashes travel with their side");
+  assert.deepEqual(found.distinctions, ["只看甲", "只看乙"]);
+  assert.equal(s2.listDifferentiatedPairs().length, 1, "re-saving the same pair updates instead of duplicating");
+  s2.saveDifferentiatedPair({ run_id: "r2", memory_a: "ma", memory_b: "mb", hash_a: "ha2", hash_b: "hb2" });
+  assert.equal(s2.listDifferentiatedPairs().length, 1, "still one row for one pair");
+  const updated = s2.findDifferentiatedPair("ma", "mb");
+  assert.equal(updated.hash_a, "ha2", "the refresh overwrites the hashes");
+  assert.equal(updated.distinctions, undefined, "an empty distinctions lands as NULL, not as an empty array");
+  s2.close();
+});
+
 test("conflict_pending table persists across store reopen", () => {
   const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-conflict-"));
   const path = join(dir, "memory.db");
@@ -502,3 +527,198 @@ test("Issue #128: needsEmbedding skips archived and forgotten rows", () => {
   assert.deepEqual(ids, [active.id], "only the active row is a backfill candidate");
   store.close();
 });
+
+// Issue #495：listDreamRuns 的 excludeRunType 是**下推**条件而不是调用方后置过滤——
+// 后置过滤在 limit 生效之后就晚了：5 个名额已经被 organize 占掉，再筛只能得到空。
+// 三条一起钉：默认不过滤（审计面要看全量）、指定值真的排除、白名单之外的值不生效
+// （这个参数拼进 SQL 的 != 条件，任意外来字符串不能改变查询形状）。
+test("Issue #495: listDreamRuns excludes a run type by pushdown, and only accepts known types", () => {
+  const store = openMemory();
+  store.saveDreamRun({ created_at: "2026-01-01T00:00:00.000Z", status: "ok", snapshot_hash: "h", input_count: 0, run_type: "auto", receipt: "r1" });
+  store.saveDreamRun({ created_at: "2026-01-02T00:00:00.000Z", status: "ok", snapshot_hash: "h", input_count: 0, run_type: "organize", receipt: "r2" });
+  store.saveDreamRun({ created_at: "2026-01-03T00:00:00.000Z", status: "ok", snapshot_hash: "h", input_count: 0, run_type: "organize", receipt: "r3" });
+
+  assert.equal(store.listDreamRuns().length, 3, "no filter by default — the audit surface keeps every run type");
+  assert.equal(store.listDreamRuns({ limit: 1 })[0].run_type, "organize", "limit applies to the full set");
+
+  const onlyConsolidation = store.listDreamRuns({ limit: 1, excludeRunType: "organize" });
+  assert.equal(onlyConsolidation.length, 1);
+  assert.equal(onlyConsolidation[0].run_type, "auto", "the pushdown must apply before LIMIT, not after");
+
+  // 白名单之外的值按「不过滤」处理，不静默返回空集。诚实说：这条断言钉得住
+  // 「未知值 ⇒ 不过滤」这个可观测契约，钉不住白名单本身——把 includes 判断换成裸绑定，
+  // 四条断言仍然全绿（不存在的 run_type 本来也筛不掉任何行）。白名单的价值是纵深：
+  // 值来自调用方时只允许已知的三个字面量进 SQL 的 != 条件，查询形状不随外部字符串改变。
+  assert.equal(store.listDreamRuns({ excludeRunType: "auto' OR 1=1 --" }).length, 3,
+    "a hostile value is bound as a parameter and filters nothing, never widens the query");
+  assert.equal(store.listDreamRuns({ excludeRunType: "nope" }).length, 3);
+  store.close();
+});
+
+// ============================ #512 蒸馏 run 归因
+
+test("#512 迁移：老库补上 distill_run_id 列与两张新表，存量链接留 NULL 不猜", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-migrate-run-"));
+  const dbPath = join(dir, "legacy.db");
+  try {
+    // 存量库：#399 时代的形状——memory_provenance 没有 distill_run_id，也没有
+    // distill_runs 与 memory_mints。这一行代表「改造之前就落盘的链接」，它没有 run 可指。
+    const legacy = new DatabaseSync(dbPath);
+    legacy.exec("CREATE TABLE memories (" +
+      "id TEXT PRIMARY KEY, type TEXT NOT NULL, title TEXT NOT NULL, content TEXT NOT NULL, " +
+      "tags TEXT NOT NULL DEFAULT '[]', importance INTEGER NOT NULL DEFAULT 3, " +
+      "forgotten INTEGER NOT NULL DEFAULT 0, archived INTEGER NOT NULL DEFAULT 0, " +
+      "source TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);");
+    legacy.exec("CREATE TABLE memory_provenance (" +
+      "memory_id TEXT NOT NULL, session_id TEXT NOT NULL, " +
+      "seq_start INTEGER NOT NULL, seq_end INTEGER NOT NULL, created_at TEXT NOT NULL);");
+    legacy.exec("INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, created_at, updated_at) " +
+      "VALUES ('old1', 'history', '老记忆', '内容', '[]', 3, 0, 0, NULL, '2026-01-01T00:00:00.000Z', '2026-01-02T00:00:00.000Z');");
+    legacy.exec("INSERT INTO memory_provenance (memory_id, session_id, seq_start, seq_end, created_at) " +
+      "VALUES ('old1', 's-old', 1, 5, '2026-01-02T00:00:00.000Z');");
+    legacy.close();
+
+    const store = createStore(dbPath);
+    const cols = store.db.prepare("PRAGMA table_info(memory_provenance)").all().map((c) => c.name);
+    assert.ok(cols.includes("distill_run_id"), "存量库重开即补上 distill_run_id");
+    for (const table of ["distill_runs", "memory_mints"]) {
+      const row = store.db.prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name=?"
+      ).get(table);
+      assert.ok(row, "存量库重开即建 " + table);
+    }
+
+    const links = store.provenanceFor("old1");
+    assert.equal(links.length, 1);
+    assert.equal(
+      links[0].distill_run_id,
+      null,
+      "历史链接保持 NULL：反推一个合成 run id 比不填更坏（读数正常、实际是猜的）"
+    );
+    assert.equal(store.mintsFor("old1").length, 0, "历史记忆不补铸造记录——那时根本没有 run 概念");
+    store.close();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#512 迁移幂等：重开已升级的库不重复 ALTER、不动已落盘的 run 归因", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-migrate-run2-"));
+  const dbPath = join(dir, "upgraded.db");
+  try {
+    const first = createStore(dbPath);
+    const m = first.save({ type: "history", title: "t", content: "c" });
+    first.saveDistillRun({
+      id: "run-a",
+      status: "ok",
+      run_type: "autoSummarize",
+      trigger_source: "autoSummarize",
+      session_id: "s1",
+      seq_start: 1,
+      seq_end: 2,
+      memory_count: 1
+    });
+    first.saveMemoryProvenance({
+      memoryId: m.id, sessionId: "s1", seqStart: 1, seqEnd: 2,
+      createdAt: "2026-11-01T00:00:00.000Z", distillRunId: "run-a"
+    });
+    first.close();
+
+    const second = createStore(dbPath);
+    const cols = second.db.prepare("PRAGMA table_info(memory_provenance)")
+      .all().filter((c) => c.name === "distill_run_id");
+    assert.equal(cols.length, 1, "列只存在一份，没被重复 ALTER");
+    assert.equal(second.provenanceFor(m.id)[0].distill_run_id, "run-a", "重开不动已落盘的归因");
+    assert.equal(second.getDistillRun("run-a").status, "ok");
+    second.close();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#512 distill_runs：同 id replay 覆写而不重复", () => {
+  const store = openMemory();
+  store.saveDistillRun({
+    id: "r1", status: "failed", error: "boom",
+    run_type: "autoSummarize", trigger_source: "autoSummarize",
+    session_id: "s1", seq_start: 1, seq_end: 3, memory_count: 0,
+    created_at: "2026-11-01T00:00:00.000Z"
+  });
+  // 同一轮重放（等价于宿主重启后重试同一逻辑轮）：必须覆写，不能变成两行。
+  store.saveDistillRun({
+    id: "r1", status: "ok",
+    run_type: "autoSummarize", trigger_source: "autoSummarize",
+    session_id: "s1", seq_start: 1, seq_end: 3, memory_count: 2,
+    created_at: "2026-11-01T00:00:00.000Z"
+  });
+  const runs = store.listDistillRuns();
+  assert.equal(runs.length, 1, "一轮只有一行");
+  assert.equal(runs[0].status, "ok", "replay 覆写成最新的事实");
+  assert.equal(runs[0].error, undefined, "覆写清掉上一次的错误");
+  assert.equal(runs[0].memory_count, 2);
+  assert.equal(runs[0].audit_id, undefined, "没有 audit 行时是 undefined，不是 0");
+  store.close();
+});
+
+test("#512 distill_runs：audit_id 事后补注，补不存在的 run 静默返回 0", () => {
+  const store = openMemory();
+  store.saveDistillRun({ id: "r2", status: "ok", run_type: "autoSummarize", trigger_source: "autoSummarize" });
+  assert.equal(store.attachDistillRunAudit("r2", 42), 1);
+  assert.equal(store.getDistillRun("r2").audit_id, 42);
+  assert.equal(store.attachDistillRunAudit("missing", 42), 0, "行不存在时不动任何东西");
+  assert.equal(store.attachDistillRunAudit("r2", null), 0, "非整数 audit id 一律不写");
+  store.close();
+});
+
+test("#512 memory_mints：同一 (记忆, run) 只记一次，删记忆时显式清掉归因", () => {
+  const store = openMemory();
+  const m = store.save({ type: "pattern", title: "抽出来的规律", content: "c", source: "dream" });
+  const mint = { memoryId: m.id, runId: "run-d", runType: "dream", triggerSource: "autoDream", createdAt: "2026-11-01T00:00:00.000Z" };
+  assert.equal(store.saveMemoryMint(mint), 1);
+  assert.equal(store.saveMemoryMint(mint), 0, "INSERT OR IGNORE：重放不重复记一次铸造");
+  const rows = store.mintsFor(m.id);
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].run_type, "dream");
+  assert.equal(rows[0].trigger_source, "autoDream");
+
+  store.remove(m.id);
+  assert.equal(
+    store.db.prepare("SELECT count(*) AS c FROM memory_mints WHERE memory_id = ?").get(m.id).c,
+    0,
+    "记忆没了，归因不许悬空（CASCADE 之外仍显式清，与 memory_provenance 同一口径）"
+  );
+  store.close();
+});
+
+// ============================ #493 补充：失败计数持久化（读侧失效）
+// 这张表只服务一道默认关的护栏（summarizeParseFailureMaxRetries），但它的语义有三处
+// 容易写错、且错法都不可见：计数不落库（重启即清零）、失效不在读侧（几周前的失败
+// 直接熔断当前窗口）、清零写成 0（「从没失败过」与「刚清零」变得不可区分）。
+test("#493 补充：解析失败计数持久化、读侧带失效窗口、清零是真 DELETE", () => {
+  const store = openMemory();
+  const sid = "s-streak";
+  assert.equal(store.getDistillParseFailureStreak(sid), 0, "没有记录就是 0，不是 undefined");
+
+  assert.equal(store.bumpDistillParseFailureStreak(sid), 1);
+  assert.equal(store.bumpDistillParseFailureStreak(sid), 2, "累计加一");
+  assert.equal(store.getDistillParseFailureStreak(sid), 2);
+
+  // 读侧失效：时间戳挪到 30 天前，7 天窗口下必须当 0（不判失效时它仍是 2）。
+  const ancient = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+  store.db.prepare("UPDATE distill_parse_failures SET updated_at = ? WHERE session_id = ?").run(ancient, sid);
+  assert.equal(store.getDistillParseFailureStreak(sid), 2, "staleAfterMs 缺省不判失效（调用方显式要才判）");
+  assert.equal(store.getDistillParseFailureStreak(sid, { staleAfterMs: 7 * 24 * 60 * 60 * 1000 }), 0,
+    "过期的 streak 必须读成 0：拿几周前的失败去熔断当前窗口，护栏就成了新的误伤路径");
+
+  // 失效之后再加一，必须从 1 起（不是在旧值上 +1）——这条是本块实现的首版 bug，
+  // 被 summarize.test.js 的端到端用例抓出来：SQL 里写 streak + 1 会让失效判断失效。
+  assert.equal(store.bumpDistillParseFailureStreak(sid, { staleAfterMs: 7 * 24 * 60 * 60 * 1000 }), 1,
+    "过期的旧行不许把「新的第一次失败」加成 2");
+
+  // 清零是真删除：没有任何在途失败时不该留一行 0。
+  assert.equal(store.clearDistillParseFailureStreak(sid), 1);
+  assert.equal(store.getDistillParseFailureStreak(sid), 0);
+  assert.equal(store.db.prepare("SELECT count(*) AS c FROM distill_parse_failures").get().c, 0,
+    "清零是 DELETE，不是写 0——写 0 会让「从没失败过」与「刚清零」不可区分");
+  store.close();
+});

package/test/summarize.test.js

@@ -1637,6 +1637,82 @@ test("issue#399: expiring records keeps the memories and leaves provenance dangl
   assert.ok(store.provenanceFor(memoryId).length >= 1, "面板/CLI 仍能回答「这条记忆出自哪个窗口」，只是来源已过期");
 });
 
+// ── Issue #512：蒸馏归因补 run 概念 ────────────────────────────────────────
+//
+// 这四条锁的是「这条记忆是哪一次蒸馏带进来的」这条问句现在回答得出来：
+//   ① 一轮真蒸馏落一行 distill_runs，链接上带同一个 distill_run_id；
+//   ② run 与它的开销读数（llm_audit_logs）靠 audit_id 直连，不靠时间戳猜；
+//   ③ llmAudit 关掉时 run 仍然成立（归因不该依赖计费开关），只是没有 audit_id；
+//   ④ 失败轮也留一行——「那一轮跑了但没成」本身就是归因要回答的事。
+// 反面（历史链接保持 NULL、不回填）在 test/store.test.js 的迁移用例里锁。
+
+test("issue#512: a distilled window records one run, and every link points at it", async () => {
+  const { events, store } = setup(RECORDS_ON);
+  const session = recordsSession("s512-ok", [userMessage("这轮要能追到 run", 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+
+  const runs = store.listDistillRuns();
+  assert.equal(runs.length, 1, "一轮真蒸馏就是一行 run");
+  const run = runs[0];
+  assert.equal(run.status, "ok");
+  assert.equal(run.run_type, "autoSummarize");
+  assert.equal(run.trigger_source, "autoSummarize");
+  assert.equal(run.session_id, "s512-ok");
+  assert.deepEqual([run.seq_start, run.seq_end], [1, 2], "run 记的是这一步真正蒸馏掉的窗口");
+  assert.equal(run.memory_count, 2, "记忆条数是实际写成功的条数");
+
+  const links = store.db.prepare("SELECT memory_id, distill_run_id FROM memory_provenance").all();
+  assert.equal(links.length, 2);
+  for (const link of links) {
+    assert.equal(link.distill_run_id, run.id, "每条记忆的链接都指向这一轮，不是 NULL、也不是别的轮");
+  }
+});
+
+test("issue#512: the run and its spend row are joined by audit_id, not guessed from timestamps", async () => {
+  const { events, store } = setup(RECORDS_ON);
+  const session = recordsSession("s512-audit", [userMessage("归因要连到开销行", 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+
+  const run = store.listDistillRuns()[0];
+  const audits = store.listLlmAudits({ source: "autoSummarize" });
+  assert.equal(audits.length, 1);
+  assert.equal(run.audit_id, audits[0].id, "run 直接指着它自己那一行，不靠时间窗匹配");
+  // 反向也成立：从 run 拿到的 id 读回来就是那一条。
+  const join = store.getDistillRun(run.id);
+  assert.equal(join.audit_id, audits[0].id);
+});
+
+test("issue#512: with llmAudit off the run still lands — attribution must not depend on the spend switch", async () => {
+  const { events, store } = setup({ ...RECORDS_ON, llmAudit: { enabled: false } });
+  const session = recordsSession("s512-noaudit", [userMessage("关了计费也要能归因", 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(store.listLlmAudits().length, 0, "开关关着，一行 audit 都不写");
+  const runs = store.listDistillRuns();
+  assert.equal(runs.length, 1, "但 run 照落");
+  assert.equal(runs[0].status, "ok");
+  assert.equal(runs[0].audit_id, undefined, "没有开销行时这一列是空的——不填假 id");
+});
+
+test("issue#512: a failed round still leaves a run row saying it failed", async () => {
+  // 流失败：窗口保留待重试，但「跑过一轮且失败」这件事必须留痕，否则归因只记得住成的。
+  const { events, store } = setup(RECORDS_ON, {
+    stream: () => (async function* () {
+      yield { type: "block-start", block: { type: "text" } };
+      yield { type: "finish", kind: "error", error: { message: "upstream exploded" } };
+    })()
+  });
+  const session = recordsSession("s512-fail", [userMessage("这轮会失败", 1), { seq: 2, type: "turn/end" }]);
+  await eventHandler(events)(session, { seq: 2, type: "turn/end" });
+
+  const runs = store.listDistillRuns();
+  assert.equal(runs.length, 1, "失败轮也是一轮");
+  assert.equal(runs[0].status, "failed");
+  assert.ok(runs[0].error, "失败要有原因，空错误等于没说");
+  assert.equal(runs[0].memory_count, 0);
+  assert.equal(countRows(store, "SELECT count(*) AS c FROM distill_records"), 0, "失败轮不落原文");
+});
+
 test("issue#399: enabled=false (the default) writes nothing at all", async () => {
   const { events, store, service } = setup({ distillRateLimitIntervalMs: 0 });
   let saverCalls = 0;
@@ -2051,3 +2127,99 @@ test("#493 失败护栏：一次成功即清零计数，不会隔窗累计", asy
   summarizer.dispose();
   store.close();
 });
+
+// ============================ #493 补充：失败计数落库（不再只在进程内）
+// 报告者 strange2000（2026-11-02）第 ① 条：别只存裸计数。原先 streak 活在
+// createSummarizer 闭包里的一个 Map，重启即清零——而这道护栏要防的恰恰是「确定性
+// 失败反复重试」，重启一次就绕过去了。两条用例各自钉一半：
+// 1) 换一个 summarizer 实例（= 重启）后计数仍然接得上，阈值照旧触发；
+// 2) 会话停了很久之后计数失效，不会被几周前攒下的 streak 误伤（他特别点名的那个
+//    反例：护栏自己变成新的误伤路径）。
+test("#493 补充：失败计数落库——换一个 summarizer 实例（模拟重启）仍然接得上", async () => {
+  const store = createStore(":memory:");
+  const outputs = ["不是 JSON", "还不是 JSON", "依然不是 JSON"];
+  let attempt = 0;
+  const failStream = () => (async function* () {
+    yield { type: "block-start", block: { type: "text" } };
+    yield { type: "text-delta", delta: outputs[attempt++] ?? "[]" };
+    yield { type: "finish", kind: "ok" };
+  })();
+  const config = { summarizeParseFailureMaxRetries: 3, distillRateLimitIntervalMs: 0 };
+  const sessionOf = () => ({
+    id: "s493-persisted-streak",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("会被放弃的窗口", 1), { seq: 2, type: "turn/end" }]
+  });
+
+  // 第一个实例：失败两次就「重启」（dispose + 丢掉闭包），阈值 3 还没到。
+  const first = setup(config, { store, stream: failStream });
+  const handlerA = eventHandler(first.events);
+  const sessionA = sessionOf();
+  await handlerA(sessionA, { seq: 2, type: "turn/end" });
+  await handlerA(sessionA, { seq: 2, type: "turn/end" });
+  first.summarizer.dispose();
+  assert.equal(first.service.getDistillCursor("s493-persisted-streak"), undefined, "两次失败还没到阈值，游标不推进");
+  assert.equal(first.store.getDistillParseFailureStreak("s493-persisted-streak"), 2,
+    "计数必须已经在库里——进程内 Map 在这里会是 0（重启就丢）");
+
+  // 第二个实例：同一个库、同一个会话。第 3 次失败必须凑满阈值并放弃窗口。
+  const second = setup(config, { store, stream: failStream });
+  const handlerB = eventHandler(second.events);
+  const sessionB = sessionOf();
+  await handlerB(sessionB, { seq: 2, type: "turn/end" });
+
+  assert.equal(second.service.getDistillCursor("s493-persisted-streak")?.last_seq, 2,
+    "重启前攒下的 2 次 + 这次的 1 次 = 阈值，窗口必须被放弃（进程内 Map 到这儿是 1，不会放弃）");
+  const abandoned = second.service.listLlmAudits().filter((r) => r.status === "error")
+    .find((r) => r.metadata?.skipped === "parse-failure-streak");
+  assert.equal(abandoned?.metadata?.streak, 3, "审计里的 streak 是**累计**值，不是本次进程内从 1 起算");
+  assert.equal(second.store.getDistillParseFailureStreak("s493-persisted-streak"), 0,
+    "放弃后清零：窗口已消费，下一窗从全新状态起算");
+  second.summarizer.dispose();
+  store.close();
+});
+
+test("#493 补充：停了很久的会话，旧 streak 失效，不会被几周前的失败误伤", async () => {
+  const store = createStore(":memory:");
+  let attempts = 0;
+  const { events, calls, service, summarizer } = setup(
+    { summarizeParseFailureMaxRetries: 2, distillRateLimitIntervalMs: 0 },
+    {
+      store,
+      stream() {
+        return (async function* () {
+          yield { type: "block-start", block: { type: "text" } };
+          yield { type: "text-delta", delta: attempts++ === 0 ? "不是 JSON" : "[]" };
+          yield { type: "finish", kind: "ok" };
+        })();
+      }
+    }
+  );
+  const handler = eventHandler(events);
+  const session = {
+    id: "s493-stale-streak",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("隔了很久才回来的窗口", 1), { seq: 2, type: "turn/end" }]
+  };
+
+  // 先在库里种一条「很久以前失败过一次」的记录（阈值 2，再有一次就会熔断）。
+  service.bumpDistillParseFailureStreak("s493-stale-streak");
+  const ancient = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+  store.db.prepare("UPDATE distill_parse_failures SET updated_at = ? WHERE session_id = ?").run(ancient, "s493-stale-streak");
+  assert.equal(store.getDistillParseFailureStreak("s493-stale-streak"), 1, "不判失效时它还在");
+  assert.equal(store.getDistillParseFailureStreak("s493-stale-streak", { staleAfterMs: 7 * 24 * 60 * 60 * 1000 }), 0,
+    "读侧带失效窗口时必须当 0：30 天前的失败不算「连续失败」");
+
+  // 于是这次的第一次失败应当只算 streak=1，不熔断；成功一次即清零。
+  await handler(session, { seq: 2, type: "turn/end" });
+  const firstFail = service.listLlmAudits().find((r) => r.status === "error");
+  assert.equal(firstFail?.metadata?.streak, 1, "旧记录失效之后，这次失败是「新的第一次」");
+  assert.equal(firstFail?.metadata?.skipped, undefined, "不许因为几周前的失败就直接熔断当前窗口");
+  assert.equal(service.getDistillCursor("s493-stale-streak"), undefined, "游标没被跳过，窗口仍可重试");
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 2);
+  assert.equal(store.getDistillParseFailureStreak("s493-stale-streak"), 0, "成功即清零（DELETE，不是写 0）");
+  summarizer.dispose();
+  store.close();
+});