agentic-flow-kit 1.8.1 → 1.8.7

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

@@ -5,6 +5,9 @@
 // 判据自多 worktree 合并丢行事故后的实战实现逐字回灌（出处留包源仓 git 历史与 CHANGELOG））
 // 目的：把「台账本地可写」的伪造面从事后对质级升为机器可检出级（能力评审审计维度扣分项）。
 // 台账不可变原则：confirmations 历史行禁删改——修正只能走追加补偿行（README 硬规则 6）。
+// 性能（2026-10-16 自源仓 ledger-git-batch 回灌）：历史全扫原为逐提交 `git show <sha>:<path>` +
+//   `git log -1 %P`，即 O(提交数) 次进程创建（Windows 单次 ~68ms，随历史线性膨胀）；改为一次
+//   `git log` 取 sha+父、一次 `cat-file --batch` 取该路径全部 blob（O(路径数)），判据与输出不变。
 //
 // 分片形态（2026-10-10 中期方案；2026-10-12 起为 confirm-doc 默认写入口径）：
 //   .agents/confirmations.d/<doc 基名>.jsonl —— 按 doc 分片，跨机/跨 worktree 确认不同 doc 时
@@ -103,14 +106,50 @@ const VALID_STAGES = new Set(['approved', 'done', 'fixed', 'closed', 'superseded
 // 历史基线（机制 2026-10-13 ledger-history-baseline，详见头注）：kit 缺省空 = 全量扫描
 const HISTORY_BASELINE = process.env.LEDGER_HISTORY_BASELINE || '';
 
-const git = (args, opts = {}) => execFileSync('git', args, { cwd: ROOT, encoding: 'buffer', maxBuffer: 64 * 1024 * 1024, ...opts });
 const gitText = (args) => execFileSync('git', args, { cwd: ROOT, encoding: 'utf8' });
-const blobOf = (ref) => git(['show', ref]); // ref 必须为完整对象引用（<sha>:<path> / HEAD:<path> / :<path>）
-// tryBlob：安全读 blob，失败返回 null 且**不向 stderr 外泄 git fatal 噪声**（删片场景读当前提交必失败，
-// 那是预期路径不是错误——历史扫描的高频探针路径必须静默）。
+
+// ---- git 对象批量读取（2026-10-16 自源仓 ledger-git-batch 回灌）----
+// 动机：逐提交 `git show <sha>:<path>` 在 Windows 上 ~68ms/次（进程创建主导），主台账提交数 × 2 次
+// （blob + 父列表）随历史线性膨胀；改为「一次 git log 取 sha+父」+「一次 cat-file --batch 取该路径
+// 全部 blob」——spawn 数自 O(提交数) 降到 O(路径数)，判据与输出不变。
+const blobCache = new Map(); // ref -> Buffer | null（null = 对象不可读，与旧 tryBlob 同语义）
+const prefetchBlobs = (refs) => {
+  const want = [...new Set(refs)].filter((r) => !blobCache.has(r));
+  if (!want.length) return;
+  const r = spawnSync('git', ['cat-file', '--batch'], {
+    cwd: ROOT, input: `${want.join('\n')}\n`, maxBuffer: 512 * 1024 * 1024,
+  });
+  // 非零 = 真错误（仓库不可读 / spawn 失败 / 输出超 maxBuffer），不是「对象不存在」——后者由
+  // `<ref> missing` 头表达且 status 仍为 0。此处必须响亮抛出：静默置 null 会让每个 blobOf 都判
+  // 「对象不可读」，把一次环境抖动伪装成满屏「台账删除」的假硬拦（判据失真比崩溃更坏）。
+  if (r.status !== 0) {
+    throw new Error(`git cat-file --batch 失败（exit ${r.status ?? r.error?.code}）：${String(r.stderr || r.error?.message || '').trim().slice(0, 200)}`);
+  }
+  const buf = r.stdout;
+  let off = 0;
+  for (const ref of want) {
+    const nl = buf.indexOf(0x0a, off);
+    if (nl < 0) { blobCache.set(ref, null); continue; }
+    const header = buf.toString('utf8', off, nl);
+    off = nl + 1;
+    const m = /^[0-9a-f]+ \w+ (\d+)$/.exec(header); // 不匹配 = `<ref> missing` / ambiguous
+    if (!m) { blobCache.set(ref, null); continue; }
+    const size = Number(m[1]);
+    blobCache.set(ref, buf.subarray(off, off + size));
+    off += size + 1; // 内容后随一个 LF
+  }
+};
+// blobOf：ref 必须为完整对象引用（<sha>:<path> / HEAD:<path> / :<path>）；不可读即抛（调用方据此判删除）
+const blobOf = (ref) => {
+  if (!blobCache.has(ref)) prefetchBlobs([ref]);
+  const b = blobCache.get(ref);
+  if (b === null) throw new Error(`git cat-file: ${ref} 不可读`);
+  return b;
+};
+// tryBlob：安全读 blob，失败返回 null（缓存 miss 时单点回源；删片场景读当前提交必失败，是预期路径）。
 const tryBlob = (ref) => {
-  const r = spawnSync('git', ['show', ref], { cwd: ROOT, encoding: 'buffer', maxBuffer: 64 * 1024 * 1024 });
-  return r.status === 0 ? r.stdout : null;
+  if (!blobCache.has(ref)) prefetchBlobs([ref]);
+  return blobCache.get(ref);
 };
 const linesOf = (buf) => buf.toString('utf8').split('\n').filter((l, i, a) => !(l === '' && i === a.length - 1) && l !== '');
 const isShard = (rel) => rel.startsWith(`${SHARD_DIR}/`) && rel.endsWith('.jsonl');
@@ -187,13 +226,26 @@ const shardDeleteReason = (sha, rel) => {
 // allowShardDelete：分片允许「已归并后删片（或缺行已终树补登）」这一种合法消失形态；主台账永不因归并被删。
 // 返回该路径的提交史（空 = 从未入库：装户/新仓/尚在暂存区）——零史路径整体跳过，与原实现
 // 「零提交历史即静默」的契约一致（行级校验也只覆盖有史的路径，否则新仓首版会被 doc 不存在误杀）。
-function historyShas(rel) {
+// 2026-10-16 ledger-git-batch：一次 git log 同取 %H 与 %P（父列表原先逐提交另起一次 spawn），
+// 结果按 rel 缓存并回填 parentMap 供 parentShas 免 spawn 查询。
+const historyCache = new Map(); // rel -> [{sha, parents}]
+const parentMap = new Map();    // sha -> parents
+function historyEntries(rel) {
+  if (historyCache.has(rel)) return historyCache.get(rel);
+  let entries = [];
   try {
     // --full-history：不做历史简化——TREESAME 合并也入列，防「ours 合并丢一侧行」被简化隐藏（审计门立场）
-    return gitText(['log', '--full-history', '--format=%H', '--reverse', '--', rel]).split(/\s+/).filter(Boolean);
+    const out = gitText(['log', '--full-history', '--format=%H %P', '--reverse', '--', rel]);
+    entries = out.split(/\r?\n/).filter((l) => l.trim()).map((l) => {
+      const [sha, ...parents] = l.trim().split(/\s+/);
+      return { sha, parents };
+    });
   } catch {
-    return [];
+    entries = [];
   }
+  for (const e of entries) parentMap.set(e.sha, e.parents);
+  historyCache.set(rel, entries);
+  return entries;
 }
 
 // 基线后提交集（含基线可达性探测；无基线声明或基线不在本仓 → null = 基线不生效，全史扫描）
@@ -210,8 +262,9 @@ const postBaselineSet = () => {
   return _postBaseline;
 };
 
-// 多父提交的父列表（%P 全父）
+// 多父提交的父列表（%P 全父）——优先查 historyEntries 回填的 parentMap（免 spawn），未命中才回退 git
 const parentShas = (sha) => {
+  if (parentMap.has(sha)) return parentMap.get(sha);
   try {
     return gitText(['log', '-1', '--format=%P', sha]).split(/\s+/).filter(Boolean);
   } catch {
@@ -221,10 +274,12 @@ const parentShas = (sha) => {
 
 // 合并并集对账：cur 行集须恰为各父行集之并（无丢失、无凭空新增）。返回 null = 认可；否则返回原因。
 // 父提交无此路径（单侧新增）跳过该父；行比对按整行字符串（与 linesOf/前缀判据同粒度）。
-const mergeUnionProblem = (sha, rel, curBuf) => {
+// 2026-10-16 自源仓回灌：签名自 sha 改收 parents 数组——--staged 合并态无提交 sha，由调用方传
+// [HEAD, MERGE_HEAD…]；历史全扫（传 parentShas(sha)）与 --staged 共用本判据（不新开口子）。
+const mergeUnionProblem = (parents, rel, curBuf) => {
   const curLines = new Set(linesOf(curBuf));
   const parentLines = new Set();
-  for (const p of parentShas(sha)) {
+  for (const p of parents) {
     const b = tryBlob(`${p}:${rel}`);
     if (b === null) continue;
     for (const l of linesOf(b)) parentLines.add(l);
@@ -272,19 +327,26 @@ const mergePruneProblem = (parents, rel, curBuf, manifest) => {
 };
 
 function scanHistory(rel, { allowShardDelete }) {
-  const allShas = historyShas(rel);
-  if (!allShas.length) return allShas;
-  let shas = allShas;
+  const allEntries = historyEntries(rel);
+  if (!allEntries.length) return [];
+  let entries = allEntries;
   // 历史基线：只走基线后提交（详见头注）——DAG 感知比对下各提交自对己父，无需线性化起点
   const post = postBaselineSet();
   if (post) {
-    const kept = shas.filter((sha) => post.has(sha));
-    if (kept.length !== shas.length) {
-      console.error(`[info] ${rel}：${shas.length - kept.length} 个前基线提交按 HISTORY_BASELINE 声明豁免（owner 授权，见脚本头注）`);
+    const kept = entries.filter((e) => post.has(e.sha));
+    if (kept.length !== entries.length) {
+      console.error(`[info] ${rel}：${entries.length - kept.length} 个前基线提交按 HISTORY_BASELINE 声明豁免（owner 授权，见脚本头注）`);
     }
-    shas = kept;
+    entries = kept;
   }
-  for (const sha of shas) {
+  // 批量预取本路径全部 blob（各提交版本 + 各父版本）——一次 cat-file --batch 取代逐提交 git show
+  const refs = [];
+  for (const e of entries) {
+    refs.push(`${e.sha}:${rel}`);
+    for (const p of e.parents) refs.push(`${p}:${rel}`);
+  }
+  prefetchBlobs(refs);
+  for (const { sha, parents } of entries) {
     let cur;
     try { cur = blobOf(`${sha}:${rel}`); } catch {
       // 删除提交不是静默边界（复核 P2 收口）：主台账在 append-only 世界里永不应删除——任一历史提交删除
@@ -303,13 +365,12 @@ function scanHistory(rel, { allowShardDelete }) {
     }
     // DAG 感知基准：本提交第一父的 blob（dag-aware-base）——线性化「前一承」在分支汇合处会拿
     // 另一侧提交当基准产生伪前缀破坏；根提交（无父）视为新文件起步。
-    const parents = parentShas(sha);
     const base = parents.length ? tryBlob(`${parents[0]}:${rel}`) : null;
     if (base === null) continue; // 首现（父无此路径）：无基线可比，行级校验兜底
     if (parents.length >= 2) {
       // 多父提交无条件走并集对账（前缀通过不得短路——ours-resolution 合并树与第一父逐字节同 blob，
       // 嵌套判法对静默丢行全盲）
-      const unionFail = mergeUnionProblem(sha, rel, cur);
+      const unionFail = mergeUnionProblem(parents, rel, cur);
       if (!unionFail) {
         console.error(`[info] ${sha.slice(0, 10)}：合并并集无丢失——union 合并语义认可，续扫`);
         continue;
@@ -336,7 +397,7 @@ function scanHistory(rel, { allowShardDelete }) {
       }
     }
   }
-  return allShas; // 交回该路径的全量提交史，供调用方判定「有史才进行级校验」
+  return allEntries.map((e) => e.sha); // 交回该路径的全量提交史，供调用方判定「有史才进行级校验」
 }
 
 // ---- 台账路径全集：主台账 + 历史上出现过的全部分片 ----
@@ -363,6 +424,18 @@ function ledgerPaths() {
 }
 
 // ---- --staged：暂存台账面 ⊇ HEAD 前缀，或携带 manifest 的特许修剪；分片删除须已并入暂存主台账 ----
+// 合并态口径（2026-10-16 自源仓 13f67ef7 回灌 staged-merge-union）：MERGE_HEAD 在场时暂存内容是**多父
+// 合并结果**，单看 HEAD 一父不够——合法合并形态下暂存 = 父母并集（− manifest removes），严格前缀等式
+// 必然不等而误拦。此时在严格等格外**再试父母并集集合对账**——与历史全扫同一函数 mergeUnionProblem /
+// mergePruneProblem、同一口径，不新开口子：并集须无丢失、无凭空行（既禁丢行也禁凭空行）。非合并态不启用。
+const mergeParents = (() => {
+  const r = spawnSync('git', ['rev-parse', 'MERGE_HEAD'], { cwd: ROOT, encoding: 'utf8' }); // octopus 可多行
+  if (r.status !== 0) return null; // 非合并态；spawnSync 吞 stderr，不外泄 fatal 噪声
+  const shas = String(r.stdout || '').split(/\s+/).filter(Boolean);
+  if (!shas.length) return null;
+  const h = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: ROOT, encoding: 'utf8' });
+  return [String(h.stdout || '').trim(), ...shas];
+})();
 if (staged) {
   const stagedHit = gitText(['-c', 'core.quotepath=off', 'diff', '--cached', '--name-only']).split(/\r?\n/).filter(Boolean);
   const touched = ledgerPaths().filter((rel) => stagedHit.includes(rel));
@@ -388,9 +461,21 @@ if (staged) {
           console.log(`台账不变量（--staged）— ${rel} 特许修剪通过：移除 ${m.removed} 行（${m.docs.length} 家族）——凭据 ${PRUNE_REL} 随笔入库，被删行可在 git 历史对质`);
           continue;
         }
+        // 合并态（2026-10-16 回灌）：严格前缀不适用 → 先纯并集对账，再落 manifest 修剪集合对账
+        // （与历史全扫的判定顺序一致）。非合并态两者皆拒。
+        const unionFail = mergeParents ? mergeUnionProblem(mergeParents, rel, cur) : '非合并态';
+        if (!unionFail) {
+          console.log(`台账不变量（--staged）— ${rel} 合并并集无丢失认可（${mergeParents.length} 父）——暂存行集恰为父母行集之并（无丢失、无凭空行），union 语义与历史全扫同口径`);
+          continue;
+        }
+        const setErr = mergeParents ? mergePruneProblem(mergeParents, rel, cur, loadManifestFromRef(`:${PRUNE_REL}`, ROOT)) : '非合并态';
+        if (!setErr) {
+          console.log(`台账不变量（--staged）— ${rel} 合并携带特许修剪通过：父母并集集合对账认可（${mergeParents.length} 父）——凭据 ${PRUNE_REL} 随笔入库，被删行可在 git 历史对质`);
+          continue;
+        }
         let off = 0;
         while (off < Math.min(head.length, cur.length) && head[off] === cur[off]) off++;
-        problems.push(`- [台账重写] ${rel} 暂存内容不是 HEAD 的前缀扩展（首异偏移 ${off}，HEAD ${head.length}B → 暂存 ${cur.length}B）${m && m.err ? `；特许修剪对账失败：${m.err}` : ''}`);
+        problems.push(`- [台账重写] ${rel} 暂存内容不是 HEAD 的前缀扩展（首异偏移 ${off}，HEAD ${head.length}B → 暂存 ${cur.length}B）${m && m.err ? `；特许修剪对账失败：${m.err}` : ''}${mergeParents ? `；合并并集集合对账亦失败：${setErr}` : ''}${mergeParents ? `；合并纯并集对账失败：${unionFail}` : ''}`);
       }
       continue;
     }

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

@@ -591,6 +591,34 @@ const mkMergeRepo = () => {
   fs.rmSync(d, { recursive: true, force: true });
 }
 
+// M12（2026-10-16 自源仓 13f67ef7 回灌补夹具）：合并态 --staged 删掉两父母共有行（不在 manifest
+// removes 里）→ 仍拦。共享行被删是 union 语义下的真丢失——manifest 只申报了分支侧行，共有行无凭据消失。
+const mkMergePruneRepo = () => {
+  const d = mkrepo();
+  const BR = G(d, ['symbolic-ref', '--short', 'HEAD']).stdout.trim();
+  const r2 = row({ ts: '2026-10-02T01:00:00.000Z', stage: 'done', doc: 'workflow/intents/gone.md' });
+  const comp = row({ ts: '2026-10-13T00:00:00.000Z', stage: 'done', note: '补偿行：doc 仍在' });
+  append(d, r2); commitAll(d, 'main r2');
+  G(d, ['checkout', '-qb', 'br']);
+  fs.writeFileSync(ledPath(d), [row(), comp].join('\n') + '\n');
+  writeManifest(d, { ts: '2026-10-13T00:00:00.000Z', authority: 't', reason: 'branch prune', removes: [sha256Of(r2)], docs: ['gone'] });
+  commitAll(d, 'br prune + compensation');
+  G(d, ['checkout', '-q', BR]);
+  fs.writeFileSync(path.join(d, 'other.txt'), 'x');
+  commitAll(d, 'main unrelated change');
+  G(d, ['merge', '--no-commit', 'br']);
+  return { d, r2, comp };
+};
+{
+  const { d, comp } = mkMergePruneRepo();
+  fs.writeFileSync(ledPath(d), comp + '\n'); // 双父共有行 row() 被删，comp 也不在 removes 内
+  G(d, ['add', '-A']);
+  const r = run(d, ['--staged']);
+  check('M12 合并态 --staged 删双父共有行 → exit 1',
+    r.code === 1 && /合并仍丢失 manifest 外/.test(r.out), r.out);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
 // ---- 历史基线（2026-10-13 ledger-history-baseline）：owner 声明豁免前基线时代 ----
 // B1：前基线改写无凭据——无基线全史扫描拦；LEDGER_HISTORY_BASELINE 指到 HEAD 后豁免过
 //     （kit 缺省无基线 = 全量扫描，与源实现「缺省基线指向自身仓提交、外来仓退化为全扫」同语义）
@@ -607,5 +635,5 @@ const mkMergeRepo = () => {
   fs.rmSync(d, { recursive: true, force: true });
 }
 
-console.log(`\n${fail ? `❌ ${fail} failed` : '✅ all passed'}（${pass} passed）`);
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/check-loop-rev.test.mjs

@@ -35,14 +35,6 @@ const check = (name, cond, detail = '') => {
   else { fail++; console.log(`FAIL  ${name}${detail ? `\n      ${String(detail).slice(0, 800)}` : ''}`); }
 };
 
-function shBin() {
-  for (const bin of ['sh', 'bash']) {
-    const r = spawnSync(bin, ['-c', 'echo ok'], { encoding: 'utf8' });
-    if (!r.error && r.status === 0) return bin;
-  }
-  return null;
-}
-
 function gitRun(cwd, args) {
   const r = spawnSync(git, args, { cwd, encoding: 'utf8' });
   if (r.status !== 0) throw new Error(`${args.join(' ')}\n${r.stderr || r.stdout}`);
@@ -145,17 +137,19 @@ try {
     console.log('SKIP doctor 契约核对（装户位置无包源 src/）');
   }
 
-  const sh = shBin();
-  check('找到 sh 以跑 pre-push', !!sh);
-  if (sh && !HOOK) console.log('SKIP pre-push 相关场景（未找到 _githooks / .githooks 下的 pre-push）');
-  if (sh && HOOK) {
+  // pre-push 已 node 化（2026-10-16 自源仓回灌）：直调 node 跑钩子，桩改 check-loop.mjs / commit-check.cjs
+  if (!HOOK) console.log('SKIP pre-push 相关场景（未找到 _githooks / .githooks 下的 pre-push）');
+  if (HOOK) {
     fs.mkdirSync(path.join(root, '.agents', 'scripts'), { recursive: true });
+    fs.mkdirSync(path.join(root, '.agents', 'hooks'), { recursive: true });
     const node = process.execPath.replace(/\\/g, '/');
     const loopSh = LOOP.replace(/\\/g, '/');
-    fs.writeFileSync(path.join(root, '.agents', 'scripts', 'check-loop.sh'), `#!/bin/sh\nexec "${node}" "${loopSh}" "$@"\n`);
+    fs.writeFileSync(path.join(root, '.agents', 'scripts', 'check-loop.mjs'), `import { spawnSync } from 'node:child_process';\nconst r = spawnSync(${JSON.stringify(node)}, [${JSON.stringify(loopSh)}, ...process.argv.slice(2)], { stdio: 'inherit' });\nprocess.exit(r.status ?? 1);\n`);
+    // 构建门桩：零退出占位——本套件测 --rev 扫描面，不测构建触发
+    fs.writeFileSync(path.join(root, '.agents', 'hooks', 'commit-check.cjs'), 'process.exit(0);\n');
     const hookPath = path.join(root, 'pre-push');
     fs.copyFileSync(HOOK, hookPath);
-    const push = (input) => spawnSync(sh, [hookPath], { cwd: root, input, encoding: 'utf8', timeout: 120000 });
+    const push = (input) => spawnSync(process.execPath, [hookPath], { cwd: root, input, encoding: 'utf8', timeout: 120000 });
     const onlyDelete = push(`refs/heads/old ${Z} refs/heads/old ${'b'.repeat(40)}\n`);
     check('stdin 只有删除行：不阻断', onlyDelete.status === 0, outOf(onlyDelete));
     const mixed = push(

package/templates/_agents/scripts/check-loop.mjs

@@ -92,6 +92,8 @@
 //      quote 字段职责冲突(对质凭据 vs 并录指纹,现归还单一职责)。无 batch 的历史行静默跳过
 //      (无判定依据的行不产出不可消除噪声——沿 audit-gate-hardening P3 教训)
 //  17. 发版提交树上仍未收口的 intent/spec/plan [hard-block]
+//      （2026-10-16 快径：当前树 package.json 无 version 字段 → 整段跳过——无 version 则版本变化提交
+//      永不存在恒不触发，省全历史 git 扫描；源仓「registry 登记恒不触发」同款口径）
 //  18. 委派台账对账 [warning]（policy v4 加 delegationSince 生效日豁免：日期早于锚的 L2/L3 存量豁免——
 //      delegations.md 记法自始不含文件名、无豁免时 113 条不可消退；缺键 v1-v3 维持原全量对账）
 //  19. 逐阶段审计（起草先于入口确认 / 台账审批顺序倒置） [warning]
@@ -926,6 +928,12 @@ export function runCheckLoop(opts = {}) {
   {
     const accCutoff = '2026-09-12';
     let legacyUnaccounted = 0;
+    // 测试绿缺凭证聚合面（2026-10-18 告警聚合口径批）：**判据不变**（同一批文档/证据项照常检出），
+    // 只改输出形态——单文档多证据项只计一份；跨运行当日去重（同文档当日只逐份点名一次，已点名的
+    // 进一条聚合计数行，防静默被误读为已修）。背景：源仓 9 天遥测该 WARN 占全部告警 61%
+    //（1062/1738，文档密集期 14.8 条/运行）——复读刷屏稀释 WARN 信号价值。状态面放 os.tmpdir()
+    // 按 ROOT 派生键（本地机判、不进装户仓、无 gitignore 依赖、fail-open：读失败=全点名，落失败不影响裁决）。
+    const verifyMissingDocs = new Map(); // rel -> base（去重键 = 仓内相对路径）
     // 测试绿凭证状态（2026-10-07 verify-evidence）：台账读一次循环外缓存；policy 缺 verifySince
     //（v1-v4）→ ctxBase null → 对账整体跳过（向后兼容）
     const verifySinceOf = kitPolicy.verifySince;
@@ -1027,9 +1035,7 @@ export function runCheckLoop(opts = {}) {
         const hasImplEvidence = results.some((r) => r.t.ok && (r.t.type === 'sha' || r.t.type === 'process'));
         for (const r of results) {
           if (r.t.ok && r.t.type === 'verify-missing') {
-            // ⚠️ 文案锚点硬约束（既有 check-loop.test.mjs:2743 锚定「测试绿缺凭证」四字连续，零改动前提）：
-            // doc 与修复命令只能追加在整句之后，不得插进这四个字中间。
-            warnings.push(`- [WARN 测试绿缺凭证] ${base} 验收证据声明「测试绿」但 24h 内无 verify 凭证（verifications.jsonl${verifyDocBound ? `；本单须带 --doc 落账` : ''}）——跑 node .agents/scripts/verify.mjs${verifyDocBound ? ` --doc ${rel}` : ''} 后重跑（advisory，灰度第一档）`);
+            verifyMissingDocs.set(rel, base); // 出账统一在循环外（聚合/当日去重，见声明处注释）
             continue;
           }
           if (r.t.ok) continue;
@@ -1118,6 +1124,31 @@ export function runCheckLoop(opts = {}) {
           legacyUnaccounted++;
         }
     }
+    // 测试绿缺凭证出账（判据见 collector；⚠️ 文案锚点硬约束：既有 check-loop.test.mjs 锚定
+    // 「测试绿缺凭证」四字连续，doc 与修复命令只能追加在整句之后，不得插进四字中间）：
+    // 当日首次命中的文档逐份点名（可操作明细）；当日已点名的聚合成一条计数行。
+    if (verifyMissingDocs.size) {
+      const today = new Date().toISOString().slice(0, 10);
+      const statePath = path.join(os.tmpdir(), `agentic-flow-kit-check8-warn-${ROOT.replace(/[^A-Za-z0-9]/g, '-').slice(-60)}.json`);
+      let warnedToday = {};
+      try { warnedToday = JSON.parse(fs.readFileSync(statePath, 'utf8')); } catch { /* 无状态/坏状态 = 空集 → 全部点名 */ }
+      const silent = [];
+      for (const [rel, base] of verifyMissingDocs) {
+        if (warnedToday[rel] === today) silent.push({ rel, base });
+        else {
+          warnings.push(`- [WARN 测试绿缺凭证] ${base} 验收证据声明「测试绿」但 24h 内无 verify 凭证（verifications.jsonl${verifyDocBound ? `；本单须带 --doc 落账` : ''}）——跑 node .agents/scripts/verify.mjs${verifyDocBound ? ` --doc ${rel}` : ''} 后重跑（advisory，灰度第一档）`);
+        }
+      }
+      if (silent.length) {
+        warnings.push(`- [WARN 测试绿缺凭证] 另有 ${silent.length} 份在飞文档同日已点名、去重静默（${silent.slice(0, 5).map((d) => d.base).join('、')}${silent.length > 5 ? '…' : ''}）——修法同上：跑 node .agents/scripts/verify.mjs${verifyDocBound ? ' --doc <本单>' : ''} 后重跑（advisory，灰度第一档）`);
+      }
+      try {
+        // 只留当日命中（隔日自动失效，状态面自洁；本机各 ROOT 独立键，互不串扰）
+        const next = {};
+        for (const [rel] of verifyMissingDocs) next[rel] = today;
+        fs.writeFileSync(statePath, JSON.stringify(next));
+      } catch { /* 落状态失败不影响裁决与输出（fail-open，advisory 层不因状态面故障改行为面） */ }
+    }
     if (legacyUnaccounted > 0) {
       warnings.push(`- [WARN 验收对账存量] ${legacyUnaccounted} 个存量 done intent 验收标准未对账（生效日锚之前加入仓库，豁免 hard，不回填）`);
     }
@@ -1422,7 +1453,13 @@ export function runCheckLoop(opts = {}) {
   // policy.check17UnclosedAfter 时阻断。版本 1 没有该键，因此不启用后两格。
   // 版本按主、次、修订三段整数比较。沿 package.json 的全部历史查找，不设次数上限。
   // 该提交之后新建的文件不在范围内。open 的 incident 不在此列。
+  // 快径（2026-10-16 减重 自源仓回灌）：当前树 package.json 无 version 字段（装户非 node 仓 / 快照树）
+  // → 整段跳过——无 version 则「version 变化的提交」永不存在，本段恒不触发，省去全历史 git log+show
+  // 扫描。适配点：源仓 s17 为独立模块函数用 return 快返；kit 单体函数内改 if 包裹，保后续段照常执行。
   {
+    let curVer = null;
+    try { curVer = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8')).version; } catch { curVer = null; }
+    if (curVer) {
     const log = gitOut(['log', '--format=%H', '--', 'package.json']);
     if (log) {
       let release = null;
@@ -1452,6 +1489,7 @@ export function runCheckLoop(opts = {}) {
         }
       }
     }
+    }
   }
   } // laneOn(17) 守卫闭合
 

package/templates/_agents/scripts/check-loop.test.mjs

@@ -2792,6 +2792,43 @@ w(T, 'workflow/intents/2026-09-12-deep.md', INTENT('deep', '状态: draft\n级
   rmfix(T2);
 }
 
+// ---- 检查 8 测试绿缺凭证聚合口径（2026-10-18 告警聚合批）：判据不变、只改输出形态 ----
+// ① 单文档多「测试绿」证据项 → 首跑只出一份明细（per-doc 去重，不再逐项刷屏）；
+// ② 同一夹具当日第二次运行 → 明细静默 + 聚合计数行点名（跨运行当日去重——不是不报，是不复读；
+//    静默必须被计数行点名，防「没输出」被误读为「已修」）。
+{
+  const mkVeAgg = () => {
+    const T = mkfix();
+    gitInit(T);
+    w(T, '.agents/kit.json', JSON.stringify({ policyVersion: 5 }));
+    const iBody = '# INTENT — vea\n\n## 验收标准（可测试）\n- [x] 用例A通过（证据:测试全绿）\n- [x] 用例B通过（证据:测试全绿）\n';
+    const pBody = '# PLAN — vea\n';
+    const fpI = computeFingerprint(`---\n状态: approved\n级别: L1\n日期: 2026-10-18\n---\n${iBody}`);
+    const fpP = computeFingerprint(`---\n状态: approved\n级别: L1\n---\n${pBody}`);
+    w(T, 'workflow/intents/2026-10-18-vea.md', `---\n状态: done\n级别: L1\n日期: 2026-10-18\n确认指纹: ${fpI.slice(0, 16)}\n---\n${iBody}`);
+    w(T, 'workflow/plans/2026-10-18-vea.md', `---\n状态: done\n级别: L1\n确认指纹: ${fpP.slice(0, 16)}\n---\n${pBody}`);
+    const now = new Date().toISOString();
+    writeLedger(T, [
+      { ts: now, doc: 'workflow/intents/2026-10-18-vea.md', stage: 'done', fingerprint: fpI, prev: 'approved' },
+      { ts: now, doc: 'workflow/plans/2026-10-18-vea.md', stage: 'done', fingerprint: fpP, prev: 'approved' },
+    ]);
+    gitCommitAll(T, 'feat: vea fixture');
+    return T;
+  };
+  const T = mkVeAgg();
+  let r = run(T);
+  const first = outOf(r).split('\n').filter((l) => l.includes('测试绿缺凭证'));
+  check('检查 8 聚合口径:单文档多「测试绿」项 → 首跑只出一份明细',
+    r.status === 0 && first.length === 1 && first[0].includes('2026-10-18-vea.md'),
+    `exit=${r.status}\n${outOf(r)}`);
+  r = run(T);
+  const second = outOf(r).split('\n').filter((l) => l.includes('测试绿缺凭证'));
+  check('检查 8 聚合口径:同日二跑 → 明细静默 + 聚合计数行（去重不吞债）',
+    r.status === 0 && second.length === 1 && second[0].includes('另有 1 份在飞文档同日已点名') && second[0].includes('2026-10-18-vea.md'),
+    `exit=${r.status}\n${outOf(r)}`);
+  rmfix(T);
+}
+
 // ---- 检查 8 凭证按 doc 绑定（2026-10-08 verify-doc-binding）：v6 收紧 / v5 不变 ----
 // 漏洞本体：凭证行不带 doc 字段 + 判定只看「全仓任意一份 24h 内绿行」→ 跑一次 verify 就能给全仓
 // 任意一单的「测试绿」声明背书。本组三条：① v6 + 只有他单绿行 → 仍出 WARN（漏洞已堵）；

package/templates/_agents/scripts/check-scope.test.mjs

@@ -4,8 +4,11 @@ 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 CLI = path.join(path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')), 'check-scope.mjs');
+// fileURLToPath 而非手搓 pathname 解码（源仓 fdded128）：URL pathname 对非 ASCII 路径百分号编码，
+// Windows 中文 worktree 路径下子进程「Cannot find module」静默红。
+const CLI = path.join(path.dirname(fileURLToPath(import.meta.url)), 'check-scope.mjs');
 let pass = 0, fail = 0;
 const check = (name, cond, detail = '') => {
   if (cond) { pass++; console.log(`PASS  ${name}`); }

package/templates/_agents/scripts/check-scripts-syntax.mjs

@@ -4,13 +4,16 @@
 //       任何文件不可解析即判红（先例教训：verify.mjs:31 SyntaxError 带病进 CI，全链门静默失效）。
 // 语义与红线：只读裁决，不改任何状态；检查目录缺失或可检文件数为 0 一律判红（fail-closed，
 //       防「改名/删除脚本即去门」）；不 import 任何引擎件，零依赖可独立调度。
+// 性能（2026-10-16 自源仓 scripts-syntax-parallel 回灌）：node --check 无原地解析 ESM 的 API，
+//       只能逐文件起子进程（单次 ~70ms × 全量脚本）；改工作池并发（min(8, cpus-2)），判红集合不变。
 // 测试：node .agents/scripts/check-scripts-syntax.test.mjs
 // 用法：node .agents/scripts/check-scripts-syntax.mjs [目录...]（相对仓库根；缺省 .agents/scripts .agents/hooks；
 //       CHECK_LOOP_ROOT 可覆写仓库根，与 check-loop/verify 同口径）
 // 沿革：2026-10-09 guardian-selfcheck（审计 P0-1 立项，verify.mjs GATES 首门消费）。
 
 import fs from 'node:fs';
-import { spawnSync } from 'node:child_process';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -21,8 +24,8 @@ const DEFAULT_DIRS = ['.agents/scripts', '.agents/hooks'];
 const dirs = process.argv.slice(2);
 const targets = dirs.length ? dirs : DEFAULT_DIRS;
 
-let total = 0;
-const reds = [];
+// 守卫文件清单（目录缺失 fail-closed；可检文件数 0 fail-closed——防「改名/删除脚本即去门」）
+const files = [];
 const missing = [];
 for (const d of targets) {
   const abs = path.resolve(ROOT, d);
@@ -34,14 +37,34 @@ for (const d of targets) {
     missing.push(d);
     continue;
   }
-  for (const f of names.filter((n) => /\.(mjs|cjs)$/.test(n)).sort()) {
-    total++;
-    const r = spawnSync(process.execPath, ['--check', path.join(abs, f)], { encoding: 'utf8' });
-    if (r.status !== 0) {
-      const first = (r.stderr || '').split(/\r?\n/).find((l) => l.trim()) || `exit ${r.status}`;
-      reds.push(`[syntax] ❌ ${d}/${f}: ${first}`);
+  for (const f of names.filter((n) => /\.(mjs|cjs)$/.test(n)).sort()) files.push({ rel: `${d}/${f}`, abs: path.join(abs, f) });
+}
+const total = files.length;
+
+// node --check 逐文件起子进程（无 API 可原地解析 ESM 而不执行），工作池并发后墙钟 ≈ 单次 spawn ×
+// ceil(文件数/并发)。裁决口径不变：任一文件不可解析即判红，判红文件按路径排序输出（并发下不回放乱序）。
+const reds = [];
+{
+  const conc = Math.max(2, Math.min(8, os.cpus().length - 2));
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < files.length) {
+      const t = files[cursor++];
+      const r = await new Promise((resolve) => {
+        const child = spawn(process.execPath, ['--check', t.abs]);
+        let err = '';
+        child.stderr.on('data', (d) => { err += d; });
+        child.on('error', (e) => resolve({ status: null, stderr: String(e.message) }));
+        child.on('close', (status) => resolve({ status, stderr: err }));
+      });
+      if (r.status !== 0) {
+        const first = (r.stderr || '').split(/\r?\n/).find((l) => l.trim()) || `exit ${r.status}`;
+        reds.push(`[syntax] ❌ ${t.rel}: ${first}`);
+      }
     }
-  }
+  };
+  await Promise.all(Array.from({ length: Math.min(conc, files.length) }, worker));
+  reds.sort();
 }
 
 if (missing.length) {