@modusensus/dsh-mneme 0.8.16 → 0.9.0

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/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 });
@@ -121,9 +147,11 @@ test("#369: 低于重要度闸门的 history 不得例外放行", () => {
   assert.ok(!titles.includes("打开过一次终端"), "history 不是 summary/preference，闸门照样生效");
 });
 
-// pattern 只由手工写入，却已被 dreamMergeGuard 列为长保留受保护类型——巩固层当资产
-// 护住、注入面一次不给看是同一条口径的两头不一致。这条锁它进池。
-test("#369: 手写的 pattern 进注入候选池", () => {
+// 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);

package/test/llm-audit.test.js

@@ -2,7 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { EventEmitter } from "node:events";
 import { DatabaseSync } from "node:sqlite";
-import { mkdtempSync } from "node:fs";
+import { mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Context } from "@deepseek-ai/cordis";
@@ -622,6 +622,97 @@ test("entity extraction writes no audit row when llmAudit.enabled === false", as
   store.close();
 });
 
+// #405：实体抽取的审计行此前把失败原因压成一句常量、related_memory_ids 恒空，于是
+// 429 / 配额 / 鉴权 / 超时在库里长得一模一样（主库 735 条 entity_extract error 行全
+// 是「llm stream aborted or errored」），也查不出是哪条记忆没抽到实体。四条锁：原因
+// 落进 error_message（复用 dream 的 describeStreamFailure，全仓归一只此一份）、无
+// 细节时退回旧字面量、归属 id 传得进来且不凭空造、抛错路径同样带归属。
+test("#405: entity extraction audit records the stream failure cause, not a constant", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        yield {
+          type: "finish",
+          reason: { kind: "error", failure: { code: "rate_limited", message: "429 Too Many Requests", status: 429 } }
+        };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    { memoryId: "mem-1" }
+  );
+  assert.equal(text, undefined, "a failed stream yields no text");
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.equal(row.status, "error");
+  assert.equal(row.error_message, "rate_limited: 429 Too Many Requests",
+    "code + message from chunk.reason.failure survive into the audit row");
+  assert.notEqual(row.error_message, "llm stream aborted or errored",
+    "the constant that made every provider failure look identical is gone");
+  assert.deepEqual(row.related_memory_ids, ["mem-1"],
+    "the row is attributable to the memory that was being extracted");
+  store.close();
+});
+
+test("#405: entity extraction audit keeps the legacy wording when the failure has no detail", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        // 老形态：只有 kind，既没有 failure 也没有 message（dsh-llm 早期版本、或
+        // 替身）。这时退回旧字面量——把 error_message 写成空串在库里比一句常量更
+        // 难查，那等于用另一种方式把原因丢掉。
+        yield { type: "finish", reason: { kind: "aborted" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  await streamEntityText([{ role: "user", content: [{ type: "text", text: "记忆内容" }] }], {});
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.equal(row.error_message, "llm stream aborted or errored");
+  assert.deepEqual(row.related_memory_ids, [], "no memoryId → still empty, never fabricated");
+  store.close();
+});
+
+test("#405: entity extraction audit attributes a thrown stream error to the memory too", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        throw new Error("socket hang up");
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  await streamEntityText([{ role: "user", content: [{ type: "text", text: "记忆内容" }] }], { memoryId: "mem-9" });
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.equal(row.status, "error");
+  assert.equal(row.error_message, "socket hang up");
+  assert.deepEqual(row.related_memory_ids, ["mem-9"], "the throw path attributes too");
+  store.close();
+});
+
+test("#405: the failure-cause formatter stays a single implementation", async () => {
+  const indexSrc = readFileSync(new URL("../src/index.js", import.meta.url), "utf8");
+  const dreamSrc = readFileSync(new URL("../src/dream.js", import.meta.url), "utf8");
+  assert.match(indexSrc, /describeStreamFailure/, "index.js reuses dream.js's formatter");
+  // 有人在这里就地重写 code/message 拼接，就又多出一份口径——#411 的教训是「复制
+  // 粘贴漂移不是设计，是漂移」。锁死两端：归一逻辑只许在 dream.js 里存在一次。
+  assert.equal(indexSrc.match(/failure\.code/g), null, "index.js must not re-format the failure code itself");
+  assert.equal(dreamSrc.match(/function describeStreamFailure\(/g).length, 1, "exactly one definition");
+});
+
 // 启动期保留清理（Bug8）必须与写入侧读**同一份**配置。面板把 llmAudit.enabled 写进
 // kv、经 nestedFlags 合进 cfg，bundle 里可能是关的：清理若读 rawCfg，就会出现「面板
 // 说开 → 各写入点照写，raw 说关 → 不清理」这种无保留期的增长（写入准入 #254 也是读