agentic-flow-kit 1.8.2 → 2.0.0

package/templates/_agents/scripts/agg-delegations.test.mjs

@@ -1,282 +0,0 @@
-#!/usr/bin/env node
-// agg-delegations.cjs 的 fixture 驱动测试（2026-09-24 随「台账结构漂移静默吞数据」修复引入）
-// 被测脚本以 __dirname 定位台账，故复制脚本进临时根（<tmp>/.agents/scripts/）后以 cwd=<tmp> 运行。
-// 断言：①节标题缺失但表头合规 → 数据照常入账（本次事故形态回归）；②日期数据行在但表头不可识别 → exit 1 fail-loud；
-//       ③空台账（表头合规、无数据行）→ exit 0 且提示为空。
-// 用法：node .agents/scripts/agg-delegations.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, pathToFileURL } from 'node:url';
-
-const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-// 夹具闭包（2026-10-12 fixture-closure-rootfix）：入口 agg-delegations.cjs 的传递依赖自动带入（当前无，
-// 但日后加 import 不必回来改这里——漏拷 = 假绿）。
-const { copyScriptClosure } = await import(pathToFileURL(path.join(SCRIPT_DIR, 'fixture-scripts.mjs')).href);
-const USAGE = '用法：node .agents/scripts/agg-delegations.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}` : ''}`); }
-};
-
-const mkfix = (ledgerText) => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agg-delegations-test-'));
-  fs.mkdirSync(path.join(root, '.agents', 'scripts'), { recursive: true });
-  fs.mkdirSync(path.join(root, 'workflow', 'incidents'), { recursive: true });
-  fs.writeFileSync(path.join(root, 'workflow', 'delegations.md'), ledgerText, 'utf8');
-  copyScriptClosure(path.join(root, '.agents', 'scripts'), ['agg-delegations.cjs']);
-  return root;
-};
-const runAgg = (root) => spawnSync(process.execPath, [path.join(root, '.agents', 'scripts', 'agg-delegations.cjs')], { cwd: root, encoding: 'utf8' });
-
-// ---- 场景 1：无 `## ` 节标题、表头合规（2026-09-24 事故形态）→ 数据照常入账 ----
-{
-  const root = mkfix([
-    '# 量化证据台账（fixture）',
-    '',
-    '| 日期 | 被委派方(模型) | 任务一句话 | 结果 | 备注 |',
-    '|------|----------------|------------|------|------|',
-    '| 2026-09-23 | general-purpose(子代理) | 示例委派任务 | 一次通过 | fixture |',
-    '| 2026-09-24 | executor(子代理) | 结果列拼错的示例行 | 成功 | fixture |',
-    '',
-  ].join('\n'));
-  const r = runAgg(root);
-  check('场景 1：节标题缺失 + 表头合规 → exit 0', r.status === 0, `exit=${r.status}\n${r.stdout}${r.stderr}`);
-  check('场景 1：数据行入账（有效任务 1，非「台账为空」）', /有效任务 1（/.test(r.stdout) && !r.stdout.includes('台账为空'), r.stdout);
-  check('场景 1：未知结果单列计数（不混入待修，2026-09-24 口径分离）', r.stdout.includes('待修 0、未知结果 1'), r.stdout);
-  fs.rmSync(root, { recursive: true, force: true });
-}
-
-// ---- 场景 2：日期数据行在但表头不可识别 → fail-loud（不再静默「台账为空」）----
-{
-  const root = mkfix([
-    '# 量化证据台账（fixture）',
-    '',
-    '| when | who | what | result | note |',
-    '|------|-----|------|--------|------|',
-    '| 2026-09-23 | executor | 表头被改的行 | 一次通过 | fixture |',
-    '',
-  ].join('\n'));
-  const r = runAgg(root);
-  check('场景 2：表头不可识别 → exit 1', r.status === 1, `exit=${r.status}\n${r.stdout}${r.stderr}`);
-  check('场景 2：报错点名结构漂移', (r.stderr || '').includes('结构漂移'), r.stderr);
-  fs.rmSync(root, { recursive: true, force: true });
-}
-
-// ---- 场景 3：空台账（表头合规、无数据行）→ exit 0 且提示为空 ----
-{
-  const root = mkfix([
-    '# 量化证据台账（fixture）',
-    '',
-    '## 委派结果',
-    '',
-    '| 日期 | 被委派方(模型) | 任务一句话 | 结果 | 备注 |',
-    '|------|----------------|------------|------|------|',
-    '',
-    '## 自做任务结果',
-    '',
-    '| 日期 | 任务一句话 | 结果 | 备注 |',
-    '|------|------------|------|------|',
-    '',
-  ].join('\n'));
-  const r = runAgg(root);
-  check('场景 3：空台账 → exit 0', r.status === 0, `exit=${r.status}\n${r.stdout}${r.stderr}`);
-  check('场景 3：提示台账为空', r.stdout.includes('台账为空'), r.stdout);
-  fs.rmSync(root, { recursive: true, force: true });
-}
-
-// ---- 场景 4-5：扩容门口径（2026-09-27 board-kb-p1 对齐 delegations.md：返工 0 / 无主兜底 / 连续两月）----
-//     纯函数经 module.exports require（isMain 守卫后 import 不执行 main）
-import { createRequire } from 'node:module';
-const requireCjs = createRequire(import.meta.url);
-const { metrics, gateMonth, expansionVerdict, parseResult, parseVerdict, fmtAccept, ACCEPT_MIN_SAMPLE } = requireCjs(path.join(SCRIPT_DIR, 'agg-delegations.cjs'));
-
-// 场景 4：审查反例——30 任务、2 主兜底、平均返工 0.25（旧口径四门全过，声明口径下必须 ❌）
-{
-  const rows = [
-    ...Array.from({ length: 22 }, () => ({ scope: '委派', result: '一次通过' })),
-    ...Array.from({ length: 6 }, () => ({ scope: '委派', result: '返工×1' })),
-    { scope: '委派', result: '主兜底' }, { scope: '委派', result: '主兜底' },
-  ];
-  const m = metrics(rows);
-  const g = gateMonth(m);
-  check('场景 4：反例（2 主兜底 + 平均返工 0.25）门3 返工=0 ❌', g.items.find((i) => i.no === 3).ok === false, JSON.stringify(g.items));
-  check('场景 4：反例门4 主兜底=0 ❌ 且 monthOk=false（声明口径下不达标）',
-    g.items.find((i) => i.no === 4).ok === false && g.monthOk === false, `monthOk=${g.monthOk}`);
-  const good = metrics([{ scope: '自做', result: '一次通过' }, { scope: '委派', result: '一次通过' }]);
-  const g2 = gateMonth(good);
-  check('场景 4：返工 0 + 无主兜底月 → 口径项全 ✅（样本护栏项单独列出）',
-    g2.items.filter((i) => i.kind === '口径').every((i) => i.ok === true) && g2.items.find((i) => i.no === 1).ok === false,
-    JSON.stringify(g2.items));
-}
-// 场景 5：连续两月判定四态
-{
-  check('场景 5：本月+上月均达标 → ✅ 可扩容', expansionVerdict(true, true, false, []).includes('✅'));
-  check('场景 5：本月达标、上月无数据 → ⚠️ 1/2', expansionVerdict(true, undefined, true, []).includes('⚠️'));
-  check('场景 5：本月达标、上月未达标 → ⚠️ 1/2', expansionVerdict(true, false, false, []).includes('⚠️'));
-  check('场景 5：本月未达标 → ❌ 且列出未达标项号', expansionVerdict(false, true, false, [{ no: 3, ok: false }, { no: 4, ok: false }]).match(/❌.*3\+4/));
-}
-
-// 场景 6：门禁噪声返工拆分（2026-10-08 selfmeasure-and-modularize）
-// 动机：本仓质量门连续两月红（55% / 61% < 90%），根因是门禁噪声与设计返工同判第 3 项 → 指标不指示改进方向。
-{
-  check('场景 6：parseResult 识别门禁噪声档（kind=rework-noise；2026-10-08 rework-attribution-split 更正：rework 分量归 0——噪声不是设计返工；外部行为 metrics/第 3 项不变）',
-    parseResult('返工×2（门禁噪声）').kind === 'rework-noise' && parseResult('返工×2（门禁噪声）').reworkNoise === 2
-    && parseResult('返工×2（门禁噪声）').rework === 0, JSON.stringify(parseResult('返工×2（门禁噪声）')));
-  check('场景 6：存量四档解析逐条不变（向后兼容钉子）',
-    parseResult('一次通过').kind === 'pass' && parseResult('返工×2').kind === 'rework'
-    && parseResult('返工×2').rework === 2 && parseResult('主兜底').kind === 'fallback'
-    && parseResult('返工待修').kind === 'pending' && parseResult('乱填').kind === 'unknown');
-  check('场景 6：新旧形态互不误吞（$ 锚定；半角括号不认）',
-    parseResult('返工×1（门禁噪声）').kind !== 'rework' && parseResult('返工×1(门禁噪声)').kind === 'unknown');
-
-  const rows = [
-    { scope: '自做', result: '返工×2（门禁噪声）' },   // 噪声
-    { scope: '自做', result: '返工×3（门禁噪声）' },   // 噪声
-    { scope: '自做', result: '一次通过' },
-  ];
-  const m = metrics(rows);
-  check('场景 6：双列累计分离（设计返工 0 / 噪声 5）',
-    m.reworkSum === 0 && m.reworkNoiseSum === 5, JSON.stringify({ reworkSum: m.reworkSum, noise: m.reworkNoiseSum }));
-  check('场景 6：平均返工仍含噪声（快照行口径不变，delegations.md 表结构零改动）',
-    Math.abs(m.avgRework - 5 / 3) < 1e-9, String(m.avgRework));
-  const g = gateMonth(m);
-  const i3 = g.items.find((i) => i.no === 3);
-  check('场景 6：扩容门第 3 项只对设计返工判 ok=true（噪声不计入）', i3.ok === true, JSON.stringify(i3));
-  check('场景 6：噪声数字在描述里显式可见（不隐藏）', /门禁噪声返工 5 次已剥离单列/.test(i3.desc), i3.desc);
-
-  // 反向：设计返工不得因存在噪声档而被放过
-  const mixed = metrics([{ scope: '自做', result: '返工×1' }, { scope: '自做', result: '返工×1（门禁噪声）' }]);
-  check('场景 6：反例——设计返工 1 + 噪声 1 → 门 3 ❌（噪声标签不能洗白设计返工）',
-    gateMonth(mixed).items.find((i) => i.no === 3).ok === false, JSON.stringify(gateMonth(mixed).items[2]));
-}
-
-// 场景 7：行内双值归因（2026-10-08 rework-attribution-split）
-// 动机：存量逐行审计（29 行含返工）证实单值格式无法表达混合归因——一行只记一个返工总数时，
-// 「1 次设计 + 1 次噪声」只能整行倒向某一侧。行内双值是作者写入时确定已知的归因事实，不反推。
-{
-  const mixed = parseResult('返工×1 + 门禁噪声×1');
-  check('场景 7：行内双值解析出两个分量（kind=rework-mixed）',
-    mixed.kind === 'rework-mixed' && mixed.rework === 1 && mixed.reworkNoise === 1, JSON.stringify(mixed));
-  check('场景 7：宽容空格（无空格变体亦可解析）',
-    parseResult('返工×2+门禁噪声×3').rework === 2 && parseResult('返工×2+门禁噪声×3').reworkNoise === 3);
-  check('场景 7：四个返工格式互不误吞',
-    parseResult('返工×2').kind === 'rework' && parseResult('返工×2').reworkNoise === 0
-    && parseResult('返工×2（门禁噪声）').kind === 'rework-noise'
-    && parseResult('返工×2（门禁噪声）').rework === 0
-    && parseResult('一次通过').kind === 'pass' && parseResult('乱填').kind === 'unknown');
-  check('场景 7：非法数字落 unknown（记录本身有问题，不混进待修）',
-    parseResult('返工×a + 门禁噪声×1').kind === 'unknown');
-
-  // 不变量①：任务总数不虚增——一行仍是一个任务，两个数字不拆成两个任务
-  const rows = [
-    { scope: '自做', result: '返工×1 + 门禁噪声×2' },
-    { scope: '自做', result: '返工×1 + 门禁噪声×2' },
-    { scope: '自做', result: '一次通过' },
-  ];
-  const m = metrics(rows);
-  check('场景 7：不变量①——total 按行计 1（行内双值不虚增任务数 / 不抬高 passRate 分母）',
-    m.total === 3, `total=${m.total}`);
-  check('场景 7：双列准确累计（设计返工 2 / 门禁噪声 4）',
-    m.reworkSum === 2 && m.reworkNoiseSum === 4, JSON.stringify({ r: m.reworkSum, n: m.reworkNoiseSum }));
-  check('场景 7：一次通过率分母不变（1/3，与若拆成两行的结果不同——这是选行内双值而非拆行的理由）',
-    Math.abs(m.passRate - 1 / 3) < 1e-9, String(m.passRate));
-
-  // 混合行的门 3 判定：设计返工 0 + 噪声 4 → ok；设计返工 2 → ❌
-  const onlyNoise = metrics([{ scope: '自做', result: '返工×0 + 门禁噪声×3' }, { scope: '自做', result: '一次通过' }]);
-  const i3ok = gateMonth(onlyNoise).items.find((i) => i.no === 3);
-  check('场景 7：纯噪声混合行 → 门 3 ✅ 且描述带噪声数',
-    i3ok.ok === true && /门禁噪声返工 3 次已剥离单列/.test(i3ok.desc), JSON.stringify(i3ok));
-  const withDesign = gateMonth(m).items.find((i) => i.no === 3);
-  check('场景 7：含设计返工的混合行 → 门 3 ❌（噪声分量不能洗白设计分量）',
-    withDesign.ok === false, JSON.stringify(withDesign));
-}
-
-// 场景 8：产出接受率（2026-10-12 merge-accept-rate）
-// 动机（METR 2026-03）：agent 生成的 SWE-bench 通过 PR，维护者合并判定比自动评分低约 24 个百分点、
-// 约一半不会被合入——「自动门全绿」与「人愿意合」是两个维度，混列必被前者盖过后者。
-{
-  check('场景 8：parseVerdict 三档 + 留空/乱填落 null（未记录 ≠ 未合入）',
-    parseVerdict('合入') === 'accepted' && parseVerdict('返工后合入') === 'accepted-after-rework'
-    && parseVerdict('未合入') === 'rejected'
-    && parseVerdict('') === null && parseVerdict(undefined) === null && parseVerdict('已上线') === null,
-    JSON.stringify([parseVerdict('合入'), parseVerdict('返工后合入'), parseVerdict('未合入'), parseVerdict(''), parseVerdict('已上线')]));
-
-  // 反例钉子：一次通过率 100% 但接受率低 —— 这正是混列会掩盖的形态
-  const rows = [
-    ...Array.from({ length: 8 }, () => ({ scope: '自做', result: '一次通过', verdict: '合入' })),
-    { scope: '自做', result: '一次通过', verdict: '未合入' },
-    { scope: '自做', result: '一次通过', verdict: '返工后合入' },
-    { scope: '自做', result: '一次通过' }, // 留空 = 未记录，不入分母
-  ];
-  const m = metrics(rows);
-  check('场景 8：一次通过率 100% 但接受率 90%（8 合入 + 1 返工后合入 / 10 已记录）',
-    Math.abs(m.passRate - 1) < 1e-9 && Math.abs(m.acceptRate - 0.9) < 1e-9,
-    JSON.stringify({ passRate: m.passRate, acceptRate: m.acceptRate }));
-  check('场景 8：留空行不入分母（verdictRecorded=10 而非 11）',
-    m.verdictRecorded === 10 && m.accepted === 9 && m.rejected === 1, JSON.stringify(m));
-  check('场景 8：接受率不影响任何扩容门项（观测项非门槛项——METR 缺口不靠加门堵）',
-    gateMonth(m).items.length === 6, JSON.stringify(gateMonth(m).items.map((i) => i.no)));
-
-  // 样本护栏：不足 ACCEPT_MIN_SAMPLE 条不出率（给小样本比率 = 给噪声开门）
-  check('场景 8：护栏阈值 = 5 且与脚本常量同源（文档写死一处会漂）', ACCEPT_MIN_SAMPLE === 5, String(ACCEPT_MIN_SAMPLE));
-  const tiny = metrics([{ scope: '自做', result: '一次通过', verdict: '未合入' }]);
-  check('场景 8：样本 <5 → acceptRate=null 且 fmtAccept 注明样本数',
-    tiny.acceptRate === null && fmtAccept(tiny).includes(`样本 1/${ACCEPT_MIN_SAMPLE}`), `${String(tiny.acceptRate)} | ${fmtAccept(tiny)}`);
-  check('场景 8：零记录 → fmtAccept 显式说明而非打 0%',
-    fmtAccept(metrics([{ scope: '自做', result: '一次通过' }])).includes('零记录'), fmtAccept(metrics([{ scope: '自做', result: '一次通过' }])));
-
-  // 存量兼容：无 verdict 字段的行（旧行对象）零影响
-  const legacy = metrics([{ scope: '自做', result: '一次通过' }, { scope: '委派', result: '返工×1' }]);
-  check('场景 8：存量行（无 verdict 键）零影响——verdictRecorded=0 / 一次通过率与旧口径一致',
-    legacy.verdictRecorded === 0 && legacy.total === 2 && Math.abs(legacy.passRate - 0.5) < 1e-9,
-    JSON.stringify(legacy));
-}
-
-// 场景 9：表结构兼容 —— 末列缺省不误判（存量表不要求补列）
-{
-  const root = mkfix([
-    '# 量化证据台账（fixture）',
-    '',
-    '## 委派结果',
-    '',
-    '| 日期 | 被委派方(模型) | 任务一句话 | 结果 | 备注 |',
-    '|------|----------------|------------|------|------|',
-    '| 2026-09-23 | executor(子代理) | 旧表结构行（无合入结论列） | 一次通过 | fixture |',
-    '',
-  ].join('\n'));
-  const r = runAgg(root);
-  check('场景 9：存量五列表 → exit 0 且正常入账', r.status === 0 && /有效任务 1（/.test(r.stdout), `exit=${r.status}\n${r.stdout}${r.stderr}`);
-  check('场景 9：合入结论零记录 → 接受率显示「零记录」', r.stdout.includes('零记录'), r.stdout);
-  fs.rmSync(root, { recursive: true, force: true });
-
-  const root2 = mkfix([
-    '# 量化证据台账（fixture）',
-    '',
-    '## 委派结果',
-    '',
-    '| 日期 | 被委派方(模型) | 任务一句话 | 结果 | 备注 | 合入结论 |',
-    '|------|----------------|------------|------|------|----------|',
-    ...Array.from({ length: 8 }, (_, i) => `| 2026-10-0${i + 1} | executor(子代理) | 新表结构行 | 一次通过 | fixture | 合入 |`),
-    '| 2026-10-09 | executor(子代理) | 新表结构行 | 一次通过 | fixture | 未合入 |',
-    '| 2026-10-10 | executor(子代理) | 新表结构行 | 一次通过 | fixture | 返工后合入 |',
-    '',
-  ].join('\n'));
-  const r2 = runAgg(root2);
-  check('场景 9：六列表 → 末列正确解析（已记录 10 / 合入 9 / 未合入 1）',
-    r2.status === 0 && /已记录合入结论 10 行｜合入 9｜未合入 1/.test(r2.stdout), `exit=${r2.status}\n${r2.stdout}${r2.stderr}`);
-  check('场景 9：快照行含接受率列（90%（9/10）——样本过护栏才出率）',
-    /\|\s*90%（9\/10）\s*\|/.test(r2.stdout), r2.stdout);
-  fs.rmSync(root2, { 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/agg-gate-stats.mjs

@@ -1,113 +0,0 @@
-// agg-gate-stats.mjs — 门禁 ROI 聚合（2026-10-08 gate-roi-metrics）
-// 读 .agents/cache/gate-stats.jsonl（check-loop --gate-stats 落的运行时数据）→ 按检查 ID 聚合
-//   运行次数 / 命中次数 / 拦截数 / 警告数 / 平均耗时 → 输出表 + 两类决策依据：
-//   ① 噪声率 top N（警告数 ÷ 命中次数，降序）——该收窄或该修的候选；
-//   ② 死检查（声明了但从未命中）——该拆或该降级的候选。
-//
-// **为什么需要它**（本件存在的理由）：本仓门禁 16→20 项期间，2026-10 一次通过率 61%→56%——
-// 门禁数与质量指标负相关，但此前无任何数据能回答「该加门还是该拆门」（metrics/DASHBOARD 全部指标
-// 100% 指向产出物、0 条指向门禁自身）。加门是焦虑驱动的唯一理性反应，因为拆门没有依据。
-//
-// 耗时口径**含子进程时间**（检查 11 调两个生成器 --check、检查 13 调 rule-budget.mjs）——
-// 门禁真实成本本就要含子进程，不做剔除；输出中显式标注防误读为「纯计算耗时」。
-// 坏行容忍跳过（与 confirmations.jsonl / delegations 台账同容错口径）。
-// 用法：node .agents/scripts/agg-gate-stats.mjs [--days 30]
-// 测试：node templates/_agents/scripts/agg-gate-stats.test.mjs
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-const ROOT = process.env.CHECK_LOOP_ROOT || path.resolve(SCRIPT_DIR, '..', '..');
-const STATS_FILE = path.join(ROOT, '.agents', 'cache', 'gate-stats.jsonl');
-
-// readRows：读 jsonl，坏行跳过不抛
-export function readRows(file = STATS_FILE) {
-  let text = '';
-  try { text = fs.readFileSync(file, 'utf8'); } catch { return []; }
-  const out = [];
-  for (const line of text.split('\n')) {
-    if (!line.trim()) continue;
-    try {
-      const e = JSON.parse(line);
-      if (e && Array.isArray(e.segs)) out.push(e);
-    } catch { /* 坏行跳过 */ }
-  }
-  return out;
-}
-
-// aggregate：按 id 聚合（pure，供测试直测）。days = 统计窗口（天），null = 全量。
-//   runs  = 该段被记录到的运行次数；hits = 至少命中一次（warns+blocks>0）的运行次数；
-//   warns / blocks = 累计条数；msSum / avgMs = 累计与平均耗时。
-export function aggregate(rows, now = Date.now(), days = null) {
-  const cutoff = days ? now - days * 86400000 : null;
-  const by = new Map();
-  let runs = 0;
-  for (const r of rows) {
-    if (cutoff) {
-      const t = Date.parse(r.ts || '');
-      if (!Number.isFinite(t) || t < cutoff) continue;
-    }
-    runs++;
-    for (const s of r.segs || []) {
-      if (!s || !s.id) continue;
-      if (!by.has(s.id)) by.set(s.id, { id: s.id, label: s.label || '', runs: 0, hits: 0, warns: 0, blocks: 0, msSum: 0 });
-      const a = by.get(s.id);
-      a.runs++;
-      a.label = s.label || a.label;
-      a.warns += Number(s.warns) || 0;
-      a.blocks += Number(s.blocks) || 0;
-      a.msSum += Number(s.ms) || 0;
-      if ((Number(s.warns) || 0) + (Number(s.blocks) || 0) > 0) a.hits++;
-    }
-  }
-  const list = [...by.values()].map((a) => ({
-    ...a,
-    avgMs: a.runs ? Math.round(a.msSum / a.runs) : 0,
-    noiseRate: a.hits ? a.warns / a.hits : 0, // 每次命中的平均警告条数（0 = 从不产噪声）
-  }));
-  list.sort((x, y) => y.msSum - x.msSum); // 默认按累计耗时降序——成本视角优先
-  const noiseTop = [...list].filter((a) => a.warns > 0).sort((x, y) => y.noiseRate - x.noiseRate);
-  const dead = list.filter((a) => a.hits === 0);
-  const costTotal = list.reduce((a, s) => a + s.msSum, 0);
-  return { runs, list, noiseTop, dead, costTotal };
-}
-
-function fmtMs(ms) {
-  return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
-}
-
-function main() {
-  const i = process.argv.indexOf('--days');
-  const days = i >= 0 ? Number(process.argv[i + 1]) : 30;
-  const rows = readRows();
-  const { runs, list, noiseTop, dead, costTotal } = aggregate(rows, Date.now(), Number.isFinite(days) ? days : null);
-
-  if (!runs || !list.length) {
-    console.log('门禁 ROI：未采集——跑 `node .agents/scripts/check-loop.mjs --all --gate-stats` 后重试（--all 全段成本面；2026-10-13 分道后裸跑只记硬门段）');
-    console.log('（数据落 .agents/cache/gate-stats.jsonl，该目录已 gitignore；首次采集后本表才有内容）');
-    return;
-  }
-
-  console.log(`# 门禁 ROI 聚合（窗口 ${days} 天 / 有效样本 ${runs} 次运行）\n`);
-  console.log('耗时口径**含子进程时间**（检查 11 调生成器 --check、检查 13 调 rule-budget.mjs）——门禁真实成本，不做剔除。\n');
-  console.log('| 检查 | 名称 | 命中/运行 | 拦截 | 警告 | 累计耗时 | 均耗时 | 每次命中警告数 |');
-  console.log('|------|------|-----------|------|------|----------|--------|----------------|');
-  for (const a of list) {
-    console.log(`| ${a.id} | ${a.label} | ${a.hits}/${a.runs} | ${a.blocks} | ${a.warns} | ${fmtMs(a.msSum)} | ${fmtMs(a.avgMs)} | ${a.noiseRate.toFixed(1)} |`);
-  }
-  console.log(`\n累计门禁耗时 ${fmtMs(costTotal)}（${runs} 次运行，均 ${fmtMs(Math.round(costTotal / runs))}/次）`);
-
-  console.log(`\n## ① 噪声率 top（警告数 ÷ 命中次数）——收窄或修的候选`);
-  if (noiseTop.length) for (const a of noiseTop) console.log(`  检查 ${a.id} ${a.label}：${a.noiseRate.toFixed(1)} 条/次命中（累计 ${a.warns} 条警告）`);
-  else console.log('  （无段产出过警告）');
-
-  console.log(`\n## ② 死检查（声明了但从未命中）——拆或降级的候选`);
-  if (dead.length) for (const a of dead) console.log(`  检查 ${a.id} ${a.label}：${a.runs} 次运行零命中，累计耗时 ${fmtMs(a.msSum)}`);
-  else console.log('  （每段都至少命中过一次）');
-
-  if (runs < 5) console.log(`\n⚠️ 样本仅 ${runs} 次运行——**结论待样本积累**（建议 ≥30 次 / ≥30 天后再据此改判据；此刻只作线索不作决策依据）`);
-}
-
-const isMain = process.argv[1] && process.argv[1].replace(/\\/g, '/').endsWith('agg-gate-stats.mjs');
-if (isMain) main();

package/templates/_agents/scripts/agg-gate-stats.test.mjs

@@ -1,95 +0,0 @@
-// agg-gate-stats.test.mjs — 门禁 ROI 聚合测试（2026-10-08 gate-roi-metrics）
-// 覆盖：聚合数学 / 窗口过滤 / 坏行容错 / 死检查识别 / 噪声率排序 / 按耗时降序 / 空数据降级。
-// 用法：node templates/_agents/scripts/agg-gate-stats.test.mjs
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { pathToFileURL, fileURLToPath } from 'node:url';
-
-const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-const { aggregate, readRows } =
-  await import(pathToFileURL(path.join(SCRIPT_DIR, 'agg-gate-stats.mjs')).href);
-
-let pass = 0, fail = 0;
-const check = (name, cond, detail = '') => {
-  if (cond) { pass++; console.log(`PASS ${name}`); }
-  else { fail++; console.log(`FAIL ${name}${detail ? `——${detail}` : ''}`); }
-};
-
-const NOW = Date.parse('2026-10-08T00:00:00.000Z');
-const run = (ts, segs) => ({ ts, segs });
-const seg = (id, warns, blocks, ms, label = `检查${id}`) => ({ id, label, warns, blocks, ms });
-
-// ---- 1. 聚合数学 ----
-{
-  const rows = [
-    run('2026-10-07T00:00:00.000Z', [seg('8', 0, 0, 10000, '验收'), seg('4', 2, 0, 20, '引用')]),
-    run('2026-10-08T00:00:00.000Z', [seg('8', 0, 0, 12000, '验收'), seg('4', 1, 0, 30, '引用'), seg('3', 0, 1, 5, 'incidents')]),
-  ];
-  const a = aggregate(rows, NOW, null);
-  check('聚合：runs 计 2', a.runs === 2, `runs=${a.runs}`);
-  const s8 = a.list.find((x) => x.id === '8');
-  check('聚合：按 id 累计（检查 8 = 2 次运行 / 均耗时 11000ms）',
-    s8.runs === 2 && s8.avgMs === 11000 && s8.msSum === 22000, JSON.stringify(s8));
-  const s4 = a.list.find((x) => x.id === '4');
-  check('聚合：警告累计与命中次数（检查 4 = 命中 2 / 警告 3 / 噪声率 1.5）',
-    s4.hits === 2 && s4.warns === 3 && s4.noiseRate === 1.5, JSON.stringify(s4));
-  const s3 = a.list.find((x) => x.id === '3');
-  check('聚合：blocks 计入命中（检查 3 拦截 1 次 → hits=1）', s3.hits === 1 && s3.blocks === 1, JSON.stringify(s3));
-  check('聚合：默认按累计耗时降序（成本视角优先）', a.list[0].id === '8', a.list.map((x) => x.id).join(','));
-  check('聚合：costTotal = 各段 ms 之和', a.costTotal === 22000 + 50 + 5, String(a.costTotal));
-}
-
-// ---- 2. 窗口过滤 ----
-{
-  const rows = [
-    run('2026-01-01T00:00:00.000Z', [seg('8', 0, 0, 99999, '验收')]),
-    run('2026-10-07T00:00:00.000Z', [seg('8', 0, 0, 1000, '验收')]),
-  ];
-  const a = aggregate(rows, NOW, 30);
-  check('窗口：30 天外的运行被排除（runs=1，耗时不含 99999）',
-    a.runs === 1 && a.costTotal === 1000, `runs=${a.runs} cost=${a.costTotal}`);
-  const b = aggregate(rows, NOW, null);
-  check('窗口：days=null 取全量（runs=2）', b.runs === 2, `runs=${b.runs}`);
-}
-
-// ---- 3. 死检查与噪声率排序 ----
-{
-  const rows = [
-    run('2026-10-07T00:00:00.000Z', [
-      seg('8', 0, 0, 5000, '验收'),          // 贵但从不命中 → 死检查
-      seg('17', 0, 0, 4000, '发版树'),       // 贵且从不命中 → 死检查
-      seg('11', 5, 0, 100, '漂移'),          // 高噪声
-      seg('4', 1, 0, 10, '引用'),            // 低噪声
-    ]),
-  ];
-  const a = aggregate(rows, NOW, null);
-  const deadIds = a.dead.map((x) => x.id).sort();
-  check('死检查：识别「声明了但从未命中」（8/17），且按耗时排序（8 在前）',
-    deadIds.join(',') === '17,8' || deadIds.join(',') === '8,17', deadIds.join(','));
-  check('噪声率 top：11（5.0）> 4（1.0）', a.noiseTop.map((x) => x.id).join(',') === '11,4', a.noiseTop.map((x) => x.id).join(','));
-  check('死检查不进 noiseTop（从不命中 ≠ 高噪声）', !a.noiseTop.some((x) => x.id === '8'));
-}
-
-// ---- 4. 坏行容错 + 空数据 ----
-{
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'fk-gatestats-'));
-  const f = path.join(root, 'gate-stats.jsonl');
-  fs.writeFileSync(f, [
-    'not-json-bad-line',
-    JSON.stringify(run('2026-10-07T00:00:00.000Z', [seg('8', 0, 0, 100)])),
-    '',
-    JSON.stringify({ ts: '2026-10-07T00:00:00.000Z' }), // 无 segs
-  ].join('\n') + '\n');
-  const rows = readRows(f);
-  check('坏行容错：非 JSON / 无 segs 的行跳过不抛（其余 1 行入账）', rows.length === 1 && rows[0].segs.length === 1);
-  check('坏行容错：文件不存在 → 空数组不抛', readRows(path.join(root, 'nope.jsonl')).length === 0);
-  check('空数据降级：aggregate 返回零值而非抛', aggregate([], NOW, 30).runs === 0 && aggregate([], NOW, 30).list.length === 0);
-  // 段体缺字段容错
-  const r2 = aggregate([{ ts: '2026-10-07T00:00:00.000Z', segs: [{ id: '8' }, null, { warns: 1 }] }], NOW, null);
-  check('段体容错：缺 ms / null 段 / 缺 id 段不抛', r2.runs === 1 && r2.list.find((x) => x.id === '8').avgMs === 0);
-  fs.rmSync(root, { recursive: true, force: true });
-}
-
-console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
-process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/agg-judgments.mjs

@@ -1,156 +0,0 @@
-#!/usr/bin/env node
-// agg-judgments.mjs — check-loop 判定流水月度聚合（2026-10-11 judgment-ledger）
-// 用法：node .agents/scripts/agg-judgments.mjs [--month=YYYY-MM]
-//       node .agents/scripts/agg-judgments.mjs --retire-candidates [--months=6]
-// 源：.agents/judgments.jsonl（check-loop.mjs 每次真实运行追加一行，本地 gitignore；
-//     缺文件 = 尚无运行记录，提示后 exit 0——与 delegations 台账「必在」不同，这是渐积数据）。
-// 消费：mechanism-registry 月度对账（.agents/mechanism-registry.md「触发统计口径」列的 WARN/BLOCK 计数）
-//     与 advisory→hard 升格 / 退役判定的直接查账面——替代原「人工 grep check-loop 输出」。
-// --retire-candidates（2026-10-15 减重手段① 自源仓回灌，规则的死亡机制）：列出「连续 N 个有数据月
-//     零命中（WARN+BLOCK 全为 0）」的规则作为退役候选——月度对账时按 mechanism-registry「退役判据」
-//     列逐条裁决（安全主干/级别闭环主干等「不退役」行除外；「且 X 停滞」类附加条件由人判）。
-//     台账不足 N 个数据月 → 数据不充分，不产候选（年轻遥测不得制造假候选）。判定口径 = 尾部
-//     N 个「有运行的月」（非日历月——遥测断档的月不算零命中，防漏跑误判退役）。
-// 测试：node .agents/scripts/agg-judgments.test.mjs（纯函数 aggFromRows / retireCandidates 进程内断言）
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-const ROOT = path.resolve(SCRIPT_DIR, '..', '..');
-const LEDGER = path.join(ROOT, '.agents', 'judgments.jsonl');
-
-const argMonth = (process.argv.find((a) => a.startsWith('--month=')) || '').split('=')[1] || null;
-
-// aggFromRows(rows, month)：按月×规则×级别聚合。rows = 已解析的台账行数组；
-// month = 'YYYY-MM' 过滤（null = 全部）。输出 { byMonth: { 'YYYY-MM': { runs, rules: { rule: { WARN, BLOCK } } } } }。
-export function aggFromRows(rows, month = null) {
-  const byMonth = {};
-  for (const row of rows || []) {
-    if (typeof row.ts !== 'string' || !/^\d{4}-\d{2}/.test(row.ts)) continue;
-    const ym = row.ts.slice(0, 7);
-    if (month && ym !== month) continue;
-    const b = (byMonth[ym] ||= { runs: 0, rules: {} });
-    b.runs++;
-    for (const r of Array.isArray(row.rules) ? row.rules : []) {
-      if (!r || typeof r.rule !== 'string') continue;
-      const cell = (b.rules[r.rule] ||= { WARN: 0, BLOCK: 0 });
-      if (r.level === 'WARN') cell.WARN += r.count || 0;
-      else if (r.level === 'BLOCK') cell.BLOCK += r.count || 0;
-    }
-  }
-  return { byMonth };
-}
-
-function readRows() {
-  if (!fs.existsSync(LEDGER)) return null;
-  const rows = [];
-  let bad = 0;
-  for (const line of fs.readFileSync(LEDGER, 'utf8').split(/\r?\n/)) {
-    if (!line.trim()) continue;
-    try {
-      rows.push(JSON.parse(line));
-    } catch {
-      bad++;
-    }
-  }
-  return { rows, bad };
-}
-
-// retireCandidates(rows, windowMonths)：退役候选 = 「尾部 windowMonths 个有数据月零命中」的规则。
-// 口径：数据月 = 该月至少一次运行（断档月不参与，不按零命中计）；候选须在全历史出现过（含只剩
-//   零命中的月）且尾部窗口内 WARN+BLOCK 全 0。输出按全历史命中数升序（最冷门在前）。
-//   rows 不足 windowMonths 个数据月 → { sufficient:false }——年轻遥测不产候选。
-export function retireCandidates(rows, windowMonths = 6) {
-  const { byMonth } = aggFromRows(rows);
-  const months = Object.keys(byMonth).sort();
-  if (months.length < windowMonths) {
-    return { sufficient: false, dataMonths: months.length, windowMonths, candidates: [], recentHits: [] };
-  }
-  const trailing = new Set(months.slice(-windowMonths));
-  const allRules = new Set();
-  for (const ym of months) for (const r of Object.keys(byMonth[ym].rules)) allRules.add(r);
-  const candidates = [];
-  const recentHits = [];
-  for (const rule of allRules) {
-    let total = 0;
-    let lastHit = null;
-    let inWindow = 0;
-    for (const ym of months) {
-      const cell = byMonth[ym].rules[rule];
-      const n = cell ? (cell.WARN + cell.BLOCK) : 0;
-      total += n;
-      if (n > 0) {
-        lastHit = ym;
-        if (trailing.has(ym)) inWindow += n;
-      }
-    }
-    const row = { rule, total, lastHit };
-    if (inWindow === 0) candidates.push(row);
-    else recentHits.push(row);
-  }
-  candidates.sort((a, b) => a.total - b.total || a.rule.localeCompare(b.rule));
-  recentHits.sort((a, b) => b.total - a.total || a.rule.localeCompare(b.rule));
-  return {
-    sufficient: true,
-    dataMonths: months.length,
-    windowMonths,
-    windowFrom: months.slice(-windowMonths)[0],
-    windowTo: months[months.length - 1],
-    candidates,
-    recentHits,
-  };
-}
-
-function printRetireCandidates(read) {
-  const wArg = Number((process.argv.find((a) => a.startsWith('--months=')) || '').split('=')[1]);
-  const windowMonths = Number.isFinite(wArg) && wArg >= 1 ? Math.floor(wArg) : 6;
-  const r = retireCandidates(read.rows, windowMonths);
-  if (!r.sufficient) {
-    console.log(`agg-judgments: 退役候选窗口 ${windowMonths} 个月——数据月仅 ${r.dataMonths} 个（台账 ${read.rows.length} 行），数据不充分不产候选。继续积累运行记录。`);
-    return;
-  }
-  console.log(`退役候选（零命中窗口 ${r.windowFrom}..${r.windowTo}，共 ${r.windowMonths} 个数据月）——仅机械筛查，裁决走 mechanism-registry「退役判据」列（「不退役」主干除外）：`);
-  if (!r.candidates.length) {
-    console.log('  （无候选——尾部窗口内所有规则均有命中）');
-  }
-  for (const c of r.candidates) {
-    console.log(`  候选  ${c.rule.padEnd(24)} 全历史命中 ${String(c.total).padStart(4)}  末次命中 ${c.lastHit || '—'}`);
-  }
-  for (const c of r.recentHits) {
-    console.log(`  在役  ${c.rule.padEnd(24)} 全历史命中 ${String(c.total).padStart(4)}  末次命中 ${c.lastHit}`);
-  }
-  if (read.bad) console.error(`agg-judgments: 跳过坏行 ${read.bad}（JSON 解析失败，不中断聚合）`);
-}
-
-function main() {
-  const read = readRows();
-  if (!read) {
-    console.error(`agg-judgments: ${path.relative(ROOT, LEDGER)} 不存在——尚无运行记录（check-loop 真实运行一次即有一行）`);
-    process.exit(0);
-  }
-  if (process.argv.includes('--retire-candidates')) {
-    printRetireCandidates(read);
-    return;
-  }
-  const { byMonth } = aggFromRows(read.rows, argMonth);
-  const months = Object.keys(byMonth).sort();
-  if (!months.length) {
-    console.log(`agg-judgments: ${argMonth || '全部月份'} 无记录（台账共 ${read.rows.length} 行）`);
-    return;
-  }
-  for (const ym of months) {
-    const b = byMonth[ym];
-    console.log(`📅 ${ym}｜运行 ${b.runs} 次`);
-    const rules = Object.keys(b.rules).sort();
-    if (!rules.length) { console.log('    （无规则判定）'); continue; }
-    for (const rule of rules) {
-      const { WARN, BLOCK } = b.rules[rule];
-      console.log(`    ${rule.padEnd(24)} WARN×${WARN}  BLOCK×${BLOCK}`);
-    }
-  }
-  if (read.bad) console.error(`agg-judgments: 跳过坏行 ${read.bad}（JSON 解析失败，不中断聚合）`);
-}
-
-const isMain = process.argv[1] && process.argv[1].endsWith('agg-judgments.mjs');
-if (isMain) main();