@modusensus/dsh-mneme 0.7.17 → 0.7.20

package/test/api.test.js

@@ -527,10 +527,10 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   assert.equal(res.statusCode, 200);
   const data = JSON.parse(res.body);
   assert.deepEqual(data.overrides, {});
-  // effective 覆盖全部 30 个白名单键，未覆盖时取 bundle 配置的解析默认值；
-  // dreamProvider/dreamModel 无 schema 默认值（Config({}) 解析为 undefined），
-  // 不编造给前端 → 30 - 2 = 28
-  assert.equal(Object.keys(data.effective).length, 28);
+  // effective 覆盖全部 31 个白名单键（含 v0.7.20 新增的 heatEnabled），未覆盖时
+  // 取 bundle 配置的解析默认值；dreamProvider/dreamModel 无 schema 默认值
+  // （Config({}) 解析为 undefined），不编造给前端 → 31 - 2 = 29
+  assert.equal(Object.keys(data.effective).length, 29);
   assert.equal(data.effective.autoInject, true);
   assert.equal(data.effective.codingRetrospect, false);
   assert.equal(data.effective.distillMaxChars, 24000);
@@ -903,7 +903,9 @@ test("GET /api/dsh-mneme/dream-status returns runs and pending conflict ids", as
   assert.equal(data.runs.length, 2);
   assert.equal(data.runs[0].created_at, "2026-01-02T00:00:00.000Z", "created_at DESC");
   assert.deepEqual(data.lastRun, data.runs[0]);
-  assert.deepEqual(Object.keys(data.lastRun).sort(), ["created_at", "error", "model", "provider", "status"]);
+  assert.deepEqual(Object.keys(data.lastRun).sort(), ["created_at", "demotion", "error", "model", "provider", "run_type", "status"]);
+  assert.equal(data.lastRun.run_type, "auto", "default run_type is auto");
+  assert.equal(data.lastRun.demotion, null, "no demotion info for non-sleep runs");
   assert.equal(data.runs[0].error, "boom");
   assert.equal(data.runs[1].provider, "ollama");
   assert.equal(data.pendingConflicts, 1);
@@ -994,3 +996,84 @@ test("GET /api/dsh-mneme/list?archived=only lists just archived rows; default li
   await route.handler(req("/api/dsh-mneme/list"), back);
   assert.equal(JSON.parse(back.body).total, 2);
 });
+
+test("GET /api/dsh-mneme/list?deposited=only lists dream-touched memories (receipts ∪ source=dream)", async () => {
+  const { routes, service } = setup();
+  const plain = service.saveWithDedupe({ type: "preference", title: "无关", content: "plain" });
+  const merged = service.saveWithDedupe({ type: "project", title: "被巩固", content: "merged" });
+  const updated = service.saveWithDedupe({ type: "decision", title: "被更新", content: "updated" });
+  service.saveWithDedupe({ type: "summary", title: "总览", content: "overview", source: "dream" });
+  const ids = [plain, merged, updated].map((r) => r.memory.id);
+
+  // 巩固账本：merge 落在 keepSource、update 落在目标；conflict 只仲裁不落
+  // 内容，不算沉淀。verdict='live' 才有效。
+  service.saveReceipt({
+    receipt_id: "r-merge", run_id: "run-1", record_id: merged.memory.id, kind: "merge",
+    input_digest: "d1", keep_source: merged.memory.id, sources: [merged.memory.id, ids[0]],
+    verdict: "live", count_before: 2, count_after: 1, policy_epoch: 0,
+    created_at: new Date().toISOString()
+  });
+  service.saveReceipt({
+    receipt_id: "r-update", run_id: "run-1", record_id: updated.memory.id, kind: "update",
+    input_digest: "d2", verdict: "live", count_before: 1, count_after: 1,
+    policy_epoch: 0, created_at: new Date().toISOString()
+  });
+  service.saveReceipt({
+    receipt_id: "r-conflict", run_id: "run-1", record_id: "winner-x", kind: "conflict",
+    input_digest: "d3", winner_id: "winner-x", loser_id: "loser-y", verdict: "live",
+    count_before: 2, count_after: 2, policy_epoch: 0, created_at: new Date().toISOString()
+  });
+
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/list");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list?deposited=only"), res);
+  const data = JSON.parse(res.body);
+  assert.deepEqual(
+    data.items.map((m) => m.title).sort(),
+    ["总览", "被巩固", "被更新"],
+    "deposited view = receipt merge/update records ∪ source=dream writes"
+  );
+  assert.equal(data.total, 3, "total honors the deposited filter");
+
+  // 默认列表不受 deposited 过滤影响
+  const def = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list"), def);
+  assert.equal(JSON.parse(def.body).total, 4);
+
+  // 与 archived=only 可叠加：归档的沉淀记忆才出现在交集视图里
+  const upd = routes.find((r) => r.path === "/api/dsh-mneme/update");
+  const arch = new FakeRes();
+  await upd.handler(req("/api/dsh-mneme/update", "POST", { id: merged.memory.id, archived: true }), arch);
+  assert.equal(arch.statusCode, 200);
+  const both = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/list?deposited=only&archived=only"), both);
+  const bothData = JSON.parse(both.body);
+  assert.deepEqual(bothData.items.map((m) => m.title), ["被巩固"]);
+  assert.equal(bothData.total, 1);
+});
+
+test("GET /api/dsh-mneme/list projects per-memory heat only when heatEnabled=true", async () => {
+  // 默认（heatEnabled=false）：heat 字段整体缺省——前端徽章据此自动隐藏
+  const off = setup();
+  off.service.saveWithDedupe({ type: "preference", title: "免疫型", content: "immune" });
+  const r0 = new FakeRes();
+  await off.routes.find((r) => r.path === "/api/dsh-mneme/list").handler(req("/api/dsh-mneme/list"), r0);
+  const d0 = JSON.parse(r0.body);
+  assert.equal(d0.total, 1);
+  assert.equal("heat" in d0.items[0], false, "heat must be absent from the wire DTO when the flag is off");
+
+  // heatEnabled=true：逐条投影。λ=0 免疫类型（preference）恒 1.0；其余落在
+  // [0,1] 区间（新建记忆 Δt≈0 接近满格，衰减数学由 heat.test.js 看门）。
+  const on = setup(null, "", { heatEnabled: true });
+  on.service.saveWithDedupe({ type: "preference", title: "免疫型", content: "immune" });
+  on.service.saveWithDedupe({ type: "history", title: "会话历史", content: "recent" });
+  const r1 = new FakeRes();
+  await on.routes.find((r) => r.path === "/api/dsh-mneme/list").handler(req("/api/dsh-mneme/list"), r1);
+  const d1 = JSON.parse(r1.body);
+  assert.equal(d1.total, 2);
+  const byTitle = Object.fromEntries(d1.items.map((m) => [m.title, m.heat]));
+  assert.equal(byTitle["免疫型"], 1, "λ=0 immune types stay at full heat");
+  for (const v of Object.values(byTitle)) {
+    assert.ok(typeof v === "number" && v >= 0 && v <= 1, "heat values stay within [0,1]");
+  }
+});

package/test/client.test.js

@@ -219,6 +219,54 @@ test("importance renders as star glyphs, not raw text stars", () => {
   );
 });
 
+// better-sidebar ecosystem integration is an optional capability (official
+// external-plugin-guide §2.2): 'betterSidebar' IS declared in inject (DSH's
+// runtime gates ctx property access on the inject declaration — probing
+// without declaring fails the whole loader entry, verified in the field) and
+// better-sidebar 软集成（issue #88 修正）：模块级 inject 声明 betterSidebar
+// 是硬等待——未安装 bs 的环境整个 entry pending（"1 entry did not activate"，
+// Failed to load plugins）。正确模式（dsh-server-deck 同款）：外层入口零
+// inject 立即激活（独立模式保底），tab 注册挂在内层动态子插件
+// ctx.plugin({ inject: ['betterSidebar'] }) 由 cordis 原生等待服务——bs 未装
+// 时该内层 fiber 永远 INACTIVE，静默无害。
+test("better-sidebar tab mounts via an inner sub-plugin, standalone mode intact", () => {
+  assert.ok(
+    /const reg = bsCtx\.betterSidebar;[\s\S]{0,60}typeof reg\.registerTab !== "function"/.test(clientSource),
+    "the inner apply must still guard the service shape before registering"
+  );
+  assert.ok(
+    /id: "dsh-mneme:memory"/.test(clientSource),
+    "the registered tab id must be package-prefixed"
+  );
+  assert.ok(
+    /title: \(\) => t\("memory\.view\.label"\)/.test(clientSource),
+    "the tab title must reuse the localized 记忆库 label"
+  );
+  assert.ok(
+    /component: \(\) => h\(MemoryExplorer, \{ t \}\)/.test(clientSource),
+    "the tab must reuse the MemoryExplorer views"
+  );
+  assert.ok(
+    clientSource.includes('"dsh-mneme: better-sidebar tab"'),
+    "the registration effect must carry a named label for scope cleanup"
+  );
+  // issue #88：模块级 inject 声明 betterSidebar 是硬等待——未安装 bs 的环境
+  // 整个 entry pending（"1 entry did not activate"）。tab 注册必须挂在内层
+  // 动态子插件（dsh-server-deck 同款模式），外层入口零 inject 立即激活。
+  assert.ok(
+    /const inject = \["slots", "locale"\]/.test(clientSource),
+    "the module inject must not declare betterSidebar (hard-wait regression)"
+  );
+  assert.ok(
+    /ctx\.plugin\?\.\(\{[\s\S]*?inject: \["betterSidebar"\][\s\S]*?apply: \(bsCtx\) =>/.test(clientSource),
+    "the tab registration must live in an inner dynamic sub-plugin waiting on cordis"
+  );
+  assert.ok(
+    /if \(\+\+tries <= 10\) timer = setTimeout\(attempt, 1000\);/.test(clientSource) === false,
+    "the old 10×1s probe must go — cordis waits for the inner inject natively"
+  );
+});
+
 // The graph toggle must not read as "share": the primitives share icon is
 // banned and a custom node-graph glyph takes its place.
 test("graph toggle uses a node-graph glyph, not the share icon", () => {
@@ -233,6 +281,44 @@ test("graph toggle uses a node-graph glyph, not the share icon", () => {
   );
 });
 
+// 方案 A：查询收敛。状态页只做仪表盘（小页预览 + 服务端 total + 查看全部），
+// 沉淀/归档的完整浏览走记忆库的 deposited/archived 筛选视图（chip 预置 +
+// 状态页入口跳转），详情抽屉给归档记忆一个反向的「恢复」。
+test("status dashboard links into deposited/archived library views", () => {
+  assert.ok(
+    clientSource.includes('"/api/dsh-mneme/list?deposited=only&limit=8&order=chrono"'),
+    "the workbench deposited preview must read the server-side deposited view"
+  );
+  assert.ok(
+    clientSource.includes('"/api/dsh-mneme/list?archived=only&limit=3&order=chrono"'),
+    "the workbench archived preview must cap at 3 rows backed by a server total"
+  );
+  assert.ok(
+    clientSource.includes("browseWithFilter"),
+    "the status page must jump into the library with preset filters"
+  );
+  assert.ok(
+    /view === "status" && h\(StatusPanel, \{ t, onBrowse: browseWithFilter \}\)/.test(clientSource),
+    "the status panel must receive the browse-jump callback"
+  );
+  assert.ok(
+    clientSource.includes('(depositedOnly ? "&deposited=only" : "")'),
+    "the library filterQS must carry the deposited chip"
+  );
+  assert.ok(
+    clientSource.includes('(archivedOnly ? "&archived=only" : "")'),
+    "the library filterQS must carry the archived chip"
+  );
+  assert.ok(
+    clientSource.includes('postUpdate({ archived: false }, { restored: true })'),
+    "the drawer must offer restore for archived memories"
+  );
+  assert.ok(
+    clientSource.includes('"memory.status.viewAll"'),
+    "the view-all entries must come from the dictionary"
+  );
+});
+
 // Every memory feature lives in the main-area library now: the explorer
 // hosts three sub-views (browse / entities / settings) switched by tabs whose
 // labels come from dedicated dictionary keys.
@@ -332,3 +418,51 @@ test("explorer chrome aligns with the host design system", () => {
     "pill chips belong to the drawer era and must stay gone"
   );
 });
+
+// heat 阶段二：/list 仅在 heatEnabled=true 时下发逐条 heat，前端徽章三档
+// 配色且自门控（字段缺省自动隐藏）——卡片页脚、抽屉 meta、状态分布卡共用
+// 同一数据源，前端不感知开关状态。
+test("heat badges render from the /list projection and self-hide when off", () => {
+  assert.ok(
+    /const HeatBadge = \(\{ value, size = 12 \}\) =>/.test(clientSource),
+    "the heat badge component must exist"
+  );
+  assert.ok(
+    clientSource.includes("flame:"),
+    "the Lucide flame glyph must back the badge"
+  );
+  assert.ok(
+    /h\(HeatBadge, \{ value: m\.heat \}\)/.test(clientSource),
+    "the card foot must render the heat badge"
+  );
+  assert.ok(
+    clientSource.includes('t("memory.explorer.heat")'),
+    "the drawer must show a localized heat meta row"
+  );
+  assert.ok(
+    clientSource.includes("function HeatStatusCard"),
+    "the status grid must include the heat distribution card"
+  );
+  assert.ok(
+    clientSource.includes('typeof items[0].heat !== "number"'),
+    "the distribution card must self-hide when /list omits heat"
+  );
+  assert.ok(
+    /\.mneme-heat--hot\{/.test(clientSource),
+    "the three-tier heat colors must be styled"
+  );
+  // order=heat 的前端补口：热度是运行时投影无存储序，SQL 排不了——页内
+  // 对已加载条目降序，时间树保持 chrono；chip 自门控（heat 缺省不出现）。
+  assert.ok(
+    /const heatAvailable = visible\.some\(\(m\) => typeof m\.heat === "number"\);/.test(clientSource),
+    "the heat-sort chip must self-gate on the /list heat field"
+  );
+  assert.ok(
+    /const gridItems = heatSort[\s\S]{0,80}\(b\.heat \?\? 0\) - \(a\.heat \?\? 0\)/.test(clientSource),
+    "the cards grid must sort loaded items by heat in-page"
+  );
+  assert.ok(
+    clientSource.includes("if (!heatSort) switchViewMode(\"cards\")"),
+    "toggling heat sort must land on the cards view (sort does not apply to the month tree)"
+  );
+});

package/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/recall-layer.test.js

@@ -77,14 +77,24 @@ 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 to on (recallRecordDefault) — explicit false opts out", async () => {
   const { service } = setup();
   let calls = 0;
   service.setRecallRecorder(() => calls++);
   saveMemory(service, null, { title: "量子计算", content: "入门" });
   await service.searchMemories("量子", { mode: "keyword" });
+  assert.equal(calls, 1, "unset recordRecall records by default (recallRecordDefault)");
   await service.searchMemories("量子", { mode: "keyword", recordRecall: false });
-  assert.equal(calls, 0, "no recorder call when recordRecall is unset or false");
+  assert.equal(calls, 1, "explicit false opts out of recording");
+});
+
+test("recallRecordDefault=false config turns unset recordRecall off", async () => {
+  const { service } = setup({ recallRecordDefault: false });
+  let calls = 0;
+  service.setRecallRecorder(() => calls++);
+  saveMemory(service, null, { title: "量子计算", content: "入门" });
+  await service.searchMemories("量子", { mode: "keyword" });
+  assert.equal(calls, 0, "config recallRecordDefault:false → unset recordRecall is off");
 });
 
 test("recordRecall=true with no recorder installed is safe and returns normally", async () => {
@@ -301,7 +311,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: unset recordRecall records by default; explicit false adds no row", async () => {
   const store = createStore(":memory:");
   const service = createService({ store, mirror: null, config: {} });
   service.setRecallRecorder((recall) => store.saveRecallRun({
@@ -310,6 +320,7 @@ test("e2e: without recordRecall the recall_runs table gains no rows", async () =
   }));
   service.saveWithDedupe({ type: "preference", title: "量子计算入门", content: "叠加态" });
   await service.searchMemories("量子", { mode: "keyword" });
+  assert.equal(store.listRecallRuns().length, 1, "unset recordRecall records a run by default");
   await service.searchMemories("量子", { mode: "keyword", recordRecall: false });
-  assert.deepEqual(store.listRecallRuns(), [], "no rows without recordRecall=true");
+  assert.equal(store.listRecallRuns().length, 1, "explicit false adds no row");
 });

package/test/sleep-heat.test.js

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

package/test/sleep.test.js

@@ -45,6 +45,14 @@ function baseConfig(overrides = {}) {
   };
 }
 
+// v0.7.0 heat 双保护默认保守：默认 heatTypeDecay 下 project 记忆 40 天热值
+// ≈0.55、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");