agentic-flow-kit 1.8.0 → 1.8.2

package/templates/_agents/scripts/agg-judgments.test.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 // agg-judgments.test.mjs — 判定流水聚合纯函数套件（2026-10-11 judgment-ledger）
 // aggFromRows 进程内断言：按月分桶 / --month 过滤 / WARN·BLOCK 计数 / 坏 rules 字段容忍。
-import { aggFromRows } from './agg-judgments.mjs';
+// retireCandidates（2026-10-15 减重手段① 自源仓回灌）：零命中窗口候选 / 数据不充分守卫 / 断档月不按零计。
+import { aggFromRows, retireCandidates } from './agg-judgments.mjs';
 
 let pass = 0;
 let fail = 0;
@@ -41,5 +42,52 @@ const ROWS = [
 check('S3 空行数组 → 空 byMonth', Object.keys(aggFromRows([]).byMonth).length === 0);
 check('S3 null 入参不 throw', Object.keys(aggFromRows(null).byMonth).length === 0);
 
+// ---- S4 retireCandidates：零命中窗口出候选（6 个数据月，2 条规则） ----
+{
+  const mk = (ym, rule, level, count) => ({ ts: `${ym}-15T00:00:00Z`, mode: 'hard', rules: [{ rule, level, count }] });
+  const rows = [
+    // 规则甲：2026-03 有命中（窗口 04..09 之外），其后零命中 → 候选（全历史 3）
+    mk('2026-03', '规则甲', 'WARN', 3),
+    // 规则乙：尾部窗口内 2026-08 仍有命中 → 在役
+    mk('2026-08', '规则乙', 'BLOCK', 1),
+    // 规则丙：仅 2026-03 出现过（窗口外）→ 候选（全历史 5，末次 2026-03）
+    mk('2026-03', '规则丙', 'WARN', 5),
+    // 6 个数据月铺满窗口 2026-04..2026-09（每月至少一次运行）
+    ...['2026-04', '2026-05', '2026-06', '2026-07', '2026-08', '2026-09'].map((ym) => mk(ym, '规则甲', 'WARN', 0)),
+  ];
+  const r = retireCandidates(rows, 6);
+  check('S4 sufficient 且窗口起止正确', r.sufficient === true && r.windowFrom === '2026-04' && r.windowTo === '2026-09', JSON.stringify({ from: r.windowFrom, to: r.windowTo }));
+  const cand = r.candidates.map((c) => c.rule);
+  check('S4 规则甲/丙为候选、乙在役', cand.includes('规则甲') && cand.includes('规则丙') && !cand.includes('规则乙') && r.recentHits.some((x) => x.rule === '规则乙'), JSON.stringify(cand));
+  check('S4 候选按全历史命中升序（甲3 < 丙5）', cand[0] === '规则甲' && cand[1] === '规则丙', JSON.stringify(cand));
+  const jia = r.candidates.find((c) => c.rule === '规则甲');
+  const bing = r.candidates.find((c) => c.rule === '规则丙');
+  check('S4 全历史命中与末次命中月份', jia.total === 3 && jia.lastHit === '2026-03' && bing.total === 5 && bing.lastHit === '2026-03', JSON.stringify({ jia, bing }));
+}
+
+// ---- S5 数据不充分守卫：数据月 < 窗口 → 不产候选 ----
+{
+  const rows = [{ ts: '2026-10-01T00:00:00Z', mode: 'hard', rules: [{ rule: '规则甲', level: 'WARN', count: 1 }] }];
+  const r = retireCandidates(rows, 6);
+  check('S5 数据月 1 < 6 → sufficient=false 零候选', r.sufficient === false && r.dataMonths === 1 && r.candidates.length === 0, JSON.stringify(r));
+}
+
+// ---- S6 断档月不按零命中计：窗口取「有数据的月」（末 N 个数据月），断档月不参与 ----
+{
+  const mk = (ym, rule, count) => ({ ts: `${ym}-15T00:00:00Z`, mode: 'hard', rules: count ? [{ rule, level: 'WARN', count }] : [] });
+  // 数据月仅 2026-05 / 2026-08 / 2026-09（06-07 断档无运行）；规则甲 05 有命中、08/09 无 → 窗口=末 2 个数据月（08..09）
+  const rows = [mk('2026-05', '规则甲', 2), mk('2026-08', '规则甲', 0), mk('2026-09', '规则甲', 0)];
+  const r = retireCandidates(rows, 2);
+  check('S6 窗口取末 2 个数据月（08..09，断档月跳过），甲窗口外命中 → 候选', r.sufficient === true && r.windowFrom === '2026-08' && r.windowTo === '2026-09' && r.candidates.some((c) => c.rule === '规则甲'), JSON.stringify(r));
+}
+
+// ---- S7 窗口边界：末月有命中不算候选 ----
+{
+  const mk = (ym, count) => ({ ts: `${ym}-15T00:00:00Z`, mode: 'hard', rules: count ? [{ rule: '规则乙', level: 'WARN', count }] : [] });
+  const rows = [...['2026-04', '2026-05', '2026-06', '2026-07', '2026-08'].map((ym) => mk(ym, 0)), mk('2026-09', 1)];
+  const r = retireCandidates(rows, 6);
+  check('S7 末月命中 → 在役非候选', r.sufficient === true && !r.candidates.some((c) => c.rule === '规则乙') && r.recentHits.some((x) => x.rule === '规则乙'), JSON.stringify(r.candidates));
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/archive-sweep.mjs

@@ -111,7 +111,9 @@ export function buildDocList(root, dirs = DIRS) {
   return docs;
 }
 
-function loadLedgerTs(root) {
+// loadLedgerTs(root)：每篇文档的终态台账行最新日期（YYYY-MM-DD）。主台账+分片统一视图；
+// 2026-10-15 起导出（gen-workflow-metrics 归档积压提醒复用——新消费方零复制）。
+export function loadLedgerTs(root) {
   const out = {};
   // 台账统一视图（主台账+分片透明合并，坏行跳过）。源仓走 ledger-loader.loadAllConfirmations
   // （同 doc|stage|fingerprint 键去重取末次）；kit 读侧单源 = readLedgerRows（不去重）。对本判据

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

@@ -26,7 +26,11 @@ const CMD_RE = /npm\s+(run\s+)?test|verify\.mjs/;
 const CITE_RE = /npm\s+(?:run\s+)?test|verify\.mjs/g;
 // verify.mjs 全绿行（verifications.jsonl 绿凭证）实际覆盖的命令。不在此集的白名单命令没有对应绿记录。
 const GATE_CMD = new Set(['npm test', 'npm run test', 'verify.mjs']);
-const PATH_RE = /[\w.@\-\\/]+\.(mjs|js|ts|tsx|cs|md|json|html|sql)/g;
+// 路径提取（2026-10-16 自源仓 13f67ef7 回灌）：路径体 = ASCII 路径字符 + 字母（中文目录放行），
+// 扩展名加 .vue。单字符类 + 前置分隔锚，避免 (A|B)+ 在长说明上回溯；标点（如路径后的「（说明）」）
+// 不在类内，仍截断。matchAll 取捕获组（剥前导分隔符），路径分隔符归一 posix。
+const PATH_EXT = 'mjs|js|ts|tsx|vue|cs|md|json|html|sql';
+const PATH_RE = new RegExp(`(?:^|[\\s\`'"（(])([\\w.@\\-\\\\/\\p{L}]+\\.(?:${PATH_EXT}))`, 'gu');
 const SEC_RE = /^##\s+.*验收判据/;
 // 与 gen-verify-evidence.mjs 数据行同形态（kit 六列：短 SHA | ISO 时间 | 门数 | 套件计数 | 绑定单 | runId）。
 // 只取日期，不复述门数。
@@ -102,7 +106,8 @@ export function run(ctx) {
             if (hard && CMD_RE.test(ev)) ok = commandCovered(ev, d, greenDates);
             else if (CMD_RE.test(ev)) ok = true; // advisory：命令白名单认声明
             else {
-              const cands = ev.match(PATH_RE) || [];
+              const cands = [];
+              for (const m of ev.matchAll(PATH_RE)) cands.push(m[1].replace(/\\/g, '/'));
               ok = cands.some((p) => fs.existsSync(path.join(ROOT, p)));
             }
           }
@@ -110,7 +115,7 @@ export function run(ctx) {
         }
         if (missed.length) {
           const detail = `${base} ${rows.length} 条判据中 ${missed.length} 条证据无效（${missed.join('; ')}）`;
-          if (hard) blockers.push(`- [收敛未覆盖] ${detail}——状态列自报不作数；命令须是全量门（npm test / verify.mjs）且 workflow/verify-evidence.md 有不早于本 spec 日期的全绿行；路径只认存在（检查 23）。若本 spec 已标 done：先标后补会与本门互为前提（verify 门序含 check-loop）——解锁序：状态临时改回非 done → 跑 node .agents/scripts/verify.mjs 全量门（全绿尾部自动重生成 workflow/verify-evidence.md 全绿行）→ 再标 done`);
+          if (hard) blockers.push(`- [收敛未覆盖] ${detail}——状态列自报不作数；命令须是全量门（npm test / verify.mjs）且 workflow/verify-evidence.md 有不早于本 spec 日期的全绿行；路径只认存在（检查 23，含 .vue 与中文目录）。若本 spec 已标 done：先标后补会与本门互为前提（verify 门序含 check-loop）——解锁序：改正文 → 状态改回 approved（勿改 draft，L3 必须 approved/done）→ confirm-doc 重录指纹 → 再标 done。中间态不要提交`);
           else warnings.push(`- [WARN 收敛未覆盖] ${detail}——状态列自报不作数，证据须存在或为验证命令（检查 23）`);
         }
       }

package/templates/_agents/scripts/check-lane-surface.mjs

@@ -22,7 +22,7 @@
 //   B 跳过（沿 pairing 门先例）；配置行正则语法错误 → fail-closed（防静默空洞）。
 // 已知边界：commit-time 门禁，CI / pre-push 复跑面无对应全量检查（push 时刻无暂存 diff 一手事实，
 //   树级反推违背判据原则）——沿增量门禁 pre-commit-only 先例，声明于 spec 风险评估 R2。
-// 用法：node check-lane-surface.mjs [--root <dir>] [--branch <名>] [--staged-file <清单文件>]
+// 用法：node check-lane-surface.mjs [--merge] [--root <dir>] [--branch <名>] [--staged-file <清单文件>]
 //   （--root/--branch/--staged-file 为测试注入位；缺省自 git 发现。staged-file 每行一个仓库相对路径）
 // 退出码：0 放行（含 advisory）；1 阻断（stderr 出 [标签] 消息与修法）
 import fs from 'node:fs';
@@ -52,6 +52,10 @@ const STAGED = stagedArg
   : gitOut(ROOT, ['diff', '--cached', '--name-only', '--diff-filter=ACMR']).split(/\r?\n/).filter(Boolean);
 
 const isExperiment = /^experiment\//.test(BRANCH);
+// 合并进行中（2026-10-15 自源仓 13f67ef7 回灌）：pre-merge-commit 显式传 --merge（git merge 自动提交
+// 窗口 MERGE_HEAD 已不可靠，只认显式旗标）；冲突解决后的手动 commit 由 MERGE_HEAD 探测兜底（此时
+// 合并仍在进行、MERGE_HEAD 确定存在）。合并提交不引入新首发改动，各笔已在自身提交时刻过门 → 检查 A 跳过。
+const FORCE_MERGE = argv.includes('--merge');
 // 泳道协议锚（单源 policy.mjs）：无 kit.json 的测试夹具回落 v1（无键=双字段协议从未生效，单字段判）
 const RISK_LEVEL_SINCE = loadKitPolicy(ROOT).riskLevelSince;
 
@@ -175,7 +179,10 @@ const hits = patterns.length ? STAGED.filter((p) => patterns.some((re) => re.tes
 // 本次提交触达到的**最低应然档位**：lane-surfaces 命中隐含 L2（沿原口径），hints 命中按登记档取。
 // 混档取高——与 level-criteria maxLevel 同一口径（就高不就低在提交面同样成立）。
 const requiredLevel = maxLevel(hits.length ? 'L2' : '', hintLevel);
-if (requiredLevel) {
+const merging = FORCE_MERGE || gitOut(ROOT, ['rev-parse', '-q', '--verify', 'MERGE_HEAD']).trim() !== '';
+if (requiredLevel && merging) {
+  advisories.push(`[触达面判低]（advisory）合并进行中（${FORCE_MERGE ? '--merge 显式标记' : 'MERGE_HEAD 在场'}）——检查 A 跳过：合并提交不引入新首发改动，各笔已在自身提交时刻过门`);
+} else if (requiredLevel) {
   const active = collectActive();
   const requiredRank = rankOf(requiredLevel) ?? 1;
   // 入口是否够格：级别 rank ≥ 应然档。**suspect（级别/risk_level 缺失、非法或分歧）一律不够格**——

package/templates/_agents/scripts/check-lane-surface.test.mjs

@@ -31,10 +31,10 @@ const w = (root, rel, content) => fs.writeFileSync(path.join(root, rel), content
 // eol='\r\n' 时整文件按 CRLF 写（平台边界：frontmatter 读取容忍性）
 const intent = (name, fm, eol = '\n') => `---${eol}${fm}${eol}---${eol}# INTENT — ${name}${eol}`;
 const incident = (fm) => `---\n${fm}\n---\n# INCIDENT\n`;
-const run = (root, { branch = 'main', staged = [] } = {}) => {
+const run = (root, { branch = 'main', staged = [], args = [] } = {}) => {
   const listFile = path.join(root, 'staged.txt');
   fs.writeFileSync(listFile, staged.join('\n') + '\n');
-  const r = spawnSync(process.execPath, [SCRIPT, '--root', root, '--branch', branch, '--staged-file', listFile], { encoding: 'utf8' });
+  const r = spawnSync(process.execPath, [SCRIPT, '--root', root, '--branch', branch, '--staged-file', listFile, ...args], { encoding: 'utf8' });
   return { code: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
 };
 
@@ -77,6 +77,20 @@ const FM_LOW_NEW = '状态: draft\n级别: L1\n日期: 2026-10-01\n模块: ui';
   const r = run(d, { branch: 'experiment/poc', staged: ['templates/t.md'] });
   check('S2c experiment 分支检查 A → advisory 放行', r.code === 0 && r.out.includes('advisory·experiment'), r.out);
 }
+// --- S2d/S2e：合并进行中 → 检查 A 跳过（2026-10-16 自源仓 13f67ef7 回灌）---
+// git merge 自动提交窗口 MERGE_HEAD 已不可靠 → pre-merge-commit 显式传 --merge（fixture 无 MERGE_HEAD，
+// 恰验证 --merge 独生效）；对照：同夹具不带 --merge 时命中面+仅活跃 L1 照拦。
+{
+  const d = mkfix();
+  base(d);
+  const r = run(d, { staged: ['templates/_agents/scripts/x.mjs'], args: ['--merge'] });
+  check('S2d --merge 显式标记 → 检查 A 跳过且明示来源',
+    r.code === 0 && r.out.includes('合并进行中（--merge 显式标记）') && !r.out.includes('[触达面判低] 暂存命中高风险面'),
+    r.out);
+  const r2 = run(d, { staged: ['templates/_agents/scripts/x.mjs'] });
+  check('S2e 无 --merge 同夹具照拦（对照：跳过仅由旗标/MERGE_HEAD 触发）',
+    r2.code === 1 && r2.out.includes('[触达面判低]'), r2.out);
+}
 // --- S3：命中 + 无活跃入口 → advisory 放行（done 不算活跃）---
 {
   const d = mkfix();

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

@@ -221,10 +221,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);
@@ -309,7 +311,7 @@ function scanHistory(rel, { allowShardDelete }) {
     if (parents.length >= 2) {
       // 多父提交无条件走并集对账（前缀通过不得短路——ours-resolution 合并树与第一父逐字节同 blob，
       // 嵌套判法对静默丢行全盲）
-      const unionFail = mergeUnionProblem(sha, rel, cur);
+      const unionFail = mergeUnionProblem(parentShas(sha), rel, cur);
       if (!unionFail) {
         console.error(`[info] ${sha.slice(0, 10)}：合并并集无丢失——union 合并语义认可，续扫`);
         continue;
@@ -363,6 +365,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 +402,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 缺省无基线 = 全量扫描，与源实现「缺省基线指向自身仓提交、外来仓退化为全扫」同语义）

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]
@@ -1422,7 +1424,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 +1460,7 @@ export function runCheckLoop(opts = {}) {
         }
       }
     }
+    }
   }
   } // laneOn(17) 守卫闭合
 

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

@@ -3765,21 +3765,33 @@ w(T, 'workflow/intents/2026-09-12-deep.md', INTENT('deep', '状态: draft\n级
   check('检查25 预判 L2 落位 L1 → WARN「预判级别不符」含判低信号',
     r.status === 0 && outOf(r).includes('预判级别不符') && outOf(r).includes('判低信号'), `exit=${r.status}\n${outOf(r)}`);
   rmfix(T3);
-  // ④ 词表非法 kind / 整字段不可解析 → WARN「预判字段不可解析」
+  // ④ 词表非法 kind / 整字段不可解析 → WARN「预判字段不可解析」（夹具取 approved 活文档——终态 done
+  //   自 2026-10-15 起形态类告警跳过，见 ⑥）
   const T4 = mkfix();
-  w(T4, 'workflow/intents/2026-09-12-pj5.md', INTENT('pj5', '状态: done\n级别: L1\n日期: 2026-09-12\n预判: kind=bug level=L1', '\n## 验收标准（可测试）\n- [x] 用例通过（证据:fixture）\n'));
-  w(T4, 'workflow/plans/2026-09-12-pj5.md', PLAN('pj5', '状态: done\n级别: L1'));
+  w(T4, 'workflow/intents/2026-09-12-pj5.md', INTENT('pj5', '状态: approved\n级别: L1\n日期: 2026-09-12\n预判: kind=bug level=L1', '\n## 验收标准（可测试）\n- [x] 用例通过（证据:fixture）\n'));
+  w(T4, 'workflow/plans/2026-09-12-pj5.md', PLAN('pj5', '状态: draft\n级别: L1'));
   r = run(T4);
   check('检查25 kind=bug 不在词表 → WARN「预判字段不可解析」',
     r.status === 0 && outOf(r).includes('预判字段不可解析'), `exit=${r.status}\n${outOf(r)}`);
   rmfix(T4);
   const T5 = mkfix();
-  w(T5, 'workflow/intents/2026-09-12-pj6.md', INTENT('pj6', '状态: done\n级别: L1\n日期: 2026-09-12\n预判: 这是个修复', '\n## 验收标准（可测试）\n- [x] 用例通过（证据:fixture）\n'));
-  w(T5, 'workflow/plans/2026-09-12-pj6.md', PLAN('pj6', '状态: done\n级别: L1'));
+  w(T5, 'workflow/intents/2026-09-12-pj6.md', INTENT('pj6', '状态: approved\n级别: L1\n日期: 2026-09-12\n预判: 这是个修复', '\n## 验收标准（可测试）\n- [x] 用例通过（证据:fixture）\n'));
+  w(T5, 'workflow/plans/2026-09-12-pj6.md', PLAN('pj6', '状态: draft\n级别: L1'));
   r = run(T5);
   check('检查25 预判字段无 kv 形态 → WARN「预判字段不可解析」',
     r.status === 0 && outOf(r).includes('预判字段不可解析'), `exit=${r.status}\n${outOf(r)}`);
   rmfix(T5);
+  // ⑥ 终态跳过（2026-10-15）：done 文档词表/形态类告警不产——终态受检查 15 内容绑定不可修订，
+  //   WARN 永不可消（「不可消除噪声」红线）；类型/级别比对照常（level 一致；类型告警不在本断言面）
+  {
+    const T6 = mkfix();
+    w(T6, 'workflow/intents/2026-09-12-pj7.md', INTENT('pj7', '状态: done\n级别: L1\n日期: 2026-09-12\n预判: kind=bug level=L1', '\n## 验收标准（可测试）\n- [x] 用例通过（证据:fixture）\n'));
+    w(T6, 'workflow/plans/2026-09-12-pj7.md', PLAN('pj7', '状态: done\n级别: L1'));
+    r = run(T6);
+    check('检查25 终态 done 词表外 kind → 形态类告警不产（2026-10-15 终态跳过）',
+      r.status === 0 && !outOf(r).includes('预判字段不可解析'), `exit=${r.status}\n${outOf(r)}`);
+    rmfix(T6);
+  }
 }
 
 // ---- 检查 26：闭环漏斗「协议前」占比动作阈值（相邻两月均 >30% → WARN；消费 gen-workflow-metrics 产物）----

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

@@ -29,16 +29,21 @@ export function run(ctx) {
       const pj = fmGet(abs, '预判');
       if (!pj) continue;
       const rel = `${WF}/${sub}/${f}`;
+      // 终态文档（2026-10-15）：形态/词表类告警跳过——终态受检查 15 内容绑定不可修订，此类 WARN 永不可
+      // 消（「不可消除噪声」红线）；类型/级别比对保留——那是路由审计的本体信号，灰度对账照常采集。
+      // （终态并集 = doc 终态 done/superseded/cancelled + incident 终态 fixed/closed——两侧枚举无单一键
+      // 覆盖该并集，故与源仓 s25 同款内联声明。）
+      const terminalDoc = ['done', 'superseded', 'cancelled', 'fixed', 'closed'].includes(fmGet(abs, '状态'));
       const kv = {};
       for (const m of pj.matchAll(/(kind|level)=([^\s]+)/g)) kv[m[1]] = m[2];
       if (!Object.keys(kv).length) {
-        warnings.push(`- [WARN 预判字段不可解析] 须形如「预判: kind=<kind> level=<L1|L2|L3>」:${rel}`);
+        if (!terminalDoc) warnings.push(`- [WARN 预判字段不可解析] 须形如「预判: kind=<kind> level=<L1|L2|L3>」:${rel}`);
         continue;
       }
-      if (kv.kind && !KINDS.includes(kv.kind)) {
+      if (kv.kind && !KINDS.includes(kv.kind) && !terminalDoc) {
         warnings.push(`- [WARN 预判字段不可解析] kind=${kv.kind} 不在词表（${KINDS.join('/')}）:${rel}`);
       }
-      if (kv.level && !inSet(kv.level, ENUMS['level.all'])) {
+      if (kv.level && !inSet(kv.level, ENUMS['level.all']) && !terminalDoc) {
         warnings.push(`- [WARN 预判字段不可解析] level=${kv.level} 不在枚举 level.all:${rel}`);
       }
       // 类型比对：intents ≡ require、incidents ≡ fix（plans/specs 两道共用，不判类型）