agentic-flow-kit 1.8.2 → 2.0.0

package/templates/_agents/scripts/papercut-debt-sensor.mjs

@@ -1,170 +0,0 @@
-#!/usr/bin/env node
-// papercut-debt-sensor.mjs — papercut 存量债传感器（2026-10-07 papercut-debt 回路 Phase D；B10a 自
-//   Shipyard.Material 回灌——判定面逐字对齐，出处沿革留痕在包源仓 git 历史与 CHANGELOG）
-// 用途：测量设定点误差——workflow/papercuts.md 中未升级条目数（debt）。只读、零子进程、可重复。
-// 口径单源：.agents/loop/papercut-debt/DESIGN.md §1/§2（改口径先改设计文件，本脚本只实现）。
-//   未升级 = 台账数据行不含 ✅ 字面量。⏸ 暂缓 视为**未升级**（暂缓须带理由，无理由照算债）。
-// 零子进程理由（实测留痕在包源仓 git 历史与 CHANGELOG）：曾有托管 Node 环境 spawnSync 对任意 exe
-//   返回 EBUSY，依赖 git 历史的传感器在该环境不可用（check-loop.mjs 即因此崩过）。故本脚本只读
-//   文件系统——传感器不依赖子进程比依赖更稳，且免受环境回退影响。
-// CRLF：台账检出为 CRLF（全局 core.autocrlf=true），按 split(/\r?\n/) 切行，不依赖行尾格式。
-// 分片感知（B8 已落 ledger-shards）：读侧走 readLedgerText(root,'papercuts')——主台账 ∪
-//   papercuts.d/*.md 自动合并，无分片时等价原读法，传感器零额外逻辑。
-// 用法：node .agents/scripts/papercut-debt-sensor.mjs [--json] [--root <仓库根>]
-// 退出码恒 0——测量失败不该阻断回路；失败时 stderr 出 [ERROR] 行且 debt 记为 null。
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { readLedgerText } from './ledger-shards.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 LEDGER = path.join(ROOT, 'workflow', 'papercuts.md');
-
-// 表格列：| 日期 | 位置 | 症状 | 拟修 |  → 切分后 6 段（首尾空串）
-const COLS = 4;
-// 判定口径（单源，本文件）：台账表格行中含 `✅` 者计为**已消债**（真修完）。
-//   `⏸ 暂缓（日期）：理由` 者计为**已定性**——债已被人读过并判失效，不再驱动回路，
-//   但与 ✅ 分开计数，避免"暂缓"冒充"修完"。`⏸ 暂缓` 无理由者仍计债（迫使人真读一遍）。
-const DONE = '✅';
-const DEFER = '⏸';
-export const DEFER_REASONED_RE = /⏸\s*暂缓（[^）]*）\s*：\s*\S/;
-const DEFER_REASONED = DEFER_REASONED_RE;
-// 「位置」列里抽仓库相对路径做存在性检查；只标 stale 不排除（台账记历史事实，路径改名/删除是常态）
-const PATH_RE = /(?:^|[\s(（`])([.a-zA-Z0-9_][\w./-]*\/[\w./-]+)(?=[\s)）`:：,，]|$)/g;
-
-function parseRow(line) {
-  const parts = line.split('|');
-  // 单元格内可能含 | （代码片段）——多于 COLS+2 段时把中间段并回症状列
-  let cells;
-  if (parts.length > COLS + 2) {
-    const head = parts.slice(1, 3);
-    const tail = parts.slice(-(COLS - 2));
-    cells = [...head, parts.slice(3, parts.length - (COLS - 2)).join('|').trim(), ...tail];
-  } else {
-    cells = parts.slice(1, 1 + COLS).map((s) => s.trim());
-  }
-  while (cells.length < COLS) cells.push('');
-  return { date: cells[0], location: cells[1], symptom: cells[2], proposedFix: cells[3] };
-}
-
-function detectHitCount(text) {
-  // 台账约定：复发时在文本里写「第 2 次命中」「第 3 次命中」——控制器的主排序键
-  let max = 1;
-  for (const m of String(text).matchAll(/第\s*(\d+)\s*次命中/g)) {
-    const n = Number(m[1]);
-    if (Number.isFinite(n) && n > max) max = n;
-  }
-  return max;
-}
-
-function extractPaths(location) {
-  const out = new Set();
-  for (const m of String(location).matchAll(PATH_RE)) {
-    const p = m[1].replace(/[.,;:]+$/, '');
-    if (p.startsWith('.') || p.startsWith('wiki/') || p.startsWith('tmp/')) out.add(p);
-  }
-  return [...out];
-}
-
-// scan(root) 是控制器 import 的解析面——判定口径单源在此，控制器不复制任何判定正则。
-// 「位置」列 [env] 前缀 = 环境约束类（DESIGN §1）：不进债池（scan 不返回），单列 envPending。
-export function scan(root = ROOT) {
-  return parseLedger(root).rows;
-}
-
-// 环境约束挂起（[env] 前缀行）：仅列未 settled 的——写 ⏸ 前提消失 / ✅ 的 env 行已清，不占任何池。
-export function envPending(root = ROOT) {
-  return parseLedger(root).envRows.filter((r) => !r.settled);
-}
-
-function parseLedger(root) {
- const ledger = path.join(root, 'workflow', 'papercuts.md');
- if (!fs.existsSync(ledger)) throw new Error(`台账不存在: ${ledger}`);
- // 分片感知读（B8 ledger-shards）：主台账 ∪ papercuts.d/*.md；无分片时等价原读法
- const raw = readLedgerText(root, 'papercuts');
- const lines = raw.split(/\r?\n/);
-  const rows = [];
-  const envRows = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (!/^\|\s*20\d\d-\d\d-\d\d/.test(line)) continue; // 只取数据行（表头/分隔行/说明行自然排除）
-    const c = parseRow(line);
-    const resolved = line.includes(DONE);
-    const deferred = line.includes(DEFER);
-    const deferredReasoned = DEFER_REASONED.test(line);
-    const paths = extractPaths(c.location);
-    const item = {
-      line: i + 1,
-      date: c.date,
-      location: c.location,
-      symptom: c.symptom,
-      proposedFix: c.proposedFix,
-      hits: detectHitCount(`${c.symptom} ${c.proposedFix}`),
-      resolved,
-      deferred,
-      deferredReasoned,
-      // 「已消债」= 真修完，或已带理由判失效。驱动回路的是这个口径，不是 resolved。
-      settled: resolved || deferredReasoned,
-      stale: paths.length > 0 && paths.every((p) => !fs.existsSync(path.join(root, p))),
-      paths,
-    };
-    (/^\s*`?\[env\]/.test(c.location) ? envRows : rows).push(item);
-  }
-  return { rows, envRows };
-}
-
-function main() {
-  let rows;
-  try {
-    rows = scan();
-  } catch (e) {
-    console.error(`[ERROR] papercut-debt-sensor: ${e.message}`);
-    if (asJson) console.log(JSON.stringify({ error: e.message, debt: null, total: null }, null, 2));
-    return;
-  }
-  const resolved = rows.filter((r) => r.resolved);
-  const settled = rows.filter((r) => r.settled);
-  const unresolved = rows.filter((r) => !r.settled);
-  const stale = unresolved.filter((r) => r.stale);
-  const env = envPending();
-
-  if (asJson) {
-    console.log(JSON.stringify({
-      ledger: path.relative(ROOT, LEDGER).split(path.sep).join('/'),
-      total: rows.length + env.length,
-      resolved: resolved.length,
-      deferredReasoned: settled.filter((r) => r.deferredReasoned).length,
-      settled: settled.length,
-      debt: unresolved.length,
-      envPending: env.map(({ line, date, location, symptom }) => ({ line, date, location, symptom })),
-      stalePaths: stale.length,
-      unresolved: unresolved.map(({ resolved: _r, settled: _s, ...rest }) => rest),
-    }, null, 2));
-    return;
-  }
-
-  console.log(`papercut 存量债 —— ${path.relative(ROOT, LEDGER).split(path.sep).join('/')}`);
-  console.log(`条目 ${rows.length + env.length} · 已消债 ${settled.length}（✅ ${resolved.length} / ⏸带理由 ${settled.filter((r) => r.deferredReasoned).length}） · 未消债 ${unresolved.length}（设定点误差 = debt）`);
-  if (env.length) console.log(`环境约束挂起 ${env.length} 条（[env] 前缀，不计 debt——环境变化后复测前提：消失则 ⏸，实为代码缺陷则去前缀转正）`);
-  if (unresolved.length === 0) {
-    console.log('✅ debt = 0，设定点已达成——无需再跑回路。');
-    return;
-  }
-  const noReason = unresolved.filter((r) => r.deferred && !r.deferredReasoned);
-  if (noReason.length) console.log(`其中 ⏸ 暂缓但无理由 ${noReason.length} 条（不算消债）`);
-  if (stale.length) console.log(`其中位置列路径已不存在 ${stale.length} 条（stale——台账记历史事实，不自动排除）`);
-  console.log('');
-  for (const r of unresolved) {
-    const flags = [r.hits > 1 ? `第${r.hits}次命中` : '', r.deferred ? '暂缓无理由' : '', r.stale ? 'stale' : ''].filter(Boolean).join(' · ');
-    console.log(`  L${r.line} [${r.date}] ${r.location}${flags ? `  (${flags})` : ''}`);
-  }
-  console.log('');
-  console.log('下一步：node .agents/scripts/papercut-debt-controller.mjs   # 选本轮目标（--dry-run 只看不改）');
-}
-
-// 仅直接执行时跑（被控制器 / 测试 import 时不自跑、不打印——控制器只取 scan()）
-if (process.argv[1] && process.argv[1].replace(/\\/g, '/').endsWith('papercut-debt-sensor.mjs')) main();

package/templates/_agents/scripts/papercut-debt-sensor.test.mjs

@@ -1,146 +0,0 @@
-#!/usr/bin/env node
-// papercut-debt-sensor.test.mjs — 存量债传感器 fixture（B10a 自源仓回灌随件测试；源仓无直测，
-//   kit 侧按「新增引擎脚本默认必须带同名 .test.mjs」立——判定面与传感器单源，防再同步漂移）
-// 覆盖：三态计数（未升级 / ✅ 已消债 / ⏸ 暂缓无理由仍计债）/ ⏸带理由消债 / [env] 前缀单列 envPending
-//   不入债池 / 命中次数抽取 / stale 只标不排 / 分片合并读（主台账 ∪ papercuts.d）/ CRLF 容忍 /
-//   管道符并回症状列 / CLI 退出码恒 0（含台账缺失）与 --json 形状
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { scan, envPending, DEFER_REASONED_RE } from './papercut-debt-sensor.mjs';
-
-const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-const CLI = path.join(SCRIPT_DIR, 'papercut-debt-sensor.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 mkroot = () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'papercut-sensor-'));
-  fs.mkdirSync(path.join(root, 'workflow'), { recursive: true });
-  return root;
-};
-const HEADER = '| 日期 | 位置 | 症状 | 拟修 |\n|------|------|------|------|\n';
-const writeLedger = (root, text) => fs.writeFileSync(path.join(root, 'workflow', 'papercuts.md'), text, 'utf8');
-
-// ---- S1 三态计数：未升级 / ✅ 已消债 / ⏸ 暂缓无理由仍计债；⏸带理由消债 ----
-{
-  const root = mkroot();
-  writeLedger(root, HEADER
-    + '| 2026-10-01 | `.agents/commands/build.md` | 症状甲 | 拟修甲 |\n'
-    + '| 2026-10-02 | `.agents/commands/test.md` | 症状乙 | 拟修乙 ✅ 已升级修复(2026-10-03): 已改 |\n'
-    + '| 2026-10-03 | `.agents/scripts/x.mjs` | 症状丙 | 拟修丙 ⏸ 暂缓无理由 |\n'
-    + '| 2026-10-04 | `.agents/scripts/y.mjs` | 症状丁 | 拟修丁 ⏸ 暂缓（2026-10-05）：前提已消失，判失效 |\n');
-  const rows = scan(root);
-  check('S1a 数据行 4 条全入池（env 无）', rows.length === 4, `len=${rows.length}`);
-  check('S1b 未升级计债', rows.filter((r) => !r.settled).length === 2, JSON.stringify(rows.map((r) => r.settled)));
-  check('S1c ✅ 判已消债', rows[1].resolved === true && rows[1].settled === true);
-  check('S1d ⏸ 无理由仍计债（deferred 但不 settled）', rows[2].deferred === true && rows[2].deferredReasoned === false && rows[2].settled === false);
-  check('S1e ⏸带理由判消债', rows[3].deferredReasoned === true && rows[3].settled === true);
-  check('S1f DEFER_REASONED_RE 形态：全角括号+全角冒号+非空理由', DEFER_REASONED_RE.test('⏸ 暂缓（2026-10-05）：理由 X') && !DEFER_REASONED_RE.test('⏸ 暂缓无理由'));
-  fs.rmSync(root, { recursive: true, force: true });
-}
-
-// ---- S2 [env] 前缀：不进债池、单列 envPending（仅未 settled）----
-{
-  const root = mkroot();
-  writeLedger(root, HEADER
-    + '| 2026-10-01 | `[env] 无外网装不上依赖` | 症状戊 | 拟修戊 |\n'
-    + '| 2026-10-02 | `[env] 本机时区漂移` | 症状己 | 拟修己 ⏸ 暂缓（2026-10-03）：前提已消失 |\n'
-    + '| 2026-10-03 | `.agents/scripts/z.mjs` | 症状庚 | 拟修庚 |\n');
-  const rows = scan(root);
-  const env = envPending(root);
-  check('S2a [env] 行不进债池', rows.length === 1 && rows[0].symptom === '症状庚', JSON.stringify(rows.map((r) => r.symptom)));
-  check('S2b envPending 只列未 settled 的 env 行', env.length === 1 && env[0].symptom === '症状戊', JSON.stringify(env.map((r) => r.symptom)));
-  fs.rmSync(root, { recursive: true, force: true });
-}
-
-// ---- S3 命中次数抽取（症状/拟修文本「第 N 次命中」，取最大）----
-{
-  const root = mkroot();
-  writeLedger(root, HEADER
-    + '| 2026-10-01 | `.agents/commands/build.md` | 第 2 次命中：症状辛 | 拟修辛 |\n'
-    + '| 2026-10-02 | `.agents/commands/build.md` | 症状壬 | 拟修壬（第 3 次命中） |\n');
-  const rows = scan(root);
-  check('S3a 第 2 次命中抽出', rows[0].hits === 2, `hits=${rows[0].hits}`);
-  check('S3b 多处命中取最大且默认 1', rows[1].hits === 3, `hits=${rows[1].hits}`);
-  fs.rmSync(root, { recursive: true, force: true });
-}
-
-// ---- S4 stale 只标不排：位置列路径不存在 → stale true；存在 → false ----
-{
-  const root = mkroot();
-  fs.mkdirSync(path.join(root, '.agents', 'scripts'), { recursive: true });
-  fs.writeFileSync(path.join(root, '.agents', 'scripts', 'real.mjs'), '// x\n', 'utf8');
-  writeLedger(root, HEADER
-    + '| 2026-10-01 | `.agents/scripts/real.mjs` | 症状子 | 拟修子 |\n'
-    + '| 2026-10-02 | `.agents/scripts/gone.mjs` | 症状丑 | 拟修丑 |\n');
-  const rows = scan(root);
-  check('S4a 路径存在 → stale false', rows[0].stale === false);
-  check('S4b 路径不存在 → stale true（仍留在 unresolved）', rows[1].stale === true && rows.length === 2);
-  fs.rmSync(root, { recursive: true, force: true });
-}
-
-// ---- S5 分片合并读：主台账 ∪ papercuts.d/*.md（B8 ledger-shards 读侧单源）----
-{
-  const root = mkroot();
-  fs.mkdirSync(path.join(root, 'workflow', 'papercuts.d'), { recursive: true });
-  writeLedger(root, '# 命令/技能 Papercut 留痕\n\n' + HEADER
-    + '| 2026-10-01 | `.agents/commands/build.md` | 主表症状 | 主表拟修 |\n');
-  fs.writeFileSync(path.join(root, 'workflow', 'papercuts.d', '2026-09.md'),
-    HEADER + '| 2026-09-01 | `.agents/commands/test.md` | 分片症状 | 分片拟修 |\n', 'utf8');
-  const rows = scan(root);
-  check('S5a 分片行并入扫描面', rows.length === 2, JSON.stringify(rows.map((r) => r.symptom)));
-  check('S5b 分片行判定照常（未升级计债）', rows.filter((r) => !r.settled).length === 2);
-  fs.rmSync(root, { recursive: true, force: true });
-}
-
-// ---- S6 CRLF 容忍 + 管道符并回症状列 ----
-{
-  const root = mkroot();
-  writeLedger(root, HEADER.replace(/\n/g, '\r\n')
-    + '| 2026-10-01 | `.agents/scripts/w.mjs` | 症状含管道 `a|b` 续 | 拟修寅 |\r\n');
-  const rows = scan(root);
-  check('S6a CRLF 台账照常解析', rows.length === 1, JSON.stringify(rows));
-  // 源仓口径钉死：并回分支只 trim 症状列（中间段），拟修列（尾部段）不 trim——逐字保留
-  check('S6b 单元格内管道符并回症状列（拟修列含原文即可）', rows[0].symptom.includes('a|b') && rows[0].proposedFix.includes('拟修寅'),
-    JSON.stringify({ symptom: rows[0].symptom, proposedFix: rows[0].proposedFix }));
-  fs.rmSync(root, { recursive: true, force: true });
-}
-
-// ---- S7 CLI：退出码恒 0（正常 / 台账缺失），--json 形状 ----
-{
-  const root = mkroot();
-  writeLedger(root, HEADER + '| 2026-10-01 | `.agents/commands/build.md` | 症状卯 | 拟修卯 |\n');
-  const r1 = spawnSync(process.execPath, [CLI, '--json', '--root', root], { encoding: 'utf8' });
-  const j1 = JSON.parse(r1.stdout || '{}');
-  check('S7a 正常：exit 0 + debt 计数', r1.status === 0 && j1.debt === 1 && j1.total === 1 && j1.resolved === 0,
-    JSON.stringify({ status: r1.status, debt: j1.debt }));
-  check('S7b --json unresolved 带行号与命中数', j1.unresolved?.[0]?.line >= 1 && j1.unresolved?.[0]?.hits === 1, JSON.stringify(j1.unresolved));
-  const r2 = spawnSync(process.execPath, [CLI, '--root', root], { encoding: 'utf8' });
-  check('S7c 人读摘要 exit 0 且含 debt 行', r2.status === 0 && /未消债 1/.test(r2.stdout), String(r2.stdout).slice(0, 200));
-
-  const empty = mkroot();
-  const r3 = spawnSync(process.execPath, [CLI, '--json', '--root', empty], { encoding: 'utf8' });
-  const j3 = JSON.parse(r3.stdout || '{}');
-  check('S7d 台账缺失：exit 恒 0 + [ERROR] + debt null（测量失败不阻断回路）',
-    r3.status === 0 && j3.debt === null && /\[ERROR\] papercut-debt-sensor/.test(r3.stderr),
-    JSON.stringify({ status: r3.status, stderr: String(r3.stderr).slice(0, 120) }));
-  fs.rmSync(root, { recursive: true, force: true });
-  fs.rmSync(empty, { recursive: true, force: true });
-}
-
-// ---- S8 kit 适配钉子：读侧必须走 ledger-shards（分片消费）——防再同步回退成裸读主台账 ----
-{
-  const src = fs.readFileSync(CLI, 'utf8');
-  check('S8a 传感器经 readLedgerText 读台账（分片感知）', /readLedgerText\(root,\s*'papercuts'\)/.test(src));
-  check('S8b 零子进程约束：不 import child_process', !/child_process/.test(src));
-}
-
-console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
-process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/pipeline-run-docs.mjs

@@ -1,76 +0,0 @@
-// pipeline-run-docs.mjs — 文档纯函数层（2026-10-08 engine-quality-batch，L2 自 pipeline-run.mjs 拆出）
-// fmGet / placeholdersIn / sectionBody / validateDraftContent / closeoutComplete / summarizeDoc——
-// 零 IO、零 process 依赖、单向被 pipeline-run.mjs（CLI 编排层）消费；判据注释随函数原样迁入。
-// export 面 = 原主文件具名导出（placeholdersIn/validateDraftContent/closeoutComplete）+ 层内消费三函数；
-// 主文件经 re-export 保持对外导出面不变（workflow-board-server 等消费方零改动）。
-export function fmGet(text, key) {
-  const m = text.split(/\r?\n/).find((l) => l.startsWith(`${key}:`));
-  return m ? m.slice(key.length + 1).trim() : null;
-}
-
-// 占位符判定（复核 P1-3 收窄，2026-10-02）：先剔除 code span（`…`）与引号串（"…"）——
-// 正文合法的命令语法占位（如 `next --delegated "<原话>"`）几乎总在 code span 内，
-// 模板实占位符（如 <为什么做；写明需求来源…>）从不包 code span；再匹配剩余裸尖括号。
-export function placeholdersIn(text) {
-  const stripped = String(text)
-    .replace(/^```[\s\S]*?^```$/gm, '') // 复核 P2-B：跨行 code fence 整块剔除（围栏内命令示例占位不属模板占位符）
-    .replace(/`[^`\n]*`/g, '')
-    .replace(/"[^"\n]*"/g, '');
-  const hits = [];
-  for (const re of [/<[^>\n]{1,60}>/g, /YYYY-MM-DD 用户/g]) {
-    let m; while ((m = re.exec(stripped))) hits.push(m[0]);
-  }
-  return [...new Set(hits)].slice(0, 5);
-}
-
-export function sectionBody(text, title) {
-  const lines = text.split(/\r?\n/);
-  const i = lines.findIndex((l) => l.trim() === `## ${title}` || l.trim() === `## ${title}（L1 微改动无实质内容可删本节，不硬填）` || l.trim().startsWith(`## ${title}`));
-  if (i < 0) return null;
-  const body = [];
-  for (let j = i + 1; j < lines.length; j++) {
-    if (/^##\s/.test(lines[j])) break;
-    body.push(lines[j]);
-  }
-  return body.join('\n').trim();
-}
-
-export function validateDraftContent(text, kind, level) {
-  const problems = [];
-  if (!text) return ['文件不存在或为空'];
-  const state = fmGet(text, '状态');
-  if (!state) problems.push('frontmatter 缺「状态:」行');
-  if (kind !== 'incident' && !fmGet(text, '级别')) problems.push('frontmatter 缺「级别:」行');
-  const ph = placeholdersIn(text);
-  if (ph.length) problems.push(`模板占位符残留：${ph.join('、')}`);
-  const required = {
-    intent: level === 'L1' ? ['背景与问题', '目标', '验收标准'] : ['背景与问题', '历史教训/防复发', '目标', '非目标', '约束', '验收标准'],
-    spec: ['功能行为', '数据流', '系统改动', '约束遵守映射'],
-    plan: level === 'L1' ? ['改动方案', '约束与风险', '验证计划'] : ['改动方案', '任务拆解', '执行顺序', '验证计划'],
-    incident: ['时间线', '根因', '复盘三件套'],
-  }[kind] || [];
-  for (const sec of required) {
-    const b = sectionBody(text, sec);
-    if (b === null) { if (!(level === 'L1' && ['非目标', '约束', '任务拆解', '执行顺序'].includes(sec))) problems.push(`缺节：## ${sec}`); }
-    else if (!b) problems.push(`节为空：## ${sec}`);
-  }
-  return problems;
-}
-
-export function closeoutComplete(text) {
-  const body = sectionBody(text, '验收标准');
-  if (body === null) return { ok: false, problems: ['缺「## 验收标准」节'] };
-  const lines = body.split(/\r?\n/);
-  const open = lines.filter((l) => /^\s*-\s\[\s\]\s/.test(l));
-  // 复核 P2-6：证据冒号后须直接跟内容（非空白、非收括号）——「（证据：）」空值不算过
-  const checkedNoEv = lines.filter((l) => /^\s*-\s\[x\]\s/.test(l) && !/证据[:：][^）\s]/.test(l));
-  const problems = [];
-  if (open.length) problems.push(`未勾验收 ${open.length} 条`);
-  if (checkedNoEv.length) problems.push(`已勾缺证据 ${checkedNoEv.length} 条`);
-  return { ok: problems.length === 0, problems };
-}
-
-export function summarizeDoc(text) {
-  const body = text.split(/\r?\n/).filter((l) => l.trim() && !l.startsWith('---') && !/^状态:|^级别:|^日期:|^模块:|^备注:|^risk_level:/.test(l));
-  return body.slice(0, 3).join(' / ').slice(0, 200);
-}

package/templates/_agents/scripts/pipeline-run-run.mjs

@@ -1,63 +0,0 @@
-// pipeline-run-run.mjs — run 存储层（2026-10-08 engine-quality-batch，L2 自 pipeline-run.mjs 拆出）
-// ctxEnv / moduleList / runFileOf / loadRun / saveRun / emit / latestRunId / newRunId + 时间工具（nowIso/today/pad）——
-// run 文件（.agents/cache/pipeline-runs/<id>.json）原子读写与事件流；run schema 零变化。
-// 测试注入契约原样：PIPELINE_RUN_ROOT / PIPELINE_RUN_BIN / PIPELINE_RUN_GIT_BIN（ctxEnv）与
-// PIPELINE_RUN_TODAY（today——时钟依赖消除锚，spec §测试注入契约）。
-import fs from 'node:fs';
-import path from 'node:path';
-
-export const nowIso = () => new Date().toISOString();
-export const today = () => process.env.PIPELINE_RUN_TODAY || nowIso().slice(0, 10);
-export const pad = (n) => String(n).padStart(2, '0');
-
-// ── 环境解析（测试注入点） ─────────────────────────────────────────────
-export function ctxEnv(overrideRoot) {
-  const root = path.resolve(overrideRoot || process.env.PIPELINE_RUN_ROOT || process.cwd());
-  const bin = path.resolve(process.env.PIPELINE_RUN_BIN || path.join(root, '.agents', 'scripts'));
-  const gitPrefix = (process.env.PIPELINE_RUN_GIT_BIN || 'git').split(/\s+/).filter(Boolean);
-  return { root, bin, gitPrefix, runsDir: path.join(root, '.agents', 'cache', 'pipeline-runs') };
-}
-
-export function moduleList(ctx) {
-  try {
-    return fs.readFileSync(path.join(ctx.root, '.agents', 'workflow-modules.txt'), 'utf8')
-      .split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith('#'));
-  } catch { return ['backend', 'frontend', 'ui', 'infra', 'integration', 'pipeline', 'wiki']; } // 夹具缺表时的回退默认（warning 由调用方打）
-}
-
-// ── run 文件（原子写；事件 append-only） ──────────────────────────────
-export function runFileOf(ctx, runId) { return path.join(ctx.runsDir, `${runId}.json`); }
-
-export function loadRun(ctx, runId) {
-  const f = runFileOf(ctx, runId);
-  if (!fs.existsSync(f)) return null;
-  try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { return null; }
-}
-
-export function saveRun(ctx, run) {
-  fs.mkdirSync(ctx.runsDir, { recursive: true });
-  run.updatedAt = nowIso();
-  const f = runFileOf(ctx, run.runId);
-  const tmp = f + '.tmp';
-  fs.writeFileSync(tmp, JSON.stringify(run, null, 2) + '\n');
-  fs.renameSync(tmp, f);
-}
-
-export function emit(run, ev) { run.events.push({ t: nowIso(), ...ev }); }
-
-export function latestRunId(ctx) {
-  if (!fs.existsSync(ctx.runsDir)) return null;
-  const ids = fs.readdirSync(ctx.runsDir).filter((f) => f.endsWith('.json')).map((f) => f.slice(0, -5)).sort();
-  for (let i = ids.length - 1; i >= 0; i--) {
-    const r = loadRun(ctx, ids[i]);
-    if (r && !['done', 'aborted'].includes(r.stopType)) return ids[i];
-  }
-  return ids[ids.length - 1] || null;
-}
-
-export function newRunId(requirement) {
-  const d = new Date();
-  const ascii = (requirement.toLowerCase().match(/[a-z0-9]{2,}/g) || []).slice(0, 3).join('-') || 'task';
-  const rand = Math.random().toString(36).slice(2, 6);
-  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}-${ascii}-${rand}`;
-}