agentic-flow-kit 1.7.15 → 1.8.0

package/templates/_agents/scripts/run-tests.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// run-tests — 引擎脚本测试统一入口（2026-10-08 agents-hygiene 批2；2026-10-09 并行化）
+// 用途：一条命令跑 .agents/scripts/ 下全部 *.test.mjs 套件——逐个 node 直跑（与 test.md 逐条口径一致，
+//       不引 node --test：既有套件是自研 check/「合计: PASS n / FAIL n」计数风格，非 node:test 风格）。
+// 语义：套件并发执行（默认 6，--concurrency <N> 可调，1 = 等价旧串行；非正整数 fail-loud）——每套件
+//       stdout/stderr 缓冲、完成即回放（「[run-tests] ▶ 套件名」分隔头，避免并行交错不可读）；
+//       stderr 仅红套件回放尾部 5 行防刷屏；聚合各套件「合计: PASS n / FAIL n」末次计数（无该行按 0 计）；
+//       任一套件 exit 非零 / spawn 失败 / 计数 FAIL>0 → 该套件记红；有红套件即 exit 1。
+//       套件发现 = 目录内 *.test.mjs 字典序（非递归）；回放按完成序（并行的自然结果，不影响裁决）。
+// 红线：只做调度层并行，不改任何套件内部；并发默认 6（2026-10-09 实测：串行 2m47s → 并发4 2m05s →
+// 并发6 1m48s，套件各异步 tmp fixture 无共享态）——Windows spawn 密集会放大瞬时抖动（同日实证一次
+// git EBUSY 偶发红），故不取更高默认；套件内 git 调用已有 gitRetry 防护。
+// 2026-10-10 复测定案（perf 系列）：6→12 仅 -3~5%（114.4s → 111.8/108.4s，本机 12 核，两次 c12 全绿
+// 无偶发红；噪声带 ±3s）——膝点在 4-6 间，并发档位已非杠杆：工作池地板 = check-loop.test 独跑
+// 73.8s（占总时长 65%，234 次套件内顺序 spawn node）。再快须并行化套件内场景（动套件内部结构，
+// 撞本红线），收益/风险另议；默认维持 6。
+// 用法：node .agents/scripts/run-tests.mjs [--dir <目录>] [--only <文件名子串>] [--concurrency <N>]
+//       --dir 默认本脚本所在目录（测试注入钩子）；--only 过滤文件名（调试单套件用，如 --only check-loop）。
+// 测试：node .agents/scripts/run-tests.test.mjs（临时目录夹具：并行全绿聚合 / 红套件 / 崩溃套件 / --only / 空目录 / 并发数校验 / 并发1=串行）
+// 沿革：2026-10-08 立档（串行）；2026-10-09 并行化（sess_52d1d1be 路线图「串行→并行」真缺口）。
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+const val = (flag) => (args.includes(flag) ? args[args.indexOf(flag) + 1] : null);
+const dir = val('--dir') || SCRIPT_DIR;
+const only = val('--only');
+const concRaw = val('--concurrency');
+const CONC = concRaw === null ? 6 : Number(concRaw);
+if (!Number.isInteger(CONC) || CONC < 1) {
+  console.error(`run-tests: --concurrency 须为正整数（现 ${concRaw}）`);
+  process.exit(1);
+}
+
+let suites;
+try {
+  suites = fs.readdirSync(dir).filter((f) => f.endsWith('.test.mjs') && (!only || f.includes(only))).sort();
+} catch (e) {
+  console.error(`run-tests: 无法读取目录 ${dir}（${e.code || e.message}）`);
+  process.exit(1);
+}
+if (!suites.length) {
+  console.error(`run-tests: ${dir} 下无 *.test.mjs${only ? `（--only ${only}）` : ''}`);
+  process.exit(1);
+}
+
+// 工作池调度（完成一个补一个——分块会让最慢套件阻塞同块槽位，2026-10-09 实测 check-loop.test 独占 ~1/3 时长）
+let totalPass = 0, totalFail = 0, red = 0;
+const runSuite = (s) => new Promise((resolve) => {
+  const child = spawn(process.execPath, [path.join(dir, s)]);
+  let out = '', err = '';
+  child.stdout.on('data', (d) => { out += d; });
+  child.stderr.on('data', (d) => { err += d; });
+  child.on('close', (code) => resolve({ stdout: out, stderr: err, status: code, error: null }));
+  child.on('error', (e) => resolve({ stdout: out, stderr: err, status: null, error: e }));
+});
+const replay = (s, r) => {
+  const m = [...String(r.stdout || '').matchAll(/合计: PASS (\d+) \/ FAIL (\d+)/g)].pop();
+  const p = m ? Number(m[1]) : 0;
+  const f = m ? Number(m[2]) : 0;
+  totalPass += p;
+  totalFail += f;
+  const ok = r.status === 0 && f === 0;
+  process.stdout.write(`\n[run-tests] ▶ ${s}\n`);
+  if (r.stdout) process.stdout.write(r.stdout);
+  if (ok) {
+    console.log(`[run-tests] OK ${s}（PASS ${p} / FAIL ${f}）`);
+  } else {
+    red++;
+    console.log(`[run-tests] RED ${s}${r.status != null ? `（exit ${r.status}）` : r.error ? `（spawn ${r.error.code || r.error.message}）` : ''}${m ? `（PASS ${p} / FAIL ${f}）` : ''}`);
+    if (r.stderr) process.stderr.write(String(r.stderr).split('\n').slice(-5).join('\n') + '\n');
+  }
+};
+{
+  const queue = [...suites];
+  const inflight = new Map(); // suite -> promise（回放按提交序记录、完成即按序回放：用「下一个待回放」指针）
+  const pending = [];         // {s, promise}
+  let cursor = 0;
+  const launch = () => {
+    while (inflight.size < CONC && queue.length) {
+      const s = queue.shift();
+      const pr = runSuite(s).then((r) => ({ s, r }));
+      inflight.set(s, pr);
+      pending.push(pr);
+    }
+  };
+  launch();
+  while (cursor < pending.length) {
+    const { s, r } = await pending[cursor++];
+    inflight.delete(s);
+    replay(s, r);
+    launch();
+  }
+}
+console.log(`\n[run-tests] 套件 ${suites.length}（红 ${red}，并发 ${CONC}）｜断言合计 PASS ${totalPass} / FAIL ${totalFail}${red ? '——红套件见上，修复后原路重跑' : '——全绿'}`);
+process.exit(red ? 1 : 0);

package/templates/_agents/scripts/run-tests.test.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+// run-tests.mjs 的夹具驱动测试（2026-10-08 agents-hygiene 批2）
+// 场景：①全绿目录 → exit 0 且聚合计数正确；②含红套件（FAIL>0 + exit 1）→ 记红且 exit 1；
+//       ③崩溃套件（throw，无合计行）→ 记红且 exit 1；④--only 过滤；⑤空目录 → exit 1。
+// 用法：node .agents/scripts/run-tests.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';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const MAIN = path.join(SCRIPT_DIR, 'run-tests.mjs');
+const USAGE = '用法：node .agents/scripts/run-tests.test.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 = (files) => {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'run-tests-fx-'));
+  for (const [name, body] of Object.entries(files)) fs.writeFileSync(path.join(d, name), body);
+  return d;
+};
+const run = (args) => spawnSync(process.execPath, [MAIN, ...args], { encoding: 'utf8' });
+
+// ---- 场景 1：全绿目录 → exit 0 且聚合计数（非 .test.mjs 文件不入围）----
+{
+  const d = mkfix({ 'a.test.mjs': 'console.log("合计: PASS 3 / FAIL 0");', 'b.test.mjs': 'console.log("合计: PASS 2 / FAIL 0");', 'readme.md': 'x' });
+  const r = run(['--dir', d]);
+  check('场景 1：全绿目录 → exit 0', r.status === 0, `exit=${r.status}\n${r.stdout}${r.stderr}`);
+  check('场景 1：聚合计数 PASS 5 / FAIL 0 且红 0', /断言合计 PASS 5 \/ FAIL 0/.test(r.stdout) && /红 0/.test(r.stdout), r.stdout);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 2：红套件（计数 FAIL>0 且 exit 1）→ 记红且 exit 1 ----
+{
+  const d = mkfix({ 'a.test.mjs': 'console.log("合计: PASS 3 / FAIL 0");', 'bad.test.mjs': 'console.log("合计: PASS 1 / FAIL 2"); process.exit(1);' });
+  const r = run(['--dir', d]);
+  check('场景 2：含红套件 → exit 1', r.status === 1, `exit=${r.status}`);
+  check('场景 2：红套件被点名', /RED bad\.test\.mjs/.test(r.stdout) && /红 1/.test(r.stdout) && /FAIL 2/.test(r.stdout), r.stdout);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 3：崩溃套件（无合计行）→ 记红且 exit 1 ----
+{
+  const d = mkfix({ 'boom.test.mjs': 'throw new Error("boom");' });
+  const r = run(['--dir', d]);
+  check('场景 3：崩溃套件 → exit 1 且标红', r.status === 1 && /RED boom\.test\.mjs（exit 1）/.test(r.stdout), r.stdout);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 4：--only 过滤 ----
+{
+  const d = mkfix({ 'aa.test.mjs': 'console.log("合计: PASS 1 / FAIL 0");', 'bb.test.mjs': 'console.log("合计: PASS 2 / FAIL 0");' });
+  const r = run(['--dir', d, '--only', 'bb']);
+  check('场景 4：--only 只跑匹配套件', r.status === 0 && r.stdout.includes('bb.test.mjs') && !r.stdout.includes('aa.test.mjs') && /套件 1/.test(r.stdout), r.stdout);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 5：空目录 → exit 1 报无套件 ----
+{
+  const d = mkfix({ 'readme.md': 'x' });
+  const r = run(['--dir', d]);
+  check('场景 5：空目录 → exit 1 报无套件', r.status === 1 && /无 \*\.test\.mjs/.test(r.stderr || ''), `${r.status}\n${r.stderr}`);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 6：--concurrency 校验——非正整数 fail-loud ----
+{
+  const d = mkfix({ 'a.test.mjs': 'console.log("合计: PASS 1 / FAIL 0");' });
+  for (const bad of ['0', '-2', 'abc', '2.5']) {
+    const r = run(['--dir', d, '--concurrency', bad]);
+    check(`场景 6：--concurrency ${bad} → exit 1 fail-loud`, r.status === 1 && /正整数/.test(r.stderr), `exit=${r.status}\n${r.stderr}`);
+  }
+  const ok = run(['--dir', d, '--concurrency', '1']);
+  check('场景 6：--concurrency 1（串行兼容）→ exit 0 聚合正确', ok.status === 0 && /断言合计 PASS 1 \/ FAIL 0/.test(ok.stdout), `exit=${ok.status}\n${ok.stdout}`);
+  const okN = run(['--dir', d, '--concurrency', '8']);
+  check('场景 6：--concurrency 8（超套件数）→ exit 0', okN.status === 0 && /断言合计 PASS 1 \/ FAIL 0/.test(okN.stdout), `exit=${okN.status}\n${okN.stdout}`);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 7：并行回放完整（每套件有 ▶ 分隔头且计数聚合不分串）----
+{
+  const d = mkfix({
+    'a.test.mjs': 'console.log("a-out 合计: PASS 1 / FAIL 0");',
+    'b.test.mjs': 'console.log("b-out 合计: PASS 2 / FAIL 0");',
+    'c.test.mjs': 'console.log("c-out 合计: PASS 3 / FAIL 0");',
+  });
+  const r = run(['--dir', d]);
+  check('场景 7：并行全绿 → 聚合 PASS 6 且三套件回放齐全',
+    r.status === 0 && /断言合计 PASS 6 \/ FAIL 0/.test(r.stdout) && /▶ a\.test\.mjs/.test(r.stdout) && /▶ b\.test\.mjs/.test(r.stdout) && /▶ c\.test\.mjs/.test(r.stdout), `exit=${r.status}\n${r.stdout}`);
+  check('场景 7：并行下套件输出不串（a-out 紧邻其回放块）', /▶ a\.test\.mjs\na-out/.test(r.stdout), r.stdout);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+if (fail) {
+  console.log(`\n${USAGE}`);
+  process.exit(1);
+}
+process.exit(0);

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

@@ -26,7 +26,7 @@ const ENUMS_FIXTURE = [
   '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 mkfix = () => {

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

@@ -6,15 +6,18 @@
 //   incident 入口 = 文件存在 + 「时间线」小节内、行首列表条目含「用户确认」（原 maintain.md §3 约定；
 //     2026-09-30 复核 P2-1 收窄为小节内行首条目；第三轮复核 P1-1 起接受日期前缀形态，与模板样例一致）；
 //     状态 ∈ {open, fixed, closed}（spec/plan 须先于 fixed 起草，故 open 即为有效态）。
-//   入口「级别」须 ∈ L0-L3；缺失即拒（fail-closed）——**但库存量形态短路**（`流程: legacy` 或 日期早于
+//   入口「级别」须 ∈ L1-L3（2026-10-13 L0 退役，自源仓收敛系列 1 回灌；L0 → suspect 走 fail-closed）；
+//     缺失即拒（fail-closed）——**但库存量形态短路**（`流程: legacy` 或 日期早于
 //     确认门生效日）：跳过级别校验与 spec 档（2026-09-30 增量复核 N1——存量最可能缺级别，硬拒会锁死
 //     spec 起草与确认）。
 //   注意：**库存量信号本身即等于「入口已确认」**（judgeDoc：`台账行 || 存量口径`，与检查 15 / 检查 1 /
 //     配对门的既有口径一致——早于确认门生效日的自报日期即存量豁免，不要求另有台账行）；此处「短路」
 //     只额外豁免**级别前置与 spec 档**，不是对台账要求的二次豁免（P2-1：原注释把二者写反，已订正）。
 //   plan 门追加：入口级别（取入口 frontmatter 级别，不取工具 --level）为 L2/L3 时，同名 spec 须已确认（同口径）。
+//   L1 即入口例外（2026-10-13 自 Shipyard 回灌）：同名 intent/incident 均无时，级别 L1 的 plan 自身即入口，
+//     起草/确认门放行（文件已在则级别以文件 frontmatter 为准，禁用 --level L1 放行存量 L2 plan）。
 //   探索泳道豁免（2026-09-30 hybrid-governance-explore-hardening）：同名 intent 仍为 draft 且风险泳道为
-//     L0/L1（级别优先；级别缺失或非法时回落 risk_level——fill-intent 双写同值）→「先起草后确认」是协作道
+//     L1（级别优先；级别缺失或非法时回落 risk_level——fill-intent 双写同值）→「先起草后确认」是协作道
 //     语义（check-loop 检查 19 同款豁免口径），放行 spec/plan 起草与确认；L2/L3 防御道维持入口确认前置。
 //     incident 入口不豁免（过目留痕本就轻量）。收口由 check-loop --hardening 加固门兜底（入 main 前须
 //     intent approved/done + spec/plan 在场）。
@@ -25,6 +28,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { loadKitPolicy } from './policy.mjs';
+import { readLedgerRows } from './ledger-loader.mjs';
 
 export const ENTRY_STATUSES = ['approved', 'done'];
 export const INCIDENT_STATUSES = ['open', 'fixed', 'closed'];
@@ -48,16 +52,10 @@ function readBody(abs) {
 }
 
 // readLedger：confirmations.jsonl 追加式台账（坏行容忍跳过；与 check-loop 检查 15 同容错口径）
+// 读法收敛到 ledger-loader 单源（2026-10-12 ledger-loader-p1）：本函数此前自持 readFileSync+parse
+// 复刻，与其余 5 处各写各的——分片台账落地时逐处加分支必然漏改。签名与返回值不变。
 export function readLedger(root) {
-  const p = path.join(root, '.agents', 'confirmations.jsonl');
-  let text = '';
-  try { text = fs.readFileSync(p, 'utf8'); } catch { return []; }
-  const out = [];
-  for (const line of text.split('\n')) {
-    if (!line.trim()) continue;
-    try { out.push(JSON.parse(line)); } catch { /* 坏行跳过 */ }
-  }
-  return out;
+  return readLedgerRows(root);
 }
 
 // judgeDoc：状态枚举 + 机器事实源判定（供入口 / spec 复用）
@@ -151,32 +149,51 @@ export function specConfirmed(root, base) {
 // suspect 消费规则（双严）：红线类检查按 low 执行（拦红线）；豁免类门（起草豁免/--batch/--auto/加固门
 // lane/泳道豁免/逐阶段深度）按 high 执行（不豁免）。取代原三处并存语义（任一低即低 / 级别优先回落 / 仅级别）。
 export function laneOfEntry(level, risk, riskLevelSince, date) {
-  const L = /^L[0-3]$/.test(level || '') ? level : '';
+  const L = /^L[1-3]$/.test(level || '') ? level : '';
   if (!L) return 'suspect';
-  const R = /^L[0-3]$/.test(risk || '') ? risk : '';
+  const R = /^L[1-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 (dualProtocol) return (R && R === L) ? (L === 'L1' ? 'low' : 'high') : 'suspect';
   if (R && R !== L) return 'suspect';
-  return (L === 'L0' || L === 'L1') ? 'low' : 'high';
+  return 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';
+  if (!/^L[1-3]$/.test(level || '')) return 'suspect';
+  return level === 'L1' ? 'low' : 'high';
 }
 
 // draftGateFor：起草门总判（kind = 'spec' | 'plan'，fill 工具与 confirm-doc 逐阶段门共用）
-export function draftGateFor(kind, root, base) {
+// opts.level（可选，2026-10-13 自 Shipyard 回灌）：仅供 plan「L1 即入口」例外取级别——文件未落盘时认
+// fill 工具传入的 --level；confirm-doc 调用（confirmGateFor）不传，落盘后级别一律以文件 frontmatter 为准。
+export function draftGateFor(kind, root, base, opts = {}) {
   const entry = entryConfirmed(root, base);
   if (!entry.ok) {
-    // 探索泳道豁免（2026-09-30 hybrid-governance-explore-hardening）：L0/L1 draft intent 放行起草
+    // 探索泳道豁免（2026-09-30 hybrid-governance-explore-hardening）：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 };
     }
+    // L1 plan 即入口（2026-10-13 自 Shipyard 回灌）：没有 intent/incident 时，这份 plan 自己就是入口。
+    // 文件已在则级别以文件为准（禁止用 --level L1 把已有 L2 plan 放行）；尚未落盘才认 opts.level。
+    if (kind === 'plan' && entry.kind === null) {
+      const planAbs = path.join(root, 'workflow', 'plans', `${base}.md`);
+      const declared = fs.existsSync(planAbs) ? readFm(planAbs, '级别') : (opts.level || '');
+      if (declared === 'L1') {
+        return {
+          ok: true,
+          entry: {
+            ok: true, kind: 'plan', rel: `workflow/plans/${base}.md`, level: 'L1',
+            status: fs.existsSync(planAbs) ? (readFm(planAbs, '状态') || 'draft') : 'draft',
+            selfEntry: true, legacy: false,
+          },
+          laneBypass: true,
+        };
+      }
+    }
     return {
       ok: false,
       reason: `同主题入口未确认——${entry.reason}`,
@@ -188,11 +205,11 @@ export function draftGateFor(kind, root, base) {
   // spec 起草与确认。注意：库存量信号**本身即等于入口已确认**（judgeDoc 的 `台账行 || 存量口径`，
   // 与检查 1 / 15 / 配对门同口径）——台账豁免发生在 judgeDoc，不在本处；本处不做二次豁免
   // （第三轮复核 P2-1：原句「台账要求不豁免」把两件事写反，已订正）。
-  if (!entry.storageLegacy && !/^L[0-3]$/.test(entry.level)) {
+  if (!entry.storageLegacy && !/^L[1-3]$/.test(entry.level)) {
     return {
       ok: false,
       reason: `入口缺合法「级别」字段（现「${entry.level || '缺失'}」，无法判定前置深度）`,
-      hint: '先给入口补「级别: L0-L3」字段，再继续',
+      hint: '先给入口补「级别: L1-L3」字段，再继续',
     };
   }
   if (kind === 'plan' && !entry.storageLegacy && (entry.level === 'L2' || entry.level === 'L3')) {

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

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 // trust-mode: AI 自治信任等级管理（2026-09-30 ai-autonomy-trust；同日 hybrid-governance-risk-lanes 加名称双轨）
-// 管理 .agents/trust-mode.json，授权 AI 对 L0/L1 文档进行自治放行（--auto）。
+// 管理 .agents/trust-mode.json，授权 AI 对 L1 文档进行自治放行（--auto）。
 // 等级语义（名称 ↔ 数值双轨：confirm-doc.mjs 读数值 enabled/level，人机接口名称与数值皆收）：
 //   Strict   (level 0, enabled=false): AI 自治关闭（默认）——confirm-doc --auto 一律拒绝
-//   Standard (level 1): AI 可自批 L0/L1 draft -> approved
-//   Trusted  (level 2): AI 可自批 L0/L1 draft -> approved 及 approved -> done（全闭环）
+//   Standard (level 1): AI 可自批 L1 draft -> approved
+//   Trusted  (level 2): AI 可自批 L1 draft -> approved 及 approved -> done（全闭环）
 // 安全默认值：未开启（enabled: false）时，confirm-doc.mjs --auto 一律拒绝。
 import fs from 'node:fs';
 import path from 'node:path';
@@ -45,7 +45,7 @@ function main() {
     }
     writeConfig({ enabled: true, level, name: NAME_BY_LEVEL[level], enabledAt: new Date().toISOString() });
     console.log(`✅ AI 自治模式已开启 (${NAME_BY_LEVEL[level]} / Level ${level})`);
-    console.log(level === 1 ? '   授权范围：L0/L1 文档 draft -> approved' : '   授权范围：L0/L1 文档全闭环 (approved + done)');
+    console.log(level === 1 ? '   授权范围：L1 文档 draft -> approved' : '   授权范围：L1 文档全闭环 (approved + done)');
     return;
   }
 

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

@@ -30,7 +30,7 @@ const mkfix = () => {
   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');
+      'incident.status.all=open fixed closed', 'incident.status.active=open', 'level.all=L1 L2 L3'].join('\n') + '\n');
   fs.writeFileSync(path.join(d, '.agents', 'workflow-modules.txt'), '# modules\npipeline\nui\n');
   return d;
 };

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