@modusensus/dsh-mneme 0.4.1 → 0.4.2

package/test/sleep.test.js

@@ -1,401 +1,365 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { createSleepScheduler, runSleep } from "../src/dream/sleep.js";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
-import { createSleepScheduler, runSleep } from "../src/sleep.js";
-import { validateDecisions } from "../src/dream.js";
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: { sleepEnabled: true, ...config } });
-  return { store, service };
-}
-
-/** Backdate a memory's updated_at (last_accessed_at stays null → the sleep
- *  tiering reads updated_at as the reference time). */
-function backdate(store, id, days) {
-  const iso = new Date(Date.now() - days * 86400000).toISOString();
-  store.db.prepare("UPDATE memories SET updated_at = ? WHERE id = ?").run(iso, id);
-}
-
-/** Dummy embedder/vector index: every text maps to the same vector, so any two
- *  same-type memories score cosine 1.0 and become conflict candidates. */
-function fakeSemantic() {
-  return {
-    embedder: {
-      embed: async (texts) => texts.map(() => [1, 0, 0])
-    },
-    vectorIndex: {
-      getEmbedding: () => null,
-      saveEmbedding: () => {},
-      search: () => []
-    }
-  };
-}
-
-/** Deterministic sleep LLM stub: conflict prompt (user text contains 候选冲突)
- *  routes to onConflict, everything else to onPattern. */
-function sleepCtx({ onConflict = () => "[]", onPattern = () => "[]" } = {}) {
+import { createVectorIndex } from "../src/vector-index.js";
+
+// Mock embedder: every query maps to [1,0,0] so vectors are identical unless a
+// test pre-seeds a custom vector via vectorIndex.saveEmbedding.
+const embedder = {
+  embedSingle: async () => [1, 0, 0],
+  embed: async () => [1, 0, 0],
+  schedule: () => {},
+  modelHash: "mock#1",
+  dimension: 3
+};
+
+// Deterministic LLM: onConsolidation(userText) => decisions JSON string.
+function mockCtx(onConsolidation, selection = { provider: "mock", model: "sleep-model" }) {
   return {
     logger: { warn: () => {}, info: () => {} },
-    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    agentDefaultModel: { currentSelection: () => selection },
     llm: {
       async *stream(options) {
         const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        yield {
-          type: "text-delta",
-          index: 0,
-          text: userText.includes("候选冲突") ? onConflict(userText) : onPattern(userText)
-        };
+        const reply = onConsolidation ? onConsolidation(userText) : "[]";
+        yield { type: "text-delta", index: 0, text: reply };
         yield { type: "finish", reason: { kind: "stop" } };
       }
     }
   };
 }
 
+function baseConfig(overrides = {}) {
+  return {
+    sleepModeEnabled: true,
+    sleepIdleMinutes: 5,
+    sleepMinIntervalHours: 8,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,
+    sleepCompressDays: 90,
+    sleepPatternMinMemories: 100,
+    sleepMaxPatternPerRun: 3,
+    ...overrides
+  };
+}
+
+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 };
+}
+
+function makeMemory(service, title, content, type = "project") {
+  return service.saveWithDedupe({ type, title, content, importance: 3 }).memory;
+}
+
 // ------------------------------------------------------------ scheduler
 
-test("scheduler gates: idle + interval both required", async () => {
-  const { service } = setup();
-  let t = 1_000_000_000; // big enough that ±8h stays positive
-  let runs = 0;
-  const sleep = createSleepScheduler({
-    service,
-    config: { sleepEnabled: true, sleepIdleMinutes: 30, sleepMinIntervalHours: 8 },
-    onRun: async () => { runs++; return { ok: true }; },
-    now: () => t
+test("sleep: scheduler does not run when disabled", () => {
+  const { service, store } = setup();
+  const sched = createSleepScheduler({
+    service, config: baseConfig({ sleepModeEnabled: false }), logger: { warn: () => {} },
+    onRun: async () => ({ ok: true }),
+    now: () => 1_000_000, setTimeoutFn: () => 1, clearTimeoutFn: () => {}
   });
-  assert.equal(sleep.shouldRun(t + 1), false, "just wrote: not idle yet");
-  t += 30 * 60000 + 1000; // idle satisfied
-  assert.equal(sleep.shouldRun(t), true, "idle met + no prior run → runnable");
-  assert.equal(await sleep.maybeSchedule(), true);
-  assert.equal(runs, 1);
-  assert.equal(sleep.shouldRun(t), false, "interval gate: just ran");
-  assert.equal(await sleep.maybeSchedule(), false);
-  t += 8 * 3600000 + 1; // interval satisfied
-  assert.equal(sleep.shouldRun(t), true, "interval passed → runnable again");
+  assert.equal(sched.shouldRun(1_000_000 + 60 * 60000), false, "disabled never schedules");
+  store.close();
 });
 
-test("scheduler: noteWrite clears a pending idle timer and re-arms against the new window", () => {
-  const { service } = setup();
-  let t = 1_000_000_000;
-  let cleared = 0;
-  const timers = [];
-  const sleep = createSleepScheduler({
-    service,
-    config: { sleepEnabled: true, sleepIdleMinutes: 30, sleepMinIntervalHours: 8 },
+test("sleep: scheduler fires once idle window elapses", () => {
+  const { service, store } = setup();
+  const sched = createSleepScheduler({
+    service, config: baseConfig(), logger: { warn: () => {} },
     onRun: async () => ({ ok: true }),
-    now: () => t,
-    setTimeoutFn: (fn, ms) => { timers.push({ fn, ms }); return timers.length; },
-    clearTimeoutFn: () => { cleared++; }
+    now: () => 1_000_000, setTimeoutFn: () => 1, clearTimeoutFn: () => {}
   });
-  sleep.noteWrite();
-  assert.equal(timers.length, 1, "first write arms an idle timer");
-  assert.equal(timers[0].ms, 30 * 60000 + 1000, "armed against the full idle window");
-  t += 5 * 60000;
-  sleep.noteWrite();
-  assert.equal(cleared, 1, "stale timer cleared, not left to fire early");
-  assert.equal(timers.length, 2, "fresh timer armed on the write");
-  assert.equal(timers[1].ms, 30 * 60000 + 1000, "re-armed against a full idle window from the write");
+  assert.equal(sched.shouldRun(1_000_000 + 4 * 60000), false, "still within idle window");
+  assert.equal(sched.shouldRun(1_000_000 + 6 * 60000), true, "idle window elapsed");
+  store.close();
 });
 
-test("scheduler: noteWrite resets the idle clock", () => {
-  const { service } = setup();
-  let t = 1_000_000_000;
-  let runs = 0;
-  const sleep = createSleepScheduler({
-    service,
-    config: { sleepEnabled: true, sleepIdleMinutes: 30, sleepMinIntervalHours: 8 },
-    onRun: async () => { runs++; return { ok: true }; },
-    now: () => t
+test("sleep: noteWrite resets the idle clock (stale-timer guard)", () => {
+  const { service, store } = setup();
+  let now = 1_000_000;
+  const sched = createSleepScheduler({
+    service, config: baseConfig(), logger: { warn: () => {} },
+    onRun: async () => ({ ok: true }),
+    now: () => now, setTimeoutFn: () => 1, clearTimeoutFn: () => {}
   });
-  t += 30 * 60000 + 1000;
-  sleep.noteWrite(); // a write arrives: idle clock resets
-  assert.equal(sleep.shouldRun(t), false, "idle reset by noteWrite");
+  assert.equal(sched.shouldRun(now + 6 * 60000), true, "idle after 6min");
+  now = 1_000_000 + 6 * 60000;
+  sched.noteWrite();
+  assert.equal(sched.shouldRun(now), false, "write resets idle clock");
+  assert.equal(sched.shouldRun(now + 4 * 60000), false, "still idle-pending after reset");
+  assert.equal(sched.shouldRun(now + 6 * 60000), true, "idle again after fresh window");
+  store.close();
 });
 
-test("scheduler: disabled → never runs", () => {
-  const { service } = setup();
-  const sleep = createSleepScheduler({
-    service,
-    config: { sleepEnabled: false, sleepIdleMinutes: 0, sleepMinIntervalHours: 0 },
+test("sleep: first-ever run is not blocked by min interval (lastRunAt=0)", () => {
+  const { service, store } = setup();
+  const sched = createSleepScheduler({
+    service, config: baseConfig(), logger: { warn: () => {} },
     onRun: async () => ({ ok: true }),
-    now: () => 1_000_000
+    now: () => 1_000_000, setTimeoutFn: () => 1, clearTimeoutFn: () => {}
   });
-  assert.equal(sleep.shouldRun(), false);
+  assert.equal(sched.shouldRun(1_000_000 + 6 * 60000), true, "first run allowed");
+  store.close();
 });
 
-test("scheduler: onRun failure is swallowed, next window still opens", async () => {
-  const { service } = setup();
-  let t = 1_000_000_000;
-  let calls = 0;
-  const sleep = createSleepScheduler({
-    service,
-    config: { sleepEnabled: true, sleepIdleMinutes: 1, sleepMinIntervalHours: 1 },
-    onRun: async () => { calls++; if (calls === 1) throw new Error("boom"); return { ok: true }; },
-    now: () => t
+test("sleep: min interval blocks a re-run within the window, allows after", async () => {
+  const { service, store } = setup();
+  let now = 1_000_000;
+  const sched = createSleepScheduler({
+    service, config: baseConfig(), logger: { warn: () => {} },
+    onRun: async () => ({ ok: true }),
+    now: () => now, setTimeoutFn: () => 1, clearTimeoutFn: () => {}
   });
-  t += 60 * 60000;
-  assert.equal(await sleep.maybeSchedule(), false, "throwing run reports false");
-  assert.equal(calls, 1);
-  t += 3600000;
-  assert.equal(await sleep.maybeSchedule(), true, "next window still opens");
-  assert.equal(calls, 2);
+  now = 1_000_000 + 6 * 60000; // idle satisfied
+  const ok = await sched.maybeSchedule();
+  assert.equal(ok, true, "first run executed");
+  assert.equal(sched.shouldRun(now + 1 * 3600000), false, "1h later still inside 8h min interval");
+  assert.equal(sched.shouldRun(now + 9 * 3600000), true, "9h later past min interval → allowed");
+  store.close();
 });
 
-// ------------------------------------------------------------ demotion
-
-test("phase demotion: 30d → summary + _full_content, 90d → archived", async () => {
-  const { store, service } = setup({ sleepArchiveDays: 30, sleepDeepArchiveDays: 90 });
-  const long = "X".repeat(200);
-  const { memory: a } = service.saveWithDedupe({ type: "project", title: "A", content: long });
-  const { memory: b } = service.saveWithDedupe({ type: "project", title: "B", content: "b content" });
-  const { memory: c } = service.saveWithDedupe({ type: "project", title: "C", content: "c content" });
-  backdate(store, a.id, 40);
-  backdate(store, b.id, 100);
-  // c stays fresh
-  const ctx = sleepCtx();
-  const result = await runSleep(ctx, service, { sleepEnabled: true, sleepArchiveDays: 30, sleepDeepArchiveDays: 90, policyEpoch: 1 }, ctx.logger, fakeSemantic());
-  assert.ok(result.phases.demotion.demoted.includes(a.id), "40d unaccessed demoted");
-  assert.ok(result.phases.demotion.archived.includes(b.id), "100d unaccessed archived");
-  const aNow = store.getById(a.id);
-  assert.equal(aNow.content, `${"X".repeat(120)}…`, "content truncated to summary");
-  assert.equal(aNow._full_content, long, "full body preserved in _full_content");
-  assert.equal(store.getById(b.id).archived, true);
-  assert.equal(store.getById(c.id).archived, false);
-  assert.equal(store.getById(c.id)._full_content, undefined);
+test("sleep: maybeSchedule enqueues via service and serializes with other work", async () => {
+  const { service, store } = setup();
+  const config = baseConfig();
+  let now = 1_000_000;
+  let order = [];
+  const sched = createSleepScheduler({
+    service, config, logger: { warn: () => {} },
+    onRun: async () => { order.push("sleep"); return { ok: true, applied: 7 }; },
+    now: () => now, setTimeoutFn: () => 1, clearTimeoutFn: () => {}
+  });
+  now = 1_000_000 + 6 * 60000;
+  const p1 = service.enqueue(async () => { order.push("a"); });
+  const p2 = sched.maybeSchedule();
+  await p1;
+  const result = await p2;
+  assert.equal(result, true, "run result propagated through enqueue");
+  assert.deepEqual(order, ["a", "sleep"], "sleep run serialized behind queued work");
+  store.close();
 });
 
-test("demoteToSummary: minRefTimeMs skips freshly-accessed memories", () => {
-  const store = createStore(":memory:");
-  const a = store.save({ type: "project", title: "A", content: "x".repeat(200), importance: 3, tags: [], source: "test" });
-  const b = store.save({ type: "project", title: "B", content: "y".repeat(200), importance: 3, tags: [], source: "test" });
-  backdate(store, a.id, 40);
-  backdate(store, b.id, 40);
-  const cutoff = Date.now() - 30 * 86400000;
-  // b was touched after the cutoff → must NOT be demoted.
-  store.touchAccess(b.id);
-  const aAfter = store.demoteToSummary(a.id, "A summary", { minRefTimeMs: cutoff });
-  const bAfter = store.demoteToSummary(b.id, "B summary", { minRefTimeMs: cutoff });
-  assert.ok(aAfter._full_content, "old memory demoted");
-  assert.equal(bAfter._full_content, undefined, "freshly-accessed memory kept full");
+test("sleep: dispose clears the timer and prevents further runs", async () => {
+  const { service, store } = setup();
+  let cleared = false;
+  const sched = createSleepScheduler({
+    service, config: baseConfig(), logger: { warn: () => {} },
+    onRun: async () => ({ ok: true }),
+    now: () => 1_000_000,
+    setTimeoutFn: () => 1,
+    clearTimeoutFn: () => { cleared = true; }
+  });
+  sched.noteWrite(); // arm the idle timer so dispose has something to clear
+  assert.equal(cleared, false, "timer armed, not yet cleared");
+  await sched.dispose();
+  assert.equal(cleared, true, "idle timer cleared on dispose");
+  assert.equal(sched.shouldRun(1_000_000 + 6 * 60000), false, "disposed never runs");
+  store.close();
 });
 
-test("phase demotion: never double-wraps an already-demoted memory", async () => {
-  const { store, service } = setup({ sleepArchiveDays: 30, sleepDeepArchiveDays: 90 });
-  const { memory: a } = service.saveWithDedupe({ type: "project", title: "A", content: "y".repeat(200) });
-  backdate(store, a.id, 40);
-  const ctx = sleepCtx();
-  const first = await runSleep(ctx, service, { sleepEnabled: true, sleepArchiveDays: 30, sleepDeepArchiveDays: 90 }, ctx.logger, fakeSemantic());
-  const demoted1 = store.getById(a.id);
-  assert.equal(demoted1._full_content, "y".repeat(200));
-  const second = await runSleep(ctx, service, { sleepEnabled: true, sleepArchiveDays: 30, sleepDeepArchiveDays: 90 }, ctx.logger, fakeSemantic());
-  const demoted2 = store.getById(a.id);
-  assert.equal(demoted2.content, demoted1.content, "content unchanged on replay");
-  assert.equal(demoted2._full_content, "y".repeat(200), "_full_content not re-wrapped");
-  assert.equal(first.phases.demotion.demoted.length, 1);
-  assert.equal(second.phases.demotion.demoted.length, 0, "replay demotes nothing");
+// ------------------------------------------------------------ runSleep phases
+
+test("sleep: demotion shrinks cold memory to summary, keeps _full_content", async () => {
+  const { service, store } = setup();
+  const now = Date.now();
+  const m = makeMemory(service, "cold", "原内容".repeat(60), "project");
+  service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
+  const ctx = mockCtx(() => "[]");
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
+  const after = service.getById(m.id);
+  assert.equal(result.status, "ok");
+  assert.ok(after._full_content && after._full_content.length > 0, "full body preserved");
+  assert.ok(after.content.length < "原内容".repeat(60).length, "content shrank to summary");
+  assert.equal(after.archived, false, "not fully archived at 40 days");
+  store.close();
 });
 
-// ------------------------------------------------------------ patterns
-
-test("phase patterns: LLM mints pattern memories with evidence tags + sleep audit", async () => {
-  const { store, service } = setup({ sleepMaxPatterns: 5, policyEpoch: 1 });
-  const { memory: m1 } = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
-  const { memory: m2 } = service.saveWithDedupe({ type: "project", title: "插件", content: "mneme" });
-  const ctx = sleepCtx({
-    onPattern: (text) => {
-      const ids = [...text.matchAll(/id=([^\s|]+)/g)].map((x) => x[1]);
-      assert.ok(ids.includes(m1.id) && ids.includes(m2.id), "pattern prompt lists both memories");
-      return JSON.stringify([
-        { action: "create", type: "pattern", title: "中文偏好", content: "用户偏好中文内容", importance: 3, evidence: [m1.id] }
-      ]);
-    }
-  });
-  const result = await runSleep(ctx, service, { sleepEnabled: true, sleepMaxPatterns: 5, policyEpoch: 1 }, ctx.logger);
-  assert.equal(result.phases.patterns.status, "ok");
-  assert.equal(result.phases.patterns.applied, 1);
-  const patterns = store.list({ type: "pattern" });
-  assert.equal(patterns.length, 1);
-  assert.equal(patterns[0].title, "中文偏好");
-  assert.ok(patterns[0].tags.includes(`ev:${m1.id}`), "evidence ref stored as tag");
-  // sleep run is audited with run_type=sleep
-  const runs = store.listDreamRuns();
-  assert.ok(runs.some((r) => r.run_type === "sleep" && r.status === "ok"), "sleep audit row written");
+test("sleep: demotion fully archives memory past sleepCompressDays", async () => {
+  const { service, store } = setup();
+  const now = Date.now();
+  const m = makeMemory(service, "ancient", "很老的记忆", "project");
+  service.touchLastAccess(m.id, new Date(now - 100 * 86400000).toISOString());
+  const ctx = mockCtx(() => "[]");
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
+  const after = service.getById(m.id);
+  assert.equal(result.status, "ok");
+  assert.equal(after.archived, true, "past compress days → archived");
+  store.close();
 });
 
-test("phase patterns: invalid LLM output fails the phase but not the run", async () => {
-  const { store, service } = setup();
-  const { memory: m1 } = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
-  const ctx = sleepCtx({
-    onPattern: () => "[{ \"action\": \"create\", \"content\": \"no title\" }]"
-  });
-  const result = await runSleep(ctx, service, { sleepEnabled: true, sleepMaxPatterns: 5 }, ctx.logger);
-  assert.equal(result.phases.patterns.status, "failed");
-  assert.equal(result.status, "failed", "only substantive phase failed → failed");
-  assert.equal(store.list({ type: "pattern" }).length, 0, "nothing created on invalid output");
-  assert.equal(result.ok, false, "failed run reports ok=false");
+test("sleep: demoteToSummary minRefTimeMs skips a memory touched after snapshot", () => {
+  const { service, store } = setup();
+  const now = Date.now();
+  const m = makeMemory(service, "touched", "内容".repeat(60), "project");
+  service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
+  const snapshotCut = now - 1 * 86400000;
+  service.touchLastAccess(m.id, new Date(snapshotCut + 60000).toISOString());
+  const updated = service.demoteToSummary(m.id, "摘要", { minRefTimeMs: snapshotCut });
+  assert.equal(updated, undefined, "touched-after-snapshot memory is not demoted");
+  assert.equal(service.getById(m.id)._full_content ?? null, null, "no demotion happened");
+  store.close();
 });
 
-test("phase patterns: fabricated evidence ids are filtered out", async () => {
-  const { store, service } = setup({ sleepMaxPatterns: 5 });
-  const { memory: m1 } = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
-  const ctx = sleepCtx({
-    onPattern: () => JSON.stringify([
-      { action: "create", type: "pattern", title: "偏好", content: "中文内容偏好", importance: 3, evidence: [m1.id, "made-up-id-123"] }
-    ])
-  });
-  const result = await runSleep(ctx, service, { sleepEnabled: true, sleepMaxPatterns: 5 }, ctx.logger);
-  assert.equal(result.phases.patterns.status, "ok");
-  const patterns = store.list({ type: "pattern" });
-  assert.equal(patterns.length, 1);
-  assert.ok(patterns[0].tags.includes(`ev:${m1.id}`), "real evidence kept");
-  assert.ok(!patterns[0].tags.some((t) => t === "ev:made-up-id-123"), "fabricated evidence dropped");
+test("sleep: demotion demotes a memory still cold after snapshot", () => {
+  const { service, store } = setup();
+  const now = Date.now();
+  const m = makeMemory(service, "stillcold", "内容".repeat(60), "project");
+  service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
+  const snapshotCut = now - 1 * 86400000;
+  const updated = service.demoteToSummary(m.id, "摘要", { minRefTimeMs: snapshotCut });
+  assert.ok(updated && updated._full_content, "cold memory demoted to summary");
+  store.close();
 });
 
-// ------------------------------------------------------------ conflicts
-
-test("phase conflicts (freeze mode): conflicting pairs parked for review", async () => {
-  const { store, service } = setup({ conflictFreezeEnabled: true });
-  const { memory: w } = service.saveWithDedupe({ type: "decision", title: "截止", content: "8月20日" });
-  const { memory: l } = service.saveWithDedupe({ type: "decision", title: "截止旧", content: "8月15日" });
-  const ctx = sleepCtx();
-  const result = await runSleep(ctx, service, { sleepEnabled: true, conflictFreezeEnabled: true }, ctx.logger, fakeSemantic());
-  assert.equal(result.phases.conflicts.status, "ok");
-  assert.equal(result.phases.conflicts.frozen, 1);
-  assert.equal(service.countConflictPending(), 1, "conflict parked");
-  // no auto-arbitration in freeze mode
-  assert.equal(store.getById(l.id).archived, false);
+test("sleep: pattern discovery filters fabricated evidence ids", async () => {
+  const { service, store } = setup();
+  const a = makeMemory(service, "模式A", "反复出现的模式A", "project");
+  const b = makeMemory(service, "模式B", "反复出现的模式B", "project");
+  const ctx = mockCtx(() =>
+    JSON.stringify([
+      { action: "create", type: "pattern", title: "真模式", content: "从 a 和 b 提取", importance: 3, evidence: [a.id, "fake-zzz", b.id] }
+    ])
+  );
+  const result = await runSleep(ctx, service, baseConfig({ sleepPatternMinMemories: 10 }), ctx.logger, null, null);
+  assert.ok(!JSON.stringify(result.phases.patterns).includes("fake-zzz"), "fabricated evidence filtered before apply");
+  const pattern = service.all().find((x) => x.type === "pattern");
+  assert.ok(pattern, "pattern minted");
+  store.close();
 });
 
-test("phase conflicts (LLM): winner kept, loser archived", async () => {
-  const { store, service } = setup();
-  const { memory: w } = service.saveWithDedupe({ type: "decision", title: "截止", content: "8月20日" });
-  const { memory: l } = service.saveWithDedupe({ type: "decision", title: "截止旧", content: "8月15日" });
-  const ctx = sleepCtx({
-    onConflict: () => JSON.stringify([{ action: "conflict", winner: w.id, loser: l.id, reason: "更新" }])
-  });
-  const result = await runSleep(ctx, service, { sleepEnabled: true }, ctx.logger, fakeSemantic());
-  assert.equal(result.phases.conflicts.status, "ok");
-  assert.equal(result.phases.conflicts.applied, 1);
-  assert.equal(store.getById(l.id).archived, true, "loser archived");
-  assert.equal(store.getById(w.id).archived, false, "winner kept");
+test("sleep: relation completion links orphan entities co-occurring in a memory", async () => {
+  const { service, store } = setup();
+  const alpha = service.createEntity({ name: "Alpha", type: "project" });
+  const beta = service.createEntity({ name: "Beta", type: "project" });
+  makeMemory(service, "协作", "Alpha 与 Beta 一起干活", "project");
+  const ctx = mockCtx(() => "[]");
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
+  assert.equal(result.phases.relations.status, "ok", "relations phase ran");
+  const rels = service.getRelations(alpha.id);
+  assert.ok(rels.length >= 1, "orphan Alpha gained a relation");
+  assert.ok(rels.some((r) => r.to_entity === beta.id || r.from_entity === beta.id), "relation targets Beta");
+  store.close();
 });
 
-test("phase conflicts: skipped without a semantic embedder", async () => {
-  const { service } = setup();
-  const { memory: w } = service.saveWithDedupe({ type: "decision", title: "截止", content: "8月20日" });
-  const { memory: l } = service.saveWithDedupe({ type: "decision", title: "截止旧", content: "8月15日" });
-  const ctx = sleepCtx();
-  const result = await runSleep(ctx, service, { sleepEnabled: true }, ctx.logger, null);
-  assert.equal(result.phases.conflicts.status, "skipped");
+test("sleep: runSleep writes an audit receipt with run_type='sleep'", async () => {
+  const { service, store } = setup();
+  const now = Date.now();
+  const m = makeMemory(service, "cold", "内容".repeat(60), "project");
+  service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
+  const ctx = mockCtx(() => "[]");
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
+  const runs = service.listDreamRuns();
+  const last = runs[runs.length - 1];
+  assert.equal(last.run_type, "sleep", "audit row tagged sleep");
+  assert.equal(result.runId, last.id, "run id matches audit row");
+  assert.ok(typeof result.receipt === "string" && result.receipt.startsWith("dsh-mneme:run:"), "receipt is the audit string");
+  store.close();
 });
 
-test("phase conflicts: LLM omitting a pair defaults it to keep, phase survives", async () => {
-  const { store, service } = setup();
-  // 4 same-type memories → 2 deduped conflict pairs. The LLM only adjudicates
-  // the first pair; the second pair's ids must be defaulted to keep, not fail
-  // the whole phase with "missing from decisions".
-  const ids = [];
-  for (let i = 0; i < 4; i++) {
-    const { memory } = service.saveWithDedupe({ type: "decision", title: `D${i}`, content: `内容 ${i}` });
-    ids.push(memory.id);
-  }
-  const ctx = sleepCtx({
-    onConflict: (text) => {
-      const [first, second] = [...text.matchAll(/id=([^\s|]+)/g)].map((m) => m[1]);
-      assert.ok(first && second, "conflict prompt shows a pair");
-      return JSON.stringify([{ action: "conflict", winner: first, loser: second, reason: "矛盾" }]);
-    }
+test("sleep: a failing phase does not block the others (fail-safe)", async () => {
+  const { service, store } = setup();
+  service.setEmbedder({
+    embed: async () => { throw new Error("embed down"); },
+    embedSingle: async () => { throw new Error("embed down"); },
+    modelHash: "x", dimension: 3
   });
-  const result = await runSleep(ctx, service, { sleepEnabled: true }, ctx.logger, fakeSemantic());
-  assert.equal(result.phases.conflicts.status, "ok", "phase survives partial LLM coverage");
-  assert.equal(result.phases.conflicts.applied, 1, "only the adjudicated pair changed");
+  const now = Date.now();
+  const m = makeMemory(service, "cold", "内容".repeat(60), "project");
+  service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
+  const ctx = mockCtx(() => "[]");
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
+  assert.equal(result.phases.conflicts.status, "skipped", "conflicts phase degraded gracefully (no usable vectors)");
+  assert.equal(result.phases.demotion.status, "ok", "demotion still ran");
+  assert.equal(result.status, "ok", "overall run still ok despite conflicts degrading");
+  assert.ok(service.getById(m.id)._full_content, "cold memory still demoted despite conflicts failure");
+  store.close();
 });
 
-test("phase conflicts: empty LLM response → all pairs kept, phase is a noop not a failure", async () => {
-  const { store, service } = setup();
-  service.saveWithDedupe({ type: "decision", title: "D1", content: "内容 1" });
-  service.saveWithDedupe({ type: "decision", title: "D2", content: "内容 2" });
-  const ctx = sleepCtx({ onConflict: () => "[]" });
-  const result = await runSleep(ctx, service, { sleepEnabled: true }, ctx.logger, fakeSemantic());
-  assert.equal(result.phases.conflicts.status, "noop", "no decisions → nothing changed, not failed");
-  assert.equal(result.phases.conflicts.applied, 0);
+test("sleep: no LLM route skips LLM phases but demotion still runs", async () => {
+  const { service, store } = setup();
+  const now = Date.now();
+  const m = makeMemory(service, "cold", "内容".repeat(60), "project");
+  service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
+  const ctx = mockCtx(() => "[]", null); // currentSelection() → null, no route
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, null);
+  assert.equal(result.phases.conflicts.status, "skipped", "no llm route → conflicts skipped");
+  assert.equal(result.phases.patterns.status, "skipped", "no llm route → patterns skipped");
+  assert.equal(result.phases.demotion.status, "ok", "demotion is LLM-free and runs");
+  store.close();
 });
 
-// ------------------------------------------------------------ create validation
-
-test("validateDecisions: valid create passes with empty snapshot", () => {
-  const { ok, errors } = validateDecisions(
-    [{ action: "create", type: "pattern", title: "P", content: "c", importance: 3, evidence: ["x"] }],
-    new Map(),
-    { maxCreatePerRun: 5 }
-  );
-  assert.equal(ok, true, errors.join("; "));
-});
+// ------------------------------------------------------------ conflict strictness
 
-test("validateDecisions: create rejects missing title/content and over the cap", () => {
-  const empty = new Map();
-  const { ok: noTitle } = validateDecisions([{ action: "create", title: "", content: "c" }], empty);
-  assert.equal(noTitle, false);
-  const { ok: noContent } = validateDecisions([{ action: "create", title: "P" }], empty);
-  assert.equal(noContent, false);
-  const { ok: badType } = validateDecisions([{ action: "create", type: "explode", title: "P", content: "c" }], empty);
-  assert.equal(badType, false);
-  const cap = validateDecisions(
-    Array.from({ length: 6 }, (_, i) => ({ action: "create", title: `P${i}`, content: "c" })),
-    empty,
-    { maxCreatePerRun: 5 }
-  );
-  assert.equal(cap.ok, false, "exceeding maxCreatePerRun rejects");
-});
+function seedConflictPair(service, vectorIndex, sim) {
+  const a = makeMemory(service, "主题X", "内容A 关于主题X", "project");
+  const b = makeMemory(service, "主题X副本", "内容B 关于主题X", "project");
+  const sin = Math.sqrt(Math.max(0, 1 - sim * sim));
+  vectorIndex.saveEmbedding(a.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(b.id, [sim, sin, 0]);
+  return { a, b };
+}
 
-test("validateDecisions: create claims no ids, so it can't cover snapshot memories", () => {
-  const snap = new Map([["a", { id: "a", type: "preference", title: "t", content: "c", importance: 3, archived: false, forgotten: false }]]);
-  const { ok, errors } = validateDecisions([{ action: "create", title: "P", content: "c" }], snap);
-  assert.equal(ok, false);
-  assert.ok(errors.some((e) => e.includes("missing from decisions")), "create cannot claim snapshot ids");
+test("sleep: conflict strictness gentle ignores sim 0.88 pairs", async () => {
+  const { service, store, vectorIndex } = setup();
+  seedConflictPair(service, vectorIndex, 0.88);
+  const config = baseConfig({ sleepConflictStrictness: "gentle", conflictFreezeEnabled: true });
+  const ctx = mockCtx(() => "[]");
+  const result = await runSleep(ctx, service, config, ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.phases.conflicts.status, "skipped", "0.88 below gentle 0.92 → no conflicts");
+  store.close();
 });
 
-// ------------------------------------------------------------ touch wiring
-
-test("searchMemories touches last_accessed_at when sleep enabled", async () => {
-  const { store, service } = setup({ sleepEnabled: true });
-  const { memory } = service.saveWithDedupe({ type: "project", title: "插件", content: "y" });
-  assert.equal(store.getById(memory.id).last_accessed_at, undefined);
-  await service.searchMemories("插件");
-  assert.ok(store.getById(memory.id).last_accessed_at, "recalled memory touched");
+test("sleep: conflict strictness normal resolves sim 0.88 pairs", async () => {
+  const { service, store, vectorIndex } = setup();
+  seedConflictPair(service, vectorIndex, 0.88);
+  const config = baseConfig({ sleepConflictStrictness: "normal", conflictFreezeEnabled: true });
+  const ctx = mockCtx(() => "[]");
+  const result = await runSleep(ctx, service, config, ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.phases.conflicts.status, "ok", "0.88 above normal 0.85 → conflicts found");
+  assert.ok(result.phases.conflicts.frozen >= 1, "pairs frozen for review");
+  store.close();
 });
 
-test("searchMemories does NOT touch when sleep disabled", async () => {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  const { memory } = service.saveWithDedupe({ type: "project", title: "插件", content: "y" });
-  await service.searchMemories("插件");
-  assert.equal(store.getById(memory.id).last_accessed_at, undefined, "no touch when sleep off");
+test("sleep: conflict strictness aggressive adjudicates low-confidence pairs", async () => {
+  const { service, store, vectorIndex } = setup();
+  seedConflictPair(service, vectorIndex, 0.80);
+  const config = baseConfig({ sleepConflictStrictness: "aggressive", conflictFreezeEnabled: true });
+  const ctx = mockCtx(() => "[]");
+  const result = await runSleep(ctx, service, config, ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.phases.conflicts.status, "ok", "0.80 above aggressive 0.75 → conflicts found");
+  assert.ok(result.phases.conflicts.frozen >= 1, "pairs frozen");
+  store.close();
 });
 
-test("injectCandidates touches injected items when sleep enabled", () => {
-  const { store, service } = setup({ sleepEnabled: true });
-  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" });
-  const injected = service.injectCandidates();
-  assert.ok(injected.length >= 1);
-  assert.ok(store.getById(injected[0].id).last_accessed_at, "injected memory touched");
+test("sleep: conflict LLM arbitration applies winner/loser", async () => {
+  const { service, store, vectorIndex } = setup();
+  const { a, b } = seedConflictPair(service, vectorIndex, 1.0);
+  const ctx = mockCtx(() =>
+    JSON.stringify([{ action: "conflict", winner: a.id, loser: b.id, reason: "重复覆盖" }])
+  );
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.phases.conflicts.status, "ok", "conflict resolved");
+  assert.equal(service.getById(b.id).archived, true, "loser archived by arbitration");
+  store.close();
 });
 
-// ------------------------------------------------------------ whole-run
-
-test("runSleep with empty store: all phases skip, status noop", async () => {
-  const { store, service } = setup();
-  const ctx = sleepCtx();
-  const result = await runSleep(ctx, service, { sleepEnabled: true }, ctx.logger);
-  assert.equal(result.status, "noop");
-  assert.equal(result.ok, false);
-  assert.equal(result.phases.conflicts.status, "skipped");
-  assert.equal(result.phases.demotion.status, "noop");
-  assert.equal(result.phases.patterns.status, "skipped");
-  const runs = store.listDreamRuns();
-  assert.equal(runs.length, 1);
-  assert.equal(runs[0].run_type, "sleep");
-  assert.equal(runs[0].status, "noop");
+test("sleep: runSleep is abortable via signal between phases", async () => {
+  const { service, store } = setup();
+  const now = Date.now();
+  const m = makeMemory(service, "cold", "内容".repeat(60), "project");
+  service.touchLastAccess(m.id, new Date(now - 40 * 86400000).toISOString());
+  const ctrl = new AbortController();
+  ctrl.abort(); // pre-aborted
+  const ctx = mockCtx(() => "[]");
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, null, ctrl.signal);
+  assert.equal(result.phases.conflicts, undefined, "aborted before any phase ran");
+  store.close();
 });