@modusensus/dsh-mneme 0.8.15 → 0.9.0

package/test/reclaim-http.test.js

@@ -0,0 +1,209 @@
+// 存储回收（maintenance/reclaim）的 HTTP 口径 —— 共用模块自己的锁。
+//
+// 这个文件盯两类回归：
+//   a) 口径本身（解析、校验、答复形状）。表驱动跑全量边界，因为这张脸有两个入口，
+//      任何一处口径松掉都会同时污染面板与数据面；
+//   b) **不许再长出第二份实现**。历史上两个入口是整段复制的，于是 #410 修好面板侧
+//      之后数据面还停在旧形态（#411）。下面的静态锁把「校验字面量只许出现在本模块」
+//      写成断言：谁要是再复制一段出去，这里直接转红。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  MAX_RECLAIM_WINDOW_DAYS,
+  RECLAIM_CONFIRM_HINT,
+  parseReclaimQuery,
+  parseReclaimJson,
+  readReclaimFields,
+  reclaimReply
+} from "../src/reclaim-http.js";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+/** 假 maintenance：记下每次调用的实参，回一个固定报告对象（用来锁「不加包装层」）。 */
+function fakeMaintenance(report = { dryRun: true, planned: { dream_run_inputs: 1 } }) {
+  const calls = [];
+  return {
+    calls,
+    reclaim(options) {
+      calls.push(options);
+      return report;
+    }
+  };
+}
+
+// ---------------------------------------------------------------------------
+// GET 侧：query 是字符串域
+// ---------------------------------------------------------------------------
+test("parseReclaimQuery: 只收十进制整数字面量，缺省才落默认窗口", () => {
+  assert.deepEqual(parseReclaimQuery(null), { ok: true, olderThanDays: undefined }, "不传 = 落默认窗口");
+  assert.deepEqual(parseReclaimQuery("0"), { ok: true, olderThanDays: 0 }, "0 是合法值（清全部快照）");
+  assert.deepEqual(parseReclaimQuery("3"), { ok: true, olderThanDays: 3 });
+  assert.deepEqual(parseReclaimQuery(String(MAX_RECLAIM_WINDOW_DAYS)), { ok: true, olderThanDays: MAX_RECLAIM_WINDOW_DAYS }, "上界本身合法");
+});
+
+test("parseReclaimQuery: 畸形输入一律 400，绝不被静默读成 0", () => {
+  // Number() 会把 ""/[]/" " 都化成 0，而 0 在这里是「清掉全部快照」——最坏解释绝不能
+  // 从一个畸形输入静默拿到。所以这里的每一条都必须拒，而不是回落。
+  for (const bad of ["", " ", "3.5", "-1", "1e3", "0x10", "٣", "3 ", "+3", "abc"]) {
+    assert.deepEqual(
+      parseReclaimQuery(bad),
+      { ok: false, error: "invalid-older-than-days" },
+      `olderThanDays=${JSON.stringify(bad)} 必须被拒`
+    );
+  }
+});
+
+test("parseReclaimQuery: 量级超界被拒（十进制字面量不保证是个能算日期的数）", () => {
+  // 400 位十进制字面量会化成 Infinity，maintenance 拿它算日期直接抛 RangeError。
+  for (const huge of [String(MAX_RECLAIM_WINDOW_DAYS + 1), "100000000000000000000", "9".repeat(400)]) {
+    assert.deepEqual(parseReclaimQuery(huge), { ok: false, error: "invalid-older-than-days" }, `olderThanDays=${huge.slice(0, 12)}… 必须被拒`);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// POST 侧：JSON 数字域
+// ---------------------------------------------------------------------------
+test("parseReclaimJson: invalid-json 与 invalid-body 是两个不同的错", () => {
+  assert.deepEqual(parseReclaimJson(""), { ok: true, body: {} }, "空 body 等价于 {}");
+  assert.deepEqual(parseReclaimJson('{"a":1}'), { ok: true, body: { a: 1 } });
+  assert.deepEqual(parseReclaimJson("{bad"), { ok: false, error: "invalid-json" }, "发坏了");
+  assert.deepEqual(parseReclaimJson("null"), { ok: false, error: "invalid-body" }, "发成了 null");
+  assert.deepEqual(parseReclaimJson("[]"), { ok: false, error: "invalid-body" }, "发成了数组");
+  assert.deepEqual(parseReclaimJson('"x"'), { ok: false, error: "invalid-body" }, "发成了字符串");
+});
+
+test("readReclaimFields: 默认值与透传", () => {
+  assert.deepEqual(
+    readReclaimFields({}),
+    { ok: true, dryRun: true, olderThanDays: undefined, vacuum: false, confirm: false },
+    "缺省 = dry-run、默认窗口、不 VACUUM、未确认"
+  );
+  assert.deepEqual(
+    readReclaimFields({ dryRun: false, olderThanDays: 30, vacuum: true, confirm: true }),
+    { ok: true, dryRun: false, olderThanDays: 30, vacuum: true, confirm: true }
+  );
+  assert.deepEqual(readReclaimFields({ olderThanDays: null }).olderThanDays, undefined, "null 与缺省同义：落默认窗口，不是 0");
+  assert.deepEqual(readReclaimFields({ olderThanDays: 0 }).olderThanDays, 0, "0 是合法值");
+  assert.deepEqual(readReclaimFields({ olderThanDays: MAX_RECLAIM_WINDOW_DAYS }).olderThanDays, MAX_RECLAIM_WINDOW_DAYS);
+});
+
+test("readReclaimFields: 只收 JSON 数字，量级与形状都要过", () => {
+  for (const bogus of ["", [], false, "3", true, 3.5, -1]) {
+    assert.deepEqual(
+      readReclaimFields({ olderThanDays: bogus }),
+      { ok: false, error: "invalid-older-than-days" },
+      `olderThanDays=${JSON.stringify(bogus)} 必须被拒`
+    );
+  }
+  // 上界与 GET 侧同一条：1e20 也是「整数」，但 maintenance 拿它算日期会抛 RangeError。
+  for (const huge of [MAX_RECLAIM_WINDOW_DAYS + 1, 1e20, 1e21]) {
+    assert.deepEqual(readReclaimFields({ olderThanDays: huge }), { ok: false, error: "invalid-older-than-days" });
+  }
+  assert.deepEqual(readReclaimFields({ vacuum: "true" }), { ok: false, error: "invalid-vacuum" }, "vacuum 只收布尔");
+  assert.equal(readReclaimFields({ confirm: "true" }).confirm, false, "confirm 只认真布尔：字符串不算确认");
+});
+
+// ---------------------------------------------------------------------------
+// 答复：两个入口共用的那一份
+// ---------------------------------------------------------------------------
+test("reclaimReply: 没接线时 503，且根本不碰 maintenance", () => {
+  const out = reclaimReply({ maintenance: null, dryRun: true });
+  // 字面量而不是常量：这是调用方要分支的错误码，改一个字母就是对外行为变更。
+  assert.deepEqual(out, { status: 503, body: { error: "maintenance-unavailable" } });
+});
+
+test("reclaimReply: dry-run 报原样透传，不加包装层", () => {
+  const report = { dryRun: true, planned: { dream_run_inputs: 1 }, olderThanDays: 7 };
+  const maintenance = fakeMaintenance(report);
+  const out = reclaimReply({ maintenance, dryRun: true, olderThanDays: 7 });
+  assert.equal(out.status, 200);
+  assert.equal(out.body, report, "报告必须原样回，套一层 {report} 会打断既有消费方");
+  assert.deepEqual(maintenance.calls, [{ olderThanDays: 7, vacuum: false, dryRun: true }]);
+});
+
+test("reclaimReply: 缺 confirm 只回报告不执行，且报告描述的是将要执行的那个动作", () => {
+  const report = { dryRun: true, vacuum: { requested: true, ran: false } };
+  const maintenance = fakeMaintenance(report);
+  const out = reclaimReply({ maintenance, dryRun: false, olderThanDays: 30, vacuum: true });
+  assert.equal(out.status, 400);
+  assert.equal(out.body.error, "confirm-required");
+  assert.equal(out.body.hint, RECLAIM_CONFIRM_HINT, "提示是给调用方看的下一步动作，两个入口必须逐字一致");
+  assert.equal(out.body.report, report);
+  assert.deepEqual(
+    maintenance.calls,
+    [{ olderThanDays: 30, vacuum: true, dryRun: true }],
+    "报告必须带 vacuum：否则调用方看到的是「不 VACUUM」的数字，却带着 vacuum 去执行"
+  );
+});
+
+test("reclaimReply: 确认后按原样执行", () => {
+  const maintenance = fakeMaintenance({ dryRun: false, cleared: { dream_run_inputs: 1 } });
+  const out = reclaimReply({ maintenance, dryRun: false, olderThanDays: 30, vacuum: true, confirm: true });
+  assert.equal(out.status, 200);
+  assert.deepEqual(maintenance.calls, [{ olderThanDays: 30, vacuum: true, dryRun: false }]);
+});
+
+test("reclaimReply: 抛错回 500 并留日志，原始错误文本不能吞", () => {
+  const warnings = [];
+  const maintenance = {
+    reclaim() { throw new Error("database is locked"); }
+  };
+  for (const input of [
+    { dryRun: true },
+    { dryRun: false, confirm: true },
+    { dryRun: false } // confirm-required 那份报告也是这里算的（#410）
+  ]) {
+    const out = reclaimReply({ maintenance, ...input, warn: (m) => warnings.push(String(m)) });
+    assert.equal(out.status, 500, "三条会调 reclaim 的路径都必须回 500，不能无响应");
+    assert.deepEqual(out.body, { error: "internal" });
+  }
+  assert.equal(warnings.length, 3);
+  for (const w of warnings) {
+    assert.match(w, /storage reclaim failed/);
+    assert.match(w, /database is locked/, "原始错误文本要留住，否则现场无从下手");
+  }
+});
+
+test("reclaimReply: 没有 logger 也不许把异常漏出去", () => {
+  // warn 是可选的（数据面可能没接 logger）。少一个回调不能让异常穿出去变成
+  // unhandled rejection——那正是 #410 的形态：客户端拿到的是「一个字节都没回」。
+  const maintenance = { reclaim() { throw new Error("boom"); } };
+  const out = reclaimReply({ maintenance, dryRun: false });
+  assert.equal(out.status, 500);
+});
+
+// ---------------------------------------------------------------------------
+// 防分叉：口径只许有一份实现
+// ---------------------------------------------------------------------------
+test("两个入口都不许再自己写一份回收口径", () => {
+  // 每个字面量都是这张脸独有的：出现第二次就意味着又复制了一段校验/答复出去。
+  const FORKED = [
+    '"invalid-older-than-days"',
+    '"invalid-vacuum"',
+    '"confirm-required"',
+    '"maintenance-unavailable"',
+    "storage reclaim failed",
+    "MAX_RECLAIM_WINDOW_DAYS"
+  ];
+  for (const name of ["api.js", "api-standalone.js"]) {
+    const src = readFileSync(join(ROOT, "src", name), "utf8");
+    for (const literal of FORKED) {
+      assert.equal(
+        src.includes(literal),
+        false,
+        `src/${name} 里不该再出现 ${literal}——回收口径只有 src/reclaim-http.js 一份`
+      );
+    }
+    // 反向也要锁：光删掉字面量、不调共用模块，等于把功能删了。
+    assert.ok(src.includes("reclaim-http.js"), `src/${name} 必须从共用模块取口径`);
+  }
+  const panel = readFileSync(join(ROOT, "src", "api.js"), "utf8");
+  const data = readFileSync(join(ROOT, "src", "api-standalone.js"), "utf8");
+  assert.ok(panel.includes("reclaimReply("), "面板侧要真的走共用答复");
+  assert.ok(data.includes("reclaimReply("), "数据面要真的走共用答复");
+  assert.ok(panel.includes("readReclaimFields("), "面板侧 POST 要真的走共用校验");
+  assert.ok(data.includes("readReclaimFields("), "数据面要真的走共用校验");
+});

package/test/release-workflow.test.js

@@ -0,0 +1,77 @@
+// .github/workflows/release.yml 的作业依赖锁。
+//
+// 防的是一类「声明抢跑」：GitHub Release 是对外的「这个版本已发布」，registry 才是唯一事实。
+// 2026-10-12 修 Verify published version 假闸门（PR #419）时发现隔壁还有同一处豁口——release
+// job 只 needs [verify, test]，于是 publish 真失败（token 失效、registry 拒绝）时 Release 照样
+// 建出来：Release 页写着 v0.8.x，registry 上却没有，用户照 Release 装回的是上一个版本。
+//
+// 三条断言各锁一环，缺一环这类豁口就能重开：
+//   1. release 必须等 publish —— 否则「发不出去」和「发出去了」在 Release 页上同形；
+//   2. publish 必须含那道阻塞闸门（publish-gate.mjs）—— 否则 release 等的是一个不做校验的空壳，
+//      第 1 条形同虚设（改回 `npm view` 一次性查询同样会退回假绿）；
+//   3. release 仍要等 verify 与 test —— 免得为了修 1 顺手把版本/CHANGELOG 校验也绕过去。
+//
+// 工作流是 YAML，但为了三条断言引入 YAML 解析依赖不值得：这里只按缩进取作业块、读它自己的
+// needs 行。因此断言落在「内联列表形状」上（`needs: [a, b]`）——有人改成块状列表测试会红，
+// 那是真变化，值得人看一眼再改锁，而不是静默失效。
+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";
+
+const workflowPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", ".github", "workflows", "release.yml");
+const workflow = readFileSync(workflowPath, "utf8");
+
+/** 取一个顶级 job（缩进 2 格的 `name:`）的整块文本，到下一个同级键或文件结尾。 */
+function jobBlock(name) {
+  const lines = workflow.split(/\r?\n/);
+  const start = lines.findIndex((line) => line === `  ${name}:`);
+  assert.notEqual(start, -1, `release.yml 里找不到 job ${name}`);
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^ {2}[A-Za-z0-9_-]+:\s*$/.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  return lines.slice(start, end);
+}
+
+/** 读一个 job 块的 `needs:` 内联列表；没有 needs 行返回空数组。 */
+function needsOf(name) {
+  const line = jobBlock(name).find((l) => /^ {4}needs:\s*\[/.test(l));
+  if (!line) return [];
+  const inner = line.slice(line.indexOf("[") + 1, line.lastIndexOf("]"));
+  return inner.split(",").map((s) => s.trim()).filter(Boolean);
+}
+
+test("release 等 publish：发布声明不许抢在真的发出去之前", () => {
+  const needs = needsOf("release");
+  assert.ok(
+    needs.includes("publish"),
+    `release 的 needs 必须含 publish（当前 [${needs.join(", ")}]）—— 否则 publish 失败时 Release 仍会建出来`
+  );
+});
+
+test("release 仍等 verify 与 test：修依赖顺序不该绕开版本与 CHANGELOG 校验", () => {
+  const needs = needsOf("release");
+  assert.ok(needs.includes("verify"), "release 必须等 verify（版本号与 CHANGELOG 小节）");
+  assert.ok(needs.includes("test"), "release 必须等 test");
+});
+
+test("publish 内必须跑阻塞闸门：release 等的是一个真做过校验的作业", () => {
+  // 只扫非注释行：publish job 的注释里刻意留了那行旧实现（说明它为什么是假绿），
+  // 那是文档不是代码——按整块扫会把文档当成复发。
+  const code = jobBlock("publish").filter((line) => !/^\s*#/.test(line)).join("\n");
+  assert.match(
+    code,
+    /node dsh-mneme\/scripts\/publish-gate\.mjs/,
+    "publish job 必须调用 publish-gate.mjs（拿不到版本就非零退出）"
+  );
+  assert.doesNotMatch(
+    code,
+    /echo "Published: \$\(npm view/,
+    "不要退回命令替换里的 npm view —— 失败不会让 set -e 退出，那是 v0.8.16 的假绿"
+  );
+});

package/test/scope-distill-stamp.test.js

@@ -0,0 +1,135 @@
+// 把 CodeRabbit 在 PR #434 上核出的三条钉死。
+// 前两条是「读起来对、跑起来错」的形态：注释写着 A，代码实际做 B。
+// 第三条是契约与实现的落差：文件头写着「任何异常都被吞掉」，但只吞了一半。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createScopeResolver } from "../src/scope.js";
+import { createSummarizer } from "../src/summarize.js";
+
+function summarizerHarness() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const events = [];
+  const ctx = {
+    on(name, fn) { events.push({ name, fn }); return () => {}; },
+    llm: {
+      stream() {
+        const json = JSON.stringify([
+          { type: "decision", title: "选型", content: "确定用 node:sqlite", importance: 4 }
+        ]);
+        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" };
+        })();
+      }
+    }
+  };
+  createSummarizer(ctx, service, {
+    autoSummarize: true,
+    scopeEnabled: true,
+    summarizeDedupeMode: "title",
+    summarizeDedupeWindowHours: 24,
+    summarizeMinIntervalMinutes: 0,
+    summarizeMaxRunsPerSession: 0,
+    distillRateLimitIntervalMs: 0
+  }, {});
+  return { store, service, handler: events.find((e) => e.name === "session/event").fn };
+}
+
+const SID = "s-scope-dedupe";
+
+function sessionOf(scope) {
+  return {
+    id: SID,
+    header: { agentPreset: scope, cwd: "C:\\work\\probe" },
+    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" }
+    ]
+  };
+}
+
+// 回归形状：scopeEnabled 与 summarizeDedupeMode 同开时，第二轮蒸馏会命中第一轮
+// 的行。findSessionDuplicate 的候选筛（type + source + 时间窗）不看 scope，真正
+// 决定并不并的是 saveWithDedupe 的 scopeMatches 门。调用方若用「命中就不传章」
+// 表达「不重贴」，新条目的 scope 会变成 null：与已带章的候选不等 → 门拒 → 回落
+// 新建，而那一行也是新行，同样该带章却没有章。结果是同题两行、一行 auto 一行
+// NULL——跨作用域隔离没做成，同题重复倒留下了。
+test("scope + dedupe: a scope-gate rejection still stamps the replacement row", async () => {
+  const { store, service, handler } = summarizerHarness();
+  // 同 source 的存量未标注行：正是 scopeEnabled 之前写下的那些行的形状。
+  service.saveWithDedupe({
+    type: "decision", title: "选型", content: "旧内容", source: `session:${SID}`, importance: 4
+  });
+
+  await handler(sessionOf("amarre"), { seq: 2, type: "turn/end" });
+
+  const rows = store.list({ limit: null });
+  assert.equal(rows.length, 2, "跨作用域不并入，存量行原样留着");
+  const stamped = rows.filter((r) => r.agent_scope === "amarre");
+  assert.equal(stamped.length, 1, "回落新建的那一行必须带章（它同样是新行）");
+  assert.equal(stamped[0].workspace_scope, "C:\\work\\probe", "两维都盖");
+});
+
+// 反向锁：同作用域同题照旧并入，且不新造行、不把既有行的来源升级成 explicit
+// （升级只在用户显式声明时发生，见 service.js 的 scopeUpgrade 分支）。
+test("scope + dedupe: a same-scope candidate still merges and keeps its source", async () => {
+  const { store, service, handler } = summarizerHarness();
+  service.saveWithDedupe({
+    type: "decision", title: "选型", content: "旧内容", source: `session:${SID}`,
+    importance: 4,
+    agent_scope: "amarre", agent_scope_source: "auto",
+    workspace_scope: "C:\\work\\probe", workspace_scope_source: "auto"
+  });
+
+  await handler(sessionOf("amarre"), { seq: 2, type: "turn/end" });
+
+  const rows = store.list({ limit: null });
+  assert.equal(rows.length, 1, "同作用域同题：并入而不是新造");
+  assert.equal(rows[0].agent_scope_source, "auto", "并入不把来源升级成 explicit");
+});
+
+// scope.js 文件头写着硬约束「任何异常都被吞掉」，但那条约束此前只覆盖了
+// session.header 的取得与 registry 查询——header 的**字段**读取裸着。宿主给出
+// 会抛错的 accessor 时（sessionOf / sessionKeyOf 就是为同一类宿主写的 try 包），
+// 异常会穿出解析器：蒸馏路径上一个窗口的记忆与游标一起丢，工具路径上是一次
+// memory_save 直接失败。锁的是「字段级读取也必须各自护住」。
+test("scope resolver: a throwing header accessor never escapes the resolver", () => {
+  const resolve = createScopeResolver({ ctx: {}, config: { scopeEnabled: true }, logger: {} });
+  const session = {
+    id: "s-throw",
+    get header() {
+      return {
+        get agentPreset() { throw new Error("host accessor exploded"); },
+        get cwd() { throw new Error("host accessor exploded"); }
+      };
+    }
+  };
+
+  let value = null;
+  assert.doesNotThrow(() => { value = resolve({ agent: { session } }); });
+  assert.deepEqual(value, { agent_scope: null, workspace_scope: null }, "取不到就落 NULL，不是抛出");
+});
+
+// 居中 sheet 是「宿主没有右栏服务」时的唯一完整视图入口（PipelineHeaderEntry 的
+// fallback）。它 portal 到 body，焦点默认留在 trigger 上，而挂在 sheet 元素上的
+// onKeyDown 既因没有 tabIndex 不被聚焦、也收不到外部键盘事件 —— Escape 于是不
+// 生效，键盘用户只剩 Tab 摸到关闭按钮一条路。这里锁住「焦点进得去、Esc 出得来」
+// 两件事都在；做法与 MemoryOverlay 一致（打开时 focus，Esc 挂在 window 上）。
+test("pipeline sheet fallback is keyboard reachable: focus moves in, Escape gets out", () => {
+  const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+  const src = readFileSync(join(root, "lib/client.js"), "utf8");
+
+  assert.match(src, /ref: sheetRef,\s*\n\s*tabIndex: -1,/, "sheet 必须可聚焦（否则 onKeyDown 收不到事件）");
+  assert.match(src, /if \(!sheetOpen\) return undefined;\s*\n\s*if \(sheetRef\.current\) sheetRef\.current\.focus\(\);/,
+    "打开时必须把焦点移进 sheet");
+  assert.match(src, /window\.addEventListener\("keydown", onKey\)/, "Escape 必须挂在 window 上收");
+});

package/test/serve.test.js

@@ -83,7 +83,7 @@ test("serve: save → search 走通;token 持久化 kv;二次启动复用同一
   // token 持久化在 kv external_api(与 DSH 面板/CLI 共用同一凭证通道)
   assert.equal(rt.settings.getExternalApi().token, rt.api.token);
 
-  // 检索回执:recorder 已接(index.js:294-309 同款),recall_runs 不缺数 —— #363 回帖
+  // 检索回执:recorder 已接(index.js 的 setRecallRecorder,2026-10-14 在 :339-350),recall_runs 不缺数 —— #363 回帖
   // 向 bridge 承诺过「第三方检索的复用统计不受影响」,这条就是该承诺的回归锁。
   const recallRows = rt.store.db.prepare("SELECT COUNT(*) AS n FROM recall_runs").get();
   assert.ok(recallRows.n >= 1, "recall_runs should record the search above");

package/test/service.test.js

@@ -53,7 +53,10 @@ test("injectCandidates returns preferences + high-importance items within limit"
   const types = candidates.map((c) => c.type);
   assert.ok(types.includes("preference"), "preferences included");
   assert.ok(types.includes("project"), "high-importance project included");
-  assert.ok(!types.includes("history"), "history excluded by default");
+  // #369：history 曾被注入白名单挡在门外，现按「注入侧收编」进池（理由与实测数字
+  // 见 src/service.js 的 INJECT_TYPES 注释）。这里从「锁排除」改成「锁收编」——
+  // 白名单日后若被收窄，这条会红，而不是静默把两成条目关回不可注入。
+  assert.ok(types.includes("history"), "history included since #369");
   assert.ok(candidates.length <= 5, "respects maxItems");
 });
 
@@ -220,7 +223,9 @@ test("Bug4: injectCandidates with an empty query keeps the legacy rule-based sel
   assert.deepEqual(noQuery.map((c) => c.id), legacy.map((c) => c.id), "empty query behaves identically to the old logic");
   assert.deepEqual(blankQuery.map((c) => c.id), legacy.map((c) => c.id), "whitespace-only query degrades too");
   assert.equal(legacy[0].type, "summary", "summary still leads");
-  assert.ok(!legacy.some((c) => c.type === "history"), "history still excluded");
+  // #369 收编后 history 可进池；本用例的重心是「空查询与旧规则路逐字节同序」，
+  // 这条只确认收编没有撼动优先级分层——summary 仍打头。
+  assert.ok(legacy.some((c) => c.type === "history"), "history included since #369");
 });
 
 test("Bug4: injectCandidates ignores the query when hybridInject is disabled", () => {