@modusensus/dsh-mneme 0.8.16 → 0.9.0

package/test/publish-gate.test.js

@@ -0,0 +1,272 @@
+// scripts/publish-gate.mjs 的回归测试。
+//
+// 这一步的价值全在「不许假绿」上：原先的 Verify published version 是
+//   echo "Published: $(npm view "@modusensus/dsh-mneme@${V}" version)"
+// 命令替换里的失败不让 `set -e` 退出 —— v0.8.16 那次日志里明明 `404 No match found for version
+// 0.8.16`，step 与 job 却都是 success。下面第一条与第三条各自钉住两端：
+//   · 版本已在 registry（幂等跳过路径）→ 立刻通过，不为传播延迟白等；
+//   · 等满预算仍看不见 → 必须 `ok:false` 且入口退出 1。
+// 谁要是把「拿不到」改成「跳过校验」或「返回成功」，第三条会红。
+//
+// 全部用例走假时钟 + 注入 probe：零网络、零真实等待，跑起来是毫秒级。
+// 还有一条走真进程（spawnSync）的端到端用例：工作流红不红只看真进程退出码，函数级断言钉不到
+// 「主模块判别 + process.exitCode」那条路径。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  DEFAULT_INTERVAL_MS,
+  DEFAULT_TIMEOUT_MS,
+  PACKAGE_NAME,
+  main,
+  parseArgs,
+  probeVersion,
+  versionUrl,
+  waitForPublished
+} from "../scripts/publish-gate.mjs";
+
+/** 被测入口的真实路径：端到端用例要把它当子进程跑起来。 */
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+
+/** 假时钟：只有 sleep() 会让时间前进，于是超时逻辑可以确定性断言。 */
+function fakeClock() {
+  let t = 0;
+  return {
+    now: () => t,
+    sleep: async (ms) => { t += ms; },
+    slept: () => t
+  };
+}
+
+const noop = () => {};
+
+/** 前 `misses` 次报 404、之后可见的 probe；锁的是「重试真的发生了」。 */
+function probeMissingTimes(misses, { version = "0.8.16" } = {}) {
+  let calls = 0;
+  return async () => {
+    calls += 1;
+    if (calls <= misses) return { ok: false, reason: "missing", detail: "HTTP 404，registry 上还看不到" };
+    return { ok: true, version, tarball: "https://registry.npmjs.org/x/-/x-0.8.16.tgz" };
+  };
+}
+
+test("版本已在 registry：首次探测即通过，不为传播延迟白等（幂等跳过路径）", async () => {
+  const clock = fakeClock();
+  let sleeps = 0;
+  const result = await waitForPublished("0.8.16", {
+    now: clock.now,
+    sleep: async (ms) => { sleeps += 1; await clock.sleep(ms); },
+    probe: probeMissingTimes(0),
+    log: noop
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.attempts, 1);
+  assert.equal(result.waitedMs, 0);
+  assert.equal(sleeps, 0, "已发布路径不该有任何等待");
+});
+
+test("传播延迟：前两次 404、第三次可见 → 通过，且等待时间与重试次数如实报出", async () => {
+  const clock = fakeClock();
+  const result = await waitForPublished("0.8.16", {
+    now: clock.now,
+    sleep: clock.sleep,
+    intervalMs: 15000,
+    probe: probeMissingTimes(2),
+    log: noop
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.attempts, 3);
+  assert.equal(result.waitedMs, 30000, "两次间隔的等待要计入");
+  assert.ok(result.tarball.includes("0.8.16"));
+});
+
+test("等满预算仍看不见：必须 ok:false + reason timeout（防的就是 v0.8.16 那种假绿）", async () => {
+  const clock = fakeClock();
+  const result = await waitForPublished("0.8.16", {
+    now: clock.now,
+    sleep: clock.sleep,
+    timeoutMs: 30000,
+    intervalMs: 15000,
+    probe: probeMissingTimes(Infinity),
+    log: noop
+  });
+  assert.equal(result.ok, false, "拿不到版本时绝不是成功");
+  assert.equal(result.reason, "timeout");
+  assert.equal(result.attempts, 3, "t=0 / 15s / 30s 各一次探测");
+  assert.equal(result.waitedMs, 30000);
+  assert.match(result.lastError, /404/);
+});
+
+test("探测自己耗时到超过预算、但回来时版本已可见：仍然通过（预算约束等待，不约束判定）", async () => {
+  // 锁的是刻意选择：单次探测带 HTTP 超时，晚到的成功最多超出预算十几秒；而版本真的在 registry 上
+  // 就是发布成功，为晚到几秒判红是假红——闸门要消灭的是假绿，不该顺手制造另一种失真。
+  const clock = fakeClock();
+  const result = await waitForPublished("0.8.16", {
+    now: clock.now,
+    sleep: clock.sleep,
+    timeoutMs: 15000,
+    intervalMs: 15000,
+    probe: async () => {
+      await clock.sleep(20000); // 这一次探测自己就把预算耗穿了
+      return { ok: true, version: "0.8.16", tarball: "" };
+    },
+    log: noop
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.attempts, 1);
+  assert.equal(result.waitedMs, 20000);
+});
+
+test("预算不是间隔整数倍时：最后一轮只睡到超时点，不多睡一整轮", async () => {
+  const clock = fakeClock();
+  const result = await waitForPublished("0.8.16", {
+    now: clock.now,
+    sleep: clock.sleep,
+    timeoutMs: 20000,
+    intervalMs: 15000,
+    probe: probeMissingTimes(Infinity),
+    log: noop
+  });
+  assert.equal(result.ok, false);
+  assert.equal(result.attempts, 3, "t=0 / 15s / 20s（最后一次落在超时点上）");
+  assert.equal(result.waitedMs, 20000);
+  assert.equal(clock.slept(), 20000, "总睡眠时间恰为预算，而不是 30000");
+});
+
+test("网络异常同样计入重试（既不崩也不当作成功），最终以最后一次原因报出", async () => {
+  const clock = fakeClock();
+  let calls = 0;
+  const result = await waitForPublished("0.8.16", {
+    now: clock.now,
+    sleep: clock.sleep,
+    timeoutMs: 15000,
+    intervalMs: 15000,
+    probe: async () => { calls += 1; return { ok: false, detail: `请求失败：fetch failed（第 ${calls} 次）` }; },
+    log: noop
+  });
+  assert.equal(result.ok, false);
+  assert.equal(result.attempts, 2, "异常也继续重试");
+  assert.match(result.lastError, /第 2 次/, "报的是最后一次原因");
+});
+
+test("probe 返回形状异常（undefined）也不炸，按拿不到处理", async () => {
+  const clock = fakeClock();
+  const result = await waitForPublished("0.8.16", {
+    now: clock.now,
+    sleep: clock.sleep,
+    timeoutMs: 0,
+    intervalMs: 15000,
+    probe: async () => undefined,
+    log: noop
+  });
+  assert.equal(result.ok, false);
+  assert.equal(result.reason, "timeout");
+});
+
+test("默认预算：超时 10 分钟 / 间隔 15 秒（覆盖实测 ~4.5 分钟的传播延迟）", () => {
+  assert.equal(DEFAULT_TIMEOUT_MS, 600000);
+  assert.equal(DEFAULT_INTERVAL_MS, 15000);
+});
+
+test("versionUrl：scoped 包名整体编码，origin 尾斜杠不重复", () => {
+  assert.equal(
+    versionUrl(PACKAGE_NAME, "0.8.16"),
+    "https://registry.npmjs.org/%40modusensus%2Fdsh-mneme/0.8.16"
+  );
+  assert.equal(
+    versionUrl(PACKAGE_NAME, "0.8.16", "https://registry.npmjs.org/"),
+    "https://registry.npmjs.org/%40modusensus%2Fdsh-mneme/0.8.16"
+  );
+});
+
+test("probeVersion：404 = 还没传播，200 且版本一致 = 可见（带 tarball）", async () => {
+  const missing = await probeVersion("0.8.16", {
+    fetchImpl: async () => ({ ok: false, status: 404, json: async () => ({}) })
+  });
+  assert.equal(missing.ok, false);
+  assert.equal(missing.reason, "missing");
+
+  const found = await probeVersion("0.8.16", {
+    fetchImpl: async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({ version: "0.8.16", dist: { tarball: "https://registry.npmjs.org/x/-/x-0.8.16.tgz" } })
+    })
+  });
+  assert.equal(found.ok, true);
+  assert.equal(found.tarball, "https://registry.npmjs.org/x/-/x-0.8.16.tgz");
+});
+
+test("probeVersion：请求抛错 / 5xx / 响应不是 JSON / 版本对不上，都折成 ok:false 而不抛", async () => {
+  const net = await probeVersion("0.8.16", { fetchImpl: async () => { throw new Error("fetch failed"); } });
+  assert.equal(net.reason, "network");
+
+  const http = await probeVersion("0.8.16", { fetchImpl: async () => ({ ok: false, status: 500, json: async () => ({}) }) });
+  assert.equal(http.reason, "http");
+
+  const badJson = await probeVersion("0.8.16", {
+    fetchImpl: async () => ({ ok: true, status: 200, json: async () => { throw new Error("boom"); } })
+  });
+  assert.equal(badJson.reason, "bad-json");
+
+  const mismatch = await probeVersion("0.8.16", {
+    fetchImpl: async () => ({ ok: true, status: 200, json: async () => ({ version: "0.8.15" }) })
+  });
+  assert.equal(mismatch.ok, false);
+  assert.equal(mismatch.reason, "mismatch");
+});
+
+test("parseArgs：位置参数给版本号，可覆盖预算；缺版本号如实回报", () => {
+  assert.deepEqual(parseArgs(["0.8.16"]), { ok: true, version: "0.8.16", timeoutMs: 600000, intervalMs: 15000 });
+  assert.deepEqual(parseArgs(["0.8.16", "--timeout-ms", "1000", "--interval-ms", "500"]), {
+    ok: true, version: "0.8.16", timeoutMs: 1000, intervalMs: 500
+  });
+  assert.equal(parseArgs([]).reason, "missing-version");
+  assert.equal(parseArgs(["0.8.16", "0.8.17"]).reason, "missing-version");
+  assert.equal(parseArgs(["0.8.16", "--timeout-ms", "abc"]).ok, false);
+});
+
+test("入口退出码：通过 → 0；超时 → 1 且 stderr 指明去翻 publish 步日志", async () => {
+  const logs = [];
+  const errors = [];
+  const okCode = await main(["0.8.16"], {
+    log: (line) => logs.push(line),
+    error: (line) => errors.push(line),
+    wait: async (version) => ({ ok: true, version, attempts: 1, waitedMs: 0, tarball: "" })
+  });
+  assert.equal(okCode, 0);
+  assert.equal(errors.length, 0);
+
+  const failCode = await main(["0.8.16"], {
+    log: noop,
+    error: (line) => errors.push(line),
+    wait: async () => ({ ok: false, reason: "timeout", attempts: 40, waitedMs: 600000, lastError: "HTTP 404" })
+  });
+  assert.equal(failCode, 1, "闸门未通过必须以非零退出让 job 变红");
+  assert.ok(errors.some((line) => line.includes("发布闸门未通过")));
+  assert.ok(errors.some((line) => line.includes("publish 步")));
+});
+
+test("入口退出码：缺版本号 → 1 并打印用法", async () => {
+  const errors = [];
+  const code = await main([], { log: noop, error: (line) => errors.push(line), wait: async () => ({ ok: true }) });
+  assert.equal(code, 1);
+  assert.ok(errors.some((line) => line.includes("用法")));
+});
+
+test("真进程端到端：不存在的版本 → 退出码 1 且 stderr 指明原因（这一步红了 job 才会红）", () => {
+  // 单测里的 main() 是函数调用，钉不到「主模块判别 + process.exitCode」这条真实退出路径——而
+  // 工作流红不红只看真进程的退出码。目标版本刻意取一个永不存在、与发布无关的名字：registry 回
+  // 404（连不上网络则是 network 原因），两种都会走到同一个超时分支，所以这条例外不引入网络依赖。
+  const result = spawnSync(
+    process.execPath,
+    [join(scriptDir, "..", "scripts", "publish-gate.mjs"), "0.0.0-mneme-gate-test", "--timeout-ms", "1", "--interval-ms", "1"],
+    { encoding: "utf8" }
+  );
+  assert.equal(result.status, 1, `期望非零退出，实际 ${result.status}（stderr: ${result.stderr}）`);
+  assert.match(result.stderr, /发布闸门未通过/);
+  assert.match(result.stdout, /等待 @modusensus\/dsh-mneme@0\.0\.0-mneme-gate-test/);
+});

package/test/recall-retention.test.js

@@ -0,0 +1,128 @@
+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";
+
+// 2026-10-14 找回：recall_runs 的滚动清理（函数 + 启动调用）在 dd0ed78「release:
+// v0.7.12」里被整块弄丢，而配置键 recallRetentionDays、README.md 与
+// docs/CONFIGURATION.md 一直宣称它有保留期 —— 于是本机那张表只增不减，没人发现
+// （2026-10-13 当天实测就从 16,041 涨到 20,510 行）。
+//
+// 这组测试故意分两半，因为**弄丢的正是「两半都在」这件事**：
+//   1. 行为锁：函数真的删对行、边界正确、空表不炸；
+//   2. 接线锁：index.js 的启动块真的调它，且读的是装配后的 cfg（不是 rawCfg）。
+// 只锁 1 不锁 2，函数写得再对也没人调；只锁 2 不锁 1，调用调的可能是空壳。
+// 第二半用源码文本断言，理由与 test/client.test.js 的 bilingual 锁同款：这是
+// 「接线还在不在」的问题，运行时冒烟测不到一个**在运维时才会跑**的启动分支。
+
+const here = dirname(fileURLToPath(import.meta.url));
+const srcText = (name) => readFileSync(join(here, "..", "src", name), "utf8");
+
+function seedRun(store, { query, createdAt }) {
+  store.saveRecallRun({
+    query,
+    mode: "auto",
+    topK: 5,
+    threshold: null,
+    candidates: [],
+    created_at: createdAt
+  });
+}
+
+const daysAgo = (n) => new Date(Date.now() - n * 86400000).toISOString();
+
+test("保留期：删掉窗口外的行、留下窗口内的行，返回值是真实删除数", () => {
+  const store = createStore(":memory:");
+  seedRun(store, { query: "老", createdAt: daysAgo(120) });
+  seedRun(store, { query: "也老", createdAt: daysAgo(91) });
+  seedRun(store, { query: "新", createdAt: daysAgo(89) });
+  seedRun(store, { query: "很新", createdAt: daysAgo(1) });
+
+  const removed = store.purgeRecallRunsOlderThan(90);
+  assert.equal(removed, 2, "只有窗口外的两行该被删");
+
+  // 两侧都排过再比：assert 的是「留下了哪两行」，不是它们的物理顺序
+  const left = store.listRecallRunsSince(daysAgo(3650)).rows.map((r) => r.query).sort();
+  assert.deepEqual(left, ["很新", "新"].sort());
+  store.close();
+});
+
+test("保留期：边界按字典序比较，窗口内的留、窗口外的删（两侧各留 1 小时裕量）", () => {
+  const store = createStore(":memory:");
+  // 不骑刀刃：cutoff 是在**清理那一刻**用 Date.now() 现算的，而造数据也取一次
+  // Date.now()，测试跑几毫秒就足以让「正好 90 天前」翻到界外。这里两侧各留
+  // 1 小时，锁的是比较方向（`created_at < cutoff` 才删），不是毫秒级巧合。
+  const boundary = 90 * 86400000;
+  seedRun(store, { query: "窗口内一小时", createdAt: new Date(Date.now() - boundary + 3600000).toISOString() });
+  seedRun(store, { query: "窗口外一小时", createdAt: new Date(Date.now() - boundary - 3600000).toISOString() });
+
+  const removed = store.purgeRecallRunsOlderThan(90);
+  assert.equal(removed, 1, "越过界的才删，贴近界的要留");
+  assert.deepEqual(store.listRecallRunsSince(daysAgo(3650)).rows.map((r) => r.query), ["窗口内一小时"]);
+  store.close();
+});
+
+test("保留期：空表返回 0，不抛（清理是 bookkeeping，不许挡启动）", () => {
+  const store = createStore(":memory:");
+  assert.equal(store.purgeRecallRunsOlderThan(90), 0);
+  store.close();
+});
+
+test("接线锁：index.js 启动块真的调 purgeRecallRunsOlderThan，且读装配后的 cfg", () => {
+  const index = srcText("index.js");
+  assert.match(index, /store\.purgeRecallRunsOlderThan\(recallRetentionDays\)/,
+    "启动期必须真的调用清理——这对曾在 dd0ed78 里双双蒸发");
+  assert.match(index, /cfg\.recallRetentionDays/,
+    "必须读装配后的 cfg（面板改保留期才生效），不能读 rawCfg");
+  // 失败必须真的出声。这一对当初就是**无声**蒸发的：函数与调用一起没了、没人发现，
+  // 表涨到两万余行。清理再失败一次若仍然静默，同一类回归照样看不见——所以这里
+  // 两个方向都锁：接住（catch(err)，不 rethrow、不挡启动）与出声（真调 logger.warn）。
+  // 只锁「不挡启动」会放过静默吞，只锁「出声」会放过把异常抛出去挡启动。
+  const at = index.indexOf("store.purgeRecallRunsOlderThan(recallRetentionDays)");
+  assert.ok(at > 0, "启动期必须真的调用清理——这对曾在 dd0ed78 里双双蒸发");
+  const tail = index.slice(at, at + 600);
+  assert.match(tail, /catch \(err\) \{/, "清理失败要接住，不许挡插件启动");
+  assert.match(tail, /ctx\.logger\?\.warn\?\.\(/, "清理失败要 warn 出声，静默吞等于把回归再藏一次");
+  // 就近确认它落在同一族启动清理之间：失败表 → llm_audit → distill → recall_runs
+  const llm = index.indexOf("store.deleteOldLlmAudits");
+  const distill = index.indexOf("store.clearDistillRecords");
+  assert.ok(llm > 0 && distill > 0 && at > llm, "recall_runs 清理应排在 llm_audit 之后");
+  assert.ok(at > distill, "recall_runs 清理应排在 distill_records 之后（与现有启动顺序一致）");
+});
+
+test("接线锁：store.js 导出 purgeRecallRunsOlderThan（函数存在但没导出同样是断线）", () => {
+  const store = srcText("store.js");
+  assert.match(store, /function purgeRecallRunsOlderThan\(days\)/);
+  assert.match(store, /^\s*purgeRecallRunsOlderThan,\s*$/m, "必须在 createStore 的返回对象里导出");
+  assert.match(store, /DELETE FROM recall_runs WHERE created_at < \?/);
+});
+
+// 启动期清理是**一族的四个兄弟**：失败表 / llm_audit / distill_records / recall_runs。
+// 上面那条只锁了 recall_runs 一个，但四个的注释互相引用（llm_audit 那条原文写着
+// 「失败只 warn，与失败表清理同款」），而 2026-10-14 实测前三个全是
+// `catch { /* non-fatal */ }` —— 静默吞，与注释宣称的相反。recall_runs 那一对当初
+// 就是无声蒸发的，所以这一族必须一起锁：只要有一个偷偷退回静默吞，这条就红。
+test("接线锁：四个启动期清理都必须出声（catch(err) + logger.warn，不许静默吞）", () => {
+  const index = srcText("index.js");
+  const family = [
+    ["失败表", "store.deleteOldFailures("],
+    ["llm_audit", "store.deleteOldLlmAudits("],
+    ["distill_records", "store.clearDistillRecords("],
+    ["recall_runs", "store.purgeRecallRunsOlderThan(recallRetentionDays)"]
+  ];
+  for (const [label, call] of family) {
+    const at = index.indexOf(call);
+    assert.ok(at > 0, `${label} 的启动期清理调用必须在（弄丢过一次的就是这一族）`);
+    const tail = index.slice(at, at + 700);
+    assert.match(tail, /catch \(err\) \{/, `${label} 清理失败要接住，不许挡插件启动`);
+    assert.match(tail, /ctx\.logger\?\.warn\?\.\(/, `${label} 清理失败要 warn 出声，静默吞等于把回归再藏一次`);
+  }
+});
+
+test("接线锁：配置键与文档对外宣称的保留期一致（键还在、默认 90 天）", () => {
+  const cfgText = srcText("config.js");
+  assert.match(cfgText, /recallRetentionDays: z\.natural\(\)\.min\(1\)\.max\(3650\)\.default\(90\)/,
+    "配置键被改或删掉时，这条和文档一起要动——别让文档继续说谎");
+});

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");