agentic-flow-kit 1.7.15 → 1.8.0

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

@@ -0,0 +1,112 @@
+#!/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

@@ -67,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 整体运行覆盖' },
@@ -87,6 +88,12 @@ const PAIRS = [
   { 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 可注入供测试）
@@ -176,17 +183,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');
-  // check-loop 解析序：装副本 .agents/（装户径）→ 包源脚本同级（纯包源径，装户端内容清理后形态）
+  // check-loop 与本脚本同目录：包源 templates/_agents/scripts/，装户副本 .agents/scripts/。
   const here = path.dirname(fileURLToPath(import.meta.url));
-  const clPathMjs = path.join(base, '.agents', 'scripts', 'check-loop.mjs');
-  const clCandidates = [
-    clPathMjs,
-    path.join(base, '.agents', 'scripts', 'check-loop.sh'),
-    path.join(here, 'check-loop.mjs'),
-  ];
-  const clPath = clCandidates.find((p) => fs.existsSync(p));
+  const clPath = path.join(here, 'check-loop.mjs');
   if (!fs.existsSync(doctorPath)) fail('找不到 doctor.mjs：' + doctorPath);
-  if (!clPath) fail('找不到 check-loop（.mjs / .sh 均无）：' + clPathMjs);
+  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,17 +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（旧装户）
-// 装户端内容清理后（2026-10-09）：纯包源仓无 .agents/ 装副本——check-loop.mjs 在包源 scripts/ 下，
-// 即本测试同级；.agents/ 优先（装户径），包源径兜底（纯包源径），两者皆无 → hasReal 已经把守。
-const realCl = () => {
-  const mjs = path.join(SRC_ROOT, '.agents', 'scripts', 'check-loop.mjs');
-  if (fs.existsSync(mjs)) return fs.readFileSync(mjs, 'utf8');
-  const sh = path.join(SRC_ROOT, '.agents', 'scripts', 'check-loop.sh');
-  if (fs.existsSync(sh)) return fs.readFileSync(sh, 'utf8');
-  const pkgMjs = path.join(SCRIPT_DIR, 'check-loop.mjs');
-  return fs.readFileSync(pkgMjs, '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 未登记 ----

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

@@ -7,7 +7,7 @@
 // 默认路径（无 --gate-stats）下 segs 只在内存里攒、不打印不写盘 → 输出契约逐字节不变（硬约束：
 // pre-push / pre-commit 消费者 + doctor 的 WARN 行计数 + check-loop.test.mjs 223 断言全依赖它）。
 //
-// 耗时口径**刻意包含子进程时间**（检查 11 调两个生成器 --check、检查 13 调 sh rule-budget.sh）——
+// 耗时口径**刻意包含子进程时间**（检查 11 调两个生成器 --check、检查 13 调 rule-budget.mjs）——
 // 门禁真实成本本就要含子进程；不做剔除，但看板与 spec 均显式声明该口径防误读。
 export function gateSeg(collector, id, label) {
   const now = Date.now();

package/templates/_agents/scripts/gen-effective-policy.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+// gen-effective-policy.mjs — 当前生效规则视图生成器（2026-10-13 自 Shipyard.Material 参考实现回灌，
+//   源仓沿革留痕在包源仓 git 历史与 CHANGELOG——装户径不引实例路径）
+// 背景：豁免锚经 policy v1→v8 演进后，「存量豁免 vs 受管」的合成语义只活在 check-loop.mjs 源码里，
+//   规则空间永久二分且不可读——本脚本把 policy.mjs 单源渲染为人可读的 workflow/effective-policy.md，
+//   与 INDEX.md 同款「生成物 + --check 防漂移」纪律；verify.mjs 挂 --check 门（CI 强制随 policy 变更重生成）。
+// 渲染内容：当前生效 policyVersion（单源 policy.mjs#loadKitPolicy 读 .agents/kit.json，缺省回落 v1）、
+//   逐锚键的生效日 / 消费检查项 / 分级现状（hard·已生效 / advisory·已生效 / 未到期——锚日 > 今日的
+//   升级锚标注「待升级」）。
+// 判定单源：锚定义与版本回落 = policy.mjs POLICIES / loadKitPolicy（本脚本不写日期、不读第二份配置，
+//   只读只渲染）；键→检查项映射取自 check-loop.mjs 头部检查清单（kit 现役 1-20 项，编号是文档引用锚）。
+// 用法：node .agents/scripts/gen-effective-policy.mjs [--root <dir>] [--check]
+//   --check：与磁盘 workflow/effective-policy.md 比对，漂移 exit 1（CI/verify 用）。
+//   比对前双侧行尾归一（CRLF→LF）。生成器仍只写 LF，--check 不改文件。
+//   干净的 autocrlf 检出是 CRLF，字节相等会假红，且重生成只留下不可提交的行尾差。
+// 测试：node .agents/scripts/gen-effective-policy.test.mjs（fixture 注入 --root）
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { POLICIES, loadKitPolicy } from './policy.mjs';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+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 ROOT = argOf('--root') || path.resolve(SCRIPT_DIR, '..', '..');
+const OUT = path.join(ROOT, 'workflow', 'effective-policy.md');
+
+// 键 → 消费检查项与分级说明（单源 check-loop.mjs 头部检查清单编号；说明文本与本脚本共同演进）
+const CONSUMERS = {
+  moduleSince: ['检查 12', 'frontmatter「模块:」枚举合法性（词表单源 .agents/workflow-modules.txt）', 'advisory'],
+  check14Since: ['检查 14', '新 done 的 spec/plan 须有 approved git 历史（kit 口径恒 advisory 永不升级 hard）', 'advisory'],
+  confirmDocsEffective: ['检查 15', 'docs 确认台账两条件准入（台账行 ∪ 自报日期≥锚）', 'hard'],
+  confirmIncidentsEffective: ['检查 15', 'incidents 档确认阈值（fixed/closed 配对）', 'hard'],
+  bindingTs: ['检查 15', '四终态内容绑定（台账行 ts≥锚 才比对 sha256）', 'hard'],
+  check17UnclosedAfter: ['检查 17', '发版提交树未收口三件套——版本 tag 锚（非日期）', 'hard'],
+  stageGateSince: ['检查 19', '逐阶段审计（起草先于入口确认 / 台账顺序）', 'advisory'],
+  riskLevelSince: ['检查 1', 'intent risk_level 双字段协议（laneOfEntry 判道的生效锚——锚前建档单字段口径不判高）', 'hard'],
+  delegationSince: ['检查 18', '委派台账对账——锚前存量豁免', 'advisory'],
+  verifySince: ['检查 8', '测试绿声明对账（无 SHA 声明「测试绿」须 24h 内凭证）+ confirm-doc →done 前置', 'advisory'],
+  verifyDocSince: ['检查 8', '凭证按 doc 精确绑定的生效时刻（→done 前置与对账按 doc 匹配，不带 --doc 的行不给任何单背书）', 'advisory'],
+  scopeSince: ['检查 15', 'scope 子项（机器派生改动面 scope{files,sha256}——缺 scope 灰度 warning、摘要不符 hard）', 'hard'],
+  ledgerDocChainSince: ['检查 15', '台账哈希链域从物理序改为按 doc 逻辑序（写入侧 confirm-doc 同批生效）', 'hard'],
+  // B6b-2 六段 + §3x + 复核上下文（2026-10-13 自源仓回灌，消费面自本批起在场）
+  incidentRegrSince: ['检查 3x', 'incident 防复发验证证据门（fixed/closed 须落自动化用例/回归清单引用）', 'hard'],
+  specVerifSince: ['检查 21', 'spec 验证落地核查（验证节无测试文件/命令引用——advisory）', 'advisory'],
+  attributionSince: ['检查 24', 'incident 归因字段（来源/影响环境必填且在枚举——advisory）', 'advisory'],
+  convergenceSince: ['检查 23', '判据级收敛对账 advisory 档（证据无效 WARN）', 'advisory'],
+  convergenceHardSince: ['检查 23', '判据级收敛对账 hard 档（证据无效 HARD-BLOCK）', 'hard'],
+  reviewerSince: ['检查 1', '独立复核上下文标识（复核行缺「复核上下文：」——advisory）', 'advisory'],
+};
+
+// today：视图基准日。EFFECTIVE_POLICY_TODAY 为测试注入缝（跨锚日稳定性用；生产不设）。
+const today = () => process.env.EFFECTIVE_POLICY_TODAY || new Date().toISOString().slice(0, 10);
+
+function render(viewDateStr) {
+  const policy = loadKitPolicy(ROOT);
+  const v = POLICIES[policy.policyVersion] || {};
+  const todayStr = viewDateStr || today();
+  const lines = [];
+  lines.push('# 当前生效规则视图（生成物，勿手改）');
+  lines.push('');
+  lines.push('> 生成器 `node .agents/scripts/gen-effective-policy.mjs`（policy.mjs 单源渲染；漂移由 verify.mjs `effective-policy` 门 --check 把关——改 policy 后须重生成并随同提交）。');
+  lines.push(`> 当前生效：**policyVersion ${policy.policyVersion}**（kit.json 声明 ${policy.requestedVersion}${policy.requestedVersion === policy.policyVersion ? '' : '，不在 POLICIES 表内已回落 v1'}）；视图日期 ${todayStr}。`);
+  lines.push('');
+  lines.push('| 锚键 | 生效日/锚 | 消费检查项 | 语义 | 分级 | 现状 |');
+  lines.push('|---|---|---|---|---|---|');
+  for (const key of Object.keys(v)) {
+    const raw = v[key];
+    const c = CONSUMERS[key] || ['—', '（未登记消费方——policy 加新键时同步登 CONSUMERS）', '—'];
+    const isDate = /^\d{4}-\d{2}-\d{2}$/.test(String(raw));
+    // 升级锚语义：日期 > 今日 = 未到期（维持低档）；其余 = 已生效
+    const status = !isDate ? '生效（版本锚）' : (String(raw) <= todayStr ? '已生效' : `待升级（${raw} 起）`);
+    lines.push(`| \`${key}\` | ${raw} | ${c[0]} | ${c[1]} | ${c[2]} | ${status} |`);
+  }
+  lines.push('');
+  lines.push('<!-- GENERATED:BEGIN — gen-effective-policy.mjs 整段重写，手工说明写在本行之前 -->');
+  return lines.join('\n') + '\n';
+}
+
+const text = render();
+// 行尾归一（与 gen-workflow-index.mjs normEol 同句）：只影响 --check 判定，写盘仍是 LF。
+const normEol = (s) => String(s).replace(/\r\n/g, '\n');
+if (argv.includes('--check')) {
+  let disk = '';
+  try {
+    disk = fs.readFileSync(OUT, 'utf8');
+  } catch { /* 缺文件视作空——走漂移分支（新装户由 init 生成器首跑种子本文件） */ }
+  // 锚日时间炸弹拆除（源仓 2026-10-12 CI 实证：锚日当天重渲染按当日判「已生效」→ 与仓内视图必差
+  // → --check 必红——任何未来日期锚都会在锚日引爆）。修法：--check 对**磁盘文件自带的视图日期**重渲染
+  // （生成物与自身生成日自洽，跨锚日字节稳定）；显式重生成（默认模式）才前进视图日期并翻转状态列。
+  // 视图日期行缺失的存量件回落当日口径。
+  const mDate = disk.match(/视图日期 (\d{4}-\d{2}-\d{2})/);
+  const checkText = mDate ? render(mDate[1]) : text;
+  if (normEol(disk) === normEol(checkText)) {
+    console.log('[effective-policy] ✅ 与磁盘一致（无漂移；按磁盘视图日期重渲染比对）');
+    process.exit(0);
+  }
+  console.error('[effective-policy] ❌ 漂移：policy 变更后未重生成 workflow/effective-policy.md');
+  console.error('  修法：node .agents/scripts/gen-effective-policy.mjs && git add workflow/effective-policy.md（随 policy 变更同笔提交）');
+  process.exit(1);
+}
+fs.mkdirSync(path.dirname(OUT), { recursive: true });
+fs.writeFileSync(OUT, text);
+console.log(`✅ 已生成 ${path.relative(process.cwd(), OUT)}`);

package/templates/_agents/scripts/gen-effective-policy.test.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+// gen-effective-policy.test.mjs — 生效规则视图生成器 fixture 套件（2026-10-13 自 Shipyard.Material
+//   参考实现回灌时随件移植；夹具口径改 kit：注入 .agents/kit.json 的 policyVersion 取值 / 缺失 / 非法三态）
+// 方法：临时根注入 kit.json，断言生成内容与 --check 语义。
+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, 'gen-effective-policy.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 mkfix = (policyVersion) => {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'eff-policy-test-'));
+  fs.mkdirSync(path.join(d, '.agents'), { recursive: true });
+  if (policyVersion !== undefined) fs.writeFileSync(path.join(d, '.agents', 'kit.json'), JSON.stringify({ kit: 'agentic-flow-kit', policyVersion }));
+  return d;
+};
+const run = (root, ...args) => {
+  const r = spawnSync(process.execPath, [SCRIPT, '--root', root, ...args], { encoding: 'utf8' });
+  return { code: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
+};
+
+// 场景 1：v8 生成——当前版本行 + 全锚键行 + 表结构（真实 v8 锚均为历史日期，待升级分支由场景 4 注入钉住）
+{
+  const d = mkfix(8);
+  const r = run(d);
+  const doc = fs.readFileSync(path.join(d, 'workflow', 'effective-policy.md'), 'utf8');
+  check('场景 1：v8 生成成功且含版本声明与锚键行',
+    r.code === 0 && doc.includes('**policyVersion 8**') && doc.includes('`ledgerDocChainSince`') && doc.includes('`bindingTs`') && doc.includes('kit.json 声明 8'), r.out + doc);
+}
+// 场景 2：--check 一致 → 0；篡改磁盘 → 1；再生成 → 恢复 0
+{
+  const d = mkfix(8);
+  run(d);
+  check('场景 2a：生成后 --check 一致', run(d, '--check').code === 0);
+  fs.appendFileSync(path.join(d, 'workflow', 'effective-policy.md'), 'drift\n');
+  const r2 = run(d, '--check');
+  check('场景 2b：磁盘漂移 → --check exit 1 且含修法', r2.code === 1 && r2.out.includes('重生成'), r2.out);
+  run(d);
+  check('场景 2c：重生成后 --check 恢复 0', run(d, '--check').code === 0);
+}
+// 场景 2d/2e：行尾不算漂移，内容差仍算（autocrlf 假红）
+{
+  const d = mkfix(8);
+  run(d);
+  const p = path.join(d, 'workflow', 'effective-policy.md');
+  const lf = fs.readFileSync(p, 'utf8');
+  fs.writeFileSync(p, lf.replace(/\n/g, '\r\n'));
+  check('场景 2d：CRLF 检出、内容相同 → --check 0', run(d, '--check').code === 0);
+  fs.writeFileSync(p, lf.replace(/\n/g, '\r\n').replace('policyVersion', 'policyVerslon'));
+  const r = run(d, '--check');
+  check('场景 2e：CRLF 且内容漂移 → --check exit 1', r.code === 1 && r.out.includes('重生成'), r.out);
+}
+// 场景 2f：锚日翻转稳定性（源仓 2026-10-12 CI 生产事故钉：视图生成于 D1，次日系统当日 --check
+//   按当日重渲染判「已生效」→ 与仓内「待升级」必差 → 每个未来日期锚都在锚日引爆）。
+//   修法语义：--check 对磁盘自带「视图日期」重渲染——不依赖未来锚存在，视图日期行本身在旧实现下就会漂移。
+{
+  const d = mkfix(8);
+  const d1 = new Date(Date.now() - 24 * 3600 * 1000).toISOString().slice(0, 10);
+  const gen = spawnSync(process.execPath, [SCRIPT, '--root', d], { encoding: 'utf8', env: { ...process.env, EFFECTIVE_POLICY_TODAY: d1 } });
+  const doc = fs.readFileSync(path.join(d, 'workflow', 'effective-policy.md'), 'utf8');
+  const chk = run(d, '--check'); // 不带 env——按系统当日跑，模拟「次日对账」
+  check('场景 2f：视图日期 D1 生成的视图，次日 --check 仍一致（按磁盘视图日期重渲染，锚日不引爆）',
+    gen.status === 0 && doc.includes(`视图日期 ${d1}`) && chk.code === 0,
+    `gen=${gen.status} docViewDate=${(doc.match(/视图日期 (\S+)/) || [])[1]} check=${chk.code}\n${chk.out}`);
+}
+
+// 场景 3：非法版本号 → 回落 v1（渲染回落声明）；缺 kit.json → 同 v1
+{
+  const d = mkfix(99);
+  const r = run(d);
+  const doc = fs.readFileSync(path.join(d, 'workflow', 'effective-policy.md'), 'utf8');
+  check('场景 3a：非法 policyVersion=99 → 回落 v1 且声明回落',
+    r.code === 0 && doc.includes('**policyVersion 1**') && doc.includes('kit.json 声明 99') && doc.includes('已回落'), doc);
+  const d2 = mkfix(undefined);
+  const r2 = run(d2);
+  const doc2 = fs.readFileSync(path.join(d2, 'workflow', 'effective-policy.md'), 'utf8');
+  check('场景 3b：缺 kit.json → v1 基线', r2.code === 0 && doc2.includes('**policyVersion 1**'), doc2);
+}
+// 场景 4：待升级判定——不依赖墙钟：EFFECTIVE_POLICY_TODAY 注入 2026-09-24，
+//   v8 的 check14Since=2026-09-26 > 视图基准日 → 「待升级」；moduleSince=2026-09-22 ≤ → 「已生效」
+{
+  const d = mkfix(8);
+  const r = spawnSync(process.execPath, [SCRIPT, '--root', d], { encoding: 'utf8', env: { ...process.env, EFFECTIVE_POLICY_TODAY: '2026-09-24' } });
+  const doc = fs.readFileSync(path.join(d, 'workflow', 'effective-policy.md'), 'utf8');
+  check('场景 4：升级锚按视图基准日判定（moduleSince 已生效 / check14Since 待升级）',
+    r.status === 0 && doc.includes('`check14Since` | 2026-09-26 | 检查 14 | 新 done 的 spec/plan 须有 approved git 历史（kit 口径恒 advisory 永不升级 hard） | advisory | 待升级（2026-09-26 起）')
+      && doc.includes('`moduleSince` | 2026-09-22 | 检查 12'), doc);
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+process.exit(fail ? 1 : 0);