agentic-flow-kit 1.7.0 → 1.7.16

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

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+// check-engine-integrity.mjs — 门禁本体完整性门（2026-10-09 P0-A：破「裁判给自己判无罪」）
+//
+// 要解决的缺陷（审查结论 P0 第一条，本仓一手证据）：
+//   ① `.agents/` 脚本属 new-task.md §5「docs 级豁免 → 直接 commit」，而 check-lane-surface 检查 A 在
+//      「无活跃入口」时只 advisory —— 两条组合 = 改弱 check-loop.mjs 里某道门可无入口直接提交；
+//   ② CI 的机器门跑的是**被测分支自己的** `.agents/scripts/check-loop.mjs`（ci.yml:42）——被改坏的
+//      裁判验证自己的篡改，无外部参照，CI 全绿。
+//
+// 本门的做法：把「门禁本体当前的硬拦面」**冻结进一个入库基线** `templates/_agents/engine-lock.json`，
+//   判定 = 包源盘面向量 ↔ 基线逐项比对（哈希 + 硬拦单位数）。它不是签名、也不宣称不可伪造——
+//   它把「静默改弱」变成「必须显式 --update 的改弱」：
+//     · 硬拦单位数**下降**（删 blocker / 删 exit 1 / 从面清单删行 / 从 CI 删一次门调用）→ 无条件 BLOCK；
+//     · 内容变了但硬拦面没缩 → 同样 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 由此获得一个不受被测分支控制的参照。
+//     硬拦面收缩在本层**无豁免出口**：锚的参照物分支改不动，只能改判据基线并走评审。
+//     ref 不可解析 / 该 ref 无基线（首个入账提交）→ 跳过并报 ℹ️（锚缺失不误报）。
+//
+// 判据原则（沿 check-lane-surface）：只用一手事实——盘面字节哈希与可数单位；
+//   不从时间戳反推过程、不靠文档正文为改动背书。
+// 用法：node check-engine-integrity.mjs [--root <dir>] [--update] [--against <dir>] [--against-ref <ref>] [--quiet]
+//   --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';
+
+const argv = process.argv.slice(2);
+const argOf = (k) => {
+  const i = argv.indexOf(k);
+  return i >= 0 && i + 1 < argv.length ? argv[i + 1] : '';
+};
+const QUIET = argv.includes('--quiet');
+const UPDATE = argv.includes('--update');
+
+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();
+})();
+// 只认包源。基线固定 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 = () => {
+  const out = new Set();
+  const add = (rel) => { if (fs.existsSync(path.join(ROOT, rel)) && fs.statSync(path.join(ROOT, rel)).isFile()) out.add(rel); };
+  const addDir = (relDir, filter = () => true) => {
+    const abs = path.join(ROOT, relDir);
+    if (!fs.existsSync(abs)) return;
+    for (const f of fs.readdirSync(abs, { withFileTypes: true })) {
+      if (!f.isFile()) continue;
+      const rel = `${relDir}/${f.name}`;
+      if (filter(rel)) add(rel);
+    }
+  };
+  addDir('templates/_agents/scripts', (r) => /\.mjs$/.test(r) && !r.endsWith('.test.mjs'));
+  addDir('templates/_githooks');
+  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',
+    // 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('templates/AGENTS.md');
+  return [...out].sort();
+};
+
+// LF 归一 sha（口径同 src/sync.mjs#shaText：CRLF 检出与 LF 克隆同值，基线跨平台稳定）
+const shaOf = (abs) => createHash('sha256')
+  .update(Buffer.from(fs.readFileSync(abs, 'utf8').replace(/\r\n/g, '\n'), 'utf8')).digest('hex');
+
+// 硬拦单位数：文件里「这道门会拦下来」的可数形态。判据刻意保守（只数结构性标志，不数注释/文案）——
+// 目的是抓「删掉一道拦人的分支」，不是抓「改写了一句提示」。
+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);
+  }
+  if (rel.endsWith('.yml')) return count(/node [^\s]*scripts\/[^\s]*\.(mjs|cjs|sh)/g); // CI 里每道门的调用
+  if (/\.(txt|json)$/.test(rel)) {
+    return text.split(/\r?\n/).filter((l) => l.trim() && !l.trim().startsWith('#')).length; // 面清单：行即判据
+  }
+  if (rel.endsWith('AGENTS.md')) return count(/^[-#]/gm); // 常驻规则面条目（协议面）
+  return 0;
+};
+
+const buildLock = () => {
+  const files = {};
+  for (const rel of gateFiles()) {
+    const abs = path.join(ROOT, rel);
+    files[rel] = { sha256: shaOf(abs), hard: hardUnits(rel, fs.readFileSync(abs, 'utf8')) };
+  }
+  return { schema: 1, generatedAt: new Date().toISOString(), files };
+};
+
+const readJson = (p) => {
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
+};
+
+
+if (UPDATE) {
+  fs.mkdirSync(path.dirname(LOCK_ABS), { recursive: true });
+  const lock = buildLock();
+  const prev = readJson(LOCK_ABS);
+  const changed = prev ? Object.keys(lock.files).filter((k) => !prev.files[k] || prev.files[k].sha256 !== lock.files[k].sha256) : Object.keys(lock.files);
+  const removed = prev ? Object.keys(prev.files).filter((k) => !lock.files[k]) : [];
+  fs.writeFileSync(LOCK_ABS, JSON.stringify(lock, null, 2) + '\n');
+  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('  ⚠️ 基线更新本身是控制面改动：须与该次演进的 CHANGELOG 记录同批提交（改基线 = 受检面内容变更，不入新基线即被本门拦）');
+  process.exit(0);
+}
+
+const lock = readJson(LOCK_ABS);
+const problems = [];
+const current = {};
+for (const rel of gateFiles()) current[rel] = { sha256: shaOf(path.join(ROOT, rel)), hard: hardUnits(rel, fs.readFileSync(path.join(ROOT, rel), 'utf8')) };
+
+// ---- 跨提交锚（先于本地基线判定：恶意分支把盘面 engine-lock.json 删掉也逃不掉这一层——参照物读自 git 对象库）----
+if (argOf('--against-ref')) {
+  const ref = argOf('--against-ref');
+  let 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 {
+    for (const [rel, was] of Object.entries(anchor.files)) {
+      const got = current[rel];
+      if (!got) { problems.push(`[门禁件消失（跨提交锚）] ${rel} 在 ${ref} 的基线内但盘面不存在——删除一道门等于禁用该检查`); continue; }
+      if (typeof was.hard !== 'number' || got.hard >= was.hard) continue;
+      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 templates/_agents/scripts/check-engine-integrity.mjs --update 生成（跨提交锚与外部副本锚照常执行）`);
+} else {
+  for (const [rel, want] of Object.entries(lock.files)) {
+    const got = current[rel];
+    const name = path.basename(rel);
+    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/判据行的结构性形态，一律拦`);
+    } else {
+      problems.push(`[控制面改动未入基线] ${rel} 内容与基线不符（${name} 硬拦单位数 ${want.hard} → ${got.hard}）——门禁本体的每次演进都要显式更新基线，不存在「声明过的改动」自动放行`);
+    }
+  }
+  for (const rel of Object.keys(current)) {
+    if (!lock.files[rel]) problems.push(`[门禁件未入基线] ${rel} 是新出现的受检文件——合法新增判据须跑 --update 入账`);
+  }
+}
+
+if (argOf('--against')) {
+  const ext = path.resolve(argOf('--against'));
+  if (!fs.existsSync(ext)) { console.error(`用法：--against 目录不存在（${ext}）`); process.exit(2); }
+  const extProblems = [];
+  for (const rel of Object.keys(current)) {
+    const extAbs = path.join(ext, rel);
+    if (!fs.existsSync(extAbs)) continue; // 外部副本不含该件（如装户无 templates/）——不判
+    if (shaOf(extAbs) !== current[rel].sha256) extProblems.push(`  ${rel} 与外部已知良好副本失配`);
+  }
+  if (extProblems.length) problems.push(`[外部锚失配] 受检面与 ${argOf('--against')} 逐字比对不一致（外部裁判不认本次改动面）：\n${extProblems.join('\n')}`);
+}
+
+if (problems.length) {
+  console.error(`引擎完整性 — HARD-BLOCK:\n\n${problems.map((p) => `- ${p}`).join('\n')}\n`);
+  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 ? '、盘面与基线一致' : '、本地基线未启用'}）`);
+process.exit(0);

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

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+// check-engine-integrity.test.mjs — 门禁本体完整性门 fixture 套件（2026-10-09 P0-A guard-the-guards）
+// 方法：构造临时根（templates/_agents/scripts + .githooks + workflow/intents），spawn 脚本断言
+//       exit code 与 [标签]；跨提交锚用真 git 仓（init→commit→改弱→--update）端到端验证——
+//       那一条是本门存在的理由：本地层自洽（盘面↔基线同刷）时，唯祖先提交参照物仍能出账。
+// 用法：node templates/_agents/scripts/check-engine-integrity.test.mjs（npm test 随跑）
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPT = path.join(SCRIPT_DIR, 'check-engine-integrity.mjs');
+
+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 : ''}`); }
+};
+
+const w = (root, rel, content) => {
+  const abs = path.join(root, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content);
+};
+const run = (root, args = []) => {
+  const r = spawnSync(process.execPath, [SCRIPT, '--root', root, ...args], { encoding: 'utf8' });
+  return { code: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
+};
+const git = (root, args) => spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' });
+const haveGit = (() => { const r = spawnSync('git', ['--version'], { encoding: 'utf8' }); return r.status === 0; })();
+
+// 通用 fixture：一份门禁脚本（2 个 blocker + 1 个 exit(1) = 3 硬拦单位）、一个钩子（1 个 exit 1）、AGENTS.md
+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, '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`);
+  }
+  return d;
+};
+
+// --- T1 基线缺失 = 未启用（旧装副本零改动，exit 0）---
+{
+  const r = run(mkfix());
+  check('T1 无基线 → exit 0 且报「未启用」', r.code === 0 && r.out.includes('未启用'), r.out);
+}
+
+// --- T2 --update 生成基线后自身一致 ---
+{
+  const d = mkfix();
+  const u = run(d, ['--update']);
+  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['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);
+}
+
+// --- T3 硬拦单位数下降 → 无条件拦（有入口也不放行）---
+{
+  const d = mkfix({ withEntry: true });
+  run(d, ['--update']);
+  w(d, 'templates/_agents/scripts/gate.mjs', '// 门禁样例（退役一条 blocker）\nblockers.push(`A`);\nif (bad) process.exit(1);\n');
+  const r = run(d);
+  check('T3 删 blocker.push → [硬拦面收缩] 且点名文件与减量',
+    r.code === 1 && r.out.includes('[硬拦面收缩]') && r.out.includes('gate.mjs') && r.out.includes('3 → 2'), r.out);
+  check('T3b 有活跃 L2 入口仍拦（收缩无豁免出口）', r.code === 1 && r.out.includes('[硬拦面收缩]'), r.out);
+}
+
+// --- 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 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);
+}
+// --- T4e 入口面即便存在也不豁免（锁死新口径）---
+// 1.7.15 卸掉同仓双身份后，包源仓没有 workflow/intents —— 旧「立入口即放行」退路在本仓不可达。
+// 删掉该能力后，即使有人在包源仓手工造出入口文档点名该件，**也不得**成为放行口：
+// 否则一个 mkdir 就把门重新打开，等于用未验证的路径恢复未验证的能力。
+{
+  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-ctrl.md',
+    '---\n状态: approved\n级别: L2\n日期: 2026-10-09\n模块: gate\n---\n# INTENT\n改动面：gate.mjs\n');
+  const r = run(d);
+  check('T4e 活跃 L2 入口点名该件 → 仍拦（本门无声明式豁免出口）',
+    r.code === 1 && r.out.includes('[控制面改动未入基线]'), r.out);
+}
+
+// --- T5 门禁件消失 / 新增件未入基线 ---
+{
+  const d = mkfix();
+  run(d, ['--update']);
+  fs.rmSync(path.join(d, 'templates/_agents/scripts/gate.mjs'));
+  let r = run(d);
+  check('T5a 删除门禁件 → [门禁件消失]', r.code === 1 && r.out.includes('[门禁件消失]'), r.out);
+}
+{
+  const d = mkfix();
+  run(d, ['--update']);
+  w(d, 'templates/_agents/scripts/newgate.mjs', 'blockers.push(`X`);\n');
+  const r = run(d);
+  check('T5b 新受检件未入账 → [门禁件未入基线]，--update 后放行',
+    r.code === 1 && r.out.includes('[门禁件未入基线]') && r.out.includes('newgate.mjs'), r.out);
+  run(d, ['--update']);
+  check('T5c --update 把新件入账后 exit 0', run(d).code === 0);
+}
+
+// --- T6 外部副本锚 ---
+{
+  const d = mkfix();
+  run(d, ['--update']);
+  const bad = run(d, ['--against', path.join(d, 'nope')]);
+  check('T6a --against 目录不存在 → 用法错误 exit 2', bad.code === 2 && bad.out.includes('目录不存在'), bad.out);
+  const ext = fs.mkdtempSync(path.join(os.tmpdir(), 'engine-integrity-ext-'));
+  w(ext, 'templates/_agents/scripts/gate.mjs', '// 外部已知良好副本（与盘面不同）\nblockers.push(`A`);\n');
+  const r = run(d, ['--against', ext]);
+  check('T6b 与外部副本逐字失配 → [外部锚失配]', r.code === 1 && r.out.includes('[外部锚失配]'), r.out);
+}
+
+// --- T7 跨提交锚（真 git 仓端到端：本门存在的理由）---
+if (haveGit) {
+  const d = mkfix();
+  git(d, ['init', '-q']);
+  git(d, ['config', 'user.email', 't@example.com']);
+  git(d, ['config', 'user.name', 'fixture']);
+  run(d, ['--update']);
+  git(d, ['add', '-A']);
+  git(d, ['commit', '-q', '-m', 'chore: 基线入账']);
+  // 改弱门禁 + 同批刷基线：本地层完全自洽（这正是 CI 自指的形态）
+  w(d, 'templates/_agents/scripts/gate.mjs', '// 退役一条判据\nblockers.push(`A`);\nif (bad) process.exit(1);\n');
+  run(d, ['--update']);
+  const local = run(d);
+  check('T7a 改弱 + 刷基线 → 本地层自洽放行（缺陷场景复现）', local.code === 0, local.out);
+  const anchored = run(d, ['--against-ref', 'HEAD']);
+  check('T7b 跨提交锚（祖先提交基线）出账 [硬拦面收缩（跨提交锚）]',
+    anchored.code === 1 && anchored.out.includes('[硬拦面收缩（跨提交锚）]') && /3（见 HEAD）→ 盘面 2/.test(anchored.out), anchored.out);
+  // 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): 造入口文档（应不构成放行口）']);
+  const declared = run(d, ['--against-ref', 'HEAD~1']);
+  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);
+} else {
+  console.log('SKIP T7 跨提交锚（未找到 git）');
+}
+
+// --- T8 --quiet 静默面（钩子里调用不刷屏）---
+{
+  const d = mkfix();
+  run(d, ['--update']);
+  const r = run(d, ['--quiet']);
+  check('T8 --quiet 通过时不打印 ✅ 行', r.code === 0 && !r.out.includes('✅'), r.out);
+}
+
+// --- 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']);
+  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 });
+}
+
+// --- T10 包源布局：无 .agents/ → 基线落包源径，不得重建装户目录（装户端内容清理后回归锁）---
+{
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'engine-integrity-test-'));
+  w(d, 'templates/_agents/scripts/gate.mjs', 'blockers.push(`A`);\nblockers.push(`B`);\nif (bad) process.exit(1);\n');
+  w(d, 'templates/AGENTS.md', '# 协议\n- 规则一\n');
+  const u = run(d, ['--update']);
+  let lock = null;
+  try { lock = JSON.parse(fs.readFileSync(path.join(d, 'templates', '_agents', 'engine-lock.json'), 'utf8')); } catch { /* 断言兜 */ }
+  check('T10a 无 .agents/ → --update 落 templates/_agents/engine-lock.json 且入账受检面',
+    u.code === 0 && !!lock && !!lock.files['templates/_agents/scripts/gate.mjs'], u.out);
+  check('T10b --update 不重建 .agents/ 目录（旧实现按装户径兜底会重建已清理的装户目录）',
+    !fs.existsSync(path.join(d, '.agents')), '');
+  const r = run(d);
+  check('T10c 基线启用 → 「盘面与基线一致」且未启用提示点包源径',
+    r.code === 0 && r.out.includes('盘面与基线一致'), r.out);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+console.log(`\ncheck-engine-integrity: ${pass} PASS / ${fail} FAIL`);
+process.exit(fail ? 1 : 0);

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

@@ -1,5 +1,10 @@
 #!/usr/bin/env node
 // check-lane-surface.mjs — 泳道完整性门禁（pre-commit 增量；2026-10-01 drift-hardening）
+// 布局前提：本门读 .agents/lane-surfaces.txt，豁免出口是 workflow/intents 的活跃 L2/L3 入口——
+//   二者都是**装户侧**件。纯包源仓（装户端内容清理后）两处皆无：清单缺失 = 检查 A/C 按既定
+//   「装户无感」口径跳过，本门整体惰性。此时把清单解析改双路径**只会让门跑起来而不会可用**——
+//   无 L2 入口机器时，任何控制面改动都走「无活跃入口」分支（A 出 advisory / C 出 BLOCK），
+//   纯包源仓的控制面保护改由 npm test（47 套件覆盖门禁逻辑）+ 评审 + CHANGELOG 承担。
 // 检查 A「触达面判低」：暂存 diff 命中项目 L2 触达面（.agents/lane-surfaces.txt，ERE 逐行；
 //   # 注释与空行忽略；文件缺失或清单为空 = 检查跳过，装户无感）时——
 //   存在活跃 L2/L3 入口 → 放行（归因歧义为已知边界：机器不猜「哪个入口在干这批改动」）；
@@ -10,7 +15,7 @@
 // 检查 B「探索标记缺失」：experiment/* 分支暂存的 workflow/intents/*.md（排除 _TEMPLATE）
 //   frontmatter 无「阶段: exploring」且无「状态: exploring」（口径同 check-loop 加固门）→ hard 拦。
 //   标记是加固门覆盖率的前提且补写零成本——advisory 免的是纪律负担，不免标记本身。
-// 判据原则（incidents/2026-09-28-batch-ledger-audit 教训）：只用一手事实——暂存文件清单、
+// 判据原则（2026-09-28 台账批量代录事故教训）：只用一手事实——暂存文件清单、
 //   当前分支名、工作区 frontmatter 字段；不用时间戳 / 字符串相等反推过程事实。
 // 边界：git 调用一律 -c core.quotepath=off（非 ASCII 路径教训，同 check-pairing-incremental.sh）；
 //   frontmatter 读取容忍 CRLF（显式按 \r?\n 切分）；detached HEAD 分支不可判 → A 按 strict、
@@ -25,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) => {
@@ -121,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 豁免），请先立入口文档`);
   }
 }
 
@@ -171,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: 泳道完整性未通过，提交已阻止（spec: workflow/specs/2026-10-01-drift-hardening.md）');
+  console.error('pre-commit: 泳道完整性未通过，提交已阻止（判据单源见 .agents/scripts/level-criteria.mjs）');
   process.exit(1);
 }
 process.exit(0);