@modusensus/dsh-mneme 0.8.4 → 0.8.6

package/test/inject-pools.test.js

@@ -0,0 +1,170 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+import { createTools } from "../src/tools.js";
+import { MEMORY_GUIDE_SECTION } from "../src/guide.js";
+
+// 回归（issue #249 第一批）：注入形态的两件事——
+// ①能力说明（injectGuidanceEnabled）：工具描述补判断指引 + order 150 一次性
+//   总则段（常驻段必须同会话稳定，不逐轮复读）；
+// ②B1 pin 池（pinnedInjectBudget）：约束/偏好不进相关性竞争与跨轮轮换、逐字
+//   保真、排在块内排序之前，且有独立小预算（不占 maxInjectedItems 名额）。
+// 两个键都默认关/零，默认档下注入块与改动前逐字节一致（本文件第一例锁这条）。
+
+const userMsg = (text) => ({
+  type: "user/message",
+  data: { source: { kind: "user" }, content: [{ type: "text", text }] }
+});
+
+function setup(over = {}) {
+  const store = createStore(":memory:");
+  // 同一份 config 同时交给 service 与 injector——生产里是同一个 cfg 对象，
+  // 而 pin 池的预算读取发生在 service 内、能力说明的开关读取发生在 injector 内。
+  const config = { maxInjectedItems: 3, importanceThreshold: 3, ...over };
+  const service = createService({ store, mirror: null, config });
+  const settings = createSettings(store.db);
+  const contexts = [];
+  const sections = [];
+  const ctx = {
+    systemPrompt: {
+      context(def) { contexts.push(def); return () => {}; },
+      section(def) { sections.push(def); return () => {}; }
+    }
+  };
+  createInjector(ctx, service, settings, config);
+  const text = (query = "") => contexts[0].text({
+    agent: { session: { id: "s1", snapshotEvents: () => (query ? [userMsg(query)] : []) } }
+  });
+  return { store, service, contexts, sections, text };
+}
+
+const types = (body) => [...body.matchAll(/- \[(\w+)\]/g)].map((m) => m[1]);
+const leadPreference = (body) => body.match(/- \[preference\] ([^（(]*)/)?.[1]?.trim();
+
+test("#249: default (pinned budget 0) keeps the legacy order and adds no annotation", () => {
+  const { service, text } = setup({});
+  service.saveWithDedupe({ type: "summary", title: "总览", content: "总览内容", importance: 5 });
+  service.saveWithDedupe({ type: "preference", title: "偏好A", content: "偏好内容", importance: 5 });
+  const body = text();
+  // 现状档位：蒸馏摘要(0) 先于偏好(1)。pin 关闭时不得出现「偏好前置」这一改动。
+  assert.deepEqual(types(body), ["summary", "preference"], "budget 0 → legacy priority order");
+  assert.ok(!body.includes("未展示"), "pool off → no overflow annotation");
+});
+
+test("#249: pinned entries lead the block and sit outside maxInjectedItems", () => {
+  const { service, text } = setup({ maxInjectedItems: 2, pinnedInjectBudget: 2 });
+  service.saveWithDedupe({ type: "summary", title: "总览", content: "总览内容", importance: 5 });
+  service.saveWithDedupe({ type: "preference", title: "偏好A", content: "偏好甲内容", importance: 5 });
+  service.saveWithDedupe({ type: "preference", title: "偏好B", content: "偏好乙内容", importance: 5 });
+  service.saveWithDedupe({ type: "decision", title: "决定甲", content: "决定内容", importance: 5 });
+  const body = text();
+  const seq = types(body);
+  assert.deepEqual(seq.slice(0, 2), ["preference", "preference"], "pin pool leads the block");
+  assert.deepEqual(seq.slice(2), ["summary", "decision"], "general slots still fill to maxItems");
+  assert.equal(seq.length, 4, "pinned entries do not consume maxInjectedItems slots");
+});
+
+test("#249: over-budget pinned entries are annotated with the truly hidden count", () => {
+  const { service, text } = setup({ maxInjectedItems: 1, pinnedInjectBudget: 1 });
+  for (let i = 0; i < 3; i++) {
+    service.saveWithDedupe({ type: "preference", title: `偏好${i}`, content: `第 ${i} 条偏好内容`, importance: 5 });
+  }
+  const body = text();
+  // 3 条同类里 pref0 被 pin、pref1 进了 general 槽（真的在块内），只有 pref2 没展示。
+  // 按 eligible - pinned 直接相减会把 pref1 也算成未展示——虚报（#266 评审实测）。
+  assert.ok(body.includes("偏好1"), "the over-budget one that made it into a general slot is really shown");
+  assert.ok(body.includes("另有 1 条未展示"), `annotation must carry the hidden count: ${body}`);
+  assert.ok(!body.includes("另有 2 条"), "no double counting");
+});
+
+test("#249: pinned entries are exempt from cross-turn rotation", () => {
+  const { service, text } = setup({ maxInjectedItems: 1, pinnedInjectBudget: 1, injectRotationTurns: 2 });
+  service.saveWithDedupe({ type: "preference", title: "偏好A", content: "偏好甲内容", importance: 5 });
+  service.saveWithDedupe({ type: "preference", title: "偏好B", content: "偏好乙内容", importance: 5 });
+  service.saveWithDedupe({ type: "decision", title: "决定甲", content: "决定内容", importance: 5 });
+  service.saveWithDedupe({ type: "decision", title: "决定乙", content: "另一决定", importance: 5 });
+  const first = leadPreference(text("第一个问题"));
+  const second = leadPreference(text("第二个问题"));
+  assert.ok(first, "pin entry is rendered in turn 1");
+  assert.equal(first, second, "pin stays at the block head across turns (not rotated away)");
+});
+
+test("#249: pinned content is verbatim below the hard ceiling", () => {
+  const { service, text } = setup({ maxInjectedItems: 1, pinnedInjectBudget: 1, injectContentMaxChars: 60 });
+  const long = "约束原文".repeat(60); // 240 chars, 4× the per-entry cap
+  service.saveWithDedupe({ type: "preference", title: "长偏好", content: long, importance: 5 });
+  const body = text();
+  assert.ok(body.includes(long), "240-char pinned body goes in verbatim (injectContentMaxChars does not apply)");
+  assert.ok(!body.includes("已截断"), "no truncation hint needed below the ceiling");
+});
+
+test("#249: pinned content still honours the hard ceiling and says so", () => {
+  const { service, text } = setup({ maxInjectedItems: 1, pinnedInjectBudget: 1 });
+  const huge = "超长约束".repeat(900); // 3600 chars
+  service.saveWithDedupe({ type: "preference", title: "超长偏好", content: huge, importance: 5 });
+  const body = text();
+  assert.ok(!body.includes(huge), "a runaway pinned entry cannot flood the standing block");
+  assert.ok(body.includes("已截断"), "the cut is reported, never silent");
+});
+
+test("#249: pinned content does not eat the general block budget", () => {
+  // 一条 pin 就够击穿 MAX_BLOCK（PINNED_CONTENT_MAX 2000 > MAX_BLOCK 1500）：pin
+  // 若照旧扣共享预算，budget 变负后同一轮的所有普通候选都会被压成标题行。
+  const { service, text } = setup({ maxInjectedItems: 2, pinnedInjectBudget: 1 });
+  const longPinned = "约束原文".repeat(470); // 1880 字符，仍在 2000 硬顶内（不带截断）
+  service.saveWithDedupe({ type: "preference", title: "长约束", content: longPinned, importance: 5 });
+  service.saveWithDedupe({ type: "summary", title: "总览", content: "总览正文必须带出来", importance: 5 });
+  const body = text();
+  assert.ok(body.includes(longPinned), "pin 逐字保真");
+  assert.ok(body.includes("总览正文必须带出来"), "普通候选照旧拿完整正文：pin 不占共享预算");
+});
+
+test("#249: capability guide is off by default, registered once when on", () => {
+  const off = setup({});
+  assert.equal(off.sections.length, 0, "default off → no prompt section registered");
+
+  const on = setup({ injectGuidanceEnabled: true });
+  assert.equal(on.sections.length, 1, "exactly one guide section");
+  assert.equal(on.sections[0].name, "memory-guide");
+  assert.equal(on.sections[0].order, 150, "插件指引段的既有 order 惯例");
+  assert.equal(on.sections[0].text, MEMORY_GUIDE_SECTION, "常量文本 → 同会话内稳定");
+  // 不可逆工具（memory_delete）的克制指引必须在场：这是全 guide 里唯一有数据
+  // 损失后果的一句，被误删掉的回归要能立刻转红。
+  assert.ok(MEMORY_GUIDE_SECTION.includes("memory_delete"), "guide keeps the irreversible-tool warning");
+  // memory_forget 的副作用面同样不能被写窄：工具描述是「挡注入 + 从检索与列表里
+  // 消失」，只写「只挡注入」会让模型低估它（#249 文案定稿时专门改过这一句）。
+  assert.ok(
+    MEMORY_GUIDE_SECTION.includes("memory_forget suppresses it from injection, search results and lists"),
+    "reversible-tools rule states memory_forget's full reach"
+  );
+  // 优先序那条不得让模型拿 memory_search 去核对当前指令/仓库：它只搜记忆库，
+  // 搜不到「现在」——把它写成验证手段会换来一轮无效查询 + 继续采信陈旧记忆。
+  assert.ok(
+    MEMORY_GUIDE_SECTION.includes("memory_search searches stored memories only"),
+    "precedence rule points at the instruction/repository, not at memory_search"
+  );
+  // 不逐轮复读：通则只出现在一次性段落，每轮内容块里不重复。
+  on.service.saveWithDedupe({ type: "preference", title: "偏好A", content: "偏好内容", importance: 5 });
+  assert.ok(!on.text().includes("[dsh-mneme memory]"), "guide text must not ride the per-turn block");
+});
+
+test("#249: capability guide extends only the judgement-heavy tool descriptions", () => {
+  const toolsFor = (flags) => {
+    const store = createStore(":memory:");
+    const service = createService({ store, mirror: null, config: {} });
+    const registered = [];
+    const ctx = { tools: { register(def) { registered.push(def); return () => {}; } } };
+    createTools(ctx, service, { ...flags }, null);
+    return new Map(registered.map((t) => [t.name, t.description]));
+  };
+  const off = toolsFor({});
+  const on = toolsFor({ injectGuidanceEnabled: true });
+  const changed = [...off.keys()].filter((name) => off.get(name) !== on.get(name)).sort();
+  assert.deepEqual(changed, ["memory_save", "memory_search"], "only the two 'when to use' tools gain guidance");
+  for (const name of changed) {
+    assert.ok(on.get(name).startsWith(off.get(name)), `${name}: guidance is appended, original text untouched`);
+  }
+});

package/test/inject-recall.test.js

@@ -0,0 +1,105 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// #217 增量（2026-09-19 拍板）：注入是曝光型访问事件，注入终选集落
+// mode='inject' 审计行（跟随 recallRecordDefault；空选不记）。留痕与消费
+// 解耦：heatEnabled=false 时行照写，touch（heat 消费侧）不发生。
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  // 与 index.js 相同的接线：审计记账 → recall_runs（best effort）
+  service.setRecallRecorder((recall) => {
+    store.saveRecallRun({
+      query: recall.query,
+      mode: recall.mode,
+      topK: recall.topK,
+      threshold: recall.threshold ?? null,
+      candidates: recall.candidates ?? [],
+      created_at: recall.createdAt
+    });
+  });
+  return { store, service };
+}
+
+const injectRow = (store) =>
+  store.listRecallRunsSince(new Date(Date.now() - 86400000).toISOString())
+    .rows.find((r) => r.mode === "inject");
+
+test("注入落账：终选集写一行 mode='inject'，candidates 为实际注入条目", () => {
+  const { store, service } = setup();
+  service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 });
+  service.saveWithDedupe({ type: "decision", title: "乙", content: "内容乙", importance: 3 });
+  const selected = service.injectCandidates({ maxItems: 5 });
+  assert.ok(selected.length >= 2);
+  const row = injectRow(store);
+  assert.ok(row, "注入应落一行审计");
+  assert.equal(row.mode, "inject");
+  // recall_runs.query 是 NOT NULL（store.js:61）：注入无查询词，用空串而非 null
+  assert.equal(row.query, "");
+  assert.deepEqual(row.candidates.map((c) => c.id), selected.map((m) => m.id));
+  store.close();
+});
+
+test("recallRecordDefault=false 不落账（与检索侧同门）", () => {
+  const { store, service } = setup({ recallRecordDefault: false });
+  service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 });
+  service.injectCandidates({ maxItems: 5 });
+  assert.equal(injectRow(store), undefined);
+  store.close();
+});
+
+test("空选不落账（没有访问发生）", () => {
+  const { store, service } = setup();
+  service.injectCandidates({ maxItems: 5 });
+  assert.equal(injectRow(store), undefined);
+  store.close();
+});
+
+test("留痕与消费解耦：heat 关闭时行照写、touch 不发生", () => {
+  // 显式 false = 生产 config 经 resolveConfig 后的默认值；touchRecalled 的
+  // 门控是 === false 才跳过（service.js:515）
+  const { store, service } = setup({ heatEnabled: false });
+  const m = service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 }).memory;
+  const before = store.getById(m.id).last_accessed_at ?? null;
+  service.injectCandidates({ maxItems: 5 });
+  assert.ok(injectRow(store), "heat 关闭时注入行仍照写");
+  assert.equal(store.getById(m.id).last_accessed_at ?? null, before, "touch 属 heat 消费侧，不发生");
+  store.close();
+});
+
+test("聚合：注入候选计入零曝光判定，注入口径单独报数", () => {
+  const { store, service } = setup();
+  service.saveWithDedupe({ type: "decision", title: "被注入", content: "被注入候选的内容说明", importance: 4 });
+  // importance 2 低于注入阈值 3：活跃但不进注入候选 → 零曝光 → 僵尸
+  service.saveWithDedupe({ type: "decision", title: "没动静", content: "低重要度不进注入候选的内容", importance: 2 });
+  // 回拨 created_at 避开 nowIso 同毫秒单调顶推的 1ms 豁免边界：刚写入的记忆
+  // 可能比 recallStats 的 Date.now() 晚 1ms，exemptDays:0 时会落进豁免桶
+  // （宁漏勿误伤），断言就变成看运气。回拨到 10 天前，判定确定性成立。
+  const old = new Date(Date.now() - 10 * 86400000).toISOString();
+  for (const m of store.all()) {
+    store.db.prepare("UPDATE memories SET created_at = ? WHERE id = ?").run(old, m.id);
+  }
+  service.injectCandidates({ maxItems: 5 });
+  const stats = service.recallStats({ windowDays: 30, exemptDays: 0 });
+  assert.equal(stats.injection.runs, 1);
+  assert.ok(stats.injection.injectedCount >= 1);
+  assert.equal(stats.zombie.activeCount, 2);
+  assert.equal(stats.zombie.zombieCount, 1, "被注入的不算僵尸（注入=曝光），未进候选的计僵尸");
+  store.close();
+});
+
+test("slotFillRate = 注入条数 / (轮数 × 槽位数)", () => {
+  const { store, service } = setup();
+  for (let i = 0; i < 3; i++) {
+    service.saveWithDedupe({ type: "decision", title: `t${i}`, content: "x", importance: 4 });
+  }
+  service.injectCandidates({ maxItems: 5 });
+  const stats = service.recallStats({ windowDays: 30, exemptDays: 0, maxInjectSlots: 4 });
+  assert.equal(stats.injection.runs, 1);
+  assert.equal(stats.injection.injectedCount, 3);
+  assert.equal(stats.injection.slotFillRate, 3 / 4);
+  store.close();
+});

package/test/inject.test.js

@@ -2,7 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
-import { createInjector } from "../src/inject.js";
+import { createInjector, getInjectionSnapshot } from "../src/inject.js";
 import { createSettings } from "../src/settings.js";
 
 function setup(over = {}) {
@@ -247,3 +247,37 @@ test("issue #162: escapePromptVariables=false passes {{...}} through verbatim",
   assert.ok(text.includes("{{挖空}}"), "raw braces preserved when escaping disabled");
   assert.ok(text.includes("{{hl|term}}"), "raw ASCII braces preserved when escaping disabled");
 });
+
+// --- Issue #179：注入预览快照（旁路缓存最近一帧组装） ---
+
+test("injection snapshot: records last assembly and clears on dispose (issue #179)", () => {
+  const { contexts, service, injector } = setup();
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "用户用中文交流", importance: 5 });
+  contexts[0].text({});
+  let snap = getInjectionSnapshot();
+  assert.ok(snap, "snapshot exists after first render");
+  assert.equal(snap.entries.length, 1, "entries mirror the injected candidates");
+  assert.equal(snap.entries[0].title, "语言");
+  assert.equal(snap.entries[0].type, "preference");
+  assert.ok(snap.entries[0].chars > 0, "per-entry char count recorded");
+  assert.ok(snap.totalChars > 0, "total char count recorded");
+  assert.ok(snap.totalChars >= snap.entries.reduce((a, e) => a + e.chars, 0), "total >= sum of entry contents");
+  assert.equal(snap.maxItems, 3, "effective maxItems recorded (adaptive off → base)");
+  assert.equal(snap.hotChars, 0, "no hot context in this mock");
+  const before = snap.at;
+  contexts[0].text({});
+  snap = getInjectionSnapshot();
+  assert.ok(snap.at >= before, "second render refreshes the snapshot");
+  injector();
+  assert.equal(getInjectionSnapshot(), null, "dispose clears the snapshot");
+});
+
+test("injection snapshot: records adaptive budget and rotation state (issue #179)", () => {
+  const { contexts, service } = setup({ injectUncertaintyAdaptive: true, injectRotationTurns: 2 });
+  service.saveWithDedupe({ type: "project", title: "记忆插件", content: "SQLite+Markdown", importance: 4 });
+  contexts[0].text({});
+  const snap = getInjectionSnapshot();
+  assert.equal(snap.adaptive, true, "adaptive flag recorded");
+  assert.equal(snap.rotated, 0, "no suppression on first render of a fresh session");
+  assert.equal(snap.scoped, null, "no scope when strict scope is off");
+});

package/test/lastrunat-persist.test.js

@@ -0,0 +1,101 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler } from "../src/dream.js";
+import { createSleepScheduler } from "../src/dream/sleep.js";
+
+// 回归（issue #89）：调度器的 lastRunAt 只活在内存里，进程重启即归零——
+// 最小间隔/冷却闸对新实例放行，重启后 autoDream/sleep 立即连发（Sample A/C 的
+// 根因）。修复 = 构造调度器时从 dream_runs 审计表恢复种子（store.lastDreamRunAt，
+// failed/degraded 也算 run，审计表本来就是逐 run 落库）。本文件锁三点：
+//   1. lastDreamRunAt 读回最近一次 run 的开跑时刻（含 run_type 过滤）；
+//   2. dream 调度器带种子构造后，重启场景下最小间隔闸门立即生效；
+//   3. sleep 调度器带种子构造后，冷却期内不起跑、且按剩余窗口重排不丢触发权。
+
+test("issue#89: store.lastDreamRunAt recovers the last run timestamp (with run_type filter)", () => {
+  const store = createStore(":memory:");
+  assert.equal(store.lastDreamRunAt(), 0, "empty trail → 0 (never ran)");
+  assert.equal(store.lastDreamRunAt("sleep"), 0);
+  store.saveDreamRun({ status: "ok", snapshot_hash: "h1", input_count: 1, receipt: "r", created_at: "2026-09-10T01:05:23.640Z", run_type: "auto" });
+  store.saveDreamRun({ status: "ok", snapshot_hash: "h2", input_count: 1, receipt: "r", created_at: "2026-09-09T20:00:00.000Z", run_type: "sleep" });
+  assert.equal(store.lastDreamRunAt(), Date.parse("2026-09-10T01:05:23.640Z"), "latest run regardless of type");
+  assert.equal(store.lastDreamRunAt("sleep"), Date.parse("2026-09-09T20:00:00.000Z"), "filtered by run_type");
+  assert.equal(store.lastDreamRunAt("auto"), Date.parse("2026-09-10T01:05:23.640Z"), "auto filter ignores sleep rows");
+  store.close();
+});
+
+test("issue#89: dream scheduler seeded from the audit trail — restart no longer bypasses the min interval", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  // 模拟上一进程刚跑过一轮（10ms 前开跑）并留下审计行，然后「重启」：
+  // minIntervalMs 取 1min——断言窗口远宽于用例执行时间，真实时钟抖动（调度、
+  // 慢盘）不会把 10ms 偏移推出闸门外造成间歇性假失败。
+  store.saveDreamRun({
+    status: "ok", snapshot_hash: "h", input_count: 1, receipt: "r",
+    created_at: new Date(Date.now() - 10).toISOString(), run_type: "auto"
+  });
+  const dream = createDreamScheduler({
+    onRun: async () => ({ ok: false, error: "llm failed" }),
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0, minIntervalMs: 60000,
+    lastRunAtSeed: store.lastDreamRunAt("auto"),
+    logger: { warn: () => {} }
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  // 无种子时这里会返回 true（旧缺陷：重启后立刻连发）；带种子必须被闸门拦下。
+  assert.equal(dream.maybeSchedule(service), false, "seeded gate blocks immediately after 'restart'");
+  store.close();
+});
+
+test("issue#89: sleep scheduler seeded — cooldown survives a restart", async () => {
+  let nowMs = 1_000_000;
+  const timers = [];
+  let seq = 1;
+  let runs = 0;
+  const lastRunAt = nowMs - 10 * 60_000; // 上一进程 10 分钟前跑过，CD 1h 还剩 50min
+  const sched = createSleepScheduler({
+    service: { enqueue: (fn) => fn() },
+    config: { sleepModeEnabled: true, sleepIdleMinutes: 5, sleepMinIntervalHours: 1 },
+    logger: { warn: () => {} },
+    onRun: async () => { runs++; return { ok: true }; },
+    now: () => nowMs,
+    lastRunAtSeed: lastRunAt,
+    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); }
+  });
+  nowMs += 1000;
+  sched.noteWrite(); // 挂 idle 闹钟
+  const idleTimer = timers[0];
+  assert.ok(idleTimer, "idle timer armed on write");
+  nowMs = idleTimer.at;
+  timers.length = 0;
+  await idleTimer.fn();
+  assert.equal(runs, 0, "restored cooldown blocks the run");
+  const rearm = timers[0];
+  assert.ok(rearm, "re-armed for the remaining cooldown window (not dropped, #187 semantics)");
+  assert.equal(rearm.at, lastRunAt + 3_600_000 + 1000, "re-arms at CD expiry (+1s guard)");
+});
+
+// --- CodeRabbit #291 findings 5/6：index.js 的 seed 注入是单行无分支接线，仓库
+// 没有插件级挂载 harness（apply 需要完整宿主 ctx），起全量挂载只为准两条断言
+// 不成比例——改为源码级锁：删掉 index.js 的对应注入行即红。import 用绝对路径，
+// 不依赖测试进程 CWD。
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+const indexSrc = readFileSync(fileURLToPath(new URL("../src/index.js", import.meta.url)), "utf8");
+
+test("issue#89: index.js wires the dream scheduler seed from the audit trail", () => {
+  assert.match(
+    indexSrc,
+    /lastRunAtSeed:\s*store\.lastDreamRunAt\("auto"\)/,
+    "dream scheduler must seed its min-interval gate from dream_runs (run_type='auto') — remove this line and restart-bypass returns"
+  );
+});
+
+test("issue#89: index.js wires the sleep scheduler seed from the audit trail", () => {
+  assert.match(
+    indexSrc,
+    /lastRunAtSeed:\s*store\.lastDreamRunAt\("sleep"\)/,
+    "sleep scheduler must seed its cooldown gate from dream_runs (run_type='sleep') — remove this line and restart-bypass returns"
+  );
+});