@modusensus/dsh-mneme 0.9.5 → 0.10.1

package/test/session-gate.test.js

@@ -0,0 +1,264 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Config } from "../src/config.js";
+import { createSessionGate } from "../src/session-gate.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSettings } from "../src/settings.js";
+import { createInjector } from "../src/inject.js";
+import { MEMORY_GUIDE_SECTION } from "../src/guide.js";
+import { createTools } from "../src/tools.js";
+import { createSummarizer } from "../src/summarize.js";
+
+test("session gate defaults off and gates subagents by the host's delegation marks", () => {
+  const defaults = Config({});
+  assert.equal(defaults.sessionGateEnabled, false);
+  assert.equal(defaults.sessionGateSubagents, true);
+  assert.deepEqual(defaults.sessionGateSessions, []);
+
+  const gate = createSessionGate({ sessionGateEnabled: true, sessionGateSubagents: true });
+  const sessions = [
+    { id: "header-origin", header: { origin: "subagent" } },
+    { id: "header-depth", header: { delegationDepth: 2 } },
+    { id: "header-both", header: { parentSession: "captain", origin: "subagent", delegationDepth: 1 } },
+    { id: "request-origin", requestHeader: () => ({ config: { origin: "subagent", delegationDepth: 1 } }) }
+  ];
+  for (const session of sessions) {
+    assert.equal(gate.isOff(session), true, session.id);
+  }
+
+  const firstEvent = { id: "first-event", header: { parentSession: "captain", origin: "subagent" } };
+  assert.equal(gate.isOff(firstEvent), true, "header match works before any session/event was observed");
+  gate.observe(firstEvent);
+  assert.equal(gate.isOff("first-event"), true, "observed child ids remain recognizable in log scans");
+});
+
+// 形状锁：`parentSession` 是「有父会话」，不是「是子代理」。dsh-session 的
+// sessions.fork() 给**主会话分支**也写 parentSession（且不写 origin / 不带
+// delegationDepth），把它当判据就会让用户 fork 出来的普通会话整体失忆。
+// 本机 641 个真实会话头实测：origin/delegationDepth 命中 455 个子代理、零漏检，
+// parentSession 对子代理识别零贡献、只多判出 3 个 fork 主会话（各有 74–136 条
+// 用户消息、694 次工具调用）。这条用例锁的就是那次误判不许回来。
+test("parentSession alone never gates: forked captain sessions stay fully enabled", () => {
+  const gate = createSessionGate({ sessionGateEnabled: true, sessionGateSubagents: true });
+  const forked = { id: "forked-captain", header: { parentSession: "captain", isSeeded: true, delegationDepth: 0 } };
+  assert.equal(gate.isOff(forked), false, "a fork of a captain session is still a captain session");
+  assert.equal(gate.isOff({ id: "flat-parent", parentSession: "captain" }), false);
+  assert.equal(gate.isOff({ id: "alias-parent", parentSessionId: "captain" }), false);
+  assert.equal(gate.isOff({ id: "request-parent", requestHeader: () => ({ config: { parentSession: "captain" } }) }), false);
+  gate.observe(forked);
+  assert.equal(gate.isOff("forked-captain"), false, "observing a non-child must not record it as one");
+});
+
+test("manual ids survive the subagent switch, master-off is inert, and config is read live", () => {
+  const cfg = { sessionGateEnabled: false, sessionGateSubagents: false, sessionGateSessions: ["manual"] };
+  const gate = createSessionGate(cfg);
+  const manual = { id: "manual" };
+  const child = { id: "child", header: { origin: "subagent" } };
+
+  assert.equal(gate.isOff(manual), false, "the master is the only opt-in");
+  cfg.sessionGateEnabled = true;
+  assert.equal(gate.isOff(manual), true, "manual id matches even when automatic child detection is off");
+  assert.equal(gate.isOff(child), false, "subagent switch independently controls automatic matching");
+  cfg.sessionGateSubagents = true;
+  assert.equal(gate.isOff(child), true, "the next call sees a live config change");
+  cfg.sessionGateEnabled = false;
+  assert.equal(gate.isOff(manual), false, "turning the master off restores normal behavior immediately");
+
+  // 复现 comment 6541389（#541）：上面刚把总开关关掉，若在这里直接断言
+  // doesNotThrow，isEnabled() 就先把调用挡回去了，id getter 那条保护路径
+  // 一次都不会执行——测的是「关掉时不出事」，不是「读不到 id 时不出事」。
+  // 所以先开总开关，再断言两件事：不抛，且被当成普通会话（false），
+  // 而不是被当成「id 为空所以放行」的巧合。
+  cfg.sessionGateEnabled = true;
+  const inaccessible = {};
+  Object.defineProperty(inaccessible, "id", { get() { throw new Error("host getter"); } });
+  assert.doesNotThrow(() => gate.isOff(inaccessible));
+  assert.equal(gate.isOff(inaccessible), false, "an unreadable id is an ordinary session, not a gated one");
+});
+
+// #539 原文：「子会话在首次 session/event 之前就可能组装上下文，故必须直接检查
+// 传入 session，不能只靠事件后记录 ID」。所以「拿不到 id」不能当作「不是无痕
+// 会话」——那一行早退正是这条要求最容易失守的地方（注入面在上下文组装期跑的
+// 就是这条路径）。手动名单仍然依赖 id，那是名单本身的形状，不是缺陷。
+test("a subagent session without a usable id is still gated", () => {
+  const gate = createSessionGate({ sessionGateEnabled: true, sessionGateSubagents: true });
+  assert.equal(gate.isOff({ header: { origin: "subagent" } }), true, "id-less subagent header");
+  assert.equal(gate.isOff({ header: { delegationDepth: 1 } }), true, "id-less delegation depth");
+  assert.equal(gate.isOff({ id: "", header: { origin: "subagent" } }), true, "empty id is the same as missing");
+  assert.equal(gate.isOff({}), false, "no id and no child mark is an ordinary session");
+  assert.equal(gate.isOff(null), false);
+  assert.equal(gate.isOff(undefined), false);
+  const offSwitch = createSessionGate({ sessionGateEnabled: true, sessionGateSubagents: false });
+  assert.equal(offSwitch.isOff({ header: { origin: "subagent" } }), false, "the subagent switch still wins");
+});
+
+// 记账表只服务「日志扫描拿得到 id、却解析不出头」这一条退路，所以它必须有界：
+// 长驻宿主跑上几百个子代理后只涨不落会把每个 id 永久留在内存里，而淘汰最旧的
+// 代价只是那一次日志过滤少认一个会话，活路径永远直接用会话对象判定。
+test("tracked child ids stay bounded and eviction only costs the log-scan fallback", () => {
+  const gate = createSessionGate({ sessionGateEnabled: true, sessionGateSubagents: true });
+  for (let i = 0; i < 600; i += 1) gate.observe({ id: `child-${i}`, header: { origin: "subagent" } });
+  assert.equal(gate.isOff("child-599"), true, "the newest child is still tracked");
+  assert.equal(gate.isOff("child-0"), false, "the oldest id was evicted instead of kept forever");
+  gate.observe({ id: "child-599", header: { origin: "subagent" } });
+  assert.equal(gate.isOff("child-599"), true, "re-observing the same id stays stable");
+});
+
+function injectionSetup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文", importance: 5 });
+  settings.setProfile("用户画像正文");
+  settings.setRules(["先给结论"]);
+  const contexts = [];
+  const sections = [];
+  const ctx = {
+    systemPrompt: {
+      context(definition) { contexts.push(definition); return () => {}; },
+      section(definition) { sections.push(definition); return () => {}; }
+    }
+  };
+  const gate = createSessionGate({
+    sessionGateEnabled: true,
+    sessionGateSubagents: true,
+    sessionGateSessions: ["private"]
+  });
+  createInjector(ctx, service, settings, { injectGuidanceEnabled: true }, null, gate);
+  return { store, contexts, sections, gate };
+}
+
+test("all system-prompt surfaces are empty for incognito and remain available to captain", () => {
+  const { contexts, sections, gate } = injectionSetup();
+  const memory = contexts.find((item) => item.name === "memory");
+  const userSettings = contexts.find((item) => item.name === "user-settings");
+  const guide = sections.find((item) => item.name === "memory-guide");
+  const privateContext = { agent: { session: { id: "private" } } };
+  const childContext = { agent: { session: { id: "worker", header: { parentSession: "captain", origin: "subagent" } } } };
+  const captainContext = { agent: { session: { id: "captain", header: { origin: "main" } } } };
+
+  assert.equal(memory.text(privateContext), "");
+  assert.equal(userSettings.text(privateContext), "");
+  assert.equal(guide.text(privateContext), "");
+  assert.equal(memory.text(childContext), "");
+  assert.equal(userSettings.text(childContext), "");
+  assert.equal(guide.text(childContext), "");
+
+  assert.match(memory.text(captainContext), /\[记忆库\]/);
+  assert.match(userSettings.text(captainContext), /用户画像正文/);
+  assert.equal(guide.text(captainContext), MEMORY_GUIDE_SECTION);
+  gate.observe(childContext.agent.session);
+  assert.equal(gate.isOff("worker"), true);
+});
+
+test("every registered memory tool rejects before side effects for an incognito session", async () => {
+  const store = createStore(":memory:");
+  const baseService = createService({ store, mirror: null, config: {} });
+  let serviceCalls = 0;
+  const service = new Proxy(baseService, {
+    get(target, key, receiver) {
+      const value = Reflect.get(target, key, receiver);
+      if (typeof value !== "function") return value;
+      return (...args) => {
+        serviceCalls += 1;
+        return value.apply(target, args);
+      };
+    }
+  });
+  const registered = [];
+  const registry = { register(tool) { registered.push(tool); return () => {}; } };
+  const gate = createSessionGate({ sessionGateEnabled: true, sessionGateSessions: ["private"] });
+  createTools({ tools: registry }, service, {}, null, gate);
+  const exec = { agent: { session: { id: "private" } } };
+
+  assert.ok(registered.length >= 11);
+  for (const tool of registered) {
+    await assert.rejects(tool.execute({}, exec), /incognito session/, tool.name);
+  }
+  assert.equal(serviceCalls, 0, "rejected calls do not reach memory service reads or writes");
+  assert.equal(store.count(), 0, "no memory rows were written through an executor");
+  assert.equal(store.db.prepare("SELECT COUNT(*) AS n FROM scope_state").get().n, 0, "set_scope_state also rejects before writing");
+
+  const captainSave = registered.find((tool) => tool.name === "memory_save");
+  const result = await captainSave.execute(
+    { type: "preference", title: "captain", content: "可用", importance: 4 },
+    { agent: { session: { id: "captain", header: { origin: "main" } } } }
+  );
+  assert.equal(result.action, "created", "normal captain tool use is unaffected");
+  assert.equal(store.count(), 1);
+  store.close();
+});
+
+test("retained tool executors use the latest gate after live registry reapply", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const registered = [];
+  const registry = { register(tool) { registered.push(tool); return () => {}; } };
+  const initialGate = createSessionGate({ sessionGateEnabled: true, sessionGateSessions: ["private"] });
+  createTools({ tools: registry }, service, {}, null, initialGate);
+  const retainedSave = registered.find((tool) => tool.name === "memory_save");
+  const privateExec = { agent: { session: { id: "private" } } };
+  const args = { type: "preference", title: "live gate", content: "check", importance: 4 };
+
+  await assert.rejects(retainedSave.execute(args, privateExec), /incognito session/);
+  const openGate = createSessionGate({ sessionGateEnabled: false });
+  createTools({ tools: registry }, service, {}, null, openGate);
+  assert.equal(registered.length, 11, "live reapply keeps the host's existing tool registrations");
+  assert.equal((await retainedSave.execute(args, privateExec)).action, "created", "off restores the original tool behavior");
+  const closedGate = createSessionGate({ sessionGateEnabled: true, sessionGateSessions: ["private"] });
+  createTools({ tools: registry }, service, {}, null, closedGate);
+  await assert.rejects(
+    retainedSave.execute({ ...args, content: "blocked" }, privateExec),
+    /incognito session/,
+    "a retained tool uses the gate from the latest live reapply"
+  );
+  assert.equal(store.count(), 1, "the re-applied gate still runs before any write");
+  store.close();
+});
+
+function summarySession(id, header = {}) {
+  return {
+    id,
+    header,
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "选型" }] } },
+      { type: "turn/end", seq: 2 }
+    ]
+  };
+}
+
+test("distillation skips incognito sessions before model or storage work", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const listeners = [];
+  const calls = [];
+  const ctx = {
+    on(name, handler) { listeners.push({ name, handler }); return () => {}; },
+    llm: {
+      stream() {
+        calls.push(true);
+        const output = JSON.stringify([{ type: "decision", title: "选择", content: "落库", importance: 4 }]);
+        return (async function* () {
+          yield { type: "block-start", block: { type: "text" } };
+          yield { type: "text-delta", delta: output };
+          yield { type: "block-end", block: { type: "text" } };
+          yield { type: "finish", kind: "ok" };
+        })();
+      }
+    }
+  };
+  const gate = createSessionGate({ sessionGateEnabled: true, sessionGateSessions: ["private"] });
+  const summarizer = createSummarizer(ctx, service, { autoSummarize: true, distillRateLimitIntervalMs: 0 }, {}, gate);
+  const handler = listeners.find((item) => item.name === "session/event").handler;
+
+  await handler(summarySession("private"), { type: "turn/end", seq: 2 });
+  assert.equal(calls.length, 0);
+  assert.equal(store.count(), 0);
+  await handler(summarySession("captain", { origin: "main" }), { type: "turn/end", seq: 2 });
+  assert.equal(calls.length, 1);
+  assert.equal(store.count(), 1, "captain still distills normally");
+  summarizer.dispose();
+  store.close();
+});

package/test/settings.test.js

@@ -186,6 +186,8 @@ test("feature flags accept the new boolean, string, url and enum keys", () => {
     "distillRecords.retentionDays": 30,
     bm25SearchEnabled: false,
     conflictFreezeEnabled: true,
+    sessionGateEnabled: true,
+    sessionGateSubagents: false,
     trustEpistemicWeighting: true,
     reflectionFailureTracking: false,
     dreamProvider: "  siliconflow  ",
@@ -205,6 +207,8 @@ test("feature flags accept the new boolean, string, url and enum keys", () => {
   assert.equal(flags.conflictFreezeEnabled, true);
   assert.equal(flags.trustEpistemicWeighting, true);
   assert.equal(flags.reflectionFailureTracking, false);
+  assert.equal(flags.sessionGateEnabled, true);
+  assert.equal(flags.sessionGateSubagents, false);
   assert.equal(flags.dreamProvider, "siliconflow", "string values are trimmed");
   assert.equal(flags.dreamModel, "deepseek-chat");
   assert.equal(flags.ollamaBaseUrl, "http://127.0.0.1:11434/");

package/test/sleep-action-set.test.js

@@ -74,10 +74,12 @@ test("issue#126 supersede: replay is idempotent (archived loser, single note)",
   store.close();
 });
 
-test("issue#126 differentiate: both entries survive and each carries the distinctions note", () => {
+test("issue#533 differentiate: both entries survive, bodies untouched, the pair lands in the ledger", () => {
   const { service, store } = setup();
   const a = makeMemory(service, "内网 SSH 端口", "内网走 22");
   const b = makeMemory(service, "外网 SSH 端口", "外网映射 2222");
+  // 两侧各自追加注记会让共享后缀把向量拉近——先记下原始正文，事后逐字节比对。
+  const before = { [a.id]: service.getById(a.id).content, [b.id]: service.getById(b.id).content };
   const snapshot = snapshotOf(store, a, b);
   const { applied } = applyDecisions(
     [{ action: "differentiate", ids: [a.id, b.id], distinctions: ["内网直连", "外网映射"] }],
@@ -87,10 +89,12 @@ test("issue#126 differentiate: both entries survive and each carries the distinc
   for (const m of [a, b]) {
     const after = service.getById(m.id);
     assert.equal(after.archived, false, "differentiate never archives");
-    assert.ok(after.content.includes("差异注记"), "each side gets the note");
+    assert.equal(after.content, before[m.id], "the body is left byte-identical");
+    assert.ok(!after.content.includes("差异注记"), "no note is written into the body");
   }
-  assert.ok(service.getById(a.id).content.includes("内网直连"), "note carries the distinctions");
-  assert.ok(service.getById(b.id).content.includes("外网映射"));
+  const record = service.findDifferentiatedPair(a.id, b.id);
+  assert.ok(record, "the verdict is recorded as a pair, not as body text");
+  assert.deepEqual(record.distinctions, ["内网直连", "外网映射"], "the model's distinctions survive for audit");
   store.close();
 });
 
@@ -369,20 +373,20 @@ test("issue#126r: buildOutcome records a disposition for the new actions", () =>
   assert.equal(outcome.byId.d2, "differentiated");
 });
 
-test("issue#126r: differentiate refreshes the cached vectors so the note reaches the index", async () => {
+test("issue#533r: differentiate leaves the cached vectors alone (nothing changed to re-embed)", async () => {
   const { service, store, vectorIndex } = setup();
   const { a, b } = seedPair(service, vectorIndex, "向量甲", "向量乙");
-  const before = vectorIndex.getEmbedding(a.id);
-  // 让嵌入器产出与旧向量不同的结果，便于确认"确实重嵌了"。
+  const beforeA = vectorIndex.getEmbedding(a.id);
+  const beforeB = vectorIndex.getEmbedding(b.id);
+  // 让嵌入器产出与旧向量不同的结果：若源码又悄悄重嵌，这里立刻会变。
   const fresh = { ...embedder, embedSingle: async () => [0, 1, 0] };
   service.setEmbedder(fresh);
   const ctx = captureCtx(JSON.stringify([
     { action: "differentiate", ids: [a.id, b.id], distinctions: ["甲面", "乙面"] }
   ]));
   await runSleep(ctx, service, baseConfig({ sleepActionSet: "full" }), ctx.logger, { embedder: fresh, vectorIndex }, null);
-  const after = vectorIndex.getEmbedding(a.id);
-  assert.notDeepEqual(after, before, "the cached vector was recomputed after the content note");
-  assert.deepEqual(after, [0, 1, 0], "it carries the fresh embedding");
+  assert.deepEqual(vectorIndex.getEmbedding(a.id), beforeA, "side A keeps its vector");
+  assert.deepEqual(vectorIndex.getEmbedding(b.id), beforeB, "side B keeps its vector");
   store.close();
 });
 
@@ -397,7 +401,8 @@ test("issue#126r: the full tier discovers cross-type pairs (differentiate would
   ]));
   const result = await runSleep(ctx, service, baseConfig({ sleepActionSet: "full" }), ctx.logger, { embedder, vectorIndex }, null);
   assert.equal(result.phases.conflicts.applied, 1, "the cross-type pair was adjudicated");
-  assert.ok(service.getById(proj.id).content.includes("差异注记"), "differentiate reached the cross-type pair");
+  assert.ok(service.findDifferentiatedPair(proj.id, pref.id), "differentiate reached the cross-type pair");
+  assert.equal(service.getById(proj.id).content, "项目用 8080", "the project body is untouched");
   store.close();
 });
 

package/test/sleep-catchup.test.js

@@ -0,0 +1,315 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+import { createSleepScheduler, runSleep } from "../src/dream/sleep.js";
+
+// Issue #529（续排）：本轮被预算截断（conflict 相位还有没进这一轮的对）且送出去的每一对
+// 都落地了时，调度器不该等满一个 sleepMinIntervalHours（默认 8h）才跑下一轮——池子没清空，
+// 剩下的对只能等到下一次到点，等于把"分批"变成"隔夜慢慢分批"。
+//
+// 这一组用例锁的是续排语义，防的回归是：
+//   ① 判据拿 status 反推 → 全判 keep 的轮次 applied 恒为 0、status 是 noop（永远到不了 ok），
+//      续排在最该追的场景静默失效；
+//   ② 只把冷却项改成 0、不在回调里补挂闹钟 → 续排只追一轮就断，剩下的对又回到隔夜等；
+//   ③ 不限制连击 → 用户持续写入时池子进得比追得快，变成永不落地的每五分钟一轮，
+//      而审计上每轮都"有产出"，肉眼很难发现；
+//   ④ 失败轮也追 → 与连败退避抢同一只闹钟，退避被自己踩空。
+
+const embedder = {
+  embedSingle: async () => [1, 0, 0],
+  embed: async () => [1, 0, 0],
+  schedule: () => {},
+  modelHash: "mock#1",
+  dimension: 3
+};
+
+function mockCtx(responder) {
+  let call = 0;
+  return {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        let reply = "[]";
+        if (options.purpose === "sleep-conflict") reply = responder(userText, ++call);
+        yield { type: "text-delta", index: 0, text: reply };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const vectorIndex = createVectorIndex({ store });
+  service.setEmbedder(embedder);
+  service.setVectorIndex(vectorIndex);
+  return { store, service, vectorIndex };
+}
+
+// 全部推到同一个方向附近：任意两条的 cosine 都 ≈ 1，findPotentialConflicts 生成 C(n,2) 对，
+// 去重阶段按相似度留下 n/2 对（每记忆至多一对）。
+function seedSimilarPairs(service, vectorIndex, n) {
+  for (let i = 0; i < n; i++) {
+    const m = service.saveWithDedupe({ type: "project", title: `主题${i}`, content: `内容${i}`, importance: 3 }).memory;
+    vectorIndex.saveEmbedding(m.id, [1, 0, 0]);
+  }
+}
+
+function baseConfig(overrides = {}) {
+  return {
+    sleepModeEnabled: true,
+    sleepIdleMinutes: 5,
+    sleepMinIntervalHours: 8,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,
+    sleepCompressDays: 90,
+    sleepPatternMinMemories: 100,
+    sleepMaxPatternPerRun: 3,
+    ...overrides
+  };
+}
+
+// 与 test/sleep-failure-backoff.test.js 同款房型：时钟与定时器全部注入。
+function makeHarness(overrides = {}) {
+  let nowMs = 10_000_000;
+  const timers = [];
+  let seq = 1;
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  let runs = 0;
+  let outcome = () => ({ ok: true, status: "noop" });
+  // 运行**期间**要发生的事（写入 / 耗时）——用来复现"跑完那一刻已挂着的表只剩几秒"。
+  let duringRun = null;
+  const sched = createSleepScheduler({
+    service,
+    config: { sleepModeEnabled: true, sleepIdleMinutes: 5, sleepMinIntervalHours: 1, ...overrides },
+    logger: { warn: () => {} },
+    onRun: async () => {
+      runs++;
+      if (duringRun) await duringRun();
+      return outcome();
+    },
+    now: () => nowMs,
+    setTimeoutFn: (fn, delay) => {
+      const t = { id: seq++, at: nowMs + delay, fn };
+      timers.push(t);
+      return t.id;
+    },
+    clearTimeoutFn: (id) => {
+      const i = timers.findIndex((t) => t.id === id);
+      if (i >= 0) timers.splice(i, 1);
+    }
+  });
+  const fireNext = async () => {
+    timers.sort((a, b) => a.at - b.at);
+    const t = timers.shift();
+    if (!t) throw new Error("no armed timer to fire");
+    nowMs = t.at;
+    await t.fn();
+  };
+  return {
+    sched,
+    store,
+    timers,
+    fireNext,
+    runs: () => runs,
+    now: () => nowMs,
+    setOutcome: (fn) => { outcome = fn; },
+    setDuringRun: (fn) => { duringRun = fn; },
+    write: () => { nowMs += 1000; sched.noteWrite(); },
+    advance: (ms) => { nowMs += ms; }
+  };
+}
+
+const MIN = 60_000;
+const HOUR = 3_600_000;
+
+test("issue#529 续排：clean + 还有没进这一轮的对 ⇒ 下一个闹钟钉在静默窗口，不等最小间隔", async () => {
+  const h = makeHarness();
+  h.setOutcome(() => ({ ok: false, status: "noop", catchup: true, backlog: true }));
+  h.write();
+  await h.fireNext();
+  assert.equal(h.runs(), 1, "静默到点起跑一轮");
+  assert.equal(h.timers.length, 1, "关键：追 backlog 的轮次跑完必须自己补挂闹钟（此前一条都不挂）");
+  const delay = h.timers[0].at - h.now();
+  assert.equal(delay, 5 * MIN + 1000, "下限是一个静默窗口，不是 1 秒也不是 1 小时");
+
+  await h.fireNext();
+  assert.equal(h.runs(), 2, "关键：闹钟真的起跑了第二轮（只补挂不起跑等于没追）");
+  h.store.close();
+});
+
+test("issue#529 续排：不 clean 时不追，间隔回到最小间隔", async () => {
+  const h = makeHarness();
+  h.setOutcome(() => ({ ok: true, status: "degraded", catchup: false, backlog: true }));
+  h.write();
+  await h.fireNext();
+  assert.equal(h.runs(), 1);
+  assert.equal(h.timers.length, 0, "有对没落地 ⇒ 不补挂短闹钟，等下一次写入重新起算");
+  const t = h.now();
+  assert.equal(h.sched.shouldRun(t + HOUR - 1), false, "冷却仍是基数间隔");
+  assert.equal(h.sched.shouldRun(t + HOUR), true);
+  h.store.close();
+});
+
+test("issue#529 续排：运行期间用户写入挂的表要在收尾时重挂，不能剩几秒就开下一批", async () => {
+  const h = makeHarness();
+  h.setOutcome(() => ({ ok: false, status: "noop", catchup: true, backlog: true }));
+  h.write();
+  // 运行一开始就按静默窗口挂好了表（at = 起跑时刻 + 5min + 1s）。
+  const armedAt = h.timers[0].at;
+  h.setDuringRun(async () => {
+    // 运行早期用户又写了一次：noteWrite 撤表重挂，新表从**那一刻**起算。
+    h.advance(MIN);
+    h.write();
+    // 这一轮本身跑了很久（LLM 往返 + 落库），早就越过那只表的到点时刻。真实环境里
+    // 这只表此刻已经可以立即触发——收尾若不重挂，下一批就是"几秒后开跑"，
+    // 「让库安静一个静默窗口再追」形同虚设。
+    h.advance(10 * MIN);
+  });
+  await h.fireNext();
+  assert.equal(h.runs(), 1);
+  assert.ok(h.now() > armedAt, "前置：这一轮确实跑过了原来那只表的到点时刻");
+  assert.equal(h.timers.length, 1, "收尾必须只剩（重挂的）一只表");
+  assert.equal(h.timers[0].at - h.now(), 5 * MIN + 1000, "关键：从**收尾这一刻**重算整一个静默窗口，不是沿用运行期挂的旧表");
+  h.store.close();
+});
+
+test("issue#529 续排：台账写入失败要让这一轮不 clean，不能每个静默窗口重问同一个冲突", async () => {
+  const { service, store, vectorIndex } = setup();
+  seedSimilarPairs(service, vectorIndex, 8);
+  // 留痕写不进去：这一对既没被记成"已审"，下一轮还会原样回到候选池。若仍判 clean，
+  // 续排会一个静默窗口问一次 LLM、直到连击上限，而审计上每轮都是干净的成功轮。
+  service.saveConflictReviewed = () => {
+    throw new Error("ledger unavailable");
+  };
+  const ctx = mockCtx(() => "[]");
+  const config = baseConfig({ sleepConflictMaxPairs: 1, sleepConflictMaxPairsPerRun: 2 });
+  const result = await runSleep(ctx, service, config, ctx.logger, { embedder, vectorIndex }, null);
+  assert.ok(result.phases.conflicts.ledgerFailed > 0, "前置：确实有留痕写入失败");
+  assert.equal(result.phases.conflicts.clean, false, "关键：没记上账就不算落地");
+  assert.equal(result.catchup, false, "不 clean ⇒ 不追下一批，回到正常节奏");
+  store.close();
+});
+
+test("issue#529 续排：失败轮不追（与连败退避互斥）", async () => {
+  const h = makeHarness({ sleepFailureBackoff: true });
+  h.setOutcome(() => ({ ok: false, status: "failed", catchup: true, backlog: true }));
+  h.write();
+  await h.fireNext();
+  // 失败本身仍然要补挂（#187：不补挂就永远等不到下一轮），但补的是**退避后的**长表，
+  // 不是续排那张静默窗口的短表——这才是"互斥"的可观测形态。
+  assert.equal(h.timers.length, 1, "失败轮按 #187 仍补挂一张表");
+  assert.equal(h.timers[0].at - h.now(), 2 * HOUR + 1000, "补的是 1h × 2^1 的退避表，不是 5 分钟的续排表");
+  const t = h.now();
+  assert.equal(h.sched.shouldRun(t + 2 * HOUR - 1), false, "退避仍然生效（1h 基数 × 2^1）");
+  assert.equal(h.sched.shouldRun(t + 2 * HOUR), true);
+  h.store.close();
+});
+
+test("issue#529 续排：连击到上限即收手，闹钟回到正常间隔", async () => {
+  const h = makeHarness();
+  // 用 runSleep 的真实返回形状：全判 keep 的一轮 status 是 noop，而 ok 只在
+  // ok/degraded 时为真——桩里写 ok:true 会让 maybeSchedule 走进与真实路径不同的分支
+  // （!ran 那条），于是「到顶后没有定时器」测的其实是桩的偏差，不是实现的行为。
+  h.setOutcome(() => ({ ok: false, status: "noop", catchup: true, backlog: true }));
+  h.write();
+  await h.fireNext();
+  // 24 是实现里的 CATCHUP_STREAK_CAP：每轮都 clean 但池子永远追不完时，必须自己刹住。
+  for (let i = 2; i <= 24; i++) {
+    assert.equal(h.timers.length, 1, `第 ${i} 轮之前应当有一只已挂好的闹钟`);
+    await h.fireNext();
+  }
+  assert.equal(h.runs(), 24, "连追 24 轮");
+  const t = h.now();
+  assert.equal(h.sched.shouldRun(t + 5 * MIN), false, "收手后回到最小间隔，不再按静默窗口放行");
+  assert.equal(h.sched.shouldRun(t + HOUR), true);
+  // 收手后既不能是「一直按静默窗口重排」（空转链），也不能是「什么都不挂」
+  // （#187：CD 到期成了没有监听者的时刻）。正确形态是回到正常的最小间隔。
+  assert.equal(h.timers.length, 1, "按 #187 补挂一张表，但不能是续排的短表");
+  assert.equal(h.timers[0].at - h.now(), HOUR + 1000, "补的是正常最小间隔，不是 5 分钟的续排表");
+  h.store.close();
+});
+
+test("issue#529 续排：全判 keep 的一轮 status=noop 仍是 clean，续排判据不依赖 status", async () => {
+  const { service, store, vectorIndex } = setup();
+  seedSimilarPairs(service, vectorIndex, 8);
+  const ctx = mockCtx(() => "[]");
+  const config = baseConfig({ sleepConflictMaxPairs: 1, sleepConflictMaxPairsPerRun: 2 });
+  const result = await runSleep(ctx, service, config, ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.phases.conflicts.applied, 0, "全判 keep ⇒ 没有任何落地");
+  assert.equal(result.phases.conflicts.status, "noop", "关键：这一轮永远到不了 ok（拿 status 当判据就死在这里）");
+  assert.ok(result.phases.conflicts.perRunSkipped > 0, "前置：本轮确实被预算截断");
+  assert.equal(result.phases.conflicts.clean, true, "送出去的每一对都留了台账 ⇒ clean");
+  assert.equal(result.catchup, true, "关键：noop 轮次也要能追");
+  assert.equal(result.backlog, true);
+  store.close();
+});
+
+test("issue#529 续排：坏批让这一轮不 clean，即使还有 backlog 也不追", async () => {
+  const { service, store, vectorIndex } = setup();
+  seedSimilarPairs(service, vectorIndex, 8);
+  let call = 0;
+  // 第一批吐空（stream 正常结束但没有 JSON 数组 ⇒ 这批 failed），后面的批正常。
+  const ctx = mockCtx(() => (++call === 1 ? "" : "[]"));
+  const config = baseConfig({ sleepConflictMaxPairs: 1, sleepConflictMaxPairsPerRun: 2 });
+  const result = await runSleep(ctx, service, config, ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.backlog, true, "前置：确实有对没进这一轮");
+  assert.equal(result.phases.conflicts.clean, false, "有批没走通 ⇒ 不 clean");
+  assert.equal(result.catchup, false, "关键：不 clean 时宁可少追一轮，也不要在失败状态里把间隔压到静默窗口");
+  store.close();
+});
+
+test("issue#529 续排：连击到顶收手之后，下一次正常触发要能重新起算（刹车不能变成永久闸）", async () => {
+  const h = makeHarness();
+  h.setOutcome(() => ({ ok: false, status: "noop", catchup: true, backlog: true }));
+  h.write();
+  await h.fireNext();
+  for (let i = 2; i <= 24; i++) await h.fireNext();
+  assert.equal(h.runs(), 24);
+  assert.equal(h.timers[0].at - h.now(), HOUR + 1000, "前置：到顶后已收手，闹钟回到正常间隔");
+
+  // 收手若只把 catchupWanted 置 false、**不把连击清零**，这个进程此后每一轮都会被同一道闸
+  // 挡下（streak 只增不减），"等下一个静默窗口重新起算"就成了一句空话。
+  h.write();
+  for (let i = 0; i < 5 && h.runs() < 25; i++) await h.fireNext();
+  assert.equal(h.runs(), 25, "关键：收手之后仍能被正常触发救回来");
+  assert.equal(h.timers.length, 1, "重新起算后又该补挂续排闹钟");
+  assert.equal(h.timers[0].at - h.now(), 5 * MIN + 1000, "补的是静默窗口的短表，说明连击已从 0 重新算");
+  h.store.close();
+});
+
+test("issue#529 续排：一轮抛错要把连击一并清零，不能把上一轮的进度带进下一次起算", async () => {
+  const h = makeHarness();
+  // 同上面两条：runSleep 在 status==="noop" 时给 ok:false，桩要照它写。
+  const clean = () => ({ ok: false, status: "noop", catchup: true, backlog: true });
+  h.setOutcome(clean);
+  h.write();
+  await h.fireNext();
+  // 先追到 23（上限 24 的前一格）：此时连击若不被清掉，下一轮 clean 就会立刻撞上限。
+  for (let i = 2; i <= 23; i++) await h.fireNext();
+  assert.equal(h.runs(), 23);
+
+  h.setOutcome(() => {
+    throw new Error("boom");
+  });
+  h.write();
+  await h.fireNext();
+  assert.equal(h.runs(), 24, "第 24 轮抛错");
+  assert.equal(h.timers.length, 1, "抛错仍按 #187 补挂一张表（补的是退避长表）");
+  assert.equal(h.timers[0].at - h.now(), HOUR + 1000, "抛错后回落到最小间隔，续排的短表不再挂");
+
+  // 关键：抛错回合若不把 catchupStreak 清零，接下来这一轮 clean 的连击会从 23 累到 24，
+  // 于是"刚被救回来"的进程立刻又被同一道闸挡下。
+  h.setOutcome(clean);
+  await h.fireNext();
+  assert.equal(h.runs(), 25, "抛错后的第一次干净轮次仍要真的跑");
+  assert.equal(h.timers.length, 1, "关键：连击已清零，这一轮又能挂上续排闹钟");
+  assert.equal(h.timers[0].at - h.now(), 5 * MIN + 1000);
+  h.store.close();
+});