@modusensus/dsh-mneme 0.9.0 → 0.9.1

package/test/api.test.js

@@ -682,9 +682,12 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   // 溯源：开关与保留期都在嵌套对象里，两个都进 NESTED_FLAG_PATHS））
   // v0.9.0 新增 actionPipelineEnabled（M.O. beta 门控；顶层扁平键，
   // 走 configFlagValue 默认分支，不需要 NESTED_FLAG_PATHS 条目）。
+  // v0.9.0 第二批新增 actionRunEnabled（M.O. 执行记账；同样顶层扁平键）。
+  // persona 页新增 personaEnabled（人格注入顶层总闸；顶层扁平键，同上）。
   // 计数锁钉的是「白名单键 ↔ config schema 成对」：schema 加了键而漏了白名单
   // （或反过来）时，effective 会静默少键/多键，面板读不到也报不出来。
-  assert.equal(Object.keys(data.effective).length, 59 + 3 + 2 + 1 + 2 + 2 + 2 + 1 + 1 + 1 + 2 + 1 + 2 + 1 + 3 + 2 + 2 + 1 + 1 + 1 + 1 + 2 + 1 + 2 + 1);
+  // 合并 #451（人格页）后的真实计数：98（本批前）+ actionRunEnabled + personaEnabled = 99
+  assert.equal(Object.keys(data.effective).length, 99);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMergeGuard, true);
@@ -721,6 +724,11 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   // v0.9.0：M.O. beta 门控默认关——客户端 GET /features 必须能读到这个键
   // （读不到就静默不注册任何座位），且默认值必须是 false（beta opt-in）。
   assert.equal(data.effective.actionPipelineEnabled, false);
+  // v0.9.0 第二批：M.O. 执行记账同样默认关，且**是独立的一个键**——看图与写账
+  // 分开，避免「只想看图」的人不知不觉获得热路径上的写入能力。
+  assert.equal(data.effective.actionRunEnabled, false);
+  // 人格页（beta）：注入总闸默认关，effective 必须能读到（同 #254 坑形防线）。
+  assert.equal(data.effective.personaEnabled, false);
   // 新增字符串 / URL / 枚举键
   assert.equal(data.effective.localEmbedModel, "Xenova/bge-small-zh-v1.5");
   assert.equal(data.effective.ollamaBaseUrl, "http://localhost:11434");
@@ -1863,3 +1871,92 @@ test("GET /api/dsh-mneme/inject-preview: returns last assembly snapshot (issue #
   assert.equal(res.statusCode, 404);
   injector(); // 快照是模块全局：用完即清，不污染后续用例
 });
+
+// --- /pipeline：观察旁挂能真的挂进投影（CodeRabbit #458 F1 的锁）--------------
+
+test("GET /api/dsh-mneme/pipeline 带观察旁挂：observationsById 真的进了投影而不是被 catch 吞掉", async () => {
+  // 锁 F1：ids 原本声明在账本分支的块级作用域里，旁挂块一引用就 ReferenceError，
+  // 被 catch 静默吞成「没有观察」——面板上一切正常，fix-step-tool 提议却永远少一类。
+  const { mkdtempSync, mkdirSync, writeFileSync, rmSync } = await import("node:fs");
+  const { tmpdir } = await import("node:os");
+  const { join } = await import("node:path");
+  const { saveObservations } = await import("../src/pipeline-observations.js");
+
+  const root = mkdtempSync(join(tmpdir(), "mo-api-f1-"));
+  try {
+    const project = join(root, "proj");
+    const pipeline = {
+      id: "demo-f1",
+      name: "演示F1",
+      project: "someone/repo",
+      version: 0,
+      status: "active",
+      done: "做完",
+      trigger: [{ kind: "phrase", value: "跑一下" }],
+      steps: [{
+        id: "S1",
+        phase: "做",
+        title: "跑测试",
+        when: "有人要跑",
+        do: "npm test",
+        who: "main",
+        tool: "npm test",
+        done: "测试全绿",
+        risk: "R0",
+        needs: [],
+        why: "没有它后面没得跑",
+        evidence: ["跑过"]
+      }]
+    };
+    // 项目层工作流（<project>/.mneme/pipelines/*.json）
+    mkdirSync(join(project, ".mneme", "pipelines"), { recursive: true });
+    writeFileSync(join(project, ".mneme", "pipelines", "demo-f1.json"), JSON.stringify(pipeline));
+    // 运行账：<project>/.mneme/pipelines/<id>.runs.jsonl（有账才走到旁挂分支）。
+    // 行形状走 normalizeRun 契约：run.at/by + step.at 全必填（时间不补默认）。
+    writeFileSync(
+      join(project, ".mneme", "pipelines", "demo-f1.runs.jsonl"),
+      JSON.stringify({ at: "2026-10-17T01:00:00.000Z", by: "main", steps: [{ id: "S1", at: "2026-10-17T01:00:00.000Z", skipped: false, detoured: false, refuted: false }] }) + "\n"
+    );
+    // 观察旁挂：<memoryDir>/observations/<项目键>/demo-f1.jsonl。项目键走 candidates.js
+    // 的 projectKey(projectRoot)（sha256 前 8 位 + 清洗名），与 api.js 同源——不能用
+    // 裸 observations/ 目录，那不是 api 侧会查的桶。
+    const { projectKey } = await import("../src/candidates.js");
+    const memoryDir = join(root, "memory");
+    const odir = join(memoryDir, "observations", projectKey(project));
+    const saved = saveObservations({
+      dir: odir,
+      pipelineId: "demo-f1",
+      confirmAt: "2026-10-17T02:00:00.000Z",
+      activities: [{ key: "git push", count: 2 }]
+    });
+    assert.equal(saved.ok, true);
+
+    const { routes } = setup(undefined, "", { memoryDir });
+    const route = routes.find((r) => r.path === "/api/dsh-mneme/pipeline");
+    const res = new FakeRes();
+    await route.handler(req(`/api/dsh-mneme/pipeline?id=demo-f1&project=${encodeURIComponent(project)}`), res);
+    assert.equal(res.statusCode, 200);
+    const data = JSON.parse(res.body);
+    const row = (data.available || []).find((r) => r.id === "demo-f1");
+    assert.ok(row, "工作流要出现在清单里");
+    assert.ok(data.pipeline, "选中投影要存在");
+    // F1 的直接断言：观察旁挂真的喂进了 suggestions 的判据（修复前 observationsById
+    // 恒为 {}——ReferenceError 被 catch 吞掉，观察永远空）。
+    // 观察里只写了 git push，而 S1 声明 tool=npm test 且账本确认走过 1 次 → 矛盾
+    // 成立，fix-step-tool 必须冒头（下方正向锁）；观察为空时它不该冒，那是
+    // pipeline.test.js 的判据锁。
+    // runsState 是账本健康度（RUNS_STATES: absent/empty/ok/partial/broken），
+    // 不是节点状态——账本一行合法 run 即为 ok。节点级 trusted 由 deriveState 管，
+    // 在 summarizePipeline 的 perNode 里，这里不重复锁。
+    assert.equal(row.runsState, "ok", "账本一行合法 run，健康度应是 ok");
+    // suggestions 在投影顶层（不在 pipeline 对象下）。
+    assert.ok(Array.isArray(data.suggestions), "投影必须带 suggestions 数组");
+    // 正向锁：观察里只有 git push、S1 声明 npm test 且确认走过 → fix-step-tool 必须冒头。
+    // F1 未修时 observationsById 恒为空，这条断言必挂——正是要抓的回归。
+    const fix = data.suggestions.find((s) => s.kind === "fix-step-tool");
+    assert.ok(fix, "观察进了判据（npm test 未见于观察）→ 必须有 fix-step-tool 提议");
+    assert.equal(fix.stepId, "S1");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/test/changelog-prep.test.js

@@ -18,18 +18,84 @@ const hasBareLf = (text) => /(^|[^\r])\n/.test(text);
 test("LF 输入：插入占位节，行尾保持 LF，旧内容原样保留", () => {
   const r = insertReleaseSection(LF_HEAD, "0.8.13", "2026-10-03");
   assert.equal(r.ok, true);
-  assert.ok(r.text.startsWith("# Changelog\n\n## [0.8.13] - 2026-10-03"), "插在标题之后");
+  assert.ok(r.text.startsWith("# Changelog\n\n## [0.8.13] - 2026-10-03"), "没有 [Unreleased] 时插在标题之后");
   assert.ok(r.text.includes("- （待填）"), "带 release.yml verify 要的占位节");
   assert.ok(r.text.includes("## [0.8.12] - 2026-10-01"), "旧内容不动");
   assert.equal(r.text.includes("\r\n"), false, "不该往 LF 文件里混 CRLF");
 });
 
-test("CRLF 输入：同样能插（原先这里静默 no-op —— 本模块存在的首要理由）", () => {
-  const r = insertReleaseSection(CRLF_HEAD, "0.8.13", "2026-10-03");
-  assert.equal(r.ok, true, "CRLF 检出上必须也能插入");
-  assert.notEqual(r.text, CRLF_HEAD, "绝不返回原文——那正是当初的假成功");
-  assert.ok(r.text.includes("## [0.8.13] - 2026-10-03"));
-  assert.equal(hasBareLf(r.text), false, "插入的内容也要用 CRLF，不混行尾");
+test("有 [Unreleased] 时插在它下面，不插在上面", () => {
+  // Keep a Changelog 的约定：未发布区在最上，新版本节排在它下面。
+  // 插反了会得到「[0.9.1] 在 [Unreleased] 之上」——v0.9.0 那次就是靠事后人工提交
+  // （77df0fb）掰回来的，机器算得对的事不该留给人补。
+  const src = "# Changelog\n\n## [Unreleased]\n\n## 🐛 修复\n\n- 攒着的条目\n\n## [0.9.0] - 2026-10-17\n\n- 旧版本\n";
+  const r = insertReleaseSection(src, "0.9.1", "2026-10-18");
+  assert.equal(r.ok, true);
+  assert.ok(
+    r.text.indexOf("## [Unreleased]") < r.text.indexOf("## [0.9.1] - 2026-10-18"),
+    "[Unreleased] 必须排在前面"
+  );
+  assert.ok(
+    r.text.indexOf("## [0.9.1] - 2026-10-18") < r.text.indexOf("## [0.9.0] - 2026-10-17"),
+    "新版本节又必须排在上一版之前"
+  );
+  assert.ok(r.text.includes("- 攒着的条目"), "[Unreleased] 里攒的条目不许丢");
+  assert.ok(r.text.includes("- 旧版本"), "旧版本节不许丢");
+  assert.equal(r.text.includes("\r\n"), false, "这组输入是 LF，不该混进 CRLF");
+});
+
+test("[Unreleased] 攒着条目时整段搬进新版本节，不留空占位节", () => {
+  // 原先只插一个「🐛 修复 / （待填）」占位，攒着的条目原地不动：发版后文件里同时存在
+  // 「新版本节是空的」和「旧条目还挂在 Unreleased 名下」，搬运这一步照样要人工补
+  // （v0.9.0 的 77df0fb 干的就是这件事）。搬位置不搬内容——原样移动、一个字不改。
+  const src =
+    "# Changelog\n\n## [Unreleased]\n\n## 🐛 修复\n\n- 条目甲\n- 条目乙\n\n## 🔐 安全\n\n- 条目丙\n\n## [0.9.0] - 2026-10-17\n\n- 旧版本\n";
+  const r = insertReleaseSection(src, "0.9.1", "2026-10-18");
+  assert.equal(r.ok, true);
+  assert.equal(r.moved, 3, "三条条目都要搬过去");
+  assert.equal(r.movedContent, true, "搬了正文与条目，两个字段都该为真");
+  assert.equal(r.text.includes("（待填）"), false, "搬了真条目就不该再留空占位");
+  // Unreleased 立刻接新版本节，中间不夹任何内容
+  assert.ok(r.text.startsWith("# Changelog\n\n## [Unreleased]\n\n## [0.9.1] - 2026-10-18\n\n## 🐛 修复\n\n- 条目甲"));
+  assert.ok(r.text.includes("## 🔐 安全\n\n- 条目丙"), "多个小节整体搬，小节结构不动");
+  assert.ok(r.text.indexOf("- 条目丙") < r.text.indexOf("## [0.9.0]"), "全都搬进新节里，不留一条挂在 Unreleased 名下");
+});
+
+test("[Unreleased] 正文非空但没有 `- ` 条目时，movedContent 仍为 true（moved 只是计数）", () => {
+  // 用 moved 当「有没有搬」的判据是错的：正文非空、但一条 `- ` 都没有时 moved 是 0，
+  // 入口会打印「占位节（[Unreleased] 本来是空的）」——而它显然不空。两个字段必须分开用。
+  const src = "# Changelog\n\n## [Unreleased]\n\n一段没有条目的说明正文。\n\n## [0.9.0] - 2026-10-17\n\n- 旧版本\n";
+  const r = insertReleaseSection(src, "0.9.1", "2026-10-18");
+  assert.equal(r.ok, true);
+  assert.equal(r.moved, 0, "没有 `- ` 开头的行为，条目数是 0");
+  assert.equal(r.movedContent, true, "但正文确实搬了，这个字段才是「有没有搬」的判据");
+  assert.ok(r.text.includes("一段没有条目的说明正文。"), "正文不许丢");
+  assert.equal(r.text.includes("（待填）"), false, "不该在搬了正文之后还留空占位");
+});
+
+test("[Unreleased] 首行是缩进代码块时保留前导空格（原样搬，不 trim）", () => {
+  // body.trim() 会把首行的四空格吃掉，Markdown 代码块降级成普通段落——
+  // 那就不是「整段搬、一个字不改」了。只许剥掉节边界上的空行。
+  const src = "# Changelog\n\n## [Unreleased]\n\n    npm run sync\n\n## [0.9.0] - 2026-10-17\n\n- 旧版本\n";
+  const r = insertReleaseSection(src, "0.9.1", "2026-10-18");
+  assert.equal(r.ok, true);
+  assert.ok(r.text.includes("\n    npm run sync\n"), "四空格缩进必须原样保留：\n" + JSON.stringify(r.text));
+});
+
+test("[Unreleased] 为空时插占位节，且不产生多余空行", () => {
+  const src = "# Changelog\r\n\r\n## [Unreleased]\r\n## [0.9.0] - 2026-10-17\r\n\r\n- x\r\n";
+  const r = insertReleaseSection(src, "0.9.1", "2026-10-18");
+  assert.equal(r.ok, true, "CRLF 检出上也要能插");
+  assert.equal(r.moved, 0, "Unreleased 是空的，没有可搬的");
+  assert.equal(r.movedContent, false, "Unreleased 空时才该走占位节分支");
+  assert.ok(
+    r.text.startsWith(
+      "# Changelog\r\n\r\n## [Unreleased]\r\n\r\n## [0.9.1] - 2026-10-18\r\n\r\n## 🐛 修复\r\n\r\n- （待填）\r\n\r\n## [0.9.0] - 2026-10-17\r\n"
+    ),
+    "空的 Unreleased 后面接占位节，再接上一版"
+  );
+  assert.equal(/\n\n\n/.test(r.text.replace(/\r\n/g, "\n")), false, "不许出三连空行");
+  assert.equal(hasBareLf(r.text), false);
 });
 
 test("带 BOM 的输入也能插（`^#` 匹配不到属同一类形状漂移）", () => {
@@ -57,4 +123,4 @@ test("detectEol：认两种行尾，无换行时按 LF 处理", () => {
   assert.equal(detectEol("a\nb"), "\n");
   assert.equal(detectEol("a\r\nb"), "\r\n");
   assert.equal(detectEol("a"), "\n");
-});
+});

package/test/cli-enums.test.js

@@ -0,0 +1,37 @@
+// CLI 枚举是手写字面量（bin/cli.mjs 是零依赖 HTTP 客户端，不 import 服务端
+// 模块），没有类型系统兜着，所以用一张文本锁把它钉在 store.TYPES 上。
+// 防的回归：2026-10 审计发现 MEMORY_TYPES 只有 5 个类型、SEARCH_MODES 缺
+// hybrid，结果是 add --type pitfall 与 search --mode hybrid 被客户端自己拒掉
+// ——服务端明明支持，客户端先说不。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { TYPES } from "../src/store.js";
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const cli = readFileSync(path.join(root, "bin", "cli.mjs"), "utf8");
+
+function literalArray(name) {
+  const m = cli.match(new RegExp("const " + name + " = \\[([^\\]]*)\\]"));
+  assert.ok(m, name + " 应从 bin/cli.mjs 里解析出来（改名就同步改这把锁）");
+  return [...m[1].matchAll(/'([^']+)'/g)].map((x) => x[1]);
+}
+
+test("cli MEMORY_TYPES 与 store.TYPES 的差值恰好是 document", () => {
+  const cliTypes = literalArray("MEMORY_TYPES");
+  // document 只能经 memory_register_document 铸造；放进 --type 会让用户得到一条
+  // 服务端 400。锁「差值恰好是 document」而不是「完全相等」，就是为了让这条
+  // 例外显式化：未来再加一个只能经专用接口铸造的类型，这里会红。
+  const expected = [...TYPES].filter((t) => t !== "document").sort();
+  assert.deepEqual(cliTypes.slice().sort(), expected);
+});
+
+test("cli SEARCH_MODES 覆盖 API 支持的全部召回模式", () => {
+  const modes = literalArray("SEARCH_MODES");
+  // 四种模式来自 src/api.js 的 /search mode 注释（auto/hybrid/vector/keyword）。
+  for (const mode of ["keyword", "vector", "auto", "hybrid"]) {
+    assert.ok(modes.includes(mode), "SEARCH_MODES 缺少 " + mode);
+  }
+});

package/test/client.test.js

@@ -1020,10 +1020,14 @@ test("scope isolation ships panel switches and provenance surfaces (A4)", () =>
 // 默认值），面板自判、不加后端字段；④分组与折叠键中英成对。验收口径：首屏
 // 可点项 = 3 总开关 + autoInject 的 2 个子开关 + scope 2 开关 + 「全部设置」
 // 按钮 = 8（≤ 8），由 ①② 的组成正则共同钉死，不另数 DOM。
+// v0.9.0 复验修订：首屏加 group.mo（M.O. 独立组），可点项预算 8→9。这不是
+// 悄悄放宽——是产品主人点名「别藏在里面」：M.O. 独立成组却仍折在「全部
+// 设置」后等于换个地方继续藏。≤8 原为 #427 自设软预算，owner 豁免一项。
 test("settings card folds everything beyond the first screen behind All settings (issue #427)", () => {
-  // ① 首屏层组成：两组都要在，且 basic 的成员是从 core/dream 移走的。
-  assert.ok(/const FEATURE_FIRST_SCREEN = \["group\.basic", "group\.scope"\];/.test(clientSource),
-    "the first screen must be exactly the basic and scope groups");
+  // ① 首屏层组成：三组都要在（basic 总开关 / mo 座位闸门 / scope 必答题），
+  // 且 basic 的成员是从 core/dream 移走的。
+  assert.ok(/const FEATURE_FIRST_SCREEN = \["group\.basic", "group\.mo", "group\.scope"\];/.test(clientSource),
+    "the first screen must be exactly the basic, mo and scope groups");
   assert.ok(/key: "group\.basic", items: \["autoInject", "autoSummarize", "autoDream"\]/.test(clientSource),
     "group.basic must carry exactly the three master switches");
   assert.ok(!/key: "group\.core", items: \["autoInject/.test(clientSource) && !/key: "group\.dream", items: \["autoDream/.test(clientSource),
@@ -1939,3 +1943,148 @@ test("M.O. class names do not collide in the stylesheet", () => {
   // 扫描量也得钉：正则一旦匹配不到东西，上面那条会静默变绿（例如样式表被整块挪走）。
   assert.ok(declared.size >= 20, `the scan must actually see the pipeline stylesheet (saw ${declared.size})`);
 });
+
+// 回归锁（v0.9.0 复验轮沉淀）：面板的两种「静默消失」假绿形状一起钉住。
+// ① i18n 缺定义：既有的「每键恰好两次」锁只统计**字典里存在**的键，一个只有
+//   用法、零字典行的键在计数里整个消失——本轮就查出 4 个这种键（zoom.value 自
+//   基线即断）。所以这里反向查：每一处用法都必须能找到定义行。三种用法形状：
+//   字面量 t("k")、模板 t(`memory.features.${g.key}`) 按 FEATURE_GROUPS 的组键
+//   展开、模板 t(`memory.features.${k}`) 按各 items 旗标键展开（boolRow 的
+//   name/hint 各一路）。不做全量动态键解析——拼接形态的键在此设防范围外。
+// ② 图标名未注册：Icon 对查不到的名字 return null（无回退、无告警），闸门照绿
+//   而屏幕上图标没了。本轮 star 入口就是这么哑掉的。这里钉「每个用到的名字都在
+//   ICON_PATHS 注册表里」+ 提取与注册表的最低数量（防正则空转的静默绿）。
+test("panel copy and icons must not silently vanish (missing dict lines, unregistered icon names)", () => {
+  const defined = (key) => clientSource.includes('"' + key + '":');
+
+  // ①-a 字面量用法（右括号紧贴字符串，排除 "前缀" + 变量 拼接形态）
+  const usedKeys = new Set();
+  for (const m of clientSource.matchAll(/\bt\("([a-zA-Z0-9_.]+)"\)/g)) usedKeys.add(m[1]);
+  assert.ok(usedKeys.size >= 300, `the literal scan must actually see the panel's t() calls (saw ${usedKeys.size})`);
+  // ①-b 模板展开：组键 与 旗标键（label + .hint 两路）
+  const groupKeys = [...clientSource.matchAll(/key: "(group\.[a-z]+)"/g)].map((m) => m[1]);
+  assert.ok(groupKeys.length >= 5, `FEATURE_GROUPS must be parseable (saw ${groupKeys.length} groups)`);
+  for (const g of groupKeys) usedKeys.add("memory.features." + g);
+  const flagKeys = [...new Set([...clientSource.matchAll(/items: \[((?:[^\]]|\n)*)\]/g)]
+    .flatMap((m) => [...m[1].matchAll(/"([a-zA-Z0-9_.]+)"/g)].map((x) => x[1])))];
+  assert.ok(flagKeys.length >= 20, `group items must be parseable (saw ${flagKeys.length})`);
+  for (const k of flagKeys) { usedKeys.add("memory.features." + k); usedKeys.add("memory.features." + k + ".hint"); }
+
+  const missing = [...usedKeys].filter((k) => !defined(k)).sort();
+  assert.deepEqual(missing, [], `用而无典的 i18n 键（界面会裸奔出键名）：${missing.join(", ")}`);
+
+  // ② 图标名：注册表形状（顶层对象、六空格缩进）+ Icon 表达式与 feedRow 首参的提取
+  const registered = new Set([...clientSource.matchAll(/^\s{6}([a-zA-Z]+): \[\[/gm)].map((m) => m[1]));
+  assert.ok(registered.size >= 10, `the ICON_PATHS registry must be parseable (saw ${registered.size})`);
+  const iconNames = new Set();
+  for (const m of clientSource.matchAll(/h\(Icon, \{ name: ([^}]+?) [,}]/g)) {
+    const expr = m[1];
+    const direct = expr.match(/^"([a-zA-Z]+)"$/);
+    if (direct) { iconNames.add(direct[1]); continue; }
+    // 只取三元分支的纯字母串；"===" 比较对象前面是运算符不是 ? : ，不会误伤
+    for (const b of expr.matchAll(/[?:]\s*"([a-zA-Z]+)"/g)) iconNames.add(b[1]);
+  }
+  for (const m of clientSource.matchAll(/feedRow\(\s*"([a-zA-Z]+)"/g)) iconNames.add(m[1]);
+  assert.ok(iconNames.size >= 8, `icon usage must be parseable (saw ${iconNames.size})`);
+  const noIcon = [...iconNames].filter((n) => !registered.has(n)).sort();
+  assert.deepEqual(noIcon, [], `Icon 静默 return null 的未注册名：${noIcon.join(", ")}`);
+});
+
+// 人格定义页（beta）面板面回归：形状沿用 A4 的「分组 + i18n 双语 occurrences ≥ 2
+// + 关键接线」断言风格（只做源码断言，不挂 React 渲染环境）。
+test("persona page ships settings card, master switch and i18n (beta v1)", () => {
+  // 开关进 FEATURE_GROUPS 的 enhance 组（行为开关非座位闸门）
+  assert.ok(
+    /group\.enhance", items: \[(?:[^\]]|\n)*"personaEnabled"\]/.test(clientSource),
+    "FEATURE_GROUPS group.enhance must carry personaEnabled"
+  );
+  // i18n 键中英双语齐备（occurrences ≥ 2 模式；label + .hint 两路由字典锁统一覆盖）
+  for (const key of [
+    "memory.features.personaEnabled",
+    "memory.features.personaEnabled.hint",
+    "memory.settings.persona",
+    "memory.settings.personaHint",
+    "memory.settings.personaName",
+    "memory.settings.personaPersonality",
+    "memory.settings.personaReplyStyle",
+    "memory.settings.personaSave",
+    "memory.settings.personaSaved",
+    "memory.settings.personaEnabledToggle",
+    "memory.settings.personaView",
+    "memory.settings.personaViewHint",
+    "memory.settings.personaViewEmpty"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  // 设置卡接线：保存走 PUT /persona、卡内开关改 enabled 即保存、只读卡渲染
+  assert.ok(clientSource.includes('apiFetch("/api/dsh-mneme/persona"'), "persona card must talk to /persona");
+  assert.ok(clientSource.includes("method: \"PUT\""), "persona save must PUT");
+  assert.ok(clientSource.includes("t(\"memory.settings.personaView\")"), "read-only injected-view card must exist");
+  // 双闸门提示：hint 文案必须说明「总闸与卡内开关同时打开才生效」
+  assert.ok(
+    clientSource.includes("memory.features.personaEnabled.hint"),
+    "the master-switch hint must document the two-gate semantics"
+  );
+});
+
+// v1.2 多卡回归：卡列表 CRUD 可见、字段标签渲染为可见元素（v1.1 反馈：
+// aria-label 看不见）、保存失败必须冒可见错误（v1 静默 catch 吞 404 教训）。
+test("persona card is multi-card with visible field labels and save-failure error", () => {
+  for (const key of [
+    "memory.settings.personaDefaultCard",
+    "memory.settings.personaAdd",
+    "memory.settings.personaAddPlaceholder",
+    "memory.settings.personaEditingDefault",
+    "memory.settings.personaEditingFor",
+    "memory.settings.personaDeleteCard",
+    "memory.settings.personaSaveFailed",
+    "memory.settings.personaEnabledOn",
+    "memory.settings.personaEnabledOff"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  // 多卡接线：加卡/删卡/切换/保存全链函数存在
+  for (const fn of ["addPersonaCard", "removePersonaCard", "savePersonaCards", "setPersonaEditing"]) {
+    assert.ok(clientSource.includes(fn), `multi-card wiring must include ${fn}`);
+  }
+  // 可见字段标签：三个字段名的 t() 调用出现在 label 元素（mneme-featnumlabel）
+  const labelBlock = clientSource.match(/mneme-featnumlabel[^]{0,120}personaName/);
+  assert.ok(labelBlock, "persona field labels must be visible (featnumlabel class), not aria-only");
+  // 保存失败提示：personaError 状态有渲染路径（非仅 setState）
+  assert.ok(clientSource.includes("t(\"memory.settings.personaSaveFailed\")"), "save failure must render an error line");
+});
+
+// 回归锁（复验实测踩中）：面板「检测更新」的状态名必须与后端 classify
+// （src/version-check.js）逐字对齐。此前前端误写 "latest"/"up_to_date"（后端
+// 从未返回过），检测成功也掉进 error 兜底——按钮永远报「检测失败」。
+// 这条缝两端各有测试（version-check.test.js 测 classify、面板测试测渲染），
+// 但契约本身没人管。锁三件事：①前端比较的字面量是后端真实返回值；②后端
+// classify 的返回集合没有前端漏接的成员；③apiFetch 的路由路径与后端注册一致。
+test("update-check status names match the backend classify contract verbatim", () => {
+  const vcSource = readFileSync(join(root, "src/version-check.js"), "utf8");
+  // ① 后端 classify 的全部返回字面量
+  const backendStatuses = new Set(
+    [...vcSource.matchAll(/return "([a-z-]+)";/g)].map((m) => m[1])
+  );
+  assert.ok(backendStatuses.has("up-to-date") && backendStatuses.has("outdated") && backendStatuses.has("ahead") && backendStatuses.has("unknown"),
+    `classify must return the known status set (saw ${[...backendStatuses].join(", ")})`);
+  // ② 前端 checkResultText 比较的每个状态名都必须 ∈ 后端集合（防再发明新名）
+  const iStart = clientSource.indexOf("function checkResultText");
+  assert.ok(iStart > 0, "checkResultText must exist");
+  // 函数块取到下一个同级 function 声明为止：indexOf("}") 会切在首个 if 的
+  // 右括号，比较分支被截断成 1 个（2026-10-17 实测）。
+  const iEnd = clientSource.slice(iStart).search(/\n {6}function /);
+  const block = clientSource.slice(iStart, iEnd > 0 ? iStart + iEnd : undefined);
+  const compared = [...block.matchAll(/updateInfo\.status === "([a-zA-Z_-]+)"/g)].map((m) => m[1]);
+  assert.ok(compared.length >= 2, `the panel must compare real statuses (saw ${compared.length})`);
+  const unknown = [...new Set(compared)].filter((s) => !backendStatuses.has(s));
+  assert.deepEqual(unknown, [], `前端比较了后端不会返回的状态名（检测成功也会显示失败）：${unknown.join(", ")}`);
+  // ③ 路由契约：前端 fetch 的路径必须与后端注册的 exact path 一致
+  assert.ok(clientSource.includes('apiFetch("/api/dsh-mneme/version-check")'),
+    "the panel must call the registered version-check route");
+  const apiSource = readFileSync(join(root, "src/api.js"), "utf8");
+  assert.ok(apiSource.includes('path: "/api/dsh-mneme/version-check"'),
+    "the backend must register the version-check route");
+});

package/test/docs-config-keys.test.js

@@ -0,0 +1,65 @@
+// 「CONFIGURATION.md 是全键参考」这句声明需要一条闸门，否则它会慢慢变成谎话：
+// 2026-10 审计实测有 11 个 schema 键（graph 组 8 个、sensitiveScanEnabled、
+// injectTimePrefix、actionPipelineEnabled）在文档与双 README 里一个字都没有，
+// 而它们里有安全开关。锁法：从 Config({}) 的默认值深挖叶子键，要求每个键名
+// （或它的父路径，用于 heatTypeDecay 这类整表描述）在文档里出现。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { Config } from "../src/config.js";
+
+const root = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const doc = readFileSync(path.join(root, "docs", "CONFIGURATION.md"), "utf8");
+const cfgSrc = readFileSync(path.join(root, "src", "config.js"), "utf8");
+
+function leafKeys(obj, prefix) {
+  const out = [];
+  for (const [k, v] of Object.entries(obj)) {
+    const p = prefix ? prefix + "." + k : k;
+    if (v && typeof v === "object" && !Array.isArray(v)) { out.push(...leafKeys(v, p)); continue; }
+    out.push({ path: p, leaf: k, parent: prefix || "" });
+  }
+  return out;
+}
+
+// 父路径回退是给「整表说明」用的例外，白名单写死在这里而不是「任何父路径都
+// 放行」——否则往 writeAdmission 里加个子键，只要文档提到 writeAdmission 就过，
+// 测试原本要防的漏键会静默复发（评审指出的漏洞）。新增例外必须显式加一行。
+const PARENT_ONLY_OK = new Set(["heatTypeDecay"]);
+
+test("CONFIGURATION.md 覆盖 schema 的每一个键", () => {
+  const keys = leafKeys(Config({}), "");
+  assert.ok(keys.length > 150, "键枚举失败会静默返回 0 项，先锁下限");
+  const missing = keys.filter((k) => {
+    // 完整路径优先（"writeAdmission.enabled"），其次才是显式白名单里的整表父路径。
+    if (doc.includes(k.path)) return false;
+    if (k.parent && PARENT_ONLY_OK.has(k.parent) && doc.includes(k.parent)) return false;
+    // 表里写的是裸键名也认（绝大多数顶层键就是这么写的）。
+    return !doc.includes(k.leaf);
+  });
+  assert.deepEqual(missing.map((m) => m.path), []);
+});
+
+// lightMode 清单是有边界的一节：整份文档 grep 会让「删掉清单里的某一行」照样
+// 通过（图谱表里还留着同名键），测试要盯的漏项就藏在那个缝里。
+function lightSection(text) {
+  const start = text.indexOf("lightMode 强制关闭清单");
+  assert.ok(start >= 0, "文档里应有「lightMode 强制关闭清单」一节");
+  const rest = text.slice(start);
+  const end = rest.indexOf("预设只是默认值");
+  return end > 0 ? rest.slice(0, end) : rest;
+}
+
+test("LIGHT_MODE_OFF 的每一项都写进了文档的轻量档清单", () => {
+  // LIGHT_MODE_OFF 没有导出，只能解析源码文本；先锁解析结果的长度，防止
+  // 正则失配时这个用例变成「空数组 ⊂ 文档」的永真断言。
+  const m = cfgSrc.match(/const LIGHT_MODE_OFF = \[([\s\S]*?)\];/);
+  assert.ok(m, "LIGHT_MODE_OFF 应从 src/config.js 中解析出来");
+  const names = [...m[1].matchAll(/"([^"]+)"/g)].map((x) => x[1]);
+  assert.ok(names.length >= 20, "解析到 " + names.length + " 项，少于预期的 21 项");
+  const section = lightSection(doc);
+  const missing = names.filter((n) => !section.includes(n));
+  assert.deepEqual(missing, []);
+});

package/test/helpers/write-admission-samples.js

@@ -47,7 +47,11 @@ export const SAMPLE_VALUES = {
     ".eyJzdWIiOiIxMjM0NTY3ODkwIn0",
     ".dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U"
   ),
-  stripeKey: assemble("sk_", "live_", "51H8Qw2KZvN3mPqRsTuVwXyZ0123456789abcdef")
+  stripeKey: assemble("sk_", "live_", "51H8Qw2KZvN3mPqRsTuVwXyZ0123456789abcdef"),
+  // 这条曾以整串字面量留在下面的 content 里，被 GitHub secret scanning 报成 openai_api_key
+  // （alert #1）。它是形状样本不是真凭据（正文就是 a-z、0-9 顺序串），但扫描器只看形状，
+  // 所以按上面第 32-34 行的口径统一走拼接，别让它再当例外。
+  openaiKey: assemble("sk-proj-", "abcdefghijklmnopqrstuvwxyz0123456789ABCD")
 };
 
 /** 密钥凭据类正样本。kind 与 label 是判据该报回来的东西。 */
@@ -73,7 +77,7 @@ export const SECRET_SAMPLES = [
     kind: "openai_key",
     label: "OpenAI API key",
     title: "调试记录",
-    content: "临时用 sk-proj-abcdefghijklmnopqrstuvwxyz0123456789ABCD 调了一次",
+    content: `临时用 ${SAMPLE_VALUES.openaiKey} 调了一次`,
     why: "sk-/sk-proj- 前缀 + 长串"
   },
   {

package/test/lib-smoke.test.js

@@ -40,6 +40,26 @@ test("src/ and lib/ are byte-identical (no publish drift)", () => {
   assert.deepEqual(drift, [], "src↔lib must stay in sync (npm run sync)");
 });
 
+test("没有文件带双 CR（行尾必须是 LF 或 CRLF，不是 CRCRLF）", () => {
+  // 这条锁的来历：`src/candidates.js` 从诞生起每个换行都是 `<CR><CR><LF>`，
+  // 一路进了 main、又随 v0.9.0 发到 npm，而**当时没有任何检查会红**——
+  // 因为 `\r` 在 JS 里是合法空白，解析与测试全绿。代价落在别处：
+  //   · 任何改动这个文件的人，diff 都是整文件 908/908（噪声掩盖真改动）；
+  //   · 同一份文件 `Get-Content` 数出 908 行、编辑器/工具数出 454 行，两边对不上；
+  //   · 发布产物里带着畸形行尾。
+  // 判据是**扫描字节**而不是依赖某个工具的换行解释——正因工具口径不一致，
+  // 才必须查 `<CR><CR><LF>` 这个具体序列本身。
+  const bad = [];
+  for (const dir of [srcDir, libDir]) {
+    for (const file of walk(dir)) {
+      if (!file.endsWith(".js")) continue;
+      const doubleCr = readFileSync(file, "utf8").match(/\r\r\n/g);
+      if (doubleCr) bad.push(`${relative(root, file)}: ${doubleCr.length} 处`);
+    }
+  }
+  assert.deepEqual(bad, [], "行尾出现 <CR><CR><LF>——多出来的 CR 会让 diff 与行数口径一起坏掉");
+});
+
 // ---------------------------------------------------------------------------
 // lib 运行时冒烟：直接加载 npm 实际分发的产物
 // ---------------------------------------------------------------------------