@modusensus/dsh-mneme 0.6.11 → 0.7.1

package/{test → dsh-mneme/test}/api.test.js

@@ -29,8 +29,10 @@ function req(path, method = "GET", body = null) {
 
 function setup(embedder, apiToken = "") {
   const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
   const settings = createSettings(store.db);
+  // settings is threaded into the service so the /config endpoint reports the
+  // effective settings-over-config tag toggles (issue #31).
+  const service = createService({ store, mirror: null, config: {}, settings });
   const commands = {
     add: (def) => settings.addCommand(def),
     remove: (id) => settings.removeCommand(id),
@@ -554,7 +556,9 @@ test("GET/PUT /api/dsh-mneme/config round-trips autoTag switches", async () => {
   const res1 = new FakeRes();
   await route.handler(req("/api/dsh-mneme/config"), res1);
   assert.equal(res1.statusCode, 200);
-  assert.deepEqual(JSON.parse(res1.body).config, { autoTagEnabled: false, manualTagEnabled: false });
+  // unset → effective config falls back to plugin-config defaults:
+  // autoTagEnabled=false, manualTagEnabled=true (issue #31 default unification)
+  assert.deepEqual(JSON.parse(res1.body).config, { autoTagEnabled: false, manualTagEnabled: true });
   const res2 = new FakeRes();
   await route.handler(req("/api/dsh-mneme/config", "PUT", { autoTagEnabled: true, manualTagEnabled: false }), res2);
   assert.equal(res2.statusCode, 200);
@@ -590,5 +594,8 @@ test("PUT /api/dsh-mneme/config supports partial update", async () => {
   const res = new FakeRes();
   await route.handler(req("/api/dsh-mneme/config", "PUT", { autoTagEnabled: true }), res);
   assert.equal(res.statusCode, 200);
-  assert.deepEqual(JSON.parse(res.body).config, { autoTagEnabled: true, manualTagEnabled: false });
+  // Partial PUT only stores autoTagEnabled; manualTagEnabled stays unset and
+  // falls back to the plugin-config default (true) — a lone autoTag toggle must
+  // never silently disable manual tagging (issue #31).
+  assert.deepEqual(JSON.parse(res.body).config, { autoTagEnabled: true, manualTagEnabled: true });
 });

package/{test → dsh-mneme/test}/graph-api.test.js

@@ -173,3 +173,37 @@ test("ego 2-hop over 100+ nodes stays under 50ms (spec §7)", async () => {
   assert.ok(data.edges.length > 0);
   assert.ok(ms < 50, `2-hop query took ${ms.toFixed(1)}ms, spec budget is 50ms`);
 });
+
+test("ego node heat projects from linked memory heat (v0.7.0)", async () => {
+  const { routes, service } = setup();
+  const mem = service.saveWithDedupe({ type: "history", title: "test", content: "test entity heat", importance: 3 });
+  const entity = service.createEntity({ name: "E", type: "project" });
+  service.saveRelation({ from_entity: entity.id, to_entity: entity.id, relation_type: "evidence", memory_id: mem.memory.id });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/semantic/graph/ego");
+  assert.ok(route, "ego route exists");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=E"), res);
+  const data = JSON.parse(res.body);
+  const node = data.nodes.find((n) => n.name === "E");
+  assert.ok(typeof node.heat === "number" && node.heat >= 0 && node.heat <= 1, "entity node has a heat value");
+  assert.ok(Math.abs(node.heat - 1) < 0.01, "fresh memory -> heat ~1.0 -> entity heat ~1.0");
+});
+
+test("ego node heat is null when heatEnabled=false (v0.7.0)", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { heatEnabled: false } });
+  const settings = createSettings(store.db);
+  const commands = { add: () => {}, remove: () => {}, list: () => [] };
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, service, settings, commands, null, undefined, "");
+  const mem = service.saveWithDedupe({ type: "history", title: "关联记忆", content: "实体关联", importance: 3 });
+  const entity = service.createEntity({ name: "F", type: "project" });
+  service.saveRelation({ from_entity: entity.id, to_entity: entity.id, relation_type: "evidence", memory_id: mem.memory.id });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/semantic/graph/ego");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=F"), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.nodes.find((n) => n.name === "F").heat, null, "heat disabled → entity heat is null");
+  store.close();
+});

package/dsh-mneme/test/heat.test.js

@@ -0,0 +1,148 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  computeHeat,
+  buildHeatSignals,
+  TYPE_DECAY_DEFAULTS,
+} from '../src/heat.js';
+
+const HOUR = 3600000;
+
+describe('heat.js', () => {
+  test('未知类型使用默认 λ=0.002；72h 后 heat < 1 且 > 0.8，并随 Δt 单调递减', () => {
+    const now = Date.now();
+    const base = { type: 'episodic', last_accessed_at: now - 72 * HOUR };
+
+    const heat72 = computeHeat(base, now, {});
+    const heat144 = computeHeat(
+      { ...base, last_accessed_at: now - 144 * HOUR },
+      now,
+      {}
+    );
+
+    assert(heat72 < 1.0, '72h 后热度应小于 1');
+    assert(heat72 > 0.8, '72h 后热度应仍大于 0.8');
+    assert(heat144 < heat72, 'Δt 越大，热度应越低');
+  });
+
+  test('λ=0 的免疫类型任意 Δt 返回 1.0', () => {
+    const now = Date.now();
+    const config = { heatTypeDecay: { preference: 0 } };
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'preference', last_accessed_at: now - 999 * 24 * HOUR },
+        now,
+        config
+      ),
+      1.0
+    );
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'pattern', last_accessed_at: now - 365 * 24 * HOUR },
+        now,
+        { heatTypeDecay: TYPE_DECAY_DEFAULTS }
+      ),
+      1.0
+    );
+  });
+
+  test('ref 优先使用 last_accessed_at，缺失退 created_at，皆无返回 1.0', () => {
+    const now = Date.now();
+    const config = {
+      heatTypeDecay: { decision: 0.002 },
+      heatGlobalAlpha: 1.0,
+    };
+
+    const withLast = computeHeat(
+      {
+        type: 'decision',
+        last_accessed_at: now - 24 * HOUR,
+        created_at: now - 100 * HOUR,
+      },
+      now,
+      config
+    );
+
+    const withCreated = computeHeat(
+      { type: 'decision', created_at: now - 24 * HOUR },
+      now,
+      config
+    );
+
+    assert(withLast < 1.0);
+    assert.strictEqual(withLast, withCreated);
+
+    const noRef = computeHeat({ type: 'decision' }, now, config);
+    assert.strictEqual(noRef, 1.0);
+  });
+
+  test('非法 ref 或 now < ref 时返回 1.0', () => {
+    const now = Date.now();
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'decision', last_accessed_at: 'not-a-date' },
+        now,
+        {}
+      ),
+      1.0
+    );
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'decision', last_accessed_at: now + 1000 },
+        now,
+        {}
+      ),
+      1.0
+    );
+  });
+
+  test('α 越大衰减越快（同一 Δt 下 α=2 的热度低于 α=1）', () => {
+    const now = Date.now();
+    const base = {
+      type: 'decision',
+      last_accessed_at: now - 7 * 24 * HOUR,
+    };
+
+    const h1 = computeHeat(base, now, {
+      heatTypeDecay: { decision: 0.002 },
+      heatGlobalAlpha: 1.0,
+    });
+
+    const h2 = computeHeat(base, now, {
+      heatTypeDecay: { decision: 0.002 },
+      heatGlobalAlpha: 2.0,
+    });
+
+    assert(h2 < h1, 'α 更大时，同一 Δt 热度应更低');
+  });
+
+  test('buildHeatSignals 返回字段齐全且 deltaHours 正确', () => {
+    const now = 1000000000000; // 固定毫秒时间戳
+    const ref = now - 12 * HOUR;
+
+    const signals = buildHeatSignals(
+      { type: 'project', last_accessed_at: ref },
+      { heatGlobalAlpha: 1.5 },
+      now
+    );
+
+    assert.deepStrictEqual(Object.keys(signals).sort(), [
+      'alpha',
+      'deltaHours',
+      'lambda',
+      'ref',
+      'type',
+    ]);
+
+    assert.strictEqual(signals.type, 'project');
+    assert.strictEqual(signals.lambda, 0.0008);
+    assert.strictEqual(signals.alpha, 1.5);
+    assert.strictEqual(signals.ref, ref);
+    assert.strictEqual(signals.deltaHours, 12);
+  });
+});

package/{test → dsh-mneme/test}/recall-layer.test.js

@@ -77,14 +77,23 @@ test("recorded candidates carry id/title/content/score/source and match the retu
   assert.ok(cands.some((c) => c.id === b.id), "second memory recorded");
 });
 
-test("recordRecall defaults to off — recorder is not called", async () => {
+test("recordRecall defaults on (v0.7.0) — recorder is called by default", async () => {
   const { service } = setup();
   let calls = 0;
   service.setRecallRecorder(() => calls++);
   saveMemory(service, null, { title: "量子计算", content: "入门" });
   await service.searchMemories("量子", { mode: "keyword" });
+  assert.equal(calls, 1, "recorder called once by default (recall_runs 记录默认开)");
+});
+
+test("recordRecall can be opted out via explicit false or config.recallRecordDefault=false", async () => {
+  const { service } = setup({ recallRecordDefault: false });
+  let calls = 0;
+  service.setRecallRecorder(() => calls++);
+  saveMemory(service, null, { title: "量子计算", content: "入门" });
+  await service.searchMemories("量子", { mode: "keyword" });
   await service.searchMemories("量子", { mode: "keyword", recordRecall: false });
-  assert.equal(calls, 0, "no recorder call when recordRecall is unset or false");
+  assert.equal(calls, 0, "no recorder call when default disabled or explicit false");
 });
 
 test("recordRecall=true with no recorder installed is safe and returns normally", async () => {
@@ -301,7 +310,7 @@ test("e2e: index.js wiring — recordRecall search lands a row listRecallRuns ca
   assert.equal(store.getRecallRun(run.id).query, "量子", "row readable right away");
 });
 
-test("e2e: without recordRecall the recall_runs table gains no rows", async () => {
+test("e2e: recordRecall defaults on (v0.7.0) but is disabled by config.recallRecordDefault=false", async () => {
   const store = createStore(":memory:");
   const service = createService({ store, mirror: null, config: {} });
   service.setRecallRecorder((recall) => store.saveRecallRun({
@@ -310,6 +319,18 @@ test("e2e: without recordRecall the recall_runs table gains no rows", async () =
   }));
   service.saveWithDedupe({ type: "preference", title: "量子计算入门", content: "叠加态" });
   await service.searchMemories("量子", { mode: "keyword" });
-  await service.searchMemories("量子", { mode: "keyword", recordRecall: false });
-  assert.deepEqual(store.listRecallRuns(), [], "no rows without recordRecall=true");
+  assert.equal(store.listRecallRuns().length, 1, "default config records a row (记录默认开)");
+
+  const store2 = createStore(":memory:");
+  const service2 = createService({ store: store2, mirror: null, config: { recallRecordDefault: false } });
+  service2.setRecallRecorder((recall) => store2.saveRecallRun({
+    query: recall.query, mode: recall.mode, topK: recall.topK, threshold: recall.threshold ?? null,
+    candidates: recall.candidates ?? [], created_at: recall.createdAt
+  }));
+  service2.saveWithDedupe({ type: "preference", title: "量子计算入门", content: "叠加态" });
+  await service2.searchMemories("量子", { mode: "keyword" });
+  await service2.searchMemories("量子", { mode: "keyword", recordRecall: false });
+  assert.deepEqual(store2.listRecallRuns(), [], "no rows when recallRecordDefault=false or explicit false");
+  store.close();
+  store2.close();
 });

package/dsh-mneme/test/recall-runs.test.js

@@ -0,0 +1,93 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// v0.7.0 recall-layer 强度标记 + 滚动清理：
+//   - searchMemories 记搜索帧：candidates 打 injected:false（被召回）；
+//   - injectCandidates 记注入帧：mode="inject"、candidates 打 injected:true
+//     （被注入上下文）—— 两个消耗强度可分可查；
+//   - 两路都受 recallRecordDefault 门控，注入帧记账失败绝不阻断注入；
+//   - store.purgeRecallRunsOlderThan(days) 按 created_at 滚动清理防膨胀。
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+function wireRecorder(service, seen) {
+  service.setRecallRecorder((r) => seen.push(r));
+}
+
+test("search scene candidates carry injected:false", async () => {
+  const { service } = setup();
+  const seen = [];
+  wireRecorder(service, seen);
+  service.saveWithDedupe({ type: "preference", title: "量子计算", content: "入门", importance: 5 });
+  const rows = await service.searchMemories("量子", { mode: "keyword", recordRecall: true });
+  assert.equal(rows.length, 1);
+  assert.equal(seen[0].mode, "keyword");
+  assert.equal(seen[0].candidates[0].injected, false, "搜索帧是被召回的帧，标记 false");
+});
+
+test("inject scene records mode=inject with injected:true on every candidate", async () => {
+  const { service } = setup();
+  const seen = [];
+  wireRecorder(service, seen);
+  const mem = service.saveWithDedupe({ type: "preference", title: "量子计算", content: "入门", importance: 5 }).memory;
+  const injected = service.injectCandidates({ query: "量子", maxItems: 3 });
+  assert.ok(injected.some((m) => m.id === mem.id), "注入选中的记忆在返回里");
+  assert.equal(seen.length, 1, "注入帧记了 1 条 recall_runs");
+  const rec = seen[0];
+  assert.equal(rec.mode, "inject", "注入帧 mode 为 inject");
+  assert.equal(rec.topK, injected.length);
+  assert.ok(rec.candidates.length >= 1 && rec.candidates.every((c) => c.injected === true), "注入候选全部 injected:true");
+  assert.ok(rec.candidates.every((c) => c.source === "inject"), "注入候选 source 标记 inject");
+});
+
+test("inject recording is gated off by recallRecordDefault=false, search stays explicit", async () => {
+  const { service } = setup({ recallRecordDefault: false });
+  const seen = [];
+  wireRecorder(service, seen);
+  service.saveWithDedupe({ type: "preference", title: "量子计算", content: "入门", importance: 5 });
+  service.injectCandidates({ query: "量子", maxItems: 3 });
+  assert.equal(seen.length, 0, "recallRecordDefault=false 时注入帧不上报");
+  await service.searchMemories("量子", { mode: "keyword", recordRecall: true });
+  assert.equal(seen.length, 1, "显式 recordRecall:true 的搜索帧照常上报");
+});
+
+test("injected flag survives the store round-trip", async () => {
+  const store = createStore(":memory:");
+  store.saveRecallRun({
+    query: "量子", mode: "inject", topK: 1, candidates: [{ id: "a", title: "量子", content: "入门", score: 0.8, source: "inject", injected: true }]
+  });
+  store.saveRecallRun({
+    query: "量子", mode: "keyword", topK: 1, candidates: [{ id: "b", title: "量子计算", content: "叠加态", score: 0.9, source: "keyword", injected: false }]
+  });
+  const runs = store.listRecallRuns();
+  assert.equal(runs.length, 2);
+  const inject = runs.find((r) => r.mode === "inject");
+  const search = runs.find((r) => r.mode === "keyword");
+  assert.equal(inject.candidates[0].injected, true, "注入帧 injected 存得回来");
+  assert.equal(search.candidates[0].injected, false, "搜索帧 injected 存得回来");
+  assert.equal(store.getRecallRun(search.id).candidates[0].injected, false);
+});
+
+test("purgeRecallRunsOlderThan drops only rows past the retention window", async () => {
+  const store = createStore(":memory:");
+  const old = store.saveRecallRun({
+    id: "old", query: "旧查询", mode: "keyword", topK: 5, candidates: [],
+    created_at: new Date(Date.now() - 200 * 86400000).toISOString()
+  });
+  const fresh = store.saveRecallRun({
+    id: "fresh", query: "新查询", mode: "inject", topK: 5, candidates: [],
+    created_at: new Date().toISOString()
+  });
+  const deleted = store.purgeRecallRunsOlderThan(90);
+  assert.equal(deleted, 1, "只有 200 天前的老行被清除");
+  const runs = store.listRecallRuns();
+  assert.deepEqual(runs.map((r) => r.id), ["fresh"], "新行保留");
+  assert.equal(store.getRecallRun(old.id), undefined, "旧行不可再读");
+  store.close();
+});

package/{test → dsh-mneme/test}/settings.test.js

@@ -100,11 +100,15 @@ test("vector config disabled value is stored as false", () => {
   store.close();
 });
 
-test("autoTag config defaults to disabled and round-trips", () => {
+test("autoTag config defaults to null (unset) and round-trips only explicit keys", () => {
   const { store, settings } = setup();
-  assert.deepEqual(settings.getAutoTagConfig(), { autoTagEnabled: false, manualTagEnabled: false });
+  // Issue #31: an unset key is null so runtime consumers fall back to the
+  // plugin config default — the settings layer must not invent `false`.
+  assert.deepEqual(settings.getAutoTagConfig(), { autoTagEnabled: null, manualTagEnabled: null });
   settings.setAutoTagConfig({ autoTagEnabled: true, manualTagEnabled: true });
   assert.deepEqual(settings.getAutoTagConfig(), { autoTagEnabled: true, manualTagEnabled: true });
+  // A partial update only touches the key it was given: manualTagEnabled was
+  // stored earlier so it keeps its value (true), it does not revert to null.
   settings.setAutoTagConfig({ autoTagEnabled: false });
   assert.deepEqual(settings.getAutoTagConfig(), { autoTagEnabled: false, manualTagEnabled: true });
   store.close();

package/dsh-mneme/test/sleep-heat.test.js

@@ -0,0 +1,112 @@
+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,
+    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("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();
+});

package/{test → dsh-mneme/test}/sleep.test.js

@@ -45,6 +45,14 @@ function baseConfig(overrides = {}) {
   };
 }
 
+// v0.7.0 热联合判定：慢衰减类型（project λ=0.0008）默认受热闸保护——40 天热值
+// ≈0.5、100 天 ≈0.28，始终高于 sleepHeatThreshold(0.05)，demotion 不触发。
+// 降级语义测试把 project 的 λ 调快到 0.02（40 天热值≈0.03），复现"时间窗冷态
+// 即降级"的旧路径；默认保守语义由 sleep-heat.test.js 单独覆盖。
+function demotionConfig(overrides = {}) {
+  return baseConfig({ heatTypeDecay: { project: 0.02 }, ...overrides });
+}
+
 function setup() {
   const store = createStore(":memory:");
   const service = createService({ store, mirror: null, config: {} });
@@ -173,7 +181,7 @@ test("sleep: demotion shrinks cold memory to summary, keeps _full_content", asyn
   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 result = await runSleep(ctx, service, demotionConfig(), 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");
@@ -188,7 +196,7 @@ test("sleep: demotion fully archives memory past sleepCompressDays", async () =>
   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 result = await runSleep(ctx, service, demotionConfig(), ctx.logger, null, null);
   const after = service.getById(m.id);
   assert.equal(result.status, "ok");
   assert.equal(after.archived, true, "past compress days → archived");
@@ -275,7 +283,7 @@ test("sleep: a failing phase does not block the others (fail-safe)", async () =>
   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 result = await runSleep(ctx, service, demotionConfig(), 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");
@@ -289,7 +297,7 @@ test("sleep: no LLM route skips LLM phases but demotion still runs", async () =>
   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);
+  const result = await runSleep(ctx, service, demotionConfig(), 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");