@modusensus/dsh-mneme 0.13.0 → 0.14.0-beta.2

package/test/inject-content-cap.test.js

@@ -1,91 +1,91 @@
-// Issue #164① 注入截断修复测试。
-// 覆盖：截断带尾部提示（上限/原长/memory_get id 指引，不再静默）/ 短正文无
-// 提示 / 上限可配（injectContentMaxChars）/ 块预算随上限放大（调大上限不被
-// 1500 旧闸卡死）/ _full_content 压缩注入路径不加提示 / 默认 300 与既有行为
-// 对齐（ellipsis 仍在、全文不整段进入）。
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createInjector } from "../src/inject.js";
-import { createSettings } from "../src/settings.js";
-
-function setup(over = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  const settings = createSettings(store.db);
-  const contexts = [];
-  const ctx = {
-    systemPrompt: {
-      context(def) {
-        contexts.push(def);
-        return () => {};
-      }
-    }
-  };
-  const config = { maxInjectedItems: 3, importanceThreshold: 3, ...over };
-  const injector = createInjector(ctx, service, settings, config);
-  return { store, service, contexts, injector };
-}
-
-test("truncated entry carries a non-silent tail hint with limit/length/memory_get", () => {
-  const { contexts, service } = setup();
-  const long = "超长正文内容。".repeat(200); // ~1400 chars
-  const mem = service.saveWithDedupe({ type: "preference", title: "长记忆", content: long, importance: 5 }).memory;
-  const text = contexts[0].text({});
-  assert.ok(text.includes("…"), "ellipsis present");
-  assert.ok(text.includes(`memory_get "${mem.id}"`), "hint carries memory_get id");
-  assert.ok(text.includes("上限 300"), "hint carries the limit");
-  assert.ok(text.includes(`原 ${long.length} 字符`), "hint carries original length");
-});
-
-test("short content gets no hint", () => {
-  const { contexts, service } = setup();
-  service.saveWithDedupe({ type: "preference", title: "短记忆", content: "中文交流", importance: 5 });
-  const text = contexts[0].text({});
-  assert.ok(!text.includes("已截断"), "no truncation hint on short content");
-});
-
-test("injectContentMaxChars raises the cap and the hint reports the new limit", () => {
-  const { contexts, service } = setup({ injectContentMaxChars: 800 });
-  const long = "字".repeat(1000);
-  service.saveWithDedupe({ type: "preference", title: "长记忆", content: long, importance: 5 });
-  const text = contexts[0].text({});
-  assert.ok(text.includes("字".repeat(800)), "content injected up to the new cap");
-  assert.ok(!text.includes("字".repeat(801)), "content beyond the new cap is cut");
-  assert.ok(text.includes("上限 800"), "hint reports the configured limit");
-});
-
-test("block budget scales with the cap (raised cap is not defeated by the 1500 gate)", () => {
-  const { contexts, service } = setup({ injectContentMaxChars: 1000, maxInjectedItems: 2 });
-  const body = "块".repeat(900);
-  service.saveWithDedupe({ type: "preference", title: "甲", content: body, importance: 5 });
-  service.saveWithDedupe({ type: "preference", title: "乙", content: body, importance: 5 });
-  const text = contexts[0].text({});
-  assert.ok(text.includes("甲"), "first entry full");
-  assert.ok(text.includes("块".repeat(900)), "first entry body not collapsed by stale block gate");
-  assert.ok(text.includes("乙"), "second entry still rendered");
-});
-
-test("_full_content (sleep-compressed) path obeys the cap and says so (#266 评审)", () => {
-  const { store, contexts, service } = setup();
-  const mem = service.saveWithDedupe({ type: "preference", title: "压缩记忆", content: "占位", importance: 5 }).memory;
-  // 模拟 sleep 降级：content=压缩摘要（400 字符 > 默认 300 上限），原文入库 _full_content
-  const summary = "压缩摘要。".repeat(80);
-  store.db.prepare("UPDATE memories SET content=?, _full_content=? WHERE id=?")
-    .run(summary, "原始长文".repeat(100), mem.id);
-  const text = contexts[0].text({});
-  // 「降级过」不等于「天然够短」：原先这条早返回的唯一效果就是绕过上限，现在统一截断。
-  assert.ok(!text.includes(summary), "oversized summary is not injected whole");
-  assert.ok(text.includes("压缩摘要。".repeat(60)), "the part inside the cap is still there (300 chars)");
-  assert.ok(text.includes("已截断"), "the cut is reported, never silent");
-});
-
-test("default cap stays 300 (ellipsis regression of Bug6)", () => {
-  const { contexts, service } = setup();
-  const long = "x".repeat(2000);
-  service.saveWithDedupe({ type: "preference", title: "长记忆", content: long, importance: 5 });
-  const text = contexts[0].text({});
-  assert.ok(text.includes("x".repeat(300)));
-  assert.ok(!text.includes("x".repeat(301)));
-});
+// Issue #164① 注入截断修复测试。
+// 覆盖：截断带尾部提示（上限/原长/memory_get id 指引，不再静默）/ 短正文无
+// 提示 / 上限可配（injectContentMaxChars）/ 块预算随上限放大（调大上限不被
+// 1500 旧闸卡死）/ _full_content 压缩注入路径不加提示 / 默认 300 与既有行为
+// 对齐（ellipsis 仍在、全文不整段进入）。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+
+function setup(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const contexts = [];
+  const ctx = {
+    systemPrompt: {
+      context(def) {
+        contexts.push(def);
+        return () => {};
+      }
+    }
+  };
+  const config = { maxInjectedItems: 3, importanceThreshold: 3, ...over };
+  const injector = createInjector(ctx, service, settings, config);
+  return { store, service, contexts, injector };
+}
+
+test("truncated entry carries a non-silent tail hint with limit/length/memory_get", () => {
+  const { contexts, service } = setup();
+  const long = "超长正文内容。".repeat(200); // ~1400 chars
+  const mem = service.saveWithDedupe({ type: "preference", title: "长记忆", content: long, importance: 5 }).memory;
+  const text = contexts[0].text({});
+  assert.ok(text.includes("…"), "ellipsis present");
+  assert.ok(text.includes(`memory_get "${mem.id}"`), "hint carries memory_get id");
+  assert.ok(text.includes("上限 300"), "hint carries the limit");
+  assert.ok(text.includes(`原 ${long.length} 字符`), "hint carries original length");
+});
+
+test("short content gets no hint", () => {
+  const { contexts, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "短记忆", content: "中文交流", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(!text.includes("已截断"), "no truncation hint on short content");
+});
+
+test("injectContentMaxChars raises the cap and the hint reports the new limit", () => {
+  const { contexts, service } = setup({ injectContentMaxChars: 800 });
+  const long = "字".repeat(1000);
+  service.saveWithDedupe({ type: "preference", title: "长记忆", content: long, importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("字".repeat(800)), "content injected up to the new cap");
+  assert.ok(!text.includes("字".repeat(801)), "content beyond the new cap is cut");
+  assert.ok(text.includes("上限 800"), "hint reports the configured limit");
+});
+
+test("block budget scales with the cap (raised cap is not defeated by the 1500 gate)", () => {
+  const { contexts, service } = setup({ injectContentMaxChars: 1000, maxInjectedItems: 2 });
+  const body = "块".repeat(900);
+  service.saveWithDedupe({ type: "preference", title: "甲", content: body, importance: 5 });
+  service.saveWithDedupe({ type: "preference", title: "乙", content: body, importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("甲"), "first entry full");
+  assert.ok(text.includes("块".repeat(900)), "first entry body not collapsed by stale block gate");
+  assert.ok(text.includes("乙"), "second entry still rendered");
+});
+
+test("_full_content (sleep-compressed) path obeys the cap and says so (#266 评审)", () => {
+  const { store, contexts, service } = setup();
+  const mem = service.saveWithDedupe({ type: "preference", title: "压缩记忆", content: "占位", importance: 5 }).memory;
+  // 模拟 sleep 降级：content=压缩摘要（400 字符 > 默认 300 上限），原文入库 _full_content
+  const summary = "压缩摘要。".repeat(80);
+  store.db.prepare("UPDATE memories SET content=?, _full_content=? WHERE id=?")
+    .run(summary, "原始长文".repeat(100), mem.id);
+  const text = contexts[0].text({});
+  // 「降级过」不等于「天然够短」：原先这条早返回的唯一效果就是绕过上限，现在统一截断。
+  assert.ok(!text.includes(summary), "oversized summary is not injected whole");
+  assert.ok(text.includes("压缩摘要。".repeat(60)), "the part inside the cap is still there (300 chars)");
+  assert.ok(text.includes("已截断"), "the cut is reported, never silent");
+});
+
+test("default cap stays 300 (ellipsis regression of Bug6)", () => {
+  const { contexts, service } = setup();
+  const long = "x".repeat(2000);
+  service.saveWithDedupe({ type: "preference", title: "长记忆", content: long, importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("x".repeat(300)));
+  assert.ok(!text.includes("x".repeat(301)));
+});

package/test/inject-first-round-bm25.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 { createVectorIndex } from "../src/vector-index.js";
-
-// 回归（issue #198）：注入渲染是同步的（宿主 systemPrompt 不支持异步 text），
-// 查询向量只能异步 prefetch 给下一轮用——首轮 queryVectorCache 必 miss。
-// 此时 injectCandidates 落到静态 priority 排序（summary > preference >
-// importance×quality）：老的高重要性 preference 会占满全部槽位，当前话题的
-// decision/project 进不来（报告者库：427 活跃、29 条 imp=5 preference）。
-// 修复：首轮同步兜底用 BM25 词法召回领位（纯进程内、无需向量）；语义向量
-// 命中时行为不变（向量 > 缓存召回 > BM25 > 静态排序）。
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-// 与查询词法完全不相交的旧高价值 preference（双字组不重叠）
-function seedStalePreferences(service, n = 8) {
-  const ids = [];
-  for (let i = 0; i < n; i++) {
-    ids.push(service.saveWithDedupe({
-      type: "preference",
-      title: `旧偏好条目${i}`,
-      content: `用户喜欢深色界面与紧凑排版，这是第${i}条历史偏好存档`
-    , importance: 5 }).memory.id);
-  }
-  return ids;
-}
-
-test("#198: first round (no vector) leads with BM25 topical hits, not stale preferences", () => {
-  const { service, store } = setup();
-  seedStalePreferences(service, 8);
-  const onTopic = service.saveWithDedupe({
-    type: "decision",
-    title: "夜航限流选型",
-    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
-    importance: 3
-  }).memory;
-
-  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
-  assert.ok(picked.some((m) => m.id === onTopic.id), "on-topic decision must enter the first-round block");
-  assert.equal(picked[0].id, onTopic.id, "BM25 topical hit leads the block");
-  store.close();
-});
-
-test("#198: legacy static order is kept when bm25 is disabled", () => {
-  const { service, store } = setup({ bm25SearchEnabled: false });
-  seedStalePreferences(service, 8);
-  const onTopic = service.saveWithDedupe({
-    type: "decision",
-    title: "夜航限流选型",
-    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
-    importance: 3
-  }).memory;
-
-  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
-  assert.ok(!picked.some((m) => m.id === onTopic.id), "bm25 off -> legacy static order (preferences fill the slots)");
-  store.close();
-});
-
-test("#198: vector hits still outrank BM25 when a queryVector is available", async () => {
-  const { service, store } = setup();
-  seedStalePreferences(service, 3);
-  // 词法与查询不相交、但向量命中的记忆：语义路径必须压过 BM25 词法路径。
-  const vectorHit = service.saveWithDedupe({
-    type: "project",
-    title: "星图渲染重构",
-    content: "星图渲染重构记录：绘制管线迁移与图层合并",
-    importance: 3
-  }).memory;
-  const bm25Hit = service.saveWithDedupe({
-    type: "decision",
-    title: "夜航限流选型",
-    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
-    importance: 3
-  }).memory;
-  const vectorIndex = createVectorIndex({ store });
-  service.setVectorIndex(vectorIndex);
-  vectorIndex.saveEmbedding(vectorHit.id, [1, 0, 0]);
-
-  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3, queryVector: [1, 0, 0] });
-  assert.equal(picked[0].id, vectorHit.id, "vector hit leads; BM25 only fills the gap when no vector");
-  assert.ok(picked.some((m) => m.id === bm25Hit.id), "BM25 hit still present among candidates");
-  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 { createVectorIndex } from "../src/vector-index.js";
+
+// 回归（issue #198）：注入渲染是同步的（宿主 systemPrompt 不支持异步 text），
+// 查询向量只能异步 prefetch 给下一轮用——首轮 queryVectorCache 必 miss。
+// 此时 injectCandidates 落到静态 priority 排序（summary > preference >
+// importance×quality）：老的高重要性 preference 会占满全部槽位，当前话题的
+// decision/project 进不来（报告者库：427 活跃、29 条 imp=5 preference）。
+// 修复：首轮同步兜底用 BM25 词法召回领位（纯进程内、无需向量）；语义向量
+// 命中时行为不变（向量 > 缓存召回 > BM25 > 静态排序）。
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+// 与查询词法完全不相交的旧高价值 preference（双字组不重叠）
+function seedStalePreferences(service, n = 8) {
+  const ids = [];
+  for (let i = 0; i < n; i++) {
+    ids.push(service.saveWithDedupe({
+      type: "preference",
+      title: `旧偏好条目${i}`,
+      content: `用户喜欢深色界面与紧凑排版，这是第${i}条历史偏好存档`
+    , importance: 5 }).memory.id);
+  }
+  return ids;
+}
+
+test("#198: first round (no vector) leads with BM25 topical hits, not stale preferences", () => {
+  const { service, store } = setup();
+  seedStalePreferences(service, 8);
+  const onTopic = service.saveWithDedupe({
+    type: "decision",
+    title: "夜航限流选型",
+    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
+    importance: 3
+  }).memory;
+
+  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
+  assert.ok(picked.some((m) => m.id === onTopic.id), "on-topic decision must enter the first-round block");
+  assert.equal(picked[0].id, onTopic.id, "BM25 topical hit leads the block");
+  store.close();
+});
+
+test("#198: legacy static order is kept when bm25 is disabled", () => {
+  const { service, store } = setup({ bm25SearchEnabled: false });
+  seedStalePreferences(service, 8);
+  const onTopic = service.saveWithDedupe({
+    type: "decision",
+    title: "夜航限流选型",
+    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
+    importance: 3
+  }).memory;
+
+  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3 });
+  assert.ok(!picked.some((m) => m.id === onTopic.id), "bm25 off -> legacy static order (preferences fill the slots)");
+  store.close();
+});
+
+test("#198: vector hits still outrank BM25 when a queryVector is available", async () => {
+  const { service, store } = setup();
+  seedStalePreferences(service, 3);
+  // 词法与查询不相交、但向量命中的记忆：语义路径必须压过 BM25 词法路径。
+  const vectorHit = service.saveWithDedupe({
+    type: "project",
+    title: "星图渲染重构",
+    content: "星图渲染重构记录：绘制管线迁移与图层合并",
+    importance: 3
+  }).memory;
+  const bm25Hit = service.saveWithDedupe({
+    type: "decision",
+    title: "夜航限流选型",
+    content: "决定采用令牌桶做夜航App的限流方案，阈值按用户等级分层",
+    importance: 3
+  }).memory;
+  const vectorIndex = createVectorIndex({ store });
+  service.setVectorIndex(vectorIndex);
+  vectorIndex.saveEmbedding(vectorHit.id, [1, 0, 0]);
+
+  const picked = service.injectCandidates({ query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3, queryVector: [1, 0, 0] });
+  assert.equal(picked[0].id, vectorHit.id, "vector hit leads; BM25 only fills the gap when no vector");
+  assert.ok(picked.some((m) => m.id === bm25Hit.id), "BM25 hit still present among candidates");
+  store.close();
+});

package/test/inject-heat.test.js

@@ -1,77 +1,77 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-// #218 v1：heat 作为注入排序的**同级内乘数**（issue #218 拍板口径）。
-// 规则路 comparator 的层内权重 importance×quality 乘 heat；priority 分层
-// （summary=0 / preference=1 / coding 同级 / 其余 2）与 store 的 order=chrono
-// 分页序不动。
-//
-// issue #218 / E5 效用考卷：heat 乘进注入排序在真实年龄混合下饿死老约束
-// （现行量级 ≡ 拟合参数，importance-only 遵从 +12.7pp），注入侧 heat 拆出
-// 独立开关 injectHeatEnabled（默认关）——默认关档下 heatEnabled=true 的库
-// 注入排序与 heat 关闭逐字节一致（平价锁）；显式开启才恢复旧序。
-// 召回侧时钟（touchLastAccess）与 sleep 降级联判不受本键影响。
-
-const HOUR = 3600000;
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-const titles = (candidates) => candidates.map((c) => c.title);
-
-// 三个用例共用的「冷高重要性 + 新低重要性」库。
-function seedColdAndFresh(service) {
-  const cold = service.saveWithDedupe({ type: "decision", title: "冷的高重要性决策", content: "旧", importance: 4 }).memory;
-  service.saveWithDedupe({ type: "decision", title: "新的低重要性决策", content: "新", importance: 3 });
-  service.touchLastAccess(cold.id, new Date(Date.now() - 3000 * HOUR).toISOString());
-  // 新记忆不触达：ref 退 created_at（≈现在），heat≈1，不影响本用例
-}
-
-test("heat off（默认）：层内维持 importance 序，与改动前一致", () => {
-  const { store, service } = setup();
-  seedColdAndFresh(service);
-  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
-  store.close();
-});
-
-test("heat on 且 injectHeatEnabled 关（新默认）：注入序与 heat 关闭逐字节一致（E5 平价锁）", () => {
-  const { store, service } = setup({ heatEnabled: true });
-  seedColdAndFresh(service);
-  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  // E5 效用考卷：heat 乘进注入排序饿死老约束——默认不再乘，冷的高重要性决策
-  // 回到它 importance 应在的位置（与 heat off 用例逐条相同）。
-  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
-  store.close();
-});
-
-test("heat on 且 injectHeatEnabled 开：恢复旧序（老用户回滚口）", () => {
-  const { store, service } = setup({ heatEnabled: true, injectHeatEnabled: true });
-  seedColdAndFresh(service);
-  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  // λ=0.002、3000h → 冷记忆权重 4×e^-6≈0.01，新鲜记忆 3×≈1 → 反超
-  assert.deepEqual(titles(picked), ["新的低重要性决策", "冷的高重要性决策"]);
-  store.close();
-});
-
-test("heat on 且 injectHeatEnabled 开 且 λ=0（免疫类型）：乘数恒 1，importance 序不受影响", () => {
-  const { store, service } = setup({ heatEnabled: true, injectHeatEnabled: true, heatTypeDecay: { decision: 0 } });
-  seedColdAndFresh(service);
-  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
-  store.close();
-});
-
-test("heat 不跨层：再热的 decision 也不越过 summary 层（injectHeatEnabled 开）", () => {
-  const { store, service } = setup({ heatEnabled: true, injectHeatEnabled: true });
-  service.saveWithDedupe({ type: "summary", title: "会话总览", content: "总览", importance: 2 });
-  service.saveWithDedupe({ type: "decision", title: "滚烫决策", content: "新", importance: 3 });
-  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  assert.equal(picked[0].type, "summary", "priority 分层不被 heat 打破");
-  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";
+
+// #218 v1：heat 作为注入排序的**同级内乘数**（issue #218 拍板口径）。
+// 规则路 comparator 的层内权重 importance×quality 乘 heat；priority 分层
+// （summary=0 / preference=1 / coding 同级 / 其余 2）与 store 的 order=chrono
+// 分页序不动。
+//
+// issue #218 / E5 效用考卷：heat 乘进注入排序在真实年龄混合下饿死老约束
+// （现行量级 ≡ 拟合参数，importance-only 遵从 +12.7pp），注入侧 heat 拆出
+// 独立开关 injectHeatEnabled（默认关）——默认关档下 heatEnabled=true 的库
+// 注入排序与 heat 关闭逐字节一致（平价锁）；显式开启才恢复旧序。
+// 召回侧时钟（touchLastAccess）与 sleep 降级联判不受本键影响。
+
+const HOUR = 3600000;
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+const titles = (candidates) => candidates.map((c) => c.title);
+
+// 三个用例共用的「冷高重要性 + 新低重要性」库。
+function seedColdAndFresh(service) {
+  const cold = service.saveWithDedupe({ type: "decision", title: "冷的高重要性决策", content: "旧", importance: 4 }).memory;
+  service.saveWithDedupe({ type: "decision", title: "新的低重要性决策", content: "新", importance: 3 });
+  service.touchLastAccess(cold.id, new Date(Date.now() - 3000 * HOUR).toISOString());
+  // 新记忆不触达：ref 退 created_at（≈现在），heat≈1，不影响本用例
+}
+
+test("heat off（默认）：层内维持 importance 序，与改动前一致", () => {
+  const { store, service } = setup();
+  seedColdAndFresh(service);
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
+  store.close();
+});
+
+test("heat on 且 injectHeatEnabled 关（新默认）：注入序与 heat 关闭逐字节一致（E5 平价锁）", () => {
+  const { store, service } = setup({ heatEnabled: true });
+  seedColdAndFresh(service);
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  // E5 效用考卷：heat 乘进注入排序饿死老约束——默认不再乘，冷的高重要性决策
+  // 回到它 importance 应在的位置（与 heat off 用例逐条相同）。
+  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
+  store.close();
+});
+
+test("heat on 且 injectHeatEnabled 开：恢复旧序（老用户回滚口）", () => {
+  const { store, service } = setup({ heatEnabled: true, injectHeatEnabled: true });
+  seedColdAndFresh(service);
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  // λ=0.002、3000h → 冷记忆权重 4×e^-6≈0.01，新鲜记忆 3×≈1 → 反超
+  assert.deepEqual(titles(picked), ["新的低重要性决策", "冷的高重要性决策"]);
+  store.close();
+});
+
+test("heat on 且 injectHeatEnabled 开 且 λ=0（免疫类型）：乘数恒 1，importance 序不受影响", () => {
+  const { store, service } = setup({ heatEnabled: true, injectHeatEnabled: true, heatTypeDecay: { decision: 0 } });
+  seedColdAndFresh(service);
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  assert.deepEqual(titles(picked), ["冷的高重要性决策", "新的低重要性决策"]);
+  store.close();
+});
+
+test("heat 不跨层：再热的 decision 也不越过 summary 层（injectHeatEnabled 开）", () => {
+  const { store, service } = setup({ heatEnabled: true, injectHeatEnabled: true });
+  service.saveWithDedupe({ type: "summary", title: "会话总览", content: "总览", importance: 2 });
+  service.saveWithDedupe({ type: "decision", title: "滚烫决策", content: "新", importance: 3 });
+  const picked = service.injectCandidates({ maxItems: 5, threshold: 3 });
+  assert.equal(picked[0].type, "summary", "priority 分层不被 heat 打破");
+  store.close();
+});