agentic-flow-kit 1.8.7 → 2.0.0

package/templates/_agents/scripts/fixture-scripts.mjs

@@ -1,153 +0,0 @@
-// fixture-scripts.mjs — 测试夹具脚本闭包工具（2026-10-12 fixture-closure-rootfix）
-//
-// 为什么有它：夹具此前用**手工枚举**把被测脚本及其依赖拷进临时根（如 `const SCRIPTS = ['check-loop.mjs',
-// 'policy.mjs', ...]`）。那份枚举必须与被测脚本真实的依赖闭包一致，但两者互不校验——给脚本加一行
-// `import './x.mjs'`，枚举不会自动跟着变，而滞后的表现是**静默绿**：ESM resolve 失败 → 被测脚本根本没跑
-// → 断言面为空 → 套件判绿。2026-10-12 那批台账改动就因此在 `check-loop.test` / `edit-face-check.test` /
-// `ledger-prune.test` 三处先后假绿（各自补拷才转绿）。补齐是止血，消灭枚举才是根治。
-//
-// 本模块给两样东西，各自独立成立：
-//   ① scriptClosure / copyScriptClosure —— 自动求依赖传递闭包并整闭包拷贝，维护面归零（新增依赖自动跟随）；
-//   ② assertFixtureScripts —— 拷完在**目标目录**独立复扫一遍，任一相对依赖解析不到就抛错报全量缺失清单。
-//      这是纵深防御：即使将来有人又手写枚举（或绕过本 helper 直接拷），漏拷会在建夹具那一刻响亮炸掉，
-//      而不是几十个场景之后以「门禁没跑」的形式悄悄绿掉。
-//
-// 依赖发现口径（刻意取宽）：**静态 import/export from**、**动态 import()**、以及**裸文件名字面量**
-// （形如 path.join(here, 'kb-search.mjs') 的 spawn 依赖——wiki-search.mjs 就只靠这一条挂住 kb-search；
-// check-hygiene 靠它挂住 rule-budget.mjs 与两个生成器）。裸文件名只在**解析到同目录真实文件**时才计入，
-// 故 `'../hooks/commit-check.cjs'` 这类跨目录字面量天然被排除（scripts/ 下不存在同名文件）。
-// 宁可多拷（多一个文件不会让测试变假绿），不可漏拷（漏拷就是假绿）。
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-export const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-
-const SCRIPT_EXT = /\.(?:mjs|cjs|js|sh)$/;
-// 裸文件名 / ./x / ../x 三种形态；含目录分隔的更长路径字面量（如 'templates/_agents/scripts/gate.mjs'）不匹配。
-// 点开头的隐藏名不匹配：check-loop.mjs 里有 `.replace(/\.mjs$/, '.test.mjs')`，那个 '.test.mjs'
-// 是**后缀字面量**不是文件名，按名解析必然扑空（对每个测试夹具都误报「漏拷」→ 整套件红）。
-const BARE_NAME = /^(?:\.{1,2}\/)?[A-Za-z0-9_][A-Za-z0-9_.-]*$/;
-// 引号字面量（单/双引号皆可），逐行扫即可——模板字面量里的文件名由动态拼接给出，不在此列
-const QUOTED = /'([^'\n]*)'|"([^"\n]*)"/g;
-
-// stripComments：抹掉注释，保留字符串字面量内容。
-// 刻意**不用正则**：正则版把 `confirmations.d/*.jsonl` 这类注释里的 `/*` 当块注释起点，跨注释一路吃到下一个
-// 真 `*/`，把后面的 import 整段吃掉（check-ledger-invariant 实测：12141 字符被砍到 4198，43 行的
-// import 直接消失 → 闭包漏依赖 → 回到假绿）。故走一个 40 行的逐字符状态机，只认三种真形态。
-// 字符串内容**不抹**（我们要的就是字面量里的文件名），故正则里的 ".*?/*.jsonl" 这类串不被误当注释。
-function stripComments(src) {
-  let out = '';
-  let i = 0;
-  const n = src.length;
-  while (i < n) {
-    const c = src[i];
-    const d = src[i + 1];
-    if (c === '/' && d === '/') { while (i < n && src[i] !== '\n') i++; continue; }
-    if (c === '/' && d === '*') {
-      i += 2;
-      while (i < n && !(src[i] === '*' && src[i + 1] === '/')) i++;
-      i += 2;
-      continue;
-    }
-    if (c === '"' || c === "'" || c === '`') {
-      const quote = c;
-      out += c;
-      i++;
-      while (i < n) {
-        if (src[i] === '\\') { out += src[i] + (src[i + 1] || ''); i += 2; continue; }
-        out += src[i];
-        if (src[i] === quote) { i++; break; }
-        i++;
-      }
-      continue;
-    }
-    out += c;
-    i++;
-  }
-  return out;
-}
-
-// depsOf：某脚本源码里引用的、可能落在同目录的脚本文件名（去重、保持出现序）。
-// 纯文本解析——不查盘面，故「源码引用了但盘面没有的名字」也会被列出，由调用方按盘面存在性收窄。
-export function depsOf(sourceText) {
-  const out = [];
-  const push = (v) => { if (v && !out.includes(v)) out.push(v); };
-  const text = stripComments(sourceText);
-  // import/export ... from '...' 与 import('...')
-  for (const m of text.matchAll(/(?:\bfrom\s*|\bimport\s*\(\s*)(['"])([^'"]+)\1/g)) push(m[2]);
-  // 其余裸文件名字面量（spawn / path.join 依赖）
-  for (const m of text.matchAll(QUOTED)) push(m[1] || m[2]);
-  return out.filter((v) => SCRIPT_EXT.test(v) && BARE_NAME.test(v));
-}
-
-// scriptClosure：从入口出发递归求同目录依赖传递闭包（BFS，稳定序；不存在的引用不炸——由 assert 层兜）
-export function scriptClosure(entries, { from = SCRIPT_DIR } = {}) {
-  const queue = [...new Set(entries)].map((e) => path.basename(e));
-  const seen = new Set();
-  const order = [];
-  while (queue.length) {
-    const name = queue.shift();
-    if (seen.has(name)) continue;
-    seen.add(name);
-    order.push(name);
-    const abs = path.join(from, name);
-    if (!fs.existsSync(abs)) continue;
-    for (const dep of depsOf(fs.readFileSync(abs, 'utf8'))) {
-      const base = path.basename(dep);
-      if (!seen.has(base)) queue.push(base);
-    }
-  }
-  return order;
-}
-
-// copyScriptClosure：把入口的整个依赖闭包拷进 destScriptsDir，返回实际拷入的文件名。
-// opts.extra —— 额外要拷的同级非脚本件（如 rule-budget.mjs 之外的 .txt 词表由 copyAgentsFiles 负责）。
-export function copyScriptClosure(destScriptsDir, entries, opts = {}) {
-  const from = opts.from || SCRIPT_DIR;
-  fs.mkdirSync(destScriptsDir, { recursive: true });
-  const closure = scriptClosure(entries, { from });
-  const copied = [];
-  for (const name of closure) {
-    const src = path.join(from, name);
-    if (!fs.existsSync(src) || !fs.statSync(src).isFile()) continue;
-    const dest = path.join(destScriptsDir, name);
-    fs.copyFileSync(src, dest);
-    copied.push(name);
-  }
-  // 纵深防御：在**目标目录**独立复扫，不复用上面的闭包结果（这样才抓得到拷贝环节本身的错漏）
-  assertFixtureScripts(destScriptsDir);
-  return copied;
-}
-
-// copyAgentsFiles：把包源 `.agents/` 面的词表/配置（workflow-enums.txt 等）拷进夹具的 .agents/ 根
-export function copyAgentsFiles(destAgentsDir, names, { from = path.join(SCRIPT_DIR, '..') } = {}) {
-  fs.mkdirSync(destAgentsDir, { recursive: true });
-  const copied = [];
-  for (const name of names) {
-    const src = path.join(from, name);
-    if (!fs.existsSync(src)) continue;
-    fs.copyFileSync(src, path.join(destAgentsDir, name));
-    copied.push(name);
-  }
-  return copied;
-}
-
-// assertFixtureScripts：扫目录内全部脚本，任一相对/裸文件名依赖解析不到 → 抛错（报全量缺失，不报第一个）
-// 用法：夹具建好后立即调；漏拷在当场炸，而不是在「门禁静默不跑」之后绿掉。
-export function assertFixtureScripts(dir) {
-  const missing = [];
-  if (!fs.existsSync(dir)) throw new Error(`assertFixtureScripts: 目录不存在 ${dir}`);
-  for (const f of fs.readdirSync(dir).filter((f) => SCRIPT_EXT.test(f)).sort()) {
-    const src = fs.readFileSync(path.join(dir, f), 'utf8');
-    for (const dep of depsOf(src)) {
-      if (dep.includes('/') && dep.startsWith('..')) continue; // 跨目录引用不在本夹具职责内
-      if (!fs.existsSync(path.join(dir, dep))) missing.push(`${f} → ${dep}`);
-    }
-  }
-  if (missing.length) {
-    throw new Error(`夹具依赖缺失（漏拷 → 被测脚本 import 失败 → 门禁静默不跑 = 假绿）：\n  ${missing.join('\n  ')}\n`
-      + '修法：改用 copyScriptClosure(入口脚本) 让闭包自动跟随，不要手写枚举。');
-  }
-  return true;
-}

package/templates/_agents/scripts/fixture-scripts.test.mjs

@@ -1,112 +0,0 @@
-#!/usr/bin/env node
-// fixture-scripts.test.mjs — 夹具闭包工具自身套件（2026-10-12 fixture-closure-rootfix）
-// 命题：本工具**只能比手工枚举多拷，绝不能少拷**——多拷的文件不会让测试假绿，少拷的文件会让
-// 被测脚本 import 失败、门禁静默不跑、套件假绿（2026-10-12 台账那批三处假绿的根因）。
-// 覆盖面：多层传递依赖 / node: 内建跳过 / 注释与字符串字面量不误收 / 后缀字面量（'.test.mjs'）不误报 /
-//       缺失即炸且报全量清单 / spawn 依赖（裸文件名字面量）也被收进闭包。
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { SCRIPT_DIR, depsOf, scriptClosure, copyScriptClosure, assertFixtureScripts, copyAgentsFiles } from './fixture-scripts.mjs';
-
-let pass = 0, fail = 0;
-const check = (name, ok, detail = '') => {
-  if (ok) { pass++; console.log(`  ok  ${name}`); }
-  else { fail++; console.error(`FAIL  ${name}${detail ? ' — ' + detail : ''}`); }
-};
-const tmpRoot = (p) => fs.mkdtempSync(path.join(os.tmpdir(), `fxsc-${p}-`));
-// 造一个合成 scripts 目录（不触真实盘面——本工具的依赖发现是纯文本解析，故合成目录可独立验证）
-const synth = (files) => {
-  const dir = tmpRoot('synth');
-  for (const [name, body] of Object.entries(files)) fs.writeFileSync(path.join(dir, name), body, 'utf8');
-  return dir;
-};
-
-// ---- S1：多层传递依赖闭包 ----
-{
-  const src = synth({
-    'a.mjs': `import './b.mjs';\nimport { x } from './sub/c.mjs';\n`,
-    'b.mjs': `import './c.mjs';\n`,
-    'c.mjs': `export const x = 1;\n`,
-    'd.mjs': `export const y = 2;\n`,
-  });
-  const cl = scriptClosure(['a.mjs'], { from: src });
-  check('S1 三层传递依赖全部收进闭包', ['a.mjs', 'b.mjs', 'c.mjs'].every((f) => cl.includes(f)) && !cl.includes('d.mjs'), cl.join(','));
-}
-
-// ---- S2：node: 内建与跨目录字面量不误收 ----
-{
-  const src = synth({
-    'a.mjs': `import fs from 'node:fs';\nimport { x } from './b.mjs';\nconst p = path.join(h, 'templates/_agents/scripts/gate.mjs');\n`,
-    'b.mjs': 'export const x=1;\n',
-  });
-  const cl = scriptClosure(['a.mjs'], { from: src });
-  check('S2 node: 内建与长路径字面量被排除', cl.length === 2, cl.join(','));
-}
-
-// ---- S3：注释与字符串里的脚本名不算依赖 ----
-{
-  const deps = depsOf(`// 拷 './gone.mjs' 进来\n/* from './gone2.mjs' */\nimport './real.mjs';\n`);
-  check('S3 注释里的文件名不算依赖', deps.length === 1 && deps[0] === './real.mjs', JSON.stringify(deps));
-}
-
-// ---- S4：后缀字面量（'.test.mjs'）不误报——防「每个夹具都误报漏拷」 ----
-// 这条是真实回归：check-loop.mjs 里就有 `.replace(/\.mjs$/, '.test.mjs')`，按名解析必然扑空。
-{
-  const deps = depsOf(`f.replace(/\\.mjs$/, '.test.mjs')\nimport './real.mjs';\n`);
-  check('S4 后缀字面量 .test.mjs 不计入依赖', !deps.some((d) => d.includes('test')), JSON.stringify(deps));
-}
-
-// ---- S5：spawn 依赖（裸文件名字面量）也进闭包——wiki-search 只靠 path.join(here,'kb-search.mjs') 挂住依赖 ----
-{
-  const src = synth({
-    'wiki-search.mjs': `spawnSync(process.execPath, [path.join(here, 'kb-search.mjs')]);\n`,
-    'kb-search.mjs': `import './workflow-enums.mjs';\n`,
-    'workflow-enums.mjs': 'export const a=1;\n',
-  });
-  const cl = scriptClosure(['wiki-search.mjs'], { from: src });
-  check('S5 spawn 裸文件名依赖传递收进闭包', cl.includes('kb-search.mjs') && cl.includes('workflow-enums.mjs'), cl.join(','));
-}
-
-// ---- S6：缺失即炸且报全量清单（非报第一个就停） ----
-{
-  const dir = tmpRoot('missing');
-  fs.writeFileSync(path.join(dir, 'a.mjs'), `import './m1.mjs';\nimport './m2.mjs';\n`, 'utf8');
-  let msg = '';
-  try { assertFixtureScripts(dir); } catch (e) { msg = String(e.message); }
-  check('S6 缺依赖 → 抛错', !!msg, '未抛错');
-  check('S6 报全量缺失清单（m1+m2 都在）', msg.includes('m1.mjs') && msg.includes('m2.mjs'), msg);
-  check('S6 报文点明假绿与修法', msg.includes('假绿') && msg.includes('copyScriptClosure'), msg.slice(0, 120));
-}
-
-// ---- S7：copyScriptClosure 对真实盘面跑通（check-loop 闭包 + 拷后自检不炸） ----
-{
-  const dest = path.join(tmpRoot('copy'), 'scripts');
-  const copied = copyScriptClosure(dest, ['check-loop.mjs']);
-  check('S7 check-loop 闭包含新台账依赖（含 policy.mjs——B6b-1 分道/policy 锚随闭包自动跟随）', ['check-loop.mjs', 'ledger-loader.mjs', 'ledger-prune.mjs', 'policy.mjs'].every((f) => copied.includes(f)), copied.join(','));
-  // B6b-2 六段模块（2026-10-13）：check-loop.mjs import 的段模块须随闭包自动带上——漏拷 = 被测脚本
-  // 在夹具里 resolve 失败 → 门禁静默不跑（本文件头注的假绿形态）。显式断言六件在场，不靠运气。
-  check('S7 check-loop 闭包含 B6b-2 六段模块（import 闭包自动跟随）',
-    ['check-spec-verif.mjs', 'check-registry.mjs', 'check-convergence.mjs', 'check-attribution.mjs', 'check-prejudgment.mjs', 'check-funnel.mjs'].every((f) => copied.includes(f)),
-    copied.join(','));
-  check('S7 拷贝后 assertFixtureScripts 不炸（闭包自洽）', assertFixtureScripts(dest) === true);
-  // 真跑一次被测脚本，确认夹具不是「文件齐了但跑不起来」
-  const fx = path.dirname(dest);
-  fs.mkdirSync(path.join(fx, '.agents'), { recursive: true });
-  fs.copyFileSync(SCRIPT_DIR.replace(/scripts$/, 'workflow-enums.txt'), path.join(fx, '.agents', 'workflow-enums.txt'));
-  const { spawnSync } = await import('node:child_process');
-  const r = spawnSync(process.execPath, [path.join(dest, 'check-loop.mjs')], {
-    cwd: fx, encoding: 'utf8', env: { ...process.env, CHECK_LOOP_ROOT: fx },
-  });
-  check('S7 夹具内 check-loop 真能跑起来（非 ENOENT 崩）', !/Cannot find module|ERR_MODULE_NOT_FOUND/.test(`${r.stdout || ''}${r.stderr || ''}`), `${r.stdout || ''}${r.stderr || ''}`.slice(0, 200));
-}
-
-// ---- S8：copyAgentsFiles 拷词表，缺失的静默跳过 ----
-{
-  const dest = tmpRoot('agents');
-  const copied = copyAgentsFiles(dest, ['workflow-enums.txt', 'definitely-absent.txt']);
-  check('S8 存在词表拷入、缺席跳过', copied.length === 1 && copied[0] === 'workflow-enums.txt', copied.join(','));
-}
-
-console.log(`\n[fixture-scripts] PASS ${pass} / FAIL ${fail}`);
-process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/gate-checklist.mjs

@@ -1,209 +0,0 @@
-// flow-kit gate-checklist：三处口径一致性检查（doctor §检查项 ↔ check-loop §检查项，显式配对登记表）
-// 目的：任何一处加新检查项，另一处不会自动同步——本工具按登记表给出对照表 + 断档/未登记告警。
-// 机制（2026-09-25 gate-checklist-registry 重写）：关键词猜测匹配退役（实测 18×14 项只匹配 2、报 28 条
-//       噪声缺点，真漏点不可见），改为显式配对登记表 PAIRS（单源本文件）——沿 workflow-modules.txt
-//       的单源思路与 check-loop「frontmatter 受限子集替代全文正则猜测」同一演进路径。
-// 解析面（只读不改两处源码，均为既有稳定结构）：
-//   doctor：src/doctor.mjs 节注释 `// N. 标题`（N 支持 6.5 小节号）
-//   check-loop：.agents/scripts/check-loop.sh 头部检查项注释 `# N. 标题 [severity]`（多行标题截断仅影响展示，配对按 id）
-// 登记三形态：
-//   { doctor, cl }        直接配对——同一检查两处实现
-//   { doctor, cl: null }  声明独有——doctor 装户体检面，无 check-loop 对应（原 intent「只报告不修复」拍板的已知漏点入账）
-//   { doctor: '7', cl }   经 §7 覆盖——doctor §7 整体运行 check-loop，各 #N 自动流入 doctor
-// 报告（只报告不修复，B-b；exit 恒 0）：
-//   断档：登记表声明的 id 在对应侧已不存在（检查项被删/改号而登记未跟）
-//   未登记：任一侧出现登记表之外的 § 检查项（新检查项没对账——本工具的核心信号）
-// 用法：node .agents/scripts/gate-checklist.mjs --diff
-//       node .agents/scripts/gate-checklist.mjs --json
-// 零依赖；不修改 doctor / check-loop 既有检查项
-// 测试：node templates/_agents/scripts/gate-checklist.test.mjs（fixture + 真实仓库 baseline）
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-function fail(msg) { console.error('❌ ' + msg); process.exit(1); }
-
-// parseDoctorSections：扫 doctor.mjs 节注释 → [{id, title}]。两种真实格式：
-//   `// N. 标题`（整数节号带点，如 // 1. Node 版本）与 `// N.M 标题`（小节号不带点，如 // 6.5 delegations）。
-//   整数无点（如正文注释 // 4 宿主目录映射）不匹配——避免函数体普通注释误判为节。
-function parseDoctorSections(doctorSrc) {
-  const out = [];
-  const re = /^\s*\/\/\s+(\d+\.\d+|\d+\.)\s+([^\n]+)/gm;
-  let m;
-  while ((m = re.exec(doctorSrc)) !== null) {
-    const title = m[2].split(/[（(]/)[0].trim() || m[2].trim();
-    out.push({ id: m[1].replace(/\.$/, ''), title });
-  }
-  return out;
-}
-
-// parseCheckLoopChecks：扫 check-loop 检查项注释（`// N. 标题 [severity]` 于 .mjs 头部清单——2026-09-26
-// check-loop-node 迁移后的主位；旧装户 sync 前只有 .sh 时按 `# N. 标题` fallback，登记表口径不变）
-function parseCheckLoopChecks(clSrc) {
-  const checks = [];
-  const re = /^\s*(?:\/\/|#)\s*(\d+)\.\s+(.+?)(?:\s*\[(hard-block|warning|advisory)\])?\s*$/gm;
-  let m;
-  while ((m = re.exec(clSrc)) !== null) {
-    checks.push({ id: m[1], title: m[2].trim(), severity: m[3] || null });
-  }
-  return checks;
-}
-
-// ---- 配对登记表（单源契约；2026-09-25 gate-checklist-registry 全量登记）----
-// 纪律：doctor / check-loop 任一处加新 § 检查项，必须同步在本表登记（直接配对 / 声明独有 / 经 §7 覆盖），
-//       否则工具报「未登记」。删/改检查项须同步改本表，否则报「断档」。
-const PAIRS = [
-  // 直接配对：同一检查两处实现
-  { doctor: '5', cl: '2', note: '占位符残留' },
-  { doctor: '6', cl: '11', note: 'workflow/INDEX.md 漂移' },
-  // 声明独有：doctor 装户体检面（原 intent 拍板「只报告不修复」的已知漏点入账）
-  { doctor: '1', cl: null, note: 'Node 版本——装户体检独有' },
-  { doctor: '2', cl: null, note: '目录布局——装户体检独有' },
-  { doctor: '3', cl: null, note: 'git 仓库与钩子——装户体检独有' },
-  { doctor: '4', cl: null, note: 'kit.json managed 台账——装户体检独有' },
-  { doctor: '4.5', cl: null, note: '台账覆盖率——装户体检独有（盘上有 managed 类文件未登记，2026-09-26 managed-ledger-adopt）' },
-  { doctor: '6.5', cl: null, note: 'delegations 台账结构 + 快照新鲜度——装户体检独有' },
-  { doctor: '6.6', cl: null, note: 'owned 漂移——装户体检独有' },
-  { doctor: '6.7', cl: null, note: '跨宿主薄适配——装户体检独有' },
-  { doctor: '6.8', cl: null, note: 'workflows 编排脚本 lint——装户体检独有' },
-  { doctor: '6.9', cl: null, note: '模板下发感知（2026-10-06 template-downstream）——装户体检独有（只读回显 sync 出账同源判据）' },
-  { doctor: '6.10', cl: null, note: 'level-hints 配置体检（2026-10-13 hint-doctor）——装户体检独有；提交面判低由 check-lane-surface（pre-commit 增量面）承担，不在 check-loop 项内' },
-  { doctor: '8', cl: null, note: '看板端口——信息级独有' },
-  // 经 §7 覆盖：doctor §7 整体运行 check-loop（#2/#11 已直接配对，不重复登记）
-  { doctor: '7', cl: '1', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '3', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '4', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '5', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '6', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '7', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '8', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '9', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '10', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '12', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '13', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '14', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '15', note: '经 §7 整体运行覆盖' },
-  { doctor: '7', cl: '16', note: '经 §7 整体运行覆盖（量化断言指标签名对账，2026-09-28 claim-exceeds-fix）' },
-  { doctor: '7', cl: '17', note: '经 §7 整体运行覆盖（发版提交树上仍未收口的 intent/spec/plan）' },
-  { doctor: '7', cl: '18', note: '经 §7 整体运行覆盖（委派台账对账）' },
-  { doctor: '7', cl: '19', note: '经 §7 整体运行覆盖（逐阶段审计——起草先于入口确认 / 台账审批顺序倒置）' },
- { doctor: '7', cl: '20', note: '经 §7 整体运行覆盖（引擎脚本测试覆盖，2026-10-01 gate-script-test-coverage）' },
- { doctor: '7', cl: '21', note: '经 §7 整体运行覆盖（spec 验证落地核查，2026-10-13 B6b-2 回灌）' },
- { doctor: '7', cl: '22', note: '经 §7 整体运行覆盖（机制使用量台账，2026-10-13 B6b-2 回灌）' },
- { doctor: '7', cl: '23', note: '经 §7 整体运行覆盖（判据级收敛对账，2026-10-13 B6b-2 回灌）' },
- { doctor: '7', cl: '24', note: '经 §7 整体运行覆盖（incident 归因字段核查，2026-10-13 B6b-2 回灌）' },
- { doctor: '7', cl: '25', note: '经 §7 整体运行覆盖（路由预判一致性，2026-10-13 B6b-2 回灌）' },
- { doctor: '7', cl: '26', note: '经 §7 整体运行覆盖（闭环漏斗「协议前」占比动作阈值，2026-10-13 B6b-2 回灌）' },
-];
-
-// gateChecklist：按登记表对照两侧检查项（pure function；pairs 可注入供测试）
-// 返回 { doctorCount, checkLoopCount, pairs, matched, broken, unregistered, doctor, checkLoop }
-//   matched       = 登记两侧都存在的条目（直接配对 + 经 §7 覆盖）
-//   broken        = 登记声明的 id 在对应侧已不存在
-//   unregistered  = 两侧出现登记表之外的 § 检查项（新检查项未对账——核心信号）
-export function gateChecklist({ doctorSrc, checkLoopSrc, pairs = PAIRS }) {
-  const doctor = parseDoctorSections(doctorSrc);
-  const checkLoop = parseCheckLoopChecks(checkLoopSrc);
-  const doctorIds = new Set(doctor.map((d) => d.id));
-  const clIds = new Set(checkLoop.map((c) => c.id));
-  const declaredDoctor = new Set(pairs.map((p) => p.doctor).filter(Boolean));
-  const declaredCl = new Set(pairs.map((p) => p.cl).filter(Boolean));
-
-  const broken = [];
-  for (const p of pairs) {
-    if (p.doctor && !doctorIds.has(p.doctor)) broken.push({ side: 'doctor', id: p.doctor, note: p.note || '' });
-    if (p.cl && !clIds.has(p.cl)) broken.push({ side: 'check-loop', id: p.cl, note: p.note || '' });
-  }
-  const unregistered = [];
-  for (const d of doctor) {
-    if (!declaredDoctor.has(d.id)) unregistered.push({ side: 'doctor', id: d.id, title: d.title });
-  }
-  for (const c of checkLoop) {
-    if (!declaredCl.has(c.id)) unregistered.push({ side: 'check-loop', id: c.id, title: c.title });
-  }
-  const matched = pairs.filter((p) => p.doctor && doctorIds.has(p.doctor) && p.cl && clIds.has(p.cl));
-  return {
-    doctorCount: doctor.length,
-    checkLoopCount: checkLoop.length,
-    pairs,
-    matched,
-    broken,
-    unregistered,
-    doctor,
-    checkLoop,
-  };
-}
-
-const clip = (s, n) => (String(s).length > n ? String(s).slice(0, n) + '…' : String(s));
-
-function printDiff(result) {
-  console.log('▶ flow-kit gate-checklist --diff（显式配对登记表）');
-  const direct = result.pairs.filter((p) => p.doctor !== '7' && p.cl).length;
-  const via = result.pairs.filter((p) => p.doctor === '7').length;
-  const solo = result.pairs.filter((p) => !p.cl).length;
-  console.log(`  doctor §检查项: ${result.doctorCount}  |  check-loop §检查项: ${result.checkLoopCount}  |  直接配对 ${direct} + 经 §7 覆盖 ${via} + 声明独有 ${solo}`);
-  const doctorById = new Map(result.doctor.map((d) => [d.id, d]));
-  const clById = new Map(result.checkLoop.map((c) => [c.id, c]));
-  console.log('  对照表（登记表展开）:');
-  for (const p of result.pairs) {
-    const d = doctorById.get(p.doctor);
-    if (!p.cl) {
-      console.log(`    ● §${p.doctor} ${clip(d?.title || '?', 22)}（声明独有：${p.note}）`);
-    } else {
-      const c = clById.get(p.cl);
-      const mark = d && c ? '✓' : '✗';
-      console.log(`    ${mark} §${p.doctor} ${clip(d?.title || '?', 22)} ↔ #${p.cl} ${clip(c?.title || '?', 26)}（${p.note}）`);
-    }
-  }
-  if (result.broken.length) {
-    console.log('  断档（登记的检查项已不存在——删/改检查项后登记表未跟）:');
-    for (const b of result.broken) {
-      console.log(`    ⚠️  ${b.side === 'doctor' ? 'doctor §' + b.id : 'check-loop #' + b.id} 已不存在（登记备注：${b.note || '无'}）`);
-    }
-  }
-  if (result.unregistered.length) {
-    console.log('  未登记（新检查项未对账——配对 / 声明独有 / 经 §7 三选一登记进 PAIRS）:');
-    for (const u of result.unregistered) {
-      console.log(`    ⚠️  ${u.side === 'doctor' ? 'doctor §' + u.id : 'check-loop #' + u.id} ${clip(u.title, 30)}`);
-    }
-  }
-  if (!result.broken.length && !result.unregistered.length) {
-    console.log('  ✅ 登记完整（0 断档 / 0 未登记）');
-  }
-}
-
-const isMain = process.argv[1] && process.argv[1].endsWith('gate-checklist.mjs');
-if (isMain) {
-  let jsonMode = false;
-  for (const a of process.argv.slice(2)) {
-    if (a === '--json') jsonMode = true;
-    else if (a === '--diff') { /* 默认模式，兼容显式传参 */ }
-    else fail('未知选项：' + a + '（flow-kit gate-checklist --diff / --json）');
-  }
-  const pkgRoot = process.argv[2] && !process.argv[2].startsWith('--') ? process.argv[2] : null;
-  const base = pkgRoot || process.cwd();
-  const doctorPath = path.join(base, 'src', 'doctor.mjs');
-  // check-loop 与本脚本同目录：包源 templates/_agents/scripts/，装户副本 .agents/scripts/。
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  const clPath = path.join(here, 'check-loop.mjs');
-  if (!fs.existsSync(doctorPath)) fail('找不到 doctor.mjs：' + doctorPath);
-  if (!fs.existsSync(clPath)) fail('找不到 check-loop.mjs：' + clPath);
-  const doctorSrc = fs.readFileSync(doctorPath, 'utf8');
-  const checkLoopSrc = fs.readFileSync(clPath, 'utf8');
-  const result = gateChecklist({ doctorSrc, checkLoopSrc });
-  if (jsonMode) {
-    process.stdout.write(JSON.stringify({
-      doctorCount: result.doctorCount,
-      checkLoopCount: result.checkLoopCount,
-      matched: result.matched.map((p) => ({ doctor: p.doctor, cl: p.cl, note: p.note || '' })),
-      solo: result.pairs.filter((p) => !p.cl).map((p) => ({ doctor: p.doctor, note: p.note || '' })),
-      broken: result.broken,
-      unregistered: result.unregistered,
-    }, null, 2) + '\n');
-  } else {
-    printDiff(result);
-  }
-  // diff/json 模式总 exit 0；断档/未登记不视作错误（人类阅读用；B-b 决策「只报告不修复」）
-  process.exit(0);
-}
-export default gateChecklist;