agentic-flow-kit 1.7.15 → 1.7.16

package/templates/_agents/scripts/check-engine-integrity.test.mjs

@@ -37,8 +37,8 @@ const mkfix = ({ withEntry = false, entryNames = 'gate.mjs' } = {}) => {
   const d = fs.mkdtempSync(path.join(os.tmpdir(), 'engine-integrity-test-'));
   w(d, 'templates/_agents/scripts/gate.mjs',
     '// 门禁样例\nblockers.push(`A`);\nblockers.push(`B`);\nif (bad) process.exit(1);\n');
-  w(d, '.githooks/pre-commit', '#!/bin/sh\nif ! node check.mjs; then\n  echo blocked >&2\n  exit 1\nfi\nexit 0\n');
-  w(d, 'AGENTS.md', '# 协议\n- 规则一\n- 规则二\n');
+  w(d, 'templates/_githooks/pre-commit', '#!/bin/sh\nif ! node check.mjs; then\n  echo blocked >&2\n  exit 1\nfi\nexit 0\n');
+  w(d, 'templates/AGENTS.md', '# 协议\n- 规则一\n- 规则二\n');
   if (withEntry) {
     w(d, 'workflow/intents/2026-10-09-ctrl.md',
       `---\n状态: approved\n级别: L2\n日期: 2026-10-09\n模块: gate\n---\n# INTENT\n改动面：templates/_agents/scripts/${entryNames}\n`);
@@ -56,14 +56,13 @@ const mkfix = ({ withEntry = false, entryNames = 'gate.mjs' } = {}) => {
 {
   const d = mkfix();
   const u = run(d, ['--update']);
-  // fixture 无 .agents/ → 基线落包源径（resolveLock 布局回落，见 T9/T10）
   const lockPath = path.join(d, 'templates', '_agents', 'engine-lock.json');
   let lock = null;
   try { lock = JSON.parse(fs.readFileSync(lockPath, 'utf8')); } catch { /* 断言兜 */ }
   const r = run(d);
   check('T2a --update → exit 0 且基线入账受检面', u.code === 0 && !!lock && !!lock.files['templates/_agents/scripts/gate.mjs'], u.out);
   check('T2b 基线记 hard=3（2 blocker + 1 exit(1)）', !!lock && lock.files['templates/_agents/scripts/gate.mjs'].hard === 3, JSON.stringify(lock && lock.files['templates/_agents/scripts/gate.mjs']));
-  check('T2c 钩子入面 hard=1（exit 1 计数）', !!lock && lock.files['.githooks/pre-commit'].hard === 1, JSON.stringify(lock && lock.files['.githooks/pre-commit']));
+  check('T2c 钩子入面 hard=1（exit 1 计数）', !!lock && lock.files['templates/_githooks/pre-commit'].hard === 1, JSON.stringify(lock && lock.files['templates/_githooks/pre-commit']));
   check('T2d 盘面未变 → exit 0 且报「与基线一致」', r.code === 0 && r.out.includes('盘面与基线一致'), r.out);
 }
 
@@ -78,36 +77,31 @@ const mkfix = ({ withEntry = false, entryNames = 'gate.mjs' } = {}) => {
   check('T3b 有活跃 L2 入口仍拦（收缩无豁免出口）', r.code === 1 && r.out.includes('[硬拦面收缩]'), r.out);
 }
 
-// --- T4 非收缩改动：无入口拦、有入口放行 ---
+// --- T4 非收缩改动：内容漂移即拦（2026-10-13 移除入口退路后无豁免出口）---
 {
   const d = mkfix();
   run(d, ['--update']);
   w(d, 'templates/_agents/scripts/gate.mjs', '// 门禁样例（改写文案）\n// 说明行\ntoast(`hint`);\nblockers.push(`A`);\nblockers.push(`B`);\nif (bad) process.exit(1);\n');
-  const noEntry = run(d);
-  check('T4a 内容漂移 + 无入口 → [控制面改动无入口]',
-    noEntry.code === 1 && noEntry.out.includes('[控制面改动无入口]') && noEntry.out.includes('gate.mjs'), noEntry.out);
-  w(d, 'workflow/intents/2026-10-09-ctrl.md',
-    '---\n状态: approved\n级别: L2\n日期: 2026-10-09\n模块: gate\n---\n# INTENT\n改动面：templates/_agents/scripts/gate.mjs\n');
-  const withEntry = run(d);
-  check('T4b 同一改动 + 活跃 L2 入口点名该件 → 放行', withEntry.code === 0, withEntry.out);
-}
-// --- T4c 入口存在但级别为 L1（协作道）→ 不算点名 ---
-{
-  const d = mkfix({ withEntry: false });
-  run(d, ['--update']);
-  w(d, 'templates/_agents/scripts/gate.mjs', 'blockers.push(`A`);\nblockers.push(`B`);\nif (bad) process.exit(1);\n// 追加注释不改硬拦面\n');
-  w(d, 'workflow/intents/2026-10-09-low.md', '---\n状态: approved\n级别: L1\n日期: 2026-10-09\n模块: gate\n---\n改动面：gate.mjs\n');
-  const r = run(d);
-  check('T4c L1 入口点名不豁免（控制面须防御道）', r.code === 1 && r.out.includes('[控制面改动无入口]'), r.out);
+  const drift = run(d);
+  check('T4a 内容漂移（硬拦面未缩）→ [控制面改动未入基线]',
+    drift.code === 1 && drift.out.includes('[控制面改动未入基线]') && drift.out.includes('gate.mjs'), drift.out);
+  check('T4a 修法指向 --update（不再宣传不可达的「立 L2 入口」）',
+    drift.out.includes('--update') && !drift.out.includes('立 L2 入口'), drift.out);
+  check('T4a --update 入账后放行', run(d, ['--update']).code === 0 && run(d).code === 0);
 }
-// --- T4d 入口非活跃（done 已关单）→ 不算点名 ---
+// --- T4e 入口面即便存在也不豁免（锁死新口径）---
+// 1.7.15 卸掉同仓双身份后，包源仓没有 workflow/intents —— 旧「立入口即放行」退路在本仓不可达。
+// 删掉该能力后，即使有人在包源仓手工造出入口文档点名该件，**也不得**成为放行口：
+// 否则一个 mkdir 就把门重新打开，等于用未验证的路径恢复未验证的能力。
 {
-  const d = mkfix({ withEntry: false });
+  const d = mkfix();
   run(d, ['--update']);
   w(d, 'templates/_agents/scripts/gate.mjs', 'blockers.push(`A`);\nblockers.push(`B`);\nif (bad) process.exit(1);\n// 追加注释\n');
-  w(d, 'workflow/intents/2026-10-09-done.md', '---\n状态: done\n级别: L2\n日期: 2026-10-09\n模块: gate\n---\n改动面：gate.mjs\n');
+  w(d, 'workflow/intents/2026-10-09-ctrl.md',
+    '---\n状态: approved\n级别: L2\n日期: 2026-10-09\n模块: gate\n---\n# INTENT\n改动面：gate.mjs\n');
   const r = run(d);
-  check('T4d done 入口不点名（活跃口径：draft/approved）', r.code === 1 && r.out.includes('[控制面改动无入口]'), r.out);
+  check('T4e 活跃 L2 入口点名该件 → 仍拦（本门无声明式豁免出口）',
+    r.code === 1 && r.out.includes('[控制面改动未入基线]'), r.out);
 }
 
 // --- T5 门禁件消失 / 新增件未入基线 ---
@@ -158,26 +152,20 @@ if (haveGit) {
   const anchored = run(d, ['--against-ref', 'HEAD']);
   check('T7b 跨提交锚（祖先提交基线）出账 [硬拦面收缩（跨提交锚）]',
     anchored.code === 1 && anchored.out.includes('[硬拦面收缩（跨提交锚）]') && /3（见 HEAD）→ 盘面 2/.test(anchored.out), anchored.out);
-  // 合法退役出口：活跃 L2 入口点名该件
+  // T7c/T7e（2026-10-13 移除入口退路后删除）：原为「活跃 L2 入口点名 → 锚层放行」与「严格档：
+  //   模糊提及不豁免」两条断言。二者均依赖 workflow/intents 入口面，而该面在本仓结构性不可达
+  //   （1.7.15 卸掉同仓双身份），故能力与测试一并移除——锚层的收缩判定现在**无豁免出口**。
+  // T7c 替代断言：造出入口文档点名该件，锚层仍须拦（锁死「无豁免」不随时间被悄悄恢复）
   w(d, 'workflow/intents/2026-10-09-retire.md',
     '---\n状态: approved\n级别: L2\n日期: 2026-10-09\n模块: gate\n---\n# INTENT\n改动面：templates/_agents/scripts/gate.mjs（退役 B 判据）\n');
   git(d, ['add', '-A']);
-  git(d, ['commit', '-q', '-m', 'docs(gate): L2 入口留痕']);
+  git(d, ['commit', '-q', '-m', 'docs(gate): 造入口文档（应不构成放行口）']);
   const declared = run(d, ['--against-ref', 'HEAD~1']);
-  check('T7c 声明过的收缩（L2 入口点名）→ 跨提交锚放行', declared.code === 0, declared.out);
+  check('T7c 入口文档点名该件 → 锚层仍拦（本门无声明式豁免出口）',
+    declared.code === 1 && declared.out.includes('[硬拦面收缩（跨提交锚）]'), declared.out);
   // 锚缺失（首个入账提交之前）→ 跳过不误报
   const missing = run(d, ['--against-ref', 'HEAD~9']);
   check('T7d ref 不可解析 → 锚缺失跳过（exit 0 不假阳性）', missing.code === 0 && missing.out.includes('跨提交锚缺失'), missing.out);
-  // 严格档反例（T7e）：正文顺手提及 ≠ 声明改动面——存量无关 L2 文档不得替改弱行为背书
-  w(d, 'workflow/intents/2026-10-09-retire.md',
-    '---\n状态: superseded\n级别: L2\n日期: 2026-10-09\n模块: gate\n---\n# INTENT\n改动面：templates/_agents/scripts/gate.mjs\n');
-  w(d, 'workflow/intents/2026-10-09-prose.md',
-    '---\n状态: approved\n级别: L2\n日期: 2026-10-09\n模块: gate\n---\n# INTENT\n本批沿用 gate.mjs 与 check-loop.mjs 的既有判据，未改动它们。\n');
-  git(d, ['add', '-A']);
-  git(d, ['commit', '-q', '-m', 'docs(gate):  prose 提及（非声明改动面）']);
-  const prose = run(d, ['--against-ref', 'HEAD~2']);
-  check('T7e 正文提及但无 §改动面 声明 → 跨提交锚仍拦（严格档：模糊提及不豁免收缩）',
-    prose.code === 1 && prose.out.includes('[硬拦面收缩（跨提交锚）]'), prose.out);
 } else {
   console.log('SKIP T7 跨提交锚（未找到 git）');
 }
@@ -190,18 +178,18 @@ if (haveGit) {
   check('T8 --quiet 通过时不打印 ✅ 行', r.code === 0 && !r.out.includes('✅'), r.out);
 }
 
-// --- T9 装户布局：.agents/ 在 → 基线落装户径，不新建 templates/_agents/engine-lock.json ---
+// --- T9 非包源根：拒绝，不写基线、不建 templates/_agents ---
 {
   const d = fs.mkdtempSync(path.join(os.tmpdir(), 'engine-integrity-test-'));
   w(d, '.agents/scripts/gate.mjs', 'blockers.push(`A`);\nblockers.push(`B`);\nif (bad) process.exit(1);\n');
   w(d, 'AGENTS.md', '# 协议\n- 规则一\n');
   const u = run(d, ['--update']);
-  let lock = null;
-  try { lock = JSON.parse(fs.readFileSync(path.join(d, '.agents', 'engine-lock.json'), 'utf8')); } catch { /* 断言兜 */ }
-  check('T9a .agents/ 在 → --update 落 .agents/engine-lock.json（装户径行为不变）',
-    u.code === 0 && !!lock && !!lock.files['.agents/scripts/gate.mjs'], u.out);
-  check('T9b 装户布局不新建 templates/_agents/engine-lock.json',
-    !fs.existsSync(path.join(d, 'templates', '_agents', 'engine-lock.json')), '');
+  const plain = run(d);
+  check('T9a 非包源根 --update 拒绝', u.code !== 0 && /只在包源仓运行/.test(u.out), u.out);
+  check('T9b 非包源根默认模式同样拒绝', plain.code !== 0 && /只在包源仓运行/.test(plain.out), plain.out);
+  check('T9c 不写 .agents/engine-lock.json，不建 templates/_agents',
+    !fs.existsSync(path.join(d, '.agents', 'engine-lock.json'))
+    && !fs.existsSync(path.join(d, 'templates', '_agents')), '');
   fs.rmSync(d, { recursive: true, force: true });
 }
 

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

@@ -30,6 +30,7 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { laneOfEntry, laneOfDoc } from './stage-gates.mjs';
 import { loadKitPolicy } from './policy.mjs';
+import { loadLevelHints, hintLevelFor, rankOf, maxLevel } from './level-criteria.mjs';
 
 const argv = process.argv.slice(2);
 const argOf = (k) => {
@@ -126,32 +127,80 @@ const collectActive = () => {
 const blocks = [];
 const advisories = [];
 
+// --- 检查 A0：level-hints 路径下限对账（2026-10-13 hints-backstop）----------------
+// 背景：此前「就高不就低」只在 flow-kit route 输出 advisory，而提交面判低门只认 lane-surfaces.txt
+//   → 两份清单各管一头、**无机器对账**：项目在 hints 里登记了「改这些面至少 L2/L3」，提交面却可能
+//   靠一个 L1 活跃入口放行（判低有机可乘）。本段把 hints 接进提交面：
+//   ① hints 命中 → 要求存在**级别 ≥ 命中档**的活跃入口（不只「有个 high 入口」），否则 hard 拦；
+//   ② hints 已登记高风险面、lane-surfaces.txt 却缺失/为空 → advisory 提示「意图面登记了、提交面无兜底」。
+//   fail-closed：hints 语法错 → hard 拦（写错配置比没配置危险，见 level-criteria parseLevelHints）。
+const hintsState = (() => {
+  try {
+    const { hints } = loadLevelHints(ROOT);
+    return { hints, invalid: null };
+  } catch (e) {
+    return { hints: [], invalid: e.message };
+  }
+})();
+
+if (hintsState.invalid) {
+  blocks.push([
+    '[level-hints 配置错误] .agents/level-hints.txt 非法（档位只收 L2/L3；ERE 不得带行内注释）——配置面坏了整条兜底不可信：',
+    ...String(hintsState.invalid).split('\n').map((l) => `  ${l}`),
+    '  修法：修正清单后重试（fail-closed，防静默空洞——写错配置比没配置危险：没配置会提示，写错会误判档位）',
+  ].join('\n'));
+}
+
+// 命中判定复用判据单源的 hintLevelFor（2026-10-13 executor-review）：此前本文件手写了一遍
+//   「路径归一化 + 多条命中取高档」，与 level-criteria.mjs:104 的实现同形但独立演进——
+//   双源漂移是本仓硬规则（doctor 段就写着「不复刻解析器」），一旦归一化口径调整，
+//   route 会判 L1 而本门拦 L3，且没有任何测试能发现。
+const hintHits = hintsState.hints.length
+  ? STAGED
+    .map((p) => ({ p, lv: hintLevelFor(hintsState.hints, [p]).level }))
+    .filter((x) => x.lv)
+  : [];
+const hintLevel = hintHits.reduce((acc, x) => maxLevel(acc, x.lv), '');
+
 // --- 检查 A：触达面判低 ---
 const patterns = loadPatterns();
+
+if (hintLevel && !patterns.length) {
+  advisories.push(
+    `[level-hints 无提交面兜底] .agents/level-hints.txt 登记了 ${hintHits.length} 个命中（${hintHits.slice(0, 5).map((x) => `${x.p}→${x.lv}`).join(' ')}）——`
+    + '但 .agents/lane-surfaces.txt 缺失或为空，触达面判低检查整体跳过：意图面登记了高风险面，提交面却无兜底',
+  );
+}
 const hits = patterns.length ? STAGED.filter((p) => patterns.some((re) => re.test(p))) : [];
-if (hits.length) {
+// 本次提交触达到的**最低应然档位**：lane-surfaces 命中隐含 L2（沿原口径），hints 命中按登记档取。
+// 混档取高——与 level-criteria maxLevel 同一口径（就高不就低在提交面同样成立）。
+const requiredLevel = maxLevel(hits.length ? 'L2' : '', hintLevel);
+if (requiredLevel) {
   const active = collectActive();
-  const hasHigh = active.some((e) => e.lane === 'high');
-  if (!hasHigh) {
-    const low = active.filter((e) => e.lane !== 'high'); // low + suspect 均拦（suspect 不作豁免依据）
-    if (low.length) {
-      const newest = [...low].sort((a, b) => (b.date || '').localeCompare(a.date || '') || b.rel.localeCompare(a.rel))[0];
-      const fixVerb = newest.lane === 'suspect'
-        ? '① 对齐该入口「级别」与「risk_level」两字段至一致的 L2/L3（fill-intent 双写口径；现两值缺失/非法/分歧）并补同名 spec（.agents/commands/design.md）'
-        : '① 升级该入口「级别」与「risk_level」两字段至 L2/L3 并补同名 spec（.agents/commands/design.md）';
-      const text = [
-        `[触达面判低] 暂存命中 L2 触达面，但活跃入口无泳道 high（存在 low/suspect）：`,
-        `  命中: ${hits.join(' ')}`,
-        `  关联入口: ${newest.rel}（级别 ${newest.level || '缺失'}/risk_level ${newest.risk || '缺失'}→ 泳道 ${newest.lane}${newest.date ? `，${newest.date}` : ''}；活跃非 high 共 ${low.length} 件）`,
-        `  修法（三选一）: ${fixVerb}`,
-        `    ② 该入口已完成则关单（done）或显式放弃（superseded/cancelled）——不留活跃残留`,
-        `    ③ 面清单误配则修 .agents/lane-surfaces.txt`,
-      ].join('\n');
-      if (isExperiment) advisories.push(`（advisory·experiment 泳道，不阻断；转正由 pre-push 加固门兜底）\n${text}`);
-      else blocks.push(text);
-    } else {
-      advisories.push(`[触达面判低]（advisory）暂存命中 L2 触达面（${hits.length} 个文件），但当前无任何活跃入口——若非 docs / bootstrap 豁免类改动（.agents/commands/new-task.md §intent 豁免），请先立入口文档`);
-    }
+  const requiredRank = rankOf(requiredLevel) ?? 1;
+  // 入口是否够格：级别 rank ≥ 应然档。**suspect（级别/risk_level 缺失、非法或分歧）一律不够格**——
+  //   沿用原口径「suspect 不作豁免依据」：分歧（L2/L1）这类看似够档的入口，机器无法确认它真罩着这批改动。
+  const enough = (e) => e.lane !== 'suspect' && (rankOf(e.level) ?? -1) >= requiredRank;
+  const insufficient = active.filter((e) => !enough(e));
+  if (insufficient.length) {
+    const newest = [...insufficient].sort((a, b) => (b.date || '').localeCompare(a.date || '') || b.rel.localeCompare(a.rel))[0];
+    const hitList = [...hits.map((p) => `${p}（触达面）`), ...hintHits.map((x) => `${x.p}（hints→${x.lv}）`)];
+    const fixVerb = newest.lane === 'suspect'
+      ? `① 对齐该入口「级别」与「risk_level」两字段至一致的 ${requiredLevel}（fill-intent 双写口径；现两值缺失/非法/分歧）并补同名 spec（.agents/commands/design.md）`
+      : `① 升级该入口「级别」与「risk_level」两字段至 ${requiredLevel} 及以上并补同名 spec（.agents/commands/design.md）`;
+    const text = [
+      `[触达面判低] 暂存命中高风险面，但活跃入口无 ${requiredLevel} 及以上（存在更低档/low/suspect）：`,
+      `  命中: ${hitList.join(' ')}`,
+      `  关联入口: ${newest.rel}（级别 ${newest.level || '缺失'}/risk_level ${newest.risk || '缺失'}→ 泳道 ${newest.lane}${newest.date ? `，${newest.date}` : ''}；活跃不足共 ${insufficient.length} 件）`,
+      ...(hintLevel ? ['  判据：.agents/level-hints.txt 登记的路径下限——就高不就低在提交面同样成立（此前只 advisory，无门）'] : []),
+      `  修法（三选一）: ${fixVerb}`,
+      `    ② 该入口已完成则关单（done）或显式放弃（superseded/cancelled）——不留活跃残留`,
+      `    ③ 清单误配则修 .agents/lane-surfaces.txt${hintLevel ? ' 或 .agents/level-hints.txt' : ''}`,
+    ].join('\n');
+    if (isExperiment) advisories.push(`（advisory·experiment 泳道，不阻断；转正由 pre-push 加固门兜底）\n${text}`);
+    else blocks.push(text);
+  } else if (!active.length) {
+    advisories.push(`[触达面判低]（advisory）暂存命中高风险面（${hits.length + hintHits.length} 个文件，应然 ${requiredLevel}），但当前无任何活跃入口——若非 docs / bootstrap 豁免类改动（.agents/commands/new-task.md §intent 豁免），请先立入口文档`);
   }
 }
 
@@ -176,7 +225,7 @@ if (isExperiment) {
 for (const a of advisories) console.error(`泳道完整性（增量）— advisory:\n${a}\n`);
 if (blocks.length) {
   for (const b of blocks) console.error(`泳道完整性（增量）— BLOCK:\n${b}\n`);
-  console.error('pre-commit: 泳道完整性未通过，提交已阻止（判据见 .agents/commands/new-task.md §级别判断）');
+  console.error('pre-commit: 泳道完整性未通过，提交已阻止（判据单源见 .agents/scripts/level-criteria.mjs）');
   process.exit(1);
 }
 process.exit(0);

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

@@ -200,6 +200,72 @@ const FM_L0_NEW = '状态: draft\n级别: L0\n日期: 2026-10-01\n模块: ui';
   const r = run(d, { staged: ['ok/a.ts'] });
   check('配置含非法 ERE → fail-closed 阻断并指出坏行', r.code === 1 && r.out.includes('[面清单语法错误]') && r.out.includes('[invalid('), r.out);
 }
+// --- S-hints（2026-10-13 hints-backstop）：level-hints 接入提交面判低 ---
+// 此前「就高不就低」只在 flow-kit route 输出 advisory，提交面只认 lane-surfaces → 两份清单无机器对账。
+{
+  // ① hints 命中 L3，但活跃入口只有 L2 → 判低必须拦（此前「有个 high 入口」就放行）
+  const d = mkfix();
+  base(d, { level: 'L2' });
+  w(d, '.agents/level-hints.txt', 'L3 ^src/db/\n');
+  const r = run(d, { staged: ['src/db/schema.sql'] });
+  check('S-hints hints 命中 L3 + 活跃仅 L2 → 阻断（要求入口 ≥ L3，不只「有个 high」）',
+    r.code === 1 && r.out.includes('[触达面判低]') && r.out.includes('src/db/schema.sql')
+      && r.out.includes('L3') && r.out.includes('level-hints.txt'), r.out);
+
+  // ② 升到 L3 后放行
+  const d2 = mkfix();
+  base(d2, { level: 'L3' });
+  w(d2, '.agents/level-hints.txt', 'L3 ^src/db/\n');
+  const r2 = run(d2, { staged: ['src/db/schema.sql'] });
+  check('S-hints 入口升到 L3 → 放行', r2.code === 0 && !r2.out.includes('[触达面判低]'), r2.out);
+
+  // ③ 无 hints（默认空）→ 不产生任何新阻断面（旧装户零影响）
+  const d3 = mkfix();
+  base(d3, { level: 'L1' });
+  const r3 = run(d3, { staged: ['src/db/schema.sql'] });
+  check('S-hints 未配 hints → 不触发新判定（默认空=纯语义定级）', !r3.out.includes('[触达面判低]'), r3.out);
+
+  // ④ hints 命中但无任何活跃入口 → advisory（与检查 A 同口径，豁免 docs/bootstrap 类）
+  const d4 = mkfix();
+  w(d4, '.agents/lane-surfaces.txt', '^templates/\n');
+  w(d4, '.agents/level-hints.txt', 'L2 ^src/db/\n');
+  const r4 = run(d4, { staged: ['src/db/x.sql'] });
+  check('S-hints 命中但无活跃入口 → advisory 不阻断',
+    r4.code === 0 && r4.out.includes('触达面判低') && r4.out.includes('advisory'), r4.out);
+
+  // ⑤ hints 语法错 → fail-closed（写错配置比没配置危险）
+  const d5 = mkfix();
+  base(d5, { level: 'L2' });
+  w(d5, '.agents/level-hints.txt', 'L3 [bad(\n');
+  const r5 = run(d5, { staged: ['ok/a.ts'] });
+  check('S-hints 非法 hints → fail-closed 阻断并带路径行号',
+    r5.code === 1 && r5.out.includes('[level-hints 配置错误]') && r5.out.includes('level-hints.txt'), r5.out);
+
+  // ⑥ 两份清单交叉对账：hints 登记了高风险面、lane-surfaces 为空 → advisory 点名「提交面无兜底」
+  const d6 = mkfix();
+  w(d6, '.agents/level-hints.txt', 'L2 ^src/db/\n');
+  const r6 = run(d6, { staged: ['src/db/x.sql'] });
+  check('S-hints hints 已登记但触达面清单空 → advisory 点名无兜底',
+    r6.code === 0 && r6.out.includes('level-hints 无提交面兜底'), r6.out);
+
+  // ⑦ L0 档 hints → 配置错误 fail-closed（2026-10-13 executor-review 实测 Major）
+  //   原实现接受 `L0 ^docs/`，提交面判低门当真 → 纯文档提交被硬拦，修法还让人「升级至 L0 及以上」
+  const d7 = mkfix();
+  base(d7, { level: 'L1' });
+  w(d7, '.agents/level-hints.txt', 'L0 ^docs/\n');
+  const r7 = run(d7, { staged: ['docs/readme.md'] });
+  check('S-hints L0 档 hints → fail-closed 阻断（不拿低档当门槛）',
+    r7.code === 1 && r7.out.includes('[level-hints 配置错误]') && r7.out.includes('L2 或 L3'), r7.out);
+
+  // ⑧ 路径归一化口径与判据单源一致（复用 hintLevelFor，不再各自复刻）
+  //   同一文件同时命中 hints 与触达面 → 判据里点名两处来源；Windows 反斜杠写法也要能命中
+  const d8 = mkfix();
+  base(d8, { level: 'L3' });
+  w(d8, '.agents/level-hints.txt', 'L3 ^src/db/\n');
+  const r8 = run(d8, { staged: ['src\\db\\a.sql'] });
+  check('S-hints 反斜杠路径经单源归一后仍命中（复用 hintLevelFor）',
+    r8.code === 0 && !r8.out.includes('[触达面判低]'), r8.out);
+}
 // --- git 真仓端到端：走生产发现路径（quotepath=off + diff --cached）---
 {
   const d = mkfix();

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

@@ -3,6 +3,14 @@
 // 目的：把「台账本地可写」的伪造面从事后对质级升为机器可检出级（能力评审审计维度扣分项）。
 // 台账不可变原则：confirmations.jsonl 历史行禁删改——修正只能走追加补偿行（README 硬规则 6）。
 //
+// **特许修剪通道（2026-10-12 ledger-prune-manifest）**：append-only 之上唯一的合法删行出口。场景是
+//   仓库所有者明令删除某批 workflow 文档——台账对应行不删则行级④持续报红，退路只剩手改台账
+//   （即把使用者逼向 `--no-verify`）。判据与凭据格式见 ledger-prune.mjs：暂存集须同带
+//   `.agents/ledger-prune-manifest.json`（被删行 sha256 + 授权 + 理由），逐行对账「新 = 旧 − manifest
+//   所列行」且每哈希恰命中一行、doc ∈ 声明家族，才认领为合法修剪；无 manifest 的删/改/重排**仍全拦**。
+//   诚实边界：manifest 是可写文件，刻意伪造即可让任意删行合法化——与「台账本地可写」同级（见 README
+//   确认门诚实边界）。本通道不宣称防伪，只把「顺手手改」抬到「提交一份可被 git 历史对质的凭据」。
+//
 // 模式：
 //   历史全扫（缺省，CI 机器门）：遍历台账全部提交历史（时间正序），每次变更必须以旧 blob 为
 //     **逐字节前缀**（允许纯追加；禁止删行/改行/重排）；再对最终树做行级校验（五项，见下）。
@@ -10,11 +18,14 @@
 //   --staged（pre-commit 前置）：暂存 blob 必须以 HEAD blob 为逐字节前缀——提交时刻即拦重写。
 //
 // 行级校验（终树，五项）：
-//   ① ts 为 ISO 字符串且全表非降序（追加时序单调）
+//   ① ts 为 ISO 字符串，且**同一 doc 内**非降序（跨 doc 物理序乱序不判——并集合并/分片归并的正常形态，
+//      2026-10-12 修正；同 doc 内倒挂仍 hard 拦，跨 doc 插行/改行由检查 15 哈希链兜）
 //   ② fingerprint 为 64 位 hex
 //   ③ source=chat-delegated 行必有非空 quote（原话对质面）
 //   ④ doc 匹配 workflow/(intents|specs|plans|incidents)/[^/]+.md 且当前树存在
 //   ⑤ stage ∈ 合法跳转终态集（approved/done/fixed/closed/superseded/cancelled）
+//   取数面 = ledger-loader 视图（主台账 + 分片 confirmations.d/*.jsonl）；视图序为主台账在前，
+//      故既有 ledger-line-exempt.json 的行号不因引入分片而漂移。
 //
 // 行级豁免（2026-10-09 ledger-line-exempt，CI 红事故处置）：.agents/ledger-line-exempt.json 登记
 // 已定性的污染行（{line, doc, reason}——line = 校验序号即非空行序）——行级五项对豁免行整体跳过、
@@ -29,6 +40,8 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
+import { matchPrune, loadManifestFromRef, PRUNE_REL } from './ledger-prune.mjs';
+import { readLedgerRows, SHARD_DIR_REL } from './ledger-loader.mjs';
 
 const argv = process.argv.slice(2);
 const argOf = (k) => {
@@ -62,11 +75,22 @@ if (staged) {
     process.exit(0); // 对象读取异常（如极端并发）交由 CI 全扫兜底
   }
   if (!cur.subarray(0, head.length).equals(head)) {
+    // 特许修剪（2026-10-12 ledger-prune-manifest）：仓库所有者明令删某批 workflow 文档时，台账对应行
+    // 须随之删除，否则行级④「doc 在当前树存在」持续报红、退路只剩手改台账（踩 --no-verify 红线）。
+    // 出口 = **逐行对账 + 凭据入库**：暂存集须同时携带 .agents/ledger-prune-manifest.json，判据见
+    // ledger-prune.mjs matchPrune（四条缺一不可）。无 manifest 的删/改/重排仍全拦——append-only 红线
+    // 对其他一切场景不变。被删行哈希随 manifest 入库，事后可对质。
+    const m = matchPrune(head.toString('utf8'), cur.toString('utf8'),
+      loadManifestFromRef(`:${PRUNE_REL}`, ROOT));
+    if (m && !m.err) {
+      console.log(`台账不变量（--staged）— 特许修剪通过：移除 ${m.removed} 行（${m.docs.length} 家族）——凭据 ${PRUNE_REL} 随笔入库，被删行可在 git 历史对质`);
+      process.exit(0);
+    }
     let off = 0;
     while (off < Math.min(head.length, cur.length) && head[off] === cur[off]) off++;
-    problems.push(`- [台账重写] 暂存内容不是 HEAD 的前缀扩展（首异偏移 ${off}，HEAD ${head.length}B → 暂存 ${cur.length}B）`);
+    problems.push(`- [台账重写] 暂存内容不是 HEAD 的前缀扩展（首异偏移 ${off}，HEAD ${head.length}B → 暂存 ${cur.length}B）${m && m.err ? `；特许修剪对账失败：${m.err}` : ''}`);
     console.error('台账不可变（--staged）— BLOCK:\n' + problems.join('\n'));
-    console.error('  修法：台账历史行禁删改——误写走追加补偿行（node .agents/scripts/confirm-doc.mjs ...）；确需撤销历史提交请 git revert 后重新追加');
+    console.error(`  修法：台账历史行禁删改——误写走追加补偿行（node .agents/scripts/confirm-doc.mjs ...）；确需撤销历史提交请 git revert 后重新追加。\n        所有者明令删除某批文档须同笔暂存 ${PRUNE_REL}（逐行 sha256 + 授权 + 理由），门禁逐行对账后才放行。`);
     process.exit(1);
   }
   process.exit(0);
@@ -82,6 +106,15 @@ try {
 }
 if (!shas.length) process.exit(0);
 
+// 分片路径清单（2026-10-12 ledger-shard-write）：**扫 git 全历史里出现过的分片**，不只看工作树现有的
+// ——compact 会把分片删掉，只看工作树就永远扫不到「已删分片的历史」。用 pathspec 枚举全史分片路径。
+let shardRelPaths = [];
+try {
+  shardRelPaths = gitText(['log', '--all', '--format=', '--name-only', '--', `${SHARD_DIR_REL}/`])
+    .split(/\r?\n/).map((l) => l.trim()).filter((l) => l.startsWith(`${SHARD_DIR_REL}/`) && l.endsWith('.jsonl'));
+  shardRelPaths = [...new Set(shardRelPaths)].sort();
+} catch { /* 非仓库/无分片历史 → 空清单，分片段整段跳过 */ }
+
 let prev = null;
 let prevSha = null;
 for (const sha of shas) {
@@ -94,20 +127,68 @@ for (const sha of shas) {
     continue;
   }
   if (prev !== null && !cur.subarray(0, prev.length).equals(prev)) {
-    let off = 0;
-    while (off < Math.min(prev.length, cur.length) && prev[off] === cur[off]) off++;
-    const removed = prev.length > cur.length;
-    problems.push(`- [前缀破坏] ${sha.slice(0, 10)}（前承 ${prevSha.slice(0, 10)}）：历史内容被${removed ? `删减 ${prev.length - cur.length}B` : `改写（首异偏移 ${off}，旧 ${prev.length}B → 新 ${cur.length}B）`}`);
+    // 特许修剪：前缀破坏时，若该提交树上携带 manifest 且逐行对账通过 = 认领为合法修剪，
+    // loud 记录后**以新 blob 为基线续扫**（对质凭据 = 该提交的 manifest + 被删行内容在 git 历史里）。
+    const m = matchPrune(prev.toString('utf8'), cur.toString('utf8'), loadManifestFromRef(`${sha}:${PRUNE_REL}`, ROOT));
+    if (m && !m.err) {
+      console.error(`[info] ${sha.slice(0, 10)}：特许修剪 ${m.removed} 行（${m.docs.length} 家族）——manifest 对账通过，凭据 ${PRUNE_REL} 入库可对质`);
+    } else {
+      let off = 0;
+      while (off < Math.min(prev.length, cur.length) && prev[off] === cur[off]) off++;
+      const removed = prev.length > cur.length;
+      problems.push(`- [前缀破坏] ${sha.slice(0, 10)}（前承 ${prevSha.slice(0, 10)}）：历史内容被${removed ? `删减 ${prev.length - cur.length}B` : `改写（首异偏移 ${off}，旧 ${prev.length}B → 新 ${cur.length}B）`}${m && m.err ? `；特许修剪对账失败：${m.err}` : ''}`);
+    }
   }
   prev = cur;
   prevSha = sha;
 }
 
+// ---- 分片历史扫描（2026-10-12 ledger-shard-write）----
+// 分片 `.agents/confirmations.d/*.jsonl` 此前**不受本门约束**——`--shard` 写入一旦可用，分片就成了
+// 前缀不变量的缺口（可改可删而不被历史扫到）。故逐分片路径做同样的前缀不变量扫描。
+// **删除豁免（与主台账相反）**：compact-ledgers.mjs 归并后**删除分片是合法形态**，不能照抄主台账那条
+// 「删文件即 hard fail」。豁免判据：该分片被删时的内容，其**每一行都已出现在同提交的主台账里**
+// （并集归并的必然结果）→ 认领为 compact 归并；否则（行未并入 = 丢行）仍 hard fail。
+for (const shard of shardRelPaths) {
+  let sShas;
+  try {
+    sShas = gitText(['log', '--format=%H', '--reverse', '--', shard]).split(/\s+/).filter(Boolean);
+  } catch { continue; }
+  let sPrev = null;
+  for (const sha of sShas) {
+    let sCur = null;
+    try { sCur = blobOf(`${sha}:${shard}`); } catch { sCur = null; }
+    if (sCur === null) {
+      // 分片在本次提交消失 → 只在「行已全部并入主台账」时认领 compact 归并
+      if (sPrev !== null) {
+        const shardLines = sPrev.toString('utf8').replace(/\r\n/g, '\n').split('\n').filter((l) => l.trim());
+        let mainNow = '';
+        try { mainNow = blobOf(`${sha}:${REL}`).toString('utf8'); } catch { /* 主台账亦不在 = 整体删除，另行报 */ }
+        const mainLines = new Set(mainNow.replace(/\r\n/g, '\n').split('\n').filter((l) => l.trim()));
+        const missing = shardLines.filter((l) => !mainLines.has(l));
+        if (missing.length === 0) {
+          console.error(`[info] ${sha.slice(0, 10)}：分片 ${shard} 删除（${shardLines.length} 行已全部并入主台账——compact 归并形态，放行）`);
+        } else {
+          problems.push(`- [分片删除丢行] ${sha.slice(0, 10)}：${shard} 被删除，但其中 ${missing.length} 行未出现在主台账（compact 归并须先并入再删）`);
+        }
+      }
+      sPrev = null;
+      continue;
+    }
+    if (sPrev !== null && !sCur.subarray(0, sPrev.length).equals(sPrev)) {
+      let off = 0;
+      while (off < Math.min(sPrev.length, sCur.length) && sPrev[off] === sCur[off]) off++;
+      problems.push(`- [分片前缀破坏] ${sha.slice(0, 10)}：${shard} 历史内容被改写（首异偏移 ${off}，旧 ${sPrev.length}B → 新 ${sCur.length}B）——分片同受 append-only 前缀不变量约束`);
+    }
+    sPrev = sCur;
+  }
+}
+
 // ---- 行级校验（终树）----
-let rows = [];
-try {
-  rows = fs.readFileSync(FILE, 'utf8').split(/\r?\n/).filter((l) => l.trim()).map((l) => { try { return JSON.parse(l); } catch { return null; } });
-} catch { /* 上面 existsSync 已兜 */ }
+// 取数走 ledger-loader 视图（2026-10-12 ledger-loader-p1 / ledger-doc-chain）：主台账 + 分片
+// `.agents/confirmations.d/*.jsonl`。**视图序 = 主台账行在前、分片行在后**——故既有
+// `.agents/ledger-line-exempt.json` 的行号（基于主台账全量）不因引入分片而漂移。
+const rows = readLedgerRows(ROOT);
 const EXEMPT_P = path.join(ROOT, '.agents', 'ledger-line-exempt.json');
 const exemptLines = new Set();
 try {
@@ -118,15 +199,29 @@ try {
   }
 } catch { /* 豁免表损坏 → 视同无豁免（fail-closed 于校验面） */ }
 let exemptCount = 0;
-let prevTs = '';
+// ① ts 单调口径（2026-10-12 ledger-doc-chain 配套修正）：**按 doc 分组内单调**，跨 doc 物理序乱序不判。
+// 为什么必须改：git 并集合并（见 git-merge-jsonl.mjs）与分片归并都会把「别的 doc 的新行」追加到本文件
+//   尾部，而那些行的 ts 可能早于本文件末行的 ts → **必然**触发原「全表非降序」判据。这是正常协作的形态，
+//   不是篡改；让门禁因正常协作报红，只会逼出 `--no-verify`。
+// 仍保留的强判据：**同一 doc 内的 ts 倒挂照报**（该 doc 的确认时序倒挂是真问题），另加哈希链
+//   （检查 15）覆盖跨 doc 的插行/改行。跨 doc 乱序仅计数出账、不阻断（可观测性保留）。
+const prevTsByDoc = new Map();
+let crossDocOutOfOrder = 0;
+let prevTsAny = '';
 rows.forEach((e, idx) => {
   const at = `第 ${idx + 1} 行`;
   if (exemptLines.has(idx + 1)) { exemptCount++; return; } // 事故行豁免（登记文件入库可对质）
   if (!e || typeof e !== 'object') { problems.push(`- [行级] ${at}：非 JSON 对象行`); return; }
   if (typeof e.ts !== 'string' || Number.isNaN(Date.parse(e.ts))) problems.push(`- [行级] ${at}：ts 非 ISO 字符串`);
   else {
-    if (prevTs && e.ts < prevTs) problems.push(`- [行级] ${at}：ts ${e.ts} 早于前行 ${prevTs}（追加时序非单调）`);
-    prevTs = e.ts;
+    const docKey = typeof e.doc === 'string' ? e.doc : '（doc 缺失）';
+    const prevSameDoc = prevTsByDoc.get(docKey);
+    if (prevSameDoc && e.ts < prevSameDoc) {
+      problems.push(`- [行级] ${at}：ts ${e.ts} 早于同 doc 前行 ${prevSameDoc}（${docKey} 追加时序倒挂）`);
+    }
+    prevTsByDoc.set(docKey, e.ts);
+    if (prevTsAny && e.ts < prevTsAny) crossDocOutOfOrder++;
+    prevTsAny = e.ts;
   }
   const isRevertNote = typeof e.stage === 'string' && e.stage.startsWith('revert-');
   if (isRevertNote) {
@@ -144,6 +239,9 @@ rows.forEach((e, idx) => {
 });
 
 if (exemptCount) console.log(`ℹ️  台账豁免行 ${exemptCount} 条（定性见 .agents/ledger-line-exempt.json）`);
+if (crossDocOutOfOrder) {
+  console.log(`ℹ️  台账跨 doc 物理序 ts 乱序 ${crossDocOutOfOrder} 处（并集合并 / 分片归并的正常形态——不阻断；同 doc 内时序倒挂仍 hard 拦，插行/改行由检查 15 哈希链兜）`);
+}
 if (problems.length) {
   console.error(`台账不可变（历史全扫）— HARD-BLOCK:\n\n${problems.join('\n')}\n`);
   console.error('  修法：台账历史行禁删改（append-only 前缀不变量）——误写只能追加补偿行；确需撤销历史提交请 git revert 后重新追加。篡改属审计事件，保留现场联系仓库所有者。');

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

@@ -92,7 +92,11 @@ const append = (d, line) => fs.appendFileSync(ledPath(d), line + '\n');
   append(d, row({ ts: '2026-10-01T00:00:00.000Z', stage: 'done' })); // 早于首行
   commitAll(d, 'append out-of-order');
   const r = run(d);
-  check('S5 ts 非单调 → 行级 exit 1', r.code === 1 && r.out.includes('非单调'), r.out);
+  // S5：ts 乱序追加 → 行级拦。措辞随 2026-10-12 口径修正由「非单调」改为「追加时序倒挂」
+  // （判据从「全表非降序」收窄为「同 doc 内非降序」，跨 doc 乱序是并集合并的正常形态）。
+  // 本例两行同 doc（demo.md），故仍在新口径下 hard 拦。
+  check('S5 ts 非单调（同 doc 内倒挂）→ 行级 exit 1',
+    r.code === 1 && r.out.includes('追加时序倒挂'), r.out);
 }
 // S6：伪指纹（非 64-hex）→ 行级拦
 {

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

@@ -24,6 +24,9 @@ const HOOK = [
 ].find((p) => fs.existsSync(p)) || null;
 const git = process.platform === 'win32' ? 'git.exe' : 'git';
 const Z = '0'.repeat(40);
+// 夹具闭包（2026-10-12 fixture-closure-rootfix）：本文件此前三处手写依赖枚举（tree 场景最险——漏拷
+// ledger-loader 会让看板漂移门恒绿而非报错）。改为按入口自动求传递闭包，新增依赖自动跟随。
+const { copyScriptClosure, copyAgentsFiles } = await import('./fixture-scripts.mjs');
 
 let pass = 0;
 let fail = 0;
@@ -215,10 +218,9 @@ try {
   gitRun(tree, ['config', 'user.email', 't@example.com']);
   gitRun(tree, ['config', 'user.name', 't']);
   fs.mkdirSync(path.join(tree, '.agents', 'scripts'), { recursive: true });
-  fs.copyFileSync(ENUMS, path.join(tree, '.agents', 'workflow-enums.txt'));
-  fs.copyFileSync(path.join(HERE, 'gen-workflow-index.mjs'), path.join(tree, '.agents', 'scripts', 'gen-workflow-index.mjs'));
-  fs.copyFileSync(path.join(HERE, 'workflow-enums.mjs'), path.join(tree, '.agents', 'scripts', 'workflow-enums.mjs'));
-  fs.copyFileSync(path.join(HERE, 'rule-budget.sh'), path.join(tree, '.agents', 'scripts', 'rule-budget.sh'));
+  copyAgentsFiles(path.join(tree, '.agents'), ['workflow-enums.txt']);
+  // 索引生成器 + 预算判定件的整闭包（含 workflow-enums.mjs 与日后新增依赖）
+  copyScriptClosure(path.join(tree, '.agents', 'scripts'), ['gen-workflow-index.mjs', 'rule-budget.sh']);
   fs.writeFileSync(path.join(tree, '.agents', 'rule-budgets.txt'), 'big.txt 10\n');
   fs.writeFileSync(path.join(tree, 'big.txt'), 'ok\n');
   for (const sub of ['intents', 'specs', 'plans', 'incidents']) {