agentic-flow-kit 1.7.0 → 1.7.16

package/templates/_agents/scripts/draft-sediment.test.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+// draft-sediment.mjs 测试（B2，2026-10-10）——纯函数直测 + fixture 子进程跑真 CLI
+// 纯函数（extractSections/topicOf/renderDraft/setSedimentField）import 直测；CLI 场景
+// 以「换 cwd」方式在临时仓跑真脚本（脚本按相对路径 workflow/ + wiki/ 读写，无需注入口）。
+// 覆盖：抽节/主题取法/草稿渲染/沉淀字段回写的纯逻辑 + dry-run 不写盘 / 实跑落草稿并回写
+//   并重跑 gen-wiki-board / 状态守卫拦非 done|closed / 无高价值节拒抽 / 路径越界拒收
+// 用法：node .agents/scripts/draft-sediment.test.mjs（仓库任意目录执行均可）
+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';
+import { extractSections, topicOf, renderDraft, setSedimentField } from './draft-sediment.mjs';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const SED = path.join(SCRIPT_DIR, 'draft-sediment.mjs');
+const TODAY = new Date().toISOString().slice(0, 10); // 与脚本内取法一致（草稿目录日期段）
+const USAGE = '用法：node .agents/scripts/draft-sediment.test.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}` : ''}`); }
+};
+
+// ---- 纯函数：extractSections ----
+{
+  const text = [
+    '# INTENT — 权限收敛',
+    '',
+    '## 影响面',
+    '',
+    '- 模块：pipeline',
+    '- 数据库：无',
+    '',
+    '## 触达红线与边界',
+    '',
+    '> 这是引用块，应被剔除',
+    '<!-- 注释也应剔除 -->',
+    '<占位单行也应剔除>',
+    '- [x] 规则变更（证据：abc123）',
+    '',
+    '## 目标（不在抽取词表内）',
+    '',
+    '- 不应被抽出来',
+    '',
+    '## 影响面（空节）',
+    '',
+    '<待补>',
+    '',
+  ].join('\n');
+  const got = extractSections(text, ['影响面', '触达红线']);
+  const titles = got.map((s) => s.title);
+  check('1a 抽取指定节（影响面）', titles.includes('影响面'), JSON.stringify(titles));
+  check('1b 节标题前缀匹配（「触达红线与边界」命中「触达红线」）', titles.includes('触达红线与边界'), JSON.stringify(titles));
+  check('1c 词表外节不抽（目标节缺席）', !titles.some((t) => t.startsWith('目标')), JSON.stringify(titles));
+  const yx = got.find((s) => s.title === '影响面');
+  check('1d 正文保留（模块行入库）', yx && yx.body.includes('- 模块：pipeline'), yx && yx.body);
+  const hx = got.find((s) => s.title === '触达红线与边界');
+  check('1e 占位行剔除（引用块/注释/单行尖括号均不进 body）',
+    hx && !hx.body.includes('引用块') && !hx.body.includes('注释也应') && !hx.body.includes('占位单行')
+    && hx.body.includes('规则变更（证据：abc123）'), hx && hx.body);
+  check('1f 仅占位的空节被丢弃（「影响面（空节）」不入结果）',
+    !titles.includes('影响面（空节）'), JSON.stringify(titles));
+}
+
+// ---- 纯函数：topicOf（标题行优先于文件名）----
+{
+  check('2a 标题行优先（# INTENT — 权限收敛 胜过文件名尾段 perm）',
+    topicOf('workflow/intents/2026-10-10-perm.md', '# INTENT — 权限收敛\n') === '权限收敛', '');
+  check('2b 无标题行退文件名尾段（去日期前缀）',
+    topicOf('workflow/intents/2026-10-10-perm.md', '# 无标题文档\n') === 'perm', '');
+  check('2c 无标题无日期退文件基名',
+    topicOf('wiki/随便/a.md', '# 无标题文档\n') === 'a', '');
+  check('2d INCIDENT 标题行同样识别',
+    topicOf('workflow/incidents/2026-09-12-x.md', '# INCIDENT — 越权写操作\n') === '越权写操作', '');
+}
+
+// ---- 纯函数：renderDraft ----
+{
+  const out = renderDraft({ topic: '权限收敛', date: '2026-10-10', source: 'workflow/intents/2026-10-10-perm.md',
+    sections: [{ title: '影响面', body: '- 模块：pipeline' }], kind: 'intent' });
+  check('3a frontmatter 含来源与草稿状态', out.startsWith('---\n') && out.includes('来源: workflow/intents/2026-10-10-perm.md')
+    && out.includes('状态: 草稿（待人工归类）'), out.split('\n').slice(0, 5).join('\n'));
+  check('3b intent 渲染为「需求沉淀草稿」', out.includes('# 权限收敛（需求沉淀草稿）'), out.split('\n')[4]);
+  check('3c incident 渲染为「事故复盘草稿」',
+    renderDraft({ topic: 't', date: '2026-10-10', source: 's', sections: [], kind: 'incident' })
+      .includes('# t（事故复盘草稿）'), '');
+  check('3d 抽取节原样落到正文 ## 节下', out.includes('## 影响面\n\n- 模块：pipeline'), out);
+  check('3e 草稿头含中间态提示（引导人工归类）', out.includes('中间态'), out);
+}
+
+// ---- 纯函数：setSedimentField ----
+{
+  const fm = (body) => `---\n${body}\n---\n# INTENT — t\n`;
+  const a = setSedimentField(fm('状态: done\n级别: L1'), 'wiki/drafts-archive/2026-10-10-t/t.md');
+  check('4a 无沉淀字段 → 追加且 changed=true',
+    a.changed && a.text.includes('沉淀: wiki/drafts-archive/2026-10-10-t/t.md')
+    && a.text.includes('# INTENT — t\n'), a.text);
+  const b = setSedimentField(fm('状态: done\n沉淀: 无'), 'wiki/drafts-archive/2026-10-10-t/t.md');
+  check('4b 「沉淀: 无」显式豁免位 → 覆盖（豁免是占位，可写）',
+    b.changed && b.text.includes('沉淀: wiki/drafts-archive/2026-10-10-t/t.md'), b.text);
+  const c = setSedimentField(fm('状态: done\n沉淀: wiki/规范/x.md'), 'wiki/drafts-archive/2026-10-10-t/t.md');
+  check('4c 已有人工登记 → 不覆盖 changed=false（防误抹）',
+    !c.changed && c.text.includes('沉淀: wiki/规范/x.md'), c.text);
+  const d = setSedimentField('# 无 frontmatter 的文档\n', 'wiki/drafts-archive/x.md');
+  check('4d 无 frontmatter → 不动 changed=false', !d.changed, d.text);
+  const e = setSedimentField(fm('状态: done\n沉淀:  '), 'wiki/drafts-archive/y.md');
+  check('4e 空值沉淀位 → 覆盖（空同未填）',
+    e.changed && e.text.includes('沉淀: wiki/drafts-archive/y.md'), e.text);
+}
+
+// ---- fixture：临时仓（wiki 根带 INDEX/看板锚点，供 gen-wiki-board 重跑；workflow 两目录）----
+const mkfx = () => {
+  const fx = fs.mkdtempSync(path.join(os.tmpdir(), 'draft-sed-test-'));
+  fs.mkdirSync(path.join(fx, 'wiki', '主题A'), { recursive: true });
+  fs.mkdirSync(path.join(fx, 'wiki', 'drafts-archive'), { recursive: true });
+  fs.writeFileSync(path.join(fx, 'wiki', '主题A', 'a.md'), '# a\n', 'utf8');
+  fs.writeFileSync(path.join(fx, 'wiki', 'INDEX.md'), [
+    '# wiki 索引（fixture）', '',
+    '| 主题 | 文件数 | 用途 |', '|---|---|---|',
+    '| 主题A | 1 | fixture 主题 |',
+    '| drafts-archive | — | 原文档备份（按 日期-主题 分目录）', '',
+    '合计：**1 份**知识文档，**1 个主题**', '',
+    '---', '', '## 文件 → 主题 → 归属目录 映射表', '',
+    '### 主题A（1）', '',
+    '| 文件名 | 主题 | 归属目录 |', '|---|---|---|',
+    '| a.md | 主题A | wiki/主题A/ |', '', '---', '',
+    '## 命名规则', '', '- fixture', '',
+  ].join('\n'), 'utf8');
+  fs.writeFileSync(path.join(fx, 'wiki', '知识沉淀总览.html'), [
+    '<!doctype html><html><body><script>', 'const DATA = {',
+    '  "summary": { "total": 1, "topics": 1, "files": 1, "archive": 0 },',
+    '  "topics": [ { "name": "主题A", "files": [',
+    '      { "file": "a.md", "topic": "主题A", "dir": "./主题A/" } ]} ]',
+    '};', '</script></body></html>', '',
+  ].join('\n'), 'utf8');
+  fs.mkdirSync(path.join(fx, 'workflow', 'intents'), { recursive: true });
+  fs.mkdirSync(path.join(fx, 'workflow', 'incidents'), { recursive: true });
+  return fx;
+};
+
+// 高价值正文（intent：影响面 + 触达红线均有实质内容）
+const INTENT_DONE = [
+  '---', '状态: done', '级别: L1', '日期: 2026-10-10', '模块: pipeline', '---',
+  '# INTENT — 权限收敛', '',
+  '## 影响面', '', '- 模块：pipeline', '- 数据库：无', '',
+  '## 触达红线', '', '- [x] 规则 / 契约变更（证据：abc123）', '',
+  '## 验收标准（可测试）', '', '- [x] 全绿（证据：npm test）', '',
+].join('\n');
+
+// 高价值正文（incident：复盘三件套齐全）
+const INC_CLOSED = [
+  '---', '状态: closed', '级别: L1', '日期: 2026-09-12', '---',
+  '# INCIDENT — 越权写操作', '',
+  '## 影响面', '', '- 只读接口被放行写操作。', '',
+  '## 根因', '', '- 鉴权中间件早于路由注册生效。', '',
+  '## 为什么之前没拦住', '', '- 测试只覆盖了 happy path。', '',
+  '## 复盘三件套', '', '- 修复：注册顺序对调（SHA abc123）。', '- 防复发：加契约测试。', '- 台账：已登记。', '',
+].join('\n');
+
+const runSed = (fx, targetArgs) => spawnSync(process.execPath, [SED, ...targetArgs], {
+  cwd: fx, encoding: 'utf8',
+});
+
+// ---- CLI 5：--dry-run 不写盘 ----
+{
+  const fx = mkfx();
+  fs.writeFileSync(path.join(fx, 'workflow', 'intents', '2026-10-10-perm.md'), INTENT_DONE, 'utf8');
+  const r = runSed(fx, ['workflow/intents/2026-10-10-perm.md', '--dry-run']);
+  const out = (r.stdout || '') + (r.stderr || '');
+  check('5a --dry-run exit 0 且明示未写盘', r.status === 0 && out.includes('未写盘'), `exit=${r.status}\n${out.slice(0, 400)}`);
+  check('5b 未落草稿（drafts-archive 仍空）',
+    fs.readdirSync(path.join(fx, 'wiki', 'drafts-archive')).length === 0, '');
+  check('5c 源文件未回写（无沉淀字段）',
+    !fs.readFileSync(path.join(fx, 'workflow', 'intents', '2026-10-10-perm.md'), 'utf8').includes('沉淀:'), '');
+  check('5d 预览含来源与抽取节标题', out.includes('来源: workflow/intents/2026-10-10-perm.md')
+    && out.includes('## 影响面') && out.includes('## 触达红线'), out);
+  check('5e 主题取标题行（权限收敛）而非文件名尾段（perm）',
+    out.includes('wiki/drafts-archive/' + TODAY + '-权限收敛'), out);
+  fs.rmSync(fx, { recursive: true, force: true });
+}
+
+// ---- CLI 6：实跑 intent —— 落草稿 + 回写沉淀 + 重跑 gen-wiki-board ----
+{
+  const fx = mkfx();
+  fs.writeFileSync(path.join(fx, 'workflow', 'intents', '2026-10-10-perm.md'), INTENT_DONE, 'utf8');
+  const r = runSed(fx, ['workflow/intents/2026-10-10-perm.md']);
+  const out = (r.stdout || '') + (r.stderr || '');
+  const draftP = path.join(fx, 'wiki', 'drafts-archive', `${TODAY}-权限收敛`, '权限收敛.md');
+  check('6a 实跑 exit 0', r.status === 0, `exit=${r.status}\n${out.slice(0, 500)}`);
+  check('6b 草稿落到 drafts-archive/<日期-主题>/<主题>.md',
+    fs.existsSync(draftP), `期望存在：${draftP}`);
+  const draft = fs.existsSync(draftP) ? fs.readFileSync(draftP, 'utf8') : '';
+  check('6c 草稿带来源 frontmatter 指回源文件',
+    draft.startsWith('---\n') && draft.includes('来源: workflow/intents/2026-10-10-perm.md')
+    && draft.includes('（需求沉淀草稿）'), draft.split('\n').slice(0, 6).join('\n'));
+  const src = fs.readFileSync(path.join(fx, 'workflow', 'intents', '2026-10-10-perm.md'), 'utf8');
+  check('6d 源文件回写沉淀字段（B1 闭环——断链 WARN 由此消除）',
+    src.includes(`沉淀: wiki/drafts-archive/${TODAY}-权限收敛/权限收敛.md`), src.split('\n').slice(0, 7).join('\n'));
+  const board = fs.readFileSync(path.join(fx, 'wiki', '知识沉淀总览.html'), 'utf8');
+  check('6e gen-wiki-board 已重跑（看板归档计数 0→1）',
+    /"archive": 1/.test(board) && out.includes('gen-wiki-board'), board.split('\n').slice(0, 6).join('\n'));
+  check('6f 沉淀回写幂等：再跑一次不覆盖已有登记（changed=false 分支）',
+    runSed(fx, ['workflow/intents/2026-10-10-perm.md']).status === 0
+    && src.includes(`沉淀: wiki/drafts-archive/${TODAY}-权限收敛/权限收敛.md`), '');
+  fs.rmSync(fx, { recursive: true, force: true });
+}
+
+// ---- CLI 7：实跑 incident —— 事故口径四节 ----
+{
+  const fx = mkfx();
+  fs.writeFileSync(path.join(fx, 'workflow', 'incidents', '2026-09-12-x.md'), INC_CLOSED, 'utf8');
+  const r = runSed(fx, ['workflow/incidents/2026-09-12-x.md']);
+  const draftP = path.join(fx, 'wiki', 'drafts-archive', `${TODAY}-越权写操作`, '越权写操作.md');
+  const draft = fs.existsSync(draftP) ? fs.readFileSync(draftP, 'utf8') : '';
+  check('7a incident 实跑 exit 0 且草稿落盘', r.status === 0 && fs.existsSync(draftP),
+    `exit=${r.status}\n${(r.stdout || '') + (r.stderr || '')}`.slice(0, 400));
+  check('7b 草稿为事故复盘口径（标题 + 四节齐备）',
+    draft.includes('（事故复盘草稿）') && ['影响面', '根因', '为什么之前没拦住', '复盘三件套']
+      .every((h) => draft.includes('## ' + h)), draft.slice(0, 300));
+  check('7c 源文件回写沉淀字段',
+    fs.readFileSync(path.join(fx, 'workflow', 'incidents', '2026-09-12-x.md'), 'utf8')
+      .includes(`沉淀: wiki/drafts-archive/${TODAY}-越权写操作/越权写操作.md`), '');
+  fs.rmSync(fx, { recursive: true, force: true });
+}
+
+// ---- CLI 8：守卫（状态 / 无高价值节 / 路径越界）----
+{
+  const fx = mkfx();
+  // 8a 非 done intent
+  fs.writeFileSync(path.join(fx, 'workflow', 'intents', 'a-draft.md'),
+    INTENT_DONE.replace('状态: done', '状态: draft'), 'utf8');
+  const r8a = runSed(fx, ['workflow/intents/a-draft.md']);
+  check('8a 非 done intent → exit 1 且明示状态要求',
+    r8a.status === 1 && (r8a.stderr || '').includes('须为 done'), `exit=${r8a.status}\n${r8a.stderr}`);
+  // 8b 非 closed incident
+  fs.writeFileSync(path.join(fx, 'workflow', 'incidents', 'b-open.md'),
+    INC_CLOSED.replace('状态: closed', '状态: open'), 'utf8');
+  const r8b = runSed(fx, ['workflow/incidents/b-open.md']);
+  check('8b 非 closed incident → exit 1 且明示状态要求',
+    r8b.status === 1 && (r8b.stderr || '').includes('须为 closed'), `exit=${r8b.status}\n${r8b.stderr}`);
+  // 8c 高价值节全为占位 → 拒抽
+  fs.writeFileSync(path.join(fx, 'workflow', 'intents', 'c-empty.md'), [
+    '---', '状态: done', '---', '# INTENT — 空单', '',
+    '## 影响面', '', '<待补>', '', '## 触达红线', '', '<待补>', '',
+  ].join('\n'), 'utf8');
+  const r8c = runSed(fx, ['workflow/intents/c-empty.md']);
+  check('8c 高价值节仅占位 → exit 1 且明示无沉淀价值',
+    r8c.status === 1 && (r8c.stderr || '').includes('未抽取到高价值节'), `exit=${r8c.status}\n${r8c.stderr}`);
+  check('8c 占位拒抽不落草稿', !fs.existsSync(path.join(fx, 'wiki', 'drafts-archive', `${TODAY}-空单`)), '');
+  // 8d 路径在 workflow/ 外
+  fs.writeFileSync(path.join(fx, 'outside.md'), INTENT_DONE, 'utf8');
+  const r8d = runSed(fx, ['outside.md']);
+  check('8d 源文件不在 workflow/intents|incidents 下 → exit 1',
+    r8d.status === 1 && (r8d.stderr || '').includes('workflow/intents'), `exit=${r8d.status}\n${r8d.stderr}`);
+  // 8e 不存在的文件
+  const r8e = runSed(fx, ['workflow/intents/不存在.md']);
+  check('8e 源文件不存在 → exit 1', r8e.status === 1, `exit=${r8e.status}\n${r8e.stderr}`);
+  // 8f 无参数
+  const r8f = runSed(fx, []);
+  check('8f 无源文件参数 → exit 1 且打印用法', r8f.status === 1, `exit=${r8f.status}`);
+  fs.rmSync(fx, { recursive: true, force: true });
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+if (fail) {
+  console.log(`\n${USAGE}`);
+  process.exit(1);
+}
+process.exit(0);

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

@@ -36,16 +36,17 @@ check('globToRe：目录前缀', globToRe('.agents/cache/').test('.agents/cache/
 }
 
 // ---- ② 端到端 fixture ----
-const SCRIPTS = ['check-loop.mjs', 'policy.mjs', 'stage-gates.mjs', 'check-metric-claims.mjs', 'check-hygiene.mjs', 'check-stage-index.mjs', 'gate-seg.mjs', 'workflow-enums.mjs', 'edit-face-check.mjs'];
+// 夹具闭包（2026-10-12 fixture-closure-rootfix）：此前手写 SCRIPTS 枚举，漏拷 ledger-loader / ledger-prune
+// 就让 check-loop import 失败 → 门禁静默不跑 → **假绿**。改为按入口自动求传递闭包，新增依赖自动跟随。
+const { copyScriptClosure, copyAgentsFiles } = await import('./fixture-scripts.mjs');
 // 引用完整性哑文件（检查 4/6/7 的存在性判据——避免 fixture 结构性 WARN 淹没断言面）
 const REF_COMMANDS = ['new-task', 'plan', 'design', 'build', 'test', 'deploy', 'maintain', 'review'];
 const REF_ROLES = ['implementer', 'independent-reviewer', 'ui-verifier'];
 function mkFixture({ breakStageIndex, overBudget }) {
   const fx = fs.mkdtempSync(path.join(os.tmpdir(), 'efc-'));
   fs.mkdirSync(path.join(fx, '.agents', 'scripts'), { recursive: true });
-  for (const f of SCRIPTS) fs.copyFileSync(path.join(SRC, f), path.join(fx, '.agents', 'scripts', f));
-  for (const f of ['kit.json', 'workflow-modules.txt', 'workflow-enums.txt'])
-    if (fs.existsSync(path.join(SRC, '..', f))) fs.copyFileSync(path.join(SRC, '..', f), path.join(fx, '.agents', f));
+  copyScriptClosure(path.join(fx, '.agents', 'scripts'), ['edit-face-check.mjs', 'check-loop.mjs']);
+  copyAgentsFiles(path.join(fx, '.agents'), ['kit.json', 'workflow-modules.txt', 'workflow-enums.txt']);
   fs.mkdirSync(path.join(fx, 'workflow', 'intents'), { recursive: true });
   for (const d of ['specs', 'plans', 'incidents']) fs.mkdirSync(path.join(fx, 'workflow', d), { recursive: true });
   for (const c of REF_COMMANDS) { fs.mkdirSync(path.join(fx, '.agents', 'commands'), { recursive: true }); fs.writeFileSync(path.join(fx, '.agents', 'commands', `${c}.md`), `# ${c}\n`); }

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

@@ -33,8 +33,8 @@ const SECTIONS = [
   { title: '目标', hint: '- <可验证的目标>' },
   { title: '非目标（L1 微改动无实质内容可删本节，不硬填）', hint: '- <明确不做的，防止范围蔓延>' },
   { title: '约束（L1 微改动无实质内容可删本节，不硬填）', hint: '- <复用什么、不许动什么>' },
-  { title: '影响面', hint: '- 模块：<词表之一，见 .agents/workflow-modules.txt>\n- 数据库：无 / <表名>（涉及 schema 变更 → L3；无 schema 的运行时 / 管线结构面亦为 L3，判据见 .agents/commands/new-task.md §级别判断）\n- 前端页面：<路由或组件，无则删本行>' },
-  { title: '触达红线（对照 AGENTS.md，勾选仅标记触及范围；具体如何满足在同名 spec 或 Quick-Plan 中说明）', hint: '- [ ] <按本项目 AGENTS.md 红线逐行补；无则删本行>\n- [ ] 规则 / 契约变更（编码权威 / 共享契约 / 接口签名 / 既有参数语义 / 全局口径）→ 级别至少 L2\n- [ ] schema / 迁移 SQL / DI 链 / 认证与中间件管线 → 级别 L3\n\n> 触及任一红线即为 L2 / L3，必须立 ../specs/YYYY-MM-DD-<主题>.md 写明如何满足，方可起草 plan。' },
+  { title: '影响面', hint: '- 模块：<词表之一，见 .agents/workflow-modules.txt>\n- 数据库：无 / <表名>（涉及 schema 变更 → L3；无 schema 的运行时 / 管线结构面亦为 L3，判据单源见 .agents/scripts/level-criteria.mjs 的 L3_SURFACES）\n- 前端页面：<路由或组件，无则删本行>' },
+  { title: '触达红线（对照 AGENTS.md，勾选仅标记触及范围；具体如何满足在同名 spec 或 Quick-Plan 中说明）', hint: '- [ ] <按本项目 AGENTS.md 红线逐行补；无则删本行>\n- [ ] 触及判据单源 `.agents/scripts/level-criteria.mjs` 的 `L2_SURFACES` 触达面闭集 → 级别至少 L2\n- [ ] 触及同源的 `L3_SURFACES` 结构面闭集 → 级别 L3\n\n> 两条闭集只在该单源一处定义，**逐条对照单源勾选，不要凭记忆复述**（此处曾各写一份且条目不一致，判低即错判）。\n> 触及任一红线即为 L2 / L3，必须立 ../specs/YYYY-MM-DD-<主题>.md 写明如何满足，方可起草 plan。' },
   { title: '验收标准（可测试）', hint: '- [ ] <逐条可测试；写不出可测试判据 = 还没想清楚>\n\n> **闭环对账**：关单在 test 阶段（不依赖 deploy）。intent 置 done 前逐条勾验，每条补证据——`- [x] <判据>（证据：<commit SHA / 测试用例名 / 冒烟脚本输出>）`。\n> done 状态仍有未勾项会被 check-loop 拦截（2026-09-12 起新建 intent 为 hard-block，存量 intent 仅 warning 提示）；勾选但缺「证据：」为 hard-block。' },
 ];
 

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

@@ -0,0 +1,153 @@
+// 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.sh 与两个生成器）。裸文件名只在**解析到同目录真实文件**时才计入，
+// 故 `'../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.sh 之外的 .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

@@ -0,0 +1,107 @@
+#!/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 闭包含新台账依赖', ['check-loop.mjs', 'ledger-loader.mjs', 'ledger-prune.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

@@ -19,6 +19,7 @@
 // 测试：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); }
 
@@ -66,6 +67,7 @@ const PAIRS = [
   { 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 整体运行覆盖' },
@@ -175,10 +177,11 @@ if (isMain) {
   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');
-  const clPathMjs = path.join(base, '.agents', 'scripts', 'check-loop.mjs');
-  const clPath = fs.existsSync(clPathMjs) ? clPathMjs : path.join(base, '.agents', 'scripts', 'check-loop.sh');
+  // 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 / .sh 均无）：' + clPath);
+  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 });

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

@@ -152,11 +152,8 @@ const y = 2;
 }
 
 const realDoctor = () => fs.readFileSync(path.join(SRC_ROOT, 'src', 'doctor.mjs'), 'utf8');
-// check-loop 解析面与 CLI 同口径：.mjs 优先（2026-09-26 迁移后主位），fallback .sh（旧装户）
-const realCl = () => {
-  const mjs = path.join(SRC_ROOT, '.agents', 'scripts', 'check-loop.mjs');
-  return fs.readFileSync(fs.existsSync(mjs) ? mjs : path.join(SRC_ROOT, '.agents', 'scripts', 'check-loop.sh'), 'utf8');
-};
+// check-loop 与 gate-checklist.mjs 同目录（包源 scripts/，拷进装户后是 .agents/scripts/）。
+const realCl = () => fs.readFileSync(path.join(SCRIPT_DIR, 'check-loop.mjs'), 'utf8');
 const hasReal = fs.existsSync(path.join(SRC_ROOT, 'src', 'doctor.mjs'));
 
 // ---- S10 真实仓库 baseline：PAIRS 全量登记 → 0 断档 / 0 未登记 ----