agentic-flow-kit 1.8.2 → 2.0.0

package/templates/engine/.agents/scripts/check-loop-sections/s01-pairing.mjs

@@ -0,0 +1,116 @@
+// check-loop-sections/s01-pairing.mjs — 1. 红线判低 + L3 状态（hard）＋ 同名配对/L3 确认三件（advisory）
+// （2026-10-10 收敛系列 4b 自 check-loop.mjs 原位切出；2026-10-21 门禁极小化第 1 批降档：
+//   配对完整性 ×4 与 L3 确认三件 ×3 由 blockers 降 WARN——「事后扫」移交 closeout skill 自查（第 2 批），
+//   红线判低与 L3 状态未确认保 hard：前者是判低逃逸的唯一机器面，后者是状态机主干。）
+// （基础设施由 kit 供给。）
+// （2026-10-28 减重第二刀：本段扫描面默认收窄为「本轮 diff 触及的 workflow 文档」；CHECK_LOOP_FULL=1 全量。）
+import {
+  fs, os, path, spawnSync, createHash, createRequire, fileURLToPath,
+  loadEnums, auditEnabled, loadKitPolicy, hasFreshVerifyLine, laneOfDoc, MARK_RE,
+  SCRIPT_DIR, GIT, REV_ARG, REV, ROOT, ENUMS, inSet, stOkDoc,
+  spawnGit, gitOut, linesOf, fmGet, WF, DOC_DIRS, blockers, warnings, kitPolicy, isTracked, docFiles,
+  addedDateOf, warnEvidenceExempt, VERIFY_GREEN_RE, verifyEvidenceTruth,
+  versionGreater, fmStatus, bindingSha256, readdirOrNull, isDirectoryOrNull,
+} from '../check-loop-kit.mjs';
+
+// 红线判低：非 high 勾了「→ 级别 / 级别至少 L2|L3」即 hard。L1 plan 即入口后，plan 正文同样扫描。
+function pushRedline(file, base, lvl) {
+  if (laneOfDoc(lvl) === 'high') return;
+  const redlineTouched = (linesOf(file) || [])
+    .some((l) => /^- \[x\]/.test(l) && /(\$\\rightarrow\$|→)\s*级别|级别至少\s*L[23]/.test(l));
+  if (redlineTouched) {
+    blockers.push(`- [红线判低] ${base} 级别为 ${lvl || '缺失'} 但触达红线已勾选（规则/契约或 schema/结构面）——协作道不受理 STOP 级改动：就高不就低，把「级别」升至 L2/L3 并补同名 spec`);
+  }
+}
+
+export function run() {
+// --- 1. 红线判低 + L3 状态（hard）＋ 同名配对/L3 确认三件（advisory，2026-10-21 第 1 批降档）---
+// L1 收成一份 plan（2026-10-10）：级别恰好为 L1 的 plan 自己就是入口，不要求同名 intent/incident。
+// 级别缺失或 L2/L3 仍要求入口。已写的 intent 不论级别都仍要求同名 plan。历史台账不迁移。
+for (const intent of docFiles('intents')) {
+  const base = path.basename(intent);
+  const st = fmGet(intent, '状态');
+  const lvl = fmGet(intent, '级别');
+  if (!stOkDoc(st)) {
+    const msg = `${base}（frontmatter 状态键当前值:『${st || '缺失'}』）`;
+    if (lvl === 'L3') blockers.push(`- [状态未确认] L3 intent 必须为 approved/done/superseded/cancelled:${msg}`);
+    else warnings.push(`- [WARN 状态未确认] intent 必须为 approved/done/superseded/cancelled:${msg}`);
+  }
+  if (lvl === 'L2' || lvl === 'L3') {
+    if (!fs.existsSync(path.join(ROOT, WF, 'specs', base))) {
+      warnings.push(`- [WARN 配对断裂] intent 缺 spec:${base}（应在 ${WF}/specs/ 下同名）`);
+    }
+  }
+  // 已有 intent 仍须同名 plan（含存量 L1）。L2/L3 另须 spec。
+  if (!fs.existsSync(path.join(ROOT, WF, 'plans', base))) {
+    warnings.push(`- [WARN 配对断裂] intent 缺 plan:${base}（应在 ${WF}/plans/ 下同名）`);
+  }
+  pushRedline(intent, base, lvl);
+}
+
+for (const spec of docFiles('specs')) {
+  const base = path.basename(spec);
+  const st = fmGet(spec, '状态');
+  const lvl = fmGet(spec, '级别');
+  const hasEntry = fs.existsSync(path.join(ROOT, WF, 'intents', base)) || fs.existsSync(path.join(ROOT, WF, 'incidents', base));
+  if (!hasEntry) warnings.push(`- [WARN 配对断裂] spec 缺 intent/incident:${base}（应在 ${WF}/intents/ 或 ${WF}/incidents/ 下同名）`);
+  if (!stOkDoc(st)) {
+    const msg = `${base}（frontmatter 状态键当前值:『${st || '缺失'}』）`;
+    if (lvl === 'L3') blockers.push(`- [状态未确认] L3 spec 必须为 approved/done/superseded/cancelled:${msg}`);
+    else warnings.push(`- [WARN 状态未确认] spec 必须为 approved/done/superseded/cancelled:${msg}`);
+  }
+  // L3 确认三件：确认结果/确认时间读 frontmatter；独立复核按正文行锚定（放弃件豁免 = 枚举单源 abandoned 集）
+  if (lvl === 'L3' && !inSet(st, ENUMS['doc.status.abandoned'])) {
+    if (fmGet(spec, '确认结果') !== 'approved') warnings.push(`- [WARN L3 确认缺失] ${base} 确认结果必须为 approved`);
+    if (!fmGet(spec, '确认时间')) warnings.push(`- [WARN L3 确认缺失] ${base} 必须记录确认时间`);
+    if (!(linesOf(spec) || []).some((l) => /^- 独立复核：[ \t]*[^<\s]/.test(l))) {
+      warnings.push(`- [WARN L3 复核缺失] ${base} 必须记录新会话独立复核结论`);
+    }
+  }
+  // 独立复核上下文标识（2026-10-11 C2，policy v12 reviewerSince advisory）：独立性声明须带可证伪基底——
+  // 复核行落「复核上下文：<会话/子代理 id>」，使「主智能体自查冒充」从遗漏升级为积极伪造。只扫有独立
+  // 复核行的 spec；锚前存量豁免不回填；缺键（v1–v11）→ 检查整体跳过。
+  if (kitPolicy.reviewerSince) {
+    const rvDate = fmGet(spec, '日期') || (/^\d{4}-\d{2}-\d{2}$/.test(base.slice(0, 10)) ? base.slice(0, 10) : '');
+    if (rvDate >= kitPolicy.reviewerSince) {
+      const rvLine = (linesOf(spec) || []).find((l) => /^- 独立复核：/.test(l));
+      if (rvLine && !/复核上下文：/.test(rvLine)) {
+        warnings.push(`- [WARN 复核上下文缺失] ${base} 独立复核行缺「复核上下文：<会话/子代理 id>」——独立性声明无可证伪基底（C2，reviewerSince ${kitPolicy.reviewerSince}）`);
+      }
+    }
+  }
+}
+
+for (const plan of docFiles('plans')) {
+  const base = path.basename(plan);
+  const st = fmGet(plan, '状态');
+  const lvl = fmGet(plan, '级别');
+  const hasEntry = fs.existsSync(path.join(ROOT, WF, 'intents', base)) || fs.existsSync(path.join(ROOT, WF, 'incidents', base));
+  // L1 plan 即入口。级别缺失仍要求入口（fail-closed）。
+  if (lvl !== 'L1' && !hasEntry) warnings.push(`- [WARN 配对断裂] plan 缺 intent/incident:${base}（应在 ${WF}/intents/ 或 ${WF}/incidents/ 下同名）`);
+  pushRedline(plan, base, lvl);
+  if (!stOkDoc(st)) {
+    const msg = `${base}（frontmatter 状态键当前值:『${st || '缺失'}』）`;
+    if (lvl === 'L3') blockers.push(`- [状态未确认] L3 plan 必须为 approved/done/superseded/cancelled:${msg}`);
+    else warnings.push(`- [WARN 状态未确认] plan 必须为 approved/done/superseded/cancelled:${msg}`);
+  }
+  // 链内状态一致性（2026-10-11 链内倒挂 WARN，评审 C1 收口——B1 arrival 链暴露的盲点：配对存在≠终态同批）：
+  // README 规则 5 / stages.md Test §5.4 要求关单时入口与同名 plan 同批翻转。intent 链双向入检；incident 链只检
+  // 「closed 而 plan 在途」孤儿向——「plan done 而 incident 停 fixed」为 2026-10 前存量固定形态
+  // （INDEX incidents fixed 计数 ≈50 件），不追溯，避免不可消除噪声（同 delegationSince 存量豁免纪律）。
+  const intentUp = path.join(ROOT, WF, 'intents', base);
+  if (fs.existsSync(intentUp)) {
+    const stu = fmGet(intentUp, '状态');
+    if (st === 'done' && ['draft', 'approved'].includes(stu)) {
+      warnings.push(`- [WARN 链内倒挂] ${base} plan 已 done 而入口 intent 仍 ${stu || '缺失'}——README 规则 5：勾验 intent 验收后 intent 与同名 plan 一并 done`);
+    }
+    if (stu === 'done' && ['draft', 'approved'].includes(st)) {
+      warnings.push(`- [WARN 链内倒挂] ${base} 入口 intent 已 done 而 plan 仍 ${st}——stages.md Test §5.4 不留 approved 孤儿：同名 plan 一并 done`);
+    }
+  }
+  const incidentUp = path.join(ROOT, WF, 'incidents', base);
+  if (fs.existsSync(incidentUp) && fmGet(incidentUp, '状态') === 'closed' && ['draft', 'approved'].includes(st)) {
+    warnings.push(`- [WARN 链内倒挂] ${base} incident 已 closed 而 plan 仍 ${st}——修复类关单同名 plan 一并 done（stages.md Test §5.4）`);
+  }
+}
+}

package/templates/engine/.agents/scripts/check-loop-sections/s03x-regr-evidence.mjs

@@ -0,0 +1,38 @@
+// check-loop-sections/s03x-regr-evidence.mjs — 3 扩展. incident 防复发验证证据门 [hard-block]（2026-10-09）---
+// （2026-10-10 收敛系列 4b 自 check-loop.mjs 原位切出，段体逐字未改；基础设施由 kit 供给。）
+import {
+  fs, os, path, spawnSync, createHash, createRequire, fileURLToPath,
+  loadEnums, auditEnabled, loadKitPolicy, hasFreshVerifyLine, laneOfDoc, MARK_RE,
+  SCRIPT_DIR, GIT, REV_ARG, REV, ROOT, ENUMS, inSet, stOkDoc,
+  spawnGit, gitOut, linesOf, fmGet, WF, DOC_DIRS, blockers, warnings, kitPolicy, isTracked, docFiles,
+  addedDateOf, warnEvidenceExempt, VERIFY_GREEN_RE, verifyEvidenceTruth,
+  versionGreater, fmStatus, bindingSha256, readdirOrNull, isDirectoryOrNull,
+} from '../check-loop-kit.mjs';
+
+export function run() {
+// --- 3 扩展. incident 防复发验证证据门 [hard-block]（2026-10-09）---
+// 模板行 38 强制项的机器面：「防复发验证必须落到自动化用例或回归清单条目，禁止只写已人工验证」。
+// fixed/closed 且建档日 ≥ incidentRegrSince 的 incident，正文无自动化用例 / 回归清单引用 → hard。
+// 判据 = 宽匹配正则（引擎 .test.mjs / 后端 xunit / 前端测试目录 / 回归清单 / 冒烟 / 测试命令）——
+// 门的是「落到可复跑的验证资产」，不是猜具体测试名；存量（< 锚）豁免。kitPolicy.incidentRegrSince
+// 缺键（v1-v5）→ 整体跳过。
+{
+  const anchor = kitPolicy.incidentRegrSince;
+  if (anchor) {
+    // 回归清单引用含分片路径（2026-10-28）：regression-checklist.md §6 分片制下防复发条目落
+    // workflow/regression-checklist.d/<YYYY-MM>.md（append-only 追加区），主台账读侧自动合并——
+    // 门禁正则须同认分片，否则只引分片的 incident 被误判「未落回归清单」（2026-10-27-aggrid-hover-popconfirm 实证）
+    const REGR_EVIDENCE_RE = /\.test\.mjs|backend\/[^\s]*[Tt]ests?[\/.]|\w+Tests\.cs|frontend\/[^\s]*(?:__tests__|tests?)\/|workflow\/regression-checklist\.md|workflow\/regression-checklist\.d\/|regression-smoke|npm\s+test|dotnet\s+test|run-tests/;
+    for (const inc of docFiles('incidents')) {
+      const incSt = fmGet(inc, '状态');
+      if (!['fixed', 'closed'].includes(incSt)) continue;
+      const add = addedDateOf(inc);
+      if (!add || add < anchor) continue; // 存量豁免（不可判定亦不拦——无判定依据不出 hard）
+      const lines = linesOf(inc) || [];
+      if (!lines.some((l) => REGR_EVIDENCE_RE.test(l))) {
+        blockers.push(`- [回归证据缺失] ${path.basename(inc)} 已 ${incSt} 但防复发验证未落自动化用例/回归清单引用（模板强制项，禁「已人工验证」）`);
+      }
+    }
+  }
+}
+}

package/templates/engine/.agents/scripts/check-loop-sections/s08-acceptance.mjs

@@ -0,0 +1,130 @@
+// check-loop-sections/s08-acceptance.mjs — 8. intent 验收标准对账（done 须逐条勾验并补证据；新建 hard，存量聚合 warning）---
+// （2026-10-10 收敛系列 4b 自 check-loop.mjs 原位切出，段体逐字未改；基础设施由 kit 供给。）
+import {
+  fs, os, path, spawnSync, createHash, createRequire, fileURLToPath,
+  loadEnums, auditEnabled, loadKitPolicy, hasFreshVerifyLine, readVerifyLedgerText, laneOfDoc, MARK_RE,
+  SCRIPT_DIR, GIT, REV_ARG, REV, ROOT, ENUMS, inSet, stOkDoc,
+  spawnGit, gitOut, linesOf, fmGet, WF, DOC_DIRS, blockers, warnings, kitPolicy, isTracked, docFiles,
+  addedDateOf, warnEvidenceExempt, VERIFY_GREEN_RE, verifyEvidenceTruth,
+  versionGreater, fmStatus, bindingSha256, readdirOrNull, isDirectoryOrNull,
+} from '../check-loop-kit.mjs';
+
+export function run() {
+// --- 8. intent 验收标准对账（done 须逐条勾验并补证据；新建 hard，存量聚合 warning）---
+// 生效日锚 2026-09-28 改「git 首次加入日期」（此前取文件名前 10 字符——命名规范强制的字段、
+// 写早零成本，见 incidents/2026-09-28-check8-git-anchor）。非 git → 不可判定 → 走存量口径（不误报 hard）。
+{
+  const accCutoff = '2026-09-12';
+  let legacyUnaccounted = 0;
+  // 测试绿凭证状态（verify-evidence）：台账读一次循环外缓存；policy 缺 verifySince
+  //（v1-v4）→ ctxBase null → 对账整体跳过（向后兼容）
+  const verifySinceOf = kitPolicy.verifySince;
+  // 读口在 kit：--rev 且树上没有凭证文件时回退主工作区，其余路径只读 ROOT。
+  const verifyFresh = (() => {
+    try {
+      const text = readVerifyLedgerText();
+      return text != null ? hasFreshVerifyLine(text.split(/\r?\n/)) : false;
+    } catch { return false; }
+  })();
+  const acceptanceDocs = docFiles('intents').filter((intent) => fmGet(intent, '状态') === 'done');
+  // L1 plan 即入口：没有同名 intent 的 done L1 plan 自己对账验收。有 intent 的仍只查 intent。
+  for (const plan of docFiles('plans')) {
+    if (fmGet(plan, '状态') !== 'done' || fmGet(plan, '级别') !== 'L1') continue;
+    const baseName = path.basename(plan);
+    if (fs.existsSync(path.join(ROOT, WF, 'intents', baseName))) continue;
+    if (fs.existsSync(path.join(ROOT, WF, 'incidents', baseName))) continue;
+    acceptanceDocs.push(plan);
+  }
+  for (const intent of acceptanceDocs) {
+    const base = path.basename(intent);
+    const lines = linesOf(intent) || [];
+    // 节扫描：hs=有验收节；insec 至下一个二级标题；uc=未勾项；ne=勾选缺证据；ex=存量豁免声明
+    //   证据可写在 [x] 行的续行（仓库通写法「（证据：…）」另起一行）——pendX 记「待证据项」，
+    //   遇证据行（全角「：」/半角「:」皆认）清零；遇下一条目 / 下一小节 / 节末仍无证据 → ne
+    let hs = false, uc = false, ne = false;
+    let insec = false, ex = false;
+    let pendX = false; // 上一 [x] 项尚无证据，证据可能在紧随的续行
+    let currentEvidence = ''; // 当前条目的证据内容，用于语义校验
+    const evidenceItems = []; // 逐条证据（2026-10-06-v114-backflow-batch：两遍裁决——先文档级判实现证据在场，再逐条落判）
+    const evRe = /证据[：:]/;
+    const closeItem = () => { 
+      if (pendX) { 
+        ne = true; 
+        pendX = false; 
+      } 
+      if (currentEvidence && !ex) {
+        evidenceItems.push(currentEvidence);
+      }
+      currentEvidence = '';
+    };
+    for (const line of lines) {
+      if (/存量对账豁免（/.test(line)) ex = true;
+      if (/^\s*##\s+[^#]*验收标准/.test(line)) { hs = true; insec = true; closeItem(); continue; }
+      if (insec && /^\s*##\s/.test(line)) { insec = false; closeItem(); continue; }
+      if (!insec) continue;
+      if (/^\s*- \[ \]/.test(line)) { closeItem(); uc = true; continue; }
+      if (/^\s*- \[x\]/.test(line)) { 
+        closeItem(); 
+        pendX = !evRe.test(line); 
+        if (evRe.test(line)) currentEvidence = line.split(/证据[：:]/)[1].trim();
+        continue; 
+      }
+      if (pendX && evRe.test(line)) { 
+        pendX = false; 
+        currentEvidence = line.split(/证据[：:]/)[1].trim();
+      } else if (currentEvidence && line.trim() && !/^\s*- /.test(line)) {
+        // 简单累加续行证据
+        currentEvidence += ' ' + line.trim();
+      }
+    }
+    closeItem(); // 节末（或全文末）仍无证据 → 计缺证据
+    // 两遍裁决（2026-10-06-v114-backflow-batch 记录型提交豁免）：文档级先判「存在可过检实现证据」
+    // （sha / process 型任一），记录型提交（subject=docs 系）证据仅在实现证据在场时降级豁免告警——
+    // 冒烟报告 / approved 留痕 / 关单提交不改 plan 声明面属预期；仅引记录型而无实现证据 → 维持 hard-block
+    //（豁免通道不得独立成立，防「只引 docs 提交洗白代码改动」）。
+    if (evidenceItems.length) {
+      const planBase = base.replace(/.md$/, '');
+      // verify 对账 ctx：intent 首次加入 git ≥ verifySince（v5 锚）才参与；不可判定 → null 走 text 豁免
+      const iadd = addedDateOf(intent);
+      const vctx = typeof verifySinceOf === 'string' && iadd !== '' && iadd >= verifySinceOf
+        ? { verifyRelevant: true, hasFresh: verifyFresh } : null;
+      const results = evidenceItems.map((ev) => ({ t: verifyEvidenceTruth(ev, planBase, ROOT, vctx) }));
+      const hasImplEvidence = results.some((r) => r.t.ok && (r.t.type === 'sha' || r.t.type === 'process'));
+      for (const r of results) {
+        if (r.t.ok && r.t.type === 'verify-missing') {
+          warnings.push(`- [WARN 测试绿缺凭证] ${base} 验收证据声明「测试绿」但 24h 内无 verify 凭证（verifications.jsonl）——跑 node .agents/scripts/verify.mjs 后重跑（advisory，灰度第一档）`);
+          continue;
+        }
+        if (r.t.ok) continue;
+        if (r.t.type === 'irrelevant' && r.t.recordCommit && hasImplEvidence) {
+          warnEvidenceExempt('record', planBase);
+          continue;
+        }
+        blockers.push(`- [证据${r.t.type === 'forged' ? '伪造' : '无关'}] ${base} 验收证据校验失败: ${r.t.msg}`);
+      }
+    }
+    // 生效日锚 = git 首次加入日期（2026-09-28 改；此前取文件名前 10 字符）。**准确收益**：关掉
+    // 「改文件名日期（日常必写、零成本）即整段跳过 hard 门」这条通道；锚取 author date(%aI)，
+    // 刻意伪造（`git commit --date=`）仍可绕过——与伪造台账同属本地信任边界内，不宣称"通道已关闭"。
+    // 非 git / 查不到 → '' → isNew=false → 走存量口径（与既有语义一致：不可判定时不误报 hard）。
+    const adddate = addedDateOf(intent);
+    const isNew = adddate !== '' && adddate >= accCutoff;
+    const docWord = path.basename(path.dirname(intent)) === 'plans' ? 'plan' : 'intent';
+    if (!hs) {
+      if (isNew) blockers.push(`- [验收未对账] done ${docWord} 缺「## 验收标准」节(勾验无从核对):${base}`);
+      else if (!ex) legacyUnaccounted++;
+      continue;
+    }
+    if (!uc && !ne) continue;
+      if (isNew) {
+        if (uc) blockers.push(`- [验收未对账] done ${docWord} 验收标准有未勾验项:${base}（逐条勾验并补证据：commit/用例/冒烟输出）`);
+        if (ne) blockers.push(`- [验收缺证据] ${base} 验收标准勾选项缺「证据：」标注——证据是闭环准确性的唯一机器事实`);
+      } else if (!ex) {
+        legacyUnaccounted++;
+      }
+  }
+  if (legacyUnaccounted > 0) {
+    warnings.push(`- [WARN 验收对账存量] ${legacyUnaccounted} 个存量 done intent 验收标准未对账（生效日锚之前加入仓库，豁免 hard，不回填）`);
+  }
+}
+}

package/templates/engine/.agents/scripts/check-loop-sections/s15-fingerprint.mjs

@@ -0,0 +1,152 @@
+// check-loop-sections/s15-fingerprint.mjs — 15. 确认指纹对账 [hard-block]（confirm-gate-machine；2026
+// （2026-10-10 收敛系列 4b 自 check-loop.mjs 原位切出，段体逐字未改；基础设施由 kit 供给。）
+// （2026-10-28 减重第二刀：本段扫描面默认收窄为「本轮 diff 触及的 workflow 文档」；CHECK_LOOP_FULL=1 全量。）
+import {
+  fs, os, path, spawnSync, createHash, createRequire, fileURLToPath,
+  loadEnums, auditEnabled, loadKitPolicy, hasFreshVerifyLine, laneOfDoc, MARK_RE,
+  SCRIPT_DIR, GIT, REV_ARG, REV, ROOT, ENUMS, inSet, stOkDoc,
+  spawnGit, gitOut, linesOf, fmGet, WF, DOC_DIRS, blockers, warnings, kitPolicy, isTracked, docFiles,
+  addedDateOf, warnEvidenceExempt, VERIFY_GREEN_RE, verifyEvidenceTruth,
+  versionGreater, fmStatus, bindingSha256, readdirOrNull, isDirectoryOrNull,
+  commitmentFingerprint,
+} from '../check-loop-kit.mjs';
+
+import { loadAllConfirmations } from '../ledger-loader.mjs';
+
+export function run() {
+// --- 15. 确认指纹对账 [hard-block]（confirm-gate-machine；confirm-gate-delegated 两形态；
+//     生效日锚 2026-09-28 改台账 ts——此前锚取自文档自报「日期/发现」，新档只要把日期写早即整段跳过判定，
+//     incident 2026-09-28-confirm-gate-effective-date-anchor 实证）---
+// 确认两形态（confirm-doc.mjs）：TTY 亲手键入「可以」/ --delegated 对话委托代录（用户对话内明确放行后
+// AI 代录，台账行如实记 source=chat-delegated + quote 原话，永不伪装 TTY）。intents/specs/plans 凡
+// approved/done 须有 confirm-doc 产生的 frontmatter 确认指纹 + 台账（.agents/confirmations.jsonl）
+// 配对行——配对判据 doc/stage/fingerprint 三键，与 source 无关。
+// **生效日锚 = 台账 ts（2026-09-28 起）**：受管准入 = 该 doc 在台账中有合法跳转行（stage ∈ approved/done/
+// fixed/closed/superseded/cancelled，append-only 取末次）；无台账行 = 存量豁免（不追溯）。自报日期
+// （日期/发现/文件名）不再参与门禁判定——它可被作者手填，把「门是否生效」的决定权交给被约束对象本身
+// 是自举漏洞；台账行是「确认确实发生过」的唯一机器事实。docs 与 incidents 共用同一锚（原 incidents
+// 独立生效日 2026-09-28 常量退役：台账起算日 = docs 生效日，两档等价）。
+// 台账坏行容忍跳过（审计件，jsonl 追加式）；frontmatter 存 16 位、台账存 64 位，按前 16 位配对。
+{
+  const EFFECTIVE = kitPolicy.confirmDocsEffective;
+  const ledger = loadAllConfirmations(ROOT);
+  // incidents 侧覆盖（gate-coverage）：fixed/closed 为已确认态（open = 起草态不加门——
+  // maintain.md 创建即对话确认的既有口径）
+  // 放弃态覆盖（closing-coverage）：superseded/cancelled 入配对集——confirm-doc --to 是唯一
+  // 合法产生通道（cancelled 自 draft/approved/open/fixed；superseded 自 approved/done/fixed/closed），
+  // 此前手改 frontmatter 即出账的口子收死
+  const CONFIRMED_BY_SUB = {
+    intents: ['approved', 'done', 'superseded', 'cancelled'],
+    specs: ['approved', 'done', 'superseded', 'cancelled'],
+    plans: ['approved', 'done', 'superseded', 'cancelled'],
+    incidents: ['fixed', 'closed', 'superseded', 'cancelled'],
+  };
+  // 合法跳转 stage 集（台账行「确认确实发生过」的判据；revert-draft / revert-open 类回退注记行不算）
+  const VALID_STAGES = new Set(['approved', 'done', 'fixed', 'closed', 'superseded', 'cancelled']);
+  for (const [sub, confirmedSet] of Object.entries(CONFIRMED_BY_SUB)) {
+    for (const doc of docFiles(sub)) {
+      const st = fmGet(doc, '状态');
+      if (!confirmedSet.includes(st)) continue;
+      const base = path.basename(doc);
+      const rel = path.relative(ROOT, doc).split(path.sep).join('/');
+      // 受管准入 = 两条件取或（2026-09-28 改锚）：
+      //   ① 台账中有该 doc 的合法跳转行——「确认确实发生过」的机器事实；它独立于自报日期成立，
+      //      故堵死「确认过却把日期写早以逃掉对账」这条攻破路径（本 incident 的核心缺陷）；
+      //   ② 自报日期 ≥ 生效日——覆盖「新档完全没跑 confirm-doc」的漏网面（此类无台账行，
+      //      仅靠 ① 会被误判为存量豁免而静默放行）。
+      // 两条件皆不满足 = 存量豁免（生效日前既有、从未走确认门，不追溯）。
+      const docEntries = ledger.filter((e) => e && e.doc === rel && VALID_STAGES.has(e.stage));
+      const eff = sub === 'incidents' ? kitPolicy.confirmIncidentsEffective : EFFECTIVE;
+      let d = fmGet(doc, '日期') || fmGet(doc, '发现');
+      if (!d) d = /^\d{4}-\d{2}-\d{2}$/.test(base.slice(0, 10)) ? base.slice(0, 10) : '';
+      const dateManaged = /^\d{4}-\d{2}-\d{2}$/.test(d) && d >= eff;
+      if (!docEntries.length && !dateManaged) continue; // 存量豁免
+      const fp = fmGet(doc, '确认指纹');
+      const ok = !!fp && docEntries.some((e) => e.stage === st
+        && typeof e.fingerprint === 'string' && e.fingerprint.startsWith(fp));
+      if (!ok) {
+        blockers.push(`- [确认未对账] ${base} 状态 ${st} 无用户确认记录——AI 不得代确认，用户在终端跑 node .agents/scripts/confirm-doc.mjs ${rel} 后重试`);
+      }
+      // 内容绑定（audit-gate-hardening；生效锚 gate-hardening-p2-batch 自文档自报日期
+      // 改为台账 done 行 ts）：done 文档当前内容须与台账 done 行确认时的内容一致——按 prev 复原跳转前文本
+      // 重算比对，防「确认后篡改」（改验收标准/正文均触发）。复原口径 = confirm-doc computeFingerprint 的
+      // 逆推：CRLF 归一 → frontmatter 首个「状态:」行保分隔符换值为台账 prev（双空格等非规范分隔符不误伤，
+      // 与前向按原行字面计算对称）→ 剔「确认指纹:」行。两条降级路径：台账行缺 prev（schema 演进前存量，
+      // 无以复原）→ warning 不拦；entry.ts 早于 2026-09-28（UTC 字符串比较——该次确认在旧关单顺序时代完成）→
+      // 豁免绑定（配对判定已过，3 份失配存量即此列）。关单编辑顺序新约定不变：confirm-doc 是最后一次写入，
+      // 此后修订走 superseded 或新 intent。
+      if (ok && ['done', 'closed', 'superseded', 'cancelled'].includes(st)) {
+        const doneEntries = ledger.filter((e) => e && e.doc === rel && e.stage === st && typeof e.fingerprint === 'string');
+        const entry = doneEntries[doneEntries.length - 1]; // append-only 台账，末次生效（重确认场景）
+        if (!entry || !entry.prev) {
+          warnings.push(`- [WARN 绑定降级] ${base} 台账 stage=${st} 行缺 prev 字段（schema 演进前行），内容绑定跳过——仅配对判定`);
+        } else if (!(typeof entry.ts === 'string' && entry.ts >= kitPolicy.bindingTs)) {
+          // 该 done 确认发生在生效锚前（旧关单顺序时代）——豁免内容绑定，配对判定照常
+        } else if (bindingSha256(linesOf(doc) || [], entry.prev) !== entry.fingerprint) {
+          blockers.push(`- [确认内容漂移] ${base} ${st} 后内容与确认台账不符——已关单文档不得直接改（关单编辑先于关单确认）；确需修订走 superseded 或新 intent 引用`);
+        }
+      }
+      // 承诺面绑定（approved-content-binding 2026-10-27）：approved 档的承诺绑定。整篇逐字比对会误伤
+      // 关单期合法动作（勾验收 + 证据回填、确认结果/确认时间回填、复核行改锚），故 approved 档改绑
+      // 「承诺面」（判据文本 / 红线 / 目标 / 改动方案 / 约束与风险）：承诺在用户点头后被改写而未重新
+      // 点头 → hard-block（用户点头的不是现在这一份）。判据单源 = stage-gates.commitmentFingerprint，
+      // 与 confirm-doc 的「承诺面绑定门」（关单时刻）同口径。存量 approved 行无 commit 字段（本次
+      // 上线前确认）→ 静默跳过、不回溯（沿本段「batch 字段缺失静默跳过」同款处置）。
+      if (ok && st === 'approved') {
+        const apprWithCommit = ledger.filter((e) => e && e.doc === rel && e.stage === 'approved'
+          && typeof e.commit === 'string' && typeof e.fingerprint === 'string');
+        const byFp = fp ? apprWithCommit.filter((e) => e.fingerprint.startsWith(fp)) : [];
+        const pool = byFp.length ? byFp : apprWithCommit;
+        const lastAppr = pool[pool.length - 1];
+        if (lastAppr) {
+          const nowCommit = commitmentFingerprint(linesOf(doc) || []);
+          if (nowCommit !== lastAppr.commit) {
+            blockers.push(`- [承诺面漂移] ${base} approved 后承诺面被改写（${lastAppr.commit} → ${nowCommit}）——用户点头的不是现在这一份；请用户重新点头后跑 node .agents/scripts/confirm-doc.mjs ${rel} --reconfirm --delegated "<原话>" 重录承诺面指纹（仅勾验收/补证据/复核行改动不应触发本门——若触发请登记 papercut）`);
+          }
+        }
+      }
+    }
+  }
+  // 并录批次审计（batch-ledger-audit 改判据；原 confirm-gate-one-per-call 引入）：
+  // **读调用事实，不猜时间戳模式**。判据 = 台账行按 `batch` 分组，组内 `of > 1` → warning「确认并录」。
+  // batch/seq/of 由 confirm-doc 在**写入时**记录（那才是「本次调用落了几份」确定已知的时刻）；
+  // 旧判据「同 quote + 相邻 ts 差 < 2s」是拿两个间接信号反推该事实，已实证四类失效并**整段退役**：
+  //   ① 假阳性：合规逐件调用复用同句（用户两次都说「可以」）→ 必然误报；
+  //   ② 假阴性：并录时给每份换不同 quote → 零告警（判据的实际效果是引导伪装者改 quote）；
+  //   ③ 噪声不可消退：不按日期门豁免，退役前本仓 22 条 advisory 中 14 条为该告警，且文案自认「不可区分」；
+  //   ④ 字段职责冲突：`quote` 同时当「对质凭据」与「并录指纹」——现归还单一职责，只记用户原话。
+  // 无 `batch` 字段的历史行（schema 演进前，本仓全部 67 行均无该字段）→ **静默跳过**，不降级出账、不回溯：
+  // 按 audit-gate-hardening P3 教训（「扫了只产生不可消除的 advisory 噪声，真漏点被淹没」），无判定依据
+  // 的行不该产出告警。VALID_STAGES 复用外层声明（复核 P2-3 更正：此前本块内另有一份同名声明遮蔽外层）。
+  {
+    const byBatch = new Map(); // batch → 该批的台账行（仅计合法跳转 stage）
+    for (const e of ledger) {
+      if (!e || !VALID_STAGES.has(e.stage)) continue;
+      if (typeof e.batch !== 'string' || !e.batch) continue; // 历史行无 batch → 无判定依据，跳过
+      if (!byBatch.has(e.batch)) byBatch.set(e.batch, []);
+      byBatch.get(e.batch).push(e);
+    }
+    for (const [b, rows] of byBatch) {
+      // 判据取组内**任一行** of>1（复核 P2-3 更正：原取 rows[0].of 使结论依赖行序——同批首行 of=1、
+      // 次行 of=2 会漏报。confirm-doc 对同批所有行写同一个 of=docs.length，故正常批次组内一致；
+      // 改用 some 消除该顺序脆弱性，并对 craft 出来的不一致批次按「最大值」报，方向偏严不偏松）
+      if (!rows.some((r) => typeof r.of === 'number' && r.of > 1)) continue;
+      // of > 1 = 一次调用落多份态。delegated 形态下这正是「并录」（入口已拒多份，此处抓历史/绕行）；
+      // TTY 形态天然逐份过目（用户亲手键入），of>1 不构成违规——故只对 delegated 行报。
+      if (!rows.some((r) => r.source === 'chat-delegated')) continue;
+      // 协作道批量豁免（hybrid-governance-risk-lanes）：confirm-doc --batch 仅受理 L1
+      // （逐份读级别，L2/L3 逐份拒绝），台账行带 brief:true——全行带标记的批次是 sanctioned 泳道行为
+      // （异步审计兜底），不出「确认并录」；缺标记（旧版脚本/手造台账）照旧告警，判据偏严不偏松。
+      if (rows.every((r) => r.brief === true)) continue;
+      // 判据的主体是「多份**不同**文档并作一次」：同一文档重复落账（重确认链、手改台账把
+      // 多行写成同一 doc）不塌逐件确认门，按行数报会把它误报成并录。取 distinct doc 判定，
+      // 真并录（≥2 份不同文档）一条不漏。
+      const distinctDocs = [...new Set(rows.map((r) => String(r.doc)))];
+      if (distinctDocs.length < 2) continue;
+      const of = Math.max(...rows.map((r) => (typeof r.of === 'number' ? r.of : 0)));
+      const docs = distinctDocs.map((d) => d.replace(/^workflow\//, '')).join('、');
+      warnings.push(`- [WARN 确认并录] 单次调用落账 ${distinctDocs.length} 份不同文档（batch ${b}，of=${of}）：${docs}——同一次 --delegated 调用放行多份，塌掉「逐件确认」门（stages.md Build 章）；口径见 workflow/papercuts.d/2026-09.md 2026-09-22「并作一次」条`);
+    }
+  }
+}
+}

package/templates/engine/.agents/scripts/check-loop-sections/s23-convergence-audit.mjs

@@ -0,0 +1,182 @@
+// check-loop-sections/s23-convergence-audit.mjs — 23. 判据级收敛对账（2026-10-11；锚 convergenceSince / convergenceHardSince）
+// 背景（convergence-audit，参照 GitHub spec-kit converge 机理「完成声明不是证据」）：
+// spec 的验证承诺此前只落在叙述节（检查 21 对节内引用做存在性扫描），没有逐判据 × 逐证据的机器对账。
+// 本段把「验收判据」表（workflow/specs/_TEMPLATE.md 承重节）变成机器输入：L2/L3 done spec（锚后）逐行解析
+//   判据 → 证据。状态列自报「覆盖」而证据无效 → 仍判未覆盖。
+// 两档（convergence-hard）：
+//   advisory（有 convergenceSince、无 hard 键，或日期 < convergenceHardSince）：证据 = 存在的路径，或命令白名单声明。WARN。
+//   hard（日期 ≥ convergenceHardSince）：路径仍只认存在，不读正文、不判与判据是否相关（判断题留给新会话复核）；
+//     命令必须是 verify.mjs 全量门实际跑的那几个，且 workflow/verify-evidence.md 有不早于本 spec 日期的全绿行。
+//     答不了（空、路径不存在、命令不在全量门、没有对应全绿行）= 未覆盖，HARD-BLOCK。人工走查且证据为空仍合法。
+// 无「验收判据」节或表无数据行 → 两档都是 WARN「收敛无判据」。
+// 存量豁免：日期 < convergenceSince → 跳过。缺键（v1–v9）→ 整段跳过。缺 hard 键（v1–v10）→ 不升 hard。
+import {
+  fs, os, path, spawnSync, createHash, createRequire, fileURLToPath,
+  loadEnums, auditEnabled, loadKitPolicy, hasFreshVerifyLine, laneOfDoc, MARK_RE,
+  SCRIPT_DIR, GIT, REV_ARG, REV, ROOT, MAIN_ROOT, ENUMS, inSet, stOkDoc,
+  spawnGit, gitOut, linesOf, fmGet, WF, DOC_DIRS, blockers, warnings, kitPolicy, isTracked, docFiles,
+  addedDateOf, warnEvidenceExempt, VERIFY_GREEN_RE, verifyEvidenceTruth,
+  versionGreater, fmStatus, bindingSha256, readdirOrNull, isDirectoryOrNull,
+} from '../check-loop-kit.mjs';
+
+// 与 s21 命令面同源的声明白名单（advisory 档：文本命中即认）。hard 档不再凭命中放行。
+// 边界修复（2026-11-03）：词首加 (?<![\w.@\-\\/]) 负向断言——证据路径 `.agents/skills/verify-ui/features/*.md`
+// 中 `verify-ui` 为路径片段，无断言时被误判为命令引用 → hard 档走全量门白名单（verify-ui 不在）恒判
+// 证据无效（po-contract-required-tax-default 推送实证：4 条指向真实存在 UI 报告的人工判据全灭）。
+const CMD_RE = /(?<![\w.@\-\\/])(?:npm\s+(run\s+)?test|dotnet\s+test|run-tests|regression-smoke|verify\.mjs|check-scope|verify-ui|ui-verifier|vue-tsc|dotnet\s+build|npm\s+run\s+build)/;
+// 引用切分：长选项在前，避免 npm run build 被更短的模式截断。verify-ui 先于不会与 verify.mjs 重叠的独立词。
+const CITE_RE = /(?<![\w.@\-\\/])(?:npm\s+run\s+build|npm\s+(?:run\s+)?test|dotnet\s+build|dotnet\s+test|verify\.mjs|verify-ui|ui-verifier|regression-smoke|run-tests|check-scope|vue-tsc)/g;
+// verify.mjs 全绿行（suite=all-gates）实际覆盖的命令。不在此集的白名单命令没有对应绿记录。
+// vue-tsc（2026-10-21 verify-diet ④）：本地关单前端门 = npm run type-check（vue-tsc -b），
+// vite bundle 分离到 deploy/CI（TF_BUILD 下 frontend-build 门仍 npm run build）——两形态都是门实跑命令。
+// 方向注意（复核 P2）：npm run build 的绿记录只在 **CI 行**（runId 有值）；本地全绿行实跑 vue-tsc。
+// 按行环境严格对账挂 papercuts 2026-10-21（摘要行 runId 列已可辨 CI/本地）。
+// npm 面命令已随引擎测试面退役（2026-10-28，根 package.json scripts 已删）——白名单保留系**存量 spec
+// 兼容**：2026-10-18 前的 done spec 证据引 `npm run test:unit` 等（CITE_RE 前缀提取为 npm run test），
+// 移除会使存量档在 FULL 对账下判「收敛未覆盖」（2026-10-28 实证 po-concurrent-overorder-lost-update）。
+// 新 spec 勿再引用 npm 面命令；存量迁移（改证/解锁序）待 owner 裁决后另行清理。
+const GATE_CMD = new Set(['npm run build', 'npm test', 'npm run test', 'dotnet build', 'dotnet test', 'verify.mjs', 'vue-tsc']);
+// 扩展名交替**最长优先**（2026-10-20 修复：原 `mjs|js|ts|tsx|...|json` 中 js/ts 是 mjs/json/tsx 的
+// 前缀且交替无尾锚，`.json`/`.tsx` 路径被截断成 `.js`/`.ts` → existsSync 恒 false → 证据永不可验，
+// po-close-replace-mark-completed 关单实证）
+const PATH_EXT = 'tsx|mjs|json|html|sql|vue|cs|md|ts|js';
+// 路径体 = 原 ASCII 路径字符 + 字母（中文目录），单字符类，避免 (A|B)+ 在长说明上回溯。
+// 标点（如路径后的「（说明）」）不在类内，仍截断。
+const PATH_RE = new RegExp(`(?:^|[\\s\`'"（(])([\\w.@\\-\\\\/\\p{L}]+\\.(?:${PATH_EXT}))`, 'gu');
+const SEC_RE = /^##\s+.*验收判据/;
+// 与 gen-verify-evidence.mjs 数据行同形态：短 SHA | ISO 时间 | …。只取日期，不复述门数。
+const EVIDENCE_ROW_RE = /^\|\s*`[0-9a-f]{7,40}`\s*\|\s*([^|]+?)\s*\|/;
+
+// 关单树路径存在（2026-10-29 done-tree-evidence，papercut 待登记——handoff 2026-10-29 P0）：
+// 「关单后业务重构删证据」结构性失灵的堵口。原判据 `fs.existsSync(今天)` 单认当下——spec done 后
+// 测试文件被合法重构删除（实证 fafbc30f 删 OutboundPickTests，4 条 L3 done spec 全体 HARD-BLOCK），
+// 历史承诺被事后树态否决。补第二认：**该 spec 首次进入 done 态的提交树中路径存在**（历史树对账，
+// 与 ledger-invariant DAG 感知同哲学：关单时的承诺按关单时的树兑现判）。双认 = 今天存在 ∪ done 树存在。
+// done 树解析：spec 文件历史最早一个「正文含行首 `状态: done`」的提交（逐提交 cat-file 正文，
+// done spec 数少 + memo 缓存；非 git / 查不到 → null 不放行第二认，行为与旧判据等价不误放）。
+const doneTreeMemo = new Map(); // specAbsPath → sha|null
+function doneTreeShaOf(spec) {
+  if (doneTreeMemo.has(spec)) return doneTreeMemo.get(spec);
+  let sha = null;
+  try {
+    const rel = path.relative(ROOT, spec).split(path.sep).join('/');
+    const log = gitOut(['log', '--format=%H', '--follow', '--', rel]); // 旧→新
+    if (log) {
+      for (const line of log.split('\n').reverse()) {
+        const c = line.trim();
+        if (!c) continue;
+        const body = gitOut(['show', `${c}:${rel}`]);
+        if (body !== null && /^状态:\s*done\s*$/m.test(body.split(/\r?\n/).slice(0, 12).join('\n'))) { sha = c; break; }
+      }
+    }
+  } catch { /* 非 git / 异常 → null */ }
+  doneTreeMemo.set(spec, sha);
+  return sha;
+}
+const doneTreePathMemo = new Map(); // `${sha}\n${path}` → bool
+function doneTreeHasPath(spec, relPath) {
+  const sha = doneTreeShaOf(spec);
+  if (!sha) return false;
+  const key = `${sha}\n${relPath}`;
+  if (doneTreePathMemo.has(key)) return doneTreePathMemo.get(key);
+  let ok = false;
+  try { ok = spawnGit(['cat-file', '-e', `${sha}:${relPath}`]).status === 0; } catch { ok = false; }
+  doneTreePathMemo.set(key, ok);
+  return ok;
+}
+
+function greenEvidenceDates() {
+  const dates = [];
+  let text = '';
+  try { text = fs.readFileSync(path.join(ROOT, WF, 'verify-evidence.md'), 'utf8'); } catch { return dates; }
+  for (const raw of text.split(/\r?\n/)) {
+    const m = raw.trim().match(EVIDENCE_ROW_RE);
+    if (!m) continue;
+    const day = m[1].trim().slice(0, 10);
+    if (/^\d{4}-\d{2}-\d{2}$/.test(day)) dates.push(day);
+  }
+  return dates;
+}
+
+// 命令格：每一处引用都须落在全量门里，且有不早于 spec 日期的全绿行。解析不出引用 → 不放行。
+// 两侧日期同须 UTC 口径（台账渲染 UTC ts；spec「日期」fill-spec 默认 UTC，手写见 _TEMPLATE.md 验收判据注）：
+// 本地时区手写日期会在 UTC+8 0–8 点窗与全绿行错位一天——fail-closed，不误放。
+function commandCovered(ev, specDate, greenDates) {
+  const cites = ev.match(CITE_RE) || [];
+  if (!cites.length) return false;
+  const fresh = greenDates.some((g) => g >= specDate);
+  return cites.every((c) => GATE_CMD.has(c) && fresh);
+}
+
+export function run() {
+// --- 23. 判据级收敛对账（2026-10-11；锚 convergenceSince / convergenceHardSince）---
+{
+ const anchor = kitPolicy.convergenceSince;
+ const hardAnchor = kitPolicy.convergenceHardSince;
+ if (anchor) {
+ const greenDates = greenEvidenceDates();
+ const isPlaceholder = (s) => !s || /^<.*>$/.test(s);
+ for (const spec of docFiles('specs')) {
+ const st = fmGet(spec, '状态');
+ const lvl = fmGet(spec, '级别');
+ if (st !== 'done' || !['L2', 'L3'].includes(lvl)) continue;
+ // 生效日锚：frontmatter「日期」优先（fill-spec 必写），缺则 git 首加日 / 文件名前缀（同检查 12 退化序）
+ let d = fmGet(spec, '日期') || addedDateOf(spec);
+ if (!/^\d{4}-\d{2}-\d{2}$/.test(d)) d = /^\d{4}-\d{2}-\d{2}/.test(path.basename(spec)) ? path.basename(spec).slice(0, 10) : '';
+ if (!d || d < anchor) continue; // 锚前存量不回填
+ const hard = !!(hardAnchor && d >= hardAnchor);
+ const lines = linesOf(spec) || [];
+ const secLines = [];
+ let inSec = false;
+ for (const l of lines) {
+ if (SEC_RE.test(l)) { inSec = true; continue; }
+ if (inSec && /^##\s+/.test(l)) { inSec = false; continue; }
+ if (inSec) secLines.push(l);
+ }
+ // 解析表数据行（表头才是数据边界——沿用 agg-delegations splitTables 口径；分隔行/表头行/占位行跳过）
+ const rows = secLines
+ .filter((l) => /^\|.*\|\s*$/.test(l))
+ .filter((l) => !/^\|[\s:|-]+\|\s*$/.test(l))
+ .map((l) => l.split('|').slice(1, -1).map((c) => c.trim().replace(/^`|`$/g, '')))
+ .filter((cells) => cells.length >= 3)
+ .filter((cells) => !(/^判据/.test(cells[0]) && /^证据/.test(cells[1]))) // 表头行（「判据」「证据」带括号后缀的形态）
+ .filter((cells) => !isPlaceholder(cells[0])); // 模板占位行
+ const base = path.basename(spec);
+ if (!rows.length) {
+ warnings.push(`- [WARN 收敛无判据] ${base} 无「验收判据」表或表为空——L2/L3 done spec 须逐条登记可验判据（检查 23，模板 workflow/specs/_TEMPLATE.md）`);
+ continue;
+ }
+ const missed = [];
+ for (const [crit, ev, stat] of rows.map((c) => [c[0], c[1], (c[2] || '').trim()])) {
+ if (stat === '人工' && isPlaceholder(ev)) continue; // 人工走查判据：空证据合法
+ let ok = false;
+ if (!isPlaceholder(ev)) {
+ if (hard && CMD_RE.test(ev)) ok = commandCovered(ev, d, greenDates);
+ else if (CMD_RE.test(ev)) ok = true; // advisory：命令白名单认声明
+ else {
+ const cands = [];
+ for (const m of ev.matchAll(PATH_RE)) cands.push(m[1].replace(/\\/g, '/'));
+ // 双认（2026-10-29 done-tree-evidence）：今天存在 ∪ done 提交树存在——关单后删证据不再否决历史承诺
+ // 三认（2026-11-10 local-evidence-fallback）：`workflow/evidence/` 被 .gitignore 排除、按设计只存本机；
+ //   --rev/--range 把 ROOT 换成临时 worktree，证据文件天然不在那棵树上（2026-11-10 推送实证：
+ //   仅引证据文件的判据在 ranged 模式恒判未覆盖）。与 readVerifyLedgerText 同口径回退主工作区；
+ //   树上已有文件仍以树为准，非本机证据目录不回退（不让任意缺失路径蒙混过关）。
+ const LOCAL_EVIDENCE_PREFIX = 'workflow/evidence/';
+ const localEvidenceInMain = (p) => !!MAIN_ROOT
+   && path.resolve(MAIN_ROOT) !== path.resolve(ROOT)
+   && p.startsWith(LOCAL_EVIDENCE_PREFIX)
+   && fs.existsSync(path.join(MAIN_ROOT, p));
+ ok = cands.some((p) => fs.existsSync(path.join(ROOT, p)) || doneTreeHasPath(spec, p) || localEvidenceInMain(p));
+ }
+ }
+ if (!ok) missed.push(`${crit}→${ev || '（空）'}`);
+ }
+ if (missed.length) {
+ const detail = `${base} ${rows.length} 条判据中 ${missed.length} 条证据无效（${missed.join('; ')}）`;
+ if (hard) blockers.push(`- [收敛未覆盖] ${detail}——状态列自报不作数；命令须是全量门（dotnet test / dotnet build / npm run build / verify.mjs；npm 面命令仅存量 spec 兼容）且 workflow/verify-evidence.md 有不早于本 spec 日期的全绿行；路径只认存在（检查 23，含 .vue 与中文目录）。若本 spec 已标 done：先标后补会与本门互为前提（verify 门序含 check-loop）——解锁序：改正文 → 状态改回 approved（勿改 draft，L3 必须 approved/done）→ confirm-doc 重录指纹 → 再标 done。中间态不要提交`);
+ else warnings.push(`- [WARN 收敛未覆盖] ${detail}——状态列自报不作数，证据须存在或为验证命令（检查 23）`);
+ }
+ }
+ }
+}
+}