agentic-flow-kit 0.9.1 → 0.9.4

package/templates/_agents/scripts/check-ledger-invariant.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+// check-ledger-invariant — confirmations.jsonl 提交不变量（2026-10-02 ledger-ci-invariant）
+// 目的：把「台账本地可写」的伪造面从事后对质级升为机器可检出级（能力评审审计维度扣分项）。
+// 台账不可变原则：confirmations.jsonl 历史行禁删改——修正只能走追加补偿行（README 硬规则 6）。
+//
+// 模式：
+//   历史全扫（缺省，CI 机器门）：遍历台账全部提交历史（时间正序），每次变更必须以旧 blob 为
+//     **逐字节前缀**（允许纯追加；禁止删行/改行/重排）；再对最终树做行级校验（五项，见下）。
+//     blob 读取走 git 对象库（入库 LF 归一口径），不受工作树 autocrlf 影响。
+//   --staged（pre-commit 前置）：暂存 blob 必须以 HEAD blob 为逐字节前缀——提交时刻即拦重写。
+//
+// 行级校验（终树，五项）：
+//   ① ts 为 ISO 字符串且全表非降序（追加时序单调）
+//   ② fingerprint 为 64 位 hex
+//   ③ source=chat-delegated 行必有非空 quote（原话对质面）
+//   ④ doc 匹配 workflow/(intents|specs|plans|incidents)/[^/]+.md 且当前树存在
+//   ⑤ stage ∈ 合法跳转终态集（approved/done/fixed/closed/superseded/cancelled）
+//
+// 静默条件：台账不存在 / 零提交历史（装户、新仓）/ --staged 且暂存未触台账或无 HEAD 版本。
+// 已知边界：git log --follow 未用——台账自创建无重命名（单一路径取史）；克隆深度不足时仅扫可得
+//   历史（CI 侧 fetch-depth:0 兜全史，深度不足会告警声明边界，fail-open 于深度、fail-closed 于内容）。
+// 用法：node check-ledger-invariant.mjs [--root <仓库根>] [--staged]
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const argv = process.argv.slice(2);
+const argOf = (k) => {
+  const i = argv.indexOf(k);
+  return i >= 0 && i + 1 < argv.length ? argv[i + 1] : '';
+};
+const staged = argv.includes('--staged');
+const ROOT = argOf('--root') || (staged ? process.cwd() : execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).trim());
+const REL = '.agents/confirmations.jsonl';
+const FILE = path.join(ROOT, REL);
+const VALID_STAGES = new Set(['approved', 'done', 'fixed', 'closed', 'superseded', 'cancelled',
+  'revert-draft', 'revert-open']); // 回退注记行（check-loop :822 认可；fingerprint 恒 n/a）
+
+const git = (args, opts = {}) => execFileSync('git', args, { cwd: ROOT, encoding: 'buffer', maxBuffer: 64 * 1024 * 1024, ...opts });
+const gitText = (args) => execFileSync('git', args, { cwd: ROOT, encoding: 'utf8' });
+const blobOf = (ref) => git(['show', ref]); // ref 必须为完整对象引用（<sha>:<path> / HEAD:<path> / :<path>）
+
+const problems = [];
+const fail = (msg) => { console.error(msg); process.exit(1); };
+
+// ---- --staged：暂存 blob ⊇ HEAD blob ----
+if (staged) {
+  const stagedHit = gitText(['-c', 'core.quotepath=off', 'diff', '--cached', '--name-only']).split(/\r?\n/).includes(REL);
+  if (!stagedHit) process.exit(0);
+  const headExists = (() => { try { gitText(['rev-parse', '--verify', '--quiet', `HEAD:${REL}`]); return true; } catch { return false; } })();
+  if (!headExists) process.exit(0); // 首次入库：无 HEAD 基线，历史全扫后续覆盖
+  let head, cur;
+  try {
+    head = blobOf(`HEAD:${REL}`);
+    cur = blobOf(`:${REL}`); // 暂存区
+  } catch {
+    process.exit(0); // 对象读取异常（如极端并发）交由 CI 全扫兜底
+  }
+  if (!cur.subarray(0, head.length).equals(head)) {
+    let off = 0;
+    while (off < Math.min(head.length, cur.length) && head[off] === cur[off]) off++;
+    problems.push(`- [台账重写] 暂存内容不是 HEAD 的前缀扩展（首异偏移 ${off}，HEAD ${head.length}B → 暂存 ${cur.length}B）`);
+    console.error('台账不可变（--staged）— BLOCK:\n' + problems.join('\n'));
+    console.error('  修法：台账历史行禁删改——误写走追加补偿行（node .agents/scripts/confirm-doc.mjs ...）；确需撤销历史提交请 git revert 后重新追加');
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// ---- 历史全扫（缺省）----
+if (!fs.existsSync(FILE)) process.exit(0); // 装户/新仓无台账面
+let shas;
+try {
+  shas = gitText(['log', '--format=%H', '--reverse', '--', REL]).split(/\s+/).filter(Boolean);
+} catch {
+  process.exit(0); // 非仓库或文件未入库（测试夹具）
+}
+if (!shas.length) process.exit(0);
+
+let prev = null;
+let prevSha = null;
+for (const sha of shas) {
+  let cur;
+  // 删除提交不是静默边界（复核 P2 收口）：台账在 append-only 世界里永不应删除——任一历史提交删除
+  // 台账即 hard fail（否则「删除→次提交重加」会把重加 blob 当新基线绕过前缀判据）。
+  try { cur = blobOf(`${sha}:${REL}`); } catch {
+    problems.push(`- [台账删除] ${sha.slice(0, 10)}：该提交删除了 confirmations.jsonl（append-only 世界禁删文件）`);
+    prev = null; // 后续重加无基线可比，仅受行级校验约束
+    continue;
+  }
+  if (prev !== null && !cur.subarray(0, prev.length).equals(prev)) {
+    let off = 0;
+    while (off < Math.min(prev.length, cur.length) && prev[off] === cur[off]) off++;
+    const removed = prev.length > cur.length;
+    problems.push(`- [前缀破坏] ${sha.slice(0, 10)}（前承 ${prevSha.slice(0, 10)}）：历史内容被${removed ? `删减 ${prev.length - cur.length}B` : `改写（首异偏移 ${off}，旧 ${prev.length}B → 新 ${cur.length}B）`}`);
+  }
+  prev = cur;
+  prevSha = sha;
+}
+
+// ---- 行级校验（终树）----
+let rows = [];
+try {
+  rows = fs.readFileSync(FILE, 'utf8').split(/\r?\n/).filter((l) => l.trim()).map((l) => { try { return JSON.parse(l); } catch { return null; } });
+} catch { /* 上面 existsSync 已兜 */ }
+let prevTs = '';
+rows.forEach((e, idx) => {
+  const at = `第 ${idx + 1} 行`;
+  if (!e || typeof e !== 'object') { problems.push(`- [行级] ${at}：非 JSON 对象行`); return; }
+  if (typeof e.ts !== 'string' || Number.isNaN(Date.parse(e.ts))) problems.push(`- [行级] ${at}：ts 非 ISO 字符串`);
+  else {
+    if (prevTs && e.ts < prevTs) problems.push(`- [行级] ${at}：ts ${e.ts} 早于前行 ${prevTs}（追加时序非单调）`);
+    prevTs = e.ts;
+  }
+  const isRevertNote = typeof e.stage === 'string' && e.stage.startsWith('revert-');
+  if (isRevertNote) {
+    if (e.fingerprint !== 'n/a') problems.push(`- [行级] ${at}：回退注记行 fingerprint 恒为「n/a」`);
+  } else if (typeof e.fingerprint !== 'string' || !/^[0-9a-f]{64}$/.test(e.fingerprint)) {
+    problems.push(`- [行级] ${at}：fingerprint 非 64 位 hex`);
+  }
+  if (e.source === 'chat-delegated' && !(typeof e.quote === 'string' && e.quote.trim())) problems.push(`- [行级] ${at}：chat-delegated 行缺非空 quote（原话对质面）`);
+  if (typeof e.doc !== 'string' || !/^workflow\/(intents|specs|plans|incidents)\/[^/]+\.md$/.test(e.doc)) {
+    problems.push(`- [行级] ${at}：doc 路径不在 workflow 四目录协议内`);
+  } else if (!fs.existsSync(path.join(ROOT, e.doc))) {
+    problems.push(`- [行级] ${at}：doc ${e.doc} 在当前树不存在`);
+  }
+  if (!VALID_STAGES.has(e.stage)) problems.push(`- [行级] ${at}：stage「${e.stage || '缺失'}」不在合法跳转终态集`);
+});
+
+if (problems.length) {
+  console.error(`台账不可变（历史全扫）— HARD-BLOCK:\n\n${problems.join('\n')}\n`);
+  console.error('  修法：台账历史行禁删改（append-only 前缀不变量）——误写只能追加补偿行；确需撤销历史提交请 git revert 后重新追加。篡改属审计事件，保留现场联系仓库所有者。');
+  process.exit(1);
+}
+process.exit(0);

package/templates/_agents/scripts/check-ledger-invariant.test.mjs

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+// check-ledger-invariant.test.mjs — 台账提交不变量 fixture 套件（2026-10-02 ledger-ci-invariant）
+// 真 git 仓注入：合法追加放行 / 六类篡改与行级违例检出 / --staged 双态 / 首次入库与空台账静默。
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPT = path.join(SCRIPT_DIR, 'check-ledger-invariant.mjs');
+
+let pass = 0;
+let fail = 0;
+const check = (desc, cond, detail = '') => {
+  if (cond) { pass++; console.log(`PASS  ${desc}`); }
+  else { fail++; console.log(`FAIL  ${desc}${detail ? '\n      ' + detail : ''}`); }
+};
+
+const HEX = 'a'.repeat(64);
+const row = (o = {}) => JSON.stringify({
+  ts: '2026-10-02T00:00:00.000Z', doc: 'workflow/intents/demo.md', stage: 'approved',
+  fingerprint: HEX, prev: 'draft', source: 'chat-delegated', quote: '确认', ...o,
+});
+
+const G = (root, args) => spawnSync('git', args, { cwd: root, encoding: 'utf8' });
+const commitAll = (root, msg) => { G(root, ['add', '-A']); G(root, ['-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-qm', msg]); };
+const run = (root, args = []) => {
+  const r = spawnSync(process.execPath, [SCRIPT, '--root', root, ...args], { encoding: 'utf8' });
+  return { code: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
+};
+
+// mkrepo：临时真仓（workflow/intents/demo.md 在树 + 台账首行已提交）
+const mkrepo = (firstRow = row()) => {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'ledger-inv-test-'));
+  fs.mkdirSync(path.join(d, 'workflow', 'intents'), { recursive: true });
+  fs.mkdirSync(path.join(d, '.agents'), { recursive: true });
+  fs.writeFileSync(path.join(d, 'workflow', 'intents', 'demo.md'), '---\n状态: approved\n级别: L1\n日期: 2026-10-02\n模块: pipeline\n---\n# I\n');
+  fs.writeFileSync(path.join(d, '.agents', 'confirmations.jsonl'), firstRow + '\n');
+  G(d, ['init', '-q']);
+  G(d, ['config', 'user.email', 't@t']);
+  G(d, ['config', 'user.name', 't']);
+  commitAll(d, 'base ledger');
+  return d;
+};
+const ledPath = (d) => path.join(d, '.agents', 'confirmations.jsonl');
+const append = (d, line) => fs.appendFileSync(ledPath(d), line + '\n');
+
+// S1：合法追加 ×2 → 历史全扫过
+{
+  const d = mkrepo();
+  append(d, row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done' }));
+  commitAll(d, 'append 2nd');
+  const r = run(d);
+  check('S1 合法追加两次 → 历史全扫 exit 0', r.code === 0, r.out);
+}
+// S2：删历史行 → 前缀破坏拦
+{
+  const d = mkrepo();
+  append(d, row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done' }));
+  commitAll(d, 'append');
+  fs.writeFileSync(ledPath(d), row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done' }) + '\n'); // 删首行
+  commitAll(d, 'drop first row');
+  const r = run(d);
+  check('S2 删历史行 → 前缀破坏 exit 1', r.code === 1 && r.out.includes('前缀破坏') && r.out.includes('删减'), r.out);
+}
+// S3：改历史行内容 → 拦
+{
+  const d = mkrepo();
+  append(d, row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done' }));
+  commitAll(d, 'append');
+  const lines = fs.readFileSync(ledPath(d), 'utf8').split('\n').filter(Boolean);
+  lines[0] = lines[0].replace('确认', '改成别的'); // 改首行 quote
+  fs.writeFileSync(ledPath(d), lines.join('\n') + '\n');
+  commitAll(d, 'rewrite first line');
+  const r = run(d);
+  check('S3 改历史行 → 前缀破坏 exit 1（首异偏移）', r.code === 1 && r.out.includes('改写') && r.out.includes('首异偏移'), r.out);
+}
+// S4：非前缀改写（截断+异内容）→ 拦
+{
+  const d = mkrepo();
+  append(d, row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done' }));
+  commitAll(d, 'append');
+  fs.writeFileSync(ledPath(d), row({ ts: '2027-01-01T00:00:00.000Z', quote: '另起炉灶' }) + '\n');
+  commitAll(d, 'replace all');
+  const r = run(d);
+  check('S4 非前缀整体改写 → exit 1', r.code === 1 && r.out.includes('前缀破坏'), r.out);
+}
+// S5：ts 乱序追加 → 行级拦
+{
+  const d = mkrepo();
+  append(d, row({ ts: '2026-10-01T00:00:00.000Z', stage: 'done' })); // 早于首行
+  commitAll(d, 'append out-of-order');
+  const r = run(d);
+  check('S5 ts 非单调 → 行级 exit 1', r.code === 1 && r.out.includes('非单调'), r.out);
+}
+// S6：伪指纹（非 64-hex）→ 行级拦
+{
+  const d = mkrepo();
+  append(d, row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done', fingerprint: 'zzz' }));
+  commitAll(d, 'append bad fp');
+  const r = run(d);
+  check('S6 fingerprint 非 64-hex → 行级 exit 1', r.code === 1 && r.out.includes('64 位 hex'), r.out);
+}
+// S7：chat-delegated 空 quote → 行级拦
+{
+  const d = mkrepo();
+  append(d, row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done', quote: '' }));
+  commitAll(d, 'append empty quote');
+  const r = run(d);
+  check('S7 chat-delegated 空 quote → 行级 exit 1', r.code === 1 && r.out.includes('quote'), r.out);
+}
+// S8：doc 路径在树中不存在 → 行级拦
+{
+  const d = mkrepo();
+  append(d, row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done', doc: 'workflow/intents/ghost.md' }));
+  commitAll(d, 'append ghost doc');
+  const r = run(d);
+  check('S8 doc 当前树不存在 → 行级 exit 1', r.code === 1 && r.out.includes('不存在'), r.out);
+}
+// S9：--staged 合法追加 → 过
+{
+  const d = mkrepo();
+  append(d, row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done' }));
+  G(d, ['add', '-A']);
+  const r = run(d, ['--staged']);
+  check('S9 --staged 合法追加 → exit 0', r.code === 0, r.out);
+}
+// S10：--staged 删历史行 → 拦
+{
+  const d = mkrepo();
+  append(d, row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done' }));
+  commitAll(d, 'append');
+  fs.writeFileSync(ledPath(d), row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done' }) + '\n');
+  G(d, ['add', '-A']);
+  const r = run(d, ['--staged']);
+  check('S10 --staged 删历史行 → exit 1', r.code === 1 && r.out.includes('台账重写'), r.out);
+}
+// S11：首次入库（无 HEAD 基线）与空台账 → 静默过
+{
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'ledger-inv-fresh-'));
+  fs.mkdirSync(path.join(d, '.agents'), { recursive: true });
+  G(d, ['init', '-q']);
+  G(d, ['config', 'user.email', 't@t']);
+  G(d, ['config', 'user.name', 't']);
+  fs.writeFileSync(ledPath(d), row() + '\n');
+  G(d, ['add', '-A']);
+  const rs = run(d, ['--staged']);
+  const rh = run(d);
+  check('S11 首次入库（staged 无 HEAD 基线 / 历史零提交）均静默过', rs.code === 0 && rh.code === 0, `staged=${rs.out} hist=${rh.out}`);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+// S12：回退注记行（revert-draft / fingerprint n/a）合法放行
+{
+  const d = mkrepo(row({ ts: '2026-10-02T00:00:00.000Z', stage: 'revert-draft', fingerprint: 'n/a', prev: 'approved' }));
+  const r = run(d);
+  check('S12 回退注记行（n/a 指纹）→ 历史全扫过', r.code === 0, r.out);
+}
+
+console.log(`\n${fail ? `❌ ${fail} failed` : '✅ all passed'}（${pass} passed）`);
+process.exit(fail ? 1 : 0);

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;
       }