@modusensus/dsh-mneme 0.12.0 → 0.14.0-beta.1

package/lib/wiki/queries.js

@@ -9,6 +9,14 @@
 // 输入——面板与工具传进来的 slug 查不到模块行就返回 null，绝不用它拼路径。
 import { readFileSync, existsSync, realpathSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
+// 过期判定复用既有三件真源（t0 的 gitHead、plan 的指纹、render 的模板版本），
+// 面板侧不另造一套判据——两套判据迟早会对同一仓库给出两个答案。
+import { gitHead } from "./t0.js";
+import { loadPlanFromRepo } from "./plan.js";
+import { TEMPLATE_VERSION, T1_SECTION_START } from "./render.js";
+// claim 失效判定的纯函数（借 openwiki 的 Grounded Claims）：解析 diff + 逐条比对
+// 三列证据。放独立模块是因为它零 DB、零 IO（除 diffSince 那一次 git），可单测。
+import { diffSince, summarizeClaims } from "./claims.js";
 
 // 页正文去 frontmatter / CHORO 标记行后作为嵌入文本（P40：嵌页级全文）。
 function pageEmbedText(content) {
@@ -49,12 +57,131 @@ export function createChoroQueries({ store }) {
       `SELECT r.id, r.root_path, r.name, r.plan_fingerprint, r.git_baseline, r.updated_at,
               (SELECT COUNT(*) FROM choro_modules m WHERE m.repo_id = r.id) AS module_count,
               (SELECT COUNT(*) FROM choro_pages p JOIN choro_modules m2 ON p.module_id = m2.id
-                 WHERE m2.repo_id = r.id) AS page_count
+                 WHERE m2.repo_id = r.id) AS page_count,
+              (SELECT COUNT(*) FROM choro_claims c
+                 JOIN choro_pages p2 ON c.page_id = p2.id
+                 JOIN choro_modules m3 ON p2.module_id = m3.id
+                WHERE m3.repo_id = r.id) AS claim_count
          FROM choro_repos r ORDER BY r.id`
     ).all();
     return rows;
   }
 
+  /**
+   * 面板仓库列表（契约 §3.2）：在 listRepos 的行上补契约要求的字段。
+   *
+   * 为什么另开一个函数而不是改 listRepos 的返回形状：listRepos 的
+   * module_count / page_count 被工具层与查询层测试锁着（下划线命名），改名就是
+   * 破坏既有调用方；而契约要的是 modules / pages 这样的对外字段。两套名字并存
+   * 难看，但改名的连带面比难看贵得多——装饰层把它包一层，工具层照旧读原始行。
+   *
+   * 每个仓库都要 fork 一次 git 判过期：这是用户点开面板才走的路（不是每轮注入的
+   * 热路径），一次 rev-parse 几十毫秒在交互里不可感知。
+   */
+  /**
+   * 契约字段的仓库对象（stale 由调用方决定是否重算）。
+   *
+   * 注意区分两个入口：repoFacts 每次都会 fork git 判过期；repoFromRow 是纯行投影，
+   * 给「已经知道过期原因、手上有判定结果」的调用方用（例如自动重跑之后要紧着按
+   * 新基线说话，不能再拿旧行算一遍）。混用会得到自相矛盾的回执。
+   */
+  function repoFromRow(row) {
+    const rootPath = String(row.root_path ?? "");
+    return {
+      id: row.id,
+      name: row.name,
+      rootPath,
+      modules: Number(row.module_count ?? 0),
+      pages: Number(row.page_count ?? 0),
+      claims: Number(row.claim_count ?? 0),
+      // legacy = 这个仓库里有页面是用旧模板（或 M0 的 NULL）渲染的：重跑一次 T0 就
+      // 会把它们升级成当前模板，面板据此提示「建议重建」而不是让用户自己比对版本。
+      legacy: legacyPages(row.id) > 0,
+      // enrichedPages：已经富化过（页面里有 T1 语义段、库里有 claims）的页数。
+      // 自动刷新要看它：这类页重跑 T0 会退回骨架，所以那条路必须先问一句。
+      enrichedPages: enrichedPageCount(row.id),
+      lastRunAt: row.updated_at ?? null
+    };
+  }
+
+  /**
+   * 已富化的页数。判据取库里的 status（T1 成功后会写 enriched），而不是读盘找
+   * T1 标记——这是条给面板列表用的轻查询，几百页也不该逐文件 readFileSync。
+   * 两边可能短暂不一致（例如有人手改了 MD），但「要不要提醒」这种提示用途，
+   * 库里的账本就是最合适的真源；真正判断「会丢什么」的仍是 T0 的 collectT1Loss（读盘）。
+   */
+  function enrichedPageCount(repoId) {
+    const hit = db.prepare(
+      `SELECT COUNT(*) AS n FROM choro_pages p JOIN choro_modules m ON p.module_id = m.id
+        WHERE m.repo_id = ? AND p.status = 'enriched'`
+    ).get(repoId);
+    return Number(hit?.n ?? 0);
+  }
+
+  function legacyPages(repoId) {
+    const hit = db.prepare(
+      `SELECT COUNT(*) AS n FROM choro_pages p JOIN choro_modules m ON p.module_id = m.id
+        WHERE m.repo_id = ? AND (p.template_version IS NULL OR p.template_version <> ?)`
+    ).get(repoId, TEMPLATE_VERSION);
+    return Number(hit?.n ?? 0);
+  }
+
+  function repoFacts(row) {
+    const rootPath = String(row.root_path ?? "");
+    // git 优先：代码变了是更硬的「该重跑」信号，plan 变了才退而求其次——两者同时
+    // 成立时面板只说一句话，说「git」比说「plan」更贴近用户看到的现象（他刚改了码）。
+    const head = rootPath === "" ? null : gitHead(rootPath);
+    const baseline = String(row.git_baseline ?? "").trim();
+    let staleReason = null;
+    if (head && head !== baseline) {
+      staleReason = "git";
+    } else if (rootPath !== "") {
+      // 读不到 git（head 为 null）时不直接判「没过期」：plan.yaml 可能已经被改过，
+      // 那条判据不依赖 git，仍能给出答案。
+      let planFingerprintNow = null;
+      try { planFingerprintNow = loadPlanFromRepo(rootPath).fingerprint; } catch { planFingerprintNow = null; }
+      // plan.yaml 校验不过时 loadPlanFromRepo 会抛——那是「现在读不出结论」，不是
+      // 「过期了」，所以落 null 保持 stale=false，让重建按钮自己去报那条 YAML 错误。
+      if (planFingerprintNow && planFingerprintNow !== String(row.plan_fingerprint ?? "")) {
+        staleReason = "plan";
+      }
+    }
+    return {
+      ...repoFromRow(row),
+      stale: staleReason !== null,
+      staleReason
+    };
+  }
+
+  /** 单仓的原始 listRepos 行（自动重跑之后要拿推进过的基线，不能再用旧行）。 */
+  function listRepoRow(repoId) {
+    return listRepos().find((r) => Number(r.id) === Number(repoId)) ?? null;
+  }
+
+  /** 契约形状的仓库列表：listRepos 的原始行 → 对外字段。 */
+  function listRepoFacts() {
+    return listRepos().map((row) => repoFacts(row));
+  }
+
+  /** 仓库的契约字段（按 id/name，给 /choro/page 这类已知单仓的读路径用）。 */
+  function repoFactsById(repoId) {
+    const row = listRepoRow(repoId);
+    return row ? repoFacts(row) : null;
+  }
+
+  /**
+   * 按绝对路径找已登记仓库（面板「选目录 → 生成」必需）：T0 apply 落库时存的是
+   * realpath，所以这里也必须先 realpath 再比，否则 Windows 上盘符大小写/短名/符号
+   * 链接会让同一个目录被当成新仓库重复登记一次。
+   */
+  function repoByRoot(rootPath) {
+    const raw = String(rootPath ?? "").trim();
+    if (raw === "") return null;
+    let normalized;
+    try { normalized = realpathSync(resolve(raw)); } catch { return null; }
+    return db.prepare("SELECT * FROM choro_repos WHERE root_path = ?").get(normalized) ?? null;
+  }
+
   /** repo 解析：数字 id 或显示名（root_path 是本机私有路径，不作为对外键）。 */
   function resolveRepo(ref) {
     if (ref === undefined || ref === null || ref === "") {
@@ -82,6 +209,12 @@ export function createChoroQueries({ store }) {
       `SELECT from_slug, to_slug, weight FROM choro_edges WHERE repo_id = ?
         ORDER BY from_slug, to_slug`
     ).all(repoId);
+    // 纯加法补一个 camelCase 的 relPath：面板从地志页导入知识点要拼「根路径 + 页相对
+    // 路径」，而这里历史上直出 SQL 行的 snake_case（page_rel_path）。C 线按契约读的是
+    // mod.relPath，字段一缺就恒 undefined，用户选完模块点导入只会看到「请先选模块」。
+    // 原字段一律保留——src/tools.js 的 render 与 choro-command 都还在吃 file_count /
+    // page_status，改形状会波及它们；outline() 里的同名映射是这件事的正确写法。
+    for (const m of modules) m.relPath = m.page_rel_path ?? null;
     return { modules, edges };
   }
 
@@ -255,6 +388,152 @@ export function createChoroQueries({ store }) {
     };
   }
 
+  /**
+   * Claim 粒度的失效清单（借 openwiki 的 Grounded Claims）：把「仓库代码变过就整仓过期」
+   * 降成「这 2 页里的 5 条结论被改动碰过」。
+   *
+   * 为什么放读侧而不写成后台任务：判据是纯机械的（git diff 的 hunk 区间 × claims 的
+   * 三列证据），不需要模型，一次 diff 几十毫秒——面板打开时现算，永远比任何落库的
+   * 缓存新鲜。写路径一条不加，红线不动。
+   *
+   * **比对起点是每页自己的 verified_baseline，不是全仓 git_baseline。** claims 的行号
+   * 是那页被富化的那一刻记下的；全仓基线是 T0 的时点。若 T1 晚于 T0（常态），用全仓
+   * 基线起算就会把「T1 之前就发生、claim 早已算进去」的改动也算进 diff，误报 touched。
+   * 所以按 verified_baseline 分组、每组各跑一次 git diff（同一起点只跑一次）。
+   *
+   * 五种「说不清」要分开说，别混成一个空清单：
+   *   - repo 不存在                      → null（调用方 404）
+   *   - git 读不到 HEAD                  → 全仓 anchorStale + reason "git-unreadable"
+   *   - 某页基线认不出（浅克隆/force-push）→ 该页 anchorStale，**其余页照常判**
+   *   - 某页没记过验证基线（老数据/拿不到 HEAD）→ 该页 baselineUnknown，一条不判
+   *   - 起点 == HEAD                     → 那组真没变，clean
+   */
+  function claimDrift(repoId) {
+    const repo = db.prepare("SELECT id, root_path, name, git_baseline FROM choro_repos WHERE id = ?").get(repoId);
+    if (!repo) return null;
+    const rootPath = String(repo.root_path ?? "");
+    const rows = db.prepare(
+      `SELECT c.id, c.statement, c.kind, c.source_path, c.start_line, c.end_line,
+              m.slug AS page_slug, m.title AS page_title, p.rel_path
+         FROM choro_claims c
+         JOIN choro_pages p ON c.page_id = p.id
+         JOIN choro_modules m ON p.module_id = m.id
+        WHERE m.repo_id = ? ORDER BY m.slug, c.id`
+    ).all(repoId);
+    // 页面清单单算：hasT1 只能读盘（标记写在正文里，库里没有这一列）；验证基线在库里。
+    const pageRows = db.prepare(
+      `SELECT m.slug, m.title, p.rel_path, p.verified_baseline, p.verified_at
+         FROM choro_pages p
+         JOIN choro_modules m ON p.module_id = m.id WHERE m.repo_id = ? ORDER BY m.slug`
+    ).all(repoId);
+    const head = rootPath === "" ? null : gitHead(rootPath);
+    const baseline = String(repo.git_baseline ?? "").trim();
+    // 每组验证基线只跑一次 diff：富化往往成批完成，同一基线的页占多数。
+    const diffCache = new Map();
+    const diffFor = (verified) => {
+      if (head === null) return null;
+      const key = String(verified ?? "").trim();
+      if (key === "") return null; // 没记过起点 → 判不了，别拿别的页的起点凑
+      if (diffCache.has(key)) return diffCache.get(key);
+      let value = null;
+      if (key === head) value = { ok: true, files: new Map(), deleted: [] };
+      else {
+        const diff = diffSince(rootPath, key, head);
+        value = diff.ok ? diff : { ok: false, reason: diff.reason };
+      }
+      diffCache.set(key, value);
+      return value;
+    };
+    const pages = pageRows.map((p) => {
+      let hasT1 = false;
+      try {
+        hasT1 = readFileSync(join(rootPath, p.rel_path), "utf8").includes(T1_SECTION_START);
+      } catch { hasT1 = false; }
+      const verifiedBaseline = String(p.verified_baseline ?? "").trim() || null;
+      const verifiedAt = p.verified_at ?? null;
+      // 老数据（本功能之前富化的页）只有全仓基线可依。退到它是**保守**方向：它早于
+      // 那页被富化的时刻，diff 会把「T1 之前就发生」的改动也算进来，只会多报不会漏报。
+      // 记 baselineApprox 是为了面板能说清「这是退而求其次的起点」，不是当真的验证点。
+      //
+      // 但「验证过、却没记下基线」不是老数据，是**验证没留下凭据**（T1 那次富化写了
+      // verified_at 却没写 verified_baseline，比如中途失败）。这种情况退到全仓基线
+      // 就会把「富化之后才发生」的改动当成「富化之前就有的」而放过——方向是漏报，
+      // 与上面那条恰好相反。所以判成 baselineUnknown：不知道起点，就不装作知道。
+      const verifyWithoutBaseline = verifiedBaseline === null && verifiedAt !== null;
+      const effective = verifyWithoutBaseline ? null : (verifiedBaseline ?? (baseline || null));
+      const computed = diffFor(effective);
+      return {
+        slug: p.slug,
+        title: p.title,
+        hasT1,
+        verifiedBaseline,
+        verifiedAt,
+        diffBaseline: effective,
+        baselineApprox: !verifyWithoutBaseline && verifiedBaseline === null && effective !== null,
+        baselineUnknown: effective === null,
+        anchorStale: computed !== null && computed.ok === false,
+      };
+    });
+    const claims = rows.map((r) => ({
+      id: r.id,
+      statement: r.statement,
+      kind: r.kind,
+      sourcePath: r.source_path,
+      startLine: r.start_line,
+      endLine: r.end_line,
+      pageSlug: r.page_slug,
+      pageTitle: r.page_title,
+    }));
+    const base = {
+      repo: { id: repo.id, name: repo.name, rootPath, gitBaseline: baseline || null },
+      head: head ?? null,
+      baseline: baseline || null,
+    };
+    if (head === null) {
+      return { ...base, clean: false, anchorStale: true, reason: "git-unreadable", ...summarizeClaims(claims, null, { pages }) };
+    }
+    // 仓库级 anchorStale 保留原来的语义：**骨架**（T0 页的文件清单、模块划分）记下的
+    // 那次基线还认不认得出。它和逐页 claims 的起点是两件事，面板上也是两句话——
+    // 「骨架要重建」不等于「结论都过时」。两条都算，谁也不掩盖谁。
+    let repoStale = false;
+    let repoStaleReason = null;
+    if (baseline !== "" && baseline !== head) {
+      const repoDiff = diffSince(rootPath, baseline, head);
+      if (!repoDiff.ok) { repoStale = true; repoStaleReason = repoDiff.reason; }
+    }
+    const diffByPage = (slug) => {
+      const page = pages.find((p) => p.slug === slug);
+      if (!page) return null;
+      const computed = diffFor(page.diffBaseline);
+      return computed !== null && computed.ok ? { files: computed.files, deleted: computed.deleted } : null;
+    };
+    const summary = summarizeClaims(claims, null, { pages, diffByPage });
+    // clean 的判据：每条结论都真判过、且一条都没被碰到。
+    // 「有结论但起点认不出 / 没记过」不算 clean——那是不知道，不是没事（#607 的病根）；
+    // 一条结论都没有时也没有「没事」可说（那是「还没富化」，不是「全部干净」）。
+    // 仓库基线 == HEAD → 整仓一条提交都没发生，任何 claims 都不可能被碰过。这一条既短路
+    // 「逐页基线没记」的老数据（缺列不是判不了），也覆盖「刚跑完 T0、还没有 conclusion」
+    // 的情形：没变就是没变，不必等富化完才敢说。
+    // 不是这个情形时才逐页看：有哪页判不了就不说 clean，一条结论都没有也不说 clean
+    // （那是「还没富化」，不是「全部干净」——面板上这两句不一样）。
+    const repoAtHead = baseline !== "" && baseline === head;
+    const undecidable = summary.totals.baselineUnknownPages + summary.totals.anchorStalePages > 0;
+    // inconsistentPages 不参与 repoAtHead 的短路：它说的不是「起点认不出」，而是
+    // **页面有语义正文、库里却一条 claims 都没有**（上次 T1 没写完的残局）。这种页的
+    // 证据根本无法核对，与仓库有没有新提交无关；只要还有这种页，就不能说「全部干净」，
+    // 否则面板会把一次没落库的富化说成没事。
+    const clean = summary.totals.atRiskClaims === 0
+      && summary.totals.inconsistentPages === 0
+      && (repoAtHead || (summary.totals.claims > 0 && !undecidable && !repoStale));
+    return {
+      ...base,
+      clean,
+      anchorStale: repoStale,
+      reason: repoStale ? repoStaleReason : null,
+      ...summary,
+    };
+  }
+
   // --- chorography 向量（收尾档 P37–P39）---------------------------------
   // 惰性物化（P37）：只在 host 侧检索路径调用（embedder 由 index.js 注入）；
   // CLI 环境没有 embedder → 向量永不物化，检索退关键词。staleness 两维：
@@ -354,7 +633,8 @@ export function createChoroQueries({ store }) {
   }
 
   return {
-    listRepos, resolveRepo, moduleMap, readPage, search, repoByCwd, outline,
+    listRepos, listRepoFacts, repoFacts, repoFactsById, repoFromRow, listRepoRow, repoByRoot,
+    resolveRepo, moduleMap, readPage, search, repoByCwd, outline, claimDrift,
     embedPageVectors, searchSemantic, embedQueryText, semanticTopN,
   };
 }

package/lib/wiki/render.js

@@ -23,6 +23,80 @@ export const HUMAN_END = "<!-- CHORO:HUMAN:END -->";
 export const T1_SECTION_START = "<!-- CHORO:T1:START -->";
 export const T1_SECTION_END = "<!-- CHORO:T1:END -->";
 
+// 验证溯源的两个 frontmatter 键（issue #615 之后的 ①：语义段带上「对着哪次提交验证的」）。
+// 只有 T1 写它们，T0 渲染时一个字节都不产出——骨架页没有语义段，也就没有「哪次验证的」
+// 这回事；反过来说，T0 重建整页时这两个键随 T1 正文一起消失，与「T0 丢弃语义段」是
+// 同一件事，不新增语义。放在这里而不是 t1.js：frontmatter 的形状属于页面格式。
+export const FM_VERIFIED_BASELINE = "verifiedBaseline";
+export const FM_VERIFIED_AT = "verifiedAt";
+
+/** frontmatter 边界：首行 --- 与下一个 --- 的行号；不存在返回 null。 */
+function frontmatterBounds(lines) {
+  if (String(lines[0] ?? "").trim() !== "---") return null;
+  for (let i = 1; i < lines.length; i++) {
+    if (String(lines[i]).trim() === "---") return { open: 0, close: i };
+  }
+  return null;
+}
+
+/**
+ * 取 frontmatter 里某个顶层键的字符串值。
+ *
+ * 只认顶层键（`key: value`），缩进的列表项（`  - x`）不会误命中；值两侧的引号剥掉
+ * （yamlScalar 会给含特殊字符的值加引号，读回来要还原成原文）。
+ * 没有 frontmatter、键不存在、值为空 → 一律 null：调用方据此说「没记下」，
+ * 而不是把空串当成一个合法的提交号。
+ */
+export function readFrontmatterKey(pageText, key) {
+  const lines = String(pageText ?? "").split("\n");
+  const bounds = frontmatterBounds(lines);
+  if (!bounds) return null;
+  const re = new RegExp(`^${escapeRegExp(key)}\\s*:\\s*(.*)$`);
+  for (let i = bounds.open + 1; i < bounds.close; i++) {
+    const m = re.exec(lines[i]);
+    if (!m) continue;
+    let v = m[1].trim();
+    if (v.length >= 2 && v.startsWith('"') && v.endsWith('"')) {
+      try { v = JSON.parse(v); } catch { v = v.slice(1, -1); }
+    }
+    return v === "" ? null : v;
+  }
+  return null;
+}
+
+/**
+ * 就地设置 frontmatter 顶层键：有则覆盖、无则追加在收尾 --- 之前（按传入顺序）。
+ *
+ * value 为 null / undefined / 空串 = **删掉**这个键，不留 `key:` 空行——「这一页是哪次
+ * 提交验证的，T1 没记下来」本身要能在文件里查得出来，而不是显示成一片空白。
+ * 没有 frontmatter 的正文原样返回：绝不给人写的坏文件凭空造一个块。
+ *
+ * @param {string} pageText
+ * @param {Array<[string, string|null]>} entries
+ */
+export function setFrontmatterKeys(pageText, entries) {
+  const lines = String(pageText ?? "").split("\n");
+  const bounds = frontmatterBounds(lines);
+  if (!bounds) return String(pageText ?? "");
+  const pending = new Map(entries.map(([k, v]) => [k, v === undefined || v === null || String(v).trim() === "" ? null : String(v)]));
+  const out = lines.slice(0, bounds.open + 1);
+  for (let i = bounds.open + 1; i < bounds.close; i++) {
+    const m = /^([A-Za-z_][\w-]*)\s*:/.exec(lines[i]);
+    if (m && pending.has(m[1])) {
+      const v = pending.get(m[1]);
+      pending.delete(m[1]);
+      if (v !== null) out.push(`${m[1]}: ${v}`);
+      continue;
+    }
+    out.push(lines[i]);
+  }
+  for (const [k, v] of pending) {
+    if (v !== null) out.push(`${k}: ${v}`);
+  }
+  out.push(...lines.slice(bounds.close));
+  return out.join("\n");
+}
+
 /** 抽出全部保留区。返回 { blocks: string[]（含标记本身，原样）, count }。 */
 export function extractHumanBlocks(pageText) {
   if (typeof pageText !== "string") return { blocks: [], count: 0 };

package/lib/wiki/t0.js

@@ -39,9 +39,10 @@ export class ChoroRefusal extends Error {
  * @param {string} opts.repoRoot 仓库路径（内部 realpath）
  * @param {object|null} opts.store createStore 产物（apply 时必传；dry-run 可为 null）
  * @param {boolean} [opts.apply=false] false = dry-run（零写入）
+ * @param {boolean} [opts.guardT1Loss=false] 会丢掉已有语义段时整轮拒绝（自动刷新用）
  * @param {() => string} [opts.now] ISO 时刻（测试注入假时钟）
  */
-export function runChoroT0({ repoRoot, store = null, apply = false, now = () => new Date().toISOString() }) {
+export function runChoroT0({ repoRoot, store = null, apply = false, guardT1Loss = false, now = () => new Date().toISOString() }) {
   let rootPath;
   try {
     rootPath = realpathSync(resolve(repoRoot));
@@ -177,6 +178,36 @@ export function runChoroT0({ repoRoot, store = null, apply = false, now = () =>
       + "要留住语义段就别在这里重跑 T0；需要时再用 --t1 重新富化。"
     );
   }
+  if (t1Loss.unreadable.length > 0) {
+    warnings.push(
+      `${t1Loss.unreadable.length} 页读不出来`
+      + `（${t1Loss.unreadable.slice(0, 3).map((u) => u.relPath).join("、")}${t1Loss.unreadable.length > 3 ? " 等" : ""}），`
+      + "无法确认其中是否有 T1 语义段；自动刷新会因此拒绝，手动重建会按骨架重写这些页。"
+    );
+  }
+  // guardT1Loss（自动刷新专用）：读路径上「顺手」重跑 T0 会把用户花模型调用换来的
+  // 语义段和 claims 一起清掉——那不是顺手，那是在用户只点开一页的时候替他做了一次
+  // 破坏性写盘。手动重建不受此限：用户点了按钮，回执里的 warnings 会如实列出丢了什么。
+  //
+  // 拒绝而不是「跳过有语义段的那几页」：T0 的整仓 replaceChoroGraph 是一次事务，
+  // 只保几页会留下「页面有 T1 正文、库里 claims 已被清空」的半截状态，比整体不写更糟。
+  //
+  // 读不出来的页同样要拒绝：清点靠读盘，读失败就先不知道它有没有语义段。放行等于
+  // 赌它没有，赌输就是把它那份语义段和 claims 一起抹掉；拒绝只是这次不刷新。
+  if (guardT1Loss && (t1Loss.pages.length > 0 || t1Loss.unreadable.length > 0)) {
+    const names = t1Loss.pages.slice(0, 3).join("、");
+    const blockedBy = t1Loss.unreadable.length > 0
+      ? `另有 ${t1Loss.unreadable.length} 页读不出来（${t1Loss.unreadable.slice(0, 3).map((u) => u.relPath).join("、")}`
+        + `${t1Loss.unreadable.length > 3 ? " 等" : ""}），无法确认它们有没有语义段。`
+      : "";
+    throw new ChoroRefusal(
+      "would-drop-t1",
+      `这个仓库有 ${t1Loss.pages.length} 页已经富化过（${names}${t1Loss.pages.length > 3 ? " 等" : ""}）。`
+      + blockedBy
+      + "自动刷新会退回骨架、清空 claims，所以这次没有动："
+      + "要保留语义段就先别刷新，确实要重建骨架请在面板里手动点「重建骨架」（回执会列出丢了哪几页）。"
+    );
+  }
 
   if (!apply) {
     return {
@@ -196,7 +227,7 @@ export function runChoroT0({ repoRoot, store = null, apply = false, now = () =>
       skippedFiles: graph.skipped,
       unresolvedCount: unresolvedTotal,
       humanBlocksSeen: countExistingHumanBlocks(rootPath, pageTargets),
-      t1Loss: { pages: t1Loss.pages, orphanEvidence: t1Loss.orphanEvidence },
+      t1Loss: { pages: t1Loss.pages, unreadable: t1Loss.unreadable, orphanEvidence: t1Loss.orphanEvidence },
       wouldWrite: [...pageTargets.map((p) => ({ path: p.relPath, bytes: Buffer.byteLength(p.content, "utf8") })),
         { path: indexRelPath, bytes: Buffer.byteLength(indexContent, "utf8") },
         { path: `${CHORO_DIR}/state.json`, bytes: 0 }],
@@ -282,7 +313,7 @@ export function runChoroT0({ repoRoot, store = null, apply = false, now = () =>
     unresolvedCount: unresolvedTotal,
     humanBlocksPreserved,
     bytes,
-    t1Loss: { pages: t1Loss.pages, orphanEvidence: t1Loss.orphanEvidence },
+    t1Loss: { pages: t1Loss.pages, unreadable: t1Loss.unreadable, orphanEvidence: t1Loss.orphanEvidence },
     warnings,
     moduleSummary: modules.map((m) => ({
       slug: m.slug, title: m.title, fileCount: m.fileCount,
@@ -421,13 +452,19 @@ function existingHumanBlockCount(absPath) {
 // 引用者。两者都是「会失去什么」的清点，不构成阻止：丢弃是设计意图，静默才是 bug。
 function collectT1Loss(rootPath, pageTargets) {
   const pages = [];
+  const unreadable = [];
   for (const target of pageTargets) {
     const abs = join(rootPath, target.relPath);
     if (!existsSync(abs)) continue;
     try {
       if (readFileSync(abs, "utf8").includes(T1_SECTION_START)) pages.push(target.relPath);
-    } catch {
-      /* 读不了就当没有：清点不该让 T0 失败 */
+    } catch (err) {
+      // **读不了不等于没有**：权限、占用、编码错误都会走到这里，而「有没有 T1 语义段」
+      // 恰恰要靠读那一眼才知道。吞成「没有」的直接后果是 guard 放行，然后一整仓
+      // replaceChoroGraph 把读不到的页连同它可能有的语义段一起退回骨架、清空 claims。
+      // 清点本身不该让 T0 失败（下面 warnings 只如实记一笔），但**守卫**必须把它当成
+      // 「有会丢的东西、但我数不清」而拒绝——见 guardT1Loss 分支。
+      unreadable.push({ relPath: target.relPath, reason: String(err?.code ?? err?.message ?? err) });
     }
   }
   let orphanEvidence = 0;
@@ -437,7 +474,7 @@ function collectT1Loss(rootPath, pageTargets) {
   } catch {
     orphanEvidence = 0;
   }
-  return { pages, orphanEvidence };
+  return { pages, unreadable, orphanEvidence };
 }
 
 function countExistingHumanBlocks(rootPath, pageTargets) {