agentic-flow-kit 0.3.1 → 0.5.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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // workflow 实时看板服务：本地只读 http + SSE 文件监听，可视化 AI 执行流程（intents/incidents/plans/specs）。
-// 用法：node .agents/scripts/workflow-board-server.mjs [--port 8933]
+// 用法：node .agents/scripts/workflow-board-server.mjs [--port 8933]；多项目并行请用 ensure-board.mjs 拉起（自动上探可用端口）
 // 零依赖（node:http/node:fs/node:path/node:url/node:child_process）；只读 workflow/ 与 git，仅绑 127.0.0.1。
 // API：GET /（看板页） /marked.min.js（vendor） /api/board /api/doc?file=<相对路径> /api/history?file=<相对路径> /api/events（SSE）
 // 实时边界：文档内容与状态随落盘实时（fs.watch→SSE 推送）；git 历史仅含已提交记录（git 语义）。
@@ -9,6 +9,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFile } 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');
@@ -17,6 +18,7 @@ const DOC_TYPES = ['intents', 'incidents', 'plans', 'specs'];
 
 const portArg = process.argv.indexOf('--port');
 const PORT = portArg > 0 ? Number(process.argv[portArg + 1]) || 8933 : 8933;
+const STARTED_AT = Date.now(); // 随 /api/board 自报（startedAt），供 ensure-board.mjs 判定旧代码重启，不碰进程启动时间 API
 
 // ---- front matter + 标题解析（对照 _TEMPLATE.md 受限子集：每行 `键: 值`）----
 function parseDoc(text) {
@@ -50,17 +52,17 @@ function parseAcceptance(text) {
 }
 
 // ---- 配对断裂检测：按 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 锚定）
@@ -93,7 +95,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 复核缺失：须记录新会话独立复核结论');
@@ -155,7 +157,7 @@ async function scanBoard() {
   }
   detectAlerts(cards);
   cards.sort((a, b) => b.date.localeCompare(a.date) || a.type.localeCompare(b.type));
-  return { root: ROOT, counts, cards };
+  return { root: ROOT, pid: process.pid, startedAt: STARTED_AT, counts, cards };
 }
 
 // ---- 路径白名单：resolve 后必须仍在 workflow/ 内 ----
@@ -240,6 +242,12 @@ const server = http.createServer(async (req, res) => {
   }
 });
 
+// 绑定失败明确退出（EADDRINUSE 常见于直跑撞端口；ensure-board 会先探活选端口，这里兜底可读报错）
+server.on('error', (e) => {
+  console.error(`workflow 看板启动失败（端口 ${PORT}${e.code === 'EADDRINUSE' ? ' 已被占用' : ''}）：${e.code || e.message}`);
+  process.exit(1);
+});
+
 server.listen(PORT, '127.0.0.1', () => {
   console.log(`workflow 看板: http://127.0.0.1:${PORT}  （Ctrl+C 停止；只读 workflow/，不写任何文件）`);
 });

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

@@ -0,0 +1,68 @@
+// workflow-enums 读取器——.agents/workflow-enums.txt 单源（2026-09-25 enum-single-source）
+// 消费方：workflow-board-server.mjs / kb-search.mjs / gen-workflow-index.mjs / fill-{intent,plan,spec}.mjs
+//   （check-loop.sh 为 POSIX sh，自行 sed 读取同文件，口径同本读取器的键）。
+// 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);