@modusensus/dsh-mneme 0.13.0 → 0.14.0-beta.2

package/test/wiki-partition.test.js

@@ -1,112 +1,112 @@
-// partition.js 的回归锁：划分确定性（同输入两次逐项相同——spec §9 可重建不变量的
-// 前半段）、兄弟组内聚合并、超限逐级下切、slug 稳定、父子链按目录包含。
-import test from "node:test";
-import assert from "node:assert/strict";
-import { partitionModules } from "../src/wiki/partition.js";
-
-function graph(edges) {
-  const files = [...new Set(edges.flatMap((e) => [e.from, e.to]))].sort();
-  return { files, graph: { edges, external: new Map() } };
-}
-
-test("划分是确定性的：同输入两次结果逐项相同", () => {
-  const input = graph([
-    { from: "src/a.js", to: "src/b.js" },
-    { from: "lib/c.js", to: "src/a.js" },
-  ]);
-  const one = partitionModules({ ...input, maxFilesPerPage: 40, repoName: "demo" });
-  const two = partitionModules({ ...input, maxFilesPerPage: 40, repoName: "demo" });
-  assert.deepEqual(one, two);
-});
-
-test("根直属文件成 root 模块；目录组各自成页；互不相干的组不合并", () => {
-  // 显式给根直属文件（graph() 只从边推文件，不含根组）。
-  const files = ["README.md", "package.json", "src/a.js", "src/b.js", "tools/x.js", "tools/y.js"];
-  const g = {
-    edges: [
-      { from: "src/a.js", to: "src/b.js" },
-      { from: "tools/x.js", to: "tools/y.js" },
-    ],
-    external: new Map(),
-  };
-  const mods = partitionModules({ files, graph: g, maxFilesPerPage: 40, repoName: "demo" });
-  const slugs = mods.map((m) => m.slug).sort();
-  assert.deepEqual(slugs, ["root", "src", "tools"]);
-  const root = mods.find((m) => m.slug === "root");
-  assert.deepEqual(root.files.sort(), ["README.md", "package.json"]);
-  assert.equal(root.title, "demo（仓库根）");
-  const src = mods.find((m) => m.slug === "src");
-  assert.deepEqual(src.files.sort(), ["src/a.js", "src/b.js"]);
-});
-
-test("兄弟组交叉边 ≥3 才合并（内聚判据要能口述，V2 人判用）", () => {
-  // utils 与 src 之间 3 条边 → 合并成一个模块
-  const strong = graph([
-    { from: "src/a.js", to: "utils/u1.js" },
-    { from: "src/b.js", to: "utils/u1.js" },
-    { from: "src/a.js", to: "utils/u2.js" },
-  ]);
-  const merged = partitionModules({ ...strong, maxFilesPerPage: 40, repoName: "demo" });
-  assert.equal(merged.length, 1, "3 条交叉边触发合并");
-  // 只有 2 条边 → 各自独立
-  const weak = graph([
-    { from: "src/a.js", to: "utils/u1.js" },
-    { from: "src/b.js", to: "utils/u1.js" },
-  ]);
-  const separate = partitionModules({ ...weak, maxFilesPerPage: 40, repoName: "demo" });
-  assert.equal(separate.length, 2, "2 条边不合并");
-});
-
-test("超 max_files_per_page 的组逐级下切，叶子组仍超限按字典序切块", () => {
-  const files = [];
-  const edges = [];
-  for (let i = 0; i < 7; i++) {
-    files.push(`big/f${i}.js`);
-    if (i > 0) edges.push({ from: "big/f0.js", to: `big/f${i}.js` });
-  }
-  const mods = partitionModules({ files, graph: { edges, external: new Map() }, maxFilesPerPage: 3, repoName: "demo" });
-  const total = mods.reduce((sum, m) => sum + m.fileCount, 0);
-  assert.equal(total, 7, "切分不丢文件");
-  assert.ok(mods.every((m) => m.fileCount <= 3), "每块都不超上限");
-  assert.ok(mods.length >= 3, "7 个文件、上限 3 → 至少 3 块");
-  // slug 唯一（切块组的 #2 序号后缀避免撞名）
-  const slugs = mods.map((m) => m.slug);
-  assert.equal(new Set(slugs).size, slugs.length, "slug 无重复");
-});
-
-test("父链按目录包含取最近祖先（spec frontmatter.parents / DB parent_id 同源）", () => {
-  const { files, graph: g } = graph([
-    { from: "src/store/index.js", to: "src/store/util.js" },
-    { from: "src/wiki/t0.js", to: "src/store/index.js" },
-  ]);
-  const mods = partitionModules({ files, graph: g, maxFilesPerPage: 40, repoName: "demo" });
-  // 初稿是两级目录段：src/store、src/wiki；「src」本身不是组 → 无父链也合法，
-  // 但 src/store 与 src/wiki 之间没有包含关系（同层），互不为父。
-  const store = mods.find((m) => m.dir === "src/store");
-  const wiki = mods.find((m) => m.dir === "src/wiki");
-  assert.ok(store && wiki);
-  assert.equal(store.parentSlug, null, "同级目录不是父子");
-});
-
-test("模块指纹随文件集/边集变化（DB 记账与过期检测的输入）", () => {
-  const a = partitionModules({ ...graph([{ from: "src/a.js", to: "src/b.js" }]), maxFilesPerPage: 40, repoName: "d" });
-  const b = partitionModules({
-    files: ["src/a.js", "src/b.js", "src/c.js"],
-    graph: { edges: [{ from: "src/a.js", to: "src/b.js" }], external: new Map() },
-    maxFilesPerPage: 40,
-    repoName: "d",
-  });
-  const fa = a.find((m) => m.slug === "src").fingerprint;
-  const fb = b.find((m) => m.slug === "src").fingerprint;
-  assert.notEqual(fa, fb, "文件集变了指纹必须变");
-});
-
-test("外部依赖按模块聚合（骨架页「外部依赖」一节的数据源）", () => {
-  const files = ["src/a.js", "src/b.js", "lib/c.js"];
-  const external = new Map([["left-pad", new Set(["src/a.js", "src/b.js"])]]);
-  const mods = partitionModules({ files, graph: { edges: [], external }, maxFilesPerPage: 40, repoName: "d" });
-  const src = mods.find((m) => m.dir === "src");
-  assert.deepEqual(src.externalDeps, [{ pkg: "left-pad", count: 2 }]);
-  const lib = mods.find((m) => m.dir === "lib");
-  assert.deepEqual(lib.externalDeps, []);
-});
+// partition.js 的回归锁：划分确定性（同输入两次逐项相同——spec §9 可重建不变量的
+// 前半段）、兄弟组内聚合并、超限逐级下切、slug 稳定、父子链按目录包含。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { partitionModules } from "../src/wiki/partition.js";
+
+function graph(edges) {
+  const files = [...new Set(edges.flatMap((e) => [e.from, e.to]))].sort();
+  return { files, graph: { edges, external: new Map() } };
+}
+
+test("划分是确定性的：同输入两次结果逐项相同", () => {
+  const input = graph([
+    { from: "src/a.js", to: "src/b.js" },
+    { from: "lib/c.js", to: "src/a.js" },
+  ]);
+  const one = partitionModules({ ...input, maxFilesPerPage: 40, repoName: "demo" });
+  const two = partitionModules({ ...input, maxFilesPerPage: 40, repoName: "demo" });
+  assert.deepEqual(one, two);
+});
+
+test("根直属文件成 root 模块；目录组各自成页；互不相干的组不合并", () => {
+  // 显式给根直属文件（graph() 只从边推文件，不含根组）。
+  const files = ["README.md", "package.json", "src/a.js", "src/b.js", "tools/x.js", "tools/y.js"];
+  const g = {
+    edges: [
+      { from: "src/a.js", to: "src/b.js" },
+      { from: "tools/x.js", to: "tools/y.js" },
+    ],
+    external: new Map(),
+  };
+  const mods = partitionModules({ files, graph: g, maxFilesPerPage: 40, repoName: "demo" });
+  const slugs = mods.map((m) => m.slug).sort();
+  assert.deepEqual(slugs, ["root", "src", "tools"]);
+  const root = mods.find((m) => m.slug === "root");
+  assert.deepEqual(root.files.sort(), ["README.md", "package.json"]);
+  assert.equal(root.title, "demo（仓库根）");
+  const src = mods.find((m) => m.slug === "src");
+  assert.deepEqual(src.files.sort(), ["src/a.js", "src/b.js"]);
+});
+
+test("兄弟组交叉边 ≥3 才合并（内聚判据要能口述，V2 人判用）", () => {
+  // utils 与 src 之间 3 条边 → 合并成一个模块
+  const strong = graph([
+    { from: "src/a.js", to: "utils/u1.js" },
+    { from: "src/b.js", to: "utils/u1.js" },
+    { from: "src/a.js", to: "utils/u2.js" },
+  ]);
+  const merged = partitionModules({ ...strong, maxFilesPerPage: 40, repoName: "demo" });
+  assert.equal(merged.length, 1, "3 条交叉边触发合并");
+  // 只有 2 条边 → 各自独立
+  const weak = graph([
+    { from: "src/a.js", to: "utils/u1.js" },
+    { from: "src/b.js", to: "utils/u1.js" },
+  ]);
+  const separate = partitionModules({ ...weak, maxFilesPerPage: 40, repoName: "demo" });
+  assert.equal(separate.length, 2, "2 条边不合并");
+});
+
+test("超 max_files_per_page 的组逐级下切，叶子组仍超限按字典序切块", () => {
+  const files = [];
+  const edges = [];
+  for (let i = 0; i < 7; i++) {
+    files.push(`big/f${i}.js`);
+    if (i > 0) edges.push({ from: "big/f0.js", to: `big/f${i}.js` });
+  }
+  const mods = partitionModules({ files, graph: { edges, external: new Map() }, maxFilesPerPage: 3, repoName: "demo" });
+  const total = mods.reduce((sum, m) => sum + m.fileCount, 0);
+  assert.equal(total, 7, "切分不丢文件");
+  assert.ok(mods.every((m) => m.fileCount <= 3), "每块都不超上限");
+  assert.ok(mods.length >= 3, "7 个文件、上限 3 → 至少 3 块");
+  // slug 唯一（切块组的 #2 序号后缀避免撞名）
+  const slugs = mods.map((m) => m.slug);
+  assert.equal(new Set(slugs).size, slugs.length, "slug 无重复");
+});
+
+test("父链按目录包含取最近祖先（spec frontmatter.parents / DB parent_id 同源）", () => {
+  const { files, graph: g } = graph([
+    { from: "src/store/index.js", to: "src/store/util.js" },
+    { from: "src/wiki/t0.js", to: "src/store/index.js" },
+  ]);
+  const mods = partitionModules({ files, graph: g, maxFilesPerPage: 40, repoName: "demo" });
+  // 初稿是两级目录段：src/store、src/wiki；「src」本身不是组 → 无父链也合法，
+  // 但 src/store 与 src/wiki 之间没有包含关系（同层），互不为父。
+  const store = mods.find((m) => m.dir === "src/store");
+  const wiki = mods.find((m) => m.dir === "src/wiki");
+  assert.ok(store && wiki);
+  assert.equal(store.parentSlug, null, "同级目录不是父子");
+});
+
+test("模块指纹随文件集/边集变化（DB 记账与过期检测的输入）", () => {
+  const a = partitionModules({ ...graph([{ from: "src/a.js", to: "src/b.js" }]), maxFilesPerPage: 40, repoName: "d" });
+  const b = partitionModules({
+    files: ["src/a.js", "src/b.js", "src/c.js"],
+    graph: { edges: [{ from: "src/a.js", to: "src/b.js" }], external: new Map() },
+    maxFilesPerPage: 40,
+    repoName: "d",
+  });
+  const fa = a.find((m) => m.slug === "src").fingerprint;
+  const fb = b.find((m) => m.slug === "src").fingerprint;
+  assert.notEqual(fa, fb, "文件集变了指纹必须变");
+});
+
+test("外部依赖按模块聚合（骨架页「外部依赖」一节的数据源）", () => {
+  const files = ["src/a.js", "src/b.js", "lib/c.js"];
+  const external = new Map([["left-pad", new Set(["src/a.js", "src/b.js"])]]);
+  const mods = partitionModules({ files, graph: { edges: [], external }, maxFilesPerPage: 40, repoName: "d" });
+  const src = mods.find((m) => m.dir === "src");
+  assert.deepEqual(src.externalDeps, [{ pkg: "left-pad", count: 2 }]);
+  const lib = mods.find((m) => m.dir === "lib");
+  assert.deepEqual(lib.externalDeps, []);
+});

package/test/wiki-plan.test.js

@@ -1,80 +1,80 @@
-// plan.yaml 校验的回归锁（spec §4 / §9；实现计划 P1）。
-// 锁三类回归：未知键必须整轮拒绝（拼错的键等于失效的控制，不能静默忽略）、
-// 类型错误逐条收集一次报完（人一次改完，不逐个试错）、无 plan.yaml 走默认启发式。
-import test from "node:test";
-import assert from "node:assert/strict";
-import { loadPlan, planFingerprint, PLAN_ALLOWED_KEYS, PlanInvalidError } from "../src/wiki/plan.js";
-
-test("无 plan.yaml / 空文件走默认启发式", () => {
-  const a = loadPlan(null);
-  assert.equal(a.plan.maxFilesPerPage, 40);
-  assert.deepEqual(a.plan.exclude, []);
-  assert.equal(a.plan.pages, null);
-  assert.deepEqual(a.plan.templates, {});
-  // 「没带 plan」也是可记账状态：指纹 = 空串 sha256
-  assert.equal(a.fingerprint, planFingerprint(""));
-  const b = loadPlan("   \n");
-  assert.equal(b.plan.maxFilesPerPage, 40);
-});
-
-test("未知键整轮拒绝，报出键名与允许列表（spec 降级表第一行）", () => {
-  assert.throws(
-    () => loadPlan("includes:\n  - src\n"),
-    (err) => {
-      assert.ok(err instanceof PlanInvalidError);
-      assert.ok(err.message.includes("includes"), "报错要点名拼错的键");
-      assert.ok(err.message.includes("include"), "有相近键时给改正提示");
-      assert.ok(err.message.includes("允许的顶层键"));
-      for (const k of PLAN_ALLOWED_KEYS) assert.ok(err.message.includes(k));
-      return true;
-    }
-  );
-});
-
-test("完全不相干的未知键不给误导性提示", () => {
-  assert.throws(
-    () => loadPlan("zzzzqqqq: 1\n"),
-    (err) => err.message.includes("zzzzqqqq")
-  );
-});
-
-test("类型错误逐条收集、一次报完（不 fail-fast）", () => {
-  try {
-    loadPlan("exclude: not-an-array\nmax_files_per_page: zero\npages:\n  - path: \"\"\n");
-    assert.fail("应该抛 PlanInvalidError");
-  } catch (err) {
-    assert.ok(err instanceof PlanInvalidError);
-    assert.ok(err.issues.length >= 3, `至少三条 issue，实际 ${err.issues.length}`);
-    assert.ok(err.issues.some((i) => i.includes("exclude")));
-    assert.ok(err.issues.some((i) => i.includes("max_files_per_page")));
-    assert.ok(err.issues.some((i) => i.includes("pages[0]")));
-  }
-});
-
-test("YAML 语法错误也走同一条拒绝路径", () => {
-  assert.throws(() => loadPlan("a: [1, 2\nb: }\n"), PlanInvalidError);
-});
-
-test("pages 白名单形状合法时被接受，模板/笔记被保留", () => {
-  const { plan } = loadPlan(
-    "pages:\n  - path: src\n    title: 源码主区\n    template: arch\n    notes: 关注导出面\n" +
-    "templates:\n  arch: |\n    自定义正文行\n"
-  );
-  assert.deepEqual(plan.pages, [{ path: "src", title: "源码主区", template: "arch", notes: "关注导出面" }]);
-  assert.equal(plan.templates.arch, "自定义正文行\n");
-});
-
-test("pages 重复 path / 未知页级键 / 非 mapping 都被点名", () => {
-  try {
-    loadPlan("pages:\n  - path: src\n  - path: src\n  - bogus: 1\n  - 42\n");
-    assert.fail("应该抛");
-  } catch (err) {
-    assert.ok(err.issues.some((i) => i.includes("重复")));
-    assert.ok(err.issues.some((i) => i.includes("bogus")));
-    assert.ok(err.issues.some((i) => i.includes("pages[3]")));
-  }
-});
-
-test("指纹随内容变化（plan.yaml 改了就要重划边界）", () => {
-  assert.notEqual(planFingerprint("a: 1\n"), planFingerprint("a: 2\n"));
-});
+// plan.yaml 校验的回归锁（spec §4 / §9；实现计划 P1）。
+// 锁三类回归：未知键必须整轮拒绝（拼错的键等于失效的控制，不能静默忽略）、
+// 类型错误逐条收集一次报完（人一次改完，不逐个试错）、无 plan.yaml 走默认启发式。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { loadPlan, planFingerprint, PLAN_ALLOWED_KEYS, PlanInvalidError } from "../src/wiki/plan.js";
+
+test("无 plan.yaml / 空文件走默认启发式", () => {
+  const a = loadPlan(null);
+  assert.equal(a.plan.maxFilesPerPage, 40);
+  assert.deepEqual(a.plan.exclude, []);
+  assert.equal(a.plan.pages, null);
+  assert.deepEqual(a.plan.templates, {});
+  // 「没带 plan」也是可记账状态：指纹 = 空串 sha256
+  assert.equal(a.fingerprint, planFingerprint(""));
+  const b = loadPlan("   \n");
+  assert.equal(b.plan.maxFilesPerPage, 40);
+});
+
+test("未知键整轮拒绝，报出键名与允许列表（spec 降级表第一行）", () => {
+  assert.throws(
+    () => loadPlan("includes:\n  - src\n"),
+    (err) => {
+      assert.ok(err instanceof PlanInvalidError);
+      assert.ok(err.message.includes("includes"), "报错要点名拼错的键");
+      assert.ok(err.message.includes("include"), "有相近键时给改正提示");
+      assert.ok(err.message.includes("允许的顶层键"));
+      for (const k of PLAN_ALLOWED_KEYS) assert.ok(err.message.includes(k));
+      return true;
+    }
+  );
+});
+
+test("完全不相干的未知键不给误导性提示", () => {
+  assert.throws(
+    () => loadPlan("zzzzqqqq: 1\n"),
+    (err) => err.message.includes("zzzzqqqq")
+  );
+});
+
+test("类型错误逐条收集、一次报完（不 fail-fast）", () => {
+  try {
+    loadPlan("exclude: not-an-array\nmax_files_per_page: zero\npages:\n  - path: \"\"\n");
+    assert.fail("应该抛 PlanInvalidError");
+  } catch (err) {
+    assert.ok(err instanceof PlanInvalidError);
+    assert.ok(err.issues.length >= 3, `至少三条 issue，实际 ${err.issues.length}`);
+    assert.ok(err.issues.some((i) => i.includes("exclude")));
+    assert.ok(err.issues.some((i) => i.includes("max_files_per_page")));
+    assert.ok(err.issues.some((i) => i.includes("pages[0]")));
+  }
+});
+
+test("YAML 语法错误也走同一条拒绝路径", () => {
+  assert.throws(() => loadPlan("a: [1, 2\nb: }\n"), PlanInvalidError);
+});
+
+test("pages 白名单形状合法时被接受，模板/笔记被保留", () => {
+  const { plan } = loadPlan(
+    "pages:\n  - path: src\n    title: 源码主区\n    template: arch\n    notes: 关注导出面\n" +
+    "templates:\n  arch: |\n    自定义正文行\n"
+  );
+  assert.deepEqual(plan.pages, [{ path: "src", title: "源码主区", template: "arch", notes: "关注导出面" }]);
+  assert.equal(plan.templates.arch, "自定义正文行\n");
+});
+
+test("pages 重复 path / 未知页级键 / 非 mapping 都被点名", () => {
+  try {
+    loadPlan("pages:\n  - path: src\n  - path: src\n  - bogus: 1\n  - 42\n");
+    assert.fail("应该抛");
+  } catch (err) {
+    assert.ok(err.issues.some((i) => i.includes("重复")));
+    assert.ok(err.issues.some((i) => i.includes("bogus")));
+    assert.ok(err.issues.some((i) => i.includes("pages[3]")));
+  }
+});
+
+test("指纹随内容变化（plan.yaml 改了就要重划边界）", () => {
+  assert.notEqual(planFingerprint("a: 1\n"), planFingerprint("a: 2\n"));
+});

package/test/wiki-provenance.test.js

@@ -0,0 +1,202 @@
+// ① 语义段溯源（verifiedBaseline / verifiedAt）的回归锁。
+//
+// 这一层要防的不是「少写一个字段」，而是两个具体的假象：
+// 1. **T1 晚于 T0 的误报**：claims 的行号是 T1 那一刻的代码树，全仓 git_baseline 是 T0 的。
+//    若拿全仓基线起算 diff，T1 之前就发生、claim 早已算进去的改动会被报成 touched
+//    ——面板上就是「明明没动过，却催你复核」。所以起点必须是每页自己的 verified_baseline。
+// 2. **T0 的确定性被污染**：verified 字段只由 T1 写。T0 一旦也写时间戳，
+//    「同状态两次 apply 逐字节相同」这条不变量就破了（测试 wiki-t0.test.js 里那条）。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { runChoroT0, gitHead } from "../src/wiki/t0.js";
+import { createStore } from "../src/store.js";
+import { createChoroQueries } from "../src/wiki/queries.js";
+import { createT1 } from "../src/wiki/t1.js";
+import {
+  FM_VERIFIED_AT,
+  FM_VERIFIED_BASELINE,
+  readFrontmatterKey,
+  setFrontmatterKeys,
+  T1_SECTION_START,
+} from "../src/wiki/render.js";
+
+const FIXED_NOW = () => "2026-11-05T12:00:00.000Z";
+
+function makeFixture() {
+  const root = mkdtempSync(join(tmpdir(), "choro-prov-"));
+  writeFileSync(join(root, "package.json"), JSON.stringify({ name: "provfix", scripts: { test: "node --test" } }, null, 2) + "\n", "utf8");
+  mkdirSync(join(root, "src"), { recursive: true });
+  writeFileSync(join(root, "src", "a.js"), 'import { b } from "./b.js";\nexport const a = () => b();\n', "utf8");
+  writeFileSync(join(root, "src", "b.js"), "export const b = () => 1;\n", "utf8");
+  execFileSync("git", ["init", "-b", "main"], { cwd: root, stdio: "pipe" });
+  commit(root, "init");
+  return root;
+}
+
+function commit(root, message) {
+  execFileSync("git", ["-c", "user.email=t@t", "-c", "user.name=t", "add", "-A"], { cwd: root, stdio: "pipe" });
+  execFileSync("git", ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "-m", message, "--no-gpg-sign"], { cwd: root, stdio: "pipe" });
+  return gitHead(root);
+}
+
+function rmTempBestEffort(dir) {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* 留给系统清理 */ }
+  }
+}
+
+const GOOD_OUTPUT = JSON.stringify({
+  architecture: "src 模块承载核心导出面，a.js 依赖 b.js。",
+  convention: "导出全部用 export const 函数式风格。",
+  techStack: "纯 ESM，无框架。",
+  setup: "npm test。",
+  claims: [{ statement: "a.js 从 b.js 导入 b", kind: "architecture", sourcePath: "src/a.js", startLine: 1, endLine: 1 }],
+});
+
+// --- frontmatter 读写（页面格式层，与 T0/T1 无关的纯函数）---------------------
+
+test("setFrontmatterKeys：无则追加、有则覆盖、空值删键、无 frontmatter 原样返回", () => {
+  const page = "---\nchoro: v1\nslug: src\n---\n\n# 标题\n";
+  const added = setFrontmatterKeys(page, [[FM_VERIFIED_BASELINE, "abc1234"], [FM_VERIFIED_AT, FIXED_NOW()]]);
+  assert.equal(readFrontmatterKey(added, FM_VERIFIED_BASELINE), "abc1234");
+  assert.equal(readFrontmatterKey(added, FM_VERIFIED_AT), FIXED_NOW());
+  assert.ok(added.indexOf("---") < added.indexOf("verifiedBaseline"), "落在 frontmatter 里，不是正文");
+
+  const overwritten = setFrontmatterKeys(added, [[FM_VERIFIED_BASELINE, "def5678"]]);
+  assert.equal(readFrontmatterKey(overwritten, FM_VERIFIED_BASELINE), "def5678");
+  assert.equal(overwritten.match(/^verifiedBaseline:/gm).length, 1, "覆盖而不是重复追加");
+
+  const removed = setFrontmatterKeys(added, [[FM_VERIFIED_BASELINE, null]]);
+  assert.equal(readFrontmatterKey(removed, FM_VERIFIED_BASELINE), null);
+  assert.equal(/^verifiedBaseline:/m.test(removed), false, "删键不留空行——「没记下」要查得出来");
+
+  // 人写的坏文件（没有 frontmatter）不许被凭空造一个块出来
+  assert.equal(setFrontmatterKeys("# 纯正文\n", [[FM_VERIFIED_BASELINE, "x"]]), "# 纯正文\n");
+  assert.equal(readFrontmatterKey("# 纯正文\n", FM_VERIFIED_BASELINE), null);
+});
+
+test("readFrontmatterKey：缩进列表项不算顶层键，带引号的值剥引号", () => {
+  const page = '---\nslug: src\nsourceFiles:\n  - verifiedBaseline: 假的\nverifiedBaseline: "a:b"\n---\n';
+  assert.equal(readFrontmatterKey(page, FM_VERIFIED_BASELINE), "a:b", "只认顶层键，列表里同名的行不误命中");
+});
+
+// --- T0 一个字节都不产出这两个键 ---------------------------------------------
+
+test("T0 骨架页不含 verified 键：确定性不变量不许被溯源污染", () => {
+  const root = makeFixture();
+  const store = createStore(":memory:");
+  try {
+    runChoroT0({ repoRoot: root, store, apply: true, now: FIXED_NOW });
+    const page = readFileSync(join(root, ".chorography", "modules", "src.md"), "utf8");
+    assert.equal(page.includes(FM_VERIFIED_BASELINE), false, "骨架页没有「哪次验证的」这回事");
+    assert.equal(page.includes(FM_VERIFIED_AT), false);
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});
+
+// --- T1 写下那一刻的 HEAD，且 claims 起点跟着它走 -----------------------------
+
+test("T1 富化写下 verifiedBaseline/verifiedAt，且等于那一刻的 HEAD", async () => {
+  const root = makeFixture();
+  const store = createStore(":memory:");
+  try {
+    runChoroT0({ repoRoot: root, store, apply: true, now: FIXED_NOW });
+    const head = commit(root, "t1 之前的一次提交");
+    const t1 = createT1({ store, runSession: async () => ({ ok: true, text: GOOD_OUTPUT }), now: FIXED_NOW });
+    const receipt = await t1.runT1({ repoRoot: root, moduleSlug: "src" });
+    assert.equal(receipt.enriched.length, 1);
+    assert.equal(receipt.enriched[0].verifiedBaseline, head, "回执里带得出来，人不用去翻文件");
+
+    const page = readFileSync(join(root, ".chorography", "modules", "src.md"), "utf8");
+    assert.equal(readFrontmatterKey(page, FM_VERIFIED_BASELINE), head);
+    assert.equal(readFrontmatterKey(page, FM_VERIFIED_AT), FIXED_NOW());
+    assert.ok(page.includes(T1_SECTION_START), "语义段照旧");
+
+    const row = store.db.prepare(
+      "SELECT p.verified_baseline, p.verified_at FROM choro_pages p JOIN choro_modules m ON p.module_id = m.id WHERE m.slug = 'src'"
+    ).get();
+    assert.equal(row.verified_baseline, head, "文件与库同源同写");
+    assert.equal(row.verified_at, FIXED_NOW());
+
+    const evidence = JSON.parse(readFileSync(join(root, ".chorography", "evidence", "src.json"), "utf8"));
+    assert.equal(evidence.verifiedBaseline, head, "evidence 旁证也带起点");
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});
+
+test("claimDrift：T1 晚于 T0 时，T1 之前的改动不误报 touched（这就是 per-page 基线的理由）", async () => {
+  const root = makeFixture();
+  const store = createStore(":memory:");
+  try {
+    runChoroT0({ repoRoot: root, store, apply: true, now: FIXED_NOW });
+    // T0 之后、T1 之前有人改了 a.js 第 1 行——claim 读的就是改完之后的这棵树。
+    writeFileSync(join(root, "src", "a.js"), 'export const a = () => 1;\n', "utf8");
+    commit(root, "T0 之后、T1 之前");
+    const t1 = createT1({ store, runSession: async () => ({ ok: true, text: GOOD_OUTPUT }), now: FIXED_NOW });
+    await t1.runT1({ repoRoot: root, moduleSlug: "src" });
+
+    const q = createChoroQueries({ store });
+    const repo = q.resolveRepo(undefined);
+    const drift = q.claimDrift(repo.id);
+    assert.equal(drift.totals.claims, 1);
+    assert.equal(drift.totals.atRiskClaims, 0, "拿全仓基线起算会在这里误报 touched（旧的 bug）");
+    assert.equal(drift.clean, true);
+    const pageDrift = drift.pages.find((p) => p.slug === "src");
+    assert.equal(pageDrift.verifiedBaseline, drift.head, "起点就是 HEAD");
+    assert.equal(pageDrift.baselineApprox, false);
+
+    // 真改了 claim 锚点所在行：这时必须报出来，别因为「起点是 HEAD」就永远说干净。
+    writeFileSync(join(root, "src", "a.js"), 'export const a = () => 2;\n', "utf8");
+    commit(root, "真的动了锚点");
+    const drift2 = q.claimDrift(repo.id);
+    assert.equal(drift2.clean, false);
+    assert.equal(drift2.totals.atRiskClaims, 1);
+    assert.equal(drift2.pages.find((p) => p.slug === "src").atRisk[0].reason, "touched");
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});
+
+test("claimDrift：老数据（没有逐页基线）退到全仓基线，并标明这是近似起点", () => {
+  const root = makeFixture();
+  const store = createStore(":memory:");
+  try {
+    runChoroT0({ repoRoot: root, store, apply: true, now: FIXED_NOW });
+    const q = createChoroQueries({ store });
+    const repo = q.resolveRepo(undefined);
+    // 本功能之前富化的页：库里有 claims、没有 verified_baseline（迁移加列后的老行）。
+    const page = store.choroPageBySlug(repo.id, "src");
+    store.saveChoroPageClaims(page.id, [
+      { statement: "a 依赖 b", kind: "architecture", sourcePath: "src/a.js", startLine: 2, endLine: 2, createdAt: FIXED_NOW() },
+    ]);
+    store.db.prepare("UPDATE choro_pages SET verified_baseline = NULL, verified_at = NULL WHERE id = ?").run(page.id);
+
+    const drift = q.claimDrift(repo.id);
+    const pageDrift = drift.pages.find((p) => p.slug === "src");
+    assert.equal(pageDrift.verifiedBaseline, null, "真话：这页没记过逐页基线");
+    assert.equal(pageDrift.baselineApprox, true, "退而求其次的起点要标出来");
+    assert.equal(pageDrift.baselineUnknown, false, "有了保底起点就不再是「判不了」");
+    assert.equal(pageDrift.diffBaseline, drift.baseline, "用的就是全仓基线");
+
+    // 全仓基线也缺（极老的行）→ 才轮到 baselineUnknown，一条都不判。
+    store.db.prepare("UPDATE choro_repos SET git_baseline = '' WHERE id = ?").run(repo.id);
+    const drift2 = q.claimDrift(repo.id);
+    assert.equal(drift2.pages.find((p) => p.slug === "src").baselineUnknown, true);
+    assert.equal(drift2.totals.atRiskClaims, 0, "判不了就是判不了，不冒充没事");
+  } finally {
+    store.close();
+    rmTempBestEffort(root);
+  }
+});