@modusensus/dsh-mneme 0.12.0 → 0.14.0-beta.1

package/test/image-memory.test.js

@@ -0,0 +1,171 @@
+// Issue #611：图片记忆端到端——一张图真的走进蒸馏转录。
+//
+// 单元用例（attachment-text.test.js）只证明「块 → 文本」这一步是对的。这一份锁的是
+// 另一半：**collectMessages 真的会把它拼进发给模型的那条消息里**，并且这个数会落进
+// 审计 metadata。改动前三处 textOf 都返回空串，图-only 消息连一行都不会产出——所以
+// 这条用例在旧代码上必然红，这是它存在的理由。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSummarizer } from "../src/summarize.js";
+
+function setup(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const events = [];
+  const calls = [];
+  const ctx = {
+    on(name, fn) {
+      events.push({ name, fn });
+      return () => {};
+    },
+    llm: {
+      stream(options) {
+        calls.push(options);
+        const json = JSON.stringify([
+          { type: "history", title: "看过一张截图", content: "用户发了一张 1543x983 的截图并问数据对比", importance: 3 }
+        ]);
+        return (async function* () {
+          yield { type: "block-start", block: { type: "text" } };
+          yield { type: "text-delta", delta: json };
+          yield { type: "block-end", block: { type: "text" } };
+          yield { type: "finish", kind: "ok" };
+        })();
+      }
+    }
+  };
+  const config = { autoSummarize: true, distillRateLimitIntervalMs: 0, ...over };
+  const summarizer = createSummarizer(ctx, service, config, {});
+  return { store, service, events, calls, summarizer };
+}
+
+function imageMessage(seq, text) {
+  const content = [];
+  if (text) content.push({ type: "text", text });
+  content.push({
+    type: "image",
+    attachment: {
+      attachmentId: "sha256:abc123",
+      mediaType: "image/png",
+      width: 1543,
+      height: 983,
+      name: "屏幕截图 2026-10-19 072000.png"
+    }
+  });
+  return { seq, type: "user/message", data: { source: { kind: "user" }, content } };
+}
+
+
+test("#611 图+文消息：蒸馏转录里同时有文字与图片占位", async () => {
+  const { events, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s611-mixed",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      imageMessage(1, "能有那种数据对比吗"),
+      { seq: 2, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(calls.length, 1, "这一窗应当发起一次蒸馏");
+  const transcript = calls[0].messages.find((m) => m.role === "user").content[0].text;
+  assert.ok(transcript.includes("能有那种数据对比吗"), "文字照旧进转录");
+  assert.ok(transcript.includes("[图:"), "图片必须留下占位，而不是消失");
+  assert.ok(transcript.includes("屏幕截图 2026-10-19 072000.png"), "文件名要能对上原始附件");
+  assert.ok(transcript.includes("1543x983"), "尺寸要留下");
+});
+
+test("#611 图-only 消息不再被整条丢弃（改动前窗口里一行都没有）", async () => {
+  const { events, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s611-image-only",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [imageMessage(1, null), { seq: 2, type: "turn/end" }]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+
+  assert.equal(calls.length, 1, "图-only 窗口现在也要蒸馏——旧版这里直接 noop");
+  const transcript = calls[0].messages.find((m) => m.role === "user").content[0].text;
+  assert.ok(transcript.includes("[图:"), "占位就是这一窗的全部可提炼内容");
+});
+
+test("#611 图片张数落进审计 metadata，off 档与静默丢弃可区分", async () => {
+  const { events, service } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s611-audit",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      imageMessage(1, "第一张"),
+      imageMessage(2, "第二张"),
+      { seq: 3, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 3, type: "turn/end" });
+
+  const row = service.listLlmAudits().find((r) => r.status === "success");
+  assert.ok(row, "成功行要存在");
+  assert.equal(row.metadata?.imageCount, 2, "两张图必须被数出来");
+});
+
+test("#611 没有图时不写 imageCount（零行为变化）", async () => {
+  const { events, service } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s611-no-image",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      { seq: 1, type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "只有文字" }] } },
+      { seq: 2, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 2, type: "turn/end" });
+
+  const row = service.listLlmAudits().find((r) => r.status === "success");
+  assert.ok(row);
+  assert.equal(row.metadata?.imageCount, undefined, "没图就别写这个键，老档位逐字节不变");
+});
+test("#611 被挡掉的注入消息里的图不计入（CodeRabbit 2026-11-08 指出）", async () => {
+  // 计量的口径必须是「真正进了转录的图」，不是「窗口事件里出现过几张图」。
+  // 这条用例造一条带图的插件注入消息：它会被 publicTranscriptParts 整条挡掉
+  // （转录里没有它），所以 imageCount 不该把它算进去——否则审计会报「这窗有 1 张图」
+  // 而模型根本没看到这张图。
+  const { events, service, calls } = setup();
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const injected = {
+    seq: 1,
+    type: "user/message",
+    data: {
+      source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" },
+      content: [
+        { type: "text", text: "插件注入的机器内容" },
+        {
+          type: "image",
+          attachment: { attachmentId: "sha256:zzz", mediaType: "image/png", width: 10, height: 10, name: "不该被数.png" }
+        }
+      ]
+    }
+  };
+  const session = {
+    id: "s611-injected",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [
+      injected,
+      { seq: 2, type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "真人的一句" }] } },
+      { seq: 3, type: "turn/end" }
+    ]
+  };
+  await handler(session, { seq: 3, type: "turn/end" });
+
+  assert.equal(calls.length, 1, "窗口里有真人文本，照常蒸馏");
+  const transcript = calls[0].messages.find((m) => m.role === "user").content[0].text;
+  assert.ok(transcript.includes("真人的一句"));
+  assert.ok(!transcript.includes("插件注入的机器内容"), "注入消息本来就不进转录");
+  const row = service.listLlmAudits().find((r) => r.status === "success");
+  assert.ok(row);
+  assert.equal(row.metadata?.imageCount, undefined, "被挡掉的注入消息里的图不该被数进去");
+});

package/test/inject-parent-gate.test.js

@@ -88,13 +88,16 @@ test("#249 第二批：面板的父子关系与后端同源（漏一处就静默
   // 渲染点：子项靠 flagRow 展开。只断言「声明与文案出现过」是恒真检查——把
   // 2236 行改回 g.items.map(boolRow)，子项既不在 group.core 的 items 里、也不经
   // flagRow 渲染，面板上彻底消失，而字符串断言全绿。这一条才是那道门。
-  assert.ok(/g\.items\.map\(flagRow\)/.test(client), "分组渲染必须走 flagRow，否则子项不渲染");
+  // #427 revamp：渲染形态从 map(flagRow) 升级为 map + subAfter（子块紧贴总闸），
+  // 门锁的是「每个 items 键都经 flagRow 渲染」这件事本身。
+  assert.ok(/g\.items\.map\(\(k\) => h\(react\.Fragment, \{ key: k \}, flagRow\(k\), subAfter\[k\]\)\)/.test(client),
+    "分组渲染必须走 flagRow（经 subAfter 内联），否则子项不渲染");
   const children = client.match(/const FEATURE_CHILDREN = (\{[^}]*\})/)?.[1] ?? "";
   assert.ok(children.includes("autoInject"), "面板未声明父开关 autoInject");
-  const core = client.match(/\{ key: "group\.core", items: \[([^\]]*)\]/)?.[1] ?? "";
+  const allItems = [...client.matchAll(/items: \[([^\]]*)\]/g)].map((m) => m[1]).join("\n");
   for (const child of CHILDREN) {
     assert.ok(children.includes(`"${child}"`), `面板 FEATURE_CHILDREN 漏了 ${child}`);
-    assert.ok(!core.includes(`"${child}"`), `${child} 同时在 items 与 FEATURE_CHILDREN 里，会被渲染两次`);
+    assert.ok(!allItems.includes(`"${child}"`), `${child} 同时在 items 与 FEATURE_CHILDREN 里，会被渲染两次`);
     // 双语文案：与 test/client.test.js 的路由键同款计数（zh + en 各一份 = 2）。
     const named = client.split(`"memory.features.${child}"`).length - 1;
     const hinted = client.split(`"memory.features.${child}.hint"`).length - 1;

package/test/inject.test.js

@@ -155,6 +155,65 @@ test("Issue #129: 扁平的 data.content 形状仍被兼容", () => {
   assert.ok(text.includes("扁平形状的回答"), "flat content shape still supported");
 });
 
+// ---- issue #637: 轮内快照洪泛 ----
+// 宿主对动态 systemPrompt context 的契约是「文本变了就追加一份 runtime-context
+// 快照，旧份永久留在会话历史」。热记忆此前把「正在组装的这一轮」也配对渲染：
+// 提问先以空 A: 出现（与 prompt 里的真实 user message 重复一遍），回答落地后
+// 这一行再抖成正文——同一轮内注入块至少变两次，报告实测 4 轮 → 10 份快照、
+// 75% 重复率。注入侧省略尾部 pending 轮后，一轮内热块文本恒定，快照数降到
+// 每轮一份（回答落地时恰好变一次）。
+
+test("issue #637: the in-flight turn's query is not duplicated into the hot block", () => {
+  const { contexts } = setup();
+  // 本轮刚开头：上一轮已完成，本轮提问已落日志、回答还没来。
+  const session = {
+    id: "s1",
+    snapshotEvents: () => [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "第一问" }] } },
+      { type: "assistant/message", data: { message: { content: [{ type: "text", text: "第一答" }] } } },
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "第二问" }] } }
+    ]
+  };
+  const text = contexts[0].text({ agent: { session } });
+  assert.ok(text.includes("第一问") && text.includes("第一答"), "completed previous round replays");
+  assert.ok(!text.includes("第二问"), "the current turn's query stays only in the real user message — no empty-A duplicate");
+  assert.ok(!/\nA:\s*\n/.test(text) && !text.includes("A: \n"), "no empty-A line in the rendered block");
+});
+
+test("issue #637: renders within one turn are byte-identical (the snapshot-flood lock)", () => {
+  const { contexts } = setup();
+  const log = [
+    { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "第一问" }] } },
+    { type: "assistant/message", data: { message: { content: [{ type: "text", text: "第一答" }] } } }
+  ];
+  const render = (events) => contexts[0].text({ agent: { session: { id: "s1", snapshotEvents: () => events } } });
+  // 本轮的第一次组装：提问已落日志（回答未落地）。
+  const first = render([...log, { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "第二问" }] } }]);
+  // 工具循环中的再次组装：日志里多了 tool/assistant 中间事件，但本轮仍未闭合——
+  // 修复前这里已经是第二份快照（回答一落地就是第三份）。
+  const midTurn = render([...log,
+    { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "第二问" }] } },
+    { type: "tool/result", data: { message: { content: [{ type: "text", text: "工具输出" }] } } }
+  ]);
+  assert.equal(first, midTurn, "every assembly of the same turn renders the identical block");
+  assert.ok(first.length > 0, "the hot block still carries the completed previous round");
+});
+
+test("issue #637: the reply landing is the one change per turn; the next turn starts stable", () => {
+  const { contexts } = setup();
+  const render = (events) => contexts[0].text({ agent: { session: { id: "s1", snapshotEvents: () => events } } });
+  const u = (t) => ({ type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: t }] } });
+  const a = (t) => ({ type: "assistant/message", data: { message: { content: [{ type: "text", text: t }] } } });
+  const turnOpen = render([u("第一问")]);
+  const replyLanded = render([u("第一问"), a("第一答")]);
+  assert.ok(turnOpen === "", "the first turn renders no hot block (nothing completed yet)");
+  assert.ok(replyLanded.includes("第一问") && replyLanded.includes("第一答"), "the reply landing adds the round — the single snapshot of the turn");
+  // 下一轮开头：第三问此刻是 pending 被省略，块与上一轮收尾完全一致 → 宿主不再追快照。
+  const nextTurnOpen = render([u("第一问"), a("第一答"), u("第二问")]);
+  assert.equal(nextTurnOpen, replyLanded, "the block is stable across the turn boundary");
+});
+
+
 // ---- issue #162: 注入边界花括号转义(v0.7.4 #40 修复被 v0.7.11 误删后恢复) ----
 
 test("issue #162: {{...}} in memory content is escaped at the injection boundary", () => {

package/test/issue-617-step1-query-and-fusion.test.js

@@ -0,0 +1,361 @@
+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";
+import { createVectorIndex } from "../src/vector-index.js";
+import { createSessionGate } from "../src/session-gate.js";
+
+// #617 回归。三条缺陷各自独立成组，组内都用「一正一反」两把尺子：正向锁
+// 「改对了」，反向（关掉对应开关 / 换成对照配方）锁「这条断言真的是在测那条
+// 通路」，免得断言退化成常量真。
+
+// --- 组 1：Step 1 的当轮查询（根因 A）-------------------------------------
+//
+// 宿主 agent-loop 的每个 step 是 claim() → assemble() → step()，而 user/message
+// 要到 step() 末尾才 append。注入的 text 回调在 assemble 里求值，所以只看事件流
+// 必然慢一拍：Step 1 拿到 ""，第 N 轮的 Step 1 拿到第 N-1 轮的旧输入。
+// 票据（agent/inbox/claimed）在 claim 那一刻记原文，渲染时事件流还没长就用它。
+function setupInjector(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const contexts = [];
+  const handlers = new Map();
+  const ctx = {
+    // 真实宿主 ctx 有 on()；旧夹具没有，所以旧夹具永远测不到这条路径。
+    on(event, fn) {
+      handlers.set(event, fn);
+      return () => handlers.delete(event);
+    },
+    systemPrompt: {
+      context(def) {
+        contexts.push(def);
+        return () => {};
+      }
+    }
+  };
+  const config = { maxInjectedItems: 3, importanceThreshold: 3, ...over };
+  const injector = createInjector(ctx, service, settings, config);
+  // 查询词是注入链路里唯一能直接观测的输入：包一层记下每次渲染实际传了什么。
+  const queries = [];
+  const orig = service.injectCandidates.bind(service);
+  service.injectCandidates = (args) => {
+    queries.push(args.query);
+    return orig(args);
+  };
+  const fireClaim = (message, session) => handlers.get("agent/inbox/claimed")?.({ message, agent: { session } });
+  return { store, service, contexts, injector, queries, fireClaim, handlers };
+}
+
+const userMessage = (text) => ({ type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text }] } });
+const claimed = (text) => ({ content: [{ type: "text", text }], source: { kind: "user" }, id: "m1" });
+
+test("#617-A: Step 1 在 user/message 落盘之前，用认领票据拿到当轮输入", () => {
+  const { contexts, queries, fireClaim } = setupInjector();
+  const session = { id: "s-617", events: [], snapshotEvents() { return this.events; } };
+  // claim 发生在 assemble 之前，此刻事件流里还没有本轮消息
+  fireClaim(claimed("夜航App令牌桶限流方案怎么设计"), session);
+  assert.equal(session.events.length, 0, "夹具前提：认领时 user/message 尚未落盘");
+  contexts[0].text({ agent: { session } });
+  assert.equal(queries.at(-1), "夜航App令牌桶限流方案怎么设计", "Step 1 必须拿到当轮输入，而不是空串");
+});
+
+test("#617-A: claim 与 assemble 之间插入无关事件，票据不得提前退休", () => {
+  // 宿主 preStep 的顺序是 claim() → await tools.resolve() → assemble()。中间那个
+  // await 给了别的插件追加事件的机会；若按「事件条数变多」判票据失效，Step 1 就
+  // 又退回空串——正是本 issue 要修的那一拍。判据必须是文本，不是条数。
+  const { contexts, queries, fireClaim } = setupInjector();
+  const session = { id: "s-617i", events: [], snapshotEvents() { return this.events; } };
+  session.events.push(userMessage("上一轮的问题"));
+  fireClaim(claimed("这一轮的新问题"), session);
+  // tools.resolve 期间，别的插件追加了一个与用户消息无关的事件
+  session.events.push({ type: "system/message", data: { content: [{ type: "text", text: "插件上下文" }] } });
+  contexts[0].text({ agent: { session } });
+  assert.equal(queries.at(-1), "这一轮的新问题", "无关事件不得让票据提前失效");
+});
+
+test("#617-A: 事件流长过票据记录后，票据退休、以事件流为准", () => {
+  const { contexts, queries, fireClaim } = setupInjector();
+  const session = { id: "s-617b", events: [], snapshotEvents() { return this.events; } };
+  fireClaim(claimed("第一个问题"), session);
+  contexts[0].text({ agent: { session } });
+  assert.equal(queries.at(-1), "第一个问题");
+  // step() 末尾 append → 事件流变长
+  session.events.push(userMessage("第一个问题"));
+  contexts[0].text({ agent: { session } });
+  assert.equal(queries.at(-1), "第一个问题", "落盘后两者一致（此轮无差异）");
+  // 下一轮：新的 claim 覆盖票据，事件流里仍是上一轮的文本
+  fireClaim(claimed("第二个问题"), session);
+  contexts[0].text({ agent: { session } });
+  assert.equal(queries.at(-1), "第二个问题", "新一轮的 Step 1 不得拿到上一轮的旧输入");
+});
+
+test("#617-A: 非人类消息（source.kind 非 user）不产生票据", () => {
+  const { contexts, queries, fireClaim } = setupInjector();
+  const session = { id: "s-617c", events: [], snapshotEvents() { return this.events; } };
+  fireClaim({ content: [{ type: "text", text: "插件注入的上下文" }], source: { kind: "system" } }, session);
+  contexts[0].text({ agent: { session } });
+  assert.equal(queries.at(-1), "", "插件自己的话不得被当成用户问题");
+});
+
+test("#617-A: 卸载后摘掉 claimed 监听，不再写票据", () => {
+  const { contexts, injector, queries, fireClaim, handlers } = setupInjector();
+  const session = { id: "s-617d", events: [], snapshotEvents() { return this.events; } };
+  assert.ok(handlers.has("agent/inbox/claimed"), "挂载时注册监听");
+  injector();
+  assert.equal(handlers.has("agent/inbox/claimed"), false, "卸载即摘，不留孤儿监听");
+  fireClaim(claimed("卸载后不该记"), session);
+  // 注入器已卸载，context 也不再生效；这里只确认没有票据泄漏到下一次装配
+  assert.equal(queries.length, 0);
+  void contexts;
+});
+
+// --- 组 2：prefetch 去重与失败冷却（根因 B）-------------------------------
+//
+// 旧实现用 lastPrefetched 字符串去重，且置位在 await 之前 —— 同一条查询第一次
+// 失败（模型没下好、超时）之后永不重试，而那恰好是最需要重试的一次。
+function setupPrefetch(embedImpl) {
+  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 calls = [];
+  service.setEmbedder({
+    embedSingle: async (text) => {
+      calls.push(text);
+      return embedImpl(text);
+    }
+  });
+  const injector = createInjector(ctx, service, settings, { maxInjectedItems: 3, importanceThreshold: 3 });
+  return { store, service, contexts, injector, calls };
+}
+
+const renderWith = (contexts, session) => contexts[0].text({ agent: { session } });
+const tick = () => new Promise((r) => setTimeout(r, 0));
+
+test("#617-B: 同一步的两次求值（assemble + refreshContext）只嵌一次", async () => {
+  const { contexts, calls } = setupPrefetch(async () => [1, 0, 0]);
+  const session = { id: "p1", events: [userMessage("查询文本")], snapshotEvents() { return this.events; } };
+  renderWith(contexts, session); // 第一次求值：发起 inflight
+  renderWith(contexts, session); // 第二次求值：必须复用 inflight，不再嵌
+  await tick();
+  renderWith(contexts, session); // 第三次：命中缓存
+  assert.equal(calls.length, 1, "同一条查询只应嵌入一次");
+});
+
+test("#617-B: 失败后进入冷却期，不在同一帧反复撞模型", async () => {
+  const { contexts, calls } = setupPrefetch(async () => { throw new Error("model not ready"); });
+  const session = { id: "p2", events: [userMessage("失败查询")], snapshotEvents() { return this.events; } };
+  renderWith(contexts, session);
+  await tick();
+  renderWith(contexts, session);
+  await tick();
+  renderWith(contexts, session);
+  assert.equal(calls.length, 1, "冷却期内不得重试（15s 内）");
+});
+
+test("#617-B: 冷却按查询分别计，别的查询照常嵌入", async () => {
+  const { contexts, calls } = setupPrefetch(async (text) => {
+    if (text.includes("失败")) throw new Error("boom");
+    return [1, 0, 0];
+  });
+  const s1 = { id: "p3", events: [userMessage("失败查询")], snapshotEvents() { return this.events; } };
+  renderWith(contexts, s1);
+  await tick();
+  renderWith(contexts, s1);
+  const s2 = { id: "p4", events: [userMessage("另一条查询")], snapshotEvents() { return this.events; } };
+  renderWith(contexts, s2);
+  await tick();
+  assert.equal(calls.length, 2, "一条查询的失败冷却不应连坐其它查询");
+});
+
+// --- 组 3：向量路与 BM25 路并存（根因 C，前半）----------------------------
+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;
+}
+
+function setupDualPath(config = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config });
+  return { store, service };
+}
+
+test("#617-C: 有向量命中时，BM25 的词法精确命中不再整批消失", () => {
+  const { service, store } = setupDualPath();
+  seedStalePreferences(service, 8);
+  // 与查询词法完全不相交，但向量最近
+  const vecOnly = service.saveWithDedupe({
+    type: "project", title: "星图渲染重构", content: "绘制管线迁移与图层合并", importance: 3
+  }).memory;
+  // 词法精确命中，但没有向量（真实库里大量老行就是这样）
+  const lexHit = service.saveWithDedupe({
+    type: "decision", title: "夜航限流选型", content: "决定采用令牌桶做夜航App的限流方案", importance: 3
+  }).memory;
+  const vectorIndex = createVectorIndex({ store });
+  service.setVectorIndex(vectorIndex);
+  vectorIndex.saveEmbedding(vecOnly.id, [1, 0, 0]);
+
+  const picked = service.injectCandidates({
+    query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3, queryVector: [1, 0, 0]
+  });
+  assert.equal(picked[0].id, vecOnly.id, "纯余弦命中仍是首位");
+  assert.ok(picked.some((m) => m.id === lexHit.id), "BM25 命中不得被向量路挤掉（旧代码：有向量则 BM25 整段跳过）");
+  assert.ok(picked.length <= 5, "池子仍按 maxItems 封顶");
+  store.close();
+});
+
+test("#617-C: 关掉 BM25 后同一条词法命中确实消失（反向对照）", () => {
+  const { service, store } = setupDualPath({ bm25SearchEnabled: false });
+  seedStalePreferences(service, 8);
+  const vecOnly = service.saveWithDedupe({
+    type: "project", title: "星图渲染重构", content: "绘制管线迁移与图层合并", importance: 3
+  }).memory;
+  const lexHit = service.saveWithDedupe({
+    type: "decision", title: "夜航限流选型", content: "决定采用令牌桶做夜航App的限流方案", importance: 3
+  }).memory;
+  const vectorIndex = createVectorIndex({ store });
+  service.setVectorIndex(vectorIndex);
+  vectorIndex.saveEmbedding(vecOnly.id, [1, 0, 0]);
+
+  const picked = service.injectCandidates({
+    query: "夜航App令牌桶限流方案怎么设计的", maxItems: 5, threshold: 3, queryVector: [1, 0, 0]
+  });
+  assert.equal(picked[0].id, vecOnly.id);
+  assert.equal(picked.some((m) => m.id === lexHit.id), false, "BM25 关 = 词法路不参与，正向用例才不是在测别的东西");
+  store.close();
+});
+
+// --- 组 4：auto 不再被 keyword 覆盖（根因 C，后半）------------------------
+//
+// 旧代码在 fuseRecall 收尾处，只要 recipe !== "blend" 且 mode === "auto"，就用
+// keyword.slice(0,lim) 覆盖 merged —— 于是配了 rrf 却拿到 keyword 的顺序，配方
+// 白选。auto 的「关键词领位」语义只属于 blend。
+function setupFusion(recipe) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { recallFusion: recipe } });
+  // 标题命中（keyword 第一），但没有向量
+  const kwTitle = service.saveWithDedupe({
+    type: "preference", title: "令牌桶限流笔记", content: "随手记的限流笔记", importance: 2
+  }).memory;
+  // 正文命中（keyword 第二）+ 向量第一 —— 两路都靠前
+  const both = service.saveWithDedupe({
+    type: "decision", title: "夜航限流选型", content: "决定采用令牌桶限流方案，阈值按等级分层", importance: 5
+  }).memory;
+  const vectorIndex = createVectorIndex({ store });
+  service.setVectorIndex(vectorIndex);
+  vectorIndex.saveEmbedding(both.id, [1, 0, 0]);
+  service.setEmbedder({ embedSingle: async () => [1, 0, 0] });
+  return { service, store, kwTitle, both };
+}
+
+test("#617-C: recallFusion=rrf 时 auto 用 RRF 自己的排序，不再被 keyword 覆盖", async () => {
+  const { service, store, kwTitle, both } = setupFusion("rrf");
+  const rows = await service.searchMemories("令牌桶限流", { mode: "auto", topK: 2, useRerank: false, recordRecall: false });
+  assert.equal(rows.length, 2);
+  assert.equal(rows[0].id, both.id, "两路都命中的行必须排第一（keyword 只命中标题的行不该领位）");
+  assert.equal(rows[1].id, kwTitle.id);
+  store.close();
+});
+
+test("#617-C: blend 的 auto 关键词领位契约保持不变（反向对照）", async () => {
+  const { service, store, kwTitle, both } = setupFusion("blend");
+  const rows = await service.searchMemories("令牌桶限流", { mode: "auto", topK: 2, useRerank: false, recordRecall: false });
+  assert.equal(rows.length, 2);
+  assert.equal(rows[0].id, kwTitle.id, "blend 下 keyword 领位是既有契约，本次改动不该碰它");
+  assert.equal(rows[1].id, both.id);
+  store.close();
+});
+
+// --- 组 5：无痕会话的认领路径不得外发（#539 × #617）-----------------------
+//
+// claim 在宿主 pre-step 里同步触发，早于 assemble，因此也早于渲染侧的闸门判断。
+// 这条路径既写票据（票据会成为注入查询文本）又预取向量（embedQuery 直接 POST
+// 外部 /embeddings），闸门命中时两者都是该会话数据的外流；嵌入层自身没有任何
+// 会话维度判断（embedding.js / service.js 里 sessionGate 零命中），这里是唯一
+// 拦截点。两条反向对照（未命中名单 / 总开关关闭）保证断言不是退化成「嵌入器
+// 恰好没跑」。
+function setupGated(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const contexts = [];
+  const handlers = new Map();
+  const ctx = {
+    on(event, fn) {
+      handlers.set(event, fn);
+      return () => handlers.delete(event);
+    },
+    systemPrompt: { context(def) { contexts.push(def); return () => {}; } }
+  };
+  const calls = [];
+  service.setEmbedder({
+    embedSingle: async (text) => {
+      calls.push(text);
+      return [1, 0, 0];
+    }
+  });
+  const queries = [];
+  const orig = service.injectCandidates.bind(service);
+  service.injectCandidates = (args) => {
+    queries.push(args.query);
+    return orig(args);
+  };
+  const sessionGate = createSessionGate({
+    sessionGateEnabled: true,
+    sessionGateSessions: ["s-gated"],
+    sessionGateSubagents: true,
+    ...over
+  });
+  const injector = createInjector(
+    ctx, service, settings, { maxInjectedItems: 3, importanceThreshold: 3 }, null, sessionGate
+  );
+  const fireClaim = (message, session) => handlers.get("agent/inbox/claimed")?.({ message, agent: { session } });
+  return { store, service, contexts, injector, calls, queries, fireClaim, sessionGate };
+}
+
+test("#617-D: 无痕会话的认领消息既不预取向量，也不留票据", async () => {
+  const { contexts, calls, queries, fireClaim, sessionGate } = setupGated();
+  const session = { id: "s-gated", events: [], snapshotEvents() { return this.events; } };
+  assert.equal(sessionGate.isOff(session), true, "夹具前提：闸门认得出这个会话");
+  fireClaim(claimed("桉桉的私人日记：我今天去了协和医院复查"), session);
+  await tick();
+  assert.equal(calls.length, 0, "闸门命中时不得把原文发往嵌入端点");
+  // 票据若被写下，渲染时事件流还没长，Step 1 就会拿到这段原文
+  contexts[0].text({ agent: { session } });
+  assert.deepEqual(queries, [], "闸门命中时连 injectCandidates 都不该被调到");
+});
+
+test("#617-D: 未命中名单的会话照常预取（反向对照）", async () => {
+  const { contexts, calls, queries, fireClaim, sessionGate } = setupGated();
+  const session = { id: "s-normal", events: [], snapshotEvents() { return this.events; } };
+  assert.equal(sessionGate.isOff(session), false);
+  fireClaim(claimed("夜航App令牌桶限流方案怎么设计"), session);
+  await tick();
+  assert.equal(calls.length, 1, "普通会话的预取行为不变");
+  assert.equal(calls[0], "夜航App令牌桶限流方案怎么设计");
+  // 票据确实写下了：渲染拿到的就是认领的原文
+  contexts[0].text({ agent: { session } });
+  assert.deepEqual(queries, ["夜航App令牌桶限流方案怎么设计"]);
+});
+
+test("#617-D: 总开关关闭时闸门不生效（反向对照）", async () => {
+  const { calls, fireClaim, sessionGate } = setupGated({ sessionGateEnabled: false });
+  const session = { id: "s-gated", events: [], snapshotEvents() { return this.events; } };
+  assert.equal(sessionGate.isEnabled(), false);
+  assert.equal(sessionGate.isOff(session), false, "总开关关时名单不得生效");
+  fireClaim(claimed("夜航App令牌桶限流方案怎么设计"), session);
+  await tick();
+  assert.equal(calls.length, 1, "未开启 #539 时不得凭空拦截（默认行为须与基线一致）");
+});