@modusensus/dsh-mneme 0.9.0 → 0.9.1

package/test/release-notes.test.js

@@ -0,0 +1,240 @@
+// scripts/release-notes.mjs 的回归测试。
+//
+// 这段逻辑原先嵌在 .github/workflows/release.yml 的 node -e 里：改排版要动工作流本体、还写不了
+// 测试，而它产出的恰恰是 GitHub Release 的对外正文——最需要反复试排版的地方。抽成模块之后，
+// 形状必须被锁住，否则下次「顺手压缩一下」就会静默改变所有 Release 页的样子。
+//
+// 锁的是四条容易悄悄退化的性质：
+//   1. 分层而不是截断：标题 + 一句导语默认可见，其余折进 details，完整正文一条不丢；
+//   2. 导语与折叠块不重复：consumed 记错就会让同一句话出现两次；
+//   3. 导语不在未闭合的括号里断开，也不采用短到无法独立表意的首句；
+//   4. 找不到小节必须非零退出、不写正文——退回空正文就是假成功；
+//   5. 缩进续行跟着它所属的条目一起进折叠块，不散落到外面（老版本 CHANGELOG 里有 179 行）；
+//   6. 正文本身不长时整段就是导语，不许凭空加省略号（短正文里也常有逗号）。
+// 第 4 条走真进程（spawnSync）端到端：工作流只认退出码与 notes/body.md 这个文件。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { findSection, parseBullet, lede, renderNotes } from "../scripts/release-notes.mjs";
+
+const scriptPath = join(dirname(fileURLToPath(import.meta.url)), "..", "scripts", "release-notes.mjs");
+
+/** 括号深度：全角与半角都算。导语收尾时它必须是 0。 */
+function parenDepth(s) {
+  let d = 0;
+  for (const c of s) {
+    if (c === "\uFF08" || c === "(") d += 1;
+    else if (c === "\uFF09" || c === ")") d = Math.max(0, d - 1);
+  }
+  return d;
+}
+
+const SAMPLE = [
+  "# Changelog",
+  "",
+  "## [0.9.0] - 2026-10-17",
+  "",
+  "## \u{1F41B} 修复",
+  "",
+  "- **修掉一个能钉死宿主的轮询**：轮询器原先在没有新消息时也会整轮重建定时器，于是每收到一次心跳就多压一层等待队列，这在单次会话里看不出来，连续跑上几小时才会把宿主的事件循环拖到卡死，排查时表现为面板偶尔整片不刷新、日志里却什么异常都没有（这类问题最费时间，因为复现窗口很长，还得先怀疑是记忆库锁竞争），修法是把定时器提到循环外复用，并补一条回归用例锁住轮询次数。",
+  "",
+  "- **很短的一条**：两处水源在说谎。",
+  "",
+  "## [0.8.16] - 2026-10-12",
+  "",
+  "- 旧条目",
+].join("\n");
+
+test("findSection：取到该版小节，不含标题行，到下一个版本标题为止", () => {
+  const sec = findSection(SAMPLE, "0.9.0");
+  assert.ok(sec.startsWith("## \u{1F41B} 修复"), "小节从版本标题行之后开始");
+  assert.ok(sec.includes("修掉一个能钉死宿主的轮询"), "正文在里面");
+  assert.equal(sec.includes("[0.9.0]"), false, "不该带上版本标题行本身");
+  assert.equal(sec.includes("旧条目"), false, "到下一个 ## [ 为止");
+});
+
+test("findSection：找不到该版本返回 null（入口据此 exit 1）", () => {
+  assert.equal(findSection(SAMPLE, "9.9.9"), null);
+});
+
+test("findSection：版本号里的点被转义过，不会当成通配", () => {
+  const text = SAMPLE.replace("## [0.8.16] - 2026-10-12", "## [0x8x16] - 2026-10-12");
+  assert.equal(findSection(text, "0.8.16"), null, "点若被当通配就会误命中 0x8x16");
+});
+
+test("parseBullet：拆出标题与正文；非该形状返回 null 由调用方原样保留", () => {
+  assert.deepEqual(parseBullet("- **标题**：正文在这里"), { title: "标题", body: "正文在这里" });
+  assert.deepEqual(parseBullet("- **只有标题**"), { title: "只有标题", body: "" });
+  assert.equal(parseBullet("普通段落"), null);
+  assert.equal(parseBullet("- 没有粗体标题：正文"), null);
+});
+
+test("lede：cap 内第一个达标的句末标点处收尾，consumed 与导语等长", () => {
+  // 正文必须真的长于 cap：短于 cap 时整段就是导语（见下一条用例），那样根本走不到本分支。
+  const first = "这是一个足够长的句子，用来验证导语会在句末标点处停下来。";
+  const body = first + "后面还有别的内容，".repeat(20);
+  assert.ok(body.length > 150, "构造本身要求正文长于 cap");
+  const r = lede(body, 150);
+  assert.equal(r.lede, first);
+  assert.equal(r.consumed, r.lede.length, "consumed 必须等于导语长度，否则折叠块会错位或重复");
+});
+
+test("lede：首句短于 MIN_LEDE 时不采用（实测有条首句只有 8 字，离开上下文没信息）", () => {
+  const body = "两处水源在说谎。这个短句单独拿出来没有信息量，所以要继续往下取。";
+  const r = lede(body, 150);
+  assert.notEqual(r.lede, "两处水源在说谎。", "8 字的首句不该被当成导语");
+  assert.ok(r.lede.startsWith("两处水源在说谎。"), "仍从正文开头起，不能跳过首句");
+  assert.ok(r.lede.length > 8);
+});
+
+test("lede：软断点必须在括号平衡处 —— 不在未闭合的括号里切断", () => {
+  // 复刻 v0.9.0 实测切出来的坏例子：GET /external-api（明文回吐 Bearer，…
+  const body = "开放读清单里有 GET /external-api（明文回吐 Bearer，还会就地铸造 token），这条实测切在括号里最难看，所以专门钉住它。";
+  const naive = body.slice(0, 40).lastIndexOf("\uFF0C");
+  assert.equal(parenDepth(body.slice(0, naive)), 1, "构造本身要能触发规则：cap 内最后一个逗号在括号里");
+  const r = lede(body, 40);
+  assert.equal(parenDepth(r.lede), 0, "导语的括号必须闭合：" + r.lede);
+  assert.ok(r.lede.includes("token）"), "应越过括号再收尾：" + r.lede);
+});
+
+test("lede：落到软断点分支时，consumed 连标点一起吃进去 —— 折叠块不能以逗号开头", () => {
+  // 这条补的是 M4 类退化：软断点用省略号收尾时，若 consumed 只记到标点之前，折叠块就会以
+  // 「，」开头（读者点开看到的第一件事是一个孤零零的逗号）。句末标点分支不会暴露它，因为
+  // 那条分支把整句连同标点一起切走；只有刻意不写句末标点的正文才走得到这里。
+  const body = Array.from({ length: 12 }, (_, i) => "\u7B2C" + (i + 1) + "\u6BB5\u5185\u5BB9\u5199\u5F97\u6BD4\u8F83\u957F\u4E00\u4E9B\uFF0C").join("") + "\u6536\u5C3E\u3002";
+  const r = lede(body, 150);
+  assert.ok(r.lede.endsWith("\u2026"), "\u6CA1\u6709\u53E5\u672B\u6807\u70B9\u65F6\u7528\u7701\u7565\u53F7\u6536\u5C3E\uFF1A" + r.lede);
+  assert.equal(r.consumed, r.lede.length, "consumed \u5FC5\u987B\u7B49\u4E8E\u5BFC\u8BED\u957F\u5EA6");
+  const rest = body.slice(r.consumed);
+  assert.ok(rest.length > 0, "\u6784\u9020\u672C\u8EAB\u8981\u6C42\u8FD8\u6709\u5269\u4F59\u6B63\u6587\uFF0C\u5426\u5219\u6D4B\u4E0D\u5230");
+  assert.equal(rest.startsWith("\uFF0C"), false, "\u6298\u53E0\u5757\u4E0D\u80FD\u4EE5\u9017\u53F7\u5F00\u5934\uFF1A" + rest.slice(0, 12));
+});
+
+test("lede：正文本身比 cap 短时，整段就是导语，不加省略号也不越界", () => {
+  const body = "很短的一条正文，没有句末标点";
+  const r = lede(body, 150);
+  assert.equal(r.lede, body, "整段即导语");
+  assert.equal(r.lede.includes("\u2026"), false, "不该凭空加省略号说后面还有");
+  assert.equal(r.consumed, body.length, "consumed 不能超过正文长度");
+});
+
+test("lede：正文比 cap 短且以逗号结尾时，仍是整段导语 —— 不加省略号说「后面还有」", () => {
+  // 这条钉的是「短正文保护」的位置：它必须排在软断点搜索之前。原先守在函数末尾，短正文里
+  // 只要有个逗号就会被加省略号；逗号恰是最后一个字符时更荒唐——省略号后面什么也没有，
+  // 折叠块是空的。实测语料里 25 字的短条就被切成了这个样子。
+  const body = Array.from({ length: 4 }, () => "\u4E00\u4E8C\u4E09\u56DB\u4E94\u516D\u4E03\u516B\u4E5D\u5341").join("") + "\uFF0C";
+  const r = lede(body, 150);
+  assert.equal(r.lede, body, "整段即导语，不该被软断点截断");
+  assert.equal(r.lede.includes("\u2026"), false, "不该加省略号");
+  assert.equal(r.consumed, body.length, "consumed 要覆盖整段");
+  assert.equal(body.slice(r.consumed), "", "没有剩余正文可折 —— 折叠块必须为空");
+});
+
+test("renderNotes：标题 + 导语默认可见，其余折进 details，且导语不重复出现", () => {
+  // 正文要长于 cap，否则整段展开（没有可折的东西时，多一步点击毫无收益）。
+  const section =
+    "- **标题甲**：第一句要足够长，所以会被当作导语留下来并在此收尾。" +
+    "第二句只应该出现在折叠块里，不该在可见行重复。".repeat(12);
+  const out = renderNotes(section, { cap: 150 });
+  const [head, ...rest] = out.split("\n");
+  assert.ok(head.startsWith("- **标题甲** \u2014 "), "可见行是标题 + 导语：" + head);
+  const folded = rest.join("\n");
+  assert.ok(folded.includes("<details><summary>细节</summary>"), "剩余正文折进 details");
+  assert.ok(folded.includes("第二句只应该出现在折叠块里"), "细节里要有后半段");
+  assert.equal(folded.includes("第一句要足够长，所以会被当作导语留下来并在此收尾"), false, "导语不在折叠块里重复出现");
+});
+
+test("renderNotes：details 缩进两级且与正文之间空行 —— 否则内部 Markdown 不解析、视觉归属也断", () => {
+  const section =
+    "- **标题乙**：第一句要足够长，所以会被当作导语留下来并在此收尾。" +
+    "后面这句进折叠块。".repeat(20);
+  const lines = renderNotes(section).split("\n");
+  const open = lines.findIndex((l) => l.includes("<details"));
+  const close = lines.findIndex((l) => l.includes("</details"));
+  assert.notEqual(open, -1, "长子弹必须被折叠");
+  assert.ok(lines[open].startsWith("  <details"), "details 标签缩进两格：" + lines[open]);
+  assert.ok(lines[close].startsWith("  </details"), "闭合标签缩进两格：" + lines[close]);
+  assert.equal(lines[open + 1], "", "details 与正文之间必须空行，否则内部 Markdown 不解析");
+  assert.equal(lines[close - 1], "", "正文与闭合标签之间也要空行");
+  assert.ok(lines[open + 2].startsWith("  "), "折叠正文缩进两格：" + lines[open + 2]);
+});
+
+test("renderNotes：缩进续行随条目一起进 details，不散落到外面也不丢缩进", () => {
+  // CHANGELOG 里有 179 行缩进续行（0.8.6 / 0.8.7 / 0.8.12 等老版本集中出现）与 59 行
+  // "  - " 子列表。逐行 trim 的写法会把续行当成独立段落甩到条目的 details 外面，
+  // 子列表还会塌成平铺段落——读者看到的是「正文只有一句，剩下的莫名其妙散在下面」。
+  // 渲染的单位是条目，不是行。
+  // 首行刻意写得短且没有句末标点：这样"句末标点落在续行上"才可达，用例才能抓到
+  // "把续行拼回正文再切导语"这种写法——那种写法会把换行混进可见行。
+  const section = [
+    "- **标题丙**：首行很短",
+    "  这一句续行足够长，句末标点落在续行上，好让拼接式的导语切分会把换行混进可见行。",
+    "  这是续行二，属于上一条子弹。",
+    "  - 子列表项不应塌成段落",
+    "- **标题丁**：另起一条，用来确认块边界。",
+  ].join("\n");
+  const lines = renderNotes(section).split("\n");
+  const firstClose = lines.findIndex((l) => l.includes("</details"));
+  const secondHead = lines.findIndex((l) => l.includes("**标题丁**"));
+  assert.notEqual(firstClose, -1, "带续行的条目必须被折叠");
+  assert.ok(secondHead > firstClose, "第二条子弹应排在第一条的 details 之后，块边界不能串");
+  const folded = lines.slice(0, firstClose).join("\n");
+  assert.ok(folded.includes("这一句续行足够长"), "续行一在第一条的折叠块里");
+  assert.ok(folded.includes("这是续行二"), "续行二在第一条的折叠块里");
+  assert.ok(folded.includes("- 子列表项不应塌成段落"), "子列表在折叠块里且保留列表形状");
+  const outside = lines.slice(secondHead).join("\n");
+  assert.equal(outside.includes("这一句续行足够长"), false, "续行不该跑到下一条子弹那边");
+  const visible = lines.find((l) => l.includes("**标题丙**"));
+  assert.ok(visible.startsWith("- **标题丙** \u2014 "), "可见行仍是单行标题 + 导语：" + visible);
+  assert.equal(visible.includes("续行"), false, "续行不许挤进可见行，否则可见行撑成多行：" + visible);
+  // 这一条抓的是「把续行拼回正文再切导语」的写法：导语里混进换行后，可见行后面会多出一行
+  // 没有任何缩进的裸行，续行又散到了 details 外面。判别方法是看可见行之后紧跟什么——
+  // 正常只可能是 details 标签本身。
+  const headIdx = lines.indexOf(visible);
+  assert.ok(lines[headIdx + 1].startsWith("  <details"), "可见行之后必须直接是折叠块，不许有裸行：" + lines[headIdx + 1]);
+  assert.equal(visible.includes("\u2026"), false, "首行没有句末标点时，导语只能是首行本身，不该跨行取到续行的句号：" + visible);
+});
+
+test("renderNotes：分类小节原样保留，非子弹行不加工", () => {
+  const out = renderNotes("## \u{1F41B} 修复\n\n- 一条没有粗体标题的行\n");
+  assert.ok(out.includes("## \u{1F41B} 修复"), "小节标题原样保留");
+  assert.ok(out.includes("- 一条没有粗体标题的行"), "非 - **...** 形状原样保留");
+  assert.equal(out.includes("<details>"), false, "没拆出正文就不该有折叠块");
+});
+
+test("入口：真进程跑一遍，写出 notes/body.md，且 CHANGELOG 本体一个字不动", () => {
+  const root = mkdtempSync(join(tmpdir(), "mneme-release-notes-"));
+  mkdirSync(join(root, "dsh-mneme"), { recursive: true });
+  writeFileSync(join(root, "dsh-mneme", "CHANGELOG.md"), SAMPLE, "utf8");
+  const res = spawnSync(process.execPath, [scriptPath, "0.9.0"], { cwd: root, encoding: "utf8" });
+  assert.equal(res.status, 0, "退出码必须是 0：" + res.stderr);
+  const body = readFileSync(join(root, "notes", "body.md"), "utf8");
+  assert.ok(body.includes("## \u{1F41B} 修复"), "小节标题进了正文");
+  assert.ok(body.includes("<details>"), "长子弹被折叠");
+  assert.equal(readFileSync(join(root, "dsh-mneme", "CHANGELOG.md"), "utf8"), SAMPLE, "CHANGELOG 本体一个字不动");
+});
+
+test("入口：版本不存在时非零退出、不写正文（不许退回空正文假成功）", () => {
+  const root = mkdtempSync(join(tmpdir(), "mneme-release-notes-"));
+  mkdirSync(join(root, "dsh-mneme"), { recursive: true });
+  writeFileSync(join(root, "dsh-mneme", "CHANGELOG.md"), SAMPLE, "utf8");
+  const res = spawnSync(process.execPath, [scriptPath, "9.9.9"], { cwd: root, encoding: "utf8" });
+  assert.notEqual(res.status, 0, "找不到小节必须非零退出");
+  assert.match(
+    res.stderr,
+    /changelog section not found: 9\.9\.9/,
+    "要报出是哪一版找不到 —— 只靠非零退出码的话，脚本崩了也算通过（崩溃不是这条要防的东西，静默假成功才是）"
+  );
+  assert.equal(existsSync(join(root, "notes", "body.md")), false, "不该留下空正文");
+});
+
+test("入口：版本号格式不对时直接拒绝", () => {
+  const res = spawnSync(process.execPath, [scriptPath, "v1.2"], { encoding: "utf8" });
+  assert.notEqual(res.status, 0, "只接受 x.y.z");
+  assert.match(res.stderr, /usage: release-notes\.mjs/, "要说清用法，别静默退出");
+});

package/test/release-workflow.test.js

@@ -75,3 +75,19 @@ test("publish 内必须跑阻塞闸门：release 等的是一个真做过校验
     "不要退回命令替换里的 npm view —— 失败不会让 set -e 退出，那是 v0.8.16 的假绿"
   );
 });
+
+test("release 的正文抽取必须调模块，不许退回工作流内联脚本", () => {
+  // 原先这段是内联 node -e：改排版要动工作流本体、还没法写测试，而 Release 正文恰恰是最需要
+  // 反复试排版的东西。退回内联就等于退回「改了没人能验证」的状态，这条锁住它不再发生。
+  const code = jobBlock("release").filter((line) => !/^\s*#/.test(line)).join("\n");
+  assert.match(
+    code,
+    /node dsh-mneme\/scripts\/release-notes\.mjs/,
+    "release job 必须调用 release-notes.mjs（渲染有单测、本地可预览）"
+  );
+  assert.doesNotMatch(
+    code,
+    /node -e/,
+    "不要退回 node -e 内联脚本 —— 那段逻辑没有测试覆盖"
+  );
+});

package/test/route-policy.test.js

@@ -0,0 +1,113 @@
+// 路由鉴权的结构锁（2026-10 审计 P0 的修法验证）。
+// 这批用例锁的不是「某条路由要不要 token」，而是**鉴权不再靠人记得写**：
+//   1. 新路由漏声明 policy → createApi / register 直接抛（起不来，而不是静默开放）
+//   2. 同一路径重复登记 → 抛（防复制粘贴出两条同路径、其中一条没人管）
+//   3. 三种 policy 的运行时语义（open / token / token-write）
+//   4. 装配后的每条路由都带 policy，且 count() 与实际挂载数一致
+// 之所以不写「39 条路由 × 方法的权限矩阵」：缺声明这条已经是装配期错误，
+// 矩阵要抓的那类回归在结构上写不出来。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSettings } from "../src/settings.js";
+import { createApi, createRouteRegistrar, ROUTE_POLICIES } from "../src/api.js";
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function fakeWebServer(mounted) {
+  return { register(route) { mounted.push(route); return () => {}; } };
+}
+
+function req(method) {
+  const r = new EventEmitter();
+  r.url = "/x";
+  r.method = method;
+  r.headers = {};
+  return r;
+}
+
+function registrar(apiToken = "secret-token") {
+  const mounted = [];
+  const { register, count } = createRouteRegistrar(fakeWebServer(mounted), apiToken, []);
+  return { register, count, mounted };
+}
+
+test("漏声明 policy 的路由起不来（不是默认开放）", () => {
+  const { register } = registrar();
+  assert.throws(
+    () => register({ kind: "exact", path: "/api/dsh-mneme/nope", handler() {} }),
+    /必须声明 policy/
+  );
+  assert.throws(
+    () => register({ kind: "exact", path: "/api/dsh-mneme/nope", policy: "public", handler() {} }),
+    /必须声明 policy/
+  );
+});
+
+test("同一 kind+path 重复登记会抛", () => {
+  const { register } = registrar();
+  register({ kind: "exact", path: "/api/dsh-mneme/dup", policy: "open", handler() {} });
+  assert.throws(
+    () => register({ kind: "exact", path: "/api/dsh-mneme/dup", policy: "open", handler() {} }),
+    /重复登记/
+  );
+});
+
+test("open：配了 token 也放行", () => {
+  const { register, mounted } = registrar();
+  let called = 0;
+  register({ kind: "exact", path: "/api/dsh-mneme/open", policy: "open", handler() { called++; } });
+  const res = new FakeRes();
+  mounted[0].handler(req("GET"), res);
+  assert.equal(called, 1);
+  assert.equal(res.statusCode, 200);
+});
+
+test("token：任何方法都要 Bearer，handler 根本进不去", () => {
+  const { register, mounted } = registrar();
+  let called = 0;
+  register({ kind: "exact", path: "/api/dsh-mneme/gated", policy: "token", handler() { called++; } });
+  const denied = new FakeRes();
+  mounted[0].handler(req("GET"), denied);
+  assert.equal(denied.statusCode, 401);
+  assert.equal(called, 0);
+
+  const okReq = req("GET");
+  okReq.headers = { authorization: "Bearer secret-token" };
+  const ok = new FakeRes();
+  mounted[0].handler(okReq, ok);
+  assert.equal(called, 1);
+});
+
+test("token-write：GET 开放、POST 要 Bearer", () => {
+  const { register, mounted } = registrar();
+  let called = 0;
+  register({ kind: "exact", path: "/api/dsh-mneme/half", policy: "token-write", handler() { called++; } });
+  mounted[0].handler(req("GET"), new FakeRes());
+  assert.equal(called, 1, "GET 无 token 也放行");
+  const denied = new FakeRes();
+  mounted[0].handler(req("POST"), denied);
+  assert.equal(denied.statusCode, 401);
+  assert.equal(called, 1, "POST 无 token 不进 handler");
+});
+
+test("装配后每条路由都带 policy，count() 与实际挂载数一致", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const mounted = [];
+  const ctx = { webServer: fakeWebServer(mounted) };
+  const api = createApi(ctx, service, settings, { add() {}, remove() {}, list: () => [] }, null, undefined, "secret-token");
+  assert.ok(mounted.length >= 30, "路由数异常：" + mounted.length);
+  for (const route of mounted) {
+    assert.ok(ROUTE_POLICIES.includes(route.policy), route.path + " 的 policy 非法：" + route.policy);
+    assert.equal(typeof route.handler, "function");
+  }
+  assert.equal(api.routes, mounted.length, "createApi 汇报的路由数必须等于实际挂载数");
+});

package/test/security-doc.test.js

@@ -0,0 +1,139 @@
+// SECURITY.md 的两处声明会随时间变成谎话，而且没人会注意到：
+// 一是「Supported Versions」表——0.9.0 发了两个月它还在写 0.8.x 活跃开发中（#SECURITY 审计实测）；
+// 二是文件里的相对链接——docs/DAEMON.md 实际在 dsh-mneme/docs/ 下，链接指错了也没人点。
+// 这里把两件事都锁住：版本行必须等于 package.json 的 major.minor，链接必须真的能 stat 到。
+// 不锁「正文里出现的版本号」——历史审计节记录的是过去的事实，写死版本号在那里是对的。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSettings } from "../src/settings.js";
+import { createApi } from "../src/api.js";
+
+const pkgRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const repoRoot = path.dirname(pkgRoot);
+const docPath = path.join(repoRoot, "SECURITY.md");
+const doc = readFileSync(docPath, "utf8");
+
+// package.json 的 version → 支持表里应当出现的那一行（"0.9.0" → "0.9.x"）。
+const { version } = JSON.parse(readFileSync(path.join(pkgRoot, "package.json"), "utf8"));
+const [major, minor] = version.split(".");
+const expectedVersionRow = `${major}.${minor}.x`;
+
+// 取某一节（到下一个同级 ## 标题为止）。用节而不是全文 grep：
+// 历史审计节里也有 "v0.x.y" 字样，全文匹配会假绿。
+function section(heading) {
+  const start = doc.indexOf(heading);
+  assert.ok(start >= 0, `SECURITY.md 里应有「${heading}」一节`);
+  const rest = doc.slice(start + heading.length);
+  const end = rest.search(/\r?\n## /);
+  return end >= 0 ? rest.slice(0, end) : rest;
+}
+
+test("SECURITY.md 的支持版本表跟着 package.json 走（中英各一份）", () => {
+  for (const heading of ["## Supported Versions", "## 支持版本"]) {
+    const body = section(heading);
+    // 表第一行就是「当前支持」的那一行；锁它，别锁整表（历史版本行本来就该在）。
+    const rows = body.split(/\r?\n/).filter((l) => /^\|\s*[\d<]/.test(l));
+    assert.ok(rows.length >= 2, `${heading} 的版本表应至少两行，实际 ${rows.length} 行`);
+    const current = rows[0].split("|")[1].trim();
+    assert.equal(current, expectedVersionRow,
+      `${heading} 的首行应写 ${expectedVersionRow}（package.json 为 ${version}），实际写了 ${current}`);
+  }
+});
+
+test("SECURITY.md 的版本表在两种语言之间是同一张表", () => {
+  const versions = (heading) => section(heading)
+    .split(/\r?\n/)
+    .filter((l) => /^\|\s*[\d<]/.test(l))
+    .map((l) => l.split("|")[1].trim());
+  assert.deepEqual(versions("## 支持版本"), versions("## Supported Versions"),
+    "中文表与英文表的版本行必须逐行一致，否则读者会看到两个不同的支持范围");
+});
+
+test("SECURITY.md 里的相对链接都能落到真实文件", () => {
+  // 链接从仓库根解析（README 与 SECURITY.md 都在根上）。
+  // 只查相对路径：外链、锚点、mailto 不归这里管。
+  const links = [...doc.matchAll(/\[[^\]]*\]\(([^)\s]+)\)/g)]
+    .map((m) => m[1])
+    .filter((href) => !/^(?:[a-z][a-z0-9+.-]*:|#)/i.test(href))
+    .map((href) => href.split("#")[0])
+    .filter(Boolean);
+  assert.ok(links.length >= 2, `应解析出至少 2 条相对链接，实际 ${links.length}——正则失配会让这个用例变成永真`);
+  const broken = links.filter((href) => !existsSync(path.resolve(repoRoot, href)));
+  assert.deepEqual(broken, [], "这些相对链接指向了不存在的文件：" + broken.join(", "));
+});
+
+test("SECURITY.md 不再把供应商写成已停用的那家", () => {
+  // 依赖扫描的实况是 gitleaks + dependency-review + OSV-Scanner + Dependabot，
+  // 文档里曾长期写着第三方商业扫描平台（该平台并不在 CI 里跑）。
+  assert.ok(!/OrbisAI/i.test(doc), "依赖扫描工具应写 CI 里真实在跑的那几个，不能留旧供应商名");
+});
+
+// 安全模型节那两张路由清单是「从代码抄出来的」，抄错了没人会发现：
+// 实测就漏过 /persona（token-write，GET 开放）与 /conflicts（token，只读也要 token）。
+// 这里不重跑鉴权逻辑（那是 route-policy.test.js 的事），只锁「文档清单 == 代码里的 policy 声明」：
+// 以真实装配出来的路由为准，双向比对——文档少写、多写、写错边，都红。
+function declaredRoutes() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const mounted = [];
+  createApi(
+    { webServer: { register(route) { mounted.push(route); return () => {}; } } },
+    service, settings, { add() {}, remove() {}, list: () => [] }, null, undefined, "secret-token"
+  );
+  // 路由名去掉公共前缀，文档里写的是 /export 而不是 /api/dsh-mneme/export。
+  return mounted.map((route) => ({
+    name: route.path.replace("/api/dsh-mneme", "") || "/",
+    policy: route.policy
+  }));
+}
+
+// 从清单行里抠出反引号包着的路由。只认「可选方法 + 斜杠开头」的形状，
+// 这样 `GET`/`HEAD` 这种纯方法名不会被当成路径。
+function routesInBullet(line) {
+  const out = [];
+  for (const m of line.matchAll(/`([^`]+)`/g)) {
+    const hit = m[1].trim().match(/^(?:GET|HEAD|POST|PUT|PATCH|DELETE)?\s*(\/\S*)$/);
+    if (hit) out.push(hit[1]);
+  }
+  return out;
+}
+
+function bullet(prefix) {
+  const line = doc.split(/\r?\n/).find((l) => l.startsWith(prefix));
+  assert.ok(line, `SECURITY.md 里应有以「${prefix}」开头的清单行`);
+  return routesInBullet(line);
+}
+
+// 文档里的 /semantic/graph/* 覆盖代码里的 /semantic/graph/ego 与 /semantic/graph/entity-attrs。
+function covers(docEntry, name) {
+  if (docEntry === name) return true;
+  return docEntry.endsWith("/*") && name.startsWith(docEntry.slice(0, -1));
+}
+
+test("SECURITY.md 的开放读清单与代码里的 policy 声明一致", () => {
+  const open = declaredRoutes().filter((r) => r.policy === "open" || r.policy === "token-write");
+  for (const prefix of ["- **Open reads", "- **开放读"]) {
+    const listed = bullet(prefix);
+    const missing = open.filter((r) => !listed.some((e) => covers(e, r.name))).map((r) => r.name);
+    assert.deepEqual(missing, [], `${prefix} 漏了这些实际开放的路由：${missing.join(", ")}`);
+    const stale = listed.filter((e) => !open.some((r) => covers(e, r.name)));
+    assert.deepEqual(stale, [], `${prefix} 写了代码里并不开放的路由：${stale.join(", ")}`);
+  }
+});
+
+test("SECURITY.md 的受门控清单与代码里的 policy 声明一致", () => {
+  const gated = declaredRoutes().filter((r) => r.policy === "token" || r.policy === "token-write");
+  for (const prefix of ["- **Gated routes", "- **受门控的路由"]) {
+    const listed = bullet(prefix);
+    const missing = gated.filter((r) => !listed.some((e) => covers(e, r.name))).map((r) => r.name);
+    assert.deepEqual(missing, [], `${prefix} 漏了这些实际受门控的路由：${missing.join(", ")}`);
+    const stale = listed.filter((e) => !gated.some((r) => covers(e, r.name)));
+    assert.deepEqual(stale, [], `${prefix} 写了代码里并不受门控的路由：${stale.join(", ")}`);
+  }
+});

package/test/sensitive-scan.test.js

@@ -205,3 +205,47 @@ test("长文本上的回溯有上界：写阻塞类回归的计时护栏", () =>
     assert.ok(ms < 2000, `${text.length} 字符耗时 ${ms.toFixed(1)}ms，超 2000ms 预算（回溯上界被破坏？）`);
   }
 });
+
+// 仓库文本守卫：语料里的凭据值必须以拼接形式存在，仓库里不得留下完整形状。
+// 触发这件事的是 GitHub secret scanning 的 alert #1——write-admission-samples.js 里
+// openai-key 那条曾经是整串字面量（同文件其它四条都已是 assemble 拼接），被报成
+// openai_api_key 的 open=true 告警。它本身不是泄露（正文是 a-z、0-9 的顺序串），
+// 但扫描器只看形状；而这条漏网说明「逐条记得改」靠不住，所以用一条测试把它钉住：
+// 以后谁再往语料里加字面量，这里先红，不用等 GitHub 来通知。
+test("语料里不留完整形状的凭据字面量（secret scanning alert #1 的回归锁）", async () => {
+  const { readFile, readdir } = await import("node:fs/promises");
+  const helpersDir = new URL("./helpers/", import.meta.url);
+  const files = (await readdir(helpersDir)).filter((f) => f.endsWith(".js"));
+  // 前缀集合与长度都对齐 src/sensitive-scan.js 的 github_token / slack_token /
+  // openai_key 三条规则——只有形状一致才谈得上「扫描器会认」，前缀写窄了等于给
+  // gho_ / ghs_ / xoxp- 这些同族凭据开后门。改那三条规则时这里要跟着改。
+  // 唯一放宽的是 sk- 的下限：生产规则是 24，这里用 20，宁可多报——漏报的代价是
+  // GitHub 再报一次告警，多报的代价只是有人来把这行改成拼接。
+  const rules = [
+    // kind 与生产判据对齐，下面的断言拿它反查 scanSensitive 是不是真认这个形状。
+    { re: /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/, what: "OpenAI key", kind: "openai_key", probe: `sk-${"a1".repeat(13)}` },
+    { re: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36}\b/, what: "GitHub token", kind: "github_token", probe: `ghs_${"a1".repeat(18)}` },
+    { re: /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/, what: "Slack token", kind: "slack_token", probe: `xoxp-${"a1".repeat(8)}` }
+  ];
+  // 「与生产规则同源」不能只是注释：CodeRabbit 在 #465 指出前一版把前缀写窄了
+  // （只认 ghp_ / xoxb-，漏了 gho_/ghs_/xoxp-），注释却写着同源。所以这里反查
+  // scanSensitive——守卫的每条规则必须真的被生产判据认成同一个 kind，否则这条红。
+  // 生产规则收窄前缀时，这条测试会先于「GitHub 又报一次告警」发现不一致。
+  // 两段合起来才叫同源：探针要同时被**守卫的规则**和**生产判据**认下，且 kind 一致。
+  // 只查一边的话，任一侧收窄前缀都不会红——那正是 CodeRabbit 指出的失效模式。
+  for (const { re, what, kind, probe } of rules) {
+    assert.match(probe, re, `守卫自己的 ${what} 规则认不出 ${probe}，前缀写窄了？`);
+    assert.equal(scanSensitive(probe)?.kind, kind, `生产判据不认 ${probe} 为 ${kind}，守卫与它不同源`);
+  }
+  for (const file of files) {
+    const text = await readFile(new URL(file, helpersDir), "utf8");
+    for (const { re, what } of rules) {
+      const hit = text.match(re);
+      assert.equal(
+        hit,
+        null,
+        `${file} 里出现了完整的 ${what} 字面量（${hit?.[0]?.slice(0, 12)}…）：按 assemble 拼接，别整串写`
+      );
+    }
+  }
+});