agentic-flow-kit 1.8.1 → 1.8.2

package/templates/_agents/scripts/confirm-doc.mjs

@@ -541,9 +541,21 @@ if (isMain) {
   // 内容绑定约束，与既有归档批次同口径）。失败一律 fail-open：归档是卫生动作，不得回滚已完成的
   // 确认（**归档失败不阻断关单**——与源仓语义逐字一致）。启用锚（照搬源仓，无 policy 锚）：
   // ① 仓库已建立归档约定（workflow/archive/ 存在）——真实装户仓有，临时 fixture 无，避免测试夹具
-  //   被静默搬走（也避免在未采纳归档的仓库里凭空造目录）；② env 逃生门 CONFIRM_DOC_NO_ARCHIVE。
+  //   被静默搬走（也避免在未采纳归档的仓库里凭空造目录）；② env 逃生门 CONFIRM_DOC_NO_ARCHIVE；
+  //   ③ 特性分支默认不归档（2026-10-16 自源仓 13f67ef7 回灌）：分支上先关单再合并时，diff 只剩
+  //   archive/ 路径，泳道/配对增量门只认 workflow 活跃直路径，合法合并被拦。main/master/develop 与
+  //   游离 HEAD 维持关单即归档。CONFIRM_DOC_NO_ARCHIVE=1 仍强制关；CONFIRM_DOC_ARCHIVE=1 可在特性分支强制归档。
   const archiveRoot = path.join(root, 'workflow', 'archive');
-  if (confirmed > 0 && !process.env.CONFIRM_DOC_NO_ARCHIVE && fs.existsSync(archiveRoot)) {
+  let featureHold = false;
+  if (confirmed > 0 && !process.env.CONFIRM_DOC_NO_ARCHIVE && process.env.CONFIRM_DOC_ARCHIVE !== '1') {
+    let branch = '';
+    try { branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: root, encoding: 'utf8' }).trim(); } catch { branch = ''; }
+    featureHold = !!branch && branch !== 'HEAD' && !['main', 'master', 'develop'].includes(branch);
+    if (featureHold && fs.existsSync(archiveRoot)) {
+      console.log(`📦 特性分支 ${branch} 不归档（合并前保持 workflow 活跃路径；main/develop 关单才归档）。CONFIRM_DOC_ARCHIVE=1 可强制`);
+    }
+  }
+  if (confirmed > 0 && !process.env.CONFIRM_DOC_NO_ARCHIVE && !featureHold && fs.existsSync(archiveRoot)) {
     try {
       const { analyze, buildDocList, loadLastTouch, parseStatus, TERMINAL, ACTIVE } = await import('./archive-sweep.mjs');
       // 台账终态锚：kit 读侧单源 = readLedgerRows（主台账+分片透明合并；源仓走

package/templates/_agents/scripts/confirm-doc.test.mjs

@@ -1056,5 +1056,48 @@ const writeTrust = (root, cfg) => {
   fs.rmSync(root2, { recursive: true, force: true });
 }
 
+// ---- S45c/S45d 特性分支默认不归档（2026-10-16 自源仓 13f67ef7 回灌）----
+// 分支上先关单再合并时 diff 只剩 archive/ 路径，泳道/配对增量门只认 workflow 活跃直路径；
+// main/master/develop 与游离 HEAD 维持关单即归档。CONFIRM_DOC_ARCHIVE=1 可在特性分支强制归档。
+{
+  const mkRepoBranch = (branchName) => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-branch-'));
+    const git = (...a) => spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', a, { cwd: root, encoding: 'utf8' });
+    git('init', '-q');
+    git('config', 'user.email', 't@t');
+    git('config', 'user.name', 't');
+    git('checkout', '-q', '-b', branchName);
+    const ip = path.join(root, 'workflow', 'intents');
+    fs.mkdirSync(ip, { recursive: true });
+    fs.mkdirSync(path.join(root, 'workflow', 'archive'), { recursive: true });
+    const fp = branchName === 'main' ? 'eeee5555eeee5555' : 'ffff6666ffff6666';
+    fs.writeFileSync(path.join(ip, '2026-09-01-branch.md'), `---\n状态: approved\n级别: L1\n确认指纹: ${fp}\n---\n# I\n\n## 验收标准（可测试）\n- [x] 通过（证据:测试全绿）\n`, 'utf8');
+    git('add', '-A');
+    spawnSync(process.platform === 'win32' ? 'git.exe' : 'git', ['commit', '-q', '-m', 'c1'], { cwd: root, env: { ...process.env, GIT_AUTHOR_DATE: '2026-09-01T10:00:00+08:00', GIT_COMMITTER_DATE: '2026-09-01T10:00:00+08:00' } });
+    return { root, ip };
+  };
+  // S45c：特性分支关单 → 不归档（保持 workflow 活跃直路径），但状态照常 done
+  {
+    const { root, ip } = mkRepoBranch('feature/x');
+    const r = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-09-01-branch.md', '--delegated', '可以'],
+      { cwd: root, encoding: 'utf8', env: { ...process.env, CONFIRM_DOC_TEST_NOW: '2026-10-13' } });
+    check('S45c 特性分支关单默认不归档（状态置 done、文档留活跃路径）',
+      r.status === 0 && /状态: done/.test(fs.readFileSync(path.join(ip, '2026-09-01-branch.md'), 'utf8'))
+        && !fs.existsSync(path.join(root, 'workflow', 'archive', 'intents')) && /不归档/.test(r.stdout),
+      JSON.stringify({ status: r.status, stdout: String(r.stdout).slice(-260) }));
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+  // S45d：特性分支 + CONFIRM_DOC_ARCHIVE=1 → 强制归档
+  {
+    const { root } = mkRepoBranch('feature/y');
+    const r = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-09-01-branch.md', '--delegated', '可以'],
+      { cwd: root, encoding: 'utf8', env: { ...process.env, CONFIRM_DOC_TEST_NOW: '2026-10-13', CONFIRM_DOC_ARCHIVE: '1' } });
+    check('S45d 特性分支 CONFIRM_DOC_ARCHIVE=1 强制归档',
+      r.status === 0 && /📦 归档/.test(r.stdout),
+      JSON.stringify({ status: r.status, stdout: String(r.stdout).slice(-260) }));
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/gen-workflow-metrics.mjs

@@ -14,6 +14,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadEnums } from './workflow-enums.mjs';
 import { readLedgerRows as loadLedgerRows } from './ledger-loader.mjs';
+import { analyze, buildDocList, loadLastTouch, loadLedgerTs, parseStatus, ACTIVE } from './archive-sweep.mjs';
 
 const USAGE = `用法：node .agents/scripts/gen-workflow-metrics.mjs [--month YYYY-MM] [--dry-run] [--help]
 
@@ -217,6 +218,22 @@ console.log(`  常驻面合计：${kb(surf.total)}`);
 console.log(`  闭环漏斗：收口 ${funnel.closed}（完整链 ${funnel.full} = 一次通过 ${funnel.once} + 返工 ${funnel.rework}；协议前 ${funnel.legacy}）｜中位周期 ${medianDays === null ? '—' : `${medianDays.toFixed(1)} 天`}｜台账行 ${funnel.ledgerRows}`);
 for (const it of funnel.items) console.log(`    ${String(it.doc).padEnd(58)} ${it.kind.padEnd(7)} ${it.days} 天`);
 if (funnel.items.length) console.log('  ℹ️ 机器口径可与 workflow/delegations.md 自做表的人工自报交叉对照（差异即信号，不对账）');
+// 归档积压提醒（2026-10-15 减重手段⑥ 自源仓回灌，回路别等人喊）：滚动归档已随确认门自动跑
+// （confirm-doc archive-on-close），历史积压走 archive-sweep 手工批次——月度 stdout 报候选数使积压可见。
+// 判定单源 = archive-sweep.analyze（21 天窗，禁第二套口径）；analyze/loadLastTouch 抛错（如
+// 浅克隆无 git 历史）fail-open 静默——观测提醒不挡快照。
+try {
+  const allDocs = buildDocList(process.cwd());
+  const arch = analyze({
+    docs: allDocs,
+    ledgerTs: loadLedgerTs(process.cwd()),
+    lastTouch: loadLastTouch(process.cwd()),
+    activeTexts: allDocs.filter((d) => ACTIVE.has(parseStatus(d.text))).map((d) => d.text),
+    windowDays: 21,
+  });
+  const fams = new Set(arch.candidates.map((x) => x.file));
+  console.log(`  归档积压：候选 ${arch.candidates.length} 篇 / ${fams.size} 族（21 天窗）${arch.candidates.length ? '——node .agents/scripts/archive-sweep.mjs 查看，--execute 执行' : ''}`);
+} catch { /* fail-open */ }
 console.log(`  ${DRY ? '（--dry-run，未写盘）' : ''}`);
 
 if (DRY) { console.log(`\n将写入行：\n${row}\n${funnelRow}`); process.exit(0); }

package/templates/_agents/scripts/ledger-shards.mjs

@@ -226,8 +226,30 @@ export function renderShard(name, rows, eol = '\n') {
   return out.length ? `${out.join(eol)}${eol}` : '';
 }
 
+// insertIntoSection(text, section, lines)：把行插进已有分片的对应 ## 节（下一节标题之前）。
+// 节不存在则整节追加到文末。无 section 的行不走这里（保持追加到文末 = 末表）。
+function insertIntoSection(text, section, lines) {
+  const eol = text.includes('\r\n') ? '\r\n' : '\n';
+  const parts = text.split(/\r?\n/);
+  if (parts.length && parts[parts.length - 1] === '') parts.pop();
+  const start = parts.findIndex((l) => l.startsWith('## ') && l.includes(section));
+  if (start < 0) {
+    return `${parts.join(eol)}${eol}${eol}## ${section}${eol}${eol}${lines.join(eol)}${eol}`;
+  }
+  let end = parts.length;
+  for (let i = start + 1; i < parts.length; i++) {
+    if (parts[i].startsWith('## ')) { end = i; break; }
+  }
+  let at = end;
+  while (at > start && parts[at - 1].trim() === '') at--;
+  parts.splice(at, 0, ...lines);
+  return `${parts.join(eol)}${eol}`;
+}
+
 // appendRows(root, name, rows, { month, section })：把数据行追加进指定月分片（缺省取行内日期月）。
 // rows 可为字符串数组或 { line, section } 数组（多表台账须带 section 才能归对表）。
+// 分片已存在时：带 section 的行插入该节（不落到文末自做表）；不带 section 的行仍追加到文末
+// （2026-10-16 自源仓 13f67ef7 回灌——修「合并丢共有行」时新增行误落末表）。
 // 返回实际写入的分片路径列表。写失败 fail-loud（不静默吞）。
 export function appendRows(root, name, rows, { month, section = '' } = {}) {
   const written = [];
@@ -247,9 +269,21 @@ export function appendRows(root, name, rows, { month, section = '' } = {}) {
     const existingRows = new Set(existing.split(/\r?\n/).filter((l) => l.trim()));
     const fresh = rs.filter((r) => !existingRows.has(r.line));
     if (!fresh.length) { written.push(p); continue; } // 已在分片 → 幂等跳过
-    const next = existing
-      ? `${existing.replace(/\s*$/, '')}\n${fresh.map((r) => r.line).join('\n')}\n`
-      : renderShard(name, fresh, '\n');
+    let next;
+    if (!existing) next = renderShard(name, fresh, '\n');
+    else {
+      const placed = fresh.filter((r) => r.section);
+      const tail = fresh.filter((r) => !r.section);
+      let text = existing;
+      const bySec = new Map();
+      for (const r of placed) {
+        if (!bySec.has(r.section)) bySec.set(r.section, []);
+        bySec.get(r.section).push(r.line);
+      }
+      for (const [sec, lines] of bySec) text = insertIntoSection(text, sec, lines);
+      if (tail.length) text = `${text.replace(/\s*$/, '')}\n${tail.map((r) => r.line).join('\n')}\n`;
+      next = text.endsWith('\n') ? text : `${text}\n`;
+    }
     fs.writeFileSync(p, next, 'utf8');
     written.push(p);
   }
@@ -296,11 +330,14 @@ function main() {
     if (!row) { console.error('--append 须带 --row "<数据行>"'); process.exit(2); }
     const mIdx = argv.indexOf('--month');
     const month = mIdx >= 0 ? argv[mIdx + 1] : undefined;
-    const written = appendRows(root, name, [row], { month });
+    const sIdx = argv.indexOf('--section');
+    const section = sIdx >= 0 ? argv[sIdx + 1] : '';
+    if (sIdx >= 0 && !section) { console.error('--section 须带节标题（如 委派结果）'); process.exit(2); }
+    const written = appendRows(root, name, [row], { month, section });
     console.log(`✓ 追加 1 行 → ${written.map((p) => path.relative(root, p).split(path.sep).join('/')).join(', ')}`);
     return;
   }
-  console.error('用法：node .agents/scripts/ledger-shards.mjs --check | --split <ledger> [--dry-run] | --append <ledger> --row "<行>" [--month YYYY-MM]');
+  console.error('用法：node .agents/scripts/ledger-shards.mjs --check | --split <ledger> [--dry-run] | --append <ledger> --row "<行>" [--month YYYY-MM] [--section <节标题>]');
   process.exit(2);
 }
 

package/templates/_agents/scripts/ledger-shards.test.mjs

@@ -247,6 +247,23 @@ const wf = (root, ...p) => path.join(root, 'workflow', ...p);
   fs.rmSync(root, { recursive: true, force: true });
 }
 
+// ---- S20 appendRows --section（2026-10-16 自源仓 13f67ef7 回灌）：已有双表时委派行插入委派节，
+//      不带 section 仍落文末（修「合并丢共有行」时新增行误落末表）----
+{
+  const root = mkroot();
+  appendRows(root, 'delegations', ['| 2026-10-15 | model | 委派甲 | 一次通过 | 备注 | |'], { section: '委派结果' });
+  appendRows(root, 'delegations', ['| 2026-10-15 | 自做甲 | 一次通过 | 备注 | |'], { section: '自做任务结果' });
+  appendRows(root, 'delegations', ['| 2026-10-15 | model | 委派乙 | 一次通过 | 备注 | |'], { section: '委派结果' });
+  appendRows(root, 'delegations', ['| 2026-10-15 | 自做乙 | 一次通过 | 备注 | |']);
+  const shard = fs.readFileSync(shardPathFor(root, 'delegations', '2026-10'), 'utf8');
+  const iSelf = shard.indexOf('## 自做任务结果');
+  const iDelegRow = shard.indexOf('委派乙');
+  const iSelfRow = shard.indexOf('自做乙');
+  check('S20 后追加的委派行仍在自做节之前', iDelegRow >= 0 && iDelegRow < iSelf, shard);
+  check('S20b 不带 section 的行落在文末', iSelf >= 0 && iSelf < iSelfRow, shard);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
 // ---- S18 appendRows 幂等：同行走两次只落一次 ----
 {
   const root = mkroot();

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;