@modusensus/dsh-mneme 0.8.3 → 0.8.5

package/test/sleep-heat.test.js

@@ -1,125 +1,126 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { runSleep } from "../src/dream/sleep.js";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-// v0.7.0 待办③ sleep 降级热联合判定：
-//   降级需同时满足 时间窗 + heat<sleepHeatThreshold + importance<5 三条件；
-//   λ=0 的免疫类型 heat 恒 1.0 天然豁免；importance≥5 紧要记忆无论多冷都保留。
-// 默认 λ 下：history(0.006) 约 77 天后热值跌破 0.05，project(0.0008) 约 581 天，
-// decision(0.002) 约 232 天 —— 整体取向保守，突出"冷但重要"与"热但低值"都不降级。
-
-const DAY = 86400000;
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-function saveMemory(service, title, content, type = "project", importance = 3) {
-  return service.saveWithDedupe({ type, title, content, importance }).memory;
-}
-
-function sleepConfig(overrides = {}) {
-  return {
-    sleepModeEnabled: true,
-    // 本组测试全部验证 heat 保护语义 → 必须显式开启（v0.7.20 起默认关）。
-    heatEnabled: true,
-    sleepConflictStrictness: "normal",
-    sleepArchiveDays: 30,   // 30-90 天窗口 → 压缩为摘要
-    sleepCompressDays: 90,  // >=90 天 → 直接归档
-    sleepPatternMinMemories: 100, // 记忆数不足 → pattern 阶段跳过
-    sleepMaxPatternPerRun: 3,
-    ...overrides
-  };
-}
-
-function mockCtx() {
-  return {
-    logger: { warn: () => {}, info: () => {} },
-    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
-    llm: {
-      async *stream() {
-        yield { type: "text-delta", index: 0, text: "[]" };
-        yield { type: "finish", reason: { kind: "stop" } };
-      }
-    }
-  };
-}
-
-async function run(memories, service, config) {
-  const now = Date.now();
-  for (const [mem, daysAgo] of memories) {
-    service.touchLastAccess(mem.id, new Date(now - daysAgo * DAY).toISOString());
-  }
-  const result = await runSleep(mockCtx(), service, config, { warn: () => {}, info: () => {} }, null, null);
-  return result.phases?.["demotion"];
-}
-
-test("cold low-importance history past the compress tier archives (heat gate open)", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "久远的会话记录", "早期讨论内容", "history", 2);
-  const demotion = await run([[mem, 120]], service, sleepConfig());
-  assert.ok(demotion, "demotion phase ran");
-  assert.ok(demotion.archived.includes(mem.id), "120 天 ref + 热值≈0.03<0.05 + importance 2 → 归档");
-  assert.equal(store.getById(mem.id).archived, true);
-  store.close();
-});
-
-test("importance 5 protects a memory even when the heat is icy", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "关键决策", "不可丢失的重要结论", "decision", 5);
-  const demotion = await run([[mem, 400]], service, sleepConfig());
-  assert.ok(demotion, "demotion phase ran");
-  // decision λ=0.002, 400 天热值≈0.03<0.05，但 importance=5 → 保护，绝不降级。
-  assert.ok(!demotion.archived.includes(mem.id), "紧要记忆不被归档");
-  assert.ok(!demotion.demoted.includes(mem.id), "紧要记忆不被压缩");
-  assert.equal(store.getById(mem.id).archived, false);
-  store.close();
-});
-
-test("immune preference (λ=0, heat=1.0) is never demoted even when ancient", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "用户偏好", "喜欢简洁的总结", "preference", 3);
-  const demotion = await run([[mem, 400]], service, sleepConfig());
-  assert.ok(!demotion.archived.includes(mem.id), "免疫类型不归档");
-  assert.ok(!demotion.demoted.includes(mem.id), "免疫类型不压缩");
-  assert.equal(store.getById(mem.id).archived, false);
-  store.close();
-});
-
-test("slow-decay project stays heat-protected at the compress tier (λ=0.0008)", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "项目A", "慢衰减的进行中项目", "project", 2);
-  const demotion = await run([[mem, 100]], service, sleepConfig());
-  // 100 天已越过 90 天归档窗，但 project 热值≈0.28>0.05 → heat 闸拦下。
-  assert.ok(!demotion.archived.includes(mem.id), "慢衰减类型热值仍高 → 不归档");
-  assert.equal(store.getById(mem.id).archived, false);
-  store.close();
-});
-
-test("heatEnabled=false (v0.7.20 默认) 退回纯时间分层：importance 5 冷记忆也被归档", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "紧要决策", "v0.7.12 无 heat 保护语义", "decision", 5);
-  // 显式关 heat（默认值）→ phaseDemotion 不做热联合判定，纯时间分层。
-  const config = sleepConfig({ heatEnabled: false });
-  const demotion = await run([[mem, 400]], service, config);
-  assert.ok(demotion.archived.includes(mem.id), "heat 关 → 400 天冷记忆直接归档（无 importance 保护）");
-  assert.equal(store.getById(mem.id).archived, true);
-  store.close();
-});
-
-test("demote tier (30-90d) fires when the type's λ is cold enough", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "中期会话摘要", "可压缩的历史碎片", "history", 2);
-  // 调高 history 的 λ 到 0.05 → 40 天热值≈0.009<0.05，解锁 30-90 天压缩窗口。
-  const config = sleepConfig({ heatTypeDecay: { history: 0.05 } });
-  const demotion = await run([[mem, 40]], service, config);
-  assert.ok(!demotion.archived.includes(mem.id), "40 天未到归档线");
-  assert.ok(demotion.demoted.includes(mem.id), "热值足够冷 + importance 2 → 压缩为摘要");
-  const after = store.getById(mem.id);
-  assert.ok(after._full_content, "全文停放在 _full_content");
-  store.close();
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runSleep } from "../src/dream/sleep.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// v0.7.0 待办③ sleep 降级热联合判定：
+//   降级需同时满足 时间窗 + heat<sleepHeatThreshold + importance<5 三条件；
+//   λ=0 的免疫类型 heat 恒 1.0 天然豁免；importance≥5 紧要记忆无论多冷都保留。
+// 默认 λ 下（H=exp(-λΔt)，issue #218 广义指数）：history(0.006) 约 21 天后热值
+// 跌破 0.05，project(0.0008) 约 156 天，decision(0.002) 约 62 天 —— 整体取向
+// 保守，突出"冷但重要"与"热但低值"都不降级。
+
+const DAY = 86400000;
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+function saveMemory(service, title, content, type = "project", importance = 3) {
+  return service.saveWithDedupe({ type, title, content, importance }).memory;
+}
+
+function sleepConfig(overrides = {}) {
+  return {
+    sleepModeEnabled: true,
+    // 本组测试全部验证 heat 保护语义 → 必须显式开启（v0.7.20 起默认关）。
+    heatEnabled: true,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,   // 30-90 天窗口 → 压缩为摘要
+    sleepCompressDays: 90,  // >=90 天 → 直接归档
+    sleepPatternMinMemories: 100, // 记忆数不足 → pattern 阶段跳过
+    sleepMaxPatternPerRun: 3,
+    ...overrides
+  };
+}
+
+function mockCtx() {
+  return {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: "[]" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+async function run(memories, service, config) {
+  const now = Date.now();
+  for (const [mem, daysAgo] of memories) {
+    service.touchLastAccess(mem.id, new Date(now - daysAgo * DAY).toISOString());
+  }
+  const result = await runSleep(mockCtx(), service, config, { warn: () => {}, info: () => {} }, null, null);
+  return result.phases?.["demotion"];
+}
+
+test("cold low-importance history past the compress tier archives (heat gate open)", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "久远的会话记录", "早期讨论内容", "history", 2);
+  const demotion = await run([[mem, 120]], service, sleepConfig());
+  assert.ok(demotion, "demotion phase ran");
+  assert.ok(demotion.archived.includes(mem.id), "120 天 ref + 热值≈e^-17.3≈0<0.05 + importance 2 → 归档");
+  assert.equal(store.getById(mem.id).archived, true);
+  store.close();
+});
+
+test("importance 5 protects a memory even when the heat is icy", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "关键决策", "不可丢失的重要结论", "decision", 5);
+  const demotion = await run([[mem, 400]], service, sleepConfig());
+  assert.ok(demotion, "demotion phase ran");
+  // decision λ=0.002, 400 天热值≈e^-19.2≈0<0.05，但 importance=5 → 保护，绝不降级。
+  assert.ok(!demotion.archived.includes(mem.id), "紧要记忆不被归档");
+  assert.ok(!demotion.demoted.includes(mem.id), "紧要记忆不被压缩");
+  assert.equal(store.getById(mem.id).archived, false);
+  store.close();
+});
+
+test("immune preference (λ=0, heat=1.0) is never demoted even when ancient", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "用户偏好", "喜欢简洁的总结", "preference", 3);
+  const demotion = await run([[mem, 400]], service, sleepConfig());
+  assert.ok(!demotion.archived.includes(mem.id), "免疫类型不归档");
+  assert.ok(!demotion.demoted.includes(mem.id), "免疫类型不压缩");
+  assert.equal(store.getById(mem.id).archived, false);
+  store.close();
+});
+
+test("slow-decay project stays heat-protected at the compress tier (λ=0.0008)", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "项目A", "慢衰减的进行中项目", "project", 2);
+  const demotion = await run([[mem, 100]], service, sleepConfig());
+  // 100 天已越过 90 天归档窗，但 project 热值≈e^-1.92≈0.15>0.05 → heat 闸拦下。
+  assert.ok(!demotion.archived.includes(mem.id), "慢衰减类型热值仍高 → 不归档");
+  assert.equal(store.getById(mem.id).archived, false);
+  store.close();
+});
+
+test("heatEnabled=false (v0.7.20 默认) 退回纯时间分层：importance 5 冷记忆也被归档", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "紧要决策", "v0.7.12 无 heat 保护语义", "decision", 5);
+  // 显式关 heat（默认值）→ phaseDemotion 不做热联合判定，纯时间分层。
+  const config = sleepConfig({ heatEnabled: false });
+  const demotion = await run([[mem, 400]], service, config);
+  assert.ok(demotion.archived.includes(mem.id), "heat 关 → 400 天冷记忆直接归档（无 importance 保护）");
+  assert.equal(store.getById(mem.id).archived, true);
+  store.close();
+});
+
+test("demote tier (30-90d) fires when the type's λ is cold enough", async () => {
+  const { store, service } = setup();
+  const mem = saveMemory(service, "中期会话摘要", "可压缩的历史碎片", "history", 2);
+  // 调高 history 的 λ 到 0.05 → 40 天热值≈e^-48≈0<0.05，解锁 30-90 天压缩窗口。
+  const config = sleepConfig({ heatTypeDecay: { history: 0.05 } });
+  const demotion = await run([[mem, 40]], service, config);
+  assert.ok(!demotion.archived.includes(mem.id), "40 天未到归档线");
+  assert.ok(demotion.demoted.includes(mem.id), "热值足够冷 + importance 2 → 压缩为摘要");
+  const after = store.getById(mem.id);
+  assert.ok(after._full_content, "全文停放在 _full_content");
+  store.close();
+});

package/test/sleep-scheduler-rearm.test.js

@@ -1,89 +1,89 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createSleepScheduler } from "../src/dream/sleep.js";
-
-// 回归（issue #187）：idle 计时器到点时若撞上 sleepMinIntervalHours（CD）未满，
-// maybeSchedule 返回 false 后没有任何东西重排——armIdleTimer 的回调把返回值丢掉、
-// idleTimer 已被置 null，"CD 到期"成了没有监听者的时刻，库里攒着待清理的新写入
-// 却什么都不发生，要等用户恰好再写一次才救回来。两个断言方向：
-//   1. 撞 CD 后必须按剩余窗口重排，CD 到点自行起跑；
-//   2. 调度器构造时就该挂表——重启后零写入也应有闹钟（同族缺陷：无表可 firing）。
-// 全程注入时钟/定时器，不依赖真实等待。
-
-function makeHarness(overrides = {}) {
-  let nowMs = 1_000_000;
-  const timers = [];
-  let seq = 1;
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  let runs = 0;
-  const sched = createSleepScheduler({
-    service,
-    config: { sleepModeEnabled: true, sleepIdleMinutes: 5, sleepMinIntervalHours: 1, ...overrides },
-    logger: { warn: () => {} },
-    onRun: async () => { runs++; return { ok: true }; },
-    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,
-    write: () => { nowMs += 1000; sched.noteWrite(); }
-  };
-}
-
-test("sleep #187: CD collision re-arms a timer instead of dropping the round", async () => {
-  const h = makeHarness();
-  h.write();
-  await h.fireNext();
-  assert.equal(h.runs(), 1, "first run fires after the idle window");
-  const firstRunAt = h.now();
-
-  h.write(); // 落在 CD 窗口内的写入（默认 8h 时几乎必中）
-  await h.fireNext(); // idle 到点 → CD 未满 → 修复前：整轮被静默丢弃
-  assert.ok(h.timers.length > 0, "a timer must be re-armed after the CD collision");
-  await h.fireNext(); // 重排的表 → CD 到点 → 自行起跑
-  assert.equal(h.runs(), 2, "second run fires on its own at the CD boundary");
-  assert.ok(
-    h.now() >= firstRunAt + 3_600_000,
-    `second run must wait out the full min interval (fired at +${h.now() - firstRunAt}ms)`
-  );
-  h.store.close();
-});
-
-test("sleep #187: scheduler arms its first timer at construction (no write needed)", async () => {
-  const h = makeHarness();
-  assert.equal(h.timers.length, 1, "construction arms the idle timer");
-  await h.fireNext();
-  assert.equal(h.runs(), 1, "a quiet boot still reaches its first sleep cycle");
-  h.store.close();
-});
-
-test("sleep #187: dispose cancels the construction-armed timer", async () => {
-  const h = makeHarness();
-  await h.sched.dispose();
-  assert.equal(h.timers.length, 0, "dispose clears the armed timer");
-  h.store.close();
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSleepScheduler } from "../src/dream/sleep.js";
+
+// 回归（issue #187）：idle 计时器到点时若撞上 sleepMinIntervalHours（CD）未满，
+// maybeSchedule 返回 false 后没有任何东西重排——armIdleTimer 的回调把返回值丢掉、
+// idleTimer 已被置 null，"CD 到期"成了没有监听者的时刻，库里攒着待清理的新写入
+// 却什么都不发生，要等用户恰好再写一次才救回来。两个断言方向：
+//   1. 撞 CD 后必须按剩余窗口重排，CD 到点自行起跑；
+//   2. 调度器构造时就该挂表——重启后零写入也应有闹钟（同族缺陷：无表可 firing）。
+// 全程注入时钟/定时器，不依赖真实等待。
+
+function makeHarness(overrides = {}) {
+  let nowMs = 1_000_000;
+  const timers = [];
+  let seq = 1;
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  let runs = 0;
+  const sched = createSleepScheduler({
+    service,
+    config: { sleepModeEnabled: true, sleepIdleMinutes: 5, sleepMinIntervalHours: 1, ...overrides },
+    logger: { warn: () => {} },
+    onRun: async () => { runs++; return { ok: true }; },
+    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,
+    write: () => { nowMs += 1000; sched.noteWrite(); }
+  };
+}
+
+test("sleep #187: CD collision re-arms a timer instead of dropping the round", async () => {
+  const h = makeHarness();
+  h.write();
+  await h.fireNext();
+  assert.equal(h.runs(), 1, "first run fires after the idle window");
+  const firstRunAt = h.now();
+
+  h.write(); // 落在 CD 窗口内的写入（默认 8h 时几乎必中）
+  await h.fireNext(); // idle 到点 → CD 未满 → 修复前：整轮被静默丢弃
+  assert.ok(h.timers.length > 0, "a timer must be re-armed after the CD collision");
+  await h.fireNext(); // 重排的表 → CD 到点 → 自行起跑
+  assert.equal(h.runs(), 2, "second run fires on its own at the CD boundary");
+  assert.ok(
+    h.now() >= firstRunAt + 3_600_000,
+    `second run must wait out the full min interval (fired at +${h.now() - firstRunAt}ms)`
+  );
+  h.store.close();
+});
+
+test("sleep #187: scheduler arms its first timer at construction (no write needed)", async () => {
+  const h = makeHarness();
+  assert.equal(h.timers.length, 1, "construction arms the idle timer");
+  await h.fireNext();
+  assert.equal(h.runs(), 1, "a quiet boot still reaches its first sleep cycle");
+  h.store.close();
+});
+
+test("sleep #187: dispose cancels the construction-armed timer", async () => {
+  const h = makeHarness();
+  await h.sched.dispose();
+  assert.equal(h.timers.length, 0, "dispose clears the armed timer");
+  h.store.close();
+});