agentic-flow-kit 1.7.16 → 1.8.0

package/templates/_agents/scripts/rewrite-file.test.mjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// rewrite-file.test.mjs — 按行字面替换 + 响亮失败 fixture 套件（2026-10-12 silent-noop-loud-failure）
+// 覆盖：CRLF 保全（papercut 2026-10-06 的静默无操作场景）/ 0 命中不写盘 / 命中数不符期望 /
+//       --allow-multi / --dry-run / 缺文件 fail-loud / find===replace 自伤防护 / 跨行锚串必失败 /
+//       无尾换行保全 / 写后回读校验成功形态
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPT = path.join(SCRIPT_DIR, 'rewrite-file.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 run = (file, args) => {
+  const r = spawnSync(process.execPath, [SCRIPT, file, ...args], { encoding: 'utf8' });
+  return { code: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
+};
+const mk = (name, content) => {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'rewrite-file-'));
+  const p = path.join(d, name);
+  fs.writeFileSync(p, content, 'utf8');
+  return p;
+};
+
+// T1：基本 LF 替换 → exit 0 + 内容正确 + 成功语含回读校验
+{
+  const p = mk('lf.md', 'a\nANCHOR\nc\n');
+  const r = run(p, ['--find', 'ANCHOR', '--replace', 'NEW']);
+  const after = fs.readFileSync(p, 'utf8');
+  check('T1 基本 LF 替换 → exit 0 且内容正确', r.code === 0 && after === 'a\nNEW\nc\n', r.out);
+  check('T1b 成功语含「回读校验通过」', /回读校验通过/.test(r.out), r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T2：CRLF 保全——papercut 2026-10-06 的静默无操作场景，本工具必须真改且不坏行尾
+{
+  const p = mk('crlf.md', 'line1\r\nANCHOR here\r\nline3\r\n');
+  const r = run(p, ['--find', 'ANCHOR', '--replace', 'NEW']);
+  const after = fs.readFileSync(p, 'utf8');
+  check('T2 CRLF 文件替换成功且行尾保全', r.code === 0 && after === 'line1\r\nNEW here\r\nline3\r\n', r.out);
+  check('T2b 未混入裸 LF（无 CRLF→LF 漂移）', !/[^\r]\n/.test(after), JSON.stringify(after));
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T3：0 命中 → exit 1 且文件逐字节不变（核心：绝不存在「以为改了」）
+{
+  const before = 'x\r\nZZZ not here\r\n';
+  const p = mk('nohit.md', before);
+  const r = run(p, ['--find', 'QQQ', '--replace', 'Q']);
+  const after = fs.readFileSync(p, 'utf8');
+  check('T3 0 命中 → exit 1 且文件逐字节不变', r.code === 1 && after === before, r.out);
+  check('T3b 报错点名行尾与常见成因（CRLF 检出态）', /0 命中/.test(r.out) && /CRLF/.test(r.out) && /跨行锚/.test(r.out), r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T4：命中数与期望不符 → exit 1 且不写盘（锚串非唯一时必须响亮，不可顺手全改）
+{
+  const before = 'k\nk\n';
+  const p = mk('multi.md', before);
+  const r = run(p, ['--find', 'k', '--replace', 'K']);
+  const after = fs.readFileSync(p, 'utf8');
+  check('T4 命中 2 ≠ 期望 1 → exit 1 且未写盘', r.code === 1 && after === before && /命中数 2 ≠ 期望 1/.test(r.out), r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T5：显式 --expect 2 → 过（同一行两处命中也按处计）
+{
+  const p = mk('expect2.md', 'k k\n');
+  const r = run(p, ['--find', 'k', '--replace', 'K', '--expect', '2']);
+  const after = fs.readFileSync(p, 'utf8');
+  check('T5 --expect 2 且命中 2 → exit 0 且两处都改', r.code === 0 && after === 'K K\n', r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T6：--allow-multi 多命中 → 过（宽松形态，明示批量）
+{
+  const p = mk('allowmulti.md', 'k\nk\nk\n');
+  const r = run(p, ['--find', 'k', '--replace', 'K', '--allow-multi']);
+  const after = fs.readFileSync(p, 'utf8');
+  check('T6 --allow-multi 三命中 → exit 0 且全改', r.code === 0 && after === 'K\nK\nK\n', r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T7：--allow-multi 与 --expect 互斥 → exit 1（一宽一严无法裁决）
+{
+  const p = mk('conflict.md', 'k\n');
+  const r = run(p, ['--find', 'k', '--replace', 'K', '--allow-multi', '--expect', '1']);
+  check('T7 --allow-multi 与 --expect 互斥 → exit 1', r.code === 1 && /互斥/.test(r.out), r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T8：--dry-run → 不写盘
+{
+  const p = mk('dry.md', 'a\nANCHOR\n');
+  const r = run(p, ['--find', 'ANCHOR', '--replace', 'NEW', '--dry-run']);
+  const after = fs.readFileSync(p, 'utf8');
+  check('T8 --dry-run → exit 0 且未写盘', r.code === 0 && after === 'a\nANCHOR\n' && /dry-run/.test(r.out), r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T9：目标文件不存在 → exit 1 fail-loud（不静默创建新文件）
+{
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'rewrite-file-'));
+  const r = run(path.join(d, 'nope.md'), ['--find', 'a', '--replace', 'b']);
+  check('T9 文件不存在 → exit 1 且不创建文件', r.code === 1 && /不存在/.test(r.out) && !fs.existsSync(path.join(d, 'nope.md')), r.out);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+// T10：find === replace → exit 1（无操作却报成功，正是要堵的形态）
+{
+  const p = mk('same.md', 'a\nSAME\n');
+  const r = run(p, ['--find', 'SAME', '--replace', 'SAME']);
+  check('T10 find === replace → exit 1', r.code === 1 && /相同/.test(r.out), r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T11：跨行锚串（含 \n）→ 0 命中 exit 1——把「\n 锚串匹配 CRLF 文件静默无操作」变成响亮失败
+{
+  const p = mk('crossline.md', 'aaa\r\nbbb\r\n');
+  const r = run(p, ['--find', 'aaa\nbbb', '--replace', 'xxx']);
+  const after = fs.readFileSync(p, 'utf8');
+  check('T11 跨行锚串 → exit 1 且文件不变（提示拆单行锚）', r.code === 1 && after === 'aaa\r\nbbb\r\n' && /跨行锚/.test(r.out), r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T12：无尾换行保全
+{
+  const p = mk('notrailing.md', 'a\nANCHOR');
+  const r = run(p, ['--find', 'ANCHOR', '--replace', 'NEW']);
+  const after = fs.readFileSync(p, 'utf8');
+  check('T12 原文件无尾换行 → 替换后仍无尾换行', r.code === 0 && after === 'a\nNEW', JSON.stringify(after));
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T13：空 --find → exit 1（空串会命中每一行，属误用）
+{
+  const p = mk('emptyfind.md', 'a\n');
+  const r = run(p, ['--find', '', '--replace', 'b']);
+  check('T13 空 --find → exit 1', r.code === 1 && /不能为空串/.test(r.out), r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+// T14：同行的两处命中按处计数，且 --expect 3 精确匹配（处计数语义显式化）
+{
+  const p = mk('twiceinline.md', 'k-k-k\n');
+  const r = run(p, ['--find', 'k', '--replace', 'K', '--expect', '3']);
+  const after = fs.readFileSync(p, 'utf8');
+  check('T14 同行多处按处计数（3 处）→ exit 0', r.code === 0 && after === 'K-K-K\n', r.out);
+  fs.rmSync(path.dirname(p), { recursive: true, force: true });
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+process.exit(fail ? 1 : 0);

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

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+// 常驻面体积预算检查（单源：本脚本 + .agents/rule-budgets.txt；触发点：check-hygiene 检查 13（--all，WARN）、
+// .githooks/pre-commit（--staged，硬拦））
+// 自 sh 版移植 node（2026-10-08 ci 去 sh 化；2026-10-13 自 Shipyard.Material 参考实现回灌）——CI agent（Windows）
+// 免 git-bash 依赖，check-loop 检查 13 从「无 sh 静默跳过」变恒可跑。语义逐条对齐 sh 版：
+//   --all    查「提交后树」全量；--staged 仅查本次暂存触及的条目 + 触及目录的合计
+//   退出码 0 通过 / 1 超限（违例打到 stdout，调用方决定警告还是阻断）；缺预算表 exit 0（fixture 沙箱不拦——既有语义）
+// 「提交后树」= 索引（index）内容：staged 版优先于 HEAD；无 git（fixture）回退工作区文件。
+// 字节口径 = 索引 / HEAD 内容（git cat-file，LF 归一）。禁用工作区 wc -c 口径（CRLF 膨胀系统性偏大，
+// 2026-09-21 实测差 ~500B 一度误判超限）——本脚本所有字节数都走 cat-file，仅无 git 时才落工作区。
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const mode = process.argv[2] === '--staged' ? '--staged' : '--all';
+
+const git = (args) => {
+  const r = spawnSync('git', args, { encoding: 'utf8' });
+  return { ok: !r.error && r.status === 0, out: (r.stdout || '').trim() };
+};
+const root = git(['rev-parse', '--show-toplevel']);
+if (root.ok) process.chdir(root.out); // 非 git 环境（fixture 沙箱）留在原地
+
+const BUDGETS = '.agents/rule-budgets.txt';
+if (!fs.existsSync(BUDGETS)) process.exit(0);
+
+// 「提交后」字节数：索引 → HEAD → 工作区
+const fsize = (f) => {
+  if (git(['cat-file', '-e', `:${f}`]).ok) return Number(git(['cat-file', '-s', `:${f}`]).out);
+  if (git(['cat-file', '-e', `HEAD:${f}`]).ok) return Number(git(['cat-file', '-s', `HEAD:${f}`]).out);
+  try { return fs.readFileSync(f).length; } catch { return 0; }
+};
+
+const staged = mode === '--staged'
+  ? git(['-c', 'core.quotepath=off', 'diff', '--cached', '--name-only']).out.split('\n').filter(Boolean)
+  : [];
+
+// intentional-simple: glob 仅支持预算表在用的两形态——「固定目录 + * 后缀」（.agents/commands/*.md）
+// 与目录本身（/ 结尾，展开一层直接子文件）；表出现更复杂 glob 时再升级
+const expand = (pat) => {
+  if (pat.endsWith('/')) {
+    const dir = pat.replace(/\/$/, '');
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile())
+      .map((e) => path.join(dir, e.name));
+  }
+  if (pat.includes('*')) {
+    const i = pat.lastIndexOf('/');
+    const dir = i < 0 ? '.' : pat.slice(0, i);
+    const name = pat.slice(i + 1);
+    const star = name.indexOf('*');
+    const pre = name.slice(0, star), suf = name.slice(star + 1);
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile()
+      && e.name.startsWith(pre) && e.name.endsWith(suf))
+      .map((e) => path.join(dir, e.name));
+  }
+  return fs.existsSync(pat) ? [pat] : [];
+};
+
+let viol = 0;
+const over = (what, bytes, lim) => { console.log(`常驻面超限：${what} ${bytes}B > 上限 ${lim}B`); 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;
+  if (pat.endsWith('/')) {
+    // 目录合计：--staged 下仅当暂存触及该目录内文件才查（字面前缀匹配，同 sh 版 2026-09-24 口径）
+    if (mode === '--staged' && !staged.some((sf) => sf.startsWith(pat))) continue;
+    const total = expand(pat).reduce((s, f) => s + fsize(f), 0);
+    if (total > Number(lim)) over(`${pat} 合计`, total, lim);
+  } else {
+    for (const f of expand(pat)) {
+      if (mode === '--staged' && !staged.includes(f.replace(/\\/g, '/'))) continue;
+      const b = fsize(f);
+      if (b > Number(lim)) over(f, b, lim);
+    }
+  }
+}
+process.exit(viol ? 1 : 0);

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

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// run-tests — 引擎脚本测试统一入口（2026-10-08 agents-hygiene 批2；2026-10-09 并行化）
+// 用途：一条命令跑 .agents/scripts/ 下全部 *.test.mjs 套件——逐个 node 直跑（与 test.md 逐条口径一致，
+//       不引 node --test：既有套件是自研 check/「合计: PASS n / FAIL n」计数风格，非 node:test 风格）。
+// 语义：套件并发执行（默认 6，--concurrency <N> 可调，1 = 等价旧串行；非正整数 fail-loud）——每套件
+//       stdout/stderr 缓冲、完成即回放（「[run-tests] ▶ 套件名」分隔头，避免并行交错不可读）；
+//       stderr 仅红套件回放尾部 5 行防刷屏；聚合各套件「合计: PASS n / FAIL n」末次计数（无该行按 0 计）；
+//       任一套件 exit 非零 / spawn 失败 / 计数 FAIL>0 → 该套件记红；有红套件即 exit 1。
+//       套件发现 = 目录内 *.test.mjs 字典序（非递归）；回放按完成序（并行的自然结果，不影响裁决）。
+// 红线：只做调度层并行，不改任何套件内部；并发默认 6（2026-10-09 实测：串行 2m47s → 并发4 2m05s →
+// 并发6 1m48s，套件各异步 tmp fixture 无共享态）——Windows spawn 密集会放大瞬时抖动（同日实证一次
+// git EBUSY 偶发红），故不取更高默认；套件内 git 调用已有 gitRetry 防护。
+// 2026-10-10 复测定案（perf 系列）：6→12 仅 -3~5%（114.4s → 111.8/108.4s，本机 12 核，两次 c12 全绿
+// 无偶发红；噪声带 ±3s）——膝点在 4-6 间，并发档位已非杠杆：工作池地板 = check-loop.test 独跑
+// 73.8s（占总时长 65%，234 次套件内顺序 spawn node）。再快须并行化套件内场景（动套件内部结构，
+// 撞本红线），收益/风险另议；默认维持 6。
+// 用法：node .agents/scripts/run-tests.mjs [--dir <目录>] [--only <文件名子串>] [--concurrency <N>]
+//       --dir 默认本脚本所在目录（测试注入钩子）；--only 过滤文件名（调试单套件用，如 --only check-loop）。
+// 测试：node .agents/scripts/run-tests.test.mjs（临时目录夹具：并行全绿聚合 / 红套件 / 崩溃套件 / --only / 空目录 / 并发数校验 / 并发1=串行）
+// 沿革：2026-10-08 立档（串行）；2026-10-09 并行化（sess_52d1d1be 路线图「串行→并行」真缺口）。
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+const val = (flag) => (args.includes(flag) ? args[args.indexOf(flag) + 1] : null);
+const dir = val('--dir') || SCRIPT_DIR;
+const only = val('--only');
+const concRaw = val('--concurrency');
+const CONC = concRaw === null ? 6 : Number(concRaw);
+if (!Number.isInteger(CONC) || CONC < 1) {
+  console.error(`run-tests: --concurrency 须为正整数（现 ${concRaw}）`);
+  process.exit(1);
+}
+
+let suites;
+try {
+  suites = fs.readdirSync(dir).filter((f) => f.endsWith('.test.mjs') && (!only || f.includes(only))).sort();
+} catch (e) {
+  console.error(`run-tests: 无法读取目录 ${dir}（${e.code || e.message}）`);
+  process.exit(1);
+}
+if (!suites.length) {
+  console.error(`run-tests: ${dir} 下无 *.test.mjs${only ? `（--only ${only}）` : ''}`);
+  process.exit(1);
+}
+
+// 工作池调度（完成一个补一个——分块会让最慢套件阻塞同块槽位，2026-10-09 实测 check-loop.test 独占 ~1/3 时长）
+let totalPass = 0, totalFail = 0, red = 0;
+const runSuite = (s) => new Promise((resolve) => {
+  const child = spawn(process.execPath, [path.join(dir, s)]);
+  let out = '', err = '';
+  child.stdout.on('data', (d) => { out += d; });
+  child.stderr.on('data', (d) => { err += d; });
+  child.on('close', (code) => resolve({ stdout: out, stderr: err, status: code, error: null }));
+  child.on('error', (e) => resolve({ stdout: out, stderr: err, status: null, error: e }));
+});
+const replay = (s, r) => {
+  const m = [...String(r.stdout || '').matchAll(/合计: PASS (\d+) \/ FAIL (\d+)/g)].pop();
+  const p = m ? Number(m[1]) : 0;
+  const f = m ? Number(m[2]) : 0;
+  totalPass += p;
+  totalFail += f;
+  const ok = r.status === 0 && f === 0;
+  process.stdout.write(`\n[run-tests] ▶ ${s}\n`);
+  if (r.stdout) process.stdout.write(r.stdout);
+  if (ok) {
+    console.log(`[run-tests] OK ${s}（PASS ${p} / FAIL ${f}）`);
+  } else {
+    red++;
+    console.log(`[run-tests] RED ${s}${r.status != null ? `（exit ${r.status}）` : r.error ? `（spawn ${r.error.code || r.error.message}）` : ''}${m ? `（PASS ${p} / FAIL ${f}）` : ''}`);
+    if (r.stderr) process.stderr.write(String(r.stderr).split('\n').slice(-5).join('\n') + '\n');
+  }
+};
+{
+  const queue = [...suites];
+  const inflight = new Map(); // suite -> promise（回放按提交序记录、完成即按序回放：用「下一个待回放」指针）
+  const pending = [];         // {s, promise}
+  let cursor = 0;
+  const launch = () => {
+    while (inflight.size < CONC && queue.length) {
+      const s = queue.shift();
+      const pr = runSuite(s).then((r) => ({ s, r }));
+      inflight.set(s, pr);
+      pending.push(pr);
+    }
+  };
+  launch();
+  while (cursor < pending.length) {
+    const { s, r } = await pending[cursor++];
+    inflight.delete(s);
+    replay(s, r);
+    launch();
+  }
+}
+console.log(`\n[run-tests] 套件 ${suites.length}（红 ${red}，并发 ${CONC}）｜断言合计 PASS ${totalPass} / FAIL ${totalFail}${red ? '——红套件见上，修复后原路重跑' : '——全绿'}`);
+process.exit(red ? 1 : 0);

package/templates/_agents/scripts/run-tests.test.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+// run-tests.mjs 的夹具驱动测试（2026-10-08 agents-hygiene 批2）
+// 场景：①全绿目录 → exit 0 且聚合计数正确；②含红套件（FAIL>0 + exit 1）→ 记红且 exit 1；
+//       ③崩溃套件（throw，无合计行）→ 记红且 exit 1；④--only 过滤；⑤空目录 → exit 1。
+// 用法：node .agents/scripts/run-tests.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_DIR = path.dirname(fileURLToPath(import.meta.url));
+const MAIN = path.join(SCRIPT_DIR, 'run-tests.mjs');
+const USAGE = '用法：node .agents/scripts/run-tests.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 = (files) => {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'run-tests-fx-'));
+  for (const [name, body] of Object.entries(files)) fs.writeFileSync(path.join(d, name), body);
+  return d;
+};
+const run = (args) => spawnSync(process.execPath, [MAIN, ...args], { encoding: 'utf8' });
+
+// ---- 场景 1：全绿目录 → exit 0 且聚合计数（非 .test.mjs 文件不入围）----
+{
+  const d = mkfix({ 'a.test.mjs': 'console.log("合计: PASS 3 / FAIL 0");', 'b.test.mjs': 'console.log("合计: PASS 2 / FAIL 0");', 'readme.md': 'x' });
+  const r = run(['--dir', d]);
+  check('场景 1：全绿目录 → exit 0', r.status === 0, `exit=${r.status}\n${r.stdout}${r.stderr}`);
+  check('场景 1：聚合计数 PASS 5 / FAIL 0 且红 0', /断言合计 PASS 5 \/ FAIL 0/.test(r.stdout) && /红 0/.test(r.stdout), r.stdout);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 2：红套件（计数 FAIL>0 且 exit 1）→ 记红且 exit 1 ----
+{
+  const d = mkfix({ 'a.test.mjs': 'console.log("合计: PASS 3 / FAIL 0");', 'bad.test.mjs': 'console.log("合计: PASS 1 / FAIL 2"); process.exit(1);' });
+  const r = run(['--dir', d]);
+  check('场景 2：含红套件 → exit 1', r.status === 1, `exit=${r.status}`);
+  check('场景 2：红套件被点名', /RED bad\.test\.mjs/.test(r.stdout) && /红 1/.test(r.stdout) && /FAIL 2/.test(r.stdout), r.stdout);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 3：崩溃套件（无合计行）→ 记红且 exit 1 ----
+{
+  const d = mkfix({ 'boom.test.mjs': 'throw new Error("boom");' });
+  const r = run(['--dir', d]);
+  check('场景 3：崩溃套件 → exit 1 且标红', r.status === 1 && /RED boom\.test\.mjs（exit 1）/.test(r.stdout), r.stdout);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 4：--only 过滤 ----
+{
+  const d = mkfix({ 'aa.test.mjs': 'console.log("合计: PASS 1 / FAIL 0");', 'bb.test.mjs': 'console.log("合计: PASS 2 / FAIL 0");' });
+  const r = run(['--dir', d, '--only', 'bb']);
+  check('场景 4：--only 只跑匹配套件', r.status === 0 && r.stdout.includes('bb.test.mjs') && !r.stdout.includes('aa.test.mjs') && /套件 1/.test(r.stdout), r.stdout);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 5：空目录 → exit 1 报无套件 ----
+{
+  const d = mkfix({ 'readme.md': 'x' });
+  const r = run(['--dir', d]);
+  check('场景 5：空目录 → exit 1 报无套件', r.status === 1 && /无 \*\.test\.mjs/.test(r.stderr || ''), `${r.status}\n${r.stderr}`);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 6：--concurrency 校验——非正整数 fail-loud ----
+{
+  const d = mkfix({ 'a.test.mjs': 'console.log("合计: PASS 1 / FAIL 0");' });
+  for (const bad of ['0', '-2', 'abc', '2.5']) {
+    const r = run(['--dir', d, '--concurrency', bad]);
+    check(`场景 6：--concurrency ${bad} → exit 1 fail-loud`, r.status === 1 && /正整数/.test(r.stderr), `exit=${r.status}\n${r.stderr}`);
+  }
+  const ok = run(['--dir', d, '--concurrency', '1']);
+  check('场景 6：--concurrency 1（串行兼容）→ exit 0 聚合正确', ok.status === 0 && /断言合计 PASS 1 \/ FAIL 0/.test(ok.stdout), `exit=${ok.status}\n${ok.stdout}`);
+  const okN = run(['--dir', d, '--concurrency', '8']);
+  check('场景 6：--concurrency 8（超套件数）→ exit 0', okN.status === 0 && /断言合计 PASS 1 \/ FAIL 0/.test(okN.stdout), `exit=${okN.status}\n${okN.stdout}`);
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
+// ---- 场景 7：并行回放完整（每套件有 ▶ 分隔头且计数聚合不分串）----
+{
+  const d = mkfix({
+    'a.test.mjs': 'console.log("a-out 合计: PASS 1 / FAIL 0");',
+    'b.test.mjs': 'console.log("b-out 合计: PASS 2 / FAIL 0");',
+    'c.test.mjs': 'console.log("c-out 合计: PASS 3 / FAIL 0");',
+  });
+  const r = run(['--dir', d]);
+  check('场景 7：并行全绿 → 聚合 PASS 6 且三套件回放齐全',
+    r.status === 0 && /断言合计 PASS 6 \/ FAIL 0/.test(r.stdout) && /▶ a\.test\.mjs/.test(r.stdout) && /▶ b\.test\.mjs/.test(r.stdout) && /▶ c\.test\.mjs/.test(r.stdout), `exit=${r.status}\n${r.stdout}`);
+  check('场景 7：并行下套件输出不串（a-out 紧邻其回放块）', /▶ a\.test\.mjs\na-out/.test(r.stdout), r.stdout);
+  fs.rmSync(d, { 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/solidify-task.test.mjs

@@ -26,7 +26,7 @@ const ENUMS_FIXTURE = [
   'doc.status.abandoned=superseded cancelled',
   'incident.status.all=open fixed closed',
   'incident.status.active=open',
-  'level.all=L0 L1 L2 L3',
+  'level.all=L1 L2 L3',
 ].join('\n') + '\n';
 
 const mkfix = () => {

package/templates/_agents/scripts/stage-gates.mjs

@@ -6,15 +6,18 @@
 //   incident 入口 = 文件存在 + 「时间线」小节内、行首列表条目含「用户确认」（原 maintain.md §3 约定；
 //     2026-09-30 复核 P2-1 收窄为小节内行首条目；第三轮复核 P1-1 起接受日期前缀形态，与模板样例一致）；
 //     状态 ∈ {open, fixed, closed}（spec/plan 须先于 fixed 起草，故 open 即为有效态）。
-//   入口「级别」须 ∈ L0-L3；缺失即拒（fail-closed）——**但库存量形态短路**（`流程: legacy` 或 日期早于
+//   入口「级别」须 ∈ L1-L3（2026-10-13 L0 退役，自源仓收敛系列 1 回灌；L0 → suspect 走 fail-closed）；
+//     缺失即拒（fail-closed）——**但库存量形态短路**（`流程: legacy` 或 日期早于
 //     确认门生效日）：跳过级别校验与 spec 档（2026-09-30 增量复核 N1——存量最可能缺级别，硬拒会锁死
 //     spec 起草与确认）。
 //   注意：**库存量信号本身即等于「入口已确认」**（judgeDoc：`台账行 || 存量口径`，与检查 15 / 检查 1 /
 //     配对门的既有口径一致——早于确认门生效日的自报日期即存量豁免，不要求另有台账行）；此处「短路」
 //     只额外豁免**级别前置与 spec 档**，不是对台账要求的二次豁免（P2-1：原注释把二者写反，已订正）。
 //   plan 门追加：入口级别（取入口 frontmatter 级别，不取工具 --level）为 L2/L3 时，同名 spec 须已确认（同口径）。
+//   L1 即入口例外（2026-10-13 自 Shipyard 回灌）：同名 intent/incident 均无时，级别 L1 的 plan 自身即入口，
+//     起草/确认门放行（文件已在则级别以文件 frontmatter 为准，禁用 --level L1 放行存量 L2 plan）。
 //   探索泳道豁免（2026-09-30 hybrid-governance-explore-hardening）：同名 intent 仍为 draft 且风险泳道为
-//     L0/L1（级别优先；级别缺失或非法时回落 risk_level——fill-intent 双写同值）→「先起草后确认」是协作道
+//     L1（级别优先；级别缺失或非法时回落 risk_level——fill-intent 双写同值）→「先起草后确认」是协作道
 //     语义（check-loop 检查 19 同款豁免口径），放行 spec/plan 起草与确认；L2/L3 防御道维持入口确认前置。
 //     incident 入口不豁免（过目留痕本就轻量）。收口由 check-loop --hardening 加固门兜底（入 main 前须
 //     intent approved/done + spec/plan 在场）。
@@ -146,32 +149,51 @@ export function specConfirmed(root, base) {
 // suspect 消费规则（双严）：红线类检查按 low 执行（拦红线）；豁免类门（起草豁免/--batch/--auto/加固门
 // lane/泳道豁免/逐阶段深度）按 high 执行（不豁免）。取代原三处并存语义（任一低即低 / 级别优先回落 / 仅级别）。
 export function laneOfEntry(level, risk, riskLevelSince, date) {
-  const L = /^L[0-3]$/.test(level || '') ? level : '';
+  const L = /^L[1-3]$/.test(level || '') ? level : '';
   if (!L) return 'suspect';
-  const R = /^L[0-3]$/.test(risk || '') ? risk : '';
+  const R = /^L[1-3]$/.test(risk || '') ? risk : '';
   const dualProtocol = !!riskLevelSince && /^\d{4}-\d{2}-\d{2}$/.test(date || '') && date >= riskLevelSince;
-  if (dualProtocol) return (R && R === L) ? ((L === 'L0' || L === 'L1') ? 'low' : 'high') : 'suspect';
+  if (dualProtocol) return (R && R === L) ? (L === 'L1' ? 'low' : 'high') : 'suspect';
   if (R && R !== L) return 'suspect';
-  return (L === 'L0' || L === 'L1') ? 'low' : 'high';
+  return L === 'L1' ? 'low' : 'high';
 }
 
 // laneOfDoc：非 intent 件（spec/plan/incident——级别单字段协议）：合法按值判，非法 → suspect。
 export function laneOfDoc(level) {
-  if (!/^L[0-3]$/.test(level || '')) return 'suspect';
-  return (level === 'L0' || level === 'L1') ? 'low' : 'high';
+  if (!/^L[1-3]$/.test(level || '')) return 'suspect';
+  return level === 'L1' ? 'low' : 'high';
 }
 
 // draftGateFor：起草门总判（kind = 'spec' | 'plan'，fill 工具与 confirm-doc 逐阶段门共用）
-export function draftGateFor(kind, root, base) {
+// opts.level（可选，2026-10-13 自 Shipyard 回灌）：仅供 plan「L1 即入口」例外取级别——文件未落盘时认
+// fill 工具传入的 --level；confirm-doc 调用（confirmGateFor）不传，落盘后级别一律以文件 frontmatter 为准。
+export function draftGateFor(kind, root, base, opts = {}) {
   const entry = entryConfirmed(root, base);
   if (!entry.ok) {
-    // 探索泳道豁免（2026-09-30 hybrid-governance-explore-hardening）：L0/L1 draft intent 放行起草
+    // 探索泳道豁免（2026-09-30 hybrid-governance-explore-hardening）：L1 draft intent 放行起草
     // ——「先动手后确认」；泳道取法自 2026-10-02 caliber-convergence 起单源 laneOfEntry（方案 C 分歧
     // 双严：suspect 不豁免——级别/risk_level 缺失、非法或分歧均按防御道走入口确认）。
     const lane = laneOfEntry(entry.level, entry.risk, loadKitPolicy(root).riskLevelSince, entry.date);
     if (entry.kind === 'intent' && entry.status === 'draft' && lane === 'low') {
       return { ok: true, entry, laneBypass: true };
     }
+    // L1 plan 即入口（2026-10-13 自 Shipyard 回灌）：没有 intent/incident 时，这份 plan 自己就是入口。
+    // 文件已在则级别以文件为准（禁止用 --level L1 把已有 L2 plan 放行）；尚未落盘才认 opts.level。
+    if (kind === 'plan' && entry.kind === null) {
+      const planAbs = path.join(root, 'workflow', 'plans', `${base}.md`);
+      const declared = fs.existsSync(planAbs) ? readFm(planAbs, '级别') : (opts.level || '');
+      if (declared === 'L1') {
+        return {
+          ok: true,
+          entry: {
+            ok: true, kind: 'plan', rel: `workflow/plans/${base}.md`, level: 'L1',
+            status: fs.existsSync(planAbs) ? (readFm(planAbs, '状态') || 'draft') : 'draft',
+            selfEntry: true, legacy: false,
+          },
+          laneBypass: true,
+        };
+      }
+    }
     return {
       ok: false,
       reason: `同主题入口未确认——${entry.reason}`,
@@ -183,11 +205,11 @@ export function draftGateFor(kind, root, base) {
   // spec 起草与确认。注意：库存量信号**本身即等于入口已确认**（judgeDoc 的 `台账行 || 存量口径`，
   // 与检查 1 / 15 / 配对门同口径）——台账豁免发生在 judgeDoc，不在本处；本处不做二次豁免
   // （第三轮复核 P2-1：原句「台账要求不豁免」把两件事写反，已订正）。
-  if (!entry.storageLegacy && !/^L[0-3]$/.test(entry.level)) {
+  if (!entry.storageLegacy && !/^L[1-3]$/.test(entry.level)) {
     return {
       ok: false,
       reason: `入口缺合法「级别」字段（现「${entry.level || '缺失'}」，无法判定前置深度）`,
-      hint: '先给入口补「级别: L0-L3」字段，再继续',
+      hint: '先给入口补「级别: L1-L3」字段，再继续',
     };
   }
   if (kind === 'plan' && !entry.storageLegacy && (entry.level === 'L2' || entry.level === 'L3')) {

package/templates/_agents/scripts/trust-mode.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 // trust-mode: AI 自治信任等级管理（2026-09-30 ai-autonomy-trust；同日 hybrid-governance-risk-lanes 加名称双轨）
-// 管理 .agents/trust-mode.json，授权 AI 对 L0/L1 文档进行自治放行（--auto）。
+// 管理 .agents/trust-mode.json，授权 AI 对 L1 文档进行自治放行（--auto）。
 // 等级语义（名称 ↔ 数值双轨：confirm-doc.mjs 读数值 enabled/level，人机接口名称与数值皆收）：
 //   Strict   (level 0, enabled=false): AI 自治关闭（默认）——confirm-doc --auto 一律拒绝
-//   Standard (level 1): AI 可自批 L0/L1 draft -> approved
-//   Trusted  (level 2): AI 可自批 L0/L1 draft -> approved 及 approved -> done（全闭环）
+//   Standard (level 1): AI 可自批 L1 draft -> approved
+//   Trusted  (level 2): AI 可自批 L1 draft -> approved 及 approved -> done（全闭环）
 // 安全默认值：未开启（enabled: false）时，confirm-doc.mjs --auto 一律拒绝。
 import fs from 'node:fs';
 import path from 'node:path';
@@ -45,7 +45,7 @@ function main() {
     }
     writeConfig({ enabled: true, level, name: NAME_BY_LEVEL[level], enabledAt: new Date().toISOString() });
     console.log(`✅ AI 自治模式已开启 (${NAME_BY_LEVEL[level]} / Level ${level})`);
-    console.log(level === 1 ? '   授权范围：L0/L1 文档 draft -> approved' : '   授权范围：L0/L1 文档全闭环 (approved + done)');
+    console.log(level === 1 ? '   授权范围：L1 文档 draft -> approved' : '   授权范围：L1 文档全闭环 (approved + done)');
     return;
   }
 

package/templates/_agents/scripts/trust-mode.test.mjs

@@ -30,7 +30,7 @@ const mkfix = () => {
   fs.writeFileSync(path.join(d, '.agents', 'workflow-enums.txt'),
     ['doc.status.all=draft approved done superseded cancelled', 'doc.status.confirmed=approved done superseded cancelled',
       'doc.status.active=draft approved', 'doc.status.terminal=done superseded cancelled', 'doc.status.abandoned=superseded cancelled',
-      'incident.status.all=open fixed closed', 'incident.status.active=open', 'level.all=L0 L1 L2 L3'].join('\n') + '\n');
+      'incident.status.all=open fixed closed', 'incident.status.active=open', 'level.all=L1 L2 L3'].join('\n') + '\n');
   fs.writeFileSync(path.join(d, '.agents', 'workflow-modules.txt'), '# modules\npipeline\nui\n');
   return d;
 };