@modusensus/dsh-mneme 0.8.15 → 0.9.0

package/test/embed-ready-poll.test.js

@@ -0,0 +1,94 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// 这条锁防的是一类「上限形同不存在」的回归：上限判断如果排在会抛错的那次读取
+// 后面，轮询就永远不会停手。
+//
+// service.js 的 setEmbedder 为异步初始化的 embedder 起了个轮询：每 100ms 读一次
+// `emb.ready`，读到 true 或撞上 EMBED_READY_POLL_LIMIT(=30) 就停
+// （注释原文 "~3s ceiling; never poll forever"）。但 `ready` 是个 getter
+// —— embedding.js 的 OpenAI embedder 直接读库 —— 于是写成
+//     if (emb.ready === true || attempts >= EMBED_READY_POLL_LIMIT) { stop(); }
+// 的整条 `||` 会在左半边当场中断，右半边的天花板永远轮不到：stopEmbedReadyPolling()
+// 不执行，定时器活过上限，并且每 100ms 抛一次未捕获异常。
+//
+// 实测现场（2026-10-14，加蒸馏留存的装配级用例时撞上）：fiber.dispose() 走完
+// index.js 的 disposer（末尾一句就是 store.close()）之后，每次读 ready 都抛
+// "database is not open" [ERR_INVALID_STATE]，5s 内读了 46 次 —— 天花板 31 被
+// 击穿，node --test 进程因此不再退出。一个只在启动时读一次库的 getter，能把
+// 宿主的事件循环钉死；而现有测试全都「装配完不拆」，所以从 v0.7.1 起一直没人碰到。
+//
+// 时序照真实卸载顺序复现：安装时未就绪（轮询启动）→ store.close()（此后每次读
+// ready 都抛）→ 等超过天花板 → 看它停没停手、报了几次。
+const POLL_LIMIT = 30; // 与 src/service.js 的 EMBED_READY_POLL_LIMIT 同值，改那边要改这里
+const POLL_MS = 100;
+const CEILING_READS = 1 + POLL_LIMIT; // setEmbedder 自己读一次，之后每个 tick 一次
+const SETTLE_MS = 400; // 静默这么久没新读取，就认为定时器已经停手
+const DEADLINE_MS = 30000; // 上限：等到这里还没静默就按超时处理
+
+// 等「读取次数不再增长」。不能用「睡够 POLL_MS*30 + 600ms 再断言」——
+// 全量 npm test 是多文件并行跑的，CPU 一挤，30 个 tick 未必在 3.6s 内跑完，
+// 断言就会读到 30 而不是 31（2026-10-15 rebase 后在全量跑里实测撞到一次，
+// 单跑 3/3 通过、紧接着全量跑两遍也全绿——纯粹的负载抖动）。
+// 静默判定是可靠的：定时器周期 100ms，而越过上限后 stopEmbedReadyPolling()
+// 会 clearInterval，此后 reads 恒不再变，两者不会混淆。
+async function waitUntilSettled(getReads) {
+  const started = Date.now();
+  let last = getReads();
+  let lastChange = Date.now();
+  while (Date.now() - started < DEADLINE_MS) {
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    const now = getReads();
+    if (now !== last) {
+      last = now;
+      lastChange = Date.now();
+      continue;
+    }
+    if (Date.now() - lastChange >= SETTLE_MS) return now;
+  }
+  return getReads();
+}
+
+test("the embedder ready poll stops at its ceiling even when reading ready throws", async () => {
+  const warns = [];
+  const store = createStore(":memory:");
+  const service = createService({
+    store,
+    mirror: null,
+    config: {},
+    logger: { warn: (...args) => warns.push(args) }
+  });
+
+  let reads = 0;
+  let closed = false;
+  const embedder = {
+    get ready() {
+      reads++;
+      if (closed) {
+        // 与 embedding.js 的 OpenAI embedder 同形：getter 内部经 settings 读库。
+        store.db.prepare("SELECT count(*) AS c FROM memories").get();
+      }
+      return false; // 始终「未就绪」：轮询会一直跑下去，除非天花板真的生效
+    }
+  };
+
+  service.setEmbedder(embedder);
+  assert.equal(reads, 1, "setEmbedder 先读一次 ready，决定要不要起轮询");
+
+  closed = true;
+  store.close(); // 卸载路径的最后一步
+
+  await waitUntilSettled(() => reads);
+  const atCeiling = reads;
+
+  assert.equal(
+    atCeiling,
+    CEILING_READS,
+    `读 ready 抛错也必须按上限停手（实际读了 ${atCeiling} 次，上限 ${CEILING_READS}）`
+  );
+  assert.equal(reads, atCeiling, "越过天花板之后不许再有读取：定时器必须已经清掉");
+  assert.equal(warns.length, 1, "读不出来只报一次，别把 3s 上限变成 30 条刷屏");
+  assert.match(String(warns[0][0]), /embedder ready probe failed/);
+});

package/test/entities.test.js

@@ -533,7 +533,9 @@ test("extractor passes provider/model/reasoningEffort through to callLLM options
   const config = { entityExtractionProvider: "openai", entityExtractionModel: "gpt-x", entityExtractionReasoning: "high" };
   const result = await extractEntities({ id: "m1", content: "Vite 是前端构建工具" }, { store, config, callLLM });
   assert.equal(result.ok, true);
-  assert.deepEqual(captured, { provider: "openai", model: "gpt-x", reasoningEffort: "high" });
+  // memoryId 是 #405 加的归属通道（审计行靠它记 related_memory_ids），与 #109 的
+  // provider/model/reasoningEffort 走同一条 options 缝；形状锁保持精确相等。
+  assert.deepEqual(captured, { provider: "openai", model: "gpt-x", reasoningEffort: "high", memoryId: "m1" });
   store.close();
 });
 
@@ -542,7 +544,16 @@ test("extractor omits empty provider/model and 'none' reasoning from options", a
   let captured = "unset";
   const callLLM = async (_m, options) => { captured = options; return JSON.stringify({ entities: [], relations: [] }); };
   await extractEntities({ id: "m2", content: "空文本" }, { store, config: {}, callLLM });
-  assert.deepEqual(captured, {}, "no provider/model/reasoning keys when unset");
+  assert.deepEqual(captured, { memoryId: "m2" }, "no provider/model/reasoning keys when unset");
+  store.close();
+});
+
+test("#405: extractor omits memoryId when the memory has no id (no fabricated attribution)", async () => {
+  const store = openStore();
+  let captured = "unset";
+  const callLLM = async (_m, options) => { captured = options; return JSON.stringify({ entities: [], relations: [] }); };
+  await extractEntities({ content: "无 id 的记忆" }, { store, config: {}, callLLM });
+  assert.deepEqual(captured, {}, "an id-less memory leaves the attribution channel empty");
   store.close();
 });
 

package/test/failure-query.test.js

@@ -0,0 +1,147 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools } from "../src/tools.js";
+
+// v0.9.0：failure_memories.query 的起点是 2,367 行里只有 69 行非空（2.9%）。
+// 但那个分母误导——按「expected 逐字落在某次 dream_runs.decisions 里」归属后
+// （2026-10-14 实测，D:/DSH/.dsh/memory/memory.db）：
+//   dream 侧 2,118 行，query 非空率 0.0%——机器巩固没有用户在场，本该为空；
+//   入口侧   249 行，query 非空率 27.7%——模型自愿填 reason 的那部分。
+// 所以要修的是入口侧，不是 dream 侧。
+//
+// 修法：工具层是唯一同时握着「改写动作」与「本轮会话」的入口（service 层只认
+// ctx.query，见 src/service.js updateMemory 内的 saveFailure 调用）。调用方没给
+// reason 时，工具自己去会话里取当轮用户原话——与注入侧共用同一份实现
+// （src/inject.js 的 lastUserQuery），不复制第二份。
+//
+// 本文件锁三件事：① 没给 reason 时真的落到原话；② 给了 reason 不被覆盖；
+// ③ 两边都取不到时写 NULL 而不是空串——空串会假装「有意图」，NULL 才说实话。
+
+function setup(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({
+    store,
+    mirror: null,
+    config: { reflectionFailureTracking: true, ...config }
+  });
+  const registered = [];
+  const ctx = { tools: { register(def) { registered.push(def); return () => {}; } } };
+  createTools(ctx, service, config, null);
+  const tool = (name) => registered.find((def) => def.name === name);
+  return { store, service, tool };
+}
+
+const seed = (store) => store.save({ type: "preference", title: "语言", content: "喜欢 Python", importance: 3 });
+
+/** exec 形状与宿主一致：工具 execute 的第二个参数（src/tools.js 里的 arguments[1]）。 */
+const execWith = (events, extra = {}) => ({
+  agent: { session: { id: "s-failure-query", snapshotEvents: () => events, ...extra } }
+});
+
+const userMessage = (text, seq) => ({
+  type: "user/message",
+  ...(seq === undefined ? {} : { seq }),
+  data: { source: { kind: "user" }, content: [{ type: "text", text }] }
+});
+
+const assistantMessage = (text, seq) => ({
+  type: "assistant/message",
+  ...(seq === undefined ? {} : { seq }),
+  data: { message: { content: [{ type: "text", text }] } }
+});
+
+const run = (def, args, exec) => def.execute.bind(def)(args, exec);
+
+test("memory_update 没给 reason 时，query 落当轮用户原话", async () => {
+  const { store, tool } = setup();
+  const mem = seed(store);
+  await run(
+    tool("memory_update"),
+    { id: mem.id, content: "喜欢 Rust" },
+    execWith([userMessage("不对，我喜欢的是 Rust，不是 Python")])
+  );
+  const [row] = store.listFailures();
+  assert.equal(row.query, "不对，我喜欢的是 Rust，不是 Python");
+  // expected/actual 语义未变：expected = 改成了什么，actual = 原本是什么。
+  assert.equal(row.expected, "喜欢 Rust");
+  assert.equal(row.actual, "喜欢 Python");
+  assert.equal(row.failure_type, "user_correction");
+  assert.equal(row.memory_id, mem.id);
+});
+
+test("memory_update 给了 reason 就用 reason，不被会话原话顶掉", async () => {
+  const { store, tool } = setup();
+  const mem = seed(store);
+  await run(
+    tool("memory_update"),
+    { id: mem.id, content: "喜欢 Rust", reason: "用户说：换成 Rust" },
+    execWith([userMessage("这句是当轮原话，但调用方已经说清了理由")])
+  );
+  assert.equal(store.listFailures()[0].query, "用户说：换成 Rust");
+});
+
+test("reason 是空白串时按「没给」处理，退回会话原话", async () => {
+  const { store, tool } = setup();
+  const mem = seed(store);
+  // 与 api-standalone 的 PUT /memories/:id 同口径（body.reason.trim() 为空即视作未提供）。
+  await run(
+    tool("memory_update"),
+    { id: mem.id, content: "喜欢 Rust", reason: "   " },
+    execWith([userMessage("换成 Rust 吧")])
+  );
+  assert.equal(store.listFailures()[0].query, "换成 Rust 吧");
+});
+
+test("两边都取不到时写 NULL，不写空串（空串会假装有意图）", async () => {
+  const { store, tool } = setup();
+  const mem = seed(store);
+  // 会话里只有助手消息 → 取不到「用户原话」。
+  await run(tool("memory_update"), { id: mem.id, content: "喜欢 Rust" }, execWith([assistantMessage("好的")]));
+  assert.equal(store.listFailures()[0].query, null);
+
+  // 完全没有 exec（老宿主 / 直调）→ 同样 NULL，不抛。
+  const mem2 = store.save({ type: "preference", title: "编辑器", content: "vim", importance: 3 });
+  await run(tool("memory_update"), { id: mem2.id, content: "emacs" });
+  assert.equal(store.listFailures()[1].query, null);
+});
+
+test("被撤回/压缩遮蔽的用户消息不算当轮原话（复用注入侧同一份实现）", async () => {
+  const { store, tool } = setup();
+  const mem = seed(store);
+  // seq 1 被 rewind 遮蔽（surface.nodes 只暴露 2）——同 inject.js visibleSeqsOf 口径。
+  // 这条同时锁住「没有抄第二份实现」：naive 的副本会漏掉可见面过滤。
+  const events = [userMessage("我想撤回的那句话", 1), assistantMessage("好", 2)];
+  await run(
+    tool("memory_update"),
+    { id: mem.id, content: "喜欢 Rust" },
+    execWith(events, { surface: { nodes: [2] } })
+  );
+  assert.equal(store.listFailures()[0].query, null, "被遮蔽的消息不许当成原话");
+});
+
+test("会话内部读不出来时退化为 NULL，不让改写本身失败", async () => {
+  const { store, tool } = setup();
+  const mem = seed(store);
+  // 宿主 getter 抛错（cordis Proxy 裸读未 inject 属性）——lastUserQuery 的 catch 兜住。
+  const exec = {
+    agent: {
+      get session() {
+        throw new Error("not injected");
+      }
+    }
+  };
+  await run(tool("memory_update"), { id: mem.id, content: "喜欢 Rust" }, exec);
+  const [row] = store.listFailures();
+  assert.equal(row.query, null);
+  assert.equal(row.expected, "喜欢 Rust", "改写本身照常完成");
+  assert.equal(store.getById(mem.id).content, "喜欢 Rust");
+});
+
+test("过长的原话按注入侧同一上限截断（不是各截各的）", async () => {
+  const { store, tool } = setup();
+  const mem = seed(store);
+  await run(tool("memory_update"), { id: mem.id, content: "喜欢 Rust" }, execWith([userMessage("长".repeat(900))]));
+  assert.equal(store.listFailures()[0].query.length, 500, "safeSlice(…, 500) 与注入侧一致");
+});

package/test/failure-retention.test.js

@@ -0,0 +1,105 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Config } from "../src/config.js";
+import { createStore } from "../src/store.js";
+
+// 与 test/recall-retention.test.js 同款，这组测试故意分两半，因为弄丢的正是「两半
+// 都在」：
+// 1. 行为锁——deleteOldFailures 真的删对行、比较方向正确、空表不炸。
+// 2. 接线锁——src/index.js 的启动块真的调它，且读的是装配后的 cfg。第二半用源码
+//    文本断言，理由与 test/client.test.js 的 bilingual 锁同款：启动期清理只在运维
+//    时才会跑到，运行时冒烟测不到「这一行被挪回装配之前了」。
+//
+// 这一批补的是「写死」这条欠账：failure_memories 的清理此前排在 createStore 之后、
+// cfg 装配之前，天数硬编码 90，是四张启动期清理表里唯一没有键可陈述的一张。
+
+const here = dirname(fileURLToPath(import.meta.url));
+const srcText = (name) => readFileSync(join(here, "..", "src", name), "utf8");
+const daysAgo = (n) => new Date(Date.now() - n * 86400000).toISOString();
+
+// saveFailure 只认当前时刻，所以插进去之后把 created_at 改写成指定时刻。
+function seedFailure(store, createdAt, id) {
+  store.saveFailure({ id, failure_type: "user_correction", expected: "新值", actual: "旧值" });
+  store.db.prepare("UPDATE failure_memories SET created_at = ? WHERE id = ?").run(createdAt, id);
+  return id;
+}
+
+test("deleteOldFailures 删掉窗口外的行、留下窗口内的行", () => {
+  const store = createStore(":memory:");
+  seedFailure(store, daysAgo(200), "old-1");
+  seedFailure(store, daysAgo(120), "old-2");
+  seedFailure(store, daysAgo(10), "fresh-1");
+  seedFailure(store, daysAgo(1), "fresh-2");
+
+  assert.equal(store.listFailures().length, 4);
+  const removed = store.deleteOldFailures(daysAgo(90));
+  assert.equal(removed, 2);
+  // assert 的是留下了哪两行，不是物理顺序
+  assert.deepEqual(store.listFailures().map((r) => r.id).sort(), ["fresh-1", "fresh-2"]);
+});
+
+test("边界两侧各留 1 小时裕量：锁的是比较方向不是毫秒级巧合", () => {
+  const store = createStore(":memory:");
+  const boundary = 90 * 86400000;
+  // cutoff 是在清理那一刻现算的，所以不骑刀刃——两侧各让开一小时。
+  seedFailure(store, new Date(Date.now() - boundary + 3600000).toISOString(), "just-inside");
+  seedFailure(store, new Date(Date.now() - boundary - 3600000).toISOString(), "just-outside");
+
+  const removed = store.deleteOldFailures(new Date(Date.now() - boundary).toISOString());
+  assert.equal(removed, 1, "只有 created_at < cutoff 的那一行该走");
+  assert.deepEqual(store.listFailures().map((r) => r.id), ["just-inside"]);
+});
+
+test("空表返回 0 且不抛", () => {
+  const store = createStore(":memory:");
+  assert.equal(store.deleteOldFailures(daysAgo(90)), 0);
+});
+
+test("配置键 reflectionFailureRetentionDays：默认 90、单位是天、边界钉死", () => {
+  assert.equal(Config({}).reflectionFailureRetentionDays, 90, "默认值必须与旧行为一致");
+  assert.equal(Config({ reflectionFailureRetentionDays: 30 }).reflectionFailureRetentionDays, 30);
+  assert.equal(Config({ reflectionFailureRetentionDays: 3650 }).reflectionFailureRetentionDays, 3650);
+  // 0 天会把这张表压成「只留最近一次」，等于废掉「挖掘重复纠正模式」的用途
+  assert.throws(() => Config({ reflectionFailureRetentionDays: 0 }));
+  assert.throws(() => Config({ reflectionFailureRetentionDays: 3651 }));
+  assert.throws(() => Config({ reflectionFailureRetentionDays: 2.5 }));
+
+  // 形状锁：与 recallRetentionDays 一族同形，别各自演化
+  assert.match(
+    srcText("config.js"),
+    /reflectionFailureRetentionDays: z\.natural\(\)\.min\(1\)\.max\(3650\)\.default\(90\)/
+  );
+  // 文档面同步：README 的键表与 docs/CONFIGURATION.md 的键表是用户唯一能读到
+  // 这个键的地方。用布尔断言而不是 assert.match——断言失败时 node:test 会把整个
+  // 文件正文打进 diff，几百行文档刷满输出，反而看不见失败点。
+  for (const doc of ["README.md", "docs/CONFIGURATION.md"]) {
+    const text = readFileSync(join(here, "..", doc), "utf8");
+    assert.ok(
+      text.includes("`reflectionFailureRetentionDays`"),
+      `${doc} 必须列出 reflectionFailureRetentionDays —— 加了键不改文档正是这一族欠账的来源`
+    );
+  }
+});
+
+test("接线锁：启动期失败表清理排在 cfg 装配之后，读键而不是写死的 90 天", () => {
+  const index = srcText("index.js");
+  const callAt = index.indexOf("store.deleteOldFailures(");
+  assert.ok(callAt > 0, "index.js 必须调用 store.deleteOldFailures");
+
+  // 装配前读 rawCfg 会漏掉面板/预设合进来的值；失败表此前正好排在装配之前。
+  const cfgAt = index.indexOf("const cfg = { ...applyLightModePreset(");
+  assert.ok(cfgAt > 0 && cfgAt < callAt, "清理必须排在 cfg 装配之后，否则读不到配置值");
+
+  const block = index.slice(callAt - 700, callAt + 200);
+  assert.match(block, /cfg\.reflectionFailureRetentionDays/, "天数必须取自配置键");
+  assert.match(block, /Number\.isInteger\(/, "非法值要能落回默认，别让 NaN 传给 SQL");
+  assert.match(block, /failureRetentionDays \* 86400000/, "键的单位是天，换算在这儿");
+
+  assert.ok(
+    !/Date\.now\(\) - 90 \* 86400000/.test(index),
+    "写死的 90 天不能回来——这正是本批在修的那条欠账"
+  );
+});

package/test/graph-api.test.js

@@ -151,7 +151,7 @@ test("entity-attrs returns current valid attrs only", async () => {
   assert.equal(r2.statusCode, 400);
 });
 
-test("ego 2-hop over 100+ nodes stays under 50ms (spec §7)", async () => {
+test("ego 2-hop traversal work is bounded by limit, not by graph size (#409)", async () => {
   const { routes, service } = setup();
   // star-of-stars: hub → 20 spokes, each spoke → 5 leaves = 121 nodes, 120 edges
   const hub = service.createEntity({ name: "hub", type: "project" });
@@ -164,6 +164,13 @@ test("ego 2-hop over 100+ nodes stays under 50ms (spec §7)", async () => {
     }
   }
   const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
+  // #409：这条用例原先断言墙钟 < 50ms，而那个「spec §7」预算在仓库文档里找不到出处。
+  // 全量并行跑实测最坏 60.4ms，于是它偶发翻车。ego 路由真正要钉住的性质是「遍历工作量
+  // 由 limit 卡死、不随图规模增长」——那是个确定性事实：请求内 getRelations 的唯一调用方
+  // 就是这次遍历，所以计数即工作量。墙钟只保留一条离群告警（放到最后）。
+  const realGetRelations = service.getRelations.bind(service);
+  let lookups = 0;
+  service.getRelations = (id) => { lookups++; return realGetRelations(id); };
   const res = new FakeRes();
   const start = process.hrtime.bigint();
   await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=hub&depth=2&limit=100"), res);
@@ -171,5 +178,32 @@ test("ego 2-hop over 100+ nodes stays under 50ms (spec §7)", async () => {
   const data = JSON.parse(res.body);
   assert.equal(data.nodes.length, 100, "limit caps the traversal");
   assert.ok(data.edges.length > 0);
-  assert.ok(ms < 50, `2-hop query took ${ms.toFixed(1)}ms, spec budget is 50ms`);
+  // 两趟（BFS + 边收集）各至多 limit 次，BFS 还会为「已满之后剩下的 frontier」多问几次，
+  // 所以上界留到 3×limit；数量级级别的退化会立刻越界。
+  assert.ok(lookups <= 300, `traversal work must be bounded by the limit, saw ${lookups} adjacency lookups`);
+
+  // 同一个查询打到约 13× 大的图上：limit 没变，该做的活就不该变。这一条不含时钟。
+  const big = setup();
+  const bigHub = big.service.createEntity({ name: "hub", type: "project" });
+  for (let i = 0; i < 40; i++) {
+    const spoke = big.service.createEntity({ name: `s-${i}`, type: "technology" });
+    big.service.saveRelation({ from_entity: bigHub.id, to_entity: spoke.id, relation_type: "uses" });
+    for (let j = 0; j < 15; j++) {
+      const leaf = big.service.createEntity({ name: `l-${i}-${j}`, type: "concept" });
+      big.service.saveRelation({ from_entity: spoke.id, to_entity: leaf.id, relation_type: "related_to" });
+    }
+  }
+  const bigReal = big.service.getRelations.bind(big.service);
+  let bigLookups = 0;
+  big.service.getRelations = (id) => { bigLookups++; return bigReal(id); };
+  const bigRes = new FakeRes();
+  await graphRoute(big.routes, "/api/dsh-mneme/semantic/graph/ego")
+    .handler(req("/api/dsh-mneme/semantic/graph/ego?entity=hub&depth=2&limit=100"), bigRes);
+  assert.equal(JSON.parse(bigRes.body).nodes.length, 100, "the same limit caps the bigger graph too");
+  assert.ok(bigLookups <= lookups + 100,
+    `${1 + 40 + 600} nodes cost ${bigLookups} lookups vs ${lookups} on 121 — work must track the limit, not the graph`);
+
+  // 墙钟只留一条离群告警，不再是规格线：它抓不到的那类退化已由上面的工作量断言确定性钉死，
+  // 250ms（≈4× 实测最坏值）只为兜住数量级级别的性能崩塌（#409）。
+  assert.ok(ms < 250, `2-hop query took ${ms.toFixed(1)}ms — the work bound above is the lock; 250ms is only an outlier guard`);
 });

package/test/hot-memory.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { createHotMemory, estimateTokens } from "../src/hot-memory.js";
+import { createHotMemory, estimateTokens, roundsFromEvents } from "../src/hot-memory.js";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createVectorIndex } from "../src/vector-index.js";
@@ -143,3 +143,69 @@ test("selective injection re-orders candidates by query similarity", () => {
   assert.equal(picked[0].id, thesis.id);
   assert.ok(picked.some((m) => m.id === plugin.id));
 });
+
+// --- roundsFromEvents：surface 投影（rewind 撤回内容不得回流热记忆） ---
+
+function userEvent(seq, text, kind) {
+  return { seq, type: "user/message", data: { source: kind ? { kind } : undefined, content: [text] } };
+}
+function assistantEvent(seq, text) {
+  return { seq, type: "assistant/message", data: { message: { content: [{ type: "text", text }] } } };
+}
+
+test("roundsFromEvents pairs user/assistant rounds and keeps the trailing pending query", () => {
+  const events = [
+    userEvent(1, "第一问"),
+    assistantEvent(2, "第一答"),
+    userEvent(3, "第二问")
+  ];
+  const rounds = roundsFromEvents(events, 5);
+  assert.equal(rounds.length, 2);
+  assert.equal(rounds[0].query, "第一问");
+  assert.equal(rounds[0].response, "第一答");
+  assert.equal(rounds[1].query, "第二问");
+  assert.equal(rounds[1].response, "");
+});
+
+test("roundsFromEvents excludes events shadowed off the surface (rewind/compact)", () => {
+  // append-only 日志里被撤回的轮次仍在，但 surface 只剩可见 seq——
+  // 热记忆必须与模型同源，被遮蔽的轮次不得回流。
+  const events = [
+    userEvent(1, "已被撤回的问题"),
+    assistantEvent(2, "已被撤回的回答"),
+    { seq: 3, type: "user/message", data: { source: { kind: "dsh-rewind" }, content: [""] } },
+    userEvent(4, "撤回后的新问题"),
+    assistantEvent(5, "撤回后的新回答")
+  ];
+  const visible = new Set([3, 4, 5]);
+  const rounds = roundsFromEvents(events, 5, visible);
+  assert.equal(rounds.length, 1);
+  assert.equal(rounds[0].query, "撤回后的新问题");
+  assert.equal(rounds[0].response, "撤回后的新回答");
+  assert.ok(!JSON.stringify(rounds).includes("已被撤回"));
+});
+
+test("roundsFromEvents with no surface info keeps the legacy full-log behavior", () => {
+  const events = [userEvent(1, "旧宿主问题"), assistantEvent(2, "旧宿主回答")];
+  const rounds = roundsFromEvents(events, 5, null);
+  assert.equal(rounds.length, 1);
+  assert.equal(rounds[0].query, "旧宿主问题");
+  assert.equal(rounds[0].response, "旧宿主回答");
+});
+
+test("roundsFromEvents skips rewind markers as queries even when on the surface", () => {
+  const events = [
+    { seq: 1, type: "user/message", data: { source: { kind: "dsh-rewind" }, content: [""] } },
+    userEvent(2, "标记后的第一问"),
+    assistantEvent(3, "标记后的第一答")
+  ];
+  const visible = new Set([1, 2, 3]);
+  const rounds = roundsFromEvents(events, 5, visible);
+  assert.equal(rounds.length, 1);
+  assert.equal(rounds[0].query, "标记后的第一问");
+});
+
+test("roundsFromEvents with an empty surface yields no rounds (model sees nothing)", () => {
+  const events = [userEvent(1, "问题"), assistantEvent(2, "回答")];
+  assert.equal(roundsFromEvents(events, 5, new Set()).length, 0);
+});

package/test/inject-recall.test.js

@@ -37,12 +37,38 @@ test("注入落账：终选集写一行 mode='inject'，candidates 为实际注
   const row = injectRow(store);
   assert.ok(row, "注入应落一行审计");
   assert.equal(row.mode, "inject");
-  // recall_runs.query 是 NOT NULL（store.js:61）：注入无查询词，用空串而非 null
+  // recall_runs.query 是 NOT NULL（store.js 的 recall_runs 建表语句，2026-10-14 在 :75）：
+  // 调用方没给查询词时用空串而非 null
   assert.equal(row.query, "");
   assert.deepEqual(row.candidates.map((c) => c.id), selected.map((m) => m.id));
   store.close();
 });
 
+// v0.9.0：注入行此前恒写空串（2026-10-13 快照 18,231/18,231 全空，即 100%），把「当时想干什么」
+// 从审计里抹掉了 —— 而 inject.js 本来就带着 lastUserQuery 传进来。这两条锁住
+// 「传了要记下来」与「没传仍是空串」，同时确认下游 recallStats 按 mode 分账不受影响。
+test("注入落账：调用方给了查询词就记真值（不再恒空串）", () => {
+  const { store, service } = setup();
+  service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 });
+  const selected = service.injectCandidates({ query: "夜航App 令牌桶怎么设计的", maxItems: 5 });
+  assert.ok(selected.length >= 1);
+  const row = injectRow(store);
+  assert.ok(row, "注入应落一行审计");
+  assert.equal(row.query, "夜航App 令牌桶怎么设计的");
+  // 下游安全：口径按 mode 分账，不看 query
+  const stats = service.recallStats({ windowDays: 30, exemptDays: 0 });
+  assert.equal(stats.injection.runs, 1);
+  store.close();
+});
+
+test("注入落账：查询词两侧空白按 trim 后入账", () => {
+  const { store, service } = setup();
+  service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 });
+  service.injectCandidates({ query: "  终端  ", maxItems: 5 });
+  assert.equal(injectRow(store).query, "终端");
+  store.close();
+});
+
 test("recallRecordDefault=false 不落账（与检索侧同门）", () => {
   const { store, service } = setup({ recallRecordDefault: false });
   service.saveWithDedupe({ type: "decision", title: "甲", content: "内容甲", importance: 4 });
@@ -103,3 +129,44 @@ test("slotFillRate = 注入条数 / (轮数 × 槽位数)", () => {
   assert.equal(stats.injection.slotFillRate, 3 / 4);
   store.close();
 });
+
+// #369：history 曾被注入白名单挡在门外（蒸馏产得出、注入收不进）。这两条断言分
+// 别锁「收编生效」与「重要度闸门对 history 不豁免」——后者一旦失效，短流水账会
+// 直接挤掉决策类条目，那才是这个改动真正的风险面。
+test("#369: history 进注入候选池", () => {
+  const { service } = setup();
+  service.saveWithDedupe({ type: "history", title: "切到暗色主题", content: "用户本次会话把界面切成暗色主题", importance: 4 });
+  const titles = service.injectCandidates({ maxItems: 5 }).map((m) => m.title);
+  assert.ok(titles.includes("切到暗色主题"), "importance>=3 的 history 应进注入候选");
+});
+
+test("#369: 低于重要度闸门的 history 不得例外放行", () => {
+  const { service } = setup();
+  service.saveWithDedupe({ type: "history", title: "打开过一次终端", content: "用户中途打开过一次终端", importance: 2 });
+  const titles = service.injectCandidates({ maxItems: 5 }).map((m) => m.title);
+  assert.ok(!titles.includes("打开过一次终端"), "history 不是 summary/preference，闸门照样生效");
+});
+
+// pattern 早已被 dreamMergeGuard 列为长保留受保护类型，却一度被当成「只由手工写入」
+// （那个判据是错的，实际是 sleep 的 phasePatterns 在 mint——见 src/service.js 的
+// INJECT_TYPES 注释）。巩固层当资产护住、注入面一次不给看是同一条口径的两头
+// 不一致，与作者是谁无关。这条锁它进池。
+test("#369: pattern 进注入候选池（与作者是谁无关）", () => {
+  const { service } = setup();
+  service.saveWithDedupe({ type: "pattern", title: "重复字符串先抽共用模块", content: "多处重复的截断逻辑先收拢成共用模块，再改调用方", importance: 5 });
+  const titles = service.injectCandidates({ maxItems: 5 }).map((m) => m.title);
+  assert.ok(titles.includes("重复字符串先抽共用模块"), "importance>=3 的 pattern 应进注入候选");
+});
+
+// CodeRabbit on PR #404：语义缓存回填分支曾独漏重要度门槛（向量路与 BM25 路都带）。
+// 一正一反：反向锁「低于闸门的行走缓存也不许进池」，正向锁「达标的照常进池」，
+// 免得断言退化成常量真；缓存没被灌进来时正向那条会先红，用例不会空压。
+test("#369: 语义缓存回填同样受重要度闸门约束", async () => {
+  const { service } = setup();
+  const low = service.saveWithDedupe({ type: "history", title: "终端开了一次", content: "用户中途打开过一次终端做检查", importance: 2 });
+  const high = service.saveWithDedupe({ type: "history", title: "终端方案定案", content: "用户终端接入方案已定案并验证", importance: 4 });
+  await service.searchMemories("终端", { mode: "keyword", useRerank: false, recordRecall: false });
+  const ids = service.injectCandidates({ query: "终端", maxItems: 5 }).map((m) => m.id);
+  assert.ok(ids.includes(high.memory.id), "i4 的 history 应经缓存回填进池（正向对照）");
+  assert.equal(ids.includes(low.memory.id), false, "低于闸门的行不得借语义缓存绕开门槛");
+});

package/test/inject.test.js

@@ -418,3 +418,26 @@ test("issue #334: snapshot query carries no lone surrogate (query path cut at ex
   assert.ok(snap.query.length > 0, "query recorded");
   assert.ok(!hasLoneSurrogate(snap.query), "snapshot query is surrogate-clean");
 });
+
+// surface.nodes 是宿主 getter：消息投影所属插件被移除时，dsh-session 的
+// _assertProjections 直接 throw。读取不设防的话，异常会冒到调用方的 try，表现为
+// 热记忆整块不渲染 + 语义查询为空——比「沿用可见面失效前的旧行为」更糟。
+// 夹具用宿主真实的抛错文案，锁住「拿不到可见面就退回全量事件」这条退化路径。
+test("throwing surface getter degrades to full-log hot memory instead of a blank block", () => {
+  const { contexts } = setup();
+  const events = [
+    { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "把投影插件卸了会怎样" }] } },
+    { type: "assistant/message", data: { message: { content: [{ type: "text", text: "热记忆不该因此整块消失" }] } } }
+  ];
+  const session = {
+    snapshotEvents: () => events,
+    get surface() {
+      throw new Error('session message projection "dsh-rewind" was removed or replaced; restore the session with its owning plugin');
+    }
+  };
+  const text = contexts[0].text({ agent: { session } });
+  assert.ok(text.includes("[短期上下文]"), "热记忆块仍应渲染");
+  assert.ok(text.includes("把投影插件卸了会怎样"), "轮次提问应照旧进入");
+  assert.ok(text.includes("热记忆不该因此整块消失"), "轮次回复应照旧进入");
+  assert.equal(getInjectionSnapshot().query, "把投影插件卸了会怎样", "语义查询不受 getter 抛错影响");
+});