agentic-flow-kit 0.8.0 → 0.9.1

package/templates/_agents/scripts/check-loop.mjs

@@ -13,7 +13,9 @@
 // 违例输出到 stderr 并 exit 1；只剩警告时 exit 0。
 //
 // 检查项清单（编号/标题/severity 逐条沿 sh 版头部——gate-checklist 配对登记表按 id 消费，不得增删改号）:
-//   1. 入口文档/spec/plan 同名配对(L1 必须有 plan;L2/L3 必须有 spec+plan)        [hard-block]
+//   1. 入口文档/spec/plan 同名配对(L1 必须有 plan;L2/L3 必须有 spec+plan;L0 协作道豁免 plan;
+//      L0/L1 勾触达红线 → 「红线判低」hard——协作道不受理 STOP 级改动,就高不就低,
+//      2026-09-30 hybrid-governance-risk-lanes)                                        [hard-block]
 //   2. 模板字段占位符残留(YYYY-MM-DD / <主题> 等未替换;<主题> 与 .md 同行 = 命名约定描述,豁免)  [warning]
 //   3. incidents 复盘三件套完整性 + 状态严格枚举 + 新 intent 回路(回路断档=hard,其他=warning)
 //   4. 引用有效性(文档/指令中引用的 .agents/ 路径必须存在;支持 fill-{a,b,c}.mjs 花括号展开与 fill-*.mjs 通配;
@@ -65,6 +67,12 @@
 //      等于引导伪装)/噪声不可消退(不按日期门豁免,退役前本仓 22 条 advisory 中 14 条为该告警)/
 //      quote 字段职责冲突(对质凭据 vs 并录指纹,现归还单一职责)。无 batch 的历史行静默跳过
 //      (无判定依据的行不产出不可消除噪声——沿 audit-gate-hardening P3 教训)
+//  17. 发版提交树上仍未收口的 intent/spec/plan [hard-block]
+//  18. 委派台账对账 [warning]
+//  19. 逐阶段审计（起草先于入口确认 / 台账审批顺序倒置） [warning]
+//      判据 A=在途扫描(同名 spec/plan 为 draft 且日期≥stageGateSince 时判入口确认;plan 另判 L2/L3 的 spec);
+//      判据 B=台账 approved 行按主题校验 intents≤specs≤plans 顺序(组内最早 ts 日期≥stageGateSince 才判);
+//      stageGateSince 缺键(v1) → 本检查整体跳过;口径与 stage-gates.mjs / fill-* / confirm-doc 前置门互引
 // 16. 量化断言指标签名对账 [warning](2026-09-28 起;登记表单源 .agents/metric-claims.txt):
 // 判据 = 活跃态文档(draft/approved/open)中的 `{{指标名}}` 签名须替换为实时值,留签名=未回填=warning。
 // **只查显式签名、不全文扫数字**(据实说明):本仓活跃文档「N 行/N 条/N 份」类表述数十处,绝大多数是
@@ -80,21 +88,63 @@
 // 运行模式:CHECK_LOOP_ROOT 注入 fixture 根(全扫不过滤,非 git 时检查 10/14 跳过);
 //   缺省 = git 仓库根(不在 git 仓库内 stderr 提示后 exit 0 跳过);仓库模式只扫已提交(HEAD)内容
 //   (并行会话未跟踪半成品不拦别人的 push;ls-tree 失败退化为全扫,门禁不失效)。
+//   --rev <sha>：把该提交剥到 commit 后挂到临时 detached worktree，ROOT 改到那里再扫。
+//   原工作区的未提交改动不进入这次扫描。与 CHECK_LOOP_ROOT 同时出现则 exit 1。全 0 sha exit 1。
 // 文档协议:机器字段一律由文件头 YAML frontmatter(受限子集:每行 `键: 值`)承载,本脚本只扫 frontmatter 取字段;
 //   叙述性字段(独立复核/复盘三件套/验收勾验)按正文行锚定。枚举单源 .agents/workflow-enums.txt
 //   (缺文件/缺键 fail-loud exit 1;经 workflow-enums.mjs 读取,CRLF 天然容忍)。
 // 已确认状态: approved/done=已批或闭环; superseded/cancelled=放弃留档(仍算确认,不挡 push); incident: fixed/closed
-// 用法:node .agents/scripts/check-loop.mjs   （或经 check-loop.sh shim）
+// 用法:node .agents/scripts/check-loop.mjs [--rev <sha>] [--hardening]   （或经 check-loop.sh shim）
+//   --hardening：追加「加固门」（experiment 泳道 exploring 任务入 main 的转正门槛，hard-block；
+//     .githooks/pre-push 对 remote=refs/heads/main 的推送传入；不占 1-19 编号，gate-checklist 登记表
+//     按号配对面不变，门体说明见加固门段注释）
 // 测试:node templates/_agents/scripts/check-loop.test.mjs（fixture 注入 CHECK_LOOP_ROOT）
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { loadEnums } from './workflow-enums.mjs';
+import { runCheck16 } from './check-metric-claims.mjs';
+import { auditEnabled, loadKitPolicy } from './policy.mjs';
+// MARK_RE：incident 留痕形态的单源（第七轮复核 N3——此前 check-loop 内联复制一份同口径字面量，
+// 两处靠注释与人工同步；改为复用 stage-gates.mjs 的导出，从结构上消除漂移可能）
+import { MARK_RE, approvedTraceHit } from './stage-gates.mjs';
 
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const GIT = process.platform === 'win32' ? 'git.exe' : 'git';
+
+function takeOpts() {
+  const args = process.argv.slice(2);
+  const opts = { rev: null, hardening: false };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--rev') {
+      opts.rev = args[++i] ?? '';
+      if (!opts.rev) {
+        console.error('check-loop: 用法 node check-loop.mjs [--rev <sha>] [--hardening]');
+        process.exit(1);
+      }
+    } else if (args[i] === '--hardening') {
+      opts.hardening = true; // 加固门（2026-09-30 hybrid-governance-explore-hardening）：pre-push 对 main 目标传入
+    } else {
+      console.error('check-loop: 用法 node check-loop.mjs [--rev <sha>] [--hardening]');
+      process.exit(1);
+    }
+  }
+  return opts;
+}
+const { rev: REV_ARG, hardening: HARDENING } = takeOpts();
+if (REV_ARG && process.env.CHECK_LOOP_ROOT) {
+  console.error('check-loop: CHECK_LOOP_ROOT 与 --rev 不能同时使用');
+  process.exit(1);
+}
+if (REV_ARG && /^0+$/.test(REV_ARG)) {
+  console.error(`check-loop: --rev 不是提交 ${REV_ARG}`);
+  process.exit(1);
+}
+let REV = null;
 
 // ---- 根目录与枚举单源 ----
 let ROOT;
@@ -107,10 +157,38 @@ if (process.env.CHECK_LOOP_ROOT) {
 } else {
   const top = gitOut(['rev-parse', '--show-toplevel']);
   if (top === null) {
+    if (REV_ARG) {
+      console.error(`check-loop: --rev 剥不到提交 ${REV_ARG}`);
+      process.exit(1);
+    }
     console.error('check-loop: 不在 git 仓库内,跳过扫描');
     process.exit(0);
   }
   ROOT = top.trim();
+  if (REV_ARG) {
+    const peeled = gitOut(['rev-parse', '--verify', `${REV_ARG}^{commit}`]);
+    if (!peeled) {
+      console.error(`check-loop: --rev 剥不到提交 ${REV_ARG}`);
+      process.exit(1);
+    }
+    REV = peeled.trim();
+    const parent = fs.mkdtempSync(path.join(os.tmpdir(), 'ck-rev-'));
+    const wt = path.join(parent, 'wt');
+    const main = ROOT;
+    const add = spawnSync(GIT, ['worktree', 'add', '--detach', '--quiet', wt, REV], {
+      cwd: main, encoding: 'utf8',
+    });
+    if (add.status !== 0) {
+      fs.rmSync(parent, { recursive: true, force: true });
+      console.error(`check-loop: 导出提交失败 ${REV_ARG}\n${add.stderr || add.stdout || ''}`);
+      process.exit(1);
+    }
+    process.on('exit', () => {
+      spawnSync(GIT, ['worktree', 'remove', '--force', wt], { cwd: main });
+      fs.rmSync(parent, { recursive: true, force: true });
+    });
+    ROOT = wt;
+  }
 }
 // 枚举单源（<root>/.agents/workflow-enums.txt——fixture 契约：缺文件/缺键 fail-loud）
 let ENUMS;
@@ -130,7 +208,7 @@ const stOkDoc = (st) => inSet(st, ENUMS['doc.status.confirmed']);
 
 // git 调用（参数数组形式不走 shell——Windows cmd 不认单引号；git.exe 显式解析沿 doctor 先例）
 function gitOut(args, { ok = () => true } = {}) {
-  const r = spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', args,
+  const r = spawnSync(GIT, args,
     { cwd: ROOT, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
   if (r.error || r.status !== 0 || !ok(r)) return null;
   return r.stdout || '';
@@ -161,6 +239,12 @@ const WF = 'workflow';
 const DOC_DIRS = ['intents', 'specs', 'plans', 'incidents'];
 const blockers = [];
 const warnings = [];
+// audit:false（init 新装）只保留 blockers。缺省与 audit:true 保持全量警告。
+// 硬规则：配对 / 验收勾验的阻断 / 确认留痕 / 发版草稿。卫生项走 warnings。
+const kitPolicy = loadKitPolicy(ROOT);
+if (!auditEnabled(kitPolicy)) {
+  warnings.push = () => warnings.length;
+}
 
 // ---- 已提交(HEAD)过滤：仓库模式只扫 tracked（fixture 模式恒真；ls-tree 失败退化全扫）----
 let trackedSet = null; // null = 不过滤
@@ -179,11 +263,12 @@ const docFiles = (sub) => {
     .sort();
 };
 
-// --- 1. intent/spec/plan 同名配对 + 状态确认 + L3 确认三件 [hard-block] ---
+// --- 1. intent/spec/plan 同名配对 + 状态确认 + L3 确认三件 + 风险泳道一致性 [hard-block] ---
 for (const intent of docFiles('intents')) {
   const base = path.basename(intent);
   const st = fmGet(intent, '状态');
   const lvl = fmGet(intent, '级别');
+  const risk = fmGet(intent, 'risk_level'); // 风险泳道字段（fill-intent 落，=级别；2026-09-30 hybrid-governance-risk-lanes）
   if (!stOkDoc(st)) {
     const msg = `${base}（frontmatter 状态键当前值:『${st || '缺失'}』）`;
     if (lvl === 'L3') blockers.push(`- [状态未确认] L3 intent 必须为 approved/done/superseded/cancelled:${msg}`);
@@ -194,9 +279,19 @@ for (const intent of docFiles('intents')) {
       blockers.push(`- [配对断裂] intent 缺 spec:${base}（应在 ${WF}/specs/ 下同名）`);
     }
   }
-  if (!fs.existsSync(path.join(ROOT, WF, 'plans', base))) {
+  // 协作道（L0）豁免 plan 配对——异步审计兜底（hybrid-governance-risk-lanes）；L1 仍须 plan，L2/L3 须 spec+plan
+  if (lvl !== 'L0' && !fs.existsSync(path.join(ROOT, WF, 'plans', base))) {
     blockers.push(`- [配对断裂] intent 缺 plan:${base}（应在 ${WF}/plans/ 下同名）`);
   }
+  // 风险泳道一致性：L0/L1（级别或 risk_level 任一判定）勾选触达红线 = 自认触及规则/契约或数据/运行时
+  // 结构面——就高不就低，协作道不受理 → hard 判低，须升级 L2/L3 并补同名 spec
+  if (['L0', 'L1'].includes(lvl) || ['L0', 'L1'].includes(risk)) {
+    const redlineTouched = (linesOf(intent) || [])
+      .some((l) => /^- \[x\]/.test(l) && /(\$\\rightarrow\$|→)\s*级别|级别至少\s*L[23]/.test(l));
+    if (redlineTouched) {
+      blockers.push(`- [红线判低] ${base} 级别/风险泳道为 ${[lvl, risk].filter(Boolean).join('/')} 但触达红线已勾选（规则/契约或 schema/结构面）——协作道不受理 STOP 级改动：就高不就低，先把「级别/risk_level」升到 L2/L3 并补同名 spec`);
+    }
+  }
 }
 
 for (const spec of docFiles('specs')) {
@@ -456,6 +551,53 @@ const addedDateOf = (absDoc) => {
   return iso ? iso.slice(0, 10) : '';
 };
 
+// 证据真相校验：检查证据字符串是否包含合法的 commit SHA，且该 commit 触及了 plan 声明的文件
+function verifyEvidenceTruth(evidenceStr, planBase, root) {
+  const shaMatch = evidenceStr.match(/\b([a-f0-9]{7,40})\b/i);
+  // 排除纯数字串（时间戳/ID），必须是包含字母的 hex 串才疑似 SHA
+  if (!shaMatch || /^\d+$/.test(shaMatch[1])) return { ok: true, type: 'text' };
+
+  const sha = shaMatch[1];
+  const revParse = spawnSync(GIT, ['rev-parse', sha], { cwd: ROOT, encoding: 'utf8' });
+  if (revParse.status !== 0) {
+    // 区分本地伪造与外部仓库引用：
+    // 剔除 SHA 与泛指词后仍有其他内容（如项目名、路径描述）→ 视为外部仓库引用，不硬拦（本地无法核验他仓哈希）；
+    // 剔除后为空（如纯「commit a1b2c3d」「提交 a1b2c3d」）→ 视为本地引用伪造，硬拦。
+    const residue = evidenceStr.replace(sha, '')
+      .replace(/证据[：:]|commit|提交|[（）()。—-]/gi, '')
+      .trim();
+    if (residue.length > 0) return { ok: true, type: 'external' };
+    return { ok: false, type: 'forged', msg: `提交 ${sha} 不存在` };
+  }
+
+  // 语义核验：该 commit 必须触及 plan 中声明的任何一个文件
+  const planPath = path.join(ROOT, WF, 'plans', planBase + '.md');
+  if (!fs.existsSync(planPath)) return { ok: true, type: 'no-plan' }; // 缺 plan 走 Check 1 拦截
+
+  const planLines = linesOf(planPath) || [];
+  const declaredFiles = [];
+  // 扫描「改动面」或「任务拆解」节
+  let inDeclaredSec = false;
+  for (const line of planLines) {
+    if (/^##\s+(改动面|任务拆解)/.test(line)) { inDeclaredSec = true; continue; }
+    if (inDeclaredSec && /^##\s+/.test(line)) { inDeclaredSec = false; continue; }
+    if (inDeclaredSec) {
+      const fileMatch = line.match(/([a-zA-Z0-9._\/-]+\.[a-zA-Z0-9]+)/);
+      if (fileMatch) declaredFiles.push(fileMatch[1]);
+    }
+  }
+
+  const show = spawnSync(GIT, ['show', '--name-only', sha], { cwd: ROOT, encoding: 'utf8' });
+  if (show.status !== 0) return { ok: false, type: 'error', msg: `无法读取提交 ${sha} 的文件列表` };
+  
+  const changedFiles = show.stdout.split(/\r?\n/).filter(Boolean);
+  const hasIntersection = changedFiles.some(f => declaredFiles.some(df => f.includes(df) || df.includes(f)));
+  
+  if (!hasIntersection) return { ok: false, type: 'irrelevant', msg: `提交 ${sha} 未触及 plan 声明的任何文件` };
+  
+  return { ok: true, type: 'sha' };
+}
+
 // --- 8. intent 验收标准对账（done 须逐条勾验并补证据；新建 hard，存量聚合 warning）---
 // 生效日锚 2026-09-28 改「git 首次加入日期」（此前取文件名前 10 字符——命名规范强制的字段、
 // 写早零成本，见 incidents/2026-09-28-check8-git-anchor）。非 git → 不可判定 → 走存量口径（不误报 hard）。
@@ -472,16 +614,40 @@ const addedDateOf = (absDoc) => {
     let hs = false, uc = false, ne = false;
     let insec = false, ex = false;
     let pendX = false; // 上一 [x] 项尚无证据，证据可能在紧随的续行
+    let currentEvidence = ''; // 当前条目的证据内容，用于语义校验
     const evRe = /证据[：:]/;
-    const closeItem = () => { if (pendX) { ne = true; pendX = false; } };
+    const closeItem = () => { 
+      if (pendX) { 
+        ne = true; 
+        pendX = false; 
+      } 
+      if (currentEvidence && !ex) {
+        const truth = verifyEvidenceTruth(currentEvidence, base.replace(/\.md$/, ''), ROOT);
+        if (!truth.ok) {
+          blockers.push(`- [证据${truth.type === 'forged' ? '伪造' : '无关'}] ${base} 验收证据校验失败: ${truth.msg}`);
+        }
+      }
+      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); continue; }
-      if (pendX && evRe.test(line)) pendX = false; // 续行补上证据
+      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(); // 节末（或全文末）仍无证据 → 计缺证据
     // 生效日锚 = git 首次加入日期（2026-09-28 改；此前取文件名前 10 字符）。**准确收益**：关掉
@@ -496,12 +662,12 @@ const addedDateOf = (absDoc) => {
       continue;
     }
     if (!uc && !ne) continue;
-    if (isNew) {
-      if (uc) blockers.push(`- [验收未对账] done intent 验收标准有未勾验项:${base}（逐条勾验并补证据：commit/用例/冒烟输出）`);
-      if (ne) warnings.push(`- [WARN 验收缺证据] ${base} 验收标准勾选项缺「证据：」标注`);
-    } else if (!ex) {
-      legacyUnaccounted++;
-    }
+      if (isNew) {
+        if (uc) blockers.push(`- [验收未对账] done intent 验收标准有未勾验项:${base}（逐条勾验并补证据：commit/用例/冒烟输出）`);
+        if (ne) blockers.push(`- [验收缺证据] ${base} 验收标准勾选项缺「证据：」标注——证据是闭环准确性的唯一机器事实`);
+      } else if (!ex) {
+        legacyUnaccounted++;
+      }
   }
   if (legacyUnaccounted > 0) {
     warnings.push(`- [WARN 验收对账存量] ${legacyUnaccounted} 个存量 done intent 验收标准未对账（生效日锚之前加入仓库，豁免 hard，不回填）`);
@@ -576,8 +742,8 @@ if (gitOut(['rev-parse', '--git-dir']) !== null) {
         if (!d) d = /^\d{4}-\d{2}-\d{2}$/.test(base.slice(0, 10)) ? base.slice(0, 10) : '';
         if (mod) {
           if (!vocab.has(mod)) warnings.push(`- [WARN 模块元数据] ${base}「模块: ${mod}」不在词表(见 .agents/workflow-modules.txt)`);
-        } else if (/^\d{4}-\d{2}-\d{2}$/.test(d) && d >= '2026-09-22') {
-          warnings.push(`- [WARN 模块元数据] ${base} 缺「模块:」字段(2026-09-22 起新建文档必填)`);
+        } else if (/^\d{4}-\d{2}-\d{2}$/.test(d) && d >= kitPolicy.moduleSince) {
+          warnings.push(`- [WARN 模块元数据] ${base} 缺「模块:」字段(${kitPolicy.moduleSince} 起新建文档必填)`);
         }
       }
     }
@@ -605,12 +771,14 @@ if (gitOut(['rev-parse', '--git-dir']) !== null && gitOut(['rev-parse', '-q', '-
       const base = path.basename(doc);
       let d = fmGet(doc, '日期') || fmGet(doc, '发现');
       if (!d) d = /^\d{4}-\d{2}-\d{2}$/.test(base.slice(0, 10)) ? base.slice(0, 10) : '';
-      if (!/^\d{4}-\d{2}-\d{2}$/.test(d) || d < '2026-09-23') continue; // 生效 2026-09-23 起（规则发布次日）
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(d) || d < kitPolicy.check14Since) continue; // policy.mjs check14Since
       const lines = linesOf(doc) || [];
       if (lines.some((l) => l.includes('存量确认态豁免（'))) continue;
       const rel = path.relative(ROOT, doc).split(path.sep).join('/');
-      const hit = gitOut(['log', '-1', '--format=%H', '-G', '^状态:[[:space:]]*approved', '--', rel]);
-      if (hit !== null && hit.trim() === '') {
+      // 命中判据单源（stage-gates.approvedTraceHit，2026-09-30 confirm-gate-approved-history）：
+      // 返回 ''=从未出现 / <sha>=命中 / null=git 调用失败（不报，沿本段 fail-open 口径）
+      const hit = approvedTraceHit(ROOT, rel);
+      if (hit !== null && hit === '') {
         warnings.push(`- [WARN 确认态缺失] ${base} 状态已 done 但 git 历史中从未出现行首「状态: approved」——确认环节未留痕(draft 直跳 done)`);
       }
     }
@@ -631,7 +799,7 @@ if (gitOut(['rev-parse', '--git-dir']) !== null && gitOut(['rev-parse', '-q', '-
 // 独立生效日 2026-09-28 常量退役：台账起算日 = docs 生效日，两档等价）。
 // 台账坏行容忍跳过（审计件，jsonl 追加式）；frontmatter 存 16 位、台账存 64 位，按前 16 位配对。
 {
-  const EFFECTIVE = '2026-09-27';
+  const EFFECTIVE = kitPolicy.confirmDocsEffective;
   const ledgerPath = path.join(ROOT, '.agents', 'confirmations.jsonl');
   const ledger = [];
   if (fs.existsSync(ledgerPath)) {
@@ -666,7 +834,7 @@ if (gitOut(['rev-parse', '--git-dir']) !== null && gitOut(['rev-parse', '-q', '-
       //      仅靠 ① 会被误判为存量豁免而静默放行）。
       // 两条件皆不满足 = 存量豁免（生效日前既有、从未走确认门，不追溯）。
       const docEntries = ledger.filter((e) => e && e.doc === rel && VALID_STAGES.has(e.stage));
-      const eff = sub === 'incidents' ? '2026-09-28' : EFFECTIVE;
+      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;
@@ -690,7 +858,7 @@ if (gitOut(['rev-parse', '--git-dir']) !== null && gitOut(['rev-parse', '-q', '-
         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 >= '2026-09-28')) {
+        } 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 引用`);
@@ -725,6 +893,10 @@ if (gitOut(['rev-parse', '--git-dir']) !== null && gitOut(['rev-parse', '-q', '-
       // of > 1 = 一次调用落多份态。delegated 形态下这正是「并录」（入口已拒多份，此处抓历史/绕行）；
       // TTY 形态天然逐份过目（用户亲手键入），of>1 不构成违规——故只对 delegated 行报。
       if (!rows.some((r) => r.source === 'chat-delegated')) continue;
+      // 协作道批量豁免（2026-09-30 hybrid-governance-risk-lanes）：confirm-doc --batch 仅受理 L0/L1
+      // （逐份读级别，L2/L3 逐份拒绝），台账行带 brief:true——全行带标记的批次是 sanctioned 泳道行为
+      // （异步审计兜底），不出「确认并录」；缺标记（旧版脚本/手造台账）照旧告警，判据偏严不偏松。
+      if (rows.every((r) => r.brief === true)) continue;
       const of = Math.max(...rows.map((r) => (typeof r.of === 'number' ? r.of : 0)));
       const docs = rows.map((r) => String(r.doc).replace(/^workflow\//, '')).join('、');
       warnings.push(`- [WARN 确认并录] 单次调用落账 ${rows.length} 份（batch ${b}，of=${of}）：${docs}——同一次 --delegated 调用放行多份，塌掉「逐件确认」门（build.md）；口径见 workflow/papercuts.md 2026-09-28 与 incidents/2026-09-28-batch-ledger-audit.md`);
@@ -733,270 +905,290 @@ if (gitOut(['rev-parse', '--git-dir']) !== null && gitOut(['rev-parse', '-q', '-
 }
 
 // --- 16. 量化断言指标签名对账 [warning]（2026-09-28 claim-exceeds-fix；登记表单源 .agents/metric-claims.txt）---
-// 判据：活跃态文档（draft/approved/open）中出现的 `{{指标名}}` 签名，实时取数比对。
-// **为什么只查显式签名、不全文扫数字**（据实说明）：本仓活跃文档「N 行/N 条/N 份」类表述数十处，
-// 绝大多数是**历史叙述**（描述某次提交当时的规模，天然不随当前事实变化）——全文扫描会对这些
-// 正确表述产生大量假阳性，而本脚本已把「无判定依据的行不产出不可消除噪声」立为红线
-// （沿 audit-gate-hardening P3：噪声淹没真漏点）。故本检查假阳性恒为 0，代价是覆盖面靠登记。
-// 未登记签名 / 取数器缺失 → fail-loud（不静默跳过：静默会让「登记了但其实没查」不可见）。
-// 登记表缺失 → 静默跳过（未启用该检查的装户不应被噪声打扰）。
+// 判据要点：活跃态文档（draft/approved/open）中的 `{{指标名}}`（小写点分）签名须替换为实时值，留签名=未回填=
+//   warning；只查显式签名、不全文扫数字（历史叙述假阳性恒 0）；未登记签名 / 取数器缺失 → fail-loud 出账；
+//   登记表缺失 → 静默跳过（未启用该检查的装户零噪声）；装户自有指标走 .agents/metric-derivers.cjs（CJS 契约，
+//   内置优先）。实现自 2026-09-28 check16-inline-debt 起迁出至 check-metric-claims.mjs（原内联块，判据语义/
+//   消息文案/exit 语义零变化，迁出经全量输出 diff 基线验证）。ctx 显式携带本检查引用的外层符号
+//   （ROOT/ENUMS/docFiles/fmGet/inSet/isTracked/linesOf/readdirOrNull/warnings，以代码实际引用集为准）；
+//   调用位置须保持在检查 15 之后、输出段之前——warnings 按插入序输出，位置变化会改变输出行序。
+runCheck16({ ROOT, ENUMS, docFiles, fmGet, inSet, isTracked, linesOf, readdirOrNull, warnings });
+
+// --- 17. 发版提交树上仍未收口的 intent/spec/plan [hard-block] ---
+// 最近一次 package.json version 发生变化的提交里，当时状态已是 draft 或 approved 的
+// intent/spec/plan，被扫描的树上仍是 draft 或 approved 则阻断。
+// 当时已是 draft：不看版本锚。当时已是 approved：只在发版版本大于
+// policy.check17UnclosedAfter 时阻断。版本 1 没有该键，因此不启用后两格。
+// 版本按主、次、修订三段整数比较。沿 package.json 的全部历史查找，不设次数上限。
+// 该提交之后新建的文件不在范围内。open 的 incident 不在此列。
 {
-  const mcFile = path.join(ROOT, '.agents', 'metric-claims.txt');
-  if (fs.existsSync(mcFile)) {
-    // 取数器闭集：全部本地确定性、零网络。新增指标须同时改本表与 metric-claims.txt（缺一 fail-loud）
-    // **取数须与扫描面同口径（复核 P2 更正）**：文档扫描走 `docFiles()`（仓库模式只取 HEAD **tracked**
-    // 内容，见 isTracked），首版 `countDocs` 却直接 readdir 数盘面——实测本仓 `docs.count.plans` 会
-    // 把并行会话的**未跟踪**新档算进去（盘面 60 / HEAD 59），于是「签名填对了」却是别的读者复现不出的
-    // 数。故此处同样以 isTracked 过滤，保证「扫描看得到的文档集 == 取数统计的文档集」。
-    const countDocs = (sub) => {
-      const dir = path.join(ROOT, 'workflow', sub);
-      return (readdirOrNull(dir) || []).filter((f) => {
-        // 与 docFiles() 同口径：.md + 以数字开头（排除 _TEMPLATE.md 等非实例件）+ tracked
-        if (!f.endsWith('.md') || !/^\d/.test(f)) return false;
-        return isTracked(path.relative(ROOT, path.join(dir, f)).split(path.sep).join('/'));
-      }).length;
-    };
-    const ledgerLines = () => {
-      const p = path.join(ROOT, '.agents', 'confirmations.jsonl');
-      const ls = (linesOf(p) || []).filter((l) => l.trim());
-      return { total: ls.length, withBatch: ls.filter((l) => /"batch"/.test(l)).length };
-    };
-    // 内置取数器：全部本地确定性、零网络。**装户零配置即用**（不依赖任何装户文件）。
-    const derivers = {
-      'ledger.lines': () => ledgerLines().total,
-      'ledger.linesWithBatch': () => ledgerLines().withBatch,
-      'ledger.linesWithoutBatch': () => ledgerLines().total - ledgerLines().withBatch,
-      'docs.count.intents': () => countDocs('intents'),
-      'docs.count.specs': () => countDocs('specs'),
-      'docs.count.plans': () => countDocs('plans'),
-      'docs.count.incidents': () => countDocs('incidents'),
-      'docs.count.all': () => countDocs('intents') + countDocs('specs') + countDocs('plans') + countDocs('incidents'),
-    };
-    // ---- 装户侧取数器（2026-09-28 adopter-derivers；修「owned 登记表配 managed 取数器」P1）----
-    // 背景：登记表是 owned（装户自增指标），取数器却曾硬编码在本文件（managed）——装户一新增指标
-    // 就报「无取数器」，唯一出路是改本文件，而那是 managed：sync 永久报「本地已改」+ doctor WARN
-    // + 本脚本因供应链防线**跳过执行**（门禁静默停摆）。故改为分层：
-    //   ① 内置优先（行为与今完全一致，装户零配置可用）；② 未命中则查装户模块 `.agents/metric-derivers.cjs`
-    // **必须是 CJS（`.cjs` + module.exports）**（2026-09-28 跨版本实测修正）：
-    //   首版约定 `.mjs` 并用 `createRequire` 载入，在 Node v24.12 上实测可用（**故本机没暴露问题**）；
-    //   但跨版本实测（真下 18.20.5 / 20.18.0 / 22.11.0 二进制跑）**三者全部 `ERR_REQUIRE_ESM`**——
-    //   `require(esm)` 只在 Node ≥20.19 / ≥22.12 默认可用，Node 18 从未支持。而本仓 engines 写
-    //   `>=18.0.0`、CI 矩阵跑 18/22 → **装户取数功能在 CI 目标版本上完全不可用**（fail-loud 正常、
-    //   不崩，但功能不工作）。故改用 CJS：`createRequire` 载入 `.cjs` 在 18/20/22/24 全线可用，
-    //   且**仍是同步**（无须把本脚本改成 async 主线）。契约要求同步函数也与本检查「零网络、
-    //   本地确定性」的前提一致（异步的唯一真实收益是网络/并发 IO，此处都不允许）。
-    // **失败一律响亮、绝不静默降级**（沿 claim-exceeds-fix「假绿比红危险」与本检查自身语法错教训）：
-    // 若载入失败就「只用内置指标」，装户会看到「引用了 my.metric → 未登记」，看起来像**自己忘了登记**，
-    // 而真因是模块坏了——他会去 registry 反复核对，问题永远查不到。故载入/调用失败均出明确 WARN。
-    const adopterModRel = '.agents/metric-derivers.cjs';
-    // 旧路径（首版 .mjs）：若存在则**明确提示已改用 .cjs**，避免装户对着「无取数器」查不出所以然
-    const adopterLegacyRel = '.agents/metric-derivers.mjs';
-    let adopterState = null; // { ok:true, derivers } | { ok:false, errors:[...] } —— 懒载入 + 单次运行内缓存
-    const loadAdopterDerivers = () => {
-      if (adopterState) return adopterState;
-      const abs = path.join(ROOT, adopterModRel);
-      if (!fs.existsSync(abs)) {
-        // 常见误写：仍用首版的 .mjs 路径 → 给出可操作的迁移指引（而非任其对着「无取数器」猜）
-        if (fs.existsSync(path.join(ROOT, adopterLegacyRel))) {
-          adopterState = {
-            ok: false,
-            errors: [`${adopterModRel} 不存在，但发现旧版路径 ${adopterLegacyRel}——该路径已于 2026-09-28 弃用（\`require(esm)\` 在 Node 18/22 不可用，实测 ERR_REQUIRE_ESM）。请改名为 ${adopterModRel} 并把写法改为 CommonJS：\`module.exports = { derivers: { ... } }\``],
-          };
-          return adopterState;
-        }
-        adopterState = { ok: true, derivers: {} }; // 缺失=正常态，零告警
-        return adopterState;
+  const log = gitOut(['log', '--format=%H', '--', 'package.json']);
+  if (log) {
+    let release = null;
+    let releaseVer = '';
+    for (const sha of log.split('\n').map((s) => s.trim()).filter(Boolean)) {
+      const curTxt = gitOut(['show', `${sha}:package.json`]);
+      if (!curTxt) continue;
+      let cur = null;
+      try { cur = JSON.parse(curTxt).version; } catch { continue; }
+      const prevTxt = gitOut(['show', `${sha}^:package.json`]);
+      let prev = null;
+      if (prevTxt) { try { prev = JSON.parse(prevTxt).version; } catch { prev = null; } }
+      if (cur && cur !== prev) { release = sha; releaseVer = cur; break; }
+    }
+    const tree = release && gitOut(['ls-tree', '-r', '--name-only', release, '--', `${WF}/intents`, `${WF}/specs`, `${WF}/plans`]);
+    if (release && tree) {
+      for (const rel of tree.split('\n').map((s) => s.trim()).filter(Boolean)) {
+        if (!rel.endsWith('.md') || rel.endsWith('_TEMPLATE.md')) continue;
+        const thenTxt = gitOut(['show', `${release}:${rel}`]);
+        if (!thenTxt) continue;
+        const thenSt = fmStatus(thenTxt);
+        const nowSt = fmGet(path.join(ROOT, rel), '状态');
+        if ((thenSt !== 'draft' && thenSt !== 'approved') || (nowSt !== 'draft' && nowSt !== 'approved')) continue;
+        if (thenSt === 'approved' && !versionGreater(releaseVer, kitPolicy.check17UnclosedAfter)) continue;
+        const here = REV ? `提交 ${REV.slice(0, 7)}` : '工作区';
+        blockers.push(`- [发版草稿] ${rel} 在 version=${releaseVer} 的提交 ${release.slice(0, 7)} 上已是 ${thenSt}，${here}仍是 ${nowSt}。发版提交树上未收口的 intent/spec/plan 须先离开 draft 与 approved。覆盖面只含该提交当时已在树上的 intent/spec/plan；其后新建的文件不在此列`);
       }
-      try {
-        const req = createRequire(import.meta.url);
-        const mod = req(abs);
-        // CJS / ESM 双兼容取导出：CJS 走 module.exports.derivers；若装户误用了 ESM 语法而环境恰好
-        // 支持（新 Node 的 require(esm)），default 里也可能挂 derivers——两处都认，避免假阴性。
-        const d = (mod && mod.derivers) || (mod && mod.default && mod.default.derivers);
-        if (!d || typeof d !== 'object' || Array.isArray(d)) {
-          adopterState = { ok: false, errors: [`${adopterModRel} 未导出 \`derivers\` 对象（实际导出形态：${d === undefined ? '无 derivers 键' : Array.isArray(d) ? 'array' : typeof d}）——载入失败不降级，请用 \`module.exports = { derivers: { ... } }\``] };
-          return adopterState;
+    }
+  }
+}
+
+// --- 18. 委派台账对账 [warning] ---
+// L2/L3 的 intent、spec、plan 状态为 done，或同级别 incident 状态为 fixed 或 closed 时，
+// 「委派结果」表与「自做任务结果」表均没有日期不早于文档日期、且含该文件名（带/不带 .md 均匹配）的一行，则警告。
+// 缺级别、缺日期、以及其他状态不警告。audit:false 时 warnings.push 已被换成空函数。
+// 两表解析口径与 agg-delegations.cjs splitTables 保持一致，一边改另一边须跟。
+{
+  const rows = delegationResultRows(path.join(ROOT, WF, 'delegations.md'));
+  for (const sub of ['intents', 'specs', 'plans', 'incidents']) {
+    for (const abs of docFiles(sub)) {
+      const lvl = fmGet(abs, '级别');
+      if (lvl !== 'L2' && lvl !== 'L3') continue;
+      const st = fmGet(abs, '状态');
+      const inScope = sub === 'incidents' ? (st === 'fixed' || st === 'closed') : st === 'done';
+      if (!inScope) continue;
+      const date = sub === 'incidents' ? (fmGet(abs, '发现') || fmGet(abs, '日期')) : fmGet(abs, '日期');
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue;
+      const base = path.basename(abs);
+      const stripped = base.replace(/\.md$/, '');
+      if (rows.some((r) => r.date >= date && (r.line.includes(base) || r.line.includes(stripped)))) continue;
+      const rel = path.relative(ROOT, abs).split(path.sep).join('/');
+      warnings.push(`- [WARN 委派台账] ${rel} 在 ${date} 及之后的委派结果/自做任务结果表中没有该文件名`);
+    }
+  }
+}
+
+// --- 19. 逐阶段审计 [warning]（2026-09-30 stage-gate-machine；口径与 stage-gates.mjs / fill-* / confirm-doc 前置门互引） ---
+// 判据 A（在途扫描）：同名 spec/plan 为 draft 且其日期 ≥ stageGateSince 时——入口未确认（intent：状态非
+//   approved/done、或缺台账行且非存量；incident：「时间线」小节缺行首「用户确认」条目）→ warning；
+//   入口缺合法「级别」→ warning（与起草门 fail-closed 同口径，2026-09-30 复核 P2-7）；
+//   plan 另判（入口级别 L2/L3 且 spec 未确认或缺失）→ warning。
+// 判据 B（台账顺序）：同主题 {intents,specs,plans} 的 approved 行（每 doc 取最早）时间须非降序；仅对
+//   组内最早 ts 日期 ≥ stageGateSince 的主题判定；含更早 ts 的主题整组跳过（历史豁免）。
+// 协作道豁免（2026-09-30 hybrid-governance-risk-lanes）：入口 intent 为 draft 且级别 L0/L1 → 判据 A 静默
+//   （「先动手后确认」是泳道语义；approved/done 无台账行仍照报）；判据 B 对入口 L0/L1 的主题豁免顺序
+//   倒置判定（入口文件缺失不豁免）。
+// stageGateSince 缺键（policy v1）→ 本检查整体跳过；全部 warning、不 hard-block。
+{
+  const since = kitPolicy.stageGateSince;
+  if (typeof since === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(since)) {
+    const ledgerRows = [];
+    {
+      const lp = path.join(ROOT, '.agents', 'confirmations.jsonl');
+      if (fs.existsSync(lp)) {
+        for (const line of linesOf(lp) || []) {
+          if (!line.trim()) continue;
+          try { ledgerRows.push(JSON.parse(line)); } catch { /* 坏行跳过（同检查 15 口径） */ }
         }
-        adopterState = { ok: true, derivers: d };
-      } catch (e) {
-        const hint = /ERR_REQUIRE_ESM/.test(String(e && e.code)) ? `（该错误表示模块被当成了 ESM——本契约要求 CommonJS：文件后缀 .cjs 且用 \`module.exports = { derivers: {...} }\`）` : '';
-        adopterState = { ok: false, errors: [`${adopterModRel} 载入失败：${String(e && e.message ? e.message : e).split('\n')[0]}${hint}——载入失败不降级（静默降级会让你误以为「忘了登记」而非「模块坏了」）`] };
       }
-      return adopterState;
+    }
+    const hasRow = (rel) => ledgerRows.some((e) => e && e.doc === rel && (e.stage === 'approved' || e.stage === 'done'));
+    const docConfirmed = (rel, abs) => {
+      const st = fmGet(abs, '状态');
+      if (st !== 'approved' && st !== 'done') return { ok: false, legacy: false, why: `状态「${st || '缺失'}」` };
+      if (hasRow(rel)) return { ok: true, level: fmGet(abs, '级别'), legacy: false };
+      const d = fmGet(abs, '日期') || fmGet(abs, '发现');
+      const legacy = (linesOf(abs) || []).some((l) => /^流程: legacy/.test(l))
+        || (/^\d{4}-\d{2}-\d{2}$/.test(d) && d < kitPolicy.confirmDocsEffective);
+      if (legacy) return { ok: true, level: fmGet(abs, '级别'), legacy: true };
+      return { ok: false, legacy: false, why: '无确认台账行' };
     };
-    // ctx：注入给装户取数器的同步辅助（免其重复造轮子）
-    // **glob 逐字符转义**（自查修正）：首版用「先整体转义特殊字符、再 replace 星号」的写法，
-    // 实测 `src/**/*.ts` 匹配不到 `src/a/b/c.ts`、「**/*.md」匹配不到 `a/b/c.md`——因为 `**/`
-    // 在被替换前已被字符类转义破坏。改为逐字符状态机，语义明确：
-    //   `**/` → 任意层级（含零层）；`**` → 任意（可跨 /）；`*` → 段内任意（不跨 /）；`?` → 段内单字符
-    //   其余一律字面转义（故 `a.b.sql` 的点是字面点、`[`/`{` 也按字面处理——本 helper 不承诺
-    //   字符类 / 花括号展开，避免装户误以为支持完整 glob 语法；不支持即按字面匹配，行为可预测）
-    const globToRegExp = (p) => {
-      const s = String(p);
-      let re = '';
-      for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        if (c === '*' && s[i + 1] === '*') {
-          if (s[i + 2] === '/') { re += '(?:.*/)?'; i += 2; } // `**/` 含零层
-          else { re += '.*'; i += 1; }                        // `**` 跨段
-        } else if (c === '*') re += '[^/]*';
-        else if (c === '?') re += '[^/]';
-        else re += c.replace(/[.+^${}()|[\]\\]/, '\\$&');
+    // incident 留痕判定：**直接复用 stage-gates.mjs 的 MARK_RE**（第七轮复核 N3：此前此处内联复制
+    // 一份同口径字面量，两处靠注释人工同步、无测试钉住——改为单源复用，从结构上消除漂移可能）。
+    // 判据同源：「## 时间线」小节内、行首列表条目含「用户确认」（词边界见 MARK_RE）。
+    const incidentMarked19 = (lines) => {
+      let inTimeline = false;
+      for (const l of lines || []) {
+        if (/^##\s/.test(l)) { inTimeline = /^##\s*时间线/.test(l); continue; }
+        if (inTimeline && MARK_RE.test(l)) return true;
       }
-      return new RegExp('^' + re + '$');
+      return false;
     };
-    // 遍历时**跳过重目录 + 防环**（自查 + 复核 P2 修正）：
-    // · 剪枝 node_modules / .git / cache——无剪枝时 `ctx.glob('**/*')` 会走进依赖树，既慢又会把
-    //   依赖文件算进取数（对「我项目有多少个 X」是错的数）。
-    // · **visited 集合防环**：复核实测软链接/junction 成环时递归到 depth 128、同一文件重复 64 份
-    //   才被 statSync 的 ELOOP 拦下；POSIX 无 MAX_PATH 时该递归无界。故按**真实路径**去重。
-    const WALK_SKIP = new Set(['node_modules', '.git', 'cache']);
-    const walkFiles = (dir, out = [], rel = '', visited = new Set()) => {
-      let real = dir;
-      try { real = fs.realpathSync(dir); } catch { /* 不可解析则按原路径处理 */ }
-      if (visited.has(real)) return out; // 环 → 剪枝
-      visited.add(real);
-      for (const e of readdirOrNull(dir) || []) {
-        if (WALK_SKIP.has(e)) continue;
-        const abs = path.join(dir, e);
-        const r = rel ? `${rel}/${e}` : e;
-        let st = null;
-        try { st = fs.statSync(abs); } catch { continue; }
-        if (st.isDirectory()) walkFiles(abs, out, r, visited);
-        else out.push(r);
+    const entryConfirmed19 = (base) => {
+      const irel = `${WF}/intents/${base}.md`;
+      const iabs = path.join(ROOT, irel);
+      if (fs.existsSync(iabs)) {
+        const st19 = fmGet(iabs, '状态');
+        const lvl19 = fmGet(iabs, '级别');
+        const r = docConfirmed(irel, iabs);
+        const body = (linesOf(iabs) || []).join('\n');
+        const d19 = fmGet(iabs, '日期') || fmGet(iabs, '发现');
+        const storLegacy = /^流程: legacy/m.test(body) || (/^\d{4}-\d{2}-\d{2}$/.test(d19) && d19 < kitPolicy.confirmDocsEffective);
+        return { ...r, level: lvl19, entryDraft: st19 === 'draft', storageLegacy: storLegacy };
       }
-      return out;
-    };
-    const ctx = {
-      root: ROOT,
-      read: (rel) => { try { return fs.readFileSync(path.join(ROOT, rel), 'utf8').replace(/\r\n/g, '\n'); } catch { return ''; } },
-      glob: (pattern) => { const re = globToRegExp(pattern); return walkFiles(ROOT).filter((r) => re.test(r)); },
-      countFiles: (dir, pred) => walkFiles(path.join(ROOT, dir)).filter((r) => (typeof pred === 'function' ? pred(r) : true)).length,
-    };
-    // resolveDeriver(name) → { fn } | { error }（**绝不抛出**：引擎不因装户代码崩溃）
-    const resolveDeriver = (name) => {
-      if (derivers[name]) return { fn: derivers[name], builtin: true };
-      const st = loadAdopterDerivers();
-      if (!st.ok) return { error: st.errors.join('；') };
-      const fn = st.derivers[name];
-      if (typeof fn !== 'function') {
-        if (fn !== undefined) return { error: `${adopterModRel} 的「${name}」不是函数（实际类型：${typeof fn}）` };
-        return { error: `无对应取数器——内置 8 个指标均不含该名，${adopterModRel} 亦未定义（登记了却没实现＝其实没查）` };
+      const crel = `${WF}/incidents/${base}.md`;
+      const cabs = path.join(ROOT, crel);
+      if (fs.existsSync(cabs)) {
+        const st = fmGet(cabs, '状态');
+        if ((st === 'open' || st === 'fixed' || st === 'closed') && incidentMarked19(linesOf(cabs))) {
+          return { ok: true, level: fmGet(cabs, '级别'), legacy: false, storageLegacy: false };
+        }
+        return { ok: false, legacy: false, storageLegacy: false, why: 'incident 未见过目留痕（时间线条目缺失）' };
       }
-      return { fn, builtin: false };
+      return { ok: false, legacy: false, storageLegacy: false, why: '无同名入口' };
     };
-    // 装户模块载入失败：**独立成条**（2026-09-28 adopter-derivers）。
-    // 关键设计（真绿 vs 假绿的分界）：载入失败若只表现为「该指标无取数器」，装户会看到
-    // 「引用了 my.metric → 未登记」，看起来像**自己忘了登记**，而真因是模块坏了——他会去 registry
-    // 反复核对，永远查不到。故此处单独出一条，明示文件与错误，与「真的没登记」可区分。
-    //
-    // **仅在真的需要装户指标时才报**（复核 P2 更正）：首版在解析登记表前无条件出账——若登记表只有
-    // 内置指标、而装户留了个半成品模块（或模块坏掉但没人用），会平白多一条不可消除的 advisory。
-    // 沿本仓红线「无判定依据的行不产出噪声」：先看登记表是否真的有**非内置**指标，再决定报不报。
-    const mcLines = (linesOf(mcFile) || []).map((l) => l.trim()).filter((l) => l && !l.startsWith('#'));
-    const hasAdopterMetric = mcLines.some((l) => {
-      const mm = /^([A-Za-z][\w.]*)\s*=\s*([A-Za-z][\w.]*)$/.exec(l);
-      return mm && !derivers[mm[1]];
-    });
-    const adopterLoad = loadAdopterDerivers();
-    if (!adopterLoad.ok && hasAdopterMetric) {
-      for (const e of adopterLoad.errors) warnings.push(`- [WARN 装户取数器载入失败] ${e}`);
-    }
-    // 解析登记表：`<指标名> = <取数表达式>`（表达式须与指标名同形，二者不一致即登记笔误）
-    const declared = new Map();
-    const precedenceWarned = new Set(); // 同名 advisory 按指标去重（复核 P2 更正：首版按行重复出账）
-    for (const line of mcLines) {
-      const m = /^([A-Za-z][\w.]*)\s*=\s*([A-Za-z][\w.]*)$/.exec(line);
-      if (!m) { warnings.push(`- [WARN 指标登记] .agents/metric-claims.txt 行格式非法（应为 \`指标名 = 取数表达式\`）：${line}`); continue; }
-      if (m[1] !== m[2]) { warnings.push(`- [WARN 指标登记] 登记名与取数表达式不一致：${m[1]} ≠ ${m[2]}`); continue; }
-      const r = resolveDeriver(m[1]);
-      if (r.error) {
-        // 无取数器（内置无 + 装户模块无同名）或装户模块载入失败 → 明示可操作方向
-        const hint = adopterLoad.ok
-          ? `若为项目自有指标，请在 ${adopterModRel} 的 derivers 中实现（契约见 .agents/metric-claims.txt 头部）`
-          : `且 ${adopterModRel} 载入失败（见上方「装户取数器载入失败」条目——**这不是「忘了登记」**）`;
-        warnings.push(`- [WARN 指标登记] 指标「${m[1]}」无对应取数器（fail-loud：登记了却没实现＝其实没查）——内置 8 指标不含该名，${hint}`);
-        // **不 continue**：该指标在 registry 里确实登记过，故仍计入 declared——
-        // 否则引用它的文档会被误报为「未登记」（把「模块坏了」伪装成「忘了登记」，正是本单要防的假绿）。
-        // 取数失败在扫描阶段以「指标取数失败」单独出账，两条信息不互相掩盖。
-      } else if (r.builtin && adopterLoad.ok && typeof adopterLoad.derivers[m[1]] === 'function' && !precedenceWarned.has(m[1])) {
-        // 内置与装户同名：内置优先（保持本仓/存量行为稳定），并明示装户定义被忽略（**按指标去重**）
-        precedenceWarned.add(m[1]);
-        warnings.push(`- [WARN 指标登记] 指标「${m[1]}」由引擎内置提供，${adopterModRel} 中的同名定义**被忽略**（内置优先）——如需改用自有实现，请换一个指标名`);
+    for (const sub of ['specs', 'plans']) {
+      for (const abs of docFiles(sub)) {
+        if (fmGet(abs, '状态') !== 'draft') continue;
+        const base = path.basename(abs).replace(/\.md$/, '');
+        // 日期：frontmatter 优先，缺则回落文件名前缀（plan 无「日期」字段；沿检查 15 口径）
+        let d = fmGet(abs, '日期');
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(d)) d = /^\d{4}-\d{2}-\d{2}$/.test(base.slice(0, 10)) ? base.slice(0, 10) : '';
+        if (!(/^\d{4}-\d{2}-\d{2}$/.test(d) && d >= since)) continue;
+        const rel = path.relative(ROOT, abs).split(path.sep).join('/');
+        const ent = entryConfirmed19(base);
+        if (!ent.ok) {
+          // 协作道异步审计豁免（2026-09-30 hybrid-governance-risk-lanes）：入口 intent 仍为 draft 且
+          // 级别 L0/L1 → 「先动手后确认」是泳道语义，不告警；approved/done 却无台账行仍照报（防手改
+          // 状态冒充确认，与交叉一致性口径一致）；incident 入口不豁免（过目留痕本就轻量）。
+          if (ent.entryDraft && (ent.level === 'L0' || ent.level === 'L1')) continue;
+          warnings.push(`- [WARN 逐阶段] ${rel} 起草先于入口确认（${ent.why}）`); continue;
+        }
+        // 库存量形态（标记 / 日期早于生效日）短路 level 校验与 spec 档（与起草门同口径，N1）
+        const storLegacy = ent.storageLegacy === true;
+        if (!storLegacy && !/^L[0-3]$/.test(ent.level)) { warnings.push(`- [WARN 逐阶段] ${rel} 入口缺合法「级别」字段（无法判定前置深度；与起草门 fail-closed 同口径，库存量形态除外）`); continue; }
+        if (sub === 'plans' && !storLegacy && (ent.level === 'L2' || ent.level === 'L3')) {
+          const srel = `${WF}/specs/${base}.md`;
+          const sabs = path.join(ROOT, srel);
+          const sp = fs.existsSync(sabs) ? docConfirmed(srel, sabs) : { ok: false, why: '缺同名 spec' };
+          if (!sp.ok) warnings.push(`- [WARN 逐阶段] ${rel} 起草先于 spec 确认（${sp.why}）`);
+        }
       }
-      declared.set(m[1], true);
     }
-    // 扫活跃态文档（沿检查 4 现有尺度：终态件的历史数字是历史叙述，不扫）
-    const activeSet16 = (sub) => (sub === 'incidents' ? ENUMS['incident.status.active'] : ENUMS['doc.status.active']);
-    const scanFiles16 = [];
-    for (const sub of ['intents', 'specs', 'plans', 'incidents']) {
-      const dir = path.join(ROOT, 'workflow', sub);
-      for (const f of readdirOrNull(dir) || []) {
-        if (!f.endsWith('.md') || f === '_TEMPLATE.md') continue;
-        if (!inSet(fmGet(path.join(dir, f), '状态'), activeSet16(sub))) continue;
-        scanFiles16.push({ rel: `workflow/${sub}/${f}`, abs: path.join(dir, f) });
-      }
+    const firstApproved = new Map(); // base -> { intents?, specs?, plans? } 最早 approved ts
+    for (const e of ledgerRows) {
+      if (!e || e.stage !== 'approved' || typeof e.doc !== 'string') continue;
+      const m = /^workflow\/(intents|specs|plans)\/(.+)\.md$/.exec(e.doc);
+      if (!m) continue;
+      const rec = firstApproved.get(m[2]) || {};
+      if (!rec[m[1]] && typeof e.ts === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(e.ts)) rec[m[1]] = e.ts;
+      firstApproved.set(m[2], rec);
     }
-    for (const f of readdirOrNull(path.join(ROOT, 'workflow')) || []) {
-      if (f.endsWith('.md')) scanFiles16.push({ rel: `workflow/${f}`, abs: path.join(ROOT, 'workflow', f) });
+    for (const [base, rec] of firstApproved) {
+      const seq = ['intents', 'specs', 'plans'].filter((k) => rec[k]);
+      if (seq.length < 2) continue;
+      // 协作道豁免（2026-09-30 hybrid-governance-risk-lanes）：入口 L0/L1 的审批顺序倒置（如 plan 先于
+      // intent approved——「动手后确认」）是异步审计泳道语义，非流程违规；入口文件缺失（纯台账历史行 /
+      // incident 侧）不豁免，维持既有判据。
+      const ilvlB = fmGet(path.join(ROOT, WF, 'intents', `${base}.md`), '级别');
+      if (ilvlB === 'L0' || ilvlB === 'L1') continue;
+      const earliest = seq.map((k) => rec[k]).sort()[0];
+      if (!(earliest.slice(0, 10) >= since)) continue;
+      let ordered = true;
+      for (let i = 1; i < seq.length; i++) if (rec[seq[i]] < rec[seq[i - 1]]) ordered = false;
+      if (!ordered) warnings.push(`- [WARN 逐阶段] 台账审批顺序倒置：${base}（${seq.map((k) => `${k}=${rec[k].slice(0, 19)}`).join(' / ')}）`);
     }
-    for (const { rel, abs } of scanFiles16) {
-      const ls = linesOf(abs) || [];
-      ls.forEach((line, i) => {
-        // 签名形态收窄为**小写点分**（如 `{{ledger.lines}}`）：装户模板占位符是全大写 SCREAMING_CASE
-        // （构建命令 / 看板端口 / 项目名三类，由 init 渲染替换，非本检查对象）
-        // ——不收窄会对这些合法的模板占位符产生大量假阳性（实测：本仓 plans 内 11 处）。
-        // **转义（2026-09-28，本检查在自己的文档上抓到该需求）**：讲语法 / 举例 / 引用告警原文的
-        // 文档在签名前加反斜杠（`\{{ledger.lines}}`）表示「此处是示意、非断言」——否则本检查
-        // 会把「文档在教怎么用签名」误判为「作者忘了回填」。选显式转义而非「同句含『如/例』等标记词
-        // 即豁免」的启发式：后者会按措辞松紧漂移，且作者能无意中触发豁免而漏过真断言。
-        // **转义按「逐个出现」生效、不按整行**（复核自查 P1 更正）：首版实现是「行内出现任一 `\{{`
-        // 即整行跳过」，实测可被这样藏住真断言——`… \{{a.b}} 示意… {{ledger.lines}} 未回填` 整行静默
-        // 放过。故改为用带后顾的否匹配排除转义位，同行的真签名照常出账。
-        for (const m of line.matchAll(/(?<!\\)\{\{([a-z][a-z0-9]*(?:\.[a-z0-9]+)+)\}\}/g)) {
-          const name = m[1];
-          if (!declared.has(name)) {
-            warnings.push(`- [WARN 指标未登记] ${rel}:${i + 1} 引用 {{${name}}} 但 .agents/metric-claims.txt 未登记该指标（未登记＝无从对账）`);
-            continue;
-          }
-          const r = resolveDeriver(name);
-          if (r.error) {
-            // 取数器不可用（含装户模块载入失败 / 无该名 / 定义非法）——**响亮出账，绝不静默跳过**
-            warnings.push(`- [WARN 指标取数失败] ${rel}:${i + 1} {{${name}}} 无法取数：${r.error}`);
-            continue;
-          }
-          let real;
-          try {
-            real = r.fn(ctx);
-          } catch (e) {
-            warnings.push(`- [WARN 指标取数失败] ${rel}:${i + 1} {{${name}}} 取数器抛异常：${String(e && e.message ? e.message : e).split('\n')[0]}`);
-            continue;
-          }
-          // 返回值必须是有限数字：Promise（误写 async）/ NaN / 字符串 / undefined 一律拦下并明示类型
-          if (typeof real !== 'number' || !Number.isFinite(real)) {
-            const kind = real && typeof real.then === 'function' ? 'Promise（本检查要求**同步**函数，请去掉 async/await）' : `${typeof real}${typeof real === 'number' ? `（${real}）` : ''}`;
-            warnings.push(`- [WARN 指标取数失败] ${rel}:${i + 1} {{${name}}} 取数器返回值不是有限数字：${kind}`);
-            continue;
-          }
-          // 判据：签名**必须**被替换为实时值——留有 `{{...}}` 即视为未回填（写作期占位，关单前须落实）
-          warnings.push(`- [WARN 指标待回填] ${rel}:${i + 1} {{${name}}} 实时值 = ${real}——请把签名替换为该数字（留签名＝未回填）`);
-        }
-        // **形态不符的签名也不静默放过（复核 P2 更正）**：首版只认严格小写点分形态，于是
-        // `{{Ledger.Lines}}` / `{{ ledger.lines }}`（含空格）这类**明显本意是签名**的写法
-        // 既不匹配、也不出账——静默漏过，且绕开了「未登记」的 fail-loud。此处补一道：
-        // 非转义的 `{{...}}` 中，凡**不是**严格形态、且**不是**装户模板占位符（全大写 SCREAMING_CASE）
-        // 的，一律提示形态不符（作者才能立刻发现笔误）。
-        for (const m of line.matchAll(/(?<!\\)\{\{([^{}]+)\}\}/g)) {
-          const raw = m[1];
-          if (/^[a-z][a-z0-9]*(?:\.[a-z0-9]+)+$/.test(raw)) continue; // 严格形态，上面已处理
-          if (/^[A-Z][A-Z0-9_]*$/.test(raw)) continue; // 装户模板占位符（init 渲染对象，非本检查面）
-          warnings.push(`- [WARN 指标形态] ${rel}:${i + 1} \`{{${raw}}}\` 不是合法签名形态（应为小写点分，如 {{ledger.lines}}）——若本意是量化断言，请改正形态；若只是举例，请加反斜杠转义`);
-        }
-      });
+  }
+}
+
+// --- 加固门（仅 --hardening 启用；2026-09-30 hybrid-governance-explore-hardening）[hard-block] ---
+// 探索泳道（experiment/* 分支 + intent frontmatter「阶段: exploring」标记；「状态: exploring」亦认——
+// 非法状态本就会在检查 5 出账）允许「先动手后确认」快速 PoC；成果转正（合入 main）前必须完成加固：
+//   ① intent 状态离开 draft → approved/done（探索作废走显式放弃态 superseded/cancelled——留档即出列，
+//      不加固：放弃态无代码应随行）；
+//   ② 同名 plan 在场且状态收口（∈ doc.status.confirmed；L0 亦不豁免——本门是转正门槛，不是配对门）；
+//   ③ 泳道 L2/L3（级别优先、缺失/非法回落 risk_level，与 stage-gates 起草门同款取法）另须同名 spec
+//      在场且收口。
+// 触发面：.githooks/pre-push 对 remote=refs/heads/main 的推送以 --hardening 运行本脚本（hard 失败即阻断
+// push）；手跑 `node check-loop.mjs --hardening` 可转正前预检。诚实边界：分支名不进 commit，扫描树无法
+// 机械判定「曾在 experiment/* 上」——标记靠泳道纪律写入（intent 模板 / workflow README 口径），漏标记的
+// 探索件不被本门覆盖；本门拦的是「已标记未收口」。
+if (HARDENING) {
+  for (const intent of docFiles('intents')) {
+    if (fmGet(intent, '阶段') !== 'exploring' && fmGet(intent, '状态') !== 'exploring') continue;
+    const base = path.basename(intent);
+    const st = fmGet(intent, '状态');
+    if (st === 'superseded' || st === 'cancelled') continue; // 放弃态：探索作废留档，不加固
+    const lvl = fmGet(intent, '级别');
+    const lane = /^L[0-3]$/.test(lvl) ? lvl : fmGet(intent, 'risk_level');
+    if (st !== 'approved' && st !== 'done') {
+      blockers.push(`- [加固未过] exploring 任务入 main 须先收口:${base} intent 状态仍为『${st || '缺失'}』——先确认至 approved/done 并补齐同名 spec+plan，或显式放弃（superseded/cancelled）`);
+      continue;
+    }
+    const planAbs = path.join(ROOT, WF, 'plans', base);
+    const planSt = fs.existsSync(planAbs) ? fmGet(planAbs, '状态') : '';
+    if (!fs.existsSync(planAbs)) {
+      blockers.push(`- [加固未过] exploring 任务入 main 缺同名 plan:${base}（应在 ${WF}/plans/ 下同名）`);
+    } else if (!stOkDoc(planSt)) {
+      blockers.push(`- [加固未过] exploring 任务入 main 的 plan 未收口:${base}（plan 状态『${planSt || '缺失'}』须为 approved/done）`);
+    }
+    if (lane === 'L2' || lane === 'L3') {
+      const specAbs = path.join(ROOT, WF, 'specs', base);
+      const specSt = fs.existsSync(specAbs) ? fmGet(specAbs, '状态') : '';
+      if (!fs.existsSync(specAbs)) {
+        blockers.push(`- [加固未过] exploring 任务入 main 缺同名 spec:${base}（级别 ${lane}，应在 ${WF}/specs/ 下同名）`);
+      } else if (!stOkDoc(specSt)) {
+        blockers.push(`- [加固未过] exploring 任务入 main 的 spec 未收口:${base}（spec 状态『${specSt || '缺失'}』须为 approved/done）`);
+      }
     }
   }
 }
 
+function delegationResultRows(file) {
+  let text = '';
+  try { text = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const lines = text.split(/\r?\n/);
+  const targetSec = (line) => /^##\s+(委派结果|自做任务结果)\s*$/.test(line);
+  let inSec = false;
+  const rows = [];
+  for (const line of lines) {
+    if (/^##\s+/.test(line)) {
+      inSec = targetSec(line);
+      continue;
+    }
+    if (!inSec || !/^\s*\|/.test(line)) continue;
+    const cells = line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
+    if (!cells.length || cells.every((c) => /^[-: ]*$/.test(c))) continue;
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(cells[0])) continue;
+    rows.push({ date: cells[0], line });
+  }
+  return rows;
+}
+
+function versionGreater(a, b) {
+  const parse = (v) => {
+    const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(String(v ?? ''));
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+  };
+  const x = parse(a);
+  const y = parse(b);
+  if (!x || !y) return false;
+  for (let i = 0; i < 3; i++) {
+    if (x[i] !== y[i]) return x[i] > y[i];
+  }
+  return false;
+}
+
+function fmStatus(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  if (!/^---\s*$/.test(lines[0] || '')) return '';
+  for (let i = 1; i < lines.length; i++) {
+    if (/^---\s*$/.test(lines[i])) return '';
+    if (lines[i].startsWith('状态:')) return lines[i].slice('状态:'.length).trim();
+  }
+  return '';
+}
+
 // --- 输出（banner 沿 sh 版字样与格式 = 稳定输出契约：banner 后空行、条目 '- ' 前缀）---
 if (blockers.length) {
   process.stderr.write(`闭环骨架断档（check-loop.sh）— HARD-BLOCK:\n\n${blockers.join('\n')}\n\n`);