agentic-flow-kit 1.7.16 → 1.8.0

package/templates/_agents/scripts/confirm-doc.mjs

@@ -13,8 +13,10 @@
 //     落态记账——免 TTY、免逐份问答，但台账行如实记 source:"chat-delegated" + quote:<原话>，
 //     永不伪装 TTY 行。调用纪律（AI 须先取得用户对话内明确确认）由 AGENTS.md 确认门条款承载，
 //     quote 原话入账供事后对质。
-// 台账：.agents/confirmations.jsonl（入 git、追加式）——每行 {ts, doc, stage, fingerprint(64位), prev,
-//   source:"tty"|"chat-delegated", quote?(仅委托行), batch, seq, of}。
+// 台账：默认分片 .agents/confirmations.d/<doc基名>.jsonl（2026-10-13 ledger-shard-default，
+//   协议对齐 Shipyard 参考实现；--no-shard / CONFIRM_SHARDED=0 回退主台账 .agents/confirmations.jsonl）
+//   ——两者入 git、追加式。每行 {ts, doc, stage, fingerprint(64位), prev, source:"tty"|"chat-delegated",
+//   quote?(仅委托行), batch, seq, of}。
 //   batch/seq/of（2026-09-28 batch-ledger-audit 新增，纯增字段、向后兼容、历史行不回填）：
 //   记「本次进程调用落了几份态」这一**写入时确定已知的事实**——batch 为本次调用生成的短随机串
 //   （无时间语义、无全局唯一要求，仅需单台账内不碰撞），seq 为该次调用内件序（从 1），of 为本次
@@ -23,12 +25,12 @@
 // 指纹：内容 CRLF 归一 → 剔除「确认指纹:」行（防自引用）→ sha256；frontmatter 存前 16 位，台账存全量。
 // 用法：node .agents/scripts/confirm-doc.mjs <workflow/intents|x.md> [<doc2>...] [--root <仓库根>]
 //       node .agents/scripts/confirm-doc.mjs <doc...> --delegated "<用户对话原话>"（委托代录）
-//       node .agents/scripts/confirm-doc.mjs <doc...> --delegated "<原话>" --batch（协作道批量：L0/L1 多份一次代录）
+//       node .agents/scripts/confirm-doc.mjs <doc...> --delegated "<原话>" --batch（协作道批量：L1 多份一次代录）
 //       node .agents/scripts/confirm-doc.mjs <doc...> --to superseded|cancelled（放弃态：取代/取消，留指纹与台账）
-//       node .agents/scripts/confirm-doc.mjs <doc...> --shard（分片写入：多 worktree 并行时各写各的
-//         .agents/confirmations.d/<doc>.jsonl，避免同文件并发覆盖；里程碑跑 compact-ledgers.mjs 归并）
+//       node .agents/scripts/confirm-doc.mjs <doc...> --no-shard（回退主台账 .agents/confirmations.jsonl：
+//         分片已是默认写入口径，环境变量 CONFIRM_SHARDED=0 同效；里程碑可选跑 compact-ledgers.mjs 归并分片）
 //   多文档一次传入：TTY 模式天然逐份过目键入；--delegated 默认一次仅一份（2026-09-27
-//   confirm-gate-one-per-call：多份并录曾系统性塌掉 build.md「逐件确认」三道门），L0/L1 协作道可
+//   confirm-gate-one-per-call：多份并录曾系统性塌掉 build.md「逐件确认」三道门），L1 协作道可
 //   `--batch` 多份一次代录（2026-09-30 hybrid-governance-risk-lanes）：逐份读「级别」，L2/L3 逐份拒绝
 //   （防御道不批量）；台账行带 `brief:true` 简洁审计标记（quote 原话仍入账供对质），check-loop 检查 15
 //   并录审计对全行带标记的批次豁免「确认并录」告警。--auto 一次仍仅一份（自治放行不批量）。
@@ -40,8 +42,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import readline from 'node:readline';
 import { createHash, randomBytes } from 'node:crypto';
-import { spawnSync } from 'node:child_process';
-import { readLedgerEntries } from './ledger-loader.mjs';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { readLedgerEntries, readLedgerRows } from './ledger-loader.mjs';
 import { confirmGateFor, clarifyGateFor, doneGateFor, laneOfEntry, laneOfDoc } from './stage-gates.mjs';
 import { loadKitPolicy, hasFreshVerifyLine, ledgerChainHash, ledgerDocChainActive, ledgerDocChainPrev, scopeDigest } from './policy.mjs';
 
@@ -158,10 +160,12 @@ export function applyTransition(text, targetStage, fingerprint16) {
 //   最后一个带 hash 行**（ledgerDocChainPrev），不再取物理末行。理由见 POLICIES v8 注释：物理链隐含
 //   「单写者顺序追加」前提，而并发 append / git 并集合并 / 分片归并三种**正常协作**都会打断它。
 //   缺键（v1-v7）→ 走旧物理链口径，存量零变化。
-// shard（2026-10-12 ledger-shard-write）：多 worktree 并行时两个进程同时 append 同一台账文件会互相覆盖
-//   （各自读到同一末行 → 同 prevHash → 后写者覆盖前写者）。--shard 把本行写入分片
-//   `.agents/confirmations.d/<doc基名>.jsonl`，各 worktree 各写各的、互不冲突；里程碑跑 compact-ledgers.mjs
-//   归并回主台账。**默认仍写主台账**——分片是有意的并发开关，不设则零影响。
+// shard（2026-10-12 ledger-shard-write；2026-10-13 ledger-shard-default 升为默认）：多 worktree 并行时
+//   两个进程同时 append 同一台账文件会互相覆盖（各自读到同一末行 → 同 prevHash → 后写者覆盖前写者）。
+//   分片把本行写入 `.agents/confirmations.d/<doc基名>.jsonl`，各 worktree 各写各的、互不冲突。
+//   **默认写分片**（CLI 层；--no-shard / CONFIRM_SHARDED=0 显式回退主台账）——doc 链未激活
+//   （policyVersion < 8）时 CLI 层自动回退主台账（见 isMain 内 ledger-shard-default 注释），
+//   存量装户升级后行为零变化。函数层契约不变：shard 显式传入，默认 false。
 export function appendLedger(root, entry, { shard = false } = {}) {
   const p = shard && entry.doc
     ? path.join(root, '.agents', 'confirmations.d', `${path.basename(entry.doc, '.md')}.jsonl`)
@@ -208,8 +212,8 @@ if (isMain) {
   let delegatedQuote = null; // null = TTY 模式；字符串 = 委托代录的用户对话原话
   let toTarget = null; // null = 默认前向跳转；superseded|cancelled = 放弃态显式目标
   let autoMode = false; // AI 自治模式（信任等级授权，2026-09-30 ai-autonomy-trust）
-  let batchMode = false; // 协作道批量代录（--batch，2026-09-30 hybrid-governance-risk-lanes：仅 --delegated + L0/L1）
-  let shardWrite = false; // 分片写入（--shard，2026-10-12 ledger-shard-write）：多 worktree 并行时各写各的分片，避免互相覆盖
+  let batchMode = false; // 协作道批量代录（--batch，2026-09-30 hybrid-governance-risk-lanes：仅 --delegated + L1）
+  let shardWrite = process.env.CONFIRM_SHARDED !== '0'; // 分片默认写入口径（2026-10-13 ledger-shard-default）：CONFIRM_SHARDED=0 显式回退主台账
   const docs = [];
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === '--root') root = path.resolve(argv[++i]);
@@ -218,19 +222,34 @@ if (isMain) {
     else if (argv[i] === '--auto') autoMode = true;
     else if (argv[i] === '--batch') batchMode = true;
     else if (argv[i] === '--shard') shardWrite = true;
+    else if (argv[i] === '--no-shard') shardWrite = false;
     else docs.push(argv[i].replace(/\\/g, '/'));
   }
   if (toTarget !== null && !ABANDON_TARGETS.includes(toTarget)) {
     console.error(`用法：--to 仅接受 superseded|cancelled（现「${toTarget}」）——cancelled 自 draft/approved/open/fixed；superseded 自 approved/done/fixed/closed（未确认态只能 cancelled；终态间仅允许 done/closed→superseded）`);
     process.exit(1);
   }
-  // --shard 与 doc 链口径绑定（2026-10-12 ledger-shard-write）：分片与主台账分属不同文件，
-//   只有 doc 链能跨来源接续；旧物理链口径下分片行的 prevHash 会与主台账末行失配 → 提交即断链。
-//   故缺锚时**参数期直接拒**（友好报错），而不是让用户写完台账再被门禁拦。
-if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
-    console.error('❌ --shard 需要台账 doc 链口径（policy.ledgerDocChainSince），当前 policyVersion 无此键。\n   原因：分片与主台账是不同文件，只有 doc 链能跨来源接续；旧物理链口径下分片行会与主台账断链。\n   修法：在 .agents/kit.json 设 policyVersion: 8（或更高的支持版本）后重试。');
+  // 分片默认写入口径（2026-10-13 ledger-shard-default，对齐 Shipyard 参考实现）：
+  //   确认行默认写 `.agents/confirmations.d/<doc基名>.jsonl`——多 worktree / 多人并行天然各写各的，
+  //   互不覆盖；跨分支合并走 .gitattributes 的 union driver（confirmations.d/*.jsonl merge=jsonl-union），
+  //   里程碑可选跑 compact-ledgers.mjs 收敛碎片。--no-shard / CONFIRM_SHARDED=0 显式回退主台账。
+  // doc 链仍是分片的前提（2026-10-12 ledger-shard-write 口径保留）：分片与主台账分属不同文件，
+  //   只有 doc 链能跨来源接续；旧物理链口径下分片行的 prevHash 会与主台账末行失配 → 提交即断链。故：
+  //   显式 --shard + doc 链未激活 → 参数期直接拒（友好报错，原口径不变）；
+  //   默认分片 + doc 链未激活 → 自动回退主台账并出 ℹ️——存量装户（policyVersion < 8）升级模板后
+  //     行为零变化，分片默认仅对 doc 链已激活的装户生效；升级法：.agents/kit.json 设 policyVersion: 8。
+  if (argv.includes('--shard') && argv.includes('--no-shard')) {
+    console.error('用法：--shard 与 --no-shard 互斥——分片已是默认写入口径，显式回退主台账只需 --no-shard');
     process.exit(1);
   }
+  if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
+    if (argv.includes('--shard')) {
+      console.error('❌ --shard 需要台账 doc 链口径（policy.ledgerDocChainSince），当前 policyVersion 无此键。\n   原因：分片与主台账是不同文件，只有 doc 链能跨来源接续；旧物理链口径下分片行会与主台账断链。\n   修法：在 .agents/kit.json 设 policyVersion: 8（或更高的支持版本）后重试，或改用 --no-shard 显式写主台账。');
+      process.exit(1);
+    }
+    shardWrite = false; // 存量装户回退：分片默认仅对 doc 链已激活（policyVersion ≥ 8）的装户生效
+    console.error('ℹ️ 分片默认写入口径需 doc 链口径（policy.ledgerDocChainSince），当前 policyVersion 未激活——本次写主台账 .agents/confirmations.jsonl。升级法：.agents/kit.json 设 policyVersion: 8。');
+  }
 
   const delegated = delegatedQuote !== null;
   if (delegated && autoMode) {
@@ -247,7 +266,7 @@ if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
   }
   // AI 自治门（2026-09-30 ai-autonomy-trust；2026-09-30 hybrid-governance-explore-hardening 加隐式形态）：
   // 读 .agents/trust-mode.json。除显式 --auto 外，Trusted（level=2）下的非 TTY 单份调用在 TTY 门处
-  // 免旗标自动转入本分支（见「Trusted 自动泳道」）——L0/L1 门 / incidents 排除 / 逐阶段与 done 门照常执行。
+  // 免旗标自动转入本分支（见「Trusted 自动泳道」）——L1 门 / incidents 排除 / 逐阶段与 done 门照常执行。
   let trustConfig = null;
   if (autoMode) {
     try {
@@ -265,7 +284,7 @@ if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
       console.error('❌ AI 自治模式一次仅接受一份文档（与 --delegated 同口径，逐件放行）');
       process.exit(1);
     }
-    console.error(`⚠️  AI 自治模式（Trust L${trustConfig.level}）：仅限 L0/L1 文档；Level 1 只放行 draft→approved，Level 2 放行至 done`);
+    console.error(`⚠️  AI 自治模式（Trust L${trustConfig.level}）：仅限 L1 文档；Level 1 只放行 draft→approved，Level 2 放行至 done`);
   }
   if (delegated && !String(delegatedQuote).trim()) {
     console.error('用法：--delegated 须带用户对话原话（node .agents/scripts/confirm-doc.mjs <doc...> --delegated "<用户原话>"）——原话入台账供事后对质，不可缺省');
@@ -286,7 +305,7 @@ if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
   if (!delegated && !autoMode && !ttyForced && (!process.stdin.isTTY || !process.stdout.isTTY)) {
     // Trusted 自动泳道（2026-09-30 hybrid-governance-explore-hardening）：trust-mode.json 为 Trusted
     // （enabled 且 level=2）时，非 TTY 调用（AI 会话）对文档**免手工触发**（无需 --delegated 原话 /
-    // --auto 旗标）自动转入 AI 自治放行——单份、非放弃态才可隐式（与 --auto 同口径，L0/L1 门与
+    // --auto 旗标）自动转入 AI 自治放行——单份、非放弃态才可隐式（与 --auto 同口径，L1 门与
     // incidents 排除由主循环自治门照常执行）；不满足则维持原拒绝（fail-closed，Standard/Strict 不隐式）。
     let implicitTrust = null;
     try {
@@ -294,8 +313,8 @@ if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
     } catch { implicitTrust = { enabled: false, level: 0 }; }
     if (implicitTrust.enabled && implicitTrust.level === 2 && docs.length === 1 && !toTarget) {
       autoMode = true;
-      trustConfig = implicitTrust; // 主循环自治门（L0/L1 与 incidents 排除）直读本配置——顶部 if (autoMode) 块先于 TTY 门执行，须在此补装
-      console.error('⚠️  Trusted 自动泳道（隐式）：单份 L0/L1 文档按 AI 自治放行（Level 2 全闭环，台账 source=ai-auto-trust-L2）；L2/L3 与 incidents 仍须人工确认');
+      trustConfig = implicitTrust; // 主循环自治门（L1 与 incidents 排除）直读本配置——顶部 if (autoMode) 块先于 TTY 门执行，须在此补装
+      console.error('⚠️  Trusted 自动泳道（隐式）：单份 L1 文档按 AI 自治放行（Level 2 全闭环，台账 source=ai-auto-trust-L2）；L2/L3 与 incidents 仍须人工确认');
     } else {
       console.error('确认门须由用户在终端亲手运行（node .agents/scripts/confirm-doc.mjs <workflow/文档>...）——AI 会话内不可代确认；用户对话内明确确认后可用 --delegated "<用户原话>" 委托代录（台账如实记来源）');
       process.exit(1);
@@ -311,14 +330,14 @@ if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
     // 单文档默认（2026-09-27 confirm-gate-one-per-call）：delegated 没有TTY「逐份过目」的天然机制——
     // 多文档并录曾系统性塌掉三道阶段门（build.md「逐件确认不得并作一次」）。逐件调用：一次一份、
     // 每次带当次用户原话。TTY 形态不受限（用户亲手逐份过目键入，天然逐件）。
-    // 协作道批量（2026-09-30 hybrid-governance-risk-lanes）：L0/L1 可 `--batch` 多份一次代录——
+    // 协作道批量（2026-09-30 hybrid-governance-risk-lanes）：L1 可 `--batch` 多份一次代录——
     // 逐份读「级别」，L2/L3 逐份拒绝（见主循环协作道门）；台账行带 brief:true，检查 15 据此豁免并录告警。
     if (docs.length > 1) {
       if (!batchMode) {
-        console.error(`❌ --delegated 一次仅接受一份文档（现 ${docs.length} 份：${docs.join(' ')}）——逐件确认口径（build.md）：每份一次调用、每次带当次用户原话；L0/L1 协作道批量可加 --batch`);
+        console.error(`❌ --delegated 一次仅接受一份文档（现 ${docs.length} 份：${docs.join(' ')}）——逐件确认口径（build.md）：每份一次调用、每次带当次用户原话；L1 协作道批量可加 --batch`);
         process.exit(1);
       }
-      console.error(`   批量代录（--batch）：${docs.length} 份，仅受理 L0/L1（协作道，异步审计兜底）；L2/L3 逐份拒绝`);
+      console.error(`   批量代录（--batch）：${docs.length} 份，仅受理 L1（协作道，异步审计兜底）；L2/L3 逐份拒绝`);
     }
   }
   // 调用事实（2026-09-28 batch-ledger-audit）：本次进程调用的批次标识与件序——
@@ -434,7 +453,7 @@ if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
     // TTY 形态同样需要（事后对质问的是「放行时盘面上哪些文件在动」，与谁点的确认无关）。
     const scope = machineScope(root, doc);
     // AI 自治放行分支（2026-09-30 ai-autonomy-trust）：
-    // ① 仅 L0/L1（读 frontmatter「级别」，缺级别按不可自治处理——fail-closed）；
+    // ① 仅 L1（读 frontmatter「级别」，缺级别按不可自治处理——fail-closed）；
     // ② Level 1：仅 draft→approved；Level 2：draft→approved 与 approved→done；
     // ③ incidents 永不自治（open→fixed/fixed→closed 必须人工）。
     if (autoMode) {
@@ -443,16 +462,18 @@ if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
         ? (target === 'approved' || target === 'done')
         : target === 'approved';
       if (!isLowLevel || !stageAllowed || doc.startsWith('workflow/incidents/')) {
-        console.error(`❌ ${doc} 未过 AI 自治门（级别「${lvl || '缺失'}」/ 泳道「${lane}」/ 目标态「${target}」/ 类型）：Level ${trustConfig.level} 仅授权泳道 low（intent 两字段一致 L0/L1；suspect 须先对齐「级别/risk_level」）的 ${trustConfig.level === 2 ? 'approved/done' : 'approved'} 且不含 incidents`);
+        console.error(`❌ ${doc} 未过 AI 自治门（级别「${lvl || '缺失'}」/ 泳道「${lane}」/ 目标态「${target}」/ 类型）：Level ${trustConfig.level} 仅授权泳道 low（intent 级别 L1；suspect 须先对齐「级别/risk_level」）的 ${trustConfig.level === 2 ? 'approved/done' : 'approved'} 且不含 incidents`);
         refused++;
         continue;
       }
       fs.writeFileSync(abs, applyTransition(text, target, fp.slice(0, 16)));
+      // shard 走第三参 options（不进 entry）：appendLedger(root, entry, { shard }) 的契约是 options 形参，
+      // 写进 entry 会让旗标混入台账行数据且分片开关失效（2026-10-13 ledger-shard-default 修复的存量缺陷）。
       appendLedger(root, {
-        shard: shardWrite, ts: new Date().toISOString(), doc, stage: target, fingerprint: fp, prev: st,
+        ts: new Date().toISOString(), doc, stage: target, fingerprint: fp, prev: st,
         source: `ai-auto-trust-L${trustConfig.level}`, quote: `AI 自治放行 (Trust Level ${trustConfig.level})`,
         batch, seq, of: docs.length, scope,
-      });
+      }, { shard: shardWrite });
       console.log(`✓ ${doc} ${st} → ${target}（指纹 ${fp.slice(0, 16)}，AI 自治已记账：source=ai-auto-trust-L${trustConfig.level}）`);
       confirmed++;
       seq++;
@@ -460,27 +481,27 @@ if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
     }
     if (delegated) {
       // 协作道门（2026-09-30 hybrid-governance-risk-lanes；2026-10-02 caliber-convergence 起单源泳道）：
-      // --batch 批量仅受理泳道 low（intent 两字段一致 L0/L1；suspect 拒）——high/suspect 逐份拒绝落账；
+      // --batch 批量仅受理泳道 low（intent 级别 L1；suspect 拒）——high/suspect 逐份拒绝落账；
       // 不带 --batch 的单份代录不限级别（既有口径不变）。
       const low = lane === 'low';
       if (batchMode && !low) {
-        console.error(`❌ ${doc} 泳道「${lane}」（级别「${lvl || '缺失'}」）不在协作道——--batch 批量代录仅限两字段一致的 L0/L1；suspect（级别/risk_level 缺失、非法或分歧）须先对齐两字段，L2/L3 防御道须逐份确认（本份未落账、未写盘）`);
+        console.error(`❌ ${doc} 泳道「${lane}」（级别「${lvl || '缺失'}」）不在协作道——--batch 批量代录仅限级别 L1；suspect（级别/risk_level 缺失、非法或分歧）须先对齐两字段，L2/L3 防御道须逐份确认（本份未落账、未写盘）`);
         refused++;
         continue;
       }
       fs.writeFileSync(abs, applyTransition(text, target, fp.slice(0, 16)));
       appendLedger(root, {
-        shard: shardWrite, ts: new Date().toISOString(), doc, stage: target, fingerprint: fp, prev: st,
+        ts: new Date().toISOString(), doc, stage: target, fingerprint: fp, prev: st,
         source: 'chat-delegated', quote: String(delegatedQuote),
         // 调用事实（batch-ledger-audit）：seq=本次调用内件序（从 1），of=本次调用总份数
         batch, seq, of: docs.length,
         // 改动面事实（A1 干净版）：quote 降级为「人类可读摘要」，分辨力改由 scope（机器派生）+ fingerprint
         // （文档内容）承担——「不复用同句」纪律据此退役（复用一句摘要不再削弱任何判据）。
         scope,
-        // 简洁审计标记（hybrid-governance-risk-lanes）：L0/L1 协作道行带 brief（quote 仍入账供对质），
+        // 简洁审计标记（hybrid-governance-risk-lanes）：L1 协作道行带 brief（quote 仍入账供对质），
         // 检查 15 并录审计对全 brief 批次豁免「确认并录」告警
         ...(low ? { brief: true } : {}),
-      });
+      }, { shard: shardWrite });
       console.log(low
         ? `✓ ${doc} ${st} → ${target} [${lvl} 协作道/异步审计]（指纹 ${fp.slice(0, 16)}）`
         : `✓ ${doc} ${st} → ${target}（指纹 ${fp.slice(0, 16)}，代录已记账：source=chat-delegated）`);
@@ -500,15 +521,70 @@ if (shardWrite && !ledgerDocChainActive(loadKitPolicy(root))) {
     }
     fs.writeFileSync(abs, applyTransition(text, target, fp.slice(0, 16)));
     appendLedger(root, {
-        shard: shardWrite, ts: new Date().toISOString(), doc, stage: target, fingerprint: fp, prev: st,
+        ts: new Date().toISOString(), doc, stage: target, fingerprint: fp, prev: st,
       source: 'tty',
       batch, seq, of: docs.length, // 调用事实（形态无关：TTY 多文档天然逐件过目，of>1 不构成违规）
-    });
+    }, { shard: shardWrite });
     console.log(`✓ ${doc} → ${target}（指纹 ${fp.slice(0, 16)}，台账已记）`);
     confirmed++;
     seq++;
   }
   if (rl) rl.close();
+  // --- 终态件滚动归档（2026-10-13 archive-on-close；B9 自 Shipyard.Material 回灌，行为边界逐字对齐）---
+  // 关单即归档：本进程刚落终态的文档，其同名家族若已全终态且超窗、无活跃引用 → git mv 进
+  // workflow/archive/<家族最晚终态月>/{类型}/。动机：archive-sweep 是手工工具、无人跑，活跃目录
+  // 无限膨胀（源仓实测 885 篇、733 篇终态零引用——留痕在包源仓 git 历史与 CHANGELOG）；挂进确认门
+  // 后活跃目录恒定。判定单源 = archive-sweep.analyze（禁第二套口径）；归档单位 = 同名家族
+  // （check-loop 检查 1 的结构配对是家族双向在场审计，单篇归档会造配对断裂——源仓首批返工实证）。
+  // 时序：**台账行已写、状态已落盘之后**才 mv——check-loop 检查 15 的内容绑定按台账 doc 路径读
+  // 四目录直下文件，归档后该路径不在 buildDocList() 扫描面内，绑定检查自然跳过（归档件不再受
+  // 内容绑定约束，与既有归档批次同口径）。失败一律 fail-open：归档是卫生动作，不得回滚已完成的
+  // 确认（**归档失败不阻断关单**——与源仓语义逐字一致）。启用锚（照搬源仓，无 policy 锚）：
+  // ① 仓库已建立归档约定（workflow/archive/ 存在）——真实装户仓有，临时 fixture 无，避免测试夹具
+  //   被静默搬走（也避免在未采纳归档的仓库里凭空造目录）；② env 逃生门 CONFIRM_DOC_NO_ARCHIVE。
+  const archiveRoot = path.join(root, 'workflow', 'archive');
+  if (confirmed > 0 && !process.env.CONFIRM_DOC_NO_ARCHIVE && fs.existsSync(archiveRoot)) {
+    try {
+      const { analyze, buildDocList, loadLastTouch, parseStatus, TERMINAL, ACTIVE } = await import('./archive-sweep.mjs');
+      // 台账终态锚：kit 读侧单源 = readLedgerRows（主台账+分片透明合并；源仓走
+      // loadAllConfirmations——「每 doc 终态行最大日期」的 max 判据对去重口径无语义差，
+      // 见 archive-sweep.loadLedgerTs 同款注释）。CONFIRM_DOC_TEST_NOW 仅测试注入，生产不设。
+      const ledgerTs = {};
+      for (const e of readLedgerRows(root)) {
+        if (TERMINAL.has(e.stage) && e.doc) {
+          const d = (e.ts || '').slice(0, 10);
+          if (d && (!ledgerTs[e.doc] || d > ledgerTs[e.doc])) ledgerTs[e.doc] = d;
+        }
+      }
+      const allDocs = buildDocList(root);
+      // 窗口口径：本次确认的文档**刚**落终态，其台账 ts = 今日 → 21 天窗口必然拦下（窗口的用途是
+      // 「防归档仍在编辑的在途件」，而刚过确认门的终态件按定义已定稿，窗口对它冗余）。故对本进程
+      // 确认过的家族用 windowDays=-1（判据 `floor((today-tTime)/864e5) <= windowDays` 恒 false = 窗口
+      // 关闭；注意 0 不等于关闭——0 表示「同日也算未满窗」）；未涉及的家族不在此次归档范围（touched
+      // 过滤），历史积压仍走 archive-sweep 手工批次 + 21 天窗口。
+      const r = analyze({
+        docs: allDocs,
+        ledgerTs,
+        lastTouch: loadLastTouch(root),
+        activeTexts: allDocs.filter((d) => ACTIVE.has(parseStatus(d.text))).map((d) => d.text),
+        windowDays: -1,
+      });
+      // 只归档「本次确认涉及的家族」——不越权清理历史积压（积压走 archive-sweep 手工批次）
+      const touched = new Set(docs.map((d) => path.basename(d)));
+      const mine = r.candidates.filter((x) => touched.has(x.file));
+      if (mine.length) {
+        for (const x of mine) {
+          const destDir = path.join(root, 'workflow', 'archive', x.month, x.dir);
+          fs.mkdirSync(destDir, { recursive: true });
+          execFileSync('git', ['mv', x.rel, path.join('workflow', 'archive', x.month, x.dir, x.file)], { cwd: root });
+        }
+        const fams = new Set(mine.map((x) => x.file));
+        console.log(`📦 归档 ${mine.length} 篇 / ${fams.size} 族 → workflow/archive/<终态月>/（家族原子；活跃目录不再累积终态件）`);
+      }
+    } catch (err) {
+      console.error(`⚠️ 归档跳过（fail-open，不影响已完成的确认）：${err.message}`);
+    }
+  }
   console.log(`\n完成：确认 ${confirmed} 份 / 跳过 ${docs.length - confirmed - refused} 份 / 拒绝 ${refused} 份${delegated ? '（委托代录）' : ''}`);
   process.exit(refused ? 2 : 0);
 }

package/templates/_agents/scripts/confirm-doc.test.mjs

@@ -7,6 +7,8 @@
 //          L2/L3 时同名 spec）已确认；未过 → exit 2 + 未落盘未记账（S19-S22）
 //       ⑧ done 前置门（2026-09-30 confirm-gate-approved-history）：→done 须 git 历史已留 approved 态
 //          （先 done 后提交 / 两跳同批提交 → 拒绝）；非 git / legacy / 存量豁免声明 → 跳过（S25-S29）
+//       ⑨ 关单即归档（2026-10-13 archive-on-close，B9 自源仓回灌）：终态家族即时 git mv 进 archive、
+//          未涉及家族不越权清理、无归档约定不启用、CONFIRM_DOC_NO_ARCHIVE 逃生门（S43-S45）
 // 用法：node templates/_agents/scripts/confirm-doc.test.mjs（npm test 随跑）
 import fs from 'node:fs';
 import os from 'node:os';
@@ -615,17 +617,17 @@ const gitHead = (root) => {
   fs.rmSync(root, { recursive: true, force: true });
 }
 
-// ---- S30【协作道批量】--batch：delegated 多份 L0/L1 一次代录 → 全部落态 + 台账 brief:true（2026-09-30 hybrid-governance-risk-lanes）----
+// ---- S30【协作道批量】--batch：delegated 多份 L1 一次代录 → 全部落态 + 台账 brief:true（2026-09-30 hybrid-governance-risk-lanes）----
 {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-bt1-'));
   fs.mkdirSync(path.join(root, 'workflow', 'intents'), { recursive: true });
   fs.writeFileSync(path.join(root, 'workflow', 'intents', '2026-09-30-bt1.md'), '---\n状态: draft\n级别: L1\n日期: 2026-09-30\n---\n# I1\n');
-  fs.writeFileSync(path.join(root, 'workflow', 'intents', '2026-09-30-bt2.md'), '---\n状态: draft\n级别: L0\n日期: 2026-09-30\n---\n# I2\n');
+  fs.writeFileSync(path.join(root, 'workflow', 'intents', '2026-09-30-bt2.md'), '---\n状态: draft\n级别: L1\n日期: 2026-09-30\n---\n# I2\n');
   const r = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-09-30-bt1.md', 'workflow/intents/2026-09-30-bt2.md', '--delegated', '批量放行', '--batch'], { cwd: root, encoding: 'utf8' });
   const led = readLedgerOf(root);
   const st1 = fs.readFileSync(path.join(root, 'workflow', 'intents', '2026-09-30-bt1.md'), 'utf8');
   const st2 = fs.readFileSync(path.join(root, 'workflow', 'intents', '2026-09-30-bt2.md'), 'utf8');
-  check('S30 --batch：2 份 L0/L1 一次代录 → 全部 approved + 台账 brief:true / of=2 / seq 递增',
+  check('S30 --batch：2 份 L1 一次代录 → 全部 approved + 台账 brief:true / of=2 / seq 递增',
     r.status === 0 && led.length === 2
       && led.every((e) => e.brief === true && e.source === 'chat-delegated' && e.of === 2 && e.stage === 'approved')
       && led[0].seq === 1 && led[1].seq === 2
@@ -694,7 +696,7 @@ const gitHead = (root) => {
   fs.rmSync(root, { recursive: true, force: true });
 }
 
-// ---- S33 简洁审计：单份 delegated L0/L1（无 --batch）→ 台账 brief:true + 紧凑输出；L2 份不带 brief ----
+// ---- S33 简洁审计：单份 delegated L1（无 --batch）→ 台账 brief:true + 紧凑输出；L2 份不带 brief ----
 {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-bt4-'));
   fs.mkdirSync(path.join(root, 'workflow', 'intents'), { recursive: true });
@@ -880,5 +882,179 @@ const writeTrust = (root, cfg) => {
   fs.rmSync(root, { recursive: true, force: true });
 }
 
+// ---- S42 分片默认写入口径（2026-10-13 ledger-shard-default）：CLI 默认写分片 / 两种回退 / 存量回退 / 显式拒 ----
+{
+  const mkFixture = (withV8) => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-shard-'));
+    const docP = path.join(root, 'workflow', 'intents');
+    fs.mkdirSync(docP, { recursive: true });
+    fs.writeFileSync(path.join(docP, '2026-10-13-s.md'), '---\n状态: draft\n级别: L1\n---\n# I\n');
+    if (withV8) {
+      fs.mkdirSync(path.join(root, '.agents'), { recursive: true });
+      fs.writeFileSync(path.join(root, '.agents', 'kit.json'), JSON.stringify({ policyVersion: 8 }), 'utf8');
+    }
+    return root;
+  };
+  const shardPathOf = (root) => path.join(root, '.agents', 'confirmations.d', '2026-10-13-s.jsonl');
+  const mainPathOf = (root) => path.join(root, '.agents', 'confirmations.jsonl');
+  const readRows = (p) => (fs.existsSync(p) ? fs.readFileSync(p, 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l)) : []);
+  const spawnConfirm = (root, args, env = {}) => spawnSync(process.execPath, [CLI, 'workflow/intents/2026-10-13-s.md', '--delegated', '可以', ...args], { cwd: root, encoding: 'utf8', env: { ...process.env, ...env } });
+
+  // S42① 默认（无旗标）+ doc 链已激活（policyVersion 8）→ 写分片，主台账零行
+  {
+    const root = mkFixture(true);
+    const r = spawnConfirm(root, []);
+    check('S42① 默认写分片：exit 0 + 行落 confirmations.d/<doc基名>.jsonl + 主台账零行',
+      r.status === 0 && readRows(shardPathOf(root)).length === 1
+        && readRows(shardPathOf(root))[0].source === 'chat-delegated'
+        && readRows(mainPathOf(root)).length === 0,
+      JSON.stringify({ status: r.status, stderr: r.stderr }));
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+  // S42② --no-shard → 显式回退主台账
+  {
+    const root = mkFixture(true);
+    const r = spawnConfirm(root, ['--no-shard']);
+    check('S42② --no-shard 回退主台账：exit 0 + 行落 confirmations.jsonl + 分片不存在',
+      r.status === 0 && readRows(mainPathOf(root)).length === 1 && !fs.existsSync(shardPathOf(root)),
+      JSON.stringify({ status: r.status, stderr: r.stderr }));
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+  // S42③ CONFIRM_SHARDED=0 → 环境变量回退主台账
+  {
+    const root = mkFixture(true);
+    const r = spawnConfirm(root, [], { CONFIRM_SHARDED: '0' });
+    check('S42③ CONFIRM_SHARDED=0 回退主台账：exit 0 + 行落 confirmations.jsonl + 分片不存在',
+      r.status === 0 && readRows(mainPathOf(root)).length === 1 && !fs.existsSync(shardPathOf(root)),
+      JSON.stringify({ status: r.status, stderr: r.stderr }));
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+  // S42④ 存量装户（无 kit.json → policyVersion 1，doc 链未激活）默认 → 自动回退主台账 + ℹ️ 升级指引
+  {
+    const root = mkFixture(false);
+    const r = spawnConfirm(root, []);
+    check('S42④ 存量装户默认：自动回退主台账（exit 0 + 行落 confirmations.jsonl）+ stderr 带 policyVersion: 8 升级指引 + 分片不存在',
+      r.status === 0 && readRows(mainPathOf(root)).length === 1
+        && /policyVersion: 8/.test(r.stderr) && !fs.existsSync(shardPathOf(root)),
+      JSON.stringify({ status: r.status, stderr: r.stderr }));
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+  // S42⑤ 存量装户显式 --shard → 参数期直接拒（原口径不变）
+  {
+    const root = mkFixture(false);
+    const r = spawnConfirm(root, ['--shard']);
+    check('S42⑤ 显式 --shard 缺 doc 链锚：exit 1 + 报错带修法 + 零落账（文档/台账均未动）',
+      r.status === 1 && /--shard 需要台账 doc 链口径/.test(r.stderr)
+        && !fs.existsSync(shardPathOf(root)) && !fs.existsSync(mainPathOf(root)),
+      JSON.stringify({ status: r.status, stderr: r.stderr }));
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+  // S42⑥ --shard 与 --no-shard 互斥 → 用法错误
+  {
+    const root = mkFixture(true);
+    const r = spawnConfirm(root, ['--shard', '--no-shard']);
+    check('S42⑥ --shard 与 --no-shard 互斥：exit 1 + 用法提示 + 零落账',
+      r.status === 1 && /互斥/.test(r.stderr) && !fs.existsSync(shardPathOf(root)) && !fs.existsSync(mainPathOf(root)),
+      JSON.stringify({ status: r.status, stderr: r.stderr }));
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// ---- S43 关单即归档（2026-10-13 archive-on-close；B9 自源仓回灌随件测试）：终态家族超窗 → git mv 进 archive ----
+// 需真实 git 仓库（归档走 git mv）；家族原子：intent+plan 同进同退。月份断言锚定「实时今月」——
+// 与源仓同口径（台账终态锚 = 实时 now，归档月 = 家族最晚终态月），跨月运行需随今月更新断言。
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-arch-'));
+  const git = (...a) => spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', a, { cwd: root, encoding: 'utf8' });
+  git('init', '-q');
+  git('config', 'user.email', 't@t');
+  git('config', 'user.name', 't');
+  const ip = path.join(root, 'workflow', 'intents');
+  const pp = path.join(root, 'workflow', 'plans');
+  fs.mkdirSync(ip, { recursive: true });
+  fs.mkdirSync(pp, { recursive: true });
+  fs.mkdirSync(path.join(root, 'workflow', 'archive'), { recursive: true }); // 归档约定在场（启用条件）
+  // 家族：intent（本次关单）+ plan（已 done 且正文变更在 30 天前 → 超窗）
+  fs.writeFileSync(path.join(ip, '2026-09-01-fam.md'), '---\n状态: approved\n级别: L1\n确认指纹: aaaa1111aaaa1111\n---\n# I\n\n## 验收标准（可测试）\n- [x] 通过（证据:测试全绿）\n', 'utf8');
+  fs.writeFileSync(path.join(pp, '2026-09-01-fam.md'), '---\n状态: done\n级别: L1\n---\n# P\n\n## 改动方案\n- 正文\n', 'utf8');
+  git('add', '-A');
+  spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', ['commit', '-q', '-m', 'c1'], { cwd: root, env: { ...process.env, GIT_AUTHOR_DATE: '2026-09-01T10:00:00+08:00', GIT_COMMITTER_DATE: '2026-09-01T10:00:00+08:00' } });
+  const r = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-09-01-fam.md', '--delegated', '可以'],
+    { cwd: root, encoding: 'utf8', env: { ...process.env, CONFIRM_DOC_TEST_NOW: '2026-10-13' } });
+  const intentArchived = fs.existsSync(path.join(root, 'workflow', 'archive', '2026-10', 'intents', '2026-09-01-fam.md'));
+  const planArchived = fs.existsSync(path.join(root, 'workflow', 'archive', '2026-10', 'plans', '2026-09-01-fam.md'));
+  check('S43 关单即归档：终态家族整族 git mv 进 archive（intent+plan 同批）',
+    r.status === 0 && intentArchived && planArchived && /📦 归档/.test(r.stdout),
+    JSON.stringify({ status: r.status, stdout: String(r.stdout).slice(-300), stderr: String(r.stderr).slice(-200), intentArchived, planArchived }));
+  check('S43b 归档后活跃目录不再留该家族', !fs.existsSync(path.join(ip, '2026-09-01-fam.md')) && !fs.existsSync(path.join(pp, '2026-09-01-fam.md')));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- S44 归档边界：本次确认的家族即时归档（窗口对其冗余）；未涉及的家族不越权清理 ----
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-arch2-'));
+  const git = (...a) => spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', a, { cwd: root, encoding: 'utf8' });
+  git('init', '-q');
+  git('config', 'user.email', 't@t');
+  git('config', 'user.name', 't');
+  const ip = path.join(root, 'workflow', 'intents');
+  fs.mkdirSync(ip, { recursive: true });
+  fs.mkdirSync(path.join(root, 'workflow', 'archive'), { recursive: true }); // 归档约定在场（启用条件）
+  // 本次确认的家族（刚落终态 → 即时归档，窗口不适用）
+  fs.writeFileSync(path.join(ip, '2026-10-12-fresh.md'), '---\n状态: approved\n级别: L1\n确认指纹: bbbb2222bbbb2222\n---\n# I\n\n## 验收标准（可测试）\n- [x] 通过（证据:测试全绿）\n', 'utf8');
+  // 未涉及的家族（同为终态、超窗、零引用——但不在本次确认范围，须留守）
+  fs.writeFileSync(path.join(ip, '2026-09-01-other.md'), '---\n状态: done\n级别: L1\n---\n# I2\n\n## 验收标准（可测试）\n- [x] 通过（证据:测试全绿）\n', 'utf8');
+  git('add', '-A');
+  spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', ['commit', '-q', '-m', 'c1'], { cwd: root, env: { ...process.env, GIT_AUTHOR_DATE: '2026-10-12T10:00:00+08:00', GIT_COMMITTER_DATE: '2026-10-12T10:00:00+08:00' } });
+  const r = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-10-12-fresh.md', '--delegated', '可以'],
+    { cwd: root, encoding: 'utf8', env: { ...process.env, CONFIRM_DOC_TEST_NOW: '2026-10-13' } });
+  check('S44 本次确认家族即时归档（窗口对刚过确认门的终态件冗余）',
+    r.status === 0 && fs.existsSync(path.join(root, 'workflow', 'archive', '2026-10', 'intents', '2026-10-12-fresh.md')) && /📦 归档/.test(r.stdout),
+    JSON.stringify({ status: r.status, stdout: String(r.stdout).slice(-200), stderr: String(r.stderr).slice(-200) }));
+  check('S44b 未涉及的家族不越权清理（历史积压走 archive-sweep 手工批次）',
+    fs.existsSync(path.join(ip, '2026-09-01-other.md')),
+    JSON.stringify({ exists: fs.existsSync(path.join(ip, '2026-09-01-other.md')) }));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- S45 归档约定缺席 → 不启用（未采纳归档的仓库不凭空造目录）；env 逃生门 CONFIRM_DOC_NO_ARCHIVE ----
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-arch3-'));
+  const git = (...a) => spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', a, { cwd: root, encoding: 'utf8' });
+  git('init', '-q');
+  git('config', 'user.email', 't@t');
+  git('config', 'user.name', 't');
+  const ip = path.join(root, 'workflow', 'intents');
+  fs.mkdirSync(ip, { recursive: true });
+  fs.writeFileSync(path.join(ip, '2026-09-01-noconv.md'), '---\n状态: approved\n级别: L1\n确认指纹: cccc3333cccc3333\n---\n# I\n\n## 验收标准（可测试）\n- [x] 通过（证据:测试全绿）\n', 'utf8');
+  git('add', '-A');
+  spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', ['commit', '-q', '-m', 'c1'], { cwd: root, env: { ...process.env, GIT_AUTHOR_DATE: '2026-09-01T10:00:00+08:00', GIT_COMMITTER_DATE: '2026-09-01T10:00:00+08:00' } });
+  const r = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-09-01-noconv.md', '--delegated', '可以'],
+    { cwd: root, encoding: 'utf8', env: { ...process.env, CONFIRM_DOC_TEST_NOW: '2026-10-13' } });
+  check('S45 无 workflow/archive/ 约定 → 不归档、不造目录',
+    r.status === 0 && fs.existsSync(path.join(ip, '2026-09-01-noconv.md')) && !fs.existsSync(path.join(root, 'workflow', 'archive')) && !/📦 归档/.test(r.stdout),
+    JSON.stringify({ status: r.status, stdout: String(r.stdout).slice(-200) }));
+  // S45b 有归档约定 + CONFIRM_DOC_NO_ARCHIVE=1 → 逃生门生效（关单不归档）
+  const root2 = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-arch4-'));
+  const git2 = (...a) => spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', a, { cwd: root2, encoding: 'utf8' });
+  git2('init', '-q');
+  git2('config', 'user.email', 't@t');
+  git2('config', 'user.name', 't');
+  const ip2 = path.join(root2, 'workflow', 'intents');
+  fs.mkdirSync(ip2, { recursive: true });
+  fs.mkdirSync(path.join(root2, 'workflow', 'archive'), { recursive: true });
+  fs.writeFileSync(path.join(ip2, '2026-09-01-optout.md'), '---\n状态: approved\n级别: L1\n确认指纹: dddd4444dddd4444\n---\n# I\n\n## 验收标准（可测试）\n- [x] 通过（证据:测试全绿）\n', 'utf8');
+  git2('add', '-A');
+  spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', ['commit', '-q', '-m', 'c1'], { cwd: root2, env: { ...process.env, GIT_AUTHOR_DATE: '2026-09-01T10:00:00+08:00', GIT_COMMITTER_DATE: '2026-09-01T10:00:00+08:00' } });
+  const r2 = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-09-01-optout.md', '--delegated', '可以'],
+    { cwd: root2, encoding: 'utf8', env: { ...process.env, CONFIRM_DOC_TEST_NOW: '2026-10-13', CONFIRM_DOC_NO_ARCHIVE: '1' } });
+  check('S45b CONFIRM_DOC_NO_ARCHIVE 逃生门：关单成功且不归档（状态已置 done）',
+    r2.status === 0 && /状态: done/.test(fs.readFileSync(path.join(ip2, '2026-09-01-optout.md'), 'utf8'))
+      && !fs.existsSync(path.join(root2, 'workflow', 'archive', 'intents')) && !/📦 归档/.test(r2.stdout),
+    JSON.stringify({ status: r2.status, stdout: String(r2.stdout).slice(-200) }));
+  fs.rmSync(root, { recursive: true, force: true });
+  fs.rmSync(root2, { recursive: true, force: true });
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/edit-face-check.mjs

@@ -4,7 +4,7 @@
 //   工作树编辑期零反馈（实测：常驻面重构砍掉阶段索引，到提交才被检查 7 报警）。本脚本把判定左移到编辑时。
 // 判定零复刻铁律：闭环判定**单源**复用 check-loop——以 CHECK_LOOP_ROOT=<root>（全扫模式，扫工作树
 //   非 HEAD）子进程消费其裁决，本脚本不实现任何门判定；唯一自算是常驻面字节预算 advisory（工作树
-//   LF 字节 vs rule-budgets.txt 上限——提交门口径走 git index/HEAD（rule-budget.sh），两者判据不同面，
+//   LF 字节 vs rule-budgets.txt 上限——提交门口径走 git index/HEAD（rule-budget.mjs），两者判据不同面，
 //   此处为编辑时 advisory，冲突时以提交门为准）。
 // exit 语义：check-loop hard（exit≠0）→ 2；预算 advisory 超限 → 1；其余 → 0。
 //   WARN **不进 exit**（打印明细供 AI/人对照）——绝对 WARN 计数会让带存量 advisory 的仓库恒非零
@@ -53,9 +53,11 @@ export function budgetAdvisory(files, budgetsText) {
 }
 
 // runCheck：工作树面 check-loop（CHECK_LOOP_ROOT 全扫）。返回 { code, output, ms }。
+// --all 显式全量（2026-10-13 分道后裸跑=默认硬门）：本工具的动机就是编辑期暴露卫生面 WARN
+// （如阶段索引漂移——头部动机段），硬门子集满足不了，须显式声明全量。
 function runCheck(root, scriptDir) {
   const t0 = Date.now();
-  const r = spawnSync(process.execPath, [path.join(scriptDir, 'check-loop.mjs')], {
+  const r = spawnSync(process.execPath, [path.join(scriptDir, 'check-loop.mjs'), '--all'], {
     cwd: root, encoding: 'utf8', windowsHide: true,
     env: { ...process.env, CHECK_LOOP_ROOT: root },
   });
@@ -84,7 +86,7 @@ export function main(root = process.cwd(), scriptDir = path.dirname(fileURLToPat
     if (/\[WARN /.test(line)) console.log('  ' + line.trim().slice(0, 200));
   }
   for (const { rel, limit, actual } of over) {
-    console.log(`  ⚠️ 预算 advisory：${rel} 工作树 ${actual}B > 上限 ${limit}B（编辑时口径；提交门以 rule-budget.sh 为准）`);
+    console.log(`  ⚠️ 预算 advisory：${rel} 工作树 ${actual}B > 上限 ${limit}B（编辑时口径；提交门以 rule-budget.mjs 为准）`);
   }
   if (ck.code !== 0) {
     console.error('❌ 闭环判定 hard 未过——先修复再提交（判定单源 check-loop，详见上方输出）');

package/templates/_agents/scripts/fill-intent.mjs

@@ -1,5 +1,5 @@
 // flow-kit fill-intent：起草 intent 草稿（背景与问题/历史教训防复发/目标/非目标/约束/影响面/触达红线/验收标准 8 节正文 + 确认与复核 共 9 节）
-// 读 workflow/intents/_TEMPLATE.md 的节标题 → 输出符合 frontmatter 受限子集（6 字段，含 risk_level 风险泳道）的草稿到指定文件
+// 读 workflow/intents/_TEMPLATE.md 的节标题 → 输出符合 frontmatter 受限子集（7 字段，含 risk_level 风险泳道与预判路由）的草稿到指定文件
 // 用法：node .agents/scripts/fill-intent.mjs --module pipeline --level L1 --topic "test" --output /tmp/x.md
 // 零依赖；CLI 解析用最简字符串匹配；不替代 AI 起草——本工具只输出模板与提示句
 import fs from 'node:fs';
@@ -41,10 +41,12 @@ const SECTIONS = [
 // renderIntent：骨架渲染（纯函数）。kbHits（2026-10-09 engine-quality-round3 W2）：kb-search 命中行
 // 数组（📄 行原文）——非空时替换「历史教训/防复发」节的检索占位行为实际命中列表（历史坑强制注入，
 // 手动路由与 pipeline-run 工单同权）；空/缺省保留占位（fail-open 口径）。子进程调用在 main，本函数保持无 IO。
+// 预判（2026-10-13 自 Shipyard §25 prejudgment-ledger 回灌）：intents≡require 恒真、level 与「级别」双写
+// 同值——机器可推导字段直出（与 B6b 路由预判一致性检查对账零 WARN）；advisory 灰度，缺字段零告警。
 export function renderIntent({ topic, module, level, notes, date = TODAY, kbHits = [], kbFailNote = '' }) {
   if (!LEVELS.includes(level)) throw new Error('level 不在枚举 ' + LEVELS.join('|') + '：' + level);
-  const fm = '---\n状态: draft\n级别: ' + level + '\nrisk_level: ' + level + '\n日期: ' + date + '\n模块: ' + module + '\n备注: ' + (notes || '<可选：附注自由文本，check-loop 不解析>') + '\n---\n';
-  let body = '# INTENT — ' + topic + '\n\n<!-- 复制本模板为 YYYY-MM-DD-<主题>.md 后填写；plans/ 下同名文件与本文件配对 -->\n<!-- frontmatter 受限子集（2026-09-13）：每行 键: 值；状态∈draft/approved/done/superseded/cancelled（严格枚举，附注写备注键）；级别∈L0/L1/L2/L3；risk_level=级别（混合治理风险泳道选道：L0/L1 协作道异步审计 / L2/L3 防御道同步确认）；check-loop 只扫 frontmatter 取机器字段，正文不再写状态/级别行 -->\n\n';
+  const fm = '---\n状态: draft\n级别: ' + level + '\n预判: kind=require level=' + level + '\nrisk_level: ' + level + '\n日期: ' + date + '\n模块: ' + module + '\n备注: ' + (notes || '<可选：附注自由文本，check-loop 不解析>') + '\n---\n';
+  let body = '# INTENT — ' + topic + '\n\n<!-- 复制本模板为 YYYY-MM-DD-<主题>.md 后填写；plans/ 下同名文件与本文件配对 -->\n<!-- frontmatter 受限子集（2026-09-13）：每行 键: 值；状态∈draft/approved/done/superseded/cancelled（严格枚举，附注写备注键）；级别∈L1/L2/L3（2026-10-13 L0 退役）；risk_level=级别（混合治理风险泳道选道：L1 协作道异步审计 / L2/L3 防御道同步确认）；check-loop 只扫 frontmatter 取机器字段，正文不再写状态/级别行 -->\n\n';
   for (const { title, hint } of SECTIONS) {
     let section = hint;
     if (title === '历史教训/防复发') {