agentic-flow-kit 0.4.0 → 0.6.0

package/templates/_agents/scripts/wf-journal.test.mjs

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+// wf-journal.test.mjs — run journal 测试（2026-09-26 orchestration-journal-human）
+// 方法：纯函数（replayRun/planStages/latestRun）fixture 直测 + CLI add/status spawn 冒烟（临时 journal + 临时 workflows 目录）
+//       + 真实仓库 pipeline-closing 解析（human 形态行在位）。
+// 判据：① schema 各字段与 attempt/run 语义 ② 末次生效 ③ 就绪/待定/中止分层 ④ 坏行容忍 ⑤ 9 列/human 列两代表全解析
+// 用法：node templates/_agents/scripts/wf-journal.test.mjs（npm test 随跑）
+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 { replayRun, planStages, latestRun } from './wf-journal.mjs';
+import { parseStages } from './workflows-check.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 SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const JOURNAL_CLI = path.join(SCRIPT_DIR, 'wf-journal.mjs');
+
+const mkline = (over = {}) => JSON.stringify({ ts: '2026-09-26T10:00:00Z', run: 'w@20260926-1000', wf: 'w', stage: 'a', status: 'pass', attempt: 1, ...over });
+const STAGES = parseStages(`| id | after | role | step | task | files | accept | gate | human | retries |
+|----|-------|------|------|------|-------|--------|------|-------|---------|
+| a | — | implementer | — | 做 A | src/** | 过 | | | |
+| ask | a | — | — | 用户确认 | — | 一句可以 | | 用户确认 | |
+| b | ask | — | — | — | — | — | npm test | | |
+| c | b | — | — | — | — | — | npm run build | | |
+`) || [];
+
+// ---- S1 replayRun：字段进 state、total 计数 ----
+{
+  const r = replayRun([mkline(), mkline({ stage: 'ask', form: 'human', status: 'pass', note: '用户点头' })], 'w@20260926-1000');
+  check('S1 replayRun 记 2 条且 form/note 进 state',
+    r.total === 2 && r.state.a.status === 'pass' && r.state.ask.form === 'human' && r.state.ask.note === '用户点头',
+    JSON.stringify(r));
+}
+
+// ---- S2 末次生效 + attempt 取最大（fail→pass 重试）----
+{
+  const r = replayRun([
+    mkline({ stage: 'b', status: 'fail', attempt: 1 }),
+    mkline({ stage: 'b', status: 'fail', attempt: 2 }),
+    mkline({ stage: 'b', status: 'pass', attempt: 3 }),
+  ], 'w@20260926-1000');
+  check('S2 末次状态生效 pass 且 attempt=3',
+    r.state.b.status === 'pass' && r.state.b.attempt === 3,
+    JSON.stringify(r.state.b));
+}
+
+// ---- S3 其他 run / 坏行不混入 ----
+{
+  const r = replayRun([
+    mkline({ stage: 'a' }),
+    mkline({ stage: 'x', run: 'w@OTHER' }),
+    '{ broken json',
+    mkline({ stage: 'a', status: 'nope' }),
+  ], 'w@20260926-1000');
+  check('S3 异 run 过滤 + 坏 JSON/坏 status 计 bad 不进 state',
+    r.total === 1 && r.bad === 2 && !r.state.x,
+    JSON.stringify(r));
+}
+
+// ---- S4 latestRun：取该 wf 最后一条 run ----
+{
+  const run = latestRun([mkline({ run: 'w@A' }), mkline({ run: 'w@B', stage: 'a' })], 'w');
+  check('S4 latestRun 取末条 w@B', run === 'w@B', String(run));
+}
+
+// ---- S5 planStages：空状态 → 第 0 层就绪；pass 后下层就绪；fail 下层待定 ----
+{
+  const p0 = planStages(STAGES, {});
+  const p1 = planStages(STAGES, { a: { status: 'pass', attempt: 1 } });
+  const p2 = planStages(STAGES, { a: { status: 'pass', attempt: 1 }, ask: { status: 'fail', attempt: 1 } });
+  check('S5 分层：首层 a 就绪 → a 过后 ask 就绪 → ask fail 时 b/c 待定且 ask 重试就绪',
+    p0.ready.map((s) => s.id).join() === 'a'
+      && p1.ready.map((s) => s.id).join() === 'ask'
+      && p2.ready.some((s) => s.id === 'ask' && s.retry === 1)
+      && p2.pending.map((s) => s.id).join() === 'b,c',
+    JSON.stringify({ p0, p1, p2 }));
+}
+
+// ---- S6 planStages：blocked 标注中止 + 依赖中止提示 ----
+{
+  const p = planStages(STAGES, { a: { status: 'pass', attempt: 1 }, ask: { status: 'blocked', attempt: 1, note: '用户驳回' } });
+  check('S6 blocked 进中止列且下游标依赖中止',
+    p.blocked.length === 1 && p.blocked[0].id === 'ask' && p.blocked[0].note === '用户驳回'
+      && p.pending.some((s) => s.id === 'b' && s.depBlocked),
+    JSON.stringify(p));
+}
+
+// ---- S7 CLI add 冒烟：attempt 自动计次 + run 复用 ----
+{
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'wfj-cli-'));
+  const j = path.join(tmp, 'j.jsonl');
+  const run = (args) => spawnSync(process.execPath, [JOURNAL_CLI, ...args], { encoding: 'utf8' });
+  const r1 = run(['add', '--wf', 'w', '--stage', 'a', '--status', 'pass', '--journal', j]);
+  const r2 = run(['add', '--wf', 'w', '--stage', 'a', '--status', 'fail', '--journal', j]);
+  const lines = fs.readFileSync(j, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
+  check('S7 add×2 attempt 自动 1→2 且 run 复用同 id',
+    r1.status === 0 && r2.status === 0 && lines.length === 2
+      && lines[0].attempt === 1 && lines[1].attempt === 2 && lines[0].run === lines[1].run,
+    JSON.stringify({ r1: r1.stdout + r1.stderr, r2: r2.stdout + r2.stderr, lines }));
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ---- S8 CLI status 冒烟：临时 workflows 目录 + 坏行容忍 ----
+{
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'wfj-st-'));
+  const wfRoot = path.join(tmp, 'workflows');
+  fs.mkdirSync(wfRoot, { recursive: true });
+  fs.writeFileSync(path.join(wfRoot, 'demo.md'),
+    '---\nname: demo\ndescription: d\n---\n\n' +
+    '| id | after | role | step | task | files | accept | gate | retries |\n' +
+    '|----|-------|------|------|------|-------|--------|------|---------|\n' +
+    '| a | — | — | — | — | — | — | npm test | |\n' +
+    '| b | a | — | — | — | — | — | npm run build | |\n');
+  const j = path.join(tmp, 'j.jsonl');
+  fs.writeFileSync(j, '{ broken\n' + mkline({ wf: 'demo', stage: 'a' }) + '\n');
+  const r = spawnSync(process.execPath, [JOURNAL_CLI, 'status', '--wf', 'demo', '--journal', j, '--wf-root', wfRoot], { encoding: 'utf8' });
+  check('S8 status：坏行告警不炸、a 已完成、b 就绪',
+    r.status === 0 && /坏行 1 条/.test(r.stderr) && /已完成（1）：a/.test(r.stdout) && /就绪（1）：b/.test(r.stdout),
+    JSON.stringify({ out: r.stdout, err: r.stderr }));
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+// ---- S9 真实仓库：pipeline-closing 解析含 human 形态 confirm 行；无 journal 时首层就绪 ----
+{
+  const ROOT = path.resolve(SCRIPT_DIR, '..', '..', '..');
+  const wfFile = path.join(ROOT, '.agents', 'workflows', 'pipeline-closing.md');
+  if (!fs.existsSync(wfFile)) {
+    console.log('SKIP  S9（非包源仓库，无 pipeline-closing）');
+  } else {
+    const stages = parseStages(fs.readFileSync(wfFile, 'utf8')) || [];
+    const confirm = stages.find((s) => s.id === 'confirm');
+    const j = path.join(os.tmpdir(), `wfj-real-${Date.now()}.jsonl`);
+    const r = spawnSync(process.execPath, [JOURNAL_CLI, 'status', '--wf', 'pipeline-closing', '--journal', j], { encoding: 'utf8', cwd: ROOT });
+    check('S9 真实 pipeline-closing：confirm 为 human 形态且无 journal 时 author 首层就绪',
+      !!confirm && confirm.human && !confirm.role && stages.length >= 10
+        && r.status === 0 && /就绪（第 0 层.*author/.test(r.stdout),
+      JSON.stringify({ confirm, out: r.stdout }));
+    fs.rmSync(j, { force: true });
+  }
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/workflow-board-server.mjs

@@ -8,7 +8,8 @@ import http from 'node:http';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { execFile } from 'node:child_process';
+import { execFile, spawnSync } from 'node:child_process';
+import { ENUMS } from './workflow-enums.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
 const WORKFLOW = path.join(ROOT, 'workflow');
@@ -37,9 +38,10 @@ function parseDoc(text) {
   return { meta, title };
 }
 
-// ---- 验收标准 checkbox 统计：仅「## 验收标准」节内（至下一个 ## 标题），无该节返回 null ----
+// ---- 验收标准 checkbox 统计：仅「验收标准」节内（至下一个 ## 标题），无该节返回 null ----
+// 节匹配对齐 check-loop 检查 8 口径（^\s*##\s[^#]*验收标准，2026-09-27 board-kb-p1——「## 三、验收标准」类标题此前识别不到）
 function parseAcceptance(text) {
-  const h = text.match(/^## 验收标准.*$/m);
+  const h = text.match(/^\s*##\s[^#]*验收标准.*$/m);
   if (!h) return null;
   const rest = text.slice(h.index + h[0].length);
   const next = rest.match(/^## /m);
@@ -49,19 +51,20 @@ function parseAcceptance(text) {
   const done = (section.match(/^\s*[-*] \[[xX]\]/gm) || []).length;
   return { done, total };
 }
+export { parseAcceptance };
 
 // ---- 配对断裂检测：按 slug 聚合同族（同名 intent/incident/plan/spec），异常卡附 alerts ----
-// 规则（口径对齐 check-loop.sh 的硬断档 + 状态枚举，看板为预警层、不阻断）：
+// 规则（口径对齐 check-loop.sh 的硬断档 + 状态枚举，看板为预警层、不阻断；枚举读单源 workflow-enums.txt）：
 //   孤儿 spec / 孤儿 plan（无同名 intent·incident 入口）；入口 done 但 plan 未终态（看板启发式）；
 //   入口缺 plan（intent 一律要求；incident 需非 legacy 且级别 L1/L2/L3）；L2/L3 入口缺同名 spec；
 //   spec L3 确认三件缺失（确认结果 / 确认时间 / 正文独立复核行）；
-//   状态不在枚举内或缺失（intent·spec·plan: approved/done/superseded/cancelled；incident: open/fixed/closed）
-const PLAN_TERMINAL = ['done', 'superseded', 'cancelled'];
+//   状态不在枚举内或缺失（doc=confirmed 集；incident=all 集）
+const PLAN_TERMINAL = ENUMS['doc.status.terminal'];
 const STATUS_ENUM = {
-  intents: ['approved', 'done', 'superseded', 'cancelled'],
-  specs: ['approved', 'done', 'superseded', 'cancelled'],
-  plans: ['approved', 'done', 'superseded', 'cancelled'],
-  incidents: ['open', 'fixed', 'closed'],
+  intents: ENUMS['doc.status.confirmed'],
+  specs: ENUMS['doc.status.confirmed'],
+  plans: ENUMS['doc.status.confirmed'],
+  incidents: ENUMS['incident.status.all'],
 };
 const NO_STATUS = '（未填）';
 const L3_REVIEW = /^- 独立复核：[ \t]*[^<\s]/m; // 正文独立复核行须有实质内容（对照 check-loop 锚定）
@@ -94,7 +97,7 @@ function detectAlerts(cards) {
       alerts.push('入口缺 plan：无同名 plan');
     if (isEntry && !legacyIncident && ['L2', 'L3'].includes(c.level) && !types.has('specs'))
       alerts.push(`${c.level} 入口缺同名 spec`);
-    if (c.type === 'specs' && c.level === 'L3' && !['superseded', 'cancelled'].includes(c.status)) {
+    if (c.type === 'specs' && c.level === 'L3' && !ENUMS['doc.status.abandoned'].includes(c.status)) {
       if (c.confirm !== 'approved') alerts.push(`L3 确认缺失：确认结果须为 approved（现 ${c.confirm || '缺失'}）`);
       if (!c.confirmTime) alerts.push('L3 确认缺失：须记录确认时间');
       if (!c.hasReview) alerts.push('L3 复核缺失：须记录新会话独立复核结论');
@@ -156,7 +159,12 @@ async function scanBoard() {
   }
   detectAlerts(cards);
   cards.sort((a, b) => b.date.localeCompare(a.date) || a.type.localeCompare(b.type));
-  return { root: ROOT, pid: process.pid, startedAt: STARTED_AT, counts, cards };
+  const loop = loopHardBlocks(); // hard-block 全局告警（单源 check-loop；null = 校验不可用）
+  return {
+    root: ROOT, pid: process.pid, startedAt: STARTED_AT, counts, cards,
+    loopHardBlocks: loop.blocks, loopNote: loop.note || undefined,
+    activeStatuses: [...ENUMS['doc.status.active'], ...ENUMS['incident.status.active']], // 枚举单源贯通前端（p2-batch2）
+  };
 }
 
 // ---- 路径白名单：resolve 后必须仍在 workflow/ 内 ----
@@ -201,13 +209,54 @@ setInterval(() => { for (const res of sseClients) { if (res.destroyed) sseClient
 const MIME = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8' };
 
 function sendJson(res, code, obj) {
-  res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8' });
+  // X-Frame-Options（p2-batch2）：本地只读服务拒绝被外站 iframe 嵌套（配合 Host 校验收敛攻击面）
+  res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8', 'X-Frame-Options': 'DENY' });
   res.end(JSON.stringify(obj));
 }
 
+// ---- hard-block 告警单源（2026-09-27 board-kb-p1）----
+// 看板不再自建与 check-loop 平行的 hard 规则（此前四类缺失：回路断档/验收未对账/确认未对账/确认内容漂移，
+// test.md「双跑断言」曾必失败）——scanBoard 时 spawn check-loop.mjs，解析其 stderr hard-block 段为全局告警数组：
+// check-loop 未来新增 hard 项看板自动跟随，口径永不分叉。输出 banner 为稳定契约（check-loop 头注释明示
+// doctor/pre-push 按输出消费），本解析由双跑断言测试兜底格式漂移。
+export function parseLoopHardBlocks(stderrText) {
+  const text = String(stderrText || '');
+  const start = text.indexOf('HARD-BLOCK:');
+  if (start === -1) return [];
+  let seg = text.slice(start);
+  const warnIdx = seg.indexOf('WARN');
+  if (warnIdx > 0) seg = seg.slice(0, warnIdx);
+  return seg.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.startsWith('- ['));
+}
+
+function loopHardBlocks() {
+  // TTL 缓存（复核 P2-2 rider）：check-loop 独跑实测 ~10.5s 且 spawnSync 阻塞事件循环——搜索击键/SSE
+  // 连发场景下每请求全跑不可用。60s 内复用上次结果（loopHardBlocks 是预警层非门禁，陈旧 60s 可接受；
+  // 前端 loopNote 均如实展示）。进程级缓存，无失效盲区风险（比照 kb 两元组口径弱化声明：预警层容忍）。
+  const NOW = Date.now();
+  if (loopCache.at && NOW - loopCache.at < 60_000) return loopCache.v;
+  const v = (() => {
+    try {
+      const r = spawnSync(process.execPath, [path.join(ROOT, '.agents', 'scripts', 'check-loop.mjs')], { cwd: ROOT, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+      if (r.error) return { blocks: null, note: `check-loop 不可执行：${r.error.message}` };
+      return { blocks: parseLoopHardBlocks(r.stderr || ''), note: '' };
+    } catch (e) {
+      return { blocks: null, note: e.message };
+    }
+  })();
+  loopCache.at = NOW; loopCache.v = v;
+  return v;
+}
+const loopCache = { at: 0, v: null };
+
 const server = http.createServer(async (req, res) => {
-  const url = new URL(req.url, `http://127.0.0.1:${PORT}`);
   try {
+    // Host 校验（DNS rebinding 缓解，2026-09-27 board-kb-p1）：本地只读服务只认本机 Host
+    const host = String(req.headers.host || '');
+    if (host !== `127.0.0.1:${PORT}` && host !== `localhost:${PORT}`) {
+      return sendJson(res, 403, { error: `Host 不受信任（仅接受 127.0.0.1:${PORT} / localhost:${PORT}）` });
+    }
+    const url = new URL(req.url, `http://127.0.0.1:${PORT}`); // 畸形请求行抛错 → 400（P1-3：原在 try 外，单包可杀进程）
     if (url.pathname === '/api/events') {
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive' });
       res.write('retry: 3000\n\n');
@@ -237,6 +286,9 @@ const server = http.createServer(async (req, res) => {
     res.writeHead(200, { 'Content-Type': MIME[path.extname(abs)] || 'application/octet-stream' });
     fs.createReadStream(abs).pipe(res);
   } catch (e) {
+    if (e && e.code === 'ERR_INVALID_URL') {
+      return sendJson(res, 400, { error: `请求行/URL 非法：${e.message}` }); // 畸形请求不杀进程（P1-3）；只认 URL 错误码——其余 TypeError 是服务端缺陷，如实 500（复核 P2-1）
+    }
     sendJson(res, 500, { error: e.message });
   }
 });
@@ -247,6 +299,10 @@ server.on('error', (e) => {
   process.exit(1);
 });
 
-server.listen(PORT, '127.0.0.1', () => {
-  console.log(`workflow 看板: http://127.0.0.1:${PORT}  （Ctrl+C 停止；只读 workflow/，不写任何文件）`);
-});
+// isMain 守卫（board-kb-p1）：parseLoopHardBlocks 可被测试 import（import 不 listen）
+const isMain = process.argv[1] && process.argv[1].endsWith('workflow-board-server.mjs');
+if (isMain) {
+  server.listen(PORT, '127.0.0.1', () => {
+    console.log(`workflow 看板: http://127.0.0.1:${PORT}  （Ctrl+C 停止；只读 workflow/，不写任何文件）`);
+  });
+}

package/templates/_agents/scripts/workflow-board-server.test.mjs

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+// workflow-board-server 的纯函数测试（2026-09-27 board-kb-p1）
+// 核心 = 「双跑断言」的机器化：test.md 要求「涉及看板告警规则时，用同批 workflow fixture 双跑 check-loop
+// 与看板 /api/board，断言 hard-block 集合被看板告警覆盖（防口径分叉）」——此前是纯手工步骤且必失败
+// （四类 hard-block 看板无对应项）。告警单源化后看板直接消费 check-loop 输出，本测试把双跑断言固化为：
+// check-loop fixture 输出 → parseLoopHardBlocks → 断言四类 hard-block 全覆盖。
+// 断言：①parseLoopHardBlocks 合成样本四类齐；②真 fixture spawn check-loop → 解析覆盖四类（双跑断言）；
+//       ③空/无 hard-block → 空数组；④parseAcceptance 节匹配与 check-loop 检查 8 同口径。
+// 用法：node .agents/scripts/workflow-board-server.test.mjs（import 不 listen——server 有 isMain 守卫）
+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 { parseLoopHardBlocks, parseAcceptance } from './workflow-board-server.mjs';
+import { computeFingerprint } from './confirm-doc.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 SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const CHECK_LOOP = path.join(SCRIPT_DIR, 'check-loop.mjs');
+
+// ---- ①合成样本：四类 hard-block 各一 → 全解析 ----
+{
+  const sample = [
+    '闭环骨架断档（check-loop.sh）— HARD-BLOCK:',
+    '',
+    '- [配对断裂] intent 缺 plan:x.md',
+    '- [回路断档] inc 选「是」但未指明 intent 文件路径',
+    '- [验收未对账] done intent 缺「## 验收标准」节(勾验无从核对):x.md',
+    '- [确认未对账] x.md 状态 done 无用户确认记录',
+    '- [确认内容漂移] x.md done 后内容与确认台账不符',
+    '',
+    'WARN（advisory,不阻断）:',
+    '',
+    '- [WARN 状态未确认] plan 必须...',
+  ].join('\n');
+  const parsed = parseLoopHardBlocks(sample);
+  check('①合成样本解析 5 行 hard-block（WARN 段不混入）', parsed.length === 5, JSON.stringify(parsed));
+  check('①四类目标 hard-block 全覆盖（回路断档/验收未对账/确认未对账/确认内容漂移）',
+    ['回路断档', '验收未对账', '确认未对账', '确认内容漂移'].every((k) => parsed.some((l) => l.includes(k))),
+    JSON.stringify(parsed));
+}
+
+// ---- ②双跑（真 fixture）：spawn check-loop → parseLoopHardBlocks 覆盖四类 ----
+// **检查 8 换锚后的前置条件（2026-09-28 check8-git-anchor）**：检查 8 的生效日锚已从文件名前缀
+// 改为「文件首次加入 git 的日期」，故「验收未对账」这条 hard 的产出**需要 git 首次加入日期可判定**；
+// 非 git 仓会走存量口径、不再产出该 hard（有意语义，见 spec）。因此本场景需为**真 git 仓**——
+// 这不是放宽断言，而是补上使原断言（四类 hard-block 全覆盖）成立的前置；**断言强度与文案均未变**。
+{
+  const T = fs.mkdtempSync(path.join(os.tmpdir(), 'board-loop-test-'));
+  for (const s of ['intents', 'specs', 'plans', 'incidents']) fs.mkdirSync(path.join(T, 'workflow', s), { recursive: true });
+  fs.mkdirSync(path.join(T, '.agents'), { recursive: true });
+  fs.writeFileSync(path.join(T, '.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');
+  const w = (rel, c) => fs.writeFileSync(path.join(T, rel), c);
+  // 回路断档：incident 三件套选「是」但引用 intent 不存在
+  w('workflow/incidents/2026-09-27-loop.md', '---\n状态: open\n级别: L1\n发现: 2026-09-27\n模块: pipeline\n---\n# INCIDENT — loop\n\n## 复盘三件套\n\n1. 结构性修复\n - 是否需要新 intent:\n - 是 → ../intents/2026-09-12-ghost.md\n2. 防复发验证\n3. 规范条目\n');
+  // 验收未对账：done intent 无验收标准节（锚 = git 首次加入日期 → 见上）
+  w('workflow/intents/2026-09-27-acc.md', '---\n状态: done\n级别: L1\n日期: 2026-09-27\n模块: pipeline\n---\n# INTENT — acc\n');
+  // 确认未对账：done 无指纹无台账
+  w('workflow/plans/2026-09-27-cg.md', '---\n状态: done\n级别: L1\n日期: 2026-09-27\n---\n# PLAN — cg\n');
+  // 确认内容漂移：done + 台账 prev + 落盘后篡改
+  {
+    const body = '\n## 验收标准（可测试）\n- [x] 用例通过（证据:fixture）\n';
+    const pre = `---\n状态: approved\n级别: L1\n日期: 2026-09-28\n确认指纹: ${'a'.repeat(16)}\n---\n# INTENT — drift\n${body}`;
+    const fp = computeFingerprint(pre);
+    w('workflow/intents/2026-09-28-drift.md', `---\n状态: done\n级别: L1\n日期: 2026-09-28\n确认指纹: ${fp.slice(0, 16)}\n---\n# INTENT — drift\n${body}确认后篡改行\n`);
+    fs.writeFileSync(path.join(T, '.agents', 'confirmations.jsonl'),
+      JSON.stringify({ ts: '2026-09-28T02:00:00.000Z', doc: 'workflow/intents/2026-09-28-drift.md', stage: 'done', fingerprint: fp, prev: 'approved', source: 'tty' }) + '\n');
+  }
+  // 配对齐 plan（避免无关阻断干扰可读性——配对断裂也会在 hard 段，不影响四类断言）
+  w('workflow/plans/2026-09-27-loop.md', '---\n状态: draft\n级别: L1\n---\n# PLAN — loop\n');
+  w('workflow/plans/2026-09-27-acc.md', '---\n状态: draft\n级别: L1\n---\n# PLAN — acc\n');
+
+  // 真 git 仓（使检查 8 的 git 锚可判定）——本地提交，不入任何远端
+  const G = process.platform === 'win32' ? 'git.exe' : 'git';
+  spawnSync(G, ['init', '-q'], { cwd: T });
+  spawnSync(G, ['add', '-A'], { cwd: T });
+  spawnSync(G, ['-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-qm', 'fixture'], { cwd: T });
+
+  const r = spawnSync(process.execPath, [CHECK_LOOP], { cwd: T, encoding: 'utf8', env: { ...process.env, CHECK_LOOP_ROOT: T } });
+  const parsed = parseLoopHardBlocks(r.stderr || '');
+  check('②双跑：check-loop fixture exit 1（确有 hard-block）', r.status === 1, `exit=${r.status}\n${r.stderr}`);
+  check('②双跑断言：四类 hard-block 均被看板告警解析覆盖',
+    ['回路断档', '验收未对账', '确认未对账', '确认内容漂移'].every((k) => parsed.some((l) => l.includes(k))),
+    JSON.stringify(parsed));
+  fs.rmSync(T, { recursive: true, force: true });
+}
+
+// ---- ③空/无 hard-block → 空数组 ----
+{
+  check('③纯 WARN 输出 → 空数组', parseLoopHardBlocks('check-loop.sh WARN（advisory,不阻断）:\n\n- [WARN x]\n').length === 0);
+  check('③空输入 → 空数组', parseLoopHardBlocks('').length === 0);
+  check('③exit 0 场景（仅 WARN banner）→ 空数组', parseLoopHardBlocks('check-loop.sh WARN（advisory,不阻断）:\n\n- [WARN 引用断档] x\n').length === 0);
+}
+
+// ---- ④parseAcceptance 与 check-loop 检查 8 节匹配同口径 ----
+{
+  const std = '---\n状态: done\n---\n# I\n\n## 验收标准（可测试）\n- [x] 甲（证据:e）\n- [ ] 乙\n';
+  const numbered = '---\n状态: done\n---\n# I\n\n## 三、验收标准\n- [x] 甲（证据:e）\n- [ ] 乙\n';
+  check('④标准标题解析 1/2', parseAcceptance(std)?.done === 1 && parseAcceptance(std)?.total === 2, JSON.stringify(parseAcceptance(std)));
+  check('④带序号标题（## 三、验收标准）此前识别不到、现在同口径', parseAcceptance(numbered)?.total === 2, JSON.stringify(parseAcceptance(numbered)));
+  check('④无验收节 → null', parseAcceptance('---\n状态: done\n---\n# I\n') === null);
+}
+
+// ---- ⑤XSS 剥离口径（p2-batch2；复核 P2-3 备注）----
+// 注意：strip 与 board/index.html loadDoc 的剥离正则是【同款拷贝、非同源】——改 loadDoc 正则时本场景
+// 须同步（防回归能力受限为已知取舍：抽共享模块需前端打包链路，暂不做）。
+// activeStatuses 载荷断言未入本套件（server 侧 scanBoard 非纯函数不可直调）——
+// 以 /api/board 手工探活留证（复核已实测枚举贯通 + X-Frame-Options DENY）。
+{
+  const strip = (s) => s.replace(/<[^>]*>/g, '');
+  const evil = '正常文字 <img src=x onerror=alert(1)> 更多 <script>alert(2)</script> 结束';
+  check('⑤剥标签：img/script 标签清零，正文文字保留',
+    !/<(img|script)/.test(strip(evil)) && strip(evil).includes('正常文字') && strip(evil).includes('结束'),
+    strip(evil));
+  const md = '## 标题\n\n- 列表 **粗体** `code`\n\n[链接](intents/x.md)';
+  check('⑤markdown 语法不受剥标签影响', strip(md) === md);
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/workflow-enums.mjs

@@ -0,0 +1,70 @@
+// workflow-enums 读取器——.agents/workflow-enums.txt 单源（2026-09-25 enum-single-source）
+// 消费方：check-loop.mjs / workflow-board-server.mjs / kb-search.mjs / gen-workflow-index.mjs /
+//         fill-{intent,plan,spec}.mjs（均经本读取器）。（2026-09-26 check-loop sh→node 迁移后，
+//         原先的 sh sed 消费方已退役——全部消费方统一经本读取器，无跨语言读取口径；S11 测试仍守
+//         「空格分隔 + # 注释」格式对简单工具保持可解析）
+// fail-loud 无 fallback：kit 自带该文件，缺失/坏数据属安装破损——直接抛错崩得可见，
+//   doctor §2 布局门同时把关文件存在性。禁止在任何消费方内再抄一份枚举字面量。
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ENUMS_FILE = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'workflow-enums.txt');
+
+// parseEnums(text)：`key=a b` 行 → { key: ['a','b'] }；非法行/重复键/重复值抛错（单源纪律）
+export function parseEnums(text) {
+  const out = {};
+  for (const line of String(text).split(/\r?\n/)) {
+    if (!line || line.startsWith('#')) continue;
+    const m = line.match(/^([a-z][a-z0-9.]*)=(\S.*)$/);
+    if (!m) throw new Error('workflow-enums 行格式非法（须 key=value value）: ' + line);
+    if (m[1] in out) throw new Error('workflow-enums 键重复: ' + m[1]);
+    const vals = m[2].trim().split(/\s+/);
+    if (new Set(vals).size !== vals.length) throw new Error('workflow-enums 值重复: ' + line);
+    out[m[1]] = vals;
+  }
+  return out;
+}
+
+const NEED_KEYS = [
+  'doc.status.all', 'doc.status.confirmed', 'doc.status.active', 'doc.status.terminal', 'doc.status.abandoned',
+  'incident.status.all', 'incident.status.active', 'level.all',
+];
+
+// validateEnums(enums)：跨键不变量（子集关系 + 活跃/终态互斥 + 关键态在位）——坏数据尽早抛错
+export function validateEnums(e) {
+  for (const k of NEED_KEYS) {
+    if (!Array.isArray(e[k]) || !e[k].length) throw new Error('workflow-enums 缺键或空值: ' + k);
+  }
+  const sub = (a, b) => {
+    for (const v of e[a]) if (!e[b].includes(v)) throw new Error(`workflow-enums 不变量破: ${a} 含 ${b} 外的值 ${v}`);
+  };
+  sub('doc.status.confirmed', 'doc.status.all');
+  sub('doc.status.active', 'doc.status.all');
+  sub('doc.status.terminal', 'doc.status.all');
+  sub('doc.status.abandoned', 'doc.status.all');
+  sub('doc.status.abandoned', 'doc.status.terminal');
+  sub('incident.status.active', 'incident.status.all');
+  if (e['doc.status.active'].some((v) => e['doc.status.terminal'].includes(v))) {
+    throw new Error('workflow-enums 不变量破: doc.status.active 与 doc.status.terminal 重叠');
+  }
+  if (!e['doc.status.confirmed'].includes('approved') || !e['doc.status.terminal'].includes('done')) {
+    throw new Error('workflow-enums 不变量破: approved 须在 confirmed、done 须在 terminal（确认/关单语义锚点）');
+  }
+  return e;
+}
+
+// loadEnums(file = 单源标准位置)：读文件 → parse → validate；缺文件抛错（fail-loud）
+export function loadEnums(file = ENUMS_FILE) {
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch (err) {
+    throw new Error('workflow-enums 单源文件不可读（kit 自带，跑 flow-kit sync 恢复）: ' + file + ' — ' + err.message);
+  }
+  return validateEnums(parseEnums(text));
+}
+
+// 模块级常量：import 即加载即校验（标准位置）
+export const ENUMS = loadEnums();
+export default ENUMS;

package/templates/_agents/scripts/workflow-enums.test.mjs

@@ -0,0 +1,110 @@
+// workflow-enums.test.mjs — 枚举单源读取器测试（2026-09-25 enum-single-source）
+// 判据：① 真实单源文件解析 + 不变量通过 ② 坏数据（坏行/重复键/重复值/缺键/子集破/重叠）fail-loud
+//       ③ 缺文件 fail-loud ④ sh 消费方同口径（sed 可取到全部 8 键）
+// 用法：node templates/_agents/scripts/workflow-enums.test.mjs（npm test 随跑）
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { parseEnums, validateEnums, loadEnums, ENUMS } from './workflow-enums.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 throwsWith = (fn, kw) => {
+  try { fn(); return false; } catch (e) { return String(e.message).includes(kw); }
+};
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const ENUMS_TXT = path.join(SCRIPT_DIR, '..', 'workflow-enums.txt');
+
+// ---- S1 模块级 ENUMS 即加载即校验（真实文件），8 键齐 ----
+{
+  const keys = Object.keys(ENUMS).sort();
+  check('S1 真实单源文件加载成功且 8 键齐',
+    keys.length === 8 && keys.join(',') === 'doc.status.abandoned,doc.status.active,doc.status.all,doc.status.confirmed,doc.status.terminal,incident.status.active,incident.status.all,level.all',
+    JSON.stringify(keys));
+}
+
+// ---- S2 真实文件关键值口径（check-loop/看板/检索的行为锚点，值变更须连本测试一起改）----
+{
+  check('S2 关键集值口径：confirmed 不含 draft、active=draft+approved、terminal 含 done、abandoned ⊆ terminal',
+    !ENUMS['doc.status.confirmed'].includes('draft')
+      && ENUMS['doc.status.active'].join('+') === 'draft+approved'
+      && ENUMS['doc.status.terminal'].includes('done')
+      && ENUMS['doc.status.abandoned'].every((v) => ENUMS['doc.status.terminal'].includes(v))
+      && ENUMS['level.all'].length === 4,
+    JSON.stringify(ENUMS));
+}
+
+// ---- S3 坏行 fail-loud ----
+{
+  check('S3 非法行抛错', throwsWith(() => parseEnums('乱行 no-equals-sign'), '行格式非法'));
+}
+
+// ---- S4 重复键 fail-loud ----
+{
+  check('S4 重复键抛错', throwsWith(() => parseEnums('a.b=x\na.b=y'), '键重复'));
+}
+
+// ---- S5 重复值 fail-loud ----
+{
+  check('S5 重复值抛错', throwsWith(() => parseEnums('a.b=x x'), '值重复'));
+}
+
+// ---- S6 缺键 fail-loud（validateEnums）----
+{
+  check('S6 缺键抛错', throwsWith(() => validateEnums({ 'level.all': ['L0'] }), '缺键'));
+}
+
+// ---- S7 子集破 fail-loud ----
+{
+  const bad = {
+    'doc.status.all': ['draft', 'approved', 'done'], 'doc.status.confirmed': ['approved', 'done', 'ghost'],
+    'doc.status.active': ['draft'], 'doc.status.terminal': ['done'], 'doc.status.abandoned': ['cancelled'],
+    'incident.status.all': ['open'], 'incident.status.active': ['open'], 'level.all': ['L0'],
+  };
+  check('S7 子集不变量破抛错', throwsWith(() => validateEnums(bad), '不变量破'));
+}
+
+// ---- S8 活跃/终态重叠 fail-loud ----
+{
+  const bad = Object.fromEntries(Object.entries(ENUMS).map(([k]) => [k, [...ENUMS[k]]]));
+  bad['doc.status.terminal'] = [...bad['doc.status.terminal'], 'draft'];
+  check('S8 active 与 terminal 重叠抛错', throwsWith(() => validateEnums(bad), '重叠'));
+}
+
+// ---- S9 缺文件 fail-loud（loadEnums）----
+{
+  check('S9 单源文件缺失抛错（fail-loud 无 fallback）',
+    throwsWith(() => loadEnums(path.join(SCRIPT_DIR, '..', 'no-such-enums.txt')), '不可读'));
+}
+
+// ---- S10 注释行与空行忽略 ----
+{
+  const e = parseEnums('# 注释\n\nlevel.all=L0 L1\n');
+  check('S10 注释与空行忽略（仅 1 键）', Object.keys(e).length === 1 && e['level.all'].join('+') === 'L0+L1');
+}
+
+// ---- S11 sh 消费方同口径：check-loop.sh 的 sed 取法能取到全部 8 键 ----
+{
+  const key = 'doc.status.confirmed';
+  const val = execSync(`sh -c "sed -n 's/^${key}=//p' '${ENUMS_TXT}' | head -n 1"`, { encoding: 'utf8' }).trim();
+  check('S11 sh sed 取键与 node 读取同值（跨语言单源口径）',
+    val === ENUMS[key].join(' '), `sh=[${val}] node=[${ENUMS[key].join(' ')}]`);
+}
+
+// ---- S12 CRLF 行尾容忍（autocrlf 检出坑：rule-budgets.txt 同约定；node 侧 split(/\r?\n/) 天然免疫，显式锁定）----
+{
+  const crlf = 'doc.status.all=draft approved done superseded cancelled\r\nlevel.all=L0 L1 L2 L3\r\n';
+  const e = parseEnums(crlf);
+  check('S12 CRLF 行尾不残留 \\r（值尾无回车）',
+    e['level.all'].join('+') === 'L0+L1+L2+L3' && !e['doc.status.all'].some((v) => v.includes('\r')),
+    JSON.stringify(e));
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+process.exit(fail ? 1 : 0);