@modusensus/dsh-mneme 0.8.4 → 0.8.5

package/test/summarize.test.js

@@ -1,12 +1,54 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
-import { createSummarizer, parseSummaryJson } from "../src/summarize.js";
+import { createSummarizer, parseSummaryJson, parsePeakSpec, isInPeakWindow, nextOffPeakAt } from "../src/summarize.js";
 import { createSettings } from "../src/settings.js";
 
+// Issue #239 第 4 项：可注入的假时钟 + 定时器——错峰队列的测试必须能「推进时间」，
+// 真实 setTimeout 会让补跑路径要么测不到、要么拖慢测试。
+function fakeClock(start) {
+  let current = start.getTime();
+  const timers = [];
+  const deps = {
+    now: () => current,
+    setTimeoutFn: (fn, ms) => {
+      const entry = { fn, at: current + ms };
+      timers.push(entry);
+      return entry;
+    },
+    clearTimeoutFn: (entry) => {
+      const i = timers.indexOf(entry);
+      if (i !== -1) timers.splice(i, 1);
+    }
+  };
+  const flush = async () => {
+    // 补跑是异步链（enqueueDistill → stream）：推完时间要给微任务与一轮宏任务机会。
+    for (let i = 0; i < 4; i++) await new Promise((resolve) => setTimeout(resolve, 0));
+  };
+  return {
+    deps,
+    pending: () => timers.length,
+    async advanceTo(date) {
+      current = date.getTime();
+      for (const entry of [...timers].sort((a, b) => a.at - b.at)) {
+        if (entry.at > current) continue;
+        timers.splice(timers.indexOf(entry), 1);
+        entry.fn();
+      }
+      await flush();
+    },
+    async advance(ms) {
+      await this.advanceTo(new Date(current + ms));
+    }
+  };
+}
+
 function setup(over = {}, opts = {}) {
-  const store = createStore(":memory:");
+  const store = opts.store ?? createStore(":memory:");
   const service = createService({ store, mirror: null, config: {} });
   const events = [];
   const calls = [];
@@ -36,7 +78,7 @@ function setup(over = {}, opts = {}) {
     }
   };
   const config = { autoSummarize: true, ...over };
-  const summarizer = createSummarizer(ctx, service, config);
+  const summarizer = createSummarizer(ctx, service, config, opts.deps ?? {});
   return { store, service, events, calls, summarizer };
 }
 
@@ -151,6 +193,218 @@ test("reads events from snapshotEvents() when Session.events is absent", async (
   assert.equal(store.count(), 2);
 });
 
+// --- Issue #239：成本感知级联（零 LLM 预判）与有界检查点 ---------------------
+// 验收对齐 #239：日志可见 skip 原因、默认配置下行为零变化、开启后调用量下降。
+
+test("#239 预判默认关：阈值为 0 时不改变现状，照常发起调用", async () => {
+  const { events, calls, store } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-default",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("短", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "默认不预判：再短的窗口也照常蒸馏");
+  assert.equal(store.count(), 2);
+});
+
+test("#239 窗口过短：零 LLM 预判拦下调用，留 skip 审计并消费游标", async () => {
+  const { events, calls, service, store } = setup({ summarizeMinWindowChars: 1000 });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-small",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("好", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 0, "短窗口不得发起 LLM 调用");
+  assert.equal(store.count(), 0, "被拦下就不该写入记忆");
+  const rows = service.listLlmAudits();
+  assert.equal(rows[0].status, "skipped");
+  assert.equal(rows[0].error_message, "window-too-small", "skip 原因必须可观测");
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 0);
+  assert.equal(service.listLlmAudits().length, 1, "游标已消费：同一窗口不重复评估、不重复审计");
+});
+
+test("#239 窗口达到阈值时预判放行（不误杀）", async () => {
+  const { events, calls } = setup({ summarizeMinWindowChars: 5 });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-pass",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("这是一段足够长的用户输入", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1);
+});
+
+test("#239 每会话 run 预算：额度用尽后不再调用，审计写明原因", async () => {
+  const { events, calls, service } = setup({ summarizeMaxRunsPerSession: 1, distillRateLimitIntervalMs: 0 });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-cap",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("第一轮", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "第一次在预算内");
+
+  session.events.push(userMessage("第二轮", 3), { seq: 4, type: "turn/end" });
+  await handler(session, { seq: 4, type: "turn/end" });
+  assert.equal(calls.length, 1, "预算用尽后不得再调用");
+  const rows = service.listLlmAudits();
+  assert.equal(rows[0].status, "skipped");
+  assert.equal(rows[0].error_message, "max-runs-per-session");
+});
+
+test("#239 预算只计真实调用：被预判拦下的窗口不消耗额度", async () => {
+  const { events, calls } = setup({ summarizeMaxRunsPerSession: 1, summarizeMinWindowChars: 10, distillRateLimitIntervalMs: 0 });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-budget",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("短", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 0, "第一轮被零 LLM 预判拦下");
+
+  session.events.push(userMessage("第二轮写得足够长，应该放行并消耗唯一的一次额度", 3), { seq: 4, type: "turn/end" });
+  await handler(session, { seq: 4, type: "turn/end" });
+  assert.equal(calls.length, 1, "零成本窗口不该吃掉预算");
+});
+
+// --- Issue #239 第 4 项：错峰队列 -------------------------------------------------
+
+test("#239-4 高峰时段解析：合法 / 多段 / 跨零点 / 星期前缀 / 非法一律按未配置", () => {
+  assert.equal(parsePeakSpec(""), null);
+  assert.equal(parsePeakSpec("   "), null);
+  assert.deepEqual(parsePeakSpec("09:00-18:00"), { days: null, windows: [{ start: 540, end: 1080 }] });
+  assert.deepEqual(parsePeakSpec("09:00-12:00, 14:00-18:00"), {
+    days: null,
+    windows: [{ start: 540, end: 720 }, { start: 840, end: 1080 }]
+  });
+  assert.deepEqual(parsePeakSpec("23:00-06:00"), { days: null, windows: [{ start: 1380, end: 360 }] });
+  // 星期前缀：ISO 1=周一…7=周日，也认 mon..sun；支持列表与跨周环绕
+  assert.deepEqual(parsePeakSpec("mon-fri 08:00-12:00,14:00-18:00"), {
+    days: [1, 2, 3, 4, 5],
+    windows: [{ start: 480, end: 720 }, { start: 840, end: 1080 }]
+  });
+  assert.deepEqual(parsePeakSpec("1-5 08:00-12:00").days, [1, 2, 3, 4, 5]);
+  assert.deepEqual(parsePeakSpec("sat,sun 10:00-12:00").days, [6, 7]);
+  assert.deepEqual(parsePeakSpec("fri-mon 10:00-12:00").days, [1, 5, 6, 7], "跨周环绕");
+  // 排程是省钱手段，绝不该因为写错格式把蒸馏停掉：任何非法写法都当作「关闭」。
+  for (const bad of ["09:00~18:00", "24:00-06:00", "09:60-18:00", "09:00-09:00", "abc", "09:00-18:00,oops", "weekday 09:00-18:00", "8 09:00-18:00"]) {
+    assert.equal(parsePeakSpec(bad), null, `${bad} 应视为未配置`);
+  }
+});
+
+test("#239-4 高峰判定与补跑时刻（跨零点、右开区间）", () => {
+  const at = (h, m) => new Date(2026, 8, 19, h, m, 30);
+  assert.equal(isInPeakWindow(at(10, 0), "09:00-18:00"), true);
+  assert.equal(isInPeakWindow(at(18, 0), "09:00-18:00"), false, "右开区间：18:00 已出高峰");
+  assert.equal(isInPeakWindow(at(3, 0), "23:00-06:00"), true, "跨零点时段");
+  assert.equal(isInPeakWindow(at(12, 0), "23:00-06:00"), false);
+  assert.equal(isInPeakWindow(at(10, 0), ""), false, "未配置 = 永不高峰");
+  const next = nextOffPeakAt(at(10, 30), "09:00-18:00");
+  assert.equal(next.getHours(), 18);
+  assert.equal(next.getMinutes(), 0);
+  assert.equal(nextOffPeakAt(at(3, 0), "23:00-06:00").getHours(), 6, "跨零点取次日 06:00 结束点");
+  assert.equal(nextOffPeakAt(at(20, 0), "09:00-18:00"), null, "非高峰时刻无需补跑");
+});
+
+// 夹具：按 ISO 星期几（1=周一…7=周日）从当月 1 号推算出日期，避免把星期写死在测试里。
+function dateOnIsoDay(isoDay, hour, minute) {
+  const first = new Date(2026, 8, 1, hour, minute, 0);
+  const firstIso = first.getDay() === 0 ? 7 : first.getDay();
+  return new Date(2026, 8, 1 + ((isoDay - firstIso + 7) % 7), hour, minute, 0);
+}
+
+test("#239-4 星期过滤：工作日高峰不误伤周末（跨零点段按「开窗那天」认星期）", () => {
+  const spec = "mon-fri 08:00-12:00,14:00-18:00";
+  assert.equal(dateOnIsoDay(1, 9, 0).getDay(), 1, "夹具自检：周一");
+  assert.equal(dateOnIsoDay(6, 9, 0).getDay(), 6, "夹具自检：周六");
+  assert.equal(isInPeakWindow(dateOnIsoDay(1, 9, 0), spec), true, "工作日 09:00 在高峰");
+  assert.equal(isInPeakWindow(dateOnIsoDay(1, 12, 30), spec), false, "工作日午休不在高峰");
+  assert.equal(isInPeakWindow(dateOnIsoDay(6, 9, 0), spec), false, "周六同刻不在高峰（按周计费）");
+  assert.equal(isInPeakWindow(dateOnIsoDay(7, 15, 0), spec), false, "周日下午不在高峰");
+  assert.equal(nextOffPeakAt(dateOnIsoDay(1, 9, 0), spec).getHours(), 12, "工作日顺延到 12:00");
+  assert.equal(nextOffPeakAt(dateOnIsoDay(6, 9, 0), spec), null, "周末无需顺延");
+  // 跨零点段：周五 23:00 开的窗口延续到周六凌晨，仍算高峰；周六开的则不覆盖周日
+  const overnight = "mon-fri 23:00-06:00";
+  assert.equal(isInPeakWindow(dateOnIsoDay(6, 2, 0), overnight), true, "周六 02:00 属周五开的窗口");
+  assert.equal(isInPeakWindow(dateOnIsoDay(7, 2, 0), overnight), false, "周日 02:00 属周六开的窗口（周六不在集合内）");
+});
+
+test("#239-4 默认关：未配置高峰时行为与现状一致", async () => {
+  const clock = fakeClock(new Date(2026, 8, 19, 10, 0, 0));
+  const { events, calls } = setup({}, { deps: clock.deps });
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-peak-off",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("普通一轮", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "未配置高峰 → 照常蒸馏");
+  assert.equal(clock.pending(), 0, "不该挂补跑定时器");
+});
+
+test("#239-4 高峰内不调模型：skip 审计 + 不消费游标，非高峰补跑整窗", async () => {
+  const clock = fakeClock(new Date(2026, 8, 19, 10, 0, 0));
+  const { events, calls, service, store } = setup(
+    { summarizePeakHours: "09:00-18:00", distillRateLimitIntervalMs: 0 },
+    { deps: clock.deps }
+  );
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-peak",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("高峰里的第一段", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 0, "高峰期不得调模型");
+  assert.equal(store.count(), 0, "不该写入记忆");
+  const rows = service.listLlmAudits();
+  assert.equal(rows[0].status, "skipped");
+  assert.equal(rows[0].error_message, "peak-hours", "skip 原因必须可观测");
+  assert.equal(clock.pending(), 1, "应挂一个补跑定时器");
+
+  // 高峰期间又来一轮：游标未消费 → 窗口累积；仍不调模型、定时器不叠加
+  session.events.push(userMessage("高峰里的第二段", 3), { seq: 4, type: "turn/end" });
+  await handler(session, { seq: 4, type: "turn/end" });
+  assert.equal(calls.length, 0);
+  assert.equal(clock.pending(), 1, "每会话只挂一个定时器");
+
+  // 推到非高峰：一次补跑，且蒸到的是累积后的整窗
+  await clock.advanceTo(new Date(2026, 8, 19, 18, 0, 5));
+  assert.equal(calls.length, 1, "非高峰补跑一次");
+  const prompt = JSON.stringify(calls[0].messages);
+  assert.ok(prompt.includes("高峰里的第一段") && prompt.includes("高峰里的第二段"),
+    "补跑应蒸馏累积后的完整窗口");
+  assert.ok(store.count() > 0, "补跑真的写入了记忆");
+});
+
+test("#239-4 顺延上限：长高峰到点照跑，不饿死蒸馏", async () => {
+  const clock = fakeClock(new Date(2026, 8, 19, 9, 0, 0));
+  const { events, calls } = setup(
+    { summarizePeakHours: "09:00-18:00", summarizePeakMaxDeferMinutes: 30, distillRateLimitIntervalMs: 0 },
+    { deps: clock.deps }
+  );
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s239-peak-cap",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("长高峰里的一轮", 1), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 0, "高峰内先顺延");
+  await clock.advance(31 * 60000);
+  assert.equal(calls.length, 1, "上限到点仍处高峰也照跑（bypassPeak）");
+});
+
 test("does not call the LLM when no event was added after the last successful seq", async () => {
   const { events, calls } = setup({ distillRateLimitIntervalMs: 0 });
   const handler = events.find((e) => e.name === "session/event").fn;
@@ -172,6 +426,94 @@ test("does not call the LLM when no event was added after the last successful se
   assert.equal(ranges[1][0], 2, "the successful event seq is passed as the next snapshot lower bound");
 });
 
+test("resumes a persisted seq cursor after the summarizer is restarted", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-distill-cursor-"));
+  const dbPath = join(dir, "memory.db");
+  let firstStore;
+  let firstSummarizer;
+  let secondStore;
+  let secondSummarizer;
+  try {
+    firstStore = createStore(dbPath);
+    const first = setup({ distillRateLimitIntervalMs: 0 }, { store: firstStore });
+    firstSummarizer = first.summarizer;
+    const session = {
+      id: "s-restart",
+      requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+      events: [userMessage("重启前的窗口", 1), { seq: 2, type: "turn/end" }]
+    };
+    const firstHandler = first.events.find((e) => e.name === "session/event").fn;
+    await firstHandler(session, { seq: 2, type: "turn/end" });
+    assert.equal(first.calls.length, 1);
+    assert.equal(firstStore.getDistillCursor("s-restart").last_seq, 2);
+
+    firstSummarizer.dispose();
+    firstStore.close();
+    firstSummarizer = undefined;
+    firstStore = undefined;
+
+    secondStore = createStore(dbPath);
+    const second = setup({ distillRateLimitIntervalMs: 0 }, { store: secondStore });
+    secondSummarizer = second.summarizer;
+    const secondHandler = second.events.find((e) => e.name === "session/event").fn;
+    await secondHandler(session, { seq: 2, type: "turn/end" });
+
+    assert.equal(second.calls.length, 0, "a restarted summarizer must reuse the persisted cursor");
+    assert.equal(secondStore.count(), 2, "the restart must not duplicate memories");
+    assert.equal(secondStore.getDistillCursor("s-restart").last_seq, 2);
+  } finally {
+    secondSummarizer?.dispose();
+    secondStore?.close();
+    firstSummarizer?.dispose();
+    firstStore?.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("treats a valid empty summary as a successful cursor commit", async () => {
+  const { events, store, calls } = setup(
+    { distillRateLimitIntervalMs: 0 },
+    { stream: streamOf([]) }
+  );
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s-empty-summary",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("这一轮没有可保存的长期记忆", 1), { seq: 2, type: "turn/end" }]
+  };
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1);
+  assert.equal(store.count(), 0);
+  assert.equal(store.getDistillCursor(session.id).last_seq, 2);
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "a valid empty summary must consume the window once");
+});
+
+test("advances the cursor to the window end for mixed valid and invalid entries", async () => {
+  const valid = { type: "history", title: "有效摘要", content: "只保存这一条", importance: 3 };
+  const { events, store, calls } = setup(
+    { distillRateLimitIntervalMs: 0 },
+    { stream: streamOf([valid, { type: "unknown", title: "无效摘要", content: "忽略" }, null]) }
+  );
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s-mixed-summary",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("混合摘要窗口", 1), { seq: 2, type: "assistant/message" }, { seq: 3, type: "turn/end" }]
+  };
+
+  await handler(session, { seq: 3, type: "turn/end" });
+  assert.equal(calls.length, 1);
+  assert.equal(store.count(), 1);
+  assert.equal(store.all()[0].title, valid.title);
+  assert.equal(store.getDistillCursor(session.id).last_seq, 3);
+
+  await handler(session, { seq: 3, type: "turn/end" });
+  assert.equal(calls.length, 1, "a mixed summary must consume the window once");
+});
+
 test("distills only new seq events and keeps the recent tail when a window exceeds distillMaxChars", async () => {
   const { events, calls } = setup(
     { distillMaxChars: 80, distillRateLimitIntervalMs: 0 },
@@ -403,10 +745,12 @@ test("rolls back partial memory writes so retrying a failed window does not dupl
   await handler(session, { seq: 2, type: "turn/end" });
   assert.equal(calls.length, 1);
   assert.equal(store.count(), 0, "a failed write transaction must leave no partial memory");
+  assert.equal(store.getDistillCursor("s-partial-write"), undefined, "a failed write must not advance the cursor");
 
   await handler(session, { seq: 2, type: "turn/end" });
   assert.equal(calls.length, 2, "the failed seq window must be retried");
   assert.equal(store.count(), 2);
+  assert.equal(store.getDistillCursor("s-partial-write").last_seq, 2);
   assert.equal(store.all().find((memory) => memory.title === "第一条")?.content, "第一条内容");
 
   await handler(session, { seq: 2, type: "turn/end" });
@@ -414,6 +758,66 @@ test("rolls back partial memory writes so retrying a failed window does not dupl
   assert.equal(store.count(), 2);
 });
 
+test("rolls back memory writes when persisting the cursor fails", async () => {
+  const { events, store, service, calls } = setup(
+    { distillRateLimitIntervalMs: 0 },
+    { stream: streamOf([{ type: "history", title: "游标失败", content: "事务应回滚", importance: 3 }]) }
+  );
+  const originalSetCursor = service.setDistillCursor.bind(service);
+  let failOnce = true;
+  service.setDistillCursor = (sessionId, lastSeq) => {
+    if (failOnce) {
+      failOnce = false;
+      throw new Error("simulated cursor write failure");
+    }
+    return originalSetCursor(sessionId, lastSeq);
+  };
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s-cursor-write-failure",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("游标写入失败也不能丢窗口", 1), { seq: 2, type: "turn/end" }]
+  };
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1);
+  assert.equal(store.count(), 0, "cursor failure must roll back the memory write");
+  assert.equal(store.getDistillCursor(session.id), undefined);
+  const failedAudit = service.listLlmAudits({ source: "autoSummarize" }).find(
+    (audit) => audit.error_message === "simulated cursor write failure"
+  );
+  assert.equal(failedAudit?.status, "error", "cursor failure must not be audited as success");
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 2, "the failed cursor window must be retryable");
+  assert.equal(store.count(), 1);
+  assert.equal(store.getDistillCursor(session.id).last_seq, 2);
+});
+
+test("falls back to the in-memory cursor when service lacks setDistillCursor", async () => {
+  // 旧版 service（#274 之前）没有持久化游标：缺方法必须降级为内存游标照常蒸馏，
+  // 而不是抛错打断每轮蒸馏。方法存在但抛错走的是上一条回滚用例，两者不可混淆。
+  const { events, store, service, calls } = setup(
+    { distillRateLimitIntervalMs: 0 },
+    { stream: streamOf([{ type: "history", title: "降级游标", content: "缺方法也能蒸馏", importance: 3 }]) }
+  );
+  delete service.setDistillCursor; // 模拟旧版 service：实例属性，直接删掉
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s-no-cursor-api",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("旧宿主没有游标接口", 1), { seq: 2, type: "turn/end" }]
+  };
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "distillation must still run without a persisted cursor");
+  assert.equal(store.count(), 1, "the memory itself must be saved");
+  assert.equal(store.getDistillCursor(session.id), undefined, "nothing may be persisted without the API");
+
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "the in-memory cursor must prevent re-distillation in this process");
+});
+
 test("uses summarizeProvider/summarizeModel config override when set", async () => {
   const { events, calls } = setup({
     summarizeProvider: "aliyun",