agentic-flow-kit 0.9.0 → 0.9.4

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

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+// pre-push.test.mjs — 加固门目标分支判定 fixture 套件（2026-10-01 v09-review-defects）
+// 真仓端到端：临时仓库挂载真实 pre-push，.agents/scripts/check-loop.sh 以桩脚本记录 argv。
+// 断言三态 refspec：
+//   main→main                  → argv 含 --hardening（加固门）
+//   experiment/x→main         → argv 含 --hardening（修复回归：直推漏口）
+//   experiment/y→experiment/y → argv 不含 --hardening（advisory）
+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));
+// 钩子双布局探测：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;
+const check = (desc, cond, detail = '') => {
+  if (cond) { pass++; console.log(`PASS  ${desc}`); }
+  else { fail++; console.log(`FAIL  ${desc}${detail ? '\n      ' + detail : ''}`); }
+};
+
+const git = (cwd, args) => spawnSync('git', args, { cwd, encoding: 'utf8' });
+const run = (cwd, args) => spawnSync('git', args, { cwd, encoding: 'utf8' });
+
+const setup = () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'prepush-test-'));
+  const remote = path.join(root, 'remote.git');
+  fs.mkdirSync(path.join(root, '.githooks'), { recursive: true });
+  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']);
+  git(root, ['config', 'user.email', 't@t']);
+  git(root, ['config', 'user.name', 't']);
+  git(root, ['config', 'core.hooksPath', '.githooks']);
+  git(root, ['add', 'a.txt']);
+  git(root, ['commit', '-q', '-m', 'init']);
+  git(root, ['init', '-q', '--bare', remote]);
+  git(root, ['remote', 'add', 'origin', remote]);
+  return root;
+};
+const stubArgs = (root) => {
+  const p = path.join(root, '.stub-args');
+  return fs.existsSync(p) ? fs.readFileSync(p, 'utf8').split(/\n/).filter(Boolean) : [];
+};
+
+const root = setup();
+const w = (f, c) => fs.writeFileSync(path.join(root, f), c);
+
+// 1) main → main：应含 --hardening
+git(root, ['checkout', '-q', '-b', 'main']);
+let r = run(root, ['push', 'origin', 'HEAD:main']);
+check('main→main 推送成功', r.status === 0, `${r.stdout}${r.stderr}`);
+check('main→main argv 含 --hardening', (stubArgs(root)[0] || '').includes('--hardening'), stubArgs(root).join('|'));
+
+// 2) experiment/x → main（回归漏口）：本地分支在 experiment，目标 main → 必须含 --hardening
+git(root, ['checkout', '-q', '-b', 'experiment/x']);
+w('b.txt', 'b\n');
+git(root, ['add', 'b.txt']);
+git(root, ['commit', '-q', '-m', 'x']);
+r = run(root, ['push', 'origin', 'HEAD:main']);
+check('experiment/x→main 推送成功', r.status === 0, `${r.stdout}${r.stderr}`);
+check('experiment/x→main argv 含 --hardening（直推漏口修复）', (stubArgs(root)[1] || '').includes('--hardening'), stubArgs(root).join('|'));
+
+// 3) experiment/y → experiment/y：目标在探索泳道 → 不含 --hardening
+git(root, ['fetch', '-q', 'origin']);
+git(root, ['branch', 'experiment/y', 'origin/main']);
+git(root, ['checkout', '-q', 'experiment/y']);
+w('c.txt', 'c\n');
+git(root, ['add', 'c.txt']);
+git(root, ['commit', '-q', '-m', 'y']);
+r = run(root, ['push', 'origin', 'HEAD:experiment/y']);
+check('experiment→experiment 推送成功', r.status === 0, `${r.stdout}${r.stderr}`);
+const line3 = stubArgs(root)[2] || '';
+check('experiment→experiment argv 不含 --hardening', !line3.includes('--hardening'), stubArgs(root).join('|'));
+
+console.log(`\n${fail ? `❌ ${fail} failed` : '✅ all passed'}（${pass} passed）`);
+process.exit(fail ? 1 : 0);

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

@@ -1,101 +1,107 @@
 #!/usr/bin/env node
-// solidify-task: 将 L1 液态草稿一次性固化为正式 workflow 文档（迁移 + 批量确认 + 索引更新）
-// 用法：node .agents/scripts/solidify-task.mjs --topic "主题" [--root <仓库根>]
+// solidify-task: 将 L1 液态草稿固化为正式 workflow 文档（迁移 + 可选确认 + 索引更新）
+// 用法：
+//   node .agents/scripts/solidify-task.mjs --topic <主题> [--root <仓库根>]
+//       # 只迁移 + 更新索引，绝不写确认台账；末尾打印确认指引
+//   node .agents/scripts/solidify-task.mjs --topic <主题> --delegated "<用户原话>"
+//       # 迁移后，以调用方显式传入的用户原话逐份 confirm-doc --delegated（quote 原样转发）
+//   node .agents/scripts/solidify-task.mjs --topic <主题> --auto
+//       # 迁移后，逐份 confirm-doc --auto（trust-mode=Trusted 才放行；Strict 下被拒并计数失败）
+// 确认门契约（incidents/2026-10-01-v09-review-defects）：--delegated 的 quote 必须来自用户在对话内的
+//   明确原话，由调用方显式传入——本脚本永不编造用户话术。无确认来源时只迁移不落账，末尾打印指引。
 import fs from 'node:fs';
 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 ROOT = process.argv.includes('--root') ? 
-  process.argv[process.argv.indexOf('--root') + 1] : 
-  process.cwd();
-const DRAFTS_DIR = path.join(ROOT, '.zcode', 'drafts');
-const WF_ROOT = path.join(ROOT, 'workflow');
 
-function fail(msg) { console.error('❌ ' + msg); process.exit(1); }
+function fail(msg) {
+  console.error(`❌ ${msg}`);
+  process.exit(1);
+}
 
 function parseArgs() {
   const topicIdx = process.argv.indexOf('--topic');
-  if (topicIdx === -1 || !process.argv[topicIdx + 1]) {
-    console.error('用法: node .agents/scripts/solidify-task.mjs --topic "主题"');
-    process.exit(1);
-  }
-  return process.argv[topicIdx + 1];
+  const topic = topicIdx !== -1 ? process.argv[topicIdx + 1] : '';
+  if (!topic) fail('用法: node .agents/scripts/solidify-task.mjs --topic "主题" [--root <仓库根>] [--delegated "<用户原话>" | --auto]');
+  let root = process.cwd();
+  const rootIdx = process.argv.indexOf('--root');
+  if (rootIdx !== -1 && process.argv[rootIdx + 1]) root = process.argv[rootIdx + 1];
+  const delegatedIdx = process.argv.indexOf('--delegated');
+  const delegated = delegatedIdx !== -1 ? String(process.argv[delegatedIdx + 1] ?? '') : '';
+  const auto = process.argv.includes('--auto');
+  if (delegated && auto) fail('--delegated 与 --auto 互斥，只能选其一');
+  return { topic, root, delegated, auto };
 }
 
-async function run() {
-  const topic = parseArgs();
-  console.log(`🚀 开始固化 L1 任务: ${topic}...`);
+const classify = (content) => {
+  if (content.includes('# INTENT')) return 'intents';
+  if (content.includes('# PLAN')) return 'plans';
+  if (content.includes('# SPEC')) return 'specs';
+  if (content.includes('# INCIDENT')) return 'incidents';
+  return null;
+};
 
-  if (!fs.existsSync(DRAFTS_DIR)) fail('草稿目录 .zcode/drafts/ 不存在');
-
-  // 1. 搜寻草稿
-  const files = fs.readdirSync(DRAFTS_DIR).filter(f => f.includes(topic) && f.endsWith('.md'));
-  if (!files.length) fail(`在 ${DRAFTS_DIR} 中未找到主题为 ${topic} 的草稿文件`);
+function run() {
+  const { topic, root, delegated, auto } = parseArgs();
+  const draftsDir = path.join(root, '.zcode', 'drafts');
+  if (!fs.existsSync(draftsDir)) fail(`草稿目录 ${draftsDir} 不存在`);
+  const files = fs.readdirSync(draftsDir).filter((f) => f.includes(topic) && f.endsWith('.md'));
+  if (!files.length) fail(`在 ${draftsDir} 中未找到主题为 ${topic} 的草稿文件`);
 
   const today = new Date().toISOString().slice(0, 10);
   const solidified = [];
-
-  // 2. 迁移并规范化命名
   for (const file of files) {
-    const content = fs.readFileSync(path.join(DRAFTS_DIR, file), 'utf8');
-    let targetDir = '';
-    
-    // 简单启发式判定类型
-    if (content.includes('# INTENT')) targetDir = 'intents';
-    else if (content.includes('# PLAN')) targetDir = 'plans';
-    else if (content.includes('# SPEC')) targetDir = 'specs';
-    else if (content.includes('# INCIDENT')) targetDir = 'incidents';
-    else continue;
-
-    const targetName = `${today}-${file.replace(/.*-/, '').replace('.md', '.md')}`;
-    if (!targetName.startsWith('20')) {
-       // 如果文件名没日期前缀，强制加上
-       // 假设文件名为 <topic>.md
-    }
-    
-    // 统一处理：强制 YYYY-MM-DD- 前缀
+    const content = fs.readFileSync(path.join(draftsDir, file), 'utf8');
+    const targetDir = classify(content);
+    if (!targetDir) continue;
+    // 统一强制 YYYY-MM-DD- 前缀；已有前缀的文件名原样保留
     const finalName = /^\d{4}-\d{2}-\d{2}-/.test(file) ? file : `${today}-${file}`;
-    const targetPath = path.join(WF_ROOT, targetDir, finalName);
-
+    const targetPath = path.join(root, 'workflow', targetDir, finalName);
     fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-    fs.copyFileSync(path.join(DRAFTS_DIR, file), targetPath);
-    
-    solidified.push({
-      rel: `workflow/${targetDir}/${finalName}`,
-      abs: targetPath,
-      type: targetDir
-    });
-    console.log(`  📦 迁移: ${file} -> ${targetKebab(targetDir)}/${finalName}`);
+    fs.copyFileSync(path.join(draftsDir, file), targetPath);
+    solidified.push({ rel: `workflow/${targetDir}/${finalName}`, abs: targetPath, type: targetDir });
+    console.log(` 📦 迁移: ${file} -> ${targetDir}/${finalName}`);
   }
+  if (!solidified.length) fail(`草稿中未找到可识别的 INTENT/PLAN/SPEC/INCIDENT 文档（主题 ${topic}）`);
 
-  function targetKebab(dir) { return dir; }
-
-  // 3. 批量确认 (Delegated)
-  console.log('🛡️  执行批量确认...');
-  for (const item of solidified) {
-    const res = spawnSync('node', [
-      path.join(SCRIPT_DIR, 'confirm-doc.mjs'), 
-      item.rel, 
-      '--delegated', 
-      `固化 L1 任务 ${topic}：用户确认草稿无误，执行固化归档`
-    ], { encoding: 'utf8' });
-    
-    if (res.status !== 0) {
-      console.error(`  ❌ 确认失败 [${item.rel}]: ${res.stderr}`);
-      // 此时不 exit，尝试继续其他文件的确认
-    } else {
-      console.log(`  ✅ 已确认: ${item.rel}`);
+  // 确认：仅当调用方显式提供确认来源时执行；否则只迁移，绝不落账。
+  let failed = 0;
+  if (delegated || auto) {
+    console.log('🛡️ 执行逐份确认...');
+    for (const item of solidified) {
+      const args = [path.join(SCRIPT_DIR, 'confirm-doc.mjs'), item.rel, '--root', root];
+      if (delegated) args.push('--delegated', delegated);
+      else args.push('--auto');
+      const res = spawnSync('node', args, { cwd: root, encoding: 'utf8' });
+      if (res.status !== 0) {
+        failed++;
+        console.error(` ❌ 确认失败 [${item.rel}]: ${(res.stderr || '').trim()}`);
+      } else {
+        console.log(` ✅ 已确认: ${item.rel}`);
+      }
+    }
+    console.log(`确认汇总：${solidified.length - failed}/${solidified.length} 成功${failed ? `，${failed} 失败` : ''}`);
+  } else {
+    console.log('⏭️ 未提供确认来源，仅迁移不落账。');
+    for (const item of solidified) {
+      console.log(`  → 确认指引: node .agents/scripts/confirm-doc.mjs ${item.rel}（TTY 键入「可以」）`);
+      console.log(`    或（用户对话内明确确认后）: node .agents/scripts/confirm-doc.mjs ${item.rel} --delegated "<用户原话>"`);
     }
   }
 
-  // 4. 更新索引
+  // 更新索引；失败同样传播退出码。
   console.log('📖 更新工作流索引...');
-  spawnSync('node', [path.join(SCRIPT_DIR, 'gen-workflow-index.mjs')], { stdio: 'inherit' });
+  const idx = spawnSync('node', [path.join(SCRIPT_DIR, 'gen-workflow-index.mjs')], { cwd: root, stdio: 'inherit' });
+  if (idx.status !== 0) {
+    console.error(' ❌ 索引更新失败');
+    process.exit(1);
+  }
 
+  if (failed) process.exit(1);
   console.log(`\n✨ 任务 ${topic} 已成功固化！`);
   console.log(`👉 建议执行: git add workflow/ .agents/confirmations.jsonl && git commit -m "docs(workflow): solidify L1 task ${topic}"`);
 }
 
-run();
+run();

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

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+// solidify-task.test.mjs — 快车道固化脚本 fixture 套件（2026-10-01 v09-review-defects）
+// 验证确认门契约：无确认来源只迁移不落账；--delegated quote 原样转发；--auto Strict 下拒绝且失败退出；
+// 互斥/缺草稿/非文档等边界。gen-workflow-index 无 --root 参数，spawn 时以 fixture 根为 cwd。
+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, 'solidify-task.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 ENUMS_FIXTURE = [
+  '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';
+
+const mkfix = () => {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'solidify-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', 'drafts'), { recursive: true });
+  fs.writeFileSync(path.join(d, '.agents', 'workflow-enums.txt'), ENUMS_FIXTURE);
+  fs.writeFileSync(path.join(d, '.agents', 'workflow-modules.txt'), '# modules\npipeline\nui\n');
+  return d;
+};
+const DRAFT = (name, eol = '\n') =>
+  `---${eol}状态: draft${eol}级别: L1${eol}日期: 2026-10-01${eol}模块: pipeline${eol}---${eol}# INTENT — ${name}${eol}`;
+const run = (root, args) => {
+  const r = spawnSync(process.execPath, [SCRIPT, ...args], { cwd: root, encoding: 'utf8' });
+  return { code: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
+};
+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：默认只迁移不落账
+{
+  const d = mkfix();
+  fs.writeFileSync(path.join(d, '.zcode', 'drafts', 'demo-task.md'), DRAFT('demo'));
+  const r = run(d, ['--topic', 'demo', '--root', d]);
+  check('T1 默认迁移成功 exit 0', r.code === 0, r.out);
+  check('T1 草稿已迁移到 intents 且日期前缀正确',
+    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);
+}
+// T2：--delegated 原话原样转发
+{
+  const d = mkfix();
+  fs.writeFileSync(path.join(d, '.zcode', 'drafts', 'demo-task.md'), DRAFT('demo'));
+  const r = run(d, ['--topic', 'demo', '--root', d, '--delegated', '固化了可以']);
+  check('T2 --delegated 流程 exit 0', r.code === 0, r.out);
+  const lines = ledgerLines(d);
+  check('T2 台账落 1 行', lines.length === 1, JSON.stringify(lines));
+  check('T2 quote 原样（脚本不编造话术）',
+    lines[0].includes('"quote":"固化了可以"') && lines[0].includes('chat-delegated'), lines[0]);
+  check('T2 目标文档状态已 approved',
+    fs.readFileSync(migratedPath(d), 'utf8').includes('状态: approved'), '');
+}
+// T3：--auto 在 Strict（缺 trust-mode.json）下被拒 → 失败计数并 exit 1
+{
+  const d = mkfix();
+  fs.writeFileSync(path.join(d, '.zcode', 'drafts', 'demo-task.md'), DRAFT('demo'));
+  const r = run(d, ['--topic', 'demo', '--root', d, '--auto']);
+  check('T3 --auto 在缺省 Strict 下 exit 1（不吞失败）', r.code === 1, r.out);
+  check('T3 输出含失败汇总', r.out.includes('确认汇总') && r.out.includes('失败'), r.out);
+  check('T3 台账零行（拒绝不落账）', ledgerLines(d).length === 0, JSON.stringify(ledgerLines(d)));
+}
+// T4：缺草稿 → exit 1
+{
+  const d = mkfix();
+  fs.writeFileSync(path.join(d, '.zcode', 'drafts', 'other.md'), DRAFT('other'));
+  const r = run(d, ['--topic', 'nope', '--root', d]);
+  check('T4 缺主题草稿 exit 1 且带指引', r.code === 1 && r.out.includes('未找到主题'), r.out);
+}
+// T5：草稿非可识别文档 → exit 1
+{
+  const d = mkfix();
+  fs.writeFileSync(path.join(d, '.zcode', 'drafts', 'demo-note.md'), '# 随手笔记\nnot a workflow doc\n');
+  const r = run(d, ['--topic', 'demo', '--root', d]);
+  check('T5 无可识别文档 exit 1', r.code === 1 && r.out.includes('未找到可识别'), r.out);
+}
+// T6：--delegated 与 --auto 互斥 → exit 1
+{
+  const d = mkfix();
+  fs.writeFileSync(path.join(d, '.zcode', 'drafts', 'demo-task.md'), DRAFT('demo'));
+  const r = run(d, ['--topic', 'demo', '--root', d, '--delegated', 'x', '--auto']);
+  check('T6 互斥 exit 1', r.code === 1 && r.out.includes('互斥'), r.out);
+}
+// T7：失败路径退出码传播（确认失败后 exit 1，不吞）
+{
+  const d = mkfix();
+  fs.writeFileSync(path.join(d, '.zcode', 'drafts', 'demo-task.md'), DRAFT('demo'));
+  // 让确认失败：用 --auto 触发 Strict 拒绝（缺 trust-mode.json 即 Strict）。
+  const r = run(d, ['--topic', 'demo', '--root', d, '--auto']);
+  check('T7 失败后 exit 1 且索引仍生成', r.code === 1 && fs.existsSync(path.join(d, 'workflow', 'INDEX.md')), r.out);
+}
+// T8：索引更新失败传播退出码（独立于确认失败路径——删除 workflow/plans 目录使 gen-workflow-index 失败）
+{
+  const d = mkfix();
+  fs.writeFileSync(path.join(d, '.zcode', 'drafts', 'demo-task.md'), DRAFT('demo'));
+  fs.rmSync(path.join(d, 'workflow', 'plans'), { recursive: true });
+  const r = run(d, ['--topic', 'demo', '--root', d]);
+  check('T8 索引更新失败 exit 1 且输出指明', r.code === 1 && r.out.includes('索引更新失败'), r.out);
+}
+
+console.log(`\n${fail ? `❌ ${fail} failed` : '✅ all passed'}（${pass} passed）`);
+process.exit(fail ? 1 : 0);

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 {