agentic-flow-kit 0.9.0 → 0.9.4

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

@@ -70,6 +70,8 @@
 //  17. 发版提交树上仍未收口的 intent/spec/plan [hard-block]
 //  18. 委派台账对账 [warning]
 //  19. 逐阶段审计（起草先于入口确认 / 台账审批顺序倒置） [warning]
+//  20. 引擎脚本测试覆盖（包源环境：templates/_agents/scripts/ 下每个非 *.test.mjs 引擎脚本须有同名兄弟
+//      .test.mjs，或在 .agents/scripts-test-exempt.txt 登记豁免；2026-10-01 gate-script-test-coverage） [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 前置门互引
@@ -96,7 +98,7 @@
 // 已确认状态: approved/done=已批或闭环; superseded/cancelled=放弃留档(仍算确认,不挡 push); incident: fixed/closed
 // 用法: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 登记表
+//     .githooks/pre-push 对 remote=refs/heads/main 的推送传入；不占 1-20 编号，gate-checklist 登记表
 //     按号配对面不变，门体说明见加固门段注释）
 // 测试:node templates/_agents/scripts/check-loop.test.mjs（fixture 注入 CHECK_LOOP_ROOT）
 import fs from 'node:fs';
@@ -109,6 +111,7 @@ import { fileURLToPath } from 'node:url';
 import { loadEnums } from './workflow-enums.mjs';
 import { runCheck16 } from './check-metric-claims.mjs';
 import { auditEnabled, loadKitPolicy } from './policy.mjs';
+import { laneOfEntry } from './stage-gates.mjs';
 // MARK_RE：incident 留痕形态的单源（第七轮复核 N3——此前 check-loop 内联复制一份同口径字面量，
 // 两处靠注释与人工同步；改为复用 stage-gates.mjs 的导出，从结构上消除漂移可能）
 import { MARK_RE, approvedTraceHit } from './stage-gates.mjs';
@@ -283,13 +286,14 @@ for (const intent of docFiles('intents')) {
   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)) {
+  // 风险泳道一致性（2026-10-02 caliber-convergence 起单源 laneOfEntry·方案 C 分歧双严）：非 high
+  // （low 或 suspect——级别/risk_level 缺失、非法、分歧）勾选触达红线 = 自认触及规则/契约或数据/运行时
+  // 结构面——就高不就低，协作道不受理 → hard 判低，须对齐两字段至 L2/L3 并补同名 spec
+  if (laneOfEntry(lvl, risk, kitPolicy.riskLevelSince, fmGet(intent, '日期')) !== 'high') {
     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`);
+      blockers.push(`- [红线判低] ${base} 级别/风险泳道为 ${[lvl, risk].filter(Boolean).join('/')} 但触达红线已勾选（规则/契约或 schema/结构面）——协作道不受理 STOP 级改动：就高不就低，把「级别」与「risk_level」两字段对齐到 L2/L3（fill-intent 双写口径）并补同名 spec`);
     }
   }
 }
@@ -336,12 +340,24 @@ for (const plan of docFiles('plans')) {
   //   「复制本模板为 YYYY-MM-DD-<主题>.md」），非未填占位符；真未填的占位（标题 `# INTENT — <主题>`、
   //   `日期: YYYY-MM-DD`）不含 .md，仍照拦（2026-09-25-wf-runtime incident 记录的误报口径）
   const isNamingConv = (line) => line.includes('<主题>') && /\.md/.test(line);
+  // 样例引用豁免（2026-10-02 caliber-convergence 假阳性消除，先例=检查 18 行尾归一）：命中位于行内代码
+  // （反引号包裹）或围栏代码块内 = 引用样例而非未填占位符，不报；正文裸占位符照报——真占位符均为
+  // 裸文本（模板正文无反引号包裹），检测面不缩。
+  const stripSamples = (lines) => {
+    let inFence = false;
+    return lines.map((line) => {
+      if (/^\s*(```|~~~)/.test(line)) { inFence = !inFence; return ''; }
+      if (inFence) return '';
+      return line.replace(/`[^`]*`/g, '');
+    });
+  };
   const groups = new Map(); // file -> [ "行号:内容" ]（首现序）
   for (const sub of DOC_DIRS) {
     for (const f of docFiles(sub)) {
+      const lines = linesOf(f) || [];
       const hits = [];
-      (linesOf(f) || []).forEach((line, i) => {
-        if (phRe.test(line) && !boilerRe.test(line) && !isNamingConv(line)) hits.push(`${i + 1}:${line}`);
+      stripSamples(lines).forEach((line, i) => {
+        if (phRe.test(line) && !boilerRe.test(line) && !isNamingConv(line)) hits.push(`${i + 1}:${lines[i]}`);
       });
       if (hits.length) groups.set(f, hits);
     }
@@ -1034,7 +1050,7 @@ runCheck16({ ROOT, ENUMS, docFiles, fmGet, inSet, isTracked, linesOf, readdirOrN
         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 { ...r, level: lvl19, risk: fmGet(iabs, 'risk_level'), date: d19, entryDraft: st19 === 'draft', storageLegacy: storLegacy };
       }
       const crel = `${WF}/incidents/${base}.md`;
       const cabs = path.join(ROOT, crel);
@@ -1058,10 +1074,11 @@ runCheck16({ ROOT, ENUMS, docFiles, fmGet, inSet, isTracked, linesOf, readdirOrN
         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;
+          // 协作道异步审计豁免（2026-09-30 hybrid-governance-risk-lanes；2026-10-02 caliber-convergence
+          // 起单源 laneOfEntry·方案 C）：入口 intent 仍为 draft 且泳道 low（两字段一致 L0/L1）→「先动手后
+          // 确认」是泳道语义，不告警；suspect（缺失/非法/分歧）不豁免；approved/done 却无台账行仍照报
+          // （防手改状态冒充确认，与交叉一致性口径同）；incident 入口不豁免（过目留痕本就轻量）。
+          if (ent.entryDraft && laneOfEntry(ent.level, ent.risk, kitPolicy.riskLevelSince, ent.date) === 'low') continue;
           warnings.push(`- [WARN 逐阶段] ${rel} 起草先于入口确认（${ent.why}）`); continue;
         }
         // 库存量形态（标记 / 日期早于生效日）短路 level 校验与 spec 档（与起草门同口径，N1）
@@ -1120,7 +1137,8 @@ if (HARDENING) {
     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');
+    // 泳道单源（2026-10-02 caliber-convergence 方案 C）：suspect（缺失/非法/分歧）按 high——L2/L3 另须 spec
+    const lane = laneOfEntry(lvl, fmGet(intent, 'risk_level'), kitPolicy.riskLevelSince, fmGet(intent, '日期'));
     if (st !== 'approved' && st !== 'done') {
       blockers.push(`- [加固未过] exploring 任务入 main 须先收口:${base} intent 状态仍为『${st || '缺失'}』——先确认至 approved/done 并补齐同名 spec+plan，或显式放弃（superseded/cancelled）`);
       continue;
@@ -1132,11 +1150,13 @@ if (HARDENING) {
     } else if (!stOkDoc(planSt)) {
       blockers.push(`- [加固未过] exploring 任务入 main 的 plan 未收口:${base}（plan 状态『${planSt || '缺失'}』须为 approved/done）`);
     }
-    if (lane === 'L2' || lane === 'L3') {
+    // 泳道单源（2026-10-02 caliber-convergence 方案 C；复核 P1-1 修正）：suspect（缺失/非法/分歧）与
+    // high 同样另须同名 spec——仅 low（两字段一致 L0/L1）免 spec，只增不松。
+    if (lane !== 'low') {
       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/ 下同名）`);
+        blockers.push(`- [加固未过] exploring 任务入 main 缺同名 spec:${base}（级别 ${lvl}/risk ${fmGet(intent, 'risk_level') || '缺失'}，应在 ${WF}/specs/ 下同名）`);
       } else if (!stOkDoc(specSt)) {
         blockers.push(`- [加固未过] exploring 任务入 main 的 spec 未收口:${base}（spec 状态『${specSt || '缺失'}』须为 approved/done）`);
       }
@@ -1189,6 +1209,29 @@ function fmStatus(text) {
   return '';
 }
 
+// --- 20. 引擎脚本测试覆盖 [warning]（2026-10-01 gate-script-test-coverage；仅包源环境） ---
+// 包源开发纪律：templates/_agents/scripts/ 下每个非 *.test.mjs 引擎脚本须有同名兄弟 .test.mjs，
+// 或在 .agents/scripts-test-exempt.txt 登记豁免（managed 下发）。装户（无 templates/）整体跳过。
+{
+  const scriptsDir = path.join(ROOT, 'templates', '_agents', 'scripts');
+  if (fs.existsSync(scriptsDir)) {
+    const exemptFile = path.join(ROOT, '.agents', 'scripts-test-exempt.txt');
+    const exempt = fs.existsSync(exemptFile)
+      ? fs.readFileSync(exemptFile, 'utf8').split(/\r?\n/)
+          .map((l) => l.trim())
+          .filter((l) => l && !l.startsWith('#'))
+          .map((l) => l.split('|')[0].trim())
+          .filter(Boolean)
+      : [];
+    const orphans = fs.readdirSync(scriptsDir)
+      .filter((f) => f.endsWith('.mjs') && !f.endsWith('.test.mjs') && !exempt.includes(f))
+      .filter((f) => !fs.existsSync(path.join(scriptsDir, f.replace(/\.mjs$/, '.test.mjs'))));
+    for (const f of orphans.sort()) {
+      warnings.push(`- [WARN 脚本测试缺失] ${f} 缺同名 .test.mjs——新增引擎脚本默认必须带测试；库件/工具可在 .agents/scripts-test-exempt.txt 登记豁免`);
+    }
+  }
+}
+
 // --- 输出（banner 沿 sh 版字样与格式 = 稳定输出契约：banner 后空行、条目 '- ' 前缀）---
 if (blockers.length) {
   process.stderr.write(`闭环骨架断档（check-loop.sh）— HARD-BLOCK:\n\n${blockers.join('\n')}\n\n`);

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

@@ -12,7 +12,7 @@ import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { computeFingerprint } from './confirm-doc.mjs';
 import { POLICIES, loadKitPolicy } from './policy.mjs';
-import { entryConfirmed, MARK_RE } from './stage-gates.mjs';
+import { entryConfirmed, MARK_RE, laneOfEntry, laneOfDoc } from './stage-gates.mjs';
 
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const CHECK_LOOP = path.join(SCRIPT_DIR, 'check-loop.mjs');
@@ -2179,7 +2179,7 @@ const mkConfirmedDoc = (root, rel, fmBody) => {
   rmfix(T);
 }
 
-// ---- 加固门（2026-09-30 hybrid-governance-explore-hardening；仅 --hardening 启用，不占 1-19 编号）----
+// ---- 加固门（2026-09-30 hybrid-governance-explore-hardening；仅 --hardening 启用，不占 1-20 编号）----
 {
   // H1：未标记 exploring 的 draft 件 → 带/不带 --hardening 均不拦（本门只管「已标记未收口」，
   //  常规流程的 draft 中间态不受影响——intent approved 后 plan 起草属正常在途）
@@ -2253,5 +2253,103 @@ const mkConfirmedDoc = (root, rel, fmBody) => {
   rmfix(T);
 }
 
+// --- 20. 引擎脚本测试覆盖 [warning]（2026-10-01 gate-script-test-coverage） ---
+{
+  // C20-1：缺测试报 warning、有测试与豁免登记不报（包源环境）
+  const T = mkfix();
+  const sd = path.join(T, 'templates', '_agents', 'scripts');
+  fs.mkdirSync(sd, { recursive: true });
+  fs.writeFileSync(path.join(sd, 'foo.mjs'), 'export {};\n');
+  fs.writeFileSync(path.join(sd, 'foo.test.mjs'), '// ok\n');
+  fs.writeFileSync(path.join(sd, 'bar.mjs'), 'export {};\n');
+  fs.writeFileSync(path.join(sd, 'baz.mjs'), 'export {};\n');
+  fs.writeFileSync(path.join(T, '.agents', 'scripts-test-exempt.txt'), 'baz.mjs | 库件 | 无\n');
+  const r1 = run(T);
+  const o1 = outOf(r1);
+  check('检查20 C20-1 缺测试报 warning、有测试与豁免不报',
+    r1.status === 0 && o1.includes('[WARN 脚本测试缺失] bar.mjs') && !o1.includes('foo.mjs') && !o1.includes('baz.mjs'), o1);
+  rmfix(T);
+}
+{
+  // C20-2：装户环境（无 templates/）整体跳过
+  const T = mkfix();
+  const r2 = run(T);
+  check('检查20 C20-2 装户（无 templates/）跳过', !outOf(r2).includes('[WARN 脚本测试缺失]'), outOf(r2));
+  rmfix(T);
+}
+{
+  // C20-3：豁免文件缺失时全量列出（无豁免兜底）
+  const T = mkfix();
+  const sd = path.join(T, 'templates', '_agents', 'scripts');
+  fs.mkdirSync(sd, { recursive: true });
+  fs.writeFileSync(path.join(sd, 'zeta.mjs'), 'export {};\n');
+  const r3 = run(T);
+  check('检查20 C20-3 无豁免文件时缺测试脚本被列出', outOf(r3).includes('[WARN 脚本测试缺失] zeta.mjs'), outOf(r3));
+  rmfix(T);
+}
+
+// --- 方案 C：laneOfEntry 单源三态 + 检查 1 suspect 红线 + 检查 2 样例豁免（2026-10-02 caliber-convergence） ---
+{
+  check('laneOfEntry 一致 low / 一致 high',
+    laneOfEntry('L1', 'L1', '2026-10-01', '2026-10-02') === 'low' && laneOfEntry('L2', 'L2', '2026-10-01', '2026-10-02') === 'high');
+  check('laneOfEntry 协议期：分歧 / risk 缺失 / 级别缺失 → suspect',
+    laneOfEntry('L2', 'L1', '2026-10-01', '2026-10-02') === 'suspect'
+    && laneOfEntry('L2', '', '2026-10-01', '2026-10-02') === 'suspect'
+    && laneOfEntry('', 'L2', '2026-10-01', '2026-10-02') === 'suspect');
+  check('laneOfEntry 协议前：单字段按级别 / 两值俱在分歧仍 suspect',
+    laneOfEntry('L2', '', '2026-10-01', '2026-09-28') === 'high'
+    && laneOfEntry('L2', 'L1', '2026-10-01', '2026-09-28') === 'suspect');
+  check('laneOfDoc 单字段三态', laneOfDoc('L1') === 'low' && laneOfDoc('L3') === 'high' && laneOfDoc('') === 'suspect');
+}
+{
+  // 检查 1：协议期分歧件（L2/L1）勾红线 → suspect 按 low 拦红线（hard）
+  const T = mkfix();
+  fs.writeFileSync(path.join(T, 'workflow', 'intents', '2026-10-02-x.md'),
+    INTENT('x', '状态: approved\n级别: L2\nrisk_level: L1\n日期: 2026-10-02\n模块: pipeline',
+      '\n## 触达红线\n- [x] 规则 / 契约变更（→ 级别至少 L2）\n'));
+  fs.writeFileSync(path.join(T, 'workflow', 'plans', '2026-10-02-x.md'), '# PLAN\n');
+  const r = run(T);
+  check('检查1 分歧件勾红线 → hard-block（suspect 拦红线）', r.status === 1 && outOf(r).includes('[红线判低]') && outOf(r).includes('两字段对齐'), outOf(r));
+  rmfix(T);
+}
+{
+  // 检查 1 对照：协议前存量（级别 L2 无 risk_level）勾红线 → 不拦（单字段 high）
+  const T = mkfix();
+  fs.writeFileSync(path.join(T, 'workflow', 'intents', '2026-09-28-y.md'),
+    INTENT('y', '状态: approved\n级别: L2\n日期: 2026-09-28\n模块: pipeline',
+      '\n## 触达红线\n- [x] 规则 / 契约变更（→ 级别至少 L2）\n'));
+  fs.writeFileSync(path.join(T, 'workflow', 'plans', '2026-09-28-y.md'), '# PLAN\n');
+  const r = run(T);
+  check('检查1 协议前 L2 单字段勾红线 → 不拦（存量零新增损害）', !outOf(r).includes('[红线判低]'), outOf(r));
+  rmfix(T);
+}
+{
+  // 检查 2：样例豁免三态——反引号/围栏块内不报，正文裸占位符照报
+  const T = mkfix();
+  fs.writeFileSync(path.join(T, 'workflow', 'intents', '2026-10-02-z.md'),
+    INTENT('z', '状态: approved\n级别: L2\nrisk_level: L2\n日期: 2026-10-02\n模块: pipeline',
+      '\n行内样例 `YYYY-MM-DD` 与 `<主题>` 不报。\n\n```\n日期: YYYY-MM-DD\n```\n\n裸占位：日期: YYYY-MM-DD\n'));
+  fs.writeFileSync(path.join(T, 'workflow', 'plans', '2026-10-02-z.md'), '# PLAN\n');
+  const r = run(T);
+  const o = outOf(r);
+  const zWarn = (o.match(/2026-10-02-z\.md 含模板占位符:[\s\S]*?(?=\n- |\n\n|$)/) || [''])[0];
+  check('检查2 反引号/围栏样例不报、裸占位符照报',
+    zWarn.includes('裸占位') && !zWarn.includes('行内样例') && !zWarn.includes('```'), o);
+  rmfix(T);
+}
+
+{
+  // H7（2026-10-02 caliber-convergence 复核 P1-1）：suspect（级别 L2/risk_level L1 分歧，协议期）转正
+  // → 与 high 同样另须同名 spec——缺 spec 即拦（只增不松：suspect 不得逃 spec 前置）。
+  const T = mkfix();
+  w(T, 'workflow/intents/2026-10-02-h7.md',
+    INTENT('h7', '状态: approved\n级别: L2\nrisk_level: L1\n日期: 2026-10-02\n模块: pipeline\n阶段: exploring'));
+  w(T, 'workflow/plans/2026-10-02-h7.md', PLAN('h7', '状态: approved\n级别: L2'));
+  const r = run(T, { args: ['--hardening'] });
+  check('加固门 H7：suspect（L2/L1 分歧）转正 → 缺同名 spec 即拦',
+    r.status === 1 && outOf(r).includes('缺同名 spec'), outOf(r));
+  rmfix(T);
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/confirm-doc.mjs

@@ -39,7 +39,8 @@ import path from 'node:path';
 import readline from 'node:readline';
 import { createHash, randomBytes } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
-import { confirmGateFor, doneGateFor } from './stage-gates.mjs';
+import { confirmGateFor, doneGateFor, laneOfEntry, laneOfDoc } from './stage-gates.mjs';
+import { loadKitPolicy } from './policy.mjs';
 
 // computeFingerprint(text)：CRLF 归一 → 剔指纹行 → sha256 hex（64 位）
 export function computeFingerprint(text) {
@@ -267,6 +268,16 @@ if (isMain) {
     }
     const target = resolveTransition(st, toTarget);
     const lvl = fmLevel(nl); // 级别（AI 自治门 / 协作道批量门共用；缺 = ''）
+    // 泳道单源（2026-10-02 caliber-convergence 方案 C 分歧双严）：intent 双字段（级别+risk_level，协议
+    // 锚 policy.riskLevelSince）三态判定；其余件级别单字段。suspect（缺失/非法/分歧）按 high——--auto
+    // 与 --batch 均不受理，须先两字段对齐（fill-intent 双写口径）。
+    const fmOf = (key) => {
+      const m = nl.find((l) => l.startsWith(`${key}:`));
+      return m ? m.slice(key.length + 1).trim() : '';
+    };
+    const lane = doc.includes('/intents/')
+      ? laneOfEntry(lvl, fmOf('risk_level'), loadKitPolicy(root).riskLevelSince, fmOf('日期'))
+      : laneOfDoc(lvl);
     if (!target) {
       console.error(`跳过 ${doc}：当前状态「${st || '缺失'}」无合法跳转（前向：docs draft→approved / approved→done；incidents open→fixed / fixed→closed；放弃 --to：cancelled 自 draft/approved/open/fixed，superseded 自 approved/done/fixed/closed）`);
       continue;
@@ -299,12 +310,12 @@ if (isMain) {
     // ② Level 1：仅 draft→approved；Level 2：draft→approved 与 approved→done；
     // ③ incidents 永不自治（open→fixed/fixed→closed 必须人工）。
     if (autoMode) {
-      const isLowLevel = lvl === 'L0' || lvl === 'L1';
+      const isLowLevel = lane === 'low';
       const stageAllowed = trustConfig.level === 2
         ? (target === 'approved' || target === 'done')
         : target === 'approved';
       if (!isLowLevel || !stageAllowed || doc.startsWith('workflow/incidents/')) {
-        console.error(`❌ ${doc} 未过 AI 自治门（级别「${lvl || '缺失'}」/ 目标态「${target}」/ 类型）：Level ${trustConfig.level} 仅授权 L0/L1 的 ${trustConfig.level === 2 ? 'approved/done' : 'approved'} 且不含 incidents`);
+        console.error(`❌ ${doc} 未过 AI 自治门（级别「${lvl || '缺失'}」/ 泳道「${lane}」/ 目标态「${target}」/ 类型）：Level ${trustConfig.level} 仅授权泳道 low（intent 两字段一致 L0/L1；suspect 须先对齐「级别/risk_level」）的 ${trustConfig.level === 2 ? 'approved/done' : 'approved'} 且不含 incidents`);
         refused++;
         continue;
       }
@@ -320,11 +331,12 @@ if (isMain) {
       continue;
     }
     if (delegated) {
-      // 协作道门（2026-09-30 hybrid-governance-risk-lanes）：--batch 批量仅受理 L0/L1——L2/L3（或缺级别，
-      // fail-closed）逐份拒绝落账；不带 --batch 的单份代录不限级别（既有口径不变）。
-      const low = lvl === 'L0' || lvl === 'L1';
+      // 协作道门（2026-09-30 hybrid-governance-risk-lanes；2026-10-02 caliber-convergence 起单源泳道）：
+      // --batch 批量仅受理泳道 low（intent 两字段一致 L0/L1；suspect 拒）——high/suspect 逐份拒绝落账；
+      // 不带 --batch 的单份代录不限级别（既有口径不变）。
+      const low = lane === 'low';
       if (batchMode && !low) {
-        console.error(`❌ ${doc} 级别「${lvl || '缺失'}」不在协作道（L0/L1）——--batch 批量代录仅限 L0/L1，L2/L3 防御道须逐份确认（本份未落账、未写盘）`);
+        console.error(`❌ ${doc} 泳道「${lane}」（级别「${lvl || '缺失'}」）不在协作道——--batch 批量代录仅限两字段一致的 L0/L1；suspect（级别/risk_level 缺失、非法或分歧）须先对齐两字段，L2/L3 防御道须逐份确认（本份未落账、未写盘）`);
         refused++;
         continue;
       }

package/templates/_agents/scripts/confirm-doc.test.mjs

@@ -572,6 +572,37 @@ const gitHead = (root) => {
   fs.rmSync(root, { recursive: true, force: true });
 }
 
+// ---- S31b【方案 C 分歧双严】--batch 分歧件（级别 L1 / risk_level L2，协议期）→ 泳道 suspect 逐份拒绝（2026-10-02 caliber-convergence）----
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-bt3-'));
+  fs.mkdirSync(path.join(root, 'workflow', 'intents'), { recursive: true });
+  fs.mkdirSync(path.join(root, '.agents'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.agents', 'kit.json'), JSON.stringify({ policyVersion: 2 }));
+  fs.writeFileSync(path.join(root, 'workflow', 'intents', '2026-10-02-dv1.md'), '---\n状态: draft\n级别: L1\nrisk_level: L2\n日期: 2026-10-02\n---\n# DV\n');
+  const r = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-10-02-dv1.md', '--delegated', '批量放行', '--batch'], { cwd: root, encoding: 'utf8' });
+  const led = readLedgerOf(root);
+  const st = fs.readFileSync(path.join(root, 'workflow', 'intents', '2026-10-02-dv1.md'), 'utf8');
+  check('S31b --batch 分歧件 → 泳道 suspect 拒（exit 2 + 对齐两字段提示 + 零台账未落盘）',
+    r.status === 2 && /泳道「suspect」/.test(r.stderr) && /对齐/.test(r.stderr) && led.length === 0 && st.includes('状态: draft'),
+    JSON.stringify({ status: r.status, stderr: String(r.stderr).slice(0, 300), led }));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- S31c【方案 C 分歧双严】--auto 分歧件 → suspect 拒（消息锁定，先于 trust 判定短路）----
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-bt4-'));
+  fs.mkdirSync(path.join(root, 'workflow', 'intents'), { recursive: true });
+  fs.mkdirSync(path.join(root, '.agents'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.agents', 'kit.json'), JSON.stringify({ policyVersion: 2 }));
+  fs.writeFileSync(path.join(root, '.agents', 'trust-mode.json'), JSON.stringify({ enabled: true, level: 1, name: 'Standard', enabledAt: '2026-10-02T00:00:00.000Z' }));
+  fs.writeFileSync(path.join(root, 'workflow', 'intents', '2026-10-02-dv2.md'), '---\n状态: draft\n级别: L1\nrisk_level: L2\n日期: 2026-10-02\n---\n# DV2\n');
+  const r = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-10-02-dv2.md', '--auto'], { cwd: root, encoding: 'utf8' });
+  check('S31c --auto（trust=Standard）分歧件 → 泳道 suspect 拒（消息含 suspect 与对齐指引）',
+    r.status !== 0 && /suspect/.test(r.stderr) && /对齐/.test(r.stderr),
+    JSON.stringify({ status: r.status, stderr: String(r.stderr).slice(0, 300) }));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
 // ---- S32 --batch 组合约束：与 --auto / --to 互斥（exit 1，零落账）----
 {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-bt3-'));

package/templates/_agents/scripts/fill-intent.mjs

@@ -1,4 +1,4 @@
-// flow-kit fill-intent：起草 intent 草稿（背景与问题/目标/非目标/约束/影响面/触达红线/验收标准 共 7 节）
+// flow-kit fill-intent：起草 intent 草稿（背景与问题/历史教训防复发/目标/非目标/约束/影响面/触达红线/验收标准 8 节正文 + 确认与复核 共 9 节）
 // 读 workflow/intents/_TEMPLATE.md 的节标题 → 输出符合 frontmatter 受限子集（6 字段，含 risk_level 风险泳道）的草稿到指定文件
 // 用法：node .agents/scripts/fill-intent.mjs --module pipeline --level L1 --topic "test" --output /tmp/x.md
 // 零依赖；CLI 解析用最简字符串匹配；不替代 AI 起草——本工具只输出模板与提示句

package/templates/_agents/scripts/fill-plan.test.mjs

@@ -124,11 +124,12 @@ const runTool = (root, base, level) => spawnSync(process.execPath,
   fs.rmSync(root, { recursive: true, force: true });
 }
 {
-  // S10c 探索泳道回落：级别缺失、risk_level=L0 → 放行（risk_level 兜底判道）
+  // S10c（2026-10-02 caliber-convergence 方案 C 改判）：级别缺失 → suspect，不再回落 risk_level——
+  // 豁免仅认两字段一致的 low；缺失须先补「级别」再走起草（fail-closed 就严）。
   const root = mkws({ 'workflow/intents/2026-09-30-exp0.md': '---\n状态: draft\nrisk_level: L0\n日期: 2026-09-30\n---\n# I\n' });
   const r = runTool(root, '2026-09-30-exp0', 'L1');
-  check('S10c 探索泳道回落：级别缺失 + risk_level L0 → 放行',
-    r.status === 0 && fs.existsSync(path.join(root, 'workflow', 'plans', '2026-09-30-exp0.md')),
+  check('S10c 方案 C：级别缺失 + risk_level L0 → suspect 拒（不回落，先补级别）',
+    r.status === 2 && !fs.existsSync(path.join(root, 'workflow', 'plans', '2026-09-30-exp0.md')),
     JSON.stringify({ status: r.status, stderr: r.stderr }));
   fs.rmSync(root, { recursive: true, force: true });
 }

package/templates/_agents/scripts/gate-checklist.mjs

@@ -84,6 +84,7 @@ const PAIRS = [
   { doctor: '7', cl: '17', note: '经 §7 整体运行覆盖（发版提交树上仍未收口的 intent/spec/plan）' },
   { doctor: '7', cl: '18', note: '经 §7 整体运行覆盖（委派台账对账）' },
   { doctor: '7', cl: '19', note: '经 §7 整体运行覆盖（逐阶段审计——起草先于入口确认 / 台账审批顺序倒置）' },
+ { doctor: '7', cl: '20', note: '经 §7 整体运行覆盖（引擎脚本测试覆盖，2026-10-01 gate-script-test-coverage）' },
 ];
 
 // gateChecklist：按登记表对照两侧检查项（pure function；pairs 可注入供测试）

package/templates/_agents/scripts/gen-workflow-metrics.mjs

@@ -168,6 +168,59 @@ const idxText = fs.existsSync(path.join(WORKFLOW, 'INDEX.md')) ? fs.readFileSync
 const idxBytes = Buffer.byteLength(idxText, 'utf8');
 const idxActive = Number((idxText.match(/^## 活跃（(\d+)）/m) || [])[1] ?? NaN);
 
+// ---- 闭环漏斗（2026-10-02 ledger-funnel-metrics；口径定义式单源 = workflow/specs/2026-10-02-ledger-funnel-metrics.md）----
+// 只读台账一手字段（doc/stage/ts/source），坏行跳过（与检查 15/19 同容错）；观测面不挂门禁、不新增文档断言（检查 16 零接触）。
+const LEDGER_P = path.join('.agents', 'confirmations.jsonl');
+function readLedgerRows() {
+  if (!fs.existsSync(LEDGER_P)) return [];
+  return fs.readFileSync(LEDGER_P, 'utf8').split(/\r?\n/)
+    .map((l) => { try { return JSON.parse(l); } catch { return null; } })
+    .filter((e) => e && typeof e === 'object');
+}
+
+function funnelFromLedger(entries, month) {
+  const byDoc = new Map();
+  for (const e of entries) {
+    if (typeof e.doc !== 'string' || typeof e.ts !== 'string') continue;
+    if (!byDoc.has(e.doc)) byDoc.set(e.doc, []);
+    byDoc.get(e.doc).push(e);
+  }
+  const res = { closed: 0, full: 0, legacy: 0, once: 0, rework: 0, ledgerRows: 0, days: [], items: [] };
+  for (const e of entries) if (typeof e.ts === 'string' && e.ts.slice(0, 7) === month) res.ledgerRows++;
+  for (const [doc, rs] of byDoc) {
+    rs.sort((a, b) => String(a.ts).localeCompare(String(b.ts)));
+    const nonRevert = rs.filter((r) => !/^revert-/.test(String(r.stage || '')));
+    const terminals = nonRevert.filter((r) => r.stage === 'done' || r.stage === 'closed');
+    if (!terminals.length) continue; // 未收口件不进漏斗桶（仍计台账行数）
+    const lastTerm = terminals[terminals.length - 1];
+    if (String(lastTerm.ts).slice(0, 7) !== month) continue; // 月度归桶 = 终态行所在月
+    // 确认阶段按件型（复核 P2-3 收口）：docs=approved；incidents=fixed（两跳确认门 fixed→closed，
+    // 永无 approved 行——按 approved 判会把已走确认门的 incident 误归协议前）
+    const isInc = doc.includes('/incidents/');
+    const confirmStage = isInc ? 'fixed' : 'approved';
+    const confirms = nonRevert.filter((r) => r.stage === confirmStage);
+    const hasChain = confirms.length >= 1;
+    const hasRevert = rs.some((r) => /^revert-/.test(String(r.stage || '')));
+    const kind = !hasChain ? 'legacy' : (hasRevert || confirms.length >= 2 || terminals.length >= 2 ? 'rework' : 'once');
+    const firstTs = hasChain ? confirms[0].ts : rs[0].ts; // 协议前件首行起算
+    const days = (Date.parse(lastTerm.ts) - Date.parse(firstTs)) / 86400000;
+    res.closed++;
+    if (kind === 'legacy') res.legacy++;
+    else { res.full++; res[kind === 'once' ? 'once' : 'rework']++; }
+    if (Number.isFinite(days) && days >= 0) res.days.push(days);
+    res.items.push({ doc, kind, days: Number.isFinite(days) && days >= 0 ? days.toFixed(1) : '—' });
+  }
+  return res;
+}
+
+const ledgerRows = readLedgerRows();
+const funnel = funnelFromLedger(ledgerRows, month);
+const sortedDays = [...funnel.days].sort((a, b) => a - b);
+const medianDays = sortedDays.length
+  ? (sortedDays.length % 2 ? sortedDays[(sortedDays.length - 1) / 2] : (sortedDays[sortedDays.length / 2 - 1] + sortedDays[sortedDays.length / 2]) / 2)
+  : null;
+const funnelRow = `| ${month} | ${funnel.closed} | ${funnel.full} | ${funnel.legacy} | ${funnel.once} | ${funnel.rework} | ${medianDays === null ? '—' : medianDays.toFixed(1)} | ${funnel.ledgerRows} |`;
+
 const docs = scanDocs();
 const surf = scanSurface();
 const row = `| ${month} | ${docs.files}（活跃 ${docs.active} / 终态 ${docs.terminal}） | ${kb(docs.bytes)} | ${docs.withModule}/${docs.files} | ${kb(surf.total)}（峰值 ${surf.peak ? `${surf.peak.pct.toFixed(1)}% ${surf.peak.label}` : '—'}） | ${kb(idxBytes)}（${Number.isNaN(idxActive) ? '—' : idxActive} 行） |`;
@@ -179,9 +232,12 @@ for (const [t, v] of Object.entries(docs.perType)) console.log(`    ${t.padEnd(1
 console.log(`  索引：workflow/INDEX.md ${kb(idxBytes)}（活跃 ${Number.isNaN(idxActive) ? '—' : idxActive} 行）`);
 for (const e of surf.entries) console.log(`    ${e.label.padEnd(44)} ${String(e.max).padStart(6)} / ${String(e.lim).padStart(6)} B（${e.pct.toFixed(1)}%）`);
 console.log(`  常驻面合计：${kb(surf.total)}`);
+console.log(`  闭环漏斗：收口 ${funnel.closed}（完整链 ${funnel.full} = 一次通过 ${funnel.once} + 返工 ${funnel.rework}；协议前 ${funnel.legacy}）｜中位周期 ${medianDays === null ? '—' : `${medianDays.toFixed(1)} 天`}｜台账行 ${funnel.ledgerRows}`);
+for (const it of funnel.items) console.log(`    ${String(it.doc).padEnd(58)} ${it.kind.padEnd(7)} ${it.days} 天`);
+if (funnel.items.length) console.log('  ℹ️ 机器口径可与 workflow/delegations.md 自做表的人工自报交叉对照（差异即信号，不对账）');
 console.log(`  ${DRY ? '（--dry-run，未写盘）' : ''}`);
 
-if (DRY) { console.log(`\n将写入行：\n${row}`); process.exit(0); }
+if (DRY) { console.log(`\n将写入行：\n${row}\n${funnelRow}`); process.exit(0); }
 
 // ---- 组装：GENERATED 区内的月表按月份键 upsert（同月重跑覆盖，行序按月升序）----
 const HEADER = `# workflow 规模与规则面月度快照
@@ -193,17 +249,31 @@ const TABLE_HEAD = [
   '| 月份 | 文档（活跃/终态） | 文档字节 | 模块已填/总 | 常驻面字节（预算峰值） | INDEX（活跃行） |',
   '|---|---|---|---|---|---|',
 ];
+// 漏斗表头（第二表；口径定义式单源 = workflow/specs/2026-10-02-ledger-funnel-metrics.md）
+const FUNNEL_HEAD = [
+  '## 闭环漏斗（机器口径，源：.agents/confirmations.jsonl——定义式见 specs/2026-10-02-ledger-funnel-metrics.md）',
+  '',
+  '| 月份 | 收口 | 完整链 | 协议前 | 一次通过 | 返工件 | 中位周期(天) | 台账行数 |',
+  '|---|---|---|---|---|---|---|---|',
+];
 const existing = fs.existsSync(METRICS_P) ? fs.readFileSync(METRICS_P, 'utf8') : '';
 let rows = [];
+let funnelRows = [];
 if (existing.includes(BEGIN) && existing.includes(END)) {
-  rows = existing.slice(existing.indexOf(BEGIN), existing.indexOf(END))
-    .split(/\r?\n/)
-    .filter((l) => /^\|\s*\d{4}-\d{2}\s*\|/.test(l));
+  const section = existing.slice(existing.indexOf(BEGIN), existing.indexOf(END));
+  const marker = FUNNEL_HEAD[0];
+  const bodyPart = section.includes(marker) ? section.slice(0, section.indexOf(marker)) : section;
+  const funnelPart = section.includes(marker) ? section.slice(section.indexOf(marker)) : '';
+  rows = bodyPart.split(/\r?\n/).filter((l) => /^\|\s*\d{4}-\d{2}\s*\|/.test(l));
+  funnelRows = funnelPart.split(/\r?\n/).filter((l) => /^\|\s*\d{4}-\d{2}\s*\|/.test(l));
 }
 rows = rows.filter((l) => !l.startsWith(`| ${month} `));
 rows.push(row);
 rows.sort((a, b) => a.slice(2, 9).localeCompare(b.slice(2, 9)));
-const inner = `${BEGIN}\n\n${[...TABLE_HEAD, ...rows].join('\n')}\n\n${END}`;
+funnelRows = funnelRows.filter((l) => !l.startsWith(`| ${month} `));
+funnelRows.push(funnelRow);
+funnelRows.sort((a, b) => a.slice(2, 9).localeCompare(b.slice(2, 9)));
+const inner = `${BEGIN}\n\n${[...TABLE_HEAD, ...rows].join('\n')}\n\n${[...FUNNEL_HEAD, ...funnelRows].join('\n')}\n\n${END}`;
 let out;
 if (existing.includes(BEGIN) && existing.includes(END)) {
   out = existing.slice(0, existing.indexOf(BEGIN)) + inner + existing.slice(existing.indexOf(END) + END.length);