agentic-flow-kit 1.7.15 → 1.8.0

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

@@ -7,39 +7,44 @@
 //   ② CI 的机器门跑的是**被测分支自己的** `.agents/scripts/check-loop.mjs`（ci.yml:42）——被改坏的
 //      裁判验证自己的篡改，无外部参照，CI 全绿。
 //
-// 本门的做法：把「门禁本体当前的硬拦面」**冻结进一个入库基线** `.agents/engine-lock.json`，
-//   判定 = HEAD 盘面向量 ↔ 基线逐项比对（哈希 + 硬拦单位数）。它不是签名、也不宣称不可伪造——
-//   它把「静默改弱」变成「必须显式声明的改弱」：
+// 本门的做法：把「门禁本体当前的硬拦面」**冻结进一个入库基线** `templates/_agents/engine-lock.json`，
+//   判定 = 包源盘面向量 ↔ 基线逐项比对（哈希 + 硬拦单位数）。它不是签名、也不宣称不可伪造——
+//   它把「静默改弱」变成「必须显式 --update 的改弱」：
 //     · 硬拦单位数**下降**（删 blocker / 删 exit 1 / 从面清单删行 / 从 CI 删一次门调用）→ 无条件 BLOCK；
-//     · 内容变了但硬拦面没缩 → 须有一份**活跃 L2/L3 入口文档正文点名该文件**，否则 BLOCK；
-//     · 基线本身在受检面内（engine-lock.json 已入 control-surfaces，装户径与包源径两面），
-//       改基线同样要过入口门。
-//   于是绕过路径从「编辑一个文件」抬到「编辑两个文件 + 立一份 L2 文档 + 落一条确认台账 + 提交」——
-//   每一环都在 git 历史与台账里留痕，可事后对质。诚实边界：`--no-verify` / 不挂 hooksPath /
-//   删掉本脚本仍可绕过本地门，兜底 = CI 复跑（本脚本被 ci.yml 调用）+ 分支保护；本地信任边界内
+//     · 内容变了但硬拦面没缩 → 同样 BLOCK，直到跑 --update 把新盘面显式入账；
+//     · 基线本身在受检面内（control-surfaces 列了 templates/_agents/engine-lock.json），
+//       改基线同样要过本门（对基线的改动 = 受检面内容变更 → 未入新基线即拦）。
+//   诚实边界：`--no-verify` / 不挂 hooksPath / 删掉本脚本仍可绕过本地门，兜底 = CI 复跑
+//   （本脚本被 .github/workflows 的 engine-integrity job 调用）+ 分支保护；本地信任边界内
 //   不可机器防这一点不掩盖（沿 policy.mjs#ledgerChainHash 与 README 确认门口径）。
 //
+// **无声明式豁免（2026-10-13 移除入口退路）**：此前本门有两档豁免——本地层「正文提及即认」、
+//   锚层「活跃 L2/L3 入口在 §改动面 点名」，参照物是 `<root>/workflow/{intents,incidents}`。
+//   但 1.7.15「卸掉同仓双身份」后**包源仓已无该目录**（装户端内容清理），退路在本仓结构性不可达：
+//   门消息让包源维护者去「立 L2 入口」，而立不了——不可达的能力等于误导。故整体移除（连带
+//   T4b/T4c/T4d 与锚层严格档测试）：本仓只认 --update 这一条显式演进路径，语义更少、更可核对。
+//   **代价（诚实记录）**：跨提交锚只比对**硬拦单位数**、不比 sha，故「改写某检查的语义但保住
+//   exit 1 计数 + --update」这一形态两层都绿。补法是让锚层也比对 sha，代价是每次合法演进都需一份
+//   显式凭据（改判据面，未决）。
+//
 // 可选外部锚两条（都是「不受被测对象控制的参照物」，缺省不启用=无外部副本/无历史时不误报）：
 //   --against <目录>      逐字比对包源件与外部副本（装户/发布仓：node_modules/agentic-flow-kit）
 //   --against-ref <ref>   跨提交锚（破 CI 自指的关键一环）：从**历史 ref** 读基线（git show <ref>:<lock>），
 //     与盘面硬拦单位数做单调比较。本地门只比「盘面 ↔ 同分支基线」——恶意分支可同时改弱门禁并 --update
 //     重写基线，两者自洽、CI 全绿（「裁判给自己判无罪」的第二形态）。跨提交锚的参照物在**祖先提交**里，
 //     改它要 rewrite history + 强推（分支保护拦住），CI 由此获得一个不受被测分支控制的参照。
-//     合法收缩（退役一道门）不是一步死路：本地层宽松档（正文提及即认），锚层**严格档**——须活跃
-//     L2/L3 入口在 §改动面 段落点名该文件（正文顺手提及不豁免；否则存量无关 L2 文档可替任意改弱背书）。
+//     硬拦面收缩在本层**无豁免出口**：锚的参照物分支改不动，只能改判据基线并走评审。
 //     ref 不可解析 / 该 ref 无基线（首个入账提交）→ 跳过并报 ℹ️（锚缺失不误报）。
 //
-// 判据原则（沿 check-lane-surface）：只用一手事实——盘面字节哈希、可数单位、文档正文点名；
-//   不从时间戳反推过程。
+// 判据原则（沿 check-lane-surface）：只用一手事实——盘面字节哈希与可数单位；
+//   不从时间戳反推过程、不靠文档正文为改动背书。
 // 用法：node check-engine-integrity.mjs [--root <dir>] [--update] [--against <dir>] [--against-ref <ref>] [--quiet]
-//   --update  按当前盘面重生成基线（合法演进的最后一步；本身是控制面改动，须与入口文档同批提交）
-// 退出码：0 通过（含基线缺失=未启用）；1 阻断（stderr 出 [标签] 与修法）；2 用法错误（如 --against 目录不存在）
+//   --update  按当前盘面重生成基线（合法演进的唯一路径：演进=显式改基线，不存在自动放行）
+// 退出码：0 通过（含基线缺失=未启用）；1 阻断（stderr 出 [标签] 与修法，或目标根不是包源仓）；2 用法错误（如 --against 目录不存在）
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
-import { laneOfEntry, laneOfDoc } from './stage-gates.mjs';
-import { loadKitPolicy } from './policy.mjs';
 
 const argv = process.argv.slice(2);
 const argOf = (k) => {
@@ -53,24 +58,19 @@ const ROOT = argOf('--root') || (() => {
   const r = spawnSync('git', ['-C', process.cwd(), 'rev-parse', '--show-toplevel'], { encoding: 'utf8' });
   return r.status === 0 ? String(r.stdout || '').trim() : process.cwd();
 })();
-// 引擎基线路径双布局（装户端内容清理后）：盘面已有基线按其径读；两处皆无时按**仓库布局**定
-// 落点——.agents/ 在 = 装户径；否则 templates/_agents/ 在 = 包源径（--update 才不会重建已清理的装户目录）。
-// ⚠️ 包源径在 sync 下发面内（render.mjs 只排除 .agents/cache）：包源基线的键是 templates/_agents/scripts/…
-// 路径，装户盘面是 .agents/scripts/…——一旦把包源基线入库，sync 会把它下发进每个装户的 .agents/，
-// 命名空间错配 → 全员误报「门禁件消失 / 未入基线」。纯包源仓**不得入库包源基线**；要引擎仓自证
-// 完整性，须把基线放到 sync 扫描面之外（如仓库根）再接线 CI，且其豁免出口（L2 入口）在纯包源仓
-// 无 workflow/ 的情况下无处可立——这是设计约束，不是待修缺陷。
-const LOCK_CANDIDATES = ['.agents/engine-lock.json', 'templates/_agents/engine-lock.json'];
-const resolveLock = () => {
-  for (const rel of LOCK_CANDIDATES) {
-    if (fs.existsSync(path.join(ROOT, rel))) return { rel, abs: path.join(ROOT, rel) };
-  }
-  const fallback = fs.existsSync(path.join(ROOT, '.agents'))
-    ? LOCK_CANDIDATES[0]
-    : LOCK_CANDIDATES[1];
-  return { rel: fallback, abs: path.join(ROOT, fallback) };
-};
-const { rel: LOCK_REL, abs: LOCK_ABS } = resolveLock();
+// 只认包源。基线固定 templates/_agents/engine-lock.json。受检面只扫包源模板
+// （scripts / _githooks / templates/_github / .github/workflows / templates/AGENTS.md / templates/_agents/*.txt）。
+// `.github/workflows/*.yml` 是包源自身的 CI 编排——本门的调用点在那儿，不纳入就等于门可被无声关闭。
+// 不扫 .agents、不扫项目根 .githooks、不按「有没有 .agents」猜布局。
+// 无 templates/_agents 时所有模式都拒绝：静默扫到 0 个文件会看起来像通过。
+// render.mjs 排除 .agents/engine-lock.json，避免把包源基线下发进装户。
+const pkgAgents = path.join(ROOT, 'templates', '_agents');
+if (!fs.existsSync(pkgAgents)) {
+  console.error(`check-engine-integrity 只在包源仓运行（需要 templates/_agents）。目标根 ${ROOT} 不是包源仓。`);
+  process.exit(1);
+}
+const LOCK_REL = 'templates/_agents/engine-lock.json';
+const LOCK_ABS = path.join(ROOT, LOCK_REL);
 
 // ---- 受检面（单源：本函数；基线与比对同一份清单，防「基线少记一项」的静默空洞）----
 const gateFiles = () => {
@@ -86,18 +86,20 @@ const gateFiles = () => {
     }
   };
   addDir('templates/_agents/scripts', (r) => /\.mjs$/.test(r) && !r.endsWith('.test.mjs'));
-  addDir('.agents/scripts', (r) => /\.mjs$/.test(r) && !r.endsWith('.test.mjs'));
   addDir('templates/_githooks');
-  addDir('.githooks');
-  addDir('.agents/hooks');
-  addDir('.github/workflows', (r) => r.endsWith('.yml'));
   addDir('templates/_github/workflows', (r) => r.endsWith('.yml'));
+  // 包源自身的机器门编排（.github/workflows/*.yml）。**刻意纳入**：本门是「唯一能防改弱门禁本体」的检查，
+  //   而门要成为门就得有人调用它——调用点只存在于 CI 编排里。不纳入的话，删掉编排里的本门调用
+  //   （或整个 job）没有任何检查会发现：被保护面之外的空白，正是它自身失效的那条路径。
+  addDir('.github/workflows', (r) => r.endsWith('.yml'));
   for (const f of ['lane-surfaces.txt', 'control-surfaces.txt', 'workflow-enums.txt', 'workflow-modules.txt',
-    'scripts-test-exempt.txt', 'rule-budgets.txt', 'metric-claims.txt']) {
-    add(`.agents/${f}`);
+    'scripts-test-exempt.txt', 'rule-budgets.txt', 'metric-claims.txt',
+    // level-hints.txt（2026-10-13 flow-kit-route 补录）：风险级别的**路径下限**清单，直接驱动
+    //   flow-kit route 定级结果，且语法错会 fail-loud 抛 LEVEL_HINTS_INVALID 改判级结论。
+    //   与 lane-surfaces.txt / workflow-modules.txt 同属「喂判据的输入面」，此前漏在受检面外。
+    'level-hints.txt']) {
     add(`templates/_agents/${f}`);
   }
-  add('AGENTS.md');
   add('templates/AGENTS.md');
   return [...out].sort();
 };
@@ -112,7 +114,10 @@ const hardUnits = (rel, text) => {
   const count = (re) => (text.match(re) || []).length;
   if (/\.m?c?js$/.test(rel) && !rel.endsWith('.test.mjs')) return count(/blockers\.push\(/g) + count(/process\.exit\(1\)/g);
   if (/^(\.githooks|templates\/_githooks)\//.test(rel) || /\.sh$/.test(rel) || rel.endsWith('local-pre-commit')) {
-    return count(/\bexit\s+1\b/g);
+    // 硬拦单位数 = 钩子内可阻断提交的退出点。2026-10-13 门禁去 sh 化（B2）：无扩展名钩子改 CommonJS 后
+    // 硬拦形态从 sh 的 `exit 1` 变为 process.exit(非零字面/状态表达式)——两种形态并计，sh 侧计数不变
+    // （sh 无 process.exit；exit(0) 成功路径不计）。此为改判据基线的合法演进（本文件头口径），与 CHANGELOG 同批。
+    return count(/\bexit\s+1\b/g) + count(/process\.exit\((?!0\b)/g);
   }
   if (rel.endsWith('.yml')) return count(/node [^\s]*scripts\/[^\s]*\.(mjs|cjs|sh)/g); // CI 里每道门的调用
   if (/\.(txt|json)$/.test(rel)) {
@@ -135,71 +140,6 @@ const readJson = (p) => {
   try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
 };
 
-// 活跃 L2/L3（泳道 high）入口集合：一次扫描，宽松/严格两档判据共用同一份盘面事实
-const HIGH_ENTRIES = (() => {
-  const ACTIVE = { intent: new Set(['draft', 'approved']), incident: new Set(['open', 'fixed']) };
-  const fmGet = (lines, key) => {
-    for (let i = 1; i < lines.length; i++) {
-      if (/^---\s*$/.test(lines[i])) break;
-      const m = lines[i].match(new RegExp(`^${key}:\\s*(.*)$`));
-      if (m) return m[1].trim();
-    }
-    return '';
-  };
-  const pol = loadKitPolicy(ROOT);
-  const cache = [];
-  for (const [dir, kind] of [['intents', 'intent'], ['incidents', 'incident']]) {
-    const dp = path.join(ROOT, 'workflow', dir);
-    if (!fs.existsSync(dp)) continue;
-    for (const f of fs.readdirSync(dp)) {
-      if (!f.endsWith('.md') || f === '_TEMPLATE.md') continue;
-      const abs = path.join(dp, f);
-      let lines;
-      try { lines = fs.readFileSync(abs, 'utf8').replace(/\r\n/g, '\n').split('\n'); } catch { continue; }
-      if (!/^---\s*$/.test(lines[0] || '')) continue;
-      const st = fmGet(lines, '状态');
-      if (!ACTIVE[kind].has(st)) continue;
-      const level = fmGet(lines, '级别');
-      const lane = kind === 'intent'
-        ? laneOfEntry(level, fmGet(lines, 'risk_level'), pol.riskLevelSince, fmGet(lines, '日期'))
-        : laneOfDoc(level);
-      if (lane !== 'high') continue;
-      cache.push({ rel: `workflow/${dir}/${f}`, text: lines.join('\n') });
-    }
-  }
-  return cache;
-})();
-
-// 宽松档（本地层）：整条 rel 或 basename 出现在正文即认——口径同检查 8 的「声明改动面 ↔ 提交文件」
-//   模糊匹配，宁松不假阳性；精确性由 confirm-doc 指纹与台账承担。
-const entryNamesFile = (fileRel) => {
-  const base = path.basename(fileRel);
-  return HIGH_ENTRIES.find((e) => e.text.includes(fileRel) || e.text.includes(base)) || null;
-};
-
-// 严格档（仅跨提交锚用）：入口须在**声明改动面**段落点名该文件，而非正文任意一处提及。
-//   为什么分层：本地层的模糊放行代价低（内容漂移本就允许「声明过的演进」）；锚层拦的是
-//   「硬拦单位数下降」——若一句顺手提及就能豁免，本仓实测三份**与本批无关的存量 L2 incident**
-//   （2026-09-28-metric-claim-gate / 2026-10-03-plan-confirm-boiler 正文含 check-loop.mjs，
-//   2026-09-26-managed-ledger-adopt 含 pre-commit）即可替任意改弱行为背书，锚等于没有。
-//   严格档的误拦修法就是协议本意：把该文件写进入口的 §改动面。
-const entryDeclaresFile = (() => {
-  const SECTION = /^[^\n]{0,40}改动面/;
-  const declared = (text) => {
-    const lines = text.split('\n');
-    const out = [];
-    for (let i = 0; i < lines.length; i++) {
-      if (/^---\s*$/.test(lines[i]) || !SECTION.test(lines[i])) continue;
-      // 含标题行本身（「§改动面 点名 x.mjs」是常见的一行式声明）与标题后到下一个 heading 前的全部正文
-      for (let j = i; j < lines.length && (j === i || !/^\s*#{1,6}\s/.test(lines[j])); j++) out.push(lines[j]);
-    }
-    return out.join('\n');
-  };
-  return (fileRel) => {
-    const base = path.basename(fileRel);
-    return HIGH_ENTRIES.find((e) => { const s = declared(e.text); return s.includes(fileRel) || s.includes(base); }) || null;
-  };
-})();
 
 if (UPDATE) {
   fs.mkdirSync(path.dirname(LOCK_ABS), { recursive: true });
@@ -211,7 +151,7 @@ if (UPDATE) {
   console.log(`引擎基线已更新：${LOCK_REL}（受检面 ${Object.keys(lock.files).length} 个文件）`);
   if (changed.length) console.log(`  本次入账为改动件：${changed.length} 个`);
   if (removed.length) console.log(`  本次移除（文件已不在盘）：${removed.join(' ')}`);
-  console.log('  ⚠️ 基线更新本身是控制面改动：须与点名这些文件的 L2 入口文档同批提交（否则检查 C / 本门默认模式会拦）');
+  console.log('  ⚠️ 基线更新本身是控制面改动：须与该次演进的 CHANGELOG 记录同批提交（改基线 = 受检面内容变更，不入新基线即被本门拦）');
   process.exit(0);
 }
 
@@ -223,14 +163,10 @@ for (const rel of gateFiles()) current[rel] = { sha256: shaOf(path.join(ROOT, re
 // ---- 跨提交锚（先于本地基线判定：恶意分支把盘面 engine-lock.json 删掉也逃不掉这一层——参照物读自 git 对象库）----
 if (argOf('--against-ref')) {
   const ref = argOf('--against-ref');
-  // 两候选径都试（装户径 / 包源径）——纯包源仓的基线在 templates/_agents/ 下，锚须读得到
   let anchor = null;
-  for (const rel of LOCK_CANDIDATES) {
-    const r = spawnSync('git', ['-C', ROOT, 'show', `${ref}:${rel}`], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
-    try { anchor = JSON.parse(String(r.stdout || '')); } catch { /* 该候选径在此 ref 无基线 → 试下一个 */ }
-    if (anchor && anchor.files) break;
-    anchor = null;
-  }
+  const r = spawnSync('git', ['-C', ROOT, 'show', `${ref}:${LOCK_REL}`], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  try { anchor = JSON.parse(String(r.stdout || '')); } catch { /* 该 ref 无基线 */ }
+  if (!anchor || !anchor.files) anchor = null;
   if (!anchor) {
     if (!QUIET) console.log(`ℹ️  跨提交锚缺失（${ref} 无 ${LOCK_REL}）——该层跳过（首个入账提交/浅克隆）`);
   } else {
@@ -238,16 +174,13 @@ if (argOf('--against-ref')) {
       const got = current[rel];
       if (!got) { problems.push(`[门禁件消失（跨提交锚）] ${rel} 在 ${ref} 的基线内但盘面不存在——删除一道门等于禁用该检查`); continue; }
       if (typeof was.hard !== 'number' || got.hard >= was.hard) continue;
-      const e = entryDeclaresFile(rel);
-      if (!e) {
-        problems.push(`[硬拦面收缩（跨提交锚）] ${rel} 硬拦单位数 ${was.hard}（见 ${ref}）→ 盘面 ${got.hard}，减少 ${was.hard - got.hard}——祖先提交是参照物，本分支改不动它；确需退役该判据须有活跃 L2/L3 入口在**声明改动面**段落点名该文件（正文顺手提及不算——存量无关文档会替任意改弱行为背书）`);
-      }
+      problems.push(`[硬拦面收缩（跨提交锚）] ${rel} 硬拦单位数 ${was.hard}（见 ${ref}）→ 盘面 ${got.hard}，减少 ${was.hard - got.hard}——祖先提交是参照物，本分支改不动它。本门无声明式豁免出口（2026-10-13 移除：入口退路在本仓结构性不可达，详见文件头），收缩一律拦`);
     }
   }
 }
 
 if (!lock || !lock.files) {
-  if (!QUIET) console.log(`ℹ️ 引擎基线未启用（无 ${LOCK_REL}）——跑 node .agents/scripts/check-engine-integrity.mjs --update 生成（跨提交锚与外部副本锚照常执行）`);
+  if (!QUIET) console.log(`ℹ️ 引擎基线未启用（无 ${LOCK_REL}）——跑 node templates/_agents/scripts/check-engine-integrity.mjs --update 生成（跨提交锚与外部副本锚照常执行）`);
 } else {
   for (const [rel, want] of Object.entries(lock.files)) {
     const got = current[rel];
@@ -255,14 +188,13 @@ if (!lock || !lock.files) {
     if (!got) { problems.push(`[门禁件消失] ${rel} 在基线内但盘面不存在——删除一道门等于禁用该检查`); continue; }
     if (got.sha256 === want.sha256) continue;
     if (typeof want.hard === 'number' && got.hard < want.hard) {
-      problems.push(`[硬拦面收缩] ${rel} 硬拦单位数 ${want.hard} → ${got.hard}（减少 ${want.hard - got.hard}）——删 blocker/exit/判据行的结构性形态，无论是否声明均拦`);
+      problems.push(`[硬拦面收缩] ${rel} 硬拦单位数 ${want.hard} → ${got.hard}（减少 ${want.hard - got.hard}）——删 blocker/exit/判据行的结构性形态，一律拦`);
     } else {
-      const e = entryNamesFile(rel);
-      if (!e) problems.push(`[控制面改动无入口] ${rel} 内容与基线不符（${name} 硬拦单位数 ${want.hard} → ${got.hard}）——无活跃 L2/L3 入口正文点名该文件`);
+      problems.push(`[控制面改动未入基线] ${rel} 内容与基线不符（${name} 硬拦单位数 ${want.hard} → ${got.hard}）——门禁本体的每次演进都要显式更新基线，不存在「声明过的改动」自动放行`);
     }
   }
   for (const rel of Object.keys(current)) {
-    if (!lock.files[rel]) problems.push(`[门禁件未入基线] ${rel} 是新出现的受检文件——合法新增判据须跑 --update 并把基线更新与入口文档同批提交`);
+    if (!lock.files[rel]) problems.push(`[门禁件未入基线] ${rel} 是新出现的受检文件——合法新增判据须跑 --update 入账`);
   }
 }
 
@@ -280,8 +212,8 @@ if (argOf('--against')) {
 
 if (problems.length) {
   console.error(`引擎完整性 — HARD-BLOCK:\n\n${problems.map((p) => `- ${p}`).join('\n')}\n`);
-  console.error(`  修法：确属门禁演进 → 立 L2 入口（正文 §改动面 点名上述文件）+ 判据更新后跑 node .agents/scripts/check-engine-integrity.mjs --update，三者同批提交`);
-  console.error('  修法：非演进（误改/被他人改动）→ git diff 核对并回退，勿改基线绕过（基线本身在控制面清单内）');
+  console.error(`  修法：确属门禁演进 → 跑 node templates/_agents/scripts/check-engine-integrity.mjs --update 入账，并与 CHANGELOG 记录同批提交（提交评审即对质场；本门无声明式豁免出口，见文件头）`);
+  console.error('  修法：非演进（误改/被他人改动）→ git diff 核对并回退，勿改基线绕过（基线本身在控制面清单内，改它同样是受检面变更）');
   process.exit(1);
 }
 if (!QUIET) console.log(`✅ 引擎完整性：受检面 ${Object.keys(current).length} 个文件（硬拦面无收缩${lock && lock.files ? '、盘面与基线一致' : '、本地基线未启用'}）`);

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-funnel.mjs

@@ -0,0 +1,56 @@
+// check-funnel.mjs — 检查 26：闭环漏斗「协议前」占比动作阈值 [warning]（2026-10-13 B6b-2 自
+//   Shipyard.Material check-loop-sections/s26-funnel-action.mjs 回灌；段体判据逐字对齐，出处沿革留痕
+//   在包源仓 git 历史与 CHANGELOG——装户径不引实例路径）
+// 背景（funnel-action-threshold）：workflow/metrics.md 闭环漏斗早就在记「协议前」（收口却无确认链）
+// 件数，但该数据只有观测没有动作——门禁零触发有退役阈值、指标超额有对账，唯独「闭环被绕开」这一项
+// 无任何阈值，等于默许可绕。本段补动作面：漏斗表里日历相邻两月协议前占比均 >30% → WARN 并要求一轮归因。
+// 判据口径：
+//   - 占比 = 协议前 / 收口；收口 = 0 的月份无占比（0/0 不判），只按有分母的月参与相邻比对；
+//   - 「相邻」= nextMonth(前一月) === 当前月（行已按月升序）——单月波动（批量迁移 / 集中补录）不触发；
+//   - 阈值 30%：源仓与生成器 gen-workflow-metrics.mjs 的 LEGACY_RATIO_LIMIT 同值（单源两侧）；
+//     kit 的 gen-workflow-metrics 不渲染占比单元格（裸整数形态），故 0.30 单点在本文件——若日后给
+//     生成器加 ⚠️ 标记面，须恢复「同值单源两侧 + 夹具钉住」纪律。
+// 纯 WARN advisory（沿 §25 先例）：这是月度节奏的过程事实，不是每次提交的正确性事实——
+//   拿它做 hard-block 会把月度问题钉成每日拦路，逼人绕的正是门自己。升格判据见 mechanism-registry §26 行。
+// 数据源是生成物（gen-workflow-metrics.mjs 单源写入），单元格形如 `79（45%） ⚠️` 或存量裸 `79`——
+//   解析只取首个整数，两种形态都认（生成器升级当月不会整表重算，混合形态必须可读）。
+// ROOT 由 check-loop 供给：--rev 模式下 ROOT 指向该提交的临时 worktree，故本段在 pre-push --rev
+// 与工作区两种模式下读的都是同一棵树。
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function run(ctx) {
+  const { ROOT, WF, warnings } = ctx;
+  // --- 26. 闭环漏斗「协议前」占比动作阈值 [warning] ---
+  const RATIO_LIMIT = 0.30;
+  const metricsPath = path.join(ROOT, WF, 'metrics.md');
+  if (!fs.existsSync(metricsPath)) return; // 装户/新仓无快照 = 未启用该观测，静默跳过（沿 lane-surfaces「缺失即跳过」惯例）
+  const rows = [];
+  let inFunnel = false;
+  for (const line of fs.readFileSync(metricsPath, 'utf8').split(/\r?\n/)) {
+    if (/^##\s+闭环漏斗/.test(line)) { inFunnel = true; continue; }
+    if (inFunnel && /^##\s+/.test(line)) break; // 漏斗段到下一节为止
+    if (!inFunnel) continue;
+    const m = line.match(/^\|\s*(\d{4}-\d{2})\s*\|\s*(\d+)\s*\|\s*(\d+)\s*\|\s*(\d+)/);
+    if (!m) continue; // 表头/分隔行
+    rows.push({ month: m[1], closed: Number(m[2]), legacy: Number(m[4]) });
+  }
+  if (rows.length < 2) return;
+  rows.sort((a, b) => a.month.localeCompare(b.month));
+  const ratioOf = (r) => (r.closed > 0 ? r.legacy / r.closed : null);
+  const nextMonthKey = (ym) => {
+    const [y, m] = ym.split('-').map(Number);
+    return m === 12 ? `${y + 1}-01` : `${y}-${String(m + 1).padStart(2, '0')}`;
+  };
+  for (let i = 1; i < rows.length; i++) {
+    const prev = rows[i - 1];
+    const cur = rows[i];
+    if (nextMonthKey(prev.month) !== cur.month) continue;
+    const ra = ratioOf(prev);
+    const rb = ratioOf(cur);
+    if (ra === null || rb === null) continue;
+    if (ra > RATIO_LIMIT && rb > RATIO_LIMIT) {
+      warnings.push(`- [WARN 漏斗协议前超标] ${prev.month} ${(ra * 100).toFixed(0)}% → ${cur.month} ${(rb * 100).toFixed(0)}%（阈值 ${(RATIO_LIMIT * 100).toFixed(0)}%，相邻两月）——闭环在被系统性绕开：跑一轮归因（哪一环在逼人绕路：确认门太重 / 级别判错 / 批量豁免滥用？），结论记 workflow/papercuts.md 或立 incident，并在 mechanism-registry 月度对账登记处置`);
+    }
+  }
+}

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

@@ -26,7 +26,7 @@ import { spawnSync } from 'node:child_process';
 import { gateSeg, finishSegs, makeCollector, appendSegs } from './gate-seg.mjs';
 
 // 门禁 ROI 插桩（2026-10-08 gate-roi-metrics）：本模块承载的检查 2/9/11/12/13 同样需要计入门禁成本
-// 统计——尤其检查 11（调两个生成器 --check 的 spawn 子进程）与检查 13（调 sh rule-budget.sh）是耗时大户，
+// 统计——尤其检查 11（调两个生成器 --check 的 spawn 子进程）与检查 13（调 rule-budget.mjs）是耗时大户，
 // 不插桩就等于把最贵的两段排除在度量之外。collector 由 check-loop 传入（它持有全局 warnings/blockers），
 // 未传时跳过插桩（纯函数直测场景零副作用）。判据单源见 gate-seg.mjs。
 
@@ -43,7 +43,7 @@ export function runCheckHygiene(ctx) {
   // --- 2. 模板字段占位符残留 [warning]（排除运行时文件名格式与协议样板，口径沿 sh 版）---
   markGate('2', '模板字段占位符残留');
   {
-    const phRe = /YYYY-MM-DD|<主题>|<日期 主题>|L0 \/ L1 \/ L2 \/ L3|draft \/ approved \/ done|open \/ fixed \/ closed/;
+    const phRe = /YYYY-MM-DD|<主题>|<日期 主题>|L1 \/ L2 \/ L3|draft \/ approved \/ done|open \/ fixed \/ closed/;
     const boilerRe = /\.\.\/specs\/[A-Za-z0-9-]*\.md|写明如何满足|防复发验证|_YYYY-MM-DD\.|format\('YYYY-MM-DD'\)|value-format="YYYY-MM-DD"|确认结果：approved（YYYY-MM-DD 用户对话内确认）；done（YYYY-MM-DD 关单，随入口文档置终态）/;
     // plan 确认节样板豁免（2026-10-03 plan-confirm-boiler）：plan 模板「确认与复核」节自带
     // 「确认结果：approved（YYYY-MM-DD 用户对话内确认）；done（YYYY-MM-DD 关单，随入口文档置终态）」
@@ -145,13 +145,13 @@ export function runCheckHygiene(ctx) {
     }
   }
 
-  // --- 13. 常驻面体积预算 [warning]（判定单源 rule-budget.sh；无 sh 环境静默跳过——advisory，pre-commit 硬拦兜底）---
+  // --- 13. 常驻面体积预算 [warning]（判定单源 rule-budget.mjs——2026-10-13 自 .sh 移植 node，恒可跑）---
   markGate('13', '常驻面体积预算');
   {
-    const rb = path.join(ROOT, '.agents', 'scripts', 'rule-budget.sh');
+    const rb = path.join(ROOT, '.agents', 'scripts', 'rule-budget.mjs');
     const budgets = path.join(ROOT, '.agents', 'rule-budgets.txt');
     if (fs.existsSync(rb) && fs.existsSync(budgets)) {
-      const r = spawnSync('sh', [rb, '--all'], { cwd: ROOT, encoding: 'utf8' });
+      const r = spawnSync(process.execPath, [rb, '--all'], { cwd: ROOT, encoding: 'utf8' });
       if (!r.error && r.status !== 0) {
         const head = `${r.stdout || ''}${r.stderr || ''}`.split('\n').slice(0, 5).map((l) => '    ' + l).join('\n');
         warnings.push(`- [WARN 常驻面超限] 常驻面体积超预算(先删除或下沉被取代条目再增——一进一出):\n${head}`);

package/templates/_agents/scripts/check-index-incremental.test.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// check-index-incremental.mjs：未触及 workflow 文档则跳过；触及且 INDEX 与磁盘不一致则 exit 1；重生成后 exit 0。
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const HOOK = path.join(SCRIPT_DIR, '..', 'hooks', 'check-index-incremental.mjs');
+const GEN = path.join(SCRIPT_DIR, 'gen-workflow-index.mjs');
+const { stagedTouchesIndex } = await import(pathToFileURL(HOOK).href);
+
+let pass = 0;
+let fail = 0;
+const check = (desc, cond, detail = '') => {
+  if (cond) { pass++; console.log(`PASS  ${desc}`); }
+  else { fail++; console.log(`FAIL  ${desc}${detail ? `\n${detail}` : ''}`); }
+};
+
+check('路径：四目录 md 与 INDEX.md 触发', stagedTouchesIndex([
+  'workflow/plans/2026-10-12-a.md',
+  'README.md',
+]));
+check('路径：归档 md 触发', stagedTouchesIndex(['workflow/archive/2026-10/plans/2026-10-01-a.md']));
+check('路径：INDEX.md 触发', stagedTouchesIndex(['workflow/INDEX.md']));
+check('路径：delegations 与引擎脚本不触发', !stagedTouchesIndex([
+  'workflow/delegations.md',
+  '.agents/scripts/gen-workflow-index.mjs',
+  'backend/x.cs',
+]));
+
+const git = (cwd, args) => spawnSync('git', ['-c', 'core.hooksPath=', ...args], { cwd, encoding: 'utf8' });
+const runHook = (cwd) => spawnSync(process.execPath, [HOOK], { cwd, encoding: 'utf8' });
+
+function initRepo() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'index-incremental-'));
+  git(root, ['init']);
+  git(root, ['config', 'user.email', 'index-test@example.com']);
+  git(root, ['config', 'user.name', 'index-test']);
+  for (const d of ['intents', 'specs', 'plans', 'incidents']) fs.mkdirSync(path.join(root, 'workflow', d), { recursive: true });
+  fs.writeFileSync(path.join(root, 'workflow', 'plans', '2026-10-01-a.md'), '---\n状态: done\n级别: L1\n日期: 2026-10-01\n---\n# PLAN — 甲\n', 'utf8');
+  fs.writeFileSync(path.join(root, 'README.md'), 'x\n', 'utf8');
+  return root;
+}
+
+{
+  const root = initRepo();
+  git(root, ['add', 'README.md']);
+  const r = runHook(root);
+  check('未暂存 workflow 文档 → exit 0', r.status === 0, `${r.status}\n${r.stdout}${r.stderr}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+{
+  const root = initRepo();
+  const gen = spawnSync(process.execPath, [GEN], { cwd: root, encoding: 'utf8' });
+  check('夹具生成 INDEX exit 0', gen.status === 0, gen.stderr);
+  git(root, ['add', 'workflow']);
+  const ok = runHook(root);
+  check('INDEX 与磁盘一致 → exit 0', ok.status === 0, `${ok.stdout}${ok.stderr}`);
+  fs.writeFileSync(path.join(root, 'workflow', 'plans', '2026-10-01-a.md'), '---\n状态: approved\n级别: L1\n日期: 2026-10-01\n---\n# PLAN — 甲\n', 'utf8');
+  git(root, ['add', 'workflow/plans/2026-10-01-a.md']);
+  const blocked = runHook(root);
+  check('状态变了但 INDEX 未重生成 → exit 1', blocked.status === 1, `${blocked.stdout}${blocked.stderr}`);
+  const regen = spawnSync(process.execPath, [GEN], { cwd: root, encoding: 'utf8' });
+  git(root, ['add', 'workflow/INDEX.md']);
+  const again = runHook(root);
+  check('重生成并暂存 INDEX 后 → exit 0', regen.status === 0 && again.status === 0, `${regen.stderr}${again.stdout}${again.stderr}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+if (fail) process.exit(1);