agentic-flow-kit 0.9.1 → 0.9.4

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

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

@@ -70,8 +70,12 @@ const readMetrics = (root) => fs.readFileSync(path.join(root, 'workflow', 'metri
   run(root, ['--month', '2026-09']);
   run(root, ['--month', '2026-09']);
   let md = readMetrics(root);
-  const n09 = (md.match(/^\| 2026-09 \|/gm) || []).length;
-  check('场景 2：同月重跑只保留一行', n09 === 1, `${n09} 行\n${md}`);
+  const funnelMark = '## 闭环漏斗';
+  const bodyPart = md.slice(0, md.includes(funnelMark) ? md.indexOf(funnelMark) : undefined);
+  const n09 = (bodyPart.match(/^\| 2026-09 \|/gm) || []).length;
+  const n09f = ((md.includes(funnelMark) ? md.slice(md.indexOf(funnelMark)) : '').match(/^\| 2026-09 \|/gm) || []).length;
+  check('场景 2：同月重跑只保留一行（体量表分段计数）', n09 === 1, `${n09} 行\n${md}`);
+  check('场景 2：漏斗表同月 upsert 不重复', n09f === 1, `${n09f} 行\n${md}`);
   run(root, ['--month', '2026-08']);
   md = readMetrics(root);
   const i08 = md.indexOf('| 2026-08 |');
@@ -114,6 +118,104 @@ const readMetrics = (root) => fs.readFileSync(path.join(root, 'workflow', 'metri
   fs.rmSync(root, { recursive: true, force: true });
 }
 
+// ---- 闭环漏斗（2026-10-02 ledger-funnel-metrics；口径定义式 = specs/2026-10-02-ledger-funnel-metrics.md）----
+const LROW = (o = {}) => JSON.stringify({
+  ts: '2026-10-02T00:00:00.000Z', doc: 'workflow/intents/demo.md', stage: 'approved',
+  fingerprint: 'b'.repeat(64), prev: 'draft', source: 'chat-delegated', quote: '确认', ...o,
+});
+// mkfixLedger：在 mkfix 基础上写台账（LROW 已是 JSON 字符串，直接 join——勿再 stringify 双重编码）
+const mkfixLedger = (lines) => {
+  const root = mkfix();
+  fs.writeFileSync(path.join(root, '.agents', 'confirmations.jsonl'), lines.join('\n') + '\n', 'utf8');
+  return root;
+};
+{
+  // L1：一次通过（approved→done 同月）→ 收口 1 / 完整链 1 / 一次通过 1 / 周期 1.0 天
+  const root = mkfixLedger([
+    LROW({ ts: '2026-10-01T00:00:00.000Z' }),
+    LROW({ ts: '2026-10-02T00:00:00.000Z', stage: 'done', prev: 'approved' }),
+  ]);
+  const r = run(root, ['--month', '2026-10']);
+  const md = readMetrics(root);
+  check('漏斗 L1 一次通过：| 2026-10 | 1 | 1 | 0 | 1 | 0 | 1.0 | 2 |',
+    r.status === 0 && /\| 2026-10 \| 1 \| 1 \| 0 \| 1 \| 0 \| 1\.0 \| 2 \|/.test(md), `${r.stdout}${md}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+{
+  // L2：revert 行（回退后重走）→ 返工件
+  const root = mkfixLedger([
+    LROW({ ts: '2026-10-01T00:00:00.000Z', stage: 'revert-draft', fingerprint: 'n/a', prev: 'approved' }),
+    LROW({ ts: '2026-10-02T00:00:00.000Z' }),
+    LROW({ ts: '2026-10-03T00:00:00.000Z', stage: 'done', prev: 'approved' }),
+  ]);
+  const r = run(root, ['--month', '2026-10']);
+  const md = readMetrics(root);
+  check('漏斗 L2 revert 行 → 返工件 1（周期按首 approved 起算 1.0 天）',
+    r.status === 0 && /\| 2026-10 \| 1 \| 1 \| 0 \| 0 \| 1 \| 1\.0 \| 3 \|/.test(md), `${r.stdout}${md}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+{
+  // L3：重确认（两次 approved）→ 返工件
+  const root = mkfixLedger([
+    LROW({ ts: '2026-10-01T00:00:00.000Z' }),
+    LROW({ ts: '2026-10-02T00:00:00.000Z', quote: '重确认' }),
+    LROW({ ts: '2026-10-03T00:00:00.000Z', stage: 'done', prev: 'approved' }),
+  ]);
+  const r = run(root, ['--month', '2026-10']);
+  const md = readMetrics(root);
+  check('漏斗 L3 两次 approved → 返工件 1',
+    r.status === 0 && /\| 2026-10 \| 1 \| 1 \| 0 \| 0 \| 1 \| 2\.0 \| 3 \|/.test(md), `${r.stdout}${md}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+{
+  // L4：协议前（首行即终态，无 approved）→ 协议前 1（不计一次通过分母）
+  const root = mkfixLedger([
+    LROW({ ts: '2026-10-02T00:00:00.000Z', stage: 'done', prev: 'approved' }),
+  ]);
+  const r = run(root, ['--month', '2026-10']);
+  const md = readMetrics(root);
+  check('漏斗 L4 协议前 → | 1 | 0 | 1 | 0 | 0 |',
+    r.status === 0 && /\| 2026-10 \| 1 \| 0 \| 1 \| 0 \| 0 \| 0\.0 \| 1 \|/.test(md), `${r.stdout}${md}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+{
+  // L5：incident 两跳（fixed→closed = incident 确认链，复核 P2-3 收口）→ 完整链一次通过
+  const root = mkfixLedger([
+    LROW({ ts: '2026-10-01T00:00:00.000Z', doc: 'workflow/incidents/inc.md', stage: 'fixed' }),
+    LROW({ ts: '2026-10-02T00:00:00.000Z', doc: 'workflow/incidents/inc.md', stage: 'closed', prev: 'fixed' }),
+  ]);
+  const r = run(root, ['--month', '2026-10']);
+  const md = readMetrics(root);
+  check('漏斗 L5 incident 两跳确认链 → 完整链 1 / 一次通过 1 / 周期 1.0',
+    r.status === 0 && /\| 2026-10 \| 1 \| 1 \| 0 \| 1 \| 0 \| 1\.0 \|/.test(md), `${r.stdout}${md}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+{
+  // L7：incident 单行 closed（存量补关，无确认链）→ 协议前
+  const root = mkfixLedger([
+    LROW({ ts: '2026-10-02T00:00:00.000Z', doc: 'workflow/incidents/old.md', stage: 'closed', prev: 'fixed' }),
+  ]);
+  const r = run(root, ['--month', '2026-10']);
+  const md = readMetrics(root);
+  check('漏斗 L7 incident 单行 closed → 协议前 1',
+    r.status === 0 && /\| 2026-10 \| 1 \| 0 \| 1 \| 0 \| 0 \|/.test(md), `${r.stdout}${md}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+{
+  // L6：跨月收口（9 月 approved、10 月 done）→ 归桶 10 月；9 月只计台账行
+  const root = mkfixLedger([
+    LROW({ ts: '2026-09-30T00:00:00.000Z' }),
+    LROW({ ts: '2026-10-02T00:00:00.000Z', stage: 'done', prev: 'approved' }),
+  ]);
+  const rSep = run(root, ['--month', '2026-09']);
+  const rOct = run(root, ['--month', '2026-10']);
+  const md = readMetrics(root);
+  check('漏斗 L6 跨月收口归桶 10 月（9 月零收口 + 台账行 1）',
+    rSep.status === 0 && rOct.status === 0 && /\| 2026-09 \| 0 \| 0 \| 0 \| 0 \| 0 \| — \| 1 \|/.test(md)
+    && /\| 2026-10 \| 1 \| 1 \| 0 \| 1 \| 0 \| 2\.0 \| 1 \|/.test(md), `${rSep.stdout}${rOct.stdout}${md}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 if (fail) {
   console.log(`\n${USAGE}`);

package/templates/_agents/scripts/policy.mjs

@@ -23,6 +23,7 @@ export const POLICIES = {
     bindingTs: '2026-09-28',
     check17UnclosedAfter: '0.8.0',
     stageGateSince: '2026-09-29', // 检查 19 逐阶段审计的生效日（2026-09-30 stage-gate-machine）；锚 = 台账 ts 的 UTC 日期（复核 P2-3：本批 ts 2026-09-29T17:33Z 落在受审范围，顺序合规故静默）；v1 无此键 → 该检查整体跳过
+    riskLevelSince: '2026-10-01', // intent risk_level 双字段协议生效日（2026-10-01 hybrid-governance 落地 fill-intent 双写；2026-10-02 caliber-convergence 方案 C 引入消费）——此日前建档的 intent 无该字段不判 suspect；v1 无此键 → 双字段协议视为从未生效（单字段判）
   },
 };
 

package/templates/_agents/scripts/pre-push.test.mjs

@@ -12,7 +12,12 @@ import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-const PRE_PUSH = path.join(SCRIPT_DIR, '..', '..', '_githooks', 'pre-push');
+// 钩子双布局探测：templates 布局（../../_githooks）与装户布局（../../.githooks）——本测试随 sync
+// 落到 .agents/scripts 后 ../../_githooks 不存在（装户钩子在仓库根 .githooks/），2026-10-02 ci-red-batch
+const PRE_PUSH = [
+  path.join(SCRIPT_DIR, '..', '..', '_githooks', 'pre-push'),
+  path.join(SCRIPT_DIR, '..', '..', '.githooks', 'pre-push'),
+].find((p) => fs.existsSync(p));
 
 let pass = 0;
 let fail = 0;
@@ -31,6 +36,8 @@ const setup = () => {
   fs.mkdirSync(path.join(root, '.agents', 'scripts'), { recursive: true });
   // 挂载真实 pre-push（装户同款），stub 替换 check-loop 记录 argv
   fs.copyFileSync(PRE_PUSH, path.join(root, '.githooks', 'pre-push'));
+  // Linux：git 静默跳过不可执行钩子（推送照常成功、桩无记录）——挂载后必须设执行位；桩经 sh 调用无须 +x
+  fs.chmodSync(path.join(root, '.githooks', 'pre-push'), 0o755);
   fs.writeFileSync(path.join(root, '.agents', 'scripts', 'check-loop.sh'), '#!/bin/sh\necho "$@" >> .stub-args\nexit 0\n');
   fs.writeFileSync(path.join(root, 'a.txt'), 'a\n');
   git(root, ['init', '-q']);

package/templates/_agents/scripts/solidify-task.test.mjs

@@ -50,6 +50,9 @@ const ledgerLines = (root) => {
   const p = path.join(root, '.agents', 'confirmations.jsonl');
   return fs.existsSync(p) ? fs.readFileSync(p, 'utf8').split(/\n/).filter(Boolean) : [];
 };
+// 迁移目标名含当天日期前缀（solidify 以 toISOString 生成）——动态取值防跨天脆断
+const TODAY = new Date().toISOString().slice(0, 10);
+const migratedPath = (root) => path.join(root, 'workflow', 'intents', `${TODAY}-demo-task.md`);
 
 // T1：默认只迁移不落账
 {
@@ -58,7 +61,7 @@ const ledgerLines = (root) => {
   const r = run(d, ['--topic', 'demo', '--root', d]);
   check('T1 默认迁移成功 exit 0', r.code === 0, r.out);
   check('T1 草稿已迁移到 intents 且日期前缀正确',
-    fs.existsSync(path.join(d, 'workflow', 'intents', '2026-10-01-demo-task.md')), '');
+    fs.existsSync(migratedPath(d)), '');
   check('T1 零台账新增（无确认来源绝不落账）', ledgerLines(d).length === 0, JSON.stringify(ledgerLines(d)));
   check('T1 输出含确认指引', r.out.includes('确认指引') && r.out.includes('--delegated'), r.out);
 }
@@ -73,7 +76,7 @@ const ledgerLines = (root) => {
   check('T2 quote 原样（脚本不编造话术）',
     lines[0].includes('"quote":"固化了可以"') && lines[0].includes('chat-delegated'), lines[0]);
   check('T2 目标文档状态已 approved',
-    fs.readFileSync(path.join(d, 'workflow', 'intents', '2026-10-01-demo-task.md'), 'utf8').includes('状态: approved'), '');
+    fs.readFileSync(migratedPath(d), 'utf8').includes('状态: approved'), '');
 }
 // T3：--auto 在 Strict（缺 trust-mode.json）下被拒 → 失败计数并 exit 1
 {

package/templates/_agents/scripts/stage-gates.mjs

@@ -119,7 +119,7 @@ export function entryConfirmed(root, base) {
   const intentAbs = path.join(root, intentRel);
   if (fs.existsSync(intentAbs)) {
     const r = judgeDoc(root, intentAbs, intentRel, ENTRY_STATUSES);
-    return { ...r, kind: 'intent', rel: intentRel, level: readFm(intentAbs, '级别'), risk: readFm(intentAbs, 'risk_level'), storageLegacy: entryStorageLegacy(root, intentAbs) };
+    return { ...r, kind: 'intent', rel: intentRel, level: readFm(intentAbs, '级别'), risk: readFm(intentAbs, 'risk_level'), date: readFm(intentAbs, '日期'), storageLegacy: entryStorageLegacy(root, intentAbs) };
   }
   const incRel = `workflow/incidents/${base}.md`;
   const incAbs = path.join(root, incRel);
@@ -143,15 +143,38 @@ export function specConfirmed(root, base) {
   return judgeDoc(root, abs, rel, ENTRY_STATUSES);
 }
 
+// laneOfEntry / laneOfDoc：泳道单源取法（2026-10-02 caliber-convergence 方案 C「分歧双严」）
+// risk_level 为 intent 专属协议字段（fill-intent 双写），生效锚 policy.riskLevelSince：
+//   级别非法/缺失 → suspect（fail-closed 就严）；
+//   日期 ≥ 锚（双字段协议期）：risk 合法且与级别一致 → 按值判 low/high，否则（缺失/非法/分歧）→ suspect；
+//   日期 < 锚（协议前存量）：两值俱在且分歧 → suspect，否则按级别单字段判（risk 缺席不惩罚——字段协议尚不存在）。
+// suspect 消费规则（双严）：红线类检查按 low 执行（拦红线）；豁免类门（起草豁免/--batch/--auto/加固门
+// lane/泳道豁免/逐阶段深度）按 high 执行（不豁免）。取代原三处并存语义（任一低即低 / 级别优先回落 / 仅级别）。
+export function laneOfEntry(level, risk, riskLevelSince, date) {
+  const L = /^L[0-3]$/.test(level || '') ? level : '';
+  if (!L) return 'suspect';
+  const R = /^L[0-3]$/.test(risk || '') ? risk : '';
+  const dualProtocol = !!riskLevelSince && /^\d{4}-\d{2}-\d{2}$/.test(date || '') && date >= riskLevelSince;
+  if (dualProtocol) return (R && R === L) ? ((L === 'L0' || L === 'L1') ? 'low' : 'high') : 'suspect';
+  if (R && R !== L) return 'suspect';
+  return (L === 'L0' || L === 'L1') ? 'low' : 'high';
+}
+
+// laneOfDoc：非 intent 件（spec/plan/incident——级别单字段协议）：合法按值判，非法 → suspect。
+export function laneOfDoc(level) {
+  if (!/^L[0-3]$/.test(level || '')) return 'suspect';
+  return (level === 'L0' || level === 'L1') ? 'low' : 'high';
+}
+
 // draftGateFor：起草门总判（kind = 'spec' | 'plan'，fill 工具与 confirm-doc 逐阶段门共用）
 export function draftGateFor(kind, root, base) {
   const entry = entryConfirmed(root, base);
   if (!entry.ok) {
-    // 探索泳道豁免（2026-09-30 hybrid-governance-explore-hardening，口径见头部注释）：L0/L1 draft intent
-    // 放行起草——「先动手后确认」；泳道取级别优先、缺失/非法回落 risk_level（与 fill-intent 双写兼容，
-    // 级别合法但为 L2/L3 时不回落——fail-closed 就严）。
-    const lane = /^L[0-3]$/.test(entry.level || '') ? entry.level : entry.risk;
-    if (entry.kind === 'intent' && entry.status === 'draft' && (lane === 'L0' || lane === 'L1')) {
+    // 探索泳道豁免（2026-09-30 hybrid-governance-explore-hardening）：L0/L1 draft intent 放行起草
+    // ——「先动手后确认」；泳道取法自 2026-10-02 caliber-convergence 起单源 laneOfEntry（方案 C 分歧
+    // 双严：suspect 不豁免——级别/risk_level 缺失、非法或分歧均按防御道走入口确认）。
+    const lane = laneOfEntry(entry.level, entry.risk, loadKitPolicy(root).riskLevelSince, entry.date);
+    if (entry.kind === 'intent' && entry.status === 'draft' && lane === 'low') {
       return { ok: true, entry, laneBypass: true };
     }
     return {

package/templates/_agents/scripts/trust-mode.test.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+// trust-mode.test.mjs — AI 自治信任等级 fixture 套件（2026-10-01 gate-script-test-coverage）
+// 覆盖：三级语义（Strict/Standard/Trusted 名称↔数值双轨）、缺文件 fail-closed 回落 Strict、
+// --enable/--disable/--status CLI 行为、非法 --level 拒绝、与 confirm-doc --auto 的端到端
+// （Strict 缺文件拒绝不落账 / Trusted 放行 source=ai-auto-trust-L2）。
+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 TRUST = path.join(SCRIPT_DIR, 'trust-mode.mjs');
+const CONFIRM = path.join(SCRIPT_DIR, 'confirm-doc.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 mkfix = () => {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'trust-test-'));
+  for (const s of ['intents', 'plans', 'specs', 'incidents']) {
+    fs.mkdirSync(path.join(d, 'workflow', s), { recursive: true });
+  }
+  fs.mkdirSync(path.join(d, '.agents'), { recursive: true });
+  fs.mkdirSync(path.join(d, '.zcode'), { recursive: true });
+  fs.writeFileSync(path.join(d, '.agents', 'workflow-enums.txt'),
+    ['doc.status.all=draft approved done superseded cancelled', 'doc.status.confirmed=approved done superseded cancelled',
+      'doc.status.active=draft approved', 'doc.status.terminal=done superseded cancelled', 'doc.status.abandoned=superseded cancelled',
+      'incident.status.all=open fixed closed', 'incident.status.active=open', 'level.all=L0 L1 L2 L3'].join('\n') + '\n');
+  fs.writeFileSync(path.join(d, '.agents', 'workflow-modules.txt'), '# modules\npipeline\nui\n');
+  return d;
+};
+const runTrust = (root, args) => {
+  const r = spawnSync(process.execPath, [TRUST, ...args], { cwd: root, encoding: 'utf8' });
+  return { code: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
+};
+const cfg = (root) => {
+  const p = path.join(root, '.agents', 'trust-mode.json');
+  return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : null;
+};
+const ledgerLines = (root) => {
+  const p = path.join(root, '.agents', 'confirmations.jsonl');
+  return fs.existsSync(p) ? fs.readFileSync(p, 'utf8').split(/\n/).filter(Boolean) : [];
+};
+const DRAFT = (level = 'L1') => `---\n状态: draft\n级别: ${level}\nrisk_level: ${level}\n日期: 2026-10-01\n模块: pipeline\n---\n# INTENT — demo\n`;
+
+// T1：缺文件 → fail-closed Strict 默认
+{
+  const d = mkfix();
+  const r = runTrust(d, ['--status']);
+  check('T1 缺文件 --status 输出 Strict/level0/enabled false', r.code === 0 && r.out.includes('"name": "Strict"') && r.out.includes('"level": 0') && r.out.includes('"enabled": false'), r.out);
+}
+// T2：三级语义映射正确
+{
+  check('T2 名称↔数值双轨（NAME_BY_LEVEL 内容）',
+    fs.readFileSync(TRUST, 'utf8').includes("NAME_BY_LEVEL = { 0: 'Strict', 1: 'Standard', 2: 'Trusted' }"), '');
+}
+// T3：--enable --level Trusted → 落盘 enabled true/level 2/name Trusted
+{
+  const d = mkfix();
+  const r = runTrust(d, ['--enable', '--level', 'Trusted']);
+  const c = cfg(d);
+  check('T3 --level Trusted 落盘正确', r.code === 0 && c && c.enabled === true && c.level === 2 && c.name === 'Trusted', JSON.stringify(c));
+}
+// T4：--enable --level 0（Strict 数字）→ 关闭
+{
+  const d = mkfix();
+  const r = runTrust(d, ['--enable', '--level', '0']);
+  const c = cfg(d);
+  check('T4 --level 0 → 关闭 Strict', r.code === 0 && c && c.enabled === false && c.level === 0 && c.name === 'Strict', JSON.stringify(c));
+}
+// T5：非法 --level → 拒绝 exit 1
+{
+  const d = mkfix();
+  const r = runTrust(d, ['--enable', '--level', 'Bogus']);
+  check('T5 非法 --level 拒绝 exit 1', r.code === 1 && r.out.includes('必须为'), r.out);
+}
+// T6：--disable → 关闭 Strict
+{
+  const d = mkfix();
+  runTrust(d, ['--enable', '--level', 'Trusted']);
+  const r = runTrust(d, ['--disable']);
+  const c = cfg(d);
+  check('T6 --disable 复位 Strict', r.code === 0 && c && c.enabled === false && c.level === 0 && c.name === 'Strict', JSON.stringify(c));
+}
+// T7 e2e：Strict（缺文件）下 confirm-doc --auto 拒绝不落账
+{
+  const d = mkfix();
+  fs.writeFileSync(path.join(d, 'workflow', 'intents', '2026-10-01-demo.md'), DRAFT('L1'));
+  const r = spawnSync(process.execPath, [CONFIRM, 'workflow/intents/2026-10-01-demo.md', '--root', d, '--auto'], { cwd: d, encoding: 'utf8' });
+  check('T7 Strict 下 --auto 拒绝且零台账', r.status !== 0 && ledgerLines(d).length === 0, `${r.stdout}${r.stderr}\n${ledgerLines(d).join('|')}`);
+}
+// T8 e2e：Trusted 下 confirm-doc --auto 放行 L1，台账 source=ai-auto-trust-L2
+{
+  const d = mkfix();
+  fs.writeFileSync(path.join(d, 'workflow', 'intents', '2026-10-01-demo.md'), DRAFT('L1'));
+  runTrust(d, ['--enable', '--level', 'Trusted']);
+  const r = spawnSync(process.execPath, [CONFIRM, 'workflow/intents/2026-10-01-demo.md', '--root', d, '--auto'], { cwd: d, encoding: 'utf8' });
+  const lines = ledgerLines(d);
+  check('T8 Trusted 下 --auto 放行并记 ai-auto-trust-L2',
+    r.status === 0 && lines.length === 1 && lines[0].includes('ai-auto-trust-L2') && lines[0].includes('"stage":"approved"'),
+    `${r.stdout}${r.stderr}\n${lines.join('|')}`);
+}
+
+console.log(`\n${fail ? `❌ ${fail} failed` : '✅ all passed'}（${pass} passed）`);
+process.exit(fail ? 1 : 0);

package/templates/_agents/scripts-test-exempt.txt

@@ -0,0 +1,10 @@
+# 引擎脚本测试覆盖豁免登记（单源：本文件——check-loop 检查 20 共读，经 sync 下发装副本）
+# 格式：<脚本名> | <豁免理由> | <覆盖证据（套件名；无自动化覆盖如实写「无」）>
+# 语义：登记 ≠ 免责——须写明理由与覆盖证据；无覆盖的登记是「工具/启动器豁免」，后续批次评估补测。
+# 新增引擎脚本默认必须带同名 .test.mjs（README 规范条目）；确属库件/工具才登记本文件。
+check-metric-claims.mjs | 经 check-loop.mjs 消费 | 由 check-loop.test.mjs 间接覆盖其调用路径
+ensure-board.mjs | 看板启动器（需真实端口/进程环境） | 无（工具豁免，后续批次评估补测）
+policy.mjs | 库件 | 被 check-loop.test.mjs 直接 import 覆盖
+stage-gates.mjs | 库件 | 被 check-loop.test.mjs 直接 import 覆盖（fill-*/confirm-doc.test 消费其行为）
+verify-wiki-consistency.mjs | wiki 一致性校验工具 | 无（工具豁免，后续批次评估补测）
+wiki-search.mjs | 检索库件 | 无（工具豁免，后续批次评估补测）

package/templates/_githooks/pre-commit

@@ -93,6 +93,18 @@ if [ -d templates/_agents ] && [ -f .agents/scripts/check-ledger.mjs ]; then
   fi
 fi
 
+# 确认台账不变量前置（--staged，2026-10-02 ledger-ci-invariant）：暂存的 confirmations.jsonl 必须
+# 是 HEAD 的逐字节前缀扩展（append-only）——本地提交时刻即拦「顺手重写台账」，CI 历史全扫兜底。
+# guard 旧装副本自然跳过；暂存未触台账静默。
+if [ -f .agents/scripts/check-ledger-invariant.mjs ] && command -v node >/dev/null 2>&1; then
+  if git -c core.quotepath=off diff --cached --name-only | grep -q '^\.agents/confirmations\.jsonl$'; then
+    if ! node .agents/scripts/check-ledger-invariant.mjs --staged; then
+      echo "pre-commit: 确认台账不变量未通过，提交已阻止——历史行禁删改（append-only），修正走追加补偿行" >&2
+      exit 1
+    fi
+  fi
+fi
+
 # 项目门禁挂载点：.agents/hooks/local-pre-commit（项目自建门禁/门禁模块接线处，存在即执行）
 if [ -f .agents/hooks/local-pre-commit ]; then
   run_gate "项目门禁（local-pre-commit）" .agents/hooks/local-pre-commit

package/templates/workflow/README.md

@@ -53,8 +53,9 @@
 3. **确认留痕**：approved / done / fixed / closed 须经 `confirm-doc.mjs`，指纹与台账一致。`--delegated` 原话仅限用户对话内明确确认的当次措辞——官方脚本/门禁不得自动代录或编造 quote（2026-10-01 v09-review-defects：solidify-task 曾自动伪造原话，已修复并纳入回归）。
 4. **敏感信息**：pre-commit 的 commit-check 扫描密钥。
 5. **双源与台账**：doctor 核对 managed / owned 的 sha；引擎改动改包源 `templates/` 再 `sync`。
+6. **台账不可变**（2026-10-02 ledger-ci-invariant）：`confirmations.jsonl` 历史行禁删改（append-only 前缀不变量，机器门 = CI 历史全扫 + pre-commit `--staged` 前置）；误写/修正只能**追加补偿行**，篡改历史属审计事件（`git revert` 整个提交后重新追加）。
 
-其余检查（占位符、引用、模块字段、常驻面预算、量化签名、阶段索引、适配器断线）只在 `audit` 不是 `false` 时出警告。
+其余检查（占位符、引用、模块字段、常驻面预算、量化签名、阶段索引、适配器断线、引擎脚本测试覆盖（检查 20，包源环境——新增引擎脚本默认必须带 `.test.mjs`，库件/工具须登记 `.agents/scripts-test-exempt.txt`，2026-10-01 gate-script-test-coverage））只在 `audit` 不是 `false` 时出警告。
 
 **发版草稿**：最近一次改动 `package.json` 的 `version` 的那次提交里，当时已经是 draft 或 approved 的 intent、spec、plan，若被扫描的树上仍是 draft 或 approved，则阻断。当时已是 draft 的不看版本锚。当时已是 approved 的，只在发版版本大于 `policy.mjs` 的 `check17UnclosedAfter` 时阻断；版本 1 没有该键。不带 `--rev` 时现在的状态读工作区，带 `--rev` 时读被推送的那棵树。那次提交之后新建的文件不在范围内。状态为 open 的 incident 不在此列。
 
@@ -63,7 +64,7 @@
 ## 闭环规则
 
 1. L1 以上新需求始于已确认的 intent；L1 以上修复始于已确认的 incident 草稿（作为 intent 等价入口）
-2. L2 / L3 变更必须先有与入口文档同名的 spec 确认通过（L3 加新会话独立复核），方可起草 plan；L1 用极简 plan——改动面 + 验证方式两节起步，多文件多步骤再加任务拆解/执行顺序。**逐阶段前置已机器强制**（2026-09-30 stage-gate-machine）：fill-spec / fill-plan / confirm-doc 校验入口与 spec 前置未过即拒；顺序审计 = check-loop 检查 19
+2. L2 / L3 变更必须先有与入口文档同名的 spec 确认通过（L3 加新会话独立复核），方可起草 plan；L1 用 Quick-Plan 极简三节——改动方案 / 约束与风险 / 验证计划起步（fill-plan.mjs 单源），多文件多步骤再加任务拆解/执行顺序。**逐阶段前置已机器强制**（2026-09-30 stage-gate-machine）：fill-spec / fill-plan / confirm-doc 校验入口与 spec 前置未过即拒；顺序审计 = check-loop 检查 19
 3. 实现产物必须通过静态门（构建 + 测试 + 项目门禁）
 4. 线上 / 实测缺陷回落到 `incidents/`，复盘三件套（新 intent、防复发验证、规范条目）缺一不可；**根因属「门禁缺位 / 规范未落地 / 系统性问题」时，即使结构性修复已完成也必须立新 intent** 追踪系统性改进，禁止以「修复已完成」为由绕过 intent 回路
 5. 关单在 test：逐条勾验入口文档「验收标准」并补证据后 intent → done（不依赖是否上 prod）。done 仍有未勾项会被 check-loop 拦（新建 intent hard-block）。上 prod 另走 deploy（tag / 回滚 / 观察）

package/templates/workflow/plans/_TEMPLATE.md

@@ -6,7 +6,7 @@
 # PLAN — <与入口文档同名主题>
 <!-- 与 intents/ 或 incidents/ 下同名入口文档配对；L2/L3 必须先有 ../specs/ 同名 spec 确认通过；AI 起草、用户对话内确认后开工 -->
 <!-- frontmatter 受限子集（2026-09-13）：状态∈draft/approved/done/superseded/cancelled（严格枚举，附注写备注键）；级别∈L0/L1/L2/L3；正文不再写状态/级别行 -->
-<!-- L1 极简形态（2026-09-13 瘦身，L1 默认）：单/少文件微改动只填「改动面」+「验证方式」两节——改动面逐条列改哪个文件做什么（判据细节直接写进条目），验证一行静态门 + 按需 UI 实测；任务拆解/执行顺序仅 L1 多文件多步骤时保留 -->
+<!-- L1 极简形态（Quick-Plan，与 fill-plan.mjs 单源一致）：单/少文件微改动只填「改动方案」+「约束与风险」+「验证计划」三节——改动方案逐条列改哪个文件做什么（判据细节直接写进条目），验证计划一行静态门 + 按需 UI 实测；任务拆解/执行顺序仅 L1 多文件多步骤时保留 -->
 
 对应入口：../intents/YYYY-MM-DD-<主题>.md 或 ../incidents/YYYY-MM-DD-<主题>.md（保留实际一项）
 对应 spec：../specs/YYYY-MM-DD-<主题>.md（L1 可省略）