agentic-flow-kit 1.7.16 → 1.8.1

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

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+// papercut-debt-controller.test.mjs — 回路控制器 fixture（B10a 自源仓回灌随件测试；源仓无直测，
+//   kit 侧按「新增引擎脚本默认必须带同名 .test.mjs」立——排序键与 scope gate 防再同步漂移）
+// 覆盖：排序键三序（命中次数降序 > 日期降序 > 原行序升序）/ scope gate（源码/数据库面拦下照列）/
+//   stale 与「同上」承接行转待人工定性 / debt=0 达成态 / 全员被拦警示态 / 口径单源（不复制判定正则）/
+//   CLI 退出码（0 正常含无目标；2 测量不可用）与 --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';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const CLI = path.join(SCRIPT_DIR, 'papercut-debt-controller.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-ctrl-'));
+  // 位置列引用的文档面文件须真实存在——否则传感器 stale 判定（位置列路径全不存在）会把
+  // 条目转 needsHuman，排序键 / scope gate 场景测不到目标选取
+  for (const p of ['.agents/commands', '.agents/scripts']) {
+    fs.mkdirSync(path.join(root, ...p.split('/')), { recursive: true });
+  }
+  fs.writeFileSync(path.join(root, '.agents', 'commands', 'a.md'), '# a\n', 'utf8');
+  fs.writeFileSync(path.join(root, '.agents', 'commands', 'b.md'), '# b\n', 'utf8');
+  fs.writeFileSync(path.join(root, '.agents', 'commands', 'c.md'), '# c\n', 'utf8');
+  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');
+const run = (root, ...extra) => spawnSync(process.execPath, [CLI, '--root', root, ...extra], { encoding: 'utf8' });
+
+// ---- S1 排序键：命中次数降序 > 日期降序 > 原行序升序 ----
+{
+  const root = mkroot();
+  writeLedger(root, HEADER
+    + '| 2026-10-01 | `.agents/commands/a.md` | 症状早 | 拟修早 |\n'                       // 行序 1，日期早，hits=1
+    + '| 2026-10-05 | `.agents/commands/b.md` | 症状新 | 拟修新 |\n'                       // 行序 2，日期新，hits=1 → 日期降序胜
+    + '| 2026-10-03 | `.agents/commands/c.md` | 第 2 次命中：症状复发 | 拟修复发 |\n');    // hits=2 → 恒胜
+  const r = run(root, '--json');
+  const j = JSON.parse(r.stdout || '{}');
+  check('S1a exit 0', r.status === 0, `status=${r.status} stderr=${String(r.stderr).slice(0, 120)}`);
+  check('S1b 主排序键 = 命中次数降序', j.target?.location === '`.agents/commands/c.md`', JSON.stringify(j.target?.location));
+  check('S1c 平手时日期降序（近期优先）', j.queue?.[1]?.location === '`.agents/commands/b.md`', JSON.stringify(j.queue?.map((q) => q.location)));
+  check('S1d 再平手原行序升序', j.queue?.[2]?.location === '`.agents/commands/a.md`');
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- S2 scope gate：拟修触及源码/数据库面 → 拦下照列（不选为目标）----
+{
+  const root = mkroot();
+  writeLedger(root, HEADER
+    + '| 2026-10-01 | `.agents/commands/a.md` | 文档面症状 | 补一段说明 |\n'
+    + '| 2026-10-02 | `backend/api/x.py` | 源码面症状 | 修校验逻辑 |\n'
+    + '| 2026-10-03 | `tests/` | 测试面症状 | 补用例（涉及 DDL） |\n');
+  const r = run(root, '--json');
+  const j = JSON.parse(r.stdout || '{}');
+  check('S2a exit 0（含全部被拦态）', r.status === 0);
+  check('S2b scope gate 拦下 2 条（backend/ + tests/DDL）', j.skippedOutOfScope?.length === 2, JSON.stringify(j.skippedOutOfScope?.map((s) => s.location)));
+  check('S2c 在选目标只含文档面条目', j.target?.location === '`.agents/commands/a.md`', JSON.stringify(j.target?.location));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- S3 stale 与「同上」承接行 → needsHuman（不作为自动目标）----
+{
+  const root = mkroot();
+  writeLedger(root, HEADER
+    + '| 2026-10-01 | `.agents/commands/a.md` | 文档面症状甲 | 拟修甲 |\n'
+    + '| 2026-10-02 | `.agents/scripts/gone.mjs` | 路径已不存在 | 定性失效 |\n'
+    + '| 2026-10-03 | 同上两处 | 承接上行 | 定性重定位 |\n');
+  const r = run(root, '--json');
+  const j = JSON.parse(r.stdout || '{}');
+  check('S3a stale 与「同上」行转待人工', j.needsHuman?.length === 2, JSON.stringify(j.needsHuman?.map((h) => h.location)));
+  check('S3b 待人工条目不进 queue', !j.queue?.some((q) => q.location === '.agents/scripts/gone.mjs' || q.location === '同上两处'));
+  check('S3c 文档面条目照常在选', j.target?.location === '`.agents/commands/a.md`');
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- S4 debt = 0：achieved 态（本轮无目标）----
+{
+  const root = mkroot();
+  writeLedger(root, HEADER
+    + '| 2026-10-01 | `.agents/commands/a.md` | 症状 | 拟修 ✅ 已升级修复(2026-10-02): 已改 |\n');
+  const r = run(root, '--json');
+  const j = JSON.parse(r.stdout || '{}');
+  check('S4a debt=0 → achieved true 且无目标', r.status === 0 && j.achieved === true && j.target === null && j.debt === 0,
+    JSON.stringify({ debt: j.debt, achieved: j.achieved }));
+  const r2 = run(root);
+  check('S4b 人读口径出「设定点已达成」', /设定点已达成/.test(r2.stdout));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- S5 全员被 scope gate 拦 → 警示态、exit 0 ----
+{
+  const root = mkroot();
+  writeLedger(root, HEADER + '| 2026-10-01 | `backend/api/x.py` | 源码面症状 | 修校验逻辑 |\n');
+  const r = run(root);
+  check('S5a 全员被拦：exit 0 + 需人工授权警示', r.status === 0 && /scope gate 拦下/.test(r.stdout) && /需人工决定是否单独授权/.test(r.stdout),
+    JSON.stringify({ status: r.status, stdout: String(r.stdout).slice(0, 200) }));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- S6 测量不可用：exit 2（debt 未知）----
+{
+  const root = mkroot();
+  const r = run(root, '--json');
+  const j = JSON.parse(r.stdout || '{}');
+  check('S6a 台账缺失 → exit 2 + error JSON', r.status === 2 && j.target === null && typeof j.error === 'string',
+    JSON.stringify({ status: r.status, error: j.error }));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- S7 kit 适配钉子：口径单源（控制器不复制传感器判定正则）----
+{
+  const src = fs.readFileSync(CLI, 'utf8');
+  check('S7a 控制器 import 传感器 scan（不复制判定面）', /import\s*\{\s*scan as sensorScan\s*\}\s*from\s*'\.\/papercut-debt-sensor\.mjs'/.test(src));
+  check('S7b 控制器不复制 ✅/⏸ 判定正则', !/'✅'|"✅"/.test(src.replace(/^\/\/.*$/gm, '')));
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+process.exit(fail ? 1 : 0);

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

@@ -0,0 +1,170 @@
+#!/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

@@ -0,0 +1,146 @@
+#!/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.mjs

@@ -21,7 +21,7 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 
 const KINDS = ['require', 'fix', 'verify', 'review', 'deploy'];
-const LEVELS = ['L0', 'L1', 'L2', 'L3'];
+const LEVELS = ['L1', 'L2', 'L3']; // L0 已退役（2026-10-13 自源仓收敛系列 1 回灌）——级别三档，L1 = 一份 plan 即入口
 const TERMINAL = ['done', 'superseded', 'cancelled', 'closed'];
 const FIX_CAP = 3;
 const GIT_NEVER_FLAGS = ['--no-verify', '-n']; // 不变量：任何 git 调用不得携带（防御性断言，正常路径不会拼出）
@@ -122,7 +122,7 @@ export function stageBar(run) {
         : [['Plan', ['intent-fill', 'intent-draft', 'intent-confirm', 'incident-fill', 'incident-draft', 'incident-confirm', 'triage'].includes(s)],
           ['Design', ['spec-fill', 'spec-draft', 'spec-review', 'spec-confirm'].includes(s)],
           ['Build', ['plan-fill', 'plan-draft', 'plan-confirm', 'changes-confirm', 'implement', 'fix', 'changes-verify'].includes(s)],
-          ['Test', ['verify', 'review', 'closeout', 'done-confirm', 'incident-fixed-confirm', 'incident-closed-confirm', 'direct-commit', 'direct-edit'].includes(s) || s === 'done']];
+          ['Test', ['verify', 'review', 'closeout', 'done-confirm', 'incident-fixed-confirm', 'incident-closed-confirm', 'direct-commit'].includes(s) || s === 'done']];
   const curIdx = seq.findIndex(([, cur]) => cur);
   return seq.map(([name], i) => mk(name, i < curIdx ? 'past' : i === curIdx ? 'cur' : 'future')).join(' ');
 }
@@ -342,7 +342,7 @@ function advance(ctx, run, opt) {
             instructions: [
               '1. 读 .agents/scripts/level-criteria.mjs 判据单源（L2_SURFACES 触达面闭集 / L1 默认档 / L3_SURFACES 结构面；new-task.md 只承载流程表，判据一律看单源；机器面可先跑 `flow-kit route --kind require` 取路径下限提示）',
               `2. 对需求定级：「${run.requirement}」${run.hint ? `（预判参考：${run.hint}）` : ''}`,
-              '3. 回填：next --triage "kind=require|fix|verify|review|deploy level=L0-L3 module=<词表> topic=<英文kebab>"',
+              '3. 回填：next --triage "kind=require|fix|verify|review|deploy level=L1-L3 module=<词表> topic=<英文kebab>"',
             ],
             context: { docPath: '.agents/commands/new-task.md', kbHits: [], stderrTail: '', relatedDocs: ['workflow/INDEX.md'] },
             constraints: ['判级就高不就低；勾红线必 L2+；module 取 .agents/workflow-modules.txt 词表'],
@@ -360,8 +360,7 @@ function advance(ctx, run, opt) {
         run.docs = run.docs || { entry: null, spec: null, plan: null };
         // 路由
         run.stage = K() === 'verify' ? 'verify' : K() === 'review' ? 'review-only' : K() === 'deploy' ? 'deploy-check'
-          : K() === 'require' && L() === 'L0' ? 'direct-edit'
-            : K() === 'fix' ? 'incident-fill' : 'intent-fill';
+          : K() === 'fix' ? 'incident-fill' : 'intent-fill';
         continue;
       }
       run.stage = 'intent-fill'; continue;
@@ -489,7 +488,7 @@ function advance(ctx, run, opt) {
       const rel = `workflow/plans/${today()}-${topic()}.md`;
       run.docs.plan = rel;
       if (!docState(ctx, rel)) {
-        const r = runNode(ctx, run, 'fill-plan.mjs', ['--level', L() === 'L0' ? 'L1' : L(), '--topic', topic(), '--output', rel]);
+        const r = runNode(ctx, run, 'fill-plan.mjs', ['--level', L(), '--topic', topic(), '--output', rel]);
         if (r.exit !== 0) stopGateFail(ctx, run, s, [`fill-plan exit ${r.exit}（G1 前置门或参数）：${(r.stderr || r.stdout).split(/\r?\n/).slice(-3).join(' | ')}`]);
       }
       run.stage = 'plan-draft';
@@ -667,22 +666,7 @@ function advance(ctx, run, opt) {
       stopConfirm(ctx, run, rest[0], `${label}——逐份原话，一次一份（余 ${rest.length} 份）`, true);
     }
 
-    if (s === 'direct-edit') {
-      if (!opt.files) {
-        issueWO(ctx, run, wo(run, {
-          kind: 'implement', title: `L0 直改：${briefReq(run)}`, goal: 'docs/样式微调，无行为影响——直接改后提交',
-          instructions: ['1. 按需求直接修改目标文件', '2. 完成后回填：next --files "…"（脚本核对改动面并走 pre-commit 提交）'],
-          context: { docPath: '', kbHits: run.lastKbHits || [], stderrTail: '', relatedDocs: [] },
-          constraints: ['L0 语义：无行为影响；越此范围=判级错误，停机上报改判'],
-          acceptance: ['git 改动 ⊆ 回填清单', 'pre-commit 门通过'],
-        }), 'direct-edit');
-      }
-      const a = checkAuthorized(ctx, run, opt.files);
-      if (!a.ok) stopGateFail(ctx, run, s, a.problems);
-      const c = docsCommit(ctx, run, run.lastFiles, `docs(${run.triage.module}): ${briefReq(run)}（L0，pipeline-run ${run.runId}）`);
-      if (!c.ok) stopGateFail(ctx, run, s, [c.msg]);
-      stopDone(ctx, run);
-    }
+    // direct-edit 分支随 L0 退役删除（2026-10-13 自源仓收敛系列 1 回灌）——最低档 L1 走 intent+plan 闭环。
 
     if (s === 'verify-only') { run.stage = 'verify'; continue; }
     if (s === 'review-only') {