agentic-flow-kit 1.8.0 → 1.8.2

package/templates/_agents/scripts/mechanism-retire-watch.mjs

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+// mechanism-retire-watch.mjs — 机制退役催办自动化（2026-10-14 源仓 L5 自举接线 1b/1c；2026-10-16 回灌 kit）
+// 用途：读机制台账「退役阈值/最近触发」+ judgments 聚合，阈值触达自动产动作项——让机制的「死」与「生」同样强制。
+//   自动化的是**感知/排序**（谁触达了阈值），处置仍人放行（改状态/删代码走人 + 一进一出）。
+// 口径单源：.agents/mechanism-registry.md 列序（机制|门禁位置|触发统计口径|退役阈值|最近触发|状态|处置期限）
+//   与 .agents/judgments.jsonl（check-loop 每次真实运行落账，per-rule WARN/BLOCK 计数）。
+// 判定（确定性，无 LLM）：
+//   ① 现役行 + 阈值形态「连续 N 月 = 0」+ 口径列含「规则名」→ 以有数据的末月为终点取 N 个日历月，缺月不算零命中，全 0 即触达 → 动作项。
+//   ② 待退役行 + 处置期限为日期且已过 → 动作项（逾期）。
+//   ③ 其余阈值形态（不退役主干 / 使用率型 / 数据源型）→ 非自动可判，仅计数，交人工月判。
+//   缺月不算零命中（2026-10-15 源仓修正）：漏跑数月后陈旧月份不得凑成「连续」——日历窗口内有缺月即
+//   交人工判，不产触达动作（与 agg-judgments --retire-candidates 的「数据月」口径互补：彼按有数据月，
+//   此按日历连续）。
+// 退出码恒 0（催办报告不该阻断调度器；测量失败打 [ERROR] 行）。
+// 用法：node .agents/scripts/mechanism-retire-watch.mjs [--json] [--root <仓库根>] [--now <ISO 日期>]
+// 测试：node .agents/scripts/mechanism-retire-watch.test.mjs（纯函数 evaluate 进程内断言）
+// kit 适配（源仓→kit）：台账路径 `.agents/config/mechanism-registry.md` → kit 平铺
+//   `.agents/mechanism-registry.md`（同 check-registry.mjs 检查 22 口径）。
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { aggFromRows } from './agg-judgments.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 asJson = argv.includes('--json');
+const ROOT = path.resolve(argOf('--root') || path.join(SCRIPT_DIR, '..', '..'));
+const NOW = argOf('--now') ? new Date(argOf('--now')) : new Date();
+
+const REGISTRY_REL = path.join('.agents', 'mechanism-registry.md');
+const LEDGER_REL = path.join('.agents', 'judgments.jsonl');
+
+// parseRegistry(text)：7 列管道表 → 行对象数组。列序固定（check-loop §22 按此解析）。
+export function parseRegistry(text) {
+  const rows = [];
+  for (const l of String(text).split(/\r?\n/)) {
+    if (!/^\|/.test(l)) continue;
+    if (/^\|[\s:|-]+\|?\s*$/.test(l)) continue; // 分隔行
+    const cells = l.split('|').slice(1, -1).map((c) => c.trim());
+    if (cells.length !== 7) continue;
+    if (cells[0] === '机制') continue; // 表头
+    const [name, gate, criterion, threshold, lastTrigger, status, deadline] = cells;
+    rows.push({ name, gate, criterion, threshold, lastTrigger, status, deadline });
+  }
+  return rows;
+}
+
+// ruleNamesOf(criterion)：从「触发统计口径」列抽「」内规则名（/ 分隔）。无「」= 无法自动映射。
+export function ruleNamesOf(criterion) {
+  const names = [];
+  for (const m of String(criterion).matchAll(/「([^」]+)」/g)) {
+    for (const n of m[1].split('/')) {
+      const t = n.trim();
+      if (t) names.push(t);
+    }
+  }
+  return names;
+}
+
+// zeroMonthsOf(threshold)：阈值形态「连续 N 月 = 0」→ N；否则 null（非自动可判）。
+export function zeroMonthsOf(threshold) {
+  const m = String(threshold).match(/连续\s*(\d+)\s*月\s*=\s*0/);
+  return m ? Number(m[1]) : null;
+}
+
+// localDay(d)：本地日历日 YYYY-MM-DD。期限比较不用 UTC 零点，避免北京时 08:00 后把当天判逾期。
+export function localDay(d) {
+  const dt = d instanceof Date ? d : new Date(d);
+  const m = String(dt.getMonth() + 1).padStart(2, '0');
+  const day = String(dt.getDate()).padStart(2, '0');
+  return `${dt.getFullYear()}-${m}-${day}`;
+}
+
+// calendarWindow(endYm, n)：以有数据的末月为终点，向前取 n 个日历月（含终点）。
+export function calendarWindow(endYm, n) {
+  const [y, m] = String(endYm).split('-').map(Number);
+  const out = [];
+  for (let i = n - 1; i >= 0; i--) {
+    const d = new Date(Date.UTC(y, m - 1 - i, 1));
+    out.push(`${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}`);
+  }
+  return out;
+}
+
+// evaluate(registryRows, judgmentRows, now)：纯函数——产动作项。测试进程内断言。
+export function evaluate(registryRows, judgmentRows, now = new Date()) {
+  const { byMonth } = aggFromRows(judgmentRows || [], null);
+  const months = Object.keys(byMonth).sort(); // 升序
+  const actions = [];
+  const notAuto = [];
+
+  for (const r of registryRows) {
+    if (r.status === '已退役') continue;
+
+    if (r.status === '待退役') {
+      const d = String(r.deadline).match(/\d{4}-\d{2}-\d{2}/);
+      if (d && localDay(now) > d[0]) {
+        actions.push({ kind: 'overdue', name: r.name, detail: `待退役处置期限 ${d[0]} 已过（今 ${localDay(now)}）——按台账维护纪律「退役动作」当日删代码+测试+更新本表` });
+      } else if (!d) {
+        actions.push({ kind: 'no-deadline', name: r.name, detail: `待退役但处置期限非日期（${r.deadline || '空'}）——补时间表或改回现役` });
+      }
+      continue;
+    }
+
+    // 现役
+    const n = zeroMonthsOf(r.threshold);
+    const rules = ruleNamesOf(r.criterion);
+    if (n === null) { notAuto.push({ name: r.name, reason: '阈值形态非「连续 N 月 = 0」' }); continue; }
+    if (!rules.length) { notAuto.push({ name: r.name, reason: '口径列未列规则名（无法映射 judgments）' }); continue; }
+    if (months.length < n) { notAuto.push({ name: r.name, reason: `judgments 仅 ${months.length} 月 < 阈值 ${n} 月（数据不足）` }); continue; }
+
+    // 日历连续：缺月不算零命中（漏跑数月后陈旧月份不得凑成「连续」）。
+    const window = calendarWindow(months[months.length - 1], n);
+    const missing = window.filter((ym) => !byMonth[ym]);
+    if (missing.length) {
+      notAuto.push({ name: r.name, reason: `日历窗口 ${window.join(' / ')} 缺月 ${missing.join(' / ')}（断档不算零命中）` });
+      continue;
+    }
+    const hits = window.map((ym) => {
+      const cell = byMonth[ym].rules;
+      let c = 0;
+      for (const rule of rules) {
+        const e = cell[rule];
+        if (e) c += (e.WARN || 0) + (e.BLOCK || 0);
+      }
+      return { ym, count: c };
+    });
+    const total = hits.reduce((s, h) => s + h.count, 0);
+    if (total === 0) {
+      actions.push({ kind: 'threshold', name: r.name, detail: `连续 ${n} 月零触发（${window.join(' / ')}；规则 ${rules.join('、')}）——阈值触达，评估退役（改状态「待退役」并填处置期限）` });
+    }
+  }
+  return { actions, notAuto, months, monthCount: months.length };
+}
+
+function readJudgments(root) {
+  const p = path.join(root, LEDGER_REL);
+  if (!fs.existsSync(p)) return { rows: [], missing: true };
+  const rows = [];
+  for (const line of fs.readFileSync(p, 'utf8').split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try { rows.push(JSON.parse(line)); } catch { /* 坏行跳过，不中断 */ }
+  }
+  return { rows, missing: false };
+}
+
+function main() {
+  const regPath = path.join(ROOT, REGISTRY_REL);
+  if (!fs.existsSync(regPath)) {
+    console.error(`[ERROR] mechanism-retire-watch: 台账不存在 ${REGISTRY_REL}`);
+    if (asJson) console.log(JSON.stringify({ error: 'registry-missing', actions: [] }, null, 2));
+    process.exit(0);
+  }
+  const registryRows = parseRegistry(fs.readFileSync(regPath, 'utf8'));
+  const { rows: judgmentRows, missing } = readJudgments(ROOT);
+  const { actions, notAuto, monthCount } = evaluate(registryRows, judgmentRows, NOW);
+
+  if (asJson) {
+    console.log(JSON.stringify({ registryRows: registryRows.length, judgmentMonths: monthCount, judgmentsMissing: missing, actions, notAuto }, null, 2));
+    return;
+  }
+
+  console.log(`# 机制退役催办（${NOW.toISOString()}）`);
+  console.log('');
+  console.log(`台账 ${REGISTRY_REL}｜机制行 ${registryRows.length}｜judgments 月数 ${monthCount}${missing ? '（台账缺失——尚无运行记录）' : ''}`);
+  console.log('');
+  if (!actions.length) {
+    console.log('✅ 无阈值触达 / 无逾期——本轮无动作项。');
+  } else {
+    console.log(`## 动作项 ${actions.length} 条`);
+    for (const a of actions) console.log(`- [${a.kind}] ${a.name}：${a.detail}`);
+  }
+  if (notAuto.length) {
+    console.log('');
+    console.log(`## 非自动可判（${notAuto.length} 条，交人工月判）`);
+    for (const x of notAuto) console.log(`- ${x.name}：${x.reason}`);
+  }
+  console.log('');
+  console.log('> 处置仍人放行：改状态/删代码走人 + 一进一出（台账维护纪律）。本报告不自动改文件。');
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] || '').href) main();

package/templates/_agents/scripts/mechanism-retire-watch.test.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+// mechanism-retire-watch.test.mjs — 1b 机制退役催办纯函数套件（2026-10-14 L5 自举接线 1b）
+// parseRegistry / ruleNamesOf / zeroMonthsOf / evaluate 进程内断言。
+import { parseRegistry, ruleNamesOf, zeroMonthsOf, evaluate } from './mechanism-retire-watch.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 : ''}`); }
+};
+
+// ---- S1 parseRegistry ----
+{
+  const text = [
+    '| 机制 | 门禁位置 | 触发统计口径 | 退役阈值 | 最近触发 | 状态 | 处置期限 |',
+    '|---|---|---|---|---|---|---|',
+    '| 甲门 | check-loop §1 | WARN「甲规则」计数（月） | 连续 6 月 = 0 → 评估退役 | 2026-10 在用 | 现役 | — |',
+    '| 乙门 | check-loop §2 | hard 计数 | 不退役（主干） | 2026-10 | 现役 | — |',
+    '| 丙门 | check-loop §3 | WARN 计数 | 连续 6 月 = 0 | 2026-10 | 待退役 | 2026-01-01 |',
+    '| 坏行 | 少列 |',
+  ].join('\n');
+  const rows = parseRegistry(text);
+  check('S1 只取 7 列数据行（表头/分隔/坏行剔除）', rows.length === 3, String(rows.length));
+  check('S1 列序正确', rows[0].name === '甲门' && rows[0].status === '现役' && rows[0].deadline === '—', JSON.stringify(rows[0]));
+  check('S1 待退役行期限解析', rows[2].status === '待退役' && rows[2].deadline === '2026-01-01');
+}
+
+// ---- S2 ruleNamesOf ----
+check('S2 单规则名', ruleNamesOf('WARN「模板未填」计数（月）').join(',') === '模板未填');
+check('S2 斜杠分隔多规则', ruleNamesOf('WARN「预判类型不符/预判级别不符/预判字段不可解析」计数').join(',') === '预判类型不符,预判级别不符,预判字段不可解析');
+check('S2 无「」→ 空', ruleNamesOf('hard/WARN 计数（月）').length === 0);
+
+// ---- S3 zeroMonthsOf ----
+check('S3 连续 6 月 = 0', zeroMonthsOf('连续 6 月 = 0 → 评估退役') === 6);
+check('S3 带前缀仍解析', zeroMonthsOf('WARN 命中连续 6 月 = 0 且新增预判字段停滞 → 评估退役') === 6);
+check('S3 非零阈值形态 → null', zeroMonthsOf('不退役（防伪主干）') === null);
+check('S3 使用率型 → null', zeroMonthsOf('<10% 且无新增 → 退役双协议') === null);
+
+// ---- S4 evaluate：阈值触达 ----
+{
+  const reg = [{ name: '甲门', criterion: 'WARN「甲规则」计数', threshold: '连续 2 月 = 0 → 评估退役', status: '现役', deadline: '—' }];
+  const j = [
+    { ts: '2026-08-01T00:00:00Z', rules: [{ rule: '甲规则', level: 'WARN', count: 0 }] },
+    { ts: '2026-09-01T00:00:00Z', rules: [] },
+  ];
+  const r = evaluate(reg, j, new Date('2026-10-14'));
+  check('S4 连续 2 月零触发 → 动作项', r.actions.length === 1 && r.actions[0].kind === 'threshold', JSON.stringify(r.actions));
+  check('S4 动作项含窗口与规则名', /2026-08 \/ 2026-09/.test(r.actions[0].detail) && /甲规则/.test(r.actions[0].detail), r.actions[0].detail);
+}
+
+// ---- S5 evaluate：窗口内有触发 → 不产动作项 ----
+{
+  const reg = [{ name: '甲门', criterion: 'WARN「甲规则」计数', threshold: '连续 2 月 = 0', status: '现役', deadline: '—' }];
+  const j = [
+    { ts: '2026-08-01T00:00:00Z', rules: [{ rule: '甲规则', level: 'WARN', count: 1 }] },
+    { ts: '2026-09-01T00:00:00Z', rules: [] },
+  ];
+  const r = evaluate(reg, j, new Date('2026-10-14'));
+  check('S5 窗口内命中 → 无动作项', r.actions.length === 0, JSON.stringify(r.actions));
+}
+
+// ---- S6 evaluate：数据不足 / 无规则名 → notAuto ----
+{
+  const reg = [
+    { name: '甲门', criterion: 'WARN「甲规则」计数', threshold: '连续 6 月 = 0', status: '现役', deadline: '—' },
+    { name: '乙门', criterion: 'hard 计数', threshold: '连续 6 月 = 0', status: '现役', deadline: '—' },
+    { name: '丙门', criterion: 'WARN「丙规则」计数', threshold: '不退役（主干）', status: '现役', deadline: '—' },
+  ];
+  const j = [{ ts: '2026-09-01T00:00:00Z', rules: [] }];
+  const r = evaluate(reg, j, new Date('2026-10-14'));
+  check('S6 数据不足 → notAuto', r.notAuto.some((x) => x.name === '甲门' && /数据不足/.test(x.reason)), JSON.stringify(r.notAuto));
+  check('S6 无规则名 → notAuto', r.notAuto.some((x) => x.name === '乙门' && /未列规则名/.test(x.reason)));
+  check('S6 非零阈值形态 → notAuto', r.notAuto.some((x) => x.name === '丙门' && /非「连续/.test(x.reason)));
+  check('S6 无动作项', r.actions.length === 0);
+}
+
+// ---- S7 evaluate：待退役逾期 / 缺期限 ----
+{
+  const reg = [
+    { name: '甲门', criterion: '', threshold: '', status: '待退役', deadline: '2026-01-01' },
+    { name: '乙门', criterion: '', threshold: '', status: '待退役', deadline: '下批次' },
+    { name: '丙门', criterion: '', threshold: '', status: '已退役', deadline: '—' },
+  ];
+  const r = evaluate(reg, [], new Date('2026-10-14'));
+  check('S7 逾期 → overdue', r.actions.some((a) => a.kind === 'overdue' && a.name === '甲门'), JSON.stringify(r.actions));
+  check('S7 非日期期限 → no-deadline', r.actions.some((a) => a.kind === 'no-deadline' && a.name === '乙门'));
+  check('S7 已退役行跳过', !r.actions.some((a) => a.name === '丙门'));
+}
+// ---- S7b：期限当天不逾期（本地日，不当天 08:00 后提前催）----
+{
+  const reg = [{ name: '甲门', criterion: '', threshold: '', status: '待退役', deadline: '2026-10-14' }];
+  const now = new Date(2026, 9, 14, 9, 0, 0);
+  const r = evaluate(reg, [], now);
+  check('S7b 期限当天本地 09:00 不逾期', r.actions.length === 0, JSON.stringify(r.actions));
+}
+// ---- S4b：有数据月不连续 → 缺月不算零命中 ----
+{
+  const reg = [{ name: '甲门', criterion: 'WARN「甲规则」计数', threshold: '连续 2 月 = 0 → 评估退役', status: '现役', deadline: '—' }];
+  const j = [
+    { ts: '2026-08-01T00:00:00Z', rules: [] },
+    { ts: '2026-10-01T00:00:00Z', rules: [] },
+  ];
+  const r = evaluate(reg, j, new Date('2026-10-14T00:00:00Z'));
+  check('S4b 8 月与 10 月之间缺 9 月 → 不产退役动作', r.actions.length === 0, JSON.stringify(r.actions));
+  check('S4b 缺月记入 notAuto', r.notAuto.some((x) => x.name === '甲门' && /缺月/.test(x.reason) && /2026-09/.test(x.reason)), JSON.stringify(r.notAuto));
+}
+
+// ---- S8 空入参 ----
+check('S8 空台账 → 无动作项', evaluate([], [], new Date()).actions.length === 0);
+check('S8 null judgments 不 throw', evaluate([], null, new Date()).actions.length === 0);
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/pre-push.test.mjs

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
-// pre-push.test.mjs — 加固门目标分支判定 fixture 套件（2026-10-01 v09-review-defects）
-// 真仓端到端：临时仓库挂载真实 pre-push，.agents/scripts/check-loop.sh 以桩脚本记录 argv。
+// pre-push.test.mjs — 加固门目标分支判定 + 构建门 fixture 套件
+// （2026-10-01 v09-review-defects 建；2026-10-16 随 pre-push node 化更新：桩改 .agents/scripts/check-loop.mjs
+// 直调，补 commit-check 构建门桩与 --range 断言——自源仓 2ff869a9 回灌面）
+// 真仓端到端：临时仓库挂载真实 pre-push，check-loop.mjs 与 commit-check.cjs 以桩记录 argv。
 // 断言三态 refspec：
-//   main→main                  → argv 含 --hardening（加固门）
-//   experiment/x→main         → argv 含 --hardening（修复回归：直推漏口）
-//   experiment/y→experiment/y → argv 不含 --hardening（advisory）
+//   main→main                  → argv 含 --hardening（加固门）；构建门 --range 新分支首推=全量零 sha
+//   experiment/x→main         → argv 含 --hardening（修复回归：直推漏口）；构建门 old 为远端实 sha
+//   experiment/y→experiment/y → argv 不含 --hardening（advisory）；构建门仍按范围跑（advisory 不阻断）
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -34,11 +36,15 @@ const setup = () => {
   const remote = path.join(root, 'remote.git');
   fs.mkdirSync(path.join(root, '.githooks'), { recursive: true });
   fs.mkdirSync(path.join(root, '.agents', 'scripts'), { recursive: true });
-  // 挂载真实 pre-push（装户同款），stub 替换 check-loop 记录 argv
+  fs.mkdirSync(path.join(root, '.agents', 'hooks'), { recursive: true });
+  // 挂载真实 pre-push（装户同款），stub 替换 check-loop 与 commit-check 记录 argv
   fs.copyFileSync(PRE_PUSH, path.join(root, '.githooks', 'pre-push'));
-  // Linux：git 静默跳过不可执行钩子（推送照常成功、桩无记录）——挂载后必须设执行位；桩经 sh 调用无须 +x
+  // Linux：git 静默跳过不可执行钩子（推送照常成功、桩无记录）——挂载后必须设执行位；桩经 node 调用无须 +x
   fs.chmodSync(path.join(root, '.githooks', 'pre-push'), 0o755);
-  fs.writeFileSync(path.join(root, '.agents', 'scripts', 'check-loop.sh'), '#!/bin/sh\necho "$@" >> .stub-args\nexit 0\n');
+  fs.writeFileSync(path.join(root, '.agents', 'scripts', 'check-loop.mjs'),
+    'import fs from "node:fs";\nfs.appendFileSync(".stub-args", process.argv.slice(2).join(" ") + "\\n");\n');
+  fs.writeFileSync(path.join(root, '.agents', 'hooks', 'commit-check.cjs'),
+    'const fs = require("node:fs");\nfs.appendFileSync(".stub-args-cc", process.argv.slice(2).join(" ") + "\\n");\n');
   fs.writeFileSync(path.join(root, 'a.txt'), 'a\n');
   git(root, ['init', '-q']);
   git(root, ['config', 'user.email', 't@t']);
@@ -54,15 +60,21 @@ const stubArgs = (root) => {
   const p = path.join(root, '.stub-args');
   return fs.existsSync(p) ? fs.readFileSync(p, 'utf8').split(/\n/).filter(Boolean) : [];
 };
+const ccArgs = (root) => {
+  const p = path.join(root, '.stub-args-cc');
+  return fs.existsSync(p) ? fs.readFileSync(p, 'utf8').split(/\n/).filter(Boolean) : [];
+};
 
 const root = setup();
 const w = (f, c) => fs.writeFileSync(path.join(root, f), c);
 
-// 1) main → main：应含 --hardening
+// 1) main → main：应含 --hardening；构建门首推 = 全量零 sha
 git(root, ['checkout', '-q', '-b', 'main']);
 let r = run(root, ['push', 'origin', 'HEAD:main']);
 check('main→main 推送成功', r.status === 0, `${r.stdout}${r.stderr}`);
 check('main→main argv 含 --hardening', (stubArgs(root)[0] || '').includes('--hardening'), stubArgs(root).join('|'));
+check('main→main 构建门 --range 新分支首推=全量零 sha（2026-10-16 构建门后移）',
+  (ccArgs(root)[0] || '').startsWith('--range 0000000000000000000000000000000000000000 '), ccArgs(root).join('|'));
 
 // 2) experiment/x → main（回归漏口）：本地分支在 experiment，目标 main → 必须含 --hardening
 git(root, ['checkout', '-q', '-b', 'experiment/x']);
@@ -72,8 +84,10 @@ git(root, ['commit', '-q', '-m', 'x']);
 r = run(root, ['push', 'origin', 'HEAD:main']);
 check('experiment/x→main 推送成功', r.status === 0, `${r.stdout}${r.stderr}`);
 check('experiment/x→main argv 含 --hardening（直推漏口修复）', (stubArgs(root)[1] || '').includes('--hardening'), stubArgs(root).join('|'));
+check('experiment/x→main 构建门 --range old 为远端实 sha（非零）',
+  /^--range [0-9a-f]{40} /.test(ccArgs(root)[1] || ''), ccArgs(root).join('|'));
 
-// 3) experiment/y → experiment/y：目标在探索泳道 → 不含 --hardening
+// 3) experiment/y → experiment/y：目标在探索泳道 → 不含 --hardening；构建门仍按范围跑（advisory）
 git(root, ['fetch', '-q', 'origin']);
 git(root, ['branch', 'experiment/y', 'origin/main']);
 git(root, ['checkout', '-q', 'experiment/y']);
@@ -84,6 +98,8 @@ r = run(root, ['push', 'origin', 'HEAD:experiment/y']);
 check('experiment→experiment 推送成功', r.status === 0, `${r.stdout}${r.stderr}`);
 const line3 = stubArgs(root)[2] || '';
 check('experiment→experiment argv 不含 --hardening', !line3.includes('--hardening'), stubArgs(root).join('|'));
+check('experiment→experiment 构建门仍按范围跑（advisory 不阻断）',
+  /^--range [0-9a-f]{40} /.test(ccArgs(root)[2] || ''), ccArgs(root).join('|'));
 
 console.log(`\n${fail ? `❌ ${fail} failed` : '✅ all passed'}（${pass} passed）`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/rule-budget.mjs

@@ -8,6 +8,10 @@
 // 「提交后树」= 索引（index）内容：staged 版优先于 HEAD；无 git（fixture）回退工作区文件。
 // 字节口径 = 索引 / HEAD 内容（git cat-file，LF 归一）。禁用工作区 wc -c 口径（CRLF 膨胀系统性偏大，
 // 2026-09-21 实测差 ~500B 一度误判超限）——本脚本所有字节数都走 cat-file，仅无 git 时才落工作区。
+// 条目数预算（2026-10-15 减重手段② 自源仓回灌）：上限字段形如 `<N>#count` 时按「匹配文件条数」执法
+//   而非字节——规则面一进一出（新增一条须先退役一条，退役判定 agg-judgments --retire-candidates）。
+//   旧格式行（纯数字）不受影响；`#count` 行对旧读者（未升级的脚本副本）因上限非纯数字被跳过——
+//   fail-open，不误拦。
 import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -60,13 +64,22 @@ const expand = (pat) => {
 
 let viol = 0;
 const over = (what, bytes, lim) => { console.log(`常驻面超限：${what} ${bytes}B > 上限 ${lim}B`); viol = 1; };
+const overCount = (pat, n, lim) => { console.log(`常驻面超限（条目数）：${pat} ${n} 项 > 上限 ${lim} 项——一进一出：新增须先退役一条（退役判定 agg-judgments --retire-candidates）`); viol = 1; };
 
 for (const line of fs.readFileSync(BUDGETS, 'utf8').split(/\r?\n/)) {
   const sp = line.lastIndexOf(' ');
   if (sp < 0) continue;
   const pat = line.slice(0, sp), lim = line.slice(sp + 1);
   if (pat === '' || pat.startsWith('#')) continue;
-  if (!/^\d+$/.test(lim)) continue;
+  // 条目数预算（2026-10-15 减重手段②）：`<N>#count` = 匹配文件数上限（一进一出的执法面）
+  const cnt = /^(\d+)#count$/.exec(lim);
+  if (!cnt && !/^\d+$/.test(lim)) continue;
+  if (cnt) {
+    if (mode === '--staged' && !staged.some((sf) => sf.startsWith(pat))) continue;
+    const n = expand(pat).length;
+    if (n > Number(cnt[1])) overCount(pat, n, cnt[1]);
+    continue;
+  }
   if (pat.endsWith('/')) {
     // 目录合计：--staged 下仅当暂存触及该目录内文件才查（字面前缀匹配，同 sh 版 2026-09-24 口径）
     if (mode === '--staged' && !staged.some((sf) => sf.startsWith(pat))) continue;

package/templates/_agents/scripts/rule-budget.test.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+// rule-budget.test.mjs — 常驻面预算黑盒套件（2026-10-15 减重手段② 自源仓回灌随附：#count 条目数指令）
+// 夹具：os.tmpdir 下临时目录（非 git 环境——脚本 git rev-parse 失败留在 fixture 目录，
+// 字节口径回退工作区文件；与真实仓「索引/HEAD」口径的差异不影响指令语义判定）。
+// 覆盖：字节超限/未超、#count 超限/压线、旧格式行不受 #count 影响、缺预算表 exit 0、
+//       --staged 无 git（staged 空）时 #count 门跳过。
+// 运行：node templates/_agents/scripts/rule-budget.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';
+
+const SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), 'rule-budget.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 : ''}`); }
+};
+
+function makeFixture({ budgets, dirs = {}, files = {} }) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'rule-budget-'));
+  if (budgets !== null) {
+    fs.mkdirSync(path.join(root, '.agents'), { recursive: true });
+    fs.writeFileSync(path.join(root, '.agents', 'rule-budgets.txt'), budgets, 'utf8');
+  }
+  for (const [dir, names] of Object.entries(dirs)) {
+    fs.mkdirSync(path.join(root, dir), { recursive: true });
+    for (const n of names) fs.writeFileSync(path.join(root, dir, n), 'x\n', 'utf8');
+  }
+  for (const [f, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, f)), { recursive: true });
+    fs.writeFileSync(path.join(root, f), content, 'utf8');
+  }
+  return root;
+}
+
+const run = (cwd, mode = '--all') => {
+  const r = spawnSync(process.execPath, [SCRIPT, mode], { cwd, encoding: 'utf8' });
+  return { code: r.status, out: String(r.stdout || '') };
+};
+
+let root;
+
+// ---- T1 字节超限（旧格式语义不回归）----
+root = makeFixture({
+  budgets: 'AGENTS.md 10\n',
+  files: { 'AGENTS.md': 'x'.repeat(50) },
+});
+{
+  const r = run(root);
+  check('T1 字节超限 exit 1 + 违例行', r.code === 1 && r.out.includes('常驻面超限：AGENTS.md') && r.out.includes('> 上限 10B'), JSON.stringify(r));
+}
+
+// ---- T2 字节未超 → 0 ----
+root = makeFixture({
+  budgets: 'AGENTS.md 100\n',
+  files: { 'AGENTS.md': 'x'.repeat(50) },
+});
+check('T2 字节未超 exit 0', run(root).code === 0);
+
+// ---- T3 #count 超限 ----
+root = makeFixture({
+  budgets: '.agents/rules/ 2#count\n',
+  dirs: { '.agents/rules': ['r01-a.md', 'r02-b.md', 'r03-c.md'] },
+});
+{
+  const r = run(root);
+  check('T3 #count 超限 exit 1 + 条目数违例行 + 一进一出提示', r.code === 1 && r.out.includes('条目数') && r.out.includes('3 项 > 上限 2 项') && r.out.includes('一进一出'), JSON.stringify(r));
+}
+
+// ---- T4 #count 压线（= 上限）→ 0 ----
+root = makeFixture({
+  budgets: '.agents/rules/ 3#count\n',
+  dirs: { '.agents/rules': ['r01-a.md', 'r02-b.md', 'r03-c.md'] },
+});
+check('T4 #count 压线 exit 0', run(root).code === 0);
+
+// ---- T5 混合表：#count 行存在但未触其它字节条目 → 0（互不干扰）----
+root = makeFixture({
+  budgets: 'AGENTS.md 100\n.agents/rules/ 3#count\n',
+  files: { 'AGENTS.md': 'x'.repeat(50) },
+  dirs: { '.agents/rules': ['r01-a.md', 'r02-b.md', 'r03-c.md'] },
+});
+check('T5 混合表双通过 exit 0', run(root).code === 0);
+
+// ---- T6 缺预算表 → exit 0（fixture 沙箱不拦，既有语义）----
+root = makeFixture({ budgets: null });
+check('T6 缺预算表 exit 0', run(root).code === 0);
+
+// ---- T7 --staged 无 git（staged 空）：#count 门跳过不拦 ----
+root = makeFixture({
+  budgets: '.agents/rules/ 2#count\n',
+  dirs: { '.agents/rules': ['r01-a.md', 'r02-b.md', 'r03-c.md'] },
+});
+{
+  const r = run(root, '--staged');
+  check('T7 --staged 无 git 环境跳过 #count 门 exit 0', r.code === 0, JSON.stringify(r));
+}
+
+// ---- T8 glob 形态 #count（* 后缀）也按条数执法 ----
+root = makeFixture({
+  budgets: '.agents/commands/*.md 2#count\n',
+  dirs: { '.agents/commands': ['a.md', 'b.md', 'c.md', 'd.txt'] },
+});
+{
+  const r = run(root);
+  check('T8 glob #count 只数 *.md（3 项 > 2）exit 1', r.code === 1 && r.out.includes('3 项'), JSON.stringify(r));
+}
+
+for (const d of fs.readdirSync(os.tmpdir()).filter((f) => f.startsWith('rule-budget-'))) {
+  try { fs.rmSync(path.join(os.tmpdir(), d), { recursive: true, force: true }); } catch { /* Windows 文件锁容忍 */ }
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/verify.mjs

@@ -24,9 +24,12 @@
 //   提交——新装户由 init 生成器首跑种子该文件，缺文件对 --check 是漂移（红），不静默放行。
 // 绿凭证摘要（gen-verify-evidence.mjs）：全绿尾部自动重生成 workflow/verify-evidence.md——全绿事实与
 //   仓内摘要同刻生成，消除「本地台账已绿、committed 摘要滞后」的双真相分叉；生成失败响亮告警但不推翻绿裁决。
-// 用法：node .agents/scripts/verify.mjs [--list] [--test-cmd "<shell 命令>"] [--doc <本单 workflow 路径>]
-//   --list：按执行序打印门 id 后退出，不执行（与 --test-cmd 互斥）。
+// 用法：node .agents/scripts/verify.mjs [--list] [--test-cmd "<shell 命令>"] [--stub-gate "<命令>"] [--doc <本单 workflow 路径>]
+//   --list：按执行序打印门 id 后退出，不执行（与 --test-cmd / --stub-gate 互斥）。
 //   --test-cmd 用于测试注入，或在无根 package.json 的装户仓指定项目测试命令；
+//   --stub-gate <命令>（2026-10-16 自源仓回灌）：单门夹具但走**生产尾段**（落凭证 / 生成摘要）——
+//     与 --test-cmd 的差异是不打 testCmd 标记、尾段按生产路径执行；**必须配 CHECK_LOOP_ROOT**（夹具根），
+//     禁止在真实仓库写出可被当成关单凭证的绿行。
 //   --doc 把凭证绑到本单，如 --doc workflow/intents/<日期>-<主题>.md
 // 测试：node templates/_agents/scripts/verify.test.mjs（--test-cmd 注入假命令 + CHECK_LOOP_ROOT 注入夹具）
 import fs from 'node:fs';
@@ -59,6 +62,24 @@ const fixtureGates = (cmd) => [
 const args = process.argv.slice(2);
 const explicitTestCmd = args.includes('--test-cmd') ? args[args.indexOf('--test-cmd') + 1] : null;
 
+// --stub-gate（2026-10-16 自源仓 13f67ef7 回灌）：单门夹具但走**生产尾段**（落凭证 / 生成摘要）。
+// 与 --test-cmd 的关键差异：不打 testCmd 标记（fixture 模式绿行带 testCmd:true，生产凭证不与之混淆）。
+// **必须配 CHECK_LOOP_ROOT**——禁止在真实仓库写出可被当成关单凭证的绿行（信任边界：夹具单门不是关单凭证）。
+const stubIdx = args.indexOf('--stub-gate');
+const stubCmd = stubIdx >= 0 ? args[stubIdx + 1] : null;
+if (stubIdx >= 0 && !stubCmd) {
+  console.error('[verify] --stub-gate 需要一条命令');
+  process.exit(2);
+}
+if (stubCmd && explicitTestCmd) {
+  console.error('[verify] --stub-gate 与 --test-cmd 互斥');
+  process.exit(2);
+}
+if (stubCmd && !process.env.CHECK_LOOP_ROOT) {
+  console.error('[verify] --stub-gate 只允许配合 CHECK_LOOP_ROOT 夹具根（禁止在真实仓库落无关单凭证）');
+  process.exit(2);
+}
+
 // --doc 解析（沿 --test-cmd 同款取下一 argv 的写法；缺值报用法错误 exit 1 与 --test-cmd 对称）。
 // 归一基准 = **ROOT**（不是 cwd）——消费方两处都以仓库根为基准（check-loop 检查 8 用
 // path.relative(ROOT, intent)；confirm-doc 的 docRelOf 用 path.resolve(root, doc)）。若这里按 cwd
@@ -78,12 +99,14 @@ const docRel = docArg
 // 装户仓判定：engine-tests 门只在**当前目录**有 package.json 时才跑（npm test 亦在该目录执行）。
 // 跳过时后续不落测试绿凭证（见全绿落账段）。显式 --test-cmd 不受此判定影响。
 const hasRootPackageJson = fs.existsSync(path.join(process.cwd(), 'package.json'));
-const skipTest = explicitTestCmd === null && !hasRootPackageJson;
-const gates = explicitTestCmd ? fixtureGates(explicitTestCmd) : GATES;
+const skipTest = explicitTestCmd === null && stubCmd === null && !hasRootPackageJson;
+const gates = explicitTestCmd ? fixtureGates(explicitTestCmd)
+  : stubCmd ? [{ id: 'stub', name: '夹具单门', cmd: stubCmd, folder: '.', type: 'shell' }]
+  : GATES;
 
 if (args.includes('--list')) {
-  if (explicitTestCmd) {
-    console.error('[verify] --list 与 --test-cmd 互斥');
+  if (explicitTestCmd || stubCmd) {
+    console.error('[verify] --list 与 --test-cmd / --stub-gate 互斥');
     process.exit(1);
   }
   for (const g of gates) console.log(g.id);
@@ -104,7 +127,7 @@ const recordFailure = (step, exitInfo, note) => {
   }
 };
 
-console.log(`[verify] 🚀 开始静态门验证 (共 ${gates.length} 项)${explicitTestCmd ? '【fixture 模式】' : ''}\n`);
+console.log(`[verify] 🚀 开始静态门验证 (共 ${gates.length} 项)${explicitTestCmd ? '【fixture 模式】' : ''}${stubCmd ? '【stub 尾段】' : ''}\n`);
 
 let passedCount = 0;
 const outputs = {};
@@ -173,7 +196,8 @@ try {
 
 // 摘要事件原子化：全绿事实与仓内摘要（workflow/verify-evidence.md）同刻生成，消除「本地台账已绿、
 // committed 摘要滞后」的双真相分叉。仅生产模式（fixture 假门凭证不产 committed 摘要；测试门跳过时
-// 本就无凭证）；生成失败响亮告警但不推翻绿裁决（同落账口径）。
+// 本就无凭证）；stub 尾段按生产路径执行（摘要落在 CHECK_LOOP_ROOT 夹具根，不触真实仓）。
+// 生成失败响亮告警但不推翻绿裁决（同落账口径）。
 if (!explicitTestCmd && !skipTest) {
   const gen = spawnSync(process.execPath, [path.join(SCRIPT_DIR, 'gen-verify-evidence.mjs'), '--root', ROOT], { encoding: 'utf8' });
   if (gen.status === 0) {

package/templates/_agents/scripts/verify.test.mjs

@@ -257,6 +257,35 @@ const readLedger = (root) => {
   fs.rmSync(root10, { recursive: true, force: true });
 }
 
+// ---- 场景 12：--stub-gate 走生产尾段（落凭证；2026-10-16 自源仓 13f67ef7 回灌）----
+// 单门夹具但按生产路径落绿行（不打 testCmd 标记）；必须配 CHECK_LOOP_ROOT。
+{
+  const root = mkfix();
+  fs.mkdirSync(path.join(root, 'workflow'), { recursive: true });
+  const git = (args) => spawnSync('git', args, { cwd: root, encoding: 'utf8' });
+  git(['init', '-q']);
+  git(['config', 'user.email', 't@t']);
+  git(['config', 'user.name', 't']);
+  fs.writeFileSync(path.join(root, 'README.md'), 'stub\n');
+  git(['add', '-A']);
+  git(['commit', '-qm', 'base']);
+  const r = run(['--stub-gate', `node ${mkCmd(0)}`], { env: { ...process.env, CHECK_LOOP_ROOT: root, RUN_E2E: '' } });
+  const l = readLedger(root)[0] || null;
+  check('场景 12：stub 单门 exit 0', r.status === 0, `exit=${r.status}\n${r.stdout}\n${r.stderr}`);
+  check('场景 12：落绿行（suite=npm test）且无 testCmd 标记',
+    l !== null && l.suite === 'npm test' && l.exitCode === 0 && !('testCmd' in l), JSON.stringify(l));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+// 场景 12b：无 CHECK_LOOP_ROOT → exit 2，不跑门（信任边界：夹具单门不得当真实凭证）
+{
+  const env = { ...process.env, RUN_E2E: '' };
+  delete env.CHECK_LOOP_ROOT;
+  const r = run(['--stub-gate', 'node -e "process.exit(0)"'], { env });
+  check('场景 12b：--stub-gate 无 CHECK_LOOP_ROOT → exit 2 且不跑门',
+    r.status === 2 && String(r.stderr).includes('CHECK_LOOP_ROOT') && !String(r.stdout).includes('全绿'),
+    `exit=${r.status}\n${r.stdout}\n${r.stderr}`);
+}
+
 // ---- 场景 11：--list 锁定 engine cohort 七门序，不执行门 ----
 {
   const expect = ['scripts-syntax', 'engine-tests', 'workflows-check', 'rule-budget', 'effective-policy', 'check-loop', 'ledger-invariant'];