agentic-flow-kit 1.7.16 → 1.8.1

package/templates/_agents/scripts/verify.mjs

@@ -1,38 +1,63 @@
 #!/usr/bin/env node
-// verify.mjs — 关单固定编排（2026-09-24 intent closeout-verify-script；2026-09-26 check-loop-node 第 2 步直连 node）
-// 用途：关单前一键过门——按写死顺序执行 npm test → check-loop，逐项输出 pass/fail。
-// 语义：只编排不裁决——两条命令都是既有门禁原样跑，本脚本不读配置、不判窗口、不改退出码；
-//   任一步非零即 fail-fast 退出 1，失败原因原样透传不吞。
-//   check-loop 为 node 实现（经 check-loop.mjs 直跑——node 即本脚本运行时必然可用，
-//   旧「缺 sh 环境 fail-closed」分支随 sh 依赖消失退役）。
-// 凭证落账（2026-10-07 verify-evidence）：两步全绿后向 <root>/.agents/verifications.jsonl append
-//   一行机器事实 {ts, exitCode:0, suite, passed?, failed?, runId?}——append-only 事实记录，不属裁决
-//   （窗口判定/门禁在消费方 confirm-doc 与 check-loop 检查 8）；消费语义 = 「按门跑了 verify 且全绿」，
-//   裸跑 npm test 不落账（对齐引导）。npm test 步骤输出从 inherit 改 pipe 捕获后回放（延迟显示，
-//   关单场景可接受）——仅 best-effort 抓编排器权威汇总行 `[run-tests] 合计: SUITES n / FAILED m`，
-//   抓不到则省略计数键（宁缺勿错：exitCode 才是硬事实，计数缺失不阻断）。
-// 装户仓（根目录无 package.json，工程在子目录）下默认 npm test 恒 ENOENT（exit 4058）→ **显式跳过步骤 1**
-// 且**不落测试绿凭证**（凭证语义 = 测试真跑绿，跳过即无凭证，防假绿），并提示用
-// --test-cmd "<项目测试命令>" 指定；显式 --test-cmd 不受此判定影响（2026-10-07 papercut）。
-// 测试：node templates/_agents/scripts/verify.test.mjs（--test-cmd 注入假命令 + CHECK_LOOP_ROOT 注入夹具，不触真实 npm test 与 workflow）
-// --doc 凭证绑定（2026-10-08 verify-doc-binding）：落账行增 `doc` 字段，写入**相对仓库根的 posix 形态**
-//   （win32 反斜杠 / posix 斜杠 / 绝对路径三种写法经 resolve+relative+分隔符归一后落同一值），使凭证
-//   与被证明的那一单绑定。不带 --doc 时仍落行但**不写该键**——CI（kit-ci.yml）无单次上下文，照常记录
-//   事实；这样的行不给任何单背书（消费方按 doc 精确匹配时 e.doc 为 undefined 恒不命中）。
-// 用法：node .agents/scripts/verify.mjs [--test-cmd "<shell 命令>"] [--doc <本单 workflow 路径>]
-//   （--test-cmd 用于测试注入，或在无根 package.json 的装户仓指定项目测试命令；
-//     --doc 把凭证绑到本单，如 --doc workflow/intents/<日期>-<主题>.md）
+// verify.mjs — 关单/CI 统一静态门编排（GATES 表版；2026-10-13 自 Shipyard.Material 参考实现回灌，
+// 源仓沿革留痕在包源仓 git 历史与 CHANGELOG——装户径不引实例路径）
+// 用途：关单或 CI 前一键过门——engine cohort 七门按表执行、逐项输出 pass/fail，任一门红即 fail-fast exit 1。
+// 语义：单源口径。本地 verify 与装户远端门（kit-ci.yml 同一条命令）行为 100% 一致。
+// 凭证落账：全绿才落绿凭证；任一门红即落失败行（suite=门 id），供根因分析——消费方（confirm-doc 前置 /
+//   check-loop 检查 8）只认 exitCode===0 的行，失败行零污染凭证判定。
+// 七门照搬源仓 engine cohort（不搬 product cohort——frontend/backend 门是源仓项目私有；lane-surface-ci 门
+//   依赖 kit 侧 --ci 支持核实，留后续批次评估）。源仓 --engine 增量语义不移植：本表已全为引擎段，
+//   「部分绿 ≠ 全量凭证」的分野不存在。
+// kit 特有语义（沿现口径保留）：
+//   a) 装户仓判定——cwd 无 package.json → engine-tests 门显式跳过（跳过≠通过，不计入门数）且**不落
+//      测试绿凭证**（凭证语义 = 测试真跑绿，防假绿），提示 --test-cmd；
+//   b) 凭证行形状 = {ts, exitCode:0, suite:'npm test', gates, headShort?, passed?, failed?, doc?, runId?}
+//      （gates/headShort 自源仓回灌新增——非 git 环境解析失败则省略、不伪造；消费方只读 ts/exitCode/doc，
+//       增量字段零影响）；计数捕获只认编排器权威行 `[run-tests] 合计: SUITES n / FAILED m`
+//       （嵌套套件同形行不回退——宁缺勿错，exitCode 才是硬事实）；
+//   c) --doc 绑定语义保留（归一基准 = ROOT，与 confirm-doc / 检查 8 三处同源）；
+//   d) --test-cmd 为 fixture 测试注入缝：替换全部生产门为 [test, check-loop] 两门夹具（夹具根里没有
+//      脚本本体，check-loop 用绝对路径直调，root 归属仍由 CHECK_LOOP_ROOT 裁决）；夹具模式不触发生效规则
+//      视图门与摘要生成（假门凭证只进本地台账，不产 committed 摘要）。
+// 未执行门清单：fail-fast 后序门状态未知≠通过——验证系统输出须完备（「没跑」与「过了」可区分）。
+// 生效规则视图门（effective-policy --check）：policy 变更后必须重生成 workflow/effective-policy.md 随同
+//   提交——新装户由 init 生成器首跑种子该文件，缺文件对 --check 是漂移（红），不静默放行。
+// 绿凭证摘要（gen-verify-evidence.mjs）：全绿尾部自动重生成 workflow/verify-evidence.md——全绿事实与
+//   仓内摘要同刻生成，消除「本地台账已绿、committed 摘要滞后」的双真相分叉；生成失败响亮告警但不推翻绿裁决。
+// 用法：node .agents/scripts/verify.mjs [--list] [--test-cmd "<shell 命令>"] [--doc <本单 workflow 路径>]
+//   --list：按执行序打印门 id 后退出，不执行（与 --test-cmd 互斥）。
+//   --test-cmd 用于测试注入，或在无根 package.json 的装户仓指定项目测试命令；
+//   --doc 把凭证绑到本单，如 --doc workflow/intents/<日期>-<主题>.md
+// 测试：node templates/_agents/scripts/verify.test.mjs（--test-cmd 注入假命令 + CHECK_LOOP_ROOT 注入夹具）
 import fs from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = process.env.CHECK_LOOP_ROOT || path.resolve(SCRIPT_DIR, '..', '..');
+
+// --- 门禁定义（engine cohort 七门，序即执行序；遇红即停） ---
+const GATES = [
+  { id: 'scripts-syntax', name: '引擎脚本语法自检', cmd: 'node .agents/scripts/check-scripts-syntax.mjs', folder: '.', type: 'shell' },
+  { id: 'engine-tests', name: '测试门 (npm test)', cmd: 'npm test', folder: '.', type: 'shell' },
+  { id: 'workflows-check', name: '编排脚本检查', cmd: 'node .agents/scripts/workflows-check.mjs', folder: '.', type: 'shell' },
+  { id: 'rule-budget', name: '常驻面预算检查', cmd: 'node .agents/scripts/rule-budget.mjs --all', folder: '.', type: 'shell' },
+  { id: 'effective-policy', name: '生效规则视图漂移检查', cmd: 'node .agents/scripts/gen-effective-policy.mjs --check', folder: '.', type: 'shell' },
+  // 默认硬门。卫生段不进关单（2026-10-13 B6b-1 分道随源仓口径）：要看时另跑 check-loop.mjs --hygiene。
+  { id: 'check-loop', name: '闭环门禁校验', cmd: 'node .agents/scripts/check-loop.mjs', folder: '.', type: 'shell' },
+  { id: 'ledger-invariant', name: '确认台账不变量（历史全扫）', cmd: 'node .agents/scripts/check-ledger-invariant.mjs', folder: '.', type: 'shell' },
+];
+
+// fixture 夹具门（--test-cmd 注入时替换全部生产门，verify.test.mjs 断言依赖此口径）
+// check-loop 用绝对路径直调真实脚本——夹具根里没有脚本本体，root 归属仍由 CHECK_LOOP_ROOT 裁决。
+const fixtureGates = (cmd) => [
+  { id: 'test', name: '测试步（注入）', cmd, folder: '.', type: 'shell' },
+  { id: 'check-loop', name: '闭环门禁校验', cmd: `node "${path.join(SCRIPT_DIR, 'check-loop.mjs')}"`, folder: '.', type: 'shell' },
+];
+
 const args = process.argv.slice(2);
 const explicitTestCmd = args.includes('--test-cmd') ? args[args.indexOf('--test-cmd') + 1] : null;
-const testCmd = explicitTestCmd ?? 'npm test';
-const checkLoop = path.join(SCRIPT_DIR, 'check-loop.mjs');
-const ROOT = process.env.CHECK_LOOP_ROOT || path.resolve(SCRIPT_DIR, '..', '..');
 
 // --doc 解析（沿 --test-cmd 同款取下一 argv 的写法；缺值报用法错误 exit 1 与 --test-cmd 对称）。
 // 归一基准 = **ROOT**（不是 cwd）——消费方两处都以仓库根为基准（check-loop 检查 8 用
@@ -50,50 +75,89 @@ const docRel = docArg
   ? path.relative(ROOT, path.resolve(ROOT, docArg)).split(path.sep).join('/')
   : null;
 
-// 装户仓判定：默认命令只在**当前目录**有 package.json 时才跑（npm test 亦在该目录执行）。
-// 跳过时后续不落测试绿凭证（见文末落账段）。
+// 装户仓判定：engine-tests 门只在**当前目录**有 package.json 时才跑（npm test 亦在该目录执行）。
+// 跳过时后续不落测试绿凭证（见全绿落账段）。显式 --test-cmd 不受此判定影响。
 const hasRootPackageJson = fs.existsSync(path.join(process.cwd(), 'package.json'));
 const skipTest = explicitTestCmd === null && !hasRootPackageJson;
-let testStdout = '';
-
-if (skipTest) {
-  console.log('[verify] ⏭ 1/2 跳过 npm test：当前目录无 package.json（装户仓）——请按项目口径手工跑测试，或用 --test-cmd "<项目测试命令>" 指定后重跑');
-} else {
-  console.log(`[verify] ▶ 1/2 ${testCmd}`);
-  const t = spawnSync(testCmd, { shell: true, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
-  if (t.stdout) process.stdout.write(t.stdout);
-  if (t.stderr) process.stderr.write(t.stderr);
-  if (t.status !== 0) {
-    console.error(`[verify] ❌ 1/2 ${testCmd} 未通过（exit ${t.status ?? t.error?.code}）——修复后重跑，非绿不关单`);
+const gates = explicitTestCmd ? fixtureGates(explicitTestCmd) : GATES;
+
+if (args.includes('--list')) {
+  if (explicitTestCmd) {
+    console.error('[verify] --list 与 --test-cmd 互斥');
     process.exit(1);
   }
-  testStdout = String(t.stdout || '');
-  console.log('[verify] ✅ 1/2 测试通过');
+  for (const g of gates) console.log(g.id);
+  process.exit(0);
 }
 
-console.log('[verify] ▶ 2/2 check-loop');
-const c = spawnSync(process.execPath, [checkLoop], { stdio: 'inherit' });
-if (c.status !== 0) {
-  console.error(`[verify] ❌ 2/2 check-loop 未通过（exit ${c.status ?? c.error?.code}）——按上方输出修复后原路重跑`);
-  process.exit(1);
+// 失败留痕：失败行 {ts, exitCode, suite:门 id, note}——append-only 事实记录，供根因分析；
+// 消费方只认 exitCode===0 的绿行，失败行零污染凭证判定。IO 失败出账不阻断。
+const recordFailure = (step, exitInfo, note) => {
+  try {
+    const entry = { ts: new Date().toISOString(), exitCode: typeof exitInfo === 'number' ? exitInfo : -1, suite: step, note };
+    if (process.env.PIPELINE_RUN_ID) entry.runId = process.env.PIPELINE_RUN_ID;
+    fs.mkdirSync(path.join(ROOT, '.agents'), { recursive: true });
+    fs.appendFileSync(path.join(ROOT, '.agents', 'verifications.jsonl'), `${JSON.stringify(entry)}\n`);
+    console.log(`[verify] 🧾 失败行已留痕 verifications.jsonl（suite=${step}）`);
+  } catch (e) {
+    console.error(`[verify] ⚠️ 失败行落账失败（${e.code || e.message}）`);
+  }
+};
+
+console.log(`[verify] 🚀 开始静态门验证 (共 ${gates.length} 项)${explicitTestCmd ? '【fixture 模式】' : ''}\n`);
+
+let passedCount = 0;
+const outputs = {};
+
+for (let i = 0; i < gates.length; i++) {
+  const gate = gates[i];
+  // 装户仓：engine-tests 门显式跳过——跳过≠通过，不计入 passedCount、不算绿（全绿落账段据此不落凭证）
+  if (skipTest && gate.id === 'engine-tests') {
+    console.log(`[verify] ⏭ ${i + 1}/${gates.length} 跳过 ${gate.cmd}：当前目录无 package.json（装户仓）——请按项目口径手工跑测试，或用 --test-cmd "<项目测试命令>" 指定后重跑`);
+    continue;
+  }
+  console.log(`[verify] ▶ ${i + 1}/${gates.length} ${gate.name}...`);
+
+  const result = spawnSync(gate.cmd, {
+    shell: true,
+    encoding: 'utf8',
+    cwd: path.join(ROOT, gate.folder),
+    maxBuffer: 32 * 1024 * 1024,
+  });
+
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+
+  if (result.status !== 0) {
+    const note = `exit ${result.status ?? result.error?.code}`;
+    console.error(`[verify] ❌ ${i + 1}/${gates.length} ${gate.name} 未通过 (${note})`);
+    // 未执行门清单：fail-fast 后序门状态未知≠通过——「没跑」在台账里与「过了」不可区分即输出不完备
+    const remaining = gates.slice(i + 1).map((g) => g.id);
+    if (remaining.length) console.error(`[verify] ⏭️ 未执行门（fail-fast，状态未知）：${remaining.join('、')}`);
+    recordFailure(gate.id, result.status, note);
+    process.exit(1);
+  }
+  outputs[gate.id] = result.stdout || '';
+  console.log(`[verify] ✅ ${i + 1}/${gates.length} ${gate.name} 通过\n`);
+  passedCount++;
 }
-console.log('[verify] ✅ 2/2 闭环校验通过');
 
-// 凭证落账：两步全绿才落（check-loop 红不产生凭证——凭证语义 = verify 全绿）；**步骤 1 被跳过同样不落**
+// 凭证落账：全部门绿才落（任一门红已在上面 fail-fast 退出）；**测试门被跳过同样不落**
 // （测试未跑即无「测试绿」事实，落账即假绿）；IO 失败出账不阻断
 try {
   if (skipTest) {
-    console.log('[verify] ⚠️ 步骤 1 已跳过——本次不落测试绿凭证（凭证语义 = 测试真跑绿）');
+    console.log('[verify] ⚠️ 测试门已跳过——本次不落测试绿凭证（凭证语义 = 测试真跑绿）');
   } else {
-    // 计数行**只认编排器权威前缀**（2026-10-09 审查 P0-2）：此前是 pop 通配「合计: PASS n / FAIL n」，
-    // 而全仓 45+ 套件每个都打印自己那行同形文本 → 取到的是字母序最后一个套件的场景数
-    // （本仓实况：workflows-check.test.mjs 的 15），落进「一行机器事实」的 passed 字段。
-    // 改为精确匹配 run-tests.mjs 的专属行 + 套件口径：嵌套套件同形行不再被误取，
-    // 非本编排器口径的 --test-cmd（装户项目自有测试命令）抓不到即省略计数键，不回退到错的事实。
-    const m = [...testStdout.matchAll(/\[run-tests\] 合计: SUITES (\d+) \/ FAILED (\d+)/g)].pop();
     const entry = { ts: new Date().toISOString(), exitCode: 0, suite: 'npm test' };
-    // passed/failed 口径 = **套件**（非断言、非场景）：凭证明此记录的是「跑过多少套、挂了几套」。
-    // 步骤 1 红已在上面 fail-fast 退出，故落账行 failed 恒为 0。
+    // 门数：凭证明此记录「过全量门禁全绿」是几门（fixture 模式 = 2 门夹具，仍如实记）
+    entry.gates = passedCount;
+    // HEAD 短 SHA 钉进绿行本体（源仓回灌）：确定性证据此前只存在于测试夹具、绿行无 SHA 可锚定验证对象；
+    // 非 git 环境（fixture 根在 os.tmpdir）解析失败则省略该键，不伪造。
+    const rev = spawnSync('git', ['rev-parse', '--short', 'HEAD'], { encoding: 'utf8', cwd: ROOT });
+    if (rev.status === 0 && rev.stdout) entry.headShort = rev.stdout.trim();
+    // 计数行**只认编排器权威前缀**：嵌套套件同形行不回退——非本编排器口径的 --test-cmd
+    //（装户项目自有测试命令）抓不到即省略计数键，不回退到错的事实（宁缺勿错，exitCode 才是硬事实）。
+    const m = [...(outputs['engine-tests'] || outputs['test'] || '').matchAll(/\[run-tests\] 合计: SUITES (\d+) \/ FAILED (\d+)/g)].pop();
     if (m) { entry.passed = Number(m[1]); entry.failed = Number(m[2]); }
     if (process.env.PIPELINE_RUN_ID) entry.runId = process.env.PIPELINE_RUN_ID;
     // doc 键：未传 --doc 时**不写该键**（不是写 null）——消费方按 doc 精确匹配，undefined 与 null 都恒不命中，
@@ -106,4 +170,17 @@ try {
 } catch (e) {
   console.error(`[verify] ⚠️ 凭证落账失败（${e.code || e.message}）——不阻断，关单门前置将按无凭证告警`);
 }
-console.log('[verify] ✅ 全绿——可以关单（逐条勾验验收标准补证据后 intent/plan → done）');
+
+// 摘要事件原子化：全绿事实与仓内摘要（workflow/verify-evidence.md）同刻生成，消除「本地台账已绿、
+// committed 摘要滞后」的双真相分叉。仅生产模式（fixture 假门凭证不产 committed 摘要；测试门跳过时
+// 本就无凭证）；生成失败响亮告警但不推翻绿裁决（同落账口径）。
+if (!explicitTestCmd && !skipTest) {
+  const gen = spawnSync(process.execPath, [path.join(SCRIPT_DIR, 'gen-verify-evidence.mjs'), '--root', ROOT], { encoding: 'utf8' });
+  if (gen.status === 0) {
+    if (gen.stdout) process.stdout.write(String(gen.stdout).trimEnd() + '\n');
+  } else {
+    console.error(`[verify] ⚠️ 绿凭证摘要生成失败（${String(gen.stderr || gen.stdout || '').trim().slice(0, 200)}）——绿裁决不变，手动补跑 node .agents/scripts/gen-verify-evidence.mjs`);
+  }
+}
+
+console.log(`\n[verify] 🎉 全绿——可以关单（共 ${passedCount} 项通过；逐条勾验验收标准补证据后 intent/plan → done）`);

package/templates/_agents/scripts/verify.test.mjs

@@ -1,16 +1,21 @@
 #!/usr/bin/env node
 // verify.mjs 的 fixture 测试（--test-cmd 注入假命令 + CHECK_LOOP_ROOT 注入夹具根，不触真实 npm test 与 workflow）
-// 断言：①绿路径（假过 + 空夹具闭环）exit 0；②步骤 1 假败 exit 1 且不出全绿；
-// ③步骤 2 配对断裂夹具 exit 1（verify 自身标记断言——孙进程 stdio inherit 输出不进本测试管道）；
-// ④⑤⑥凭证落账三态（绿落 / check-loop 红不落 / 无汇总行省略计数键）；
-// ⑦装户仓（cwd 无 package.json）未给 --test-cmd → 跳过步骤 1、不落凭证、仍跑步骤 2、exit 0；
-// ⑧--doc 绑定五态；⑨⑩嵌套套件同形汇总行不得被误取（计数口径=编排器权威套件数，2026-10-09 审查 P0-2 回归锁）。
+// 断言：①绿路径（假过 + 空夹具闭环）exit 0；②步骤假败 exit 1 且失败行留痕（suite=test）；
+// ③步骤 2 配对断裂夹具 exit 1（verify 自身标记断言）；④凭证落账（绿行 + 计数捕获）；
+// ④b fixture 绿不产 committed 摘要；⑤check-loop 红失败行留痕、无绿行；
+// ⑥无汇总行省略计数键；⑦装户仓（cwd 无 package.json）跳过测试门、不落凭证、其余门全过 → exit 0；
+// ⑧--doc 绑定五态；⑨⑩嵌套套件同形汇总行不得被误取；⑪--list 七门序；⑫--list 与 --test-cmd 互斥；
+// ⑬生产模式中段红 → fail-fast + 未执行门清单 + 失败行留痕；
+// ⑭生产模式全绿端到端（七门 + 凭证含门数/headShort/套件计数 + 绿凭证摘要生成）。
+// 生产模式夹具经 fixture-scripts.mjs#copyScriptClosure 把门脚本依赖闭包拷进临时根（并种子
+// workflow/effective-policy.md——生效规则视图门对缺文件判漂移，与 init 生成器首跑同款）。
 // 用法：node templates/_agents/scripts/verify.test.mjs
 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';
+import { copyScriptClosure } from './fixture-scripts.mjs';
 
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const VERIFY = path.join(SCRIPT_DIR, 'verify.mjs');
@@ -35,7 +40,7 @@ const mkfix = () => {
     'doc.status.abandoned=superseded cancelled',
     'incident.status.all=open fixed closed',
     'incident.status.active=open',
-    'level.all=L0 L1 L2 L3',
+    'level.all=L1 L2 L3',
     '',
   ].join('\n'), 'utf8');
   return d;
@@ -57,6 +62,33 @@ const mkCmd = (code, out = '') => {
 };
 const run = (argv, opts = {}) => spawnSync(process.execPath, [VERIFY, ...argv], { encoding: 'utf8', ...opts });
 
+// 生产模式夹具：门脚本依赖闭包拷贝 + .agents/hooks 目录（语法门 fail-closed 要求）+
+// workflow/effective-policy.md 种子（生效规则视图门对缺文件判漂移——与 init §6 生成器首跑同款）
+const provision = (root) => {
+  fs.mkdirSync(path.join(root, '.agents', 'hooks'), { recursive: true });
+  copyScriptClosure(path.join(root, '.agents', 'scripts'), [
+    'check-scripts-syntax.mjs', 'workflows-check.mjs', 'rule-budget.mjs',
+    'gen-effective-policy.mjs', 'check-ledger-invariant.mjs', 'check-loop.mjs',
+  ]);
+  const gen = spawnSync(process.execPath, [path.join(root, '.agents', 'scripts', 'gen-effective-policy.mjs'), '--root', root], { encoding: 'utf8' });
+  if (gen.status !== 0) throw new Error(`夹具种子生成失败：${gen.stdout}${gen.stderr}`);
+  return root;
+};
+// 生产夹具变 git 仓（台账不变量门在非 git 根会 fail-closed；commit 供凭证 headShort 钉 SHA）
+const gitify = (root) => {
+  const g = (a) => spawnSync('git', ['-C', root, ...a], { encoding: 'utf8' });
+  g(['init']);
+  g(['-c', 'user.email=fixture@test', '-c', 'user.name=fixture', 'add', '-A']);
+  const c = g(['-c', 'user.email=fixture@test', '-c', 'user.name=fixture', 'commit', '-m', 'fixture init', '--no-gpg-sign', '-q']);
+  if (c.status !== 0) throw new Error(`夹具 git commit 失败：${c.stderr}`);
+  return g(['rev-parse', '--short', 'HEAD']).stdout.trim();
+};
+const readLedger = (root) => {
+  const p = path.join(root, '.agents', 'verifications.jsonl');
+  if (!fs.existsSync(p)) return [];
+  return fs.readFileSync(p, 'utf8').split(/\r?\n/).filter(Boolean).map((l) => JSON.parse(l));
+};
+
 // ---- 场景 1：绿路径——假过 + 空夹具闭环 → exit 0 ----
 {
   const root = mkfix();
@@ -66,12 +98,16 @@ const run = (argv, opts = {}) => spawnSync(process.execPath, [VERIFY, ...argv],
   fs.rmSync(root, { recursive: true, force: true });
 }
 
-// ---- 场景 2：红路径步骤 1——假败 → exit 1、fail-fast 不出全绿 ----
+// ---- 场景 2：红路径测试门——假败 → exit 1、fail-fast 不出全绿；失败行留痕 ----
 {
   const root = mkfix();
   const r = run(['--test-cmd', `node ${mkCmd(3)}`], { env: { ...process.env, CHECK_LOOP_ROOT: root } });
   check('场景 2：exit 1', r.status === 1, `exit=${r.status}\n${r.stdout}\n${r.stderr}`);
-  check('场景 2：步骤 1 失败标记在 stderr，且不输出全绿', r.stderr.includes('❌ 1/2') && !r.stdout.includes('全绿'), `${r.stdout}\n${r.stderr}`);
+  check('场景 2：步骤失败标记在 stderr，且不输出全绿', r.stderr.includes('❌ 1/2') && !r.stdout.includes('全绿'), `${r.stdout}\n${r.stderr}`);
+  const lines = readLedger(root);
+  check('场景 2：测试门红 → 失败行留痕（exitCode 3 + suite=test）',
+    lines.length === 1 && lines[0].exitCode === 3 && lines[0].suite === 'test' && typeof lines[0].ts === 'string',
+    `lines=${JSON.stringify(lines)}`);
   fs.rmSync(root, { recursive: true, force: true });
 }
 
@@ -84,65 +120,75 @@ const run = (argv, opts = {}) => spawnSync(process.execPath, [VERIFY, ...argv],
   fs.rmSync(root, { recursive: true, force: true });
 }
 
-// ---- 场景 4：绿路径凭证落账（2026-10-07 verify-evidence）——全绿后 fixture 台账出合法绿行 ----
+// ---- 场景 4：绿路径凭证落账——全绿后 fixture 台账出合法绿行（计数捕获 + testCmd 注入输出口径） ----
 {
   const root = mkfix();
   const r = run(['--test-cmd', `node ${mkCmd(0, '[run-tests] 合计: SUITES 3 / FAILED 0\n')}`], { env: { ...process.env, CHECK_LOOP_ROOT: root } });
-  const vp = path.join(root, '.agents', 'verifications.jsonl');
-  const line = fs.existsSync(vp) ? JSON.parse(fs.readFileSync(vp, 'utf8').trim()) : null;
-  check('场景 4：全绿 → verifications.jsonl 落绿行（exitCode 0 + 计数捕获）',
+  const line = readLedger(root)[0] || null;
+  check('场景 4：全绿 → verifications.jsonl 落绿行（exitCode 0 + 计数捕获 + 门数）',
     r.status === 0 && line !== null && line.exitCode === 0 && line.passed === 3 && line.failed === 0
-      && typeof line.ts === 'string' && r.stdout.includes('凭证已落账'),
+      && line.gates === 2 && typeof line.ts === 'string' && line.suite === 'npm test' && r.stdout.includes('凭证已落账'),
     `exit=${r.status} line=${JSON.stringify(line)}`);
   fs.rmSync(root, { recursive: true, force: true });
 }
 
-// ---- 场景 5：红路径不落账（check-loop 红 → fail-fast 在落账前退出）----
+// ---- 场景 4b：fixture 全绿不得触发摘要生成（假门凭证只进本地台账，不产 committed 摘要） ----
+{
+  const root = mkfix();
+  const r = run(['--test-cmd', `node ${mkCmd(0, '[run-tests] 合计: SUITES 3 / FAILED 0\n')}`], { env: { ...process.env, CHECK_LOOP_ROOT: root } });
+  const ev = path.join(root, 'workflow', 'verify-evidence.md');
+  check('场景 4b：fixture 绿 → 不生成 workflow/verify-evidence.md、输出无摘要生成标记',
+    r.status === 0 && !fs.existsSync(ev) && !r.stdout.includes('已生成'),
+    `exit=${r.status} exists=${fs.existsSync(ev)}\n${r.stdout}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- 场景 5：check-loop 红 → 失败行留痕、无绿行（失败也留痕；绿行语义 = verify 全绿不变） ----
 {
   const root = mkBroken();
   const r = run(['--test-cmd', `node ${mkCmd(0)}`], { env: { ...process.env, CHECK_LOOP_ROOT: root } });
-  check('场景 5：npm test 绿但 check-loop 红 → 无凭证行（凭证语义 = verify 全绿）',
-    r.status === 1 && !fs.existsSync(path.join(root, '.agents', 'verifications.jsonl')),
-    `exit=${r.status}`);
+  const lines = readLedger(root);
+  check('场景 5：测试门绿但 check-loop 红 → 仅失败行（suite=check-loop），无绿行',
+    r.status === 1 && lines.length === 1 && lines[0].exitCode !== 0 && lines[0].suite === 'check-loop'
+      && !lines.some((l) => l.exitCode === 0),
+    `exit=${r.status} lines=${JSON.stringify(lines)}`);
   fs.rmSync(root, { recursive: true, force: true });
 }
 
-// ---- 场景 6：输出无汇总行 → 计数键省略（exitCode 才是硬事实）----
+// ---- 场景 6：输出无汇总行 → 计数键省略（exitCode 才是硬事实） ----
 {
   const root = mkfix();
   const r = run(['--test-cmd', `node ${mkCmd(0, 'ok\n')}`], { env: { ...process.env, CHECK_LOOP_ROOT: root } });
-  const vp = path.join(root, '.agents', 'verifications.jsonl');
-  const line = fs.existsSync(vp) ? JSON.parse(fs.readFileSync(vp, 'utf8').trim()) : null;
+  const line = readLedger(root)[0] || null;
   check('场景 6：无汇总输出 → 绿行落盘但计数键省略',
     r.status === 0 && line !== null && line.exitCode === 0 && !('passed' in line) && !('failed' in line),
     `line=${JSON.stringify(line)}`);
   fs.rmSync(root, { recursive: true, force: true });
 }
 
-// ---- 场景 7：装户仓（cwd 无 package.json）且未给 --test-cmd → 跳过步骤 1、不落凭证、仍跑步骤 2 → exit 0 ----
+// ---- 场景 7：装户仓（cwd 无 package.json）且未给 --test-cmd → 跳过测试门、不落凭证、其余门全过 → exit 0 ----
 {
- const root = mkfix();
- const bare = fs.mkdtempSync(path.join(os.tmpdir(), 'verify-bare-'));
- const r = run([], { cwd: bare, env: { ...process.env, CHECK_LOOP_ROOT: root } });
- check('场景 7：exit 0', r.status === 0, `exit=${r.status}\n${r.stdout}\n${r.stderr}`);
- check('场景 7：步骤 1 显式跳过（⏭ 1/2）、步骤 2 通过且全绿', r.stdout.includes('⏭ 1/2') && r.stdout.includes('✅ 2/2') && r.stdout.includes('全绿'), r.stdout);
- check('场景 7：跳过时不落测试绿凭证（防假绿）',
- !fs.existsSync(path.join(root, '.agents', 'verifications.jsonl')) && r.stdout.includes('不落测试绿凭证'),
- r.stdout);
- fs.rmSync(root, { recursive: true, force: true });
- fs.rmSync(bare, { recursive: true, force: true });
+  const root = provision(mkfix());
+  gitify(root);
+  const bare = fs.mkdtempSync(path.join(os.tmpdir(), 'verify-bare-'));
+  const r = run([], { cwd: bare, env: { ...process.env, CHECK_LOOP_ROOT: root } });
+  check('场景 7：exit 0', r.status === 0, `exit=${r.status}\n${r.stdout}\n${r.stderr}`);
+  check('场景 7：测试门显式跳过（⏭ 2/7）、末门通过且全绿', r.stdout.includes('⏭ 2/7') && r.stdout.includes('✅ 7/7') && r.stdout.includes('全绿'), r.stdout);
+  check('场景 7：跳过时不落测试绿凭证（防假绿）且不生成摘要',
+    readLedger(root).length === 0 && !fs.existsSync(path.join(root, 'workflow', 'verify-evidence.md')) && r.stdout.includes('不落测试绿凭证'),
+    r.stdout);
+  fs.rmSync(root, { recursive: true, force: true });
+  fs.rmSync(bare, { recursive: true, force: true });
 }
 
-// ---- 场景 8：--doc 凭证绑定（2026-10-08 verify-doc-binding）----
+// ---- 场景 8：--doc 凭证绑定 ----
 // ① 带 --doc → 末行含 doc 且为规范化 posix 相对路径；② 不带 → 末行**无 doc 键**（不是 null）；
 // ③ win32 反斜杠 / posix / 绝对路径三种写法落同一值（归一是本单的地基，错一处=凭证永远匹配不上）；
-// ④ 缺值 → exit 1 用法错误；⑤ 跳过步骤 1 时即便带 --doc 仍不落账（防假绿语义不得被 --doc 破坏）。
+// ④ 缺值 → exit 1 用法错误；⑤ 跳过测试门时即便带 --doc 仍不落账（防假绿语义不得被 --doc 破坏）。
 {
   const readLast = (root) => {
-    const p = path.join(root, '.agents', 'verifications.jsonl');
-    if (!fs.existsSync(p)) return null;
-    const lines = fs.readFileSync(p, 'utf8').trim().split('\n').filter(Boolean);
-    return lines.length ? JSON.parse(lines[lines.length - 1]) : null;
+    const lines = readLedger(root);
+    return lines.length ? lines[lines.length - 1] : null;
   };
 
   const rootA = mkfix();
@@ -175,27 +221,27 @@ const run = (argv, opts = {}) => spawnSync(process.execPath, [VERIFY, ...argv],
   check('场景 8④：--doc 缺值 → exit 1 + 用法提示',
     rD.status === 1 && /--doc 缺值/.test(rD.stderr), `exit=${rD.status} ${rD.stderr}`);
 
-  const rootE = mkfix();
+  const rootE = provision(mkfix());
+  gitify(rootE);
   const bare = fs.mkdtempSync(path.join(os.tmpdir(), 'verify-bare-doc-'));
   const rE = run(['--doc', rel], { cwd: bare, env: { ...process.env, CHECK_LOOP_ROOT: rootE } });
-  check('场景 8⑤：步骤 1 跳过时即便带 --doc 仍不落账（防假绿语义不被 --doc 破坏）',
-    rE.status === 0 && !fs.existsSync(path.join(rootE, '.agents', 'verifications.jsonl')) && rE.stdout.includes('不落测试绿凭证'),
+  check('场景 8⑤：测试门跳过时即便带 --doc 仍不落账（防假绿语义不被 --doc 破坏）',
+    rE.status === 0 && readLedger(rootE).length === 0 && rE.stdout.includes('不落测试绿凭证'),
     `exit=${rE.status} ${rE.stdout}`);
 
   for (const r of [rootA, rootB, rootC, rootD, rootE]) fs.rmSync(r, { recursive: true, force: true });
   fs.rmSync(bare, { recursive: true, force: true });
 }
 
-// ---- 场景 9 / 10：嵌套套件同形汇总行不得被误取（2026-10-09 审查 P0-2 回归锁）----
-// 缺陷复现：旧判据 pop 通配「合计: PASS n / FAIL n」，而全仓 45+ 套件每个都打印自己那行同形文本，
-// 取到的是字母序最后一个套件的场景数（本仓实况 workflows-check.test.mjs = 15），落进凭证 passed。
+// ---- 场景 9 / 10：嵌套套件同形汇总行不得被误取（计数口径=编排器权威套件数，回归锁） ----
+// 缺陷复现：旧判据 pop 通配「合计: PASS n / FAIL n」，而全套件每个都打印自己那行同形文本，
+// 取到的是字母序最后一个套件的场景数，落进凭证 passed。
 // ⑨ 权威行与同形行并存 → 取权威套件数；⑩ 仅有同形行 → 省略计数键（宁缺勿错，不回退到错的事实）。
 {
   const root9 = mkfix();
   const r9 = run(['--test-cmd', `node ${mkCmd(0, '合计: PASS 15 / FAIL 0\n[run-tests] 合计: SUITES 45 / FAILED 0\n')}`],
     { env: { ...process.env, CHECK_LOOP_ROOT: root9 } });
-  const vp9 = path.join(root9, '.agents', 'verifications.jsonl');
-  const l9 = fs.existsSync(vp9) ? JSON.parse(fs.readFileSync(vp9, 'utf8').trim()) : null;
+  const l9 = readLedger(root9)[0] || null;
   check('场景 9：嵌套套件同形行不被误取，计数取编排器权威套件数',
     r9.status === 0 && l9 !== null && l9.passed === 45 && l9.failed === 0,
     `line=${JSON.stringify(l9)}`);
@@ -204,14 +250,77 @@ const run = (argv, opts = {}) => spawnSync(process.execPath, [VERIFY, ...argv],
   const root10 = mkfix();
   const r10 = run(['--test-cmd', `node ${mkCmd(0, '合计: PASS 15 / FAIL 0\n')}`],
     { env: { ...process.env, CHECK_LOOP_ROOT: root10 } });
-  const vp10 = path.join(root10, '.agents', 'verifications.jsonl');
-  const l10 = fs.existsSync(vp10) ? JSON.parse(fs.readFileSync(vp10, 'utf8').trim()) : null;
+  const l10 = readLedger(root10)[0] || null;
   check('场景 10：仅有嵌套同形行 → 绿行落盘但省略计数键（不回退到错的事实）',
     r10.status === 0 && l10 !== null && l10.exitCode === 0 && !('passed' in l10) && !('failed' in l10),
     `line=${JSON.stringify(l10)}`);
   fs.rmSync(root10, { recursive: true, force: true });
 }
 
+// ---- 场景 11：--list 锁定 engine cohort 七门序，不执行门 ----
+{
+  const expect = ['scripts-syntax', 'engine-tests', 'workflows-check', 'rule-budget', 'effective-policy', 'check-loop', 'ledger-invariant'];
+  const r = run(['--list'], {});
+  const ids = (r.stdout || '').trim().split(/\r?\n/).filter(Boolean);
+  check('场景 11：--list exit 0 且恰七门、序不变、不执行',
+    r.status === 0 && ids.length === expect.length && expect.every((id, i) => ids[i] === id)
+      && !String(r.stdout).includes('开始静态门'),
+    `exit=${r.status}\n${r.stdout}`);
+}
+
+// ---- 场景 12：--list 与 --test-cmd 互斥 ----
+{
+  const r = run(['--list', '--test-cmd', 'node nothing.mjs'], {});
+  check('场景 12：--list + --test-cmd → exit 1', r.status === 1 && /互斥/.test(r.stderr), `exit=${r.status} ${r.stderr}`);
+}
+
+// ---- 场景 13：生产模式中段红 → fail-fast + 未执行门清单 + 失败行留痕 ----
+// 编排脚本检查门注入一份缺 frontmatter 的坏编排（E1 error）→ 第 3 门红，后四门状态未知须点名
+{
+  const root = provision(mkfix());
+  fs.mkdirSync(path.join(root, '.agents', 'workflows'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.agents', 'workflows', 'bad.md'), '没有 frontmatter 的坏编排\n', 'utf8');
+  const bare = fs.mkdtempSync(path.join(os.tmpdir(), 'verify-bare-ff-'));
+  const r = run([], { cwd: bare, env: { ...process.env, CHECK_LOOP_ROOT: root } });
+  check('场景 13：exit 1 且不出全绿', r.status === 1 && !r.stdout.includes('全绿'), `exit=${r.status}\n${r.stdout}\n${r.stderr}`);
+  check('场景 13：fail-fast 点名未执行门（rule-budget、effective-policy、check-loop、ledger-invariant）',
+    r.stderr.includes('未执行门') && ['rule-budget', 'effective-policy', 'check-loop', 'ledger-invariant'].every((id) => r.stderr.includes(id)),
+    r.stderr);
+  const lines = readLedger(root);
+  check('场景 13：失败行留痕（suite=workflows-check）且无绿行',
+    lines.length === 1 && lines[0].suite === 'workflows-check' && lines[0].exitCode !== 0,
+    `lines=${JSON.stringify(lines)}`);
+  fs.rmSync(root, { recursive: true, force: true });
+  fs.rmSync(bare, { recursive: true, force: true });
+}
+
+// ---- 场景 14：生产模式全绿端到端——七门按序全过、凭证钉门数/headShort/套件计数、摘要生成 ----
+{
+  const root = provision(mkfix());
+  // 根 package.json（装户带根 package.json 的形态）：测试命令打印编排器权威汇总行
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({
+    name: 'verify-e2e-fixture',
+    private: true,
+    scripts: { test: 'node .agents/probe-test.mjs' },
+  }, null, 2));
+  fs.writeFileSync(path.join(root, '.agents', 'probe-test.mjs'), "console.log('[run-tests] 合计: SUITES 3 / FAILED 0');\n", 'utf8');
+  const headShort = gitify(root);
+  const r = run([], { cwd: root, env: { ...process.env, CHECK_LOOP_ROOT: root } });
+  check('场景 14：exit 0 且七门逐门输出 + 全绿',
+    r.status === 0 && ['✅ 1/7', '✅ 2/7', '✅ 3/7', '✅ 4/7', '✅ 5/7', '✅ 6/7', '✅ 7/7'].every((s) => r.stdout.includes(s)) && r.stdout.includes('全绿'),
+    `exit=${r.status}\n${r.stdout}\n${r.stderr}`);
+  const line = readLedger(root)[0] || null;
+  check('场景 14：绿凭证钉门数 7 + headShort + 套件计数',
+    line !== null && line.exitCode === 0 && line.gates === 7 && line.headShort === headShort && line.passed === 3 && line.failed === 0,
+    `headShort=${line && line.headShort} expect=${headShort} line=${JSON.stringify(line)}`);
+  const ev = path.join(root, 'workflow', 'verify-evidence.md');
+  const evText = fs.existsSync(ev) ? fs.readFileSync(ev, 'utf8') : '';
+  check('场景 14：绿凭证摘要已生成且含本 SHA 一行（自动重生成接线）',
+    fs.existsSync(ev) && evText.includes(`\`${headShort}\``) && evText.includes('| 7 | PASS 3 / FAIL 0 |'),
+    evText);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 if (fail) {
   console.log('\n用法：node templates/_agents/scripts/verify.test.mjs');

package/templates/_agents/scripts/wf-journal.mjs

@@ -15,6 +15,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { parseStages } from './workflows-check.mjs';
+// 委派台账分片感知读（2026-10-13 ledger-shard-ledgers 回灌）：单源 = ledger-shards.readDelegationsText。
+import { readDelegationsText as readDelegationsShardText } from './ledger-shards.mjs';
 
 function fail(msg) { console.error('❌ ' + msg); process.exit(1); }
 
@@ -162,8 +164,9 @@ if (isMain) {
   fail(`未知命令：${a.cmd ?? ''}（add | status，用法见文件头注释）`);
 }
 function readDelegationsText(file) {
-  const p = file || path.join(process.cwd(), 'workflow', 'delegations.md');
-  try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+  // 分片感知读（2026-10-13 ledger-shard-ledgers 回灌）：单源 = ledger-shards.readDelegationsText。
+  //（file 为显式注入路径时只读该文件——测试语义不变；null/默认路径 → 主台账 ∪ delegations.d/*.md）
+  return readDelegationsShardText(process.cwd(), file || null);
 }
 
 function delegationSectionRows(text) {
@@ -172,8 +175,9 @@ function delegationSectionRows(text) {
   const rows = [];
   for (const line of lines) {
     if (/^##\s+/.test(line)) {
-      if (inSec) break;
-      if (/^##\s+委派结果\s*$/.test(line)) inSec = true;
+      // 不 break：合并文本（主台账 ∪ 分片）里 `## 委派结果` 会出现多次，break 会漏掉后续分片的行
+      // （2026-10-13 源仓实测踩中：分片行读不到 → 静默漏报「委派台账未记录」）。
+      inSec = /^##\s+委派结果\s*$/.test(line);
       continue;
     }
     if (!inSec || !/^\s*\|/.test(line)) continue;

package/templates/_agents/scripts/workflow-board-server.test.mjs

@@ -64,7 +64,7 @@ const CHECK_LOOP = path.join(SCRIPT_DIR, 'check-loop.mjs');
     'doc.status.abandoned=superseded cancelled',
     'incident.status.all=open fixed closed',
     'incident.status.active=open',
-    'level.all=L0 L1 L2 L3',
+    'level.all=L1 L2 L3',
   ].join('\n') + '\n');
   const w = (rel, c) => fs.writeFileSync(path.join(T, rel), c);
   // 回路断档：incident 三件套选「是」但引用 intent 不存在
@@ -169,7 +169,7 @@ const CHECK_LOOP = path.join(SCRIPT_DIR, 'check-loop.mjs');
     requirement: '在 runtime-env.md 补记 pipeline-run 运行态',
     stage: 'done',
     stopType: 'done',
-    triage: { kind: 'require', level: 'L0', module: 'pipeline', topic: 'runtime-note', decidedBy: 'ai' },
+    triage: { kind: 'require', level: 'L1', module: 'pipeline', topic: 'runtime-note', decidedBy: 'ai' },
     updatedAt: '2026-10-02T10:19:22.566Z',
     events: [
       { t: '2026-10-02T10:19:02.680Z', type: 'run-created', requirement: 'x' },