@modusensus/dsh-mneme 0.9.5 → 0.10.0

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();
+});