flow-comet 1.6.4 → 1.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (85) hide show
  1. package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
  2. package/.flow-comet/skills/flow-comet/SKILL.md +36 -6
  3. package/.flow-comet/skills/flow-comet/reference/artifact-template-overlay.md +154 -0
  4. package/.flow-comet/skills/flow-comet/reference/artifact-templates.json +387 -0
  5. package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +1 -1
  6. package/.flow-comet/skills/flow-comet/reference/entry-detail.md +29 -4
  7. package/.flow-comet/skills/flow-comet/reference/workflow-protocol.json +22 -0
  8. package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +26 -23
  9. package/.flow-comet/skills/flow-comet/scripts/evolve.mjs +174 -0
  10. package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +17 -95
  11. package/.flow-comet/skills/flow-comet/scripts/health.mjs +28 -4
  12. package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +136 -19
  13. package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +54 -18
  14. package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +6 -6
  15. package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +52 -10
  16. package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +25 -10
  17. package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +4 -2
  18. package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +21 -13
  19. package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +163 -0
  20. package/.flow-comet/skills/flow-comet/scripts/lib/ac-coverage.mjs +317 -0
  21. package/.flow-comet/skills/flow-comet/scripts/lib/guard-artifact-skeleton.mjs +448 -0
  22. package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +396 -27
  23. package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +1035 -172
  24. package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +129 -98
  25. package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +8 -6
  26. package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +797 -232
  27. package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +91 -22
  28. package/.flow-comet/skills/flow-comet/scripts/lib/lessons-hits.mjs +160 -0
  29. package/.flow-comet/skills/flow-comet/scripts/lib/run-root.mjs +21 -0
  30. package/.flow-comet/skills/flow-comet/scripts/lib/section-body.mjs +92 -0
  31. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +69 -13
  32. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +454 -135
  33. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +66 -0
  34. package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +109 -13
  35. package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +55 -2
  36. package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +149 -34
  37. package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +79 -9
  38. package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +84 -31
  39. package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +78 -8
  40. package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +60 -3
  41. package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +167 -3
  42. package/.flow-comet/skills/flow-comet/scripts/lib/wave-projection.mjs +341 -0
  43. package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +287 -0
  44. package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +1454 -16
  45. package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1202 -8
  46. package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1205 -77
  47. package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +753 -5
  48. package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +52 -11
  49. package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +582 -3
  50. package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +9 -1
  51. package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +5 -0
  52. package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +22 -6
  53. package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +2 -0
  54. package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +18 -5
  55. package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +4100 -0
  56. package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +135 -0
  57. package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +6 -5
  58. package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +203 -4
  59. package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +312 -63
  60. package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +5 -2
  61. package/.flow-comet/skills/flow-comet-archive/SKILL.md +6 -2
  62. package/.flow-comet/skills/flow-comet-change/SKILL.md +6 -2
  63. package/.flow-comet/skills/flow-comet-design/GUIDANCE.md +13 -3
  64. package/.flow-comet/skills/flow-comet-design/SKILL.md +15 -8
  65. package/.flow-comet/skills/flow-comet-dev/SKILL.md +1 -1
  66. package/.flow-comet/skills/flow-comet-evolve/SKILL.md +1 -0
  67. package/.flow-comet/skills/flow-comet-execute/SKILL.md +42 -15
  68. package/.flow-comet/skills/flow-comet-health/SKILL.md +1 -1
  69. package/.flow-comet/skills/flow-comet-integration/SKILL.md +1 -1
  70. package/.flow-comet/skills/flow-comet-open/GUIDANCE.md +14 -4
  71. package/.flow-comet/skills/flow-comet-open/SKILL.md +11 -9
  72. package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +13 -3
  73. package/.flow-comet/skills/flow-comet-plan/SKILL.md +21 -10
  74. package/.flow-comet/skills/flow-comet-requirement/SKILL.md +1 -1
  75. package/.flow-comet/skills/flow-comet-review/SKILL.md +33 -18
  76. package/.flow-comet/skills/flow-comet-subagent-execute/GUIDANCE.md +13 -3
  77. package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +44 -16
  78. package/.flow-comet/skills/flow-comet-task/SKILL.md +3 -2
  79. package/.flow-comet/skills/flow-comet-test/SKILL.md +6 -2
  80. package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +2 -2
  81. package/.flow-comet/skills/flow-comet-verify/SKILL.md +12 -8
  82. package/README.md +3 -3
  83. package/package.json +1 -1
  84. package/scripts/dsh-bridge.mjs +2 -2
  85. package/scripts/lib/installer-flowkit.mjs +43 -3
@@ -0,0 +1,4100 @@
1
+ // 场景组 n — 模板权威(L1):REQUIREMENT 的 25 条验收准则逐条落夹具。
2
+ // 元素形态 `{ name, run }`;计数由 `lib/count-derivation.mjs` 从本目录聚合,不手抄数字。
3
+ //
4
+ // 夹具设计纪律(本组每一条都遵守):
5
+ // · **模板夹具自足**:每个夹具根自己写 `flow-kit/templates/<DOC>.md`(维护者检出取 vendored
6
+ // 真迹作内容权威,CI 全新检出无 vendored 副本时按登记表合成等价段形)——判据的来源是夹具根
7
+ // 内的模板,因此断言不依赖检出形态,也不会因「模板缺席」被静默跳过。
8
+ // · **每条带反向构造**:负例(抽掉 / 改掉目标 → 必红)与正例(恢复到合规形态 → 必绿)成对构造;
9
+ // 文本类判据用「同一判据函数 + 变异探针」,抽掉目标文字后判据必须发声。
10
+ // · **只判结构级**:断言落在「拦没拦 / 报出了什么类别」上,不断言散文措辞(措辞由 T08/T09 定稿)。
11
+ //
12
+ // 待实现面:本组场景先于实现落盘(RED),由产出物门禁扩展 / 加载链 / 扫描与提名 / 侧命令 /
13
+ // 文本同步各任务转绿。
14
+
15
+ import fs from 'fs';
16
+ import path from 'path';
17
+ import { spawnSync } from 'child_process';
18
+ import { pathToFileURL } from 'url';
19
+ import {
20
+ assertExit,
21
+ assertNotOut,
22
+ assertOut,
23
+ assertTrue,
24
+ baseState,
25
+ runGuard,
26
+ runState,
27
+ writeFile,
28
+ writeState,
29
+ } from '../lib/test-helpers.mjs';
30
+ import {
31
+ CHANGE_ID,
32
+ REPO_ROOT,
33
+ SCRIPTS_DIR,
34
+ TASK_DONE,
35
+ customProtocol,
36
+ dropNamedImport,
37
+ engineCodeText,
38
+ engineDefinitionHits,
39
+ engineDefinitionModule,
40
+ engineDefinitionPattern,
41
+ engineImportsSymbolFrom,
42
+ engineScriptTexts,
43
+ handoffFor,
44
+ HANDOFF,
45
+ STATE,
46
+ writeNodeDeclarationMarkers,
47
+ } from '../lib/test-fixtures.mjs';
48
+ import { scenarioProtocolPath } from '../lib/test-assertions.mjs';
49
+ import { taskBlocks } from '../task-parsing.mjs';
50
+ // 波次段名的登记点与「登记名 ↔ 模板段名」对账:登记值在骨架模块(模板缺席时的段名基准唯一登记处),
51
+ // 归一化取共享实现——两边同一把尺子,改字的段名不得被判成一致。
52
+ import { WAVE_SECTION_NAME } from '../lib/guard-artifact-skeleton.mjs';
53
+ import { normalizeHeading } from '../route-node.mjs';
54
+ import {
55
+ AUTHORITATIVE_SOURCE_ANCHOR_REL,
56
+ GITHOOKS_CODES_REL,
57
+ PUBLIC_FACE_CODE_DOCS,
58
+ SCENARIO_COUNT_FILES,
59
+ SYSTEM_TEST_COUNT_FILES,
60
+ maintainerFacePresent,
61
+ publicFaceDocsAbsent,
62
+ publicFaceSelfCheck,
63
+ singleSourceImportProblems,
64
+ } from '../lib/text-anchor-checks.mjs';
65
+
66
+ // ---------- 登记表与模板夹具(夹具输入面,不是判据) ----------
67
+
68
+ const REGISTRY_FILE = path.join(SCRIPTS_DIR, '..', 'reference', 'artifact-templates.json');
69
+ const CHANGE_DIR = '.specs/' + CHANGE_ID;
70
+ const SKILLS_ROOT = path.join(SCRIPTS_DIR, '..', '..');
71
+ // 公开文档面的形态判据来自 lib 的 publicFaceDocsAbsent(与底部自检、场景 105 同一实现):本组不再
72
+ // 自持第二套(曾按 docs/authority-map.json 是否在场分流,与 lib 的 docs/ 判据各说各话)。
73
+ // 只按 docs/ 在不在也不够——分支 / 稀疏检出 / 误删把 docs/ 拿掉时,整块判据会变成可见 SKIP。
74
+
75
+ let registryMemo;
76
+ function artifactRegistry() {
77
+ if (registryMemo === undefined) {
78
+ try {
79
+ registryMemo = JSON.parse(fs.readFileSync(REGISTRY_FILE, 'utf8'));
80
+ } catch (e) {
81
+ throw new Error('登记表不可读: ' + REGISTRY_FILE + '(' + e.message + ')——模板权威场景的前提条件');
82
+ }
83
+ }
84
+ return registryMemo;
85
+ }
86
+
87
+ function docEntry(key) {
88
+ const templates = artifactRegistry().templates ?? {};
89
+ const hit = Object.keys(templates).find((name) => name.toLowerCase() === String(key).toLowerCase());
90
+ if (!hit) throw new Error('登记表缺模板键: ' + key);
91
+ return templates[hit];
92
+ }
93
+
94
+ function docRel(key) {
95
+ return docEntry(key).file;
96
+ }
97
+
98
+ function docBase(key) {
99
+ return path.posix.basename(docRel(key));
100
+ }
101
+
102
+ function docTitle(key) {
103
+ return String(docEntry(key).titleForm ?? '# ' + key).replace(/<[^>]*>/g, '夹具');
104
+ }
105
+
106
+ // 模板夹具正文:每段给一行占位正文,供「与模板该段逐字相同」判据构造(CI 合成形态与真实模板
107
+ // 同构的只有段形;真实模板在场时正文直接取真迹,判据更强)。正文整体包进尖括号——「模板留了待填位」
108
+ // 因此在不带 vendored 模板的全新检出(CI)里同样成立,AC-6 的逐字判据不会退化成空转。
109
+ function templatePlaceholder(sectionName) {
110
+ return '<模板占位正文(' + sectionName + '):照抄本行即视为未填写。>';
111
+ }
112
+
113
+ // 登记表合成形态的段正文覆盖:LESSONS 的「条目格式」段是条目字段键判据(C20)的唯一派生源,
114
+ // ARCHITECTURE 的「ADR 列表」段是 §3 条目字段键判据的唯一派生源——CI 全新检出没有 vendored 模板时
115
+ // 也要给出等价书写样例,否则该判据在 CI 里会退化成「无法派生」而空转(报告只能声明未校验)。
116
+ const TEMPLATE_BODY_FIXTURES = {
117
+ ARCHITECTURE: [[
118
+ 'ADR 列表',
119
+ [
120
+ '### ADR-NNN · <标题>',
121
+ '',
122
+ '- **状态**:proposed | accepted | deprecated | superseded by ADR-NNN',
123
+ '- **取舍**:…',
124
+ '- **决定**:…',
125
+ '- **理由**:…',
126
+ '- **代价**:…',
127
+ '- **来源 change**:<change-id 或 (initial)>',
128
+ '- **推翻成本**:低 / 中 / 高',
129
+ ].join('\n'),
130
+ ]],
131
+ LESSONS: [[
132
+ '条目格式',
133
+ [
134
+ '```markdown',
135
+ '### L-NNN · [tag1, tag2] 标题(一行内说清,便于目录扫读)',
136
+ '',
137
+ '- **首发**: <change-id> · <task-id> · <YYYY-MM-DD>',
138
+ '- **上次复核**: <YYYY-MM-DD>',
139
+ '- **适用栈**: <例 React 18+ / Node 20 / SQLite 当前 schema>',
140
+ '- **状态**: active / superseded-by:L-MMM / deprecated:<原因>',
141
+ '- **关键词**: <空格分隔,方便 grep;用任务里会出现的词>',
142
+ '```',
143
+ ].join('\n'),
144
+ ]],
145
+ };
146
+
147
+ function templateFixtureText(key) {
148
+ const realFile = path.join(REPO_ROOT, ...docRel(key).split('/'));
149
+ if (fs.existsSync(realFile)) return fs.readFileSync(realFile, 'utf8');
150
+ const entry = docEntry(key);
151
+ const lines = [docTitle(key), ''];
152
+ for (const section of entry.sections ?? []) {
153
+ const override = (TEMPLATE_BODY_FIXTURES[key] ?? []).find(([needle]) => section.name.includes(needle));
154
+ lines.push('## ' + section.name, '', override ? override[1] : templatePlaceholder(section.name), '');
155
+ }
156
+ return lines.join('\n');
157
+ }
158
+
159
+ function writeTemplateFixture(dir, key) {
160
+ writeFile(dir, docRel(key), templateFixtureText(key));
161
+ }
162
+
163
+ // 模板夹具(示例表格形态):把某段正文替换成一张带示例数据行的表。用于构造「照抄模板里的示例
164
+ // 表格」的逐字判据——真实模板在两种检出下形态不同(vendored 真迹 / 按登记表合成),这里显式给出
165
+ // 等价段形 + 示例数据,使夹具同构;判据只看模板该段正文是否属成品形态(示例表格行),不看措辞。
166
+ function writeTableTemplateFixture(dir, key, sectionNeedle, tableText) {
167
+ const lines = templateFixtureText(key).replace(/\uFEFF/g, '').replace(/\r\n?/g, '\n').split('\n');
168
+ const out = [];
169
+ let skipping = false;
170
+ let replaced = false;
171
+ for (const line of lines) {
172
+ if (/^##\s+/.test(line)) {
173
+ skipping = line.includes(sectionNeedle);
174
+ replaced = replaced || skipping;
175
+ if (skipping) out.push(line, '', tableText, '');
176
+ else out.push(line);
177
+ continue;
178
+ }
179
+ if (skipping) continue;
180
+ out.push(line);
181
+ }
182
+ if (!replaced) throw new Error('夹具构造失败:模板段不在场 ' + key + ' / ' + sectionNeedle);
183
+ writeFile(dir, docRel(key), out.join('\n'));
184
+ }
185
+
186
+ // 模板夹具(删段形态):把某段整段(标题 + 正文)从模板里删掉——构造「上游回退 / 模板比登记表少
187
+ // 一段」的滞后面,用于 C14「登记表多出的段被忽略并 WARN」与 C9「整份缺席 vs 只缺某段」两组判据。
188
+ // 行锚定只删 `## ` 起始的段块(正文里引用段名不会劫持,L-128)。
189
+ function writeTemplateFixtureOmittingSection(dir, key, sectionNeedle) {
190
+ const lines = templateFixtureText(key).replace(/\uFEFF/g, '').replace(/\r\n?/g, '\n').split('\n');
191
+ const out = [];
192
+ let skipping = false;
193
+ let removed = false;
194
+ for (const line of lines) {
195
+ if (/^##\s+/.test(line)) {
196
+ skipping = line.includes(sectionNeedle);
197
+ removed = removed || skipping;
198
+ if (skipping) continue;
199
+ out.push(line);
200
+ continue;
201
+ }
202
+ if (skipping) continue;
203
+ out.push(line);
204
+ }
205
+ if (!removed) throw new Error('夹具构造失败:模板段不在场 ' + key + ' / ' + sectionNeedle);
206
+ writeFile(dir, docRel(key), out.join('\n'));
207
+ }
208
+
209
+ // 模板某段正文(行锚定:段标题之后、下一个 H2 之前;首尾空行剥掉)。
210
+ function templateSectionBody(key, needle) {
211
+ const lines = templateFixtureText(key).replace(/\uFEFF/g, '').replace(/\r\n?/g, '\n').split('\n');
212
+ const out = [];
213
+ let inside = false;
214
+ for (const line of lines) {
215
+ if (/^##\s+/.test(line)) {
216
+ if (inside) break;
217
+ inside = line.includes(needle);
218
+ continue;
219
+ }
220
+ if (inside) out.push(line);
221
+ }
222
+ return out.join('\n').replace(/^\n+/, '').replace(/\n+$/, '');
223
+ }
224
+
225
+ // ---------- 工件渲染(夹具;段形与顺序全部由登记表驱动) ----------
226
+
227
+ const HEADER_VALUES = {
228
+ 'Change ID': CHANGE_ID,
229
+ '创建日期': '2026-10-20',
230
+ '路径建议': '完整',
231
+ '状态': 'active',
232
+ '关联': '@.specs/' + CHANGE_ID + '/REQUIREMENT.md',
233
+ '作者': 'AI + 人工 review',
234
+ 'Task ID': 'T01',
235
+ '完成时间': '2026-10-20 10:00',
236
+ 'AI 角色': 'Dev',
237
+ '审查时间': '2026-10-20 10:00',
238
+ '审查者': 'AI',
239
+ '总体结论': '通过',
240
+ '项目类型': 'backend',
241
+ '维护者': 'AI',
242
+ '首次创建': '2026-10-20',
243
+ '最近修订': '2026-10-20',
244
+ '当前 ADR 编号最大值': 'ADR-021',
245
+ '暂停时间': '2026-10-20 10:00',
246
+ '触发清窗的信号': '上下文将满',
247
+ };
248
+
249
+ // 条件段正文:显式标注「不适用」(同时也是「视觉调性缺席 → 前端」判据的负向标记形态)。
250
+ const CONDITIONAL_BODY = '不适用(本 change 不涉及该条件段,按模板占位)。';
251
+
252
+ const SIX_DIM_BODY = [
253
+ '- 功能: 通过(brooks-review 已跑)',
254
+ '- 性能: 无影响',
255
+ '- 安全: 无影响',
256
+ '- 兼容: 通过',
257
+ '- 可观测: 通过',
258
+ '- 可维护: 通过',
259
+ ].join('\n');
260
+
261
+ const VERIFY_COMMAND_BODY = ['```', 'node --check baseline.js', '```'].join('\n');
262
+
263
+ const TASK_BLOCK_BODY = '<task id="T01" status="done"><action>实现夹具被测项</action>'
264
+ + '<write_files>src/fixture.mjs</write_files><verify>node --check baseline.js</verify></task>';
265
+
266
+ // 波次段正文:夹具任务 T01 无依赖 ⇒ 第 1 波。段在场却一条 Wave 行都没有时,plan 出口按「波次划分段
267
+ // 内容不可判」拦(未验证 ≠ 通过)——本场景测的是「缺必填 H2」的段形判据,波次段必须写出可判声明,
268
+ // 否则它先被波次判据拦下,被测报文根本不会出现。
269
+ const TASK_WAVE_BODY = ['```', 'Wave 1: T01', '```'].join('\n');
270
+
271
+ // 段级正文覆盖:[模板键, 段名片段, 正文]——只在夹具需要实质内容的位置使用。
272
+ const BODY_OVERRIDES = [
273
+ ['SUMMARY', '6 维自查', SIX_DIM_BODY],
274
+ ['SUMMARY', 'verify 输出', VERIFY_COMMAND_BODY],
275
+ ['REQUIREMENT', '验收准则', '- Given 夹具前置\n- When 夹具动作\n- Then 夹具结果(AC 夹具)'],
276
+ ['REQUIREMENT', '用户故事', '- US-1 作为执行者,我想让夹具可通过结构校验。'],
277
+ ['TASK', '波次划分', TASK_WAVE_BODY],
278
+ ['TASK', '任务清单', TASK_BLOCK_BODY],
279
+ ['REVIEW', '2.2', '- **F1 · 夹具发现**:某处存在一个可记录的衰退风险 [已修]\n'
280
+ + ' - **Symptom**: 夹具现象\n - **Source**: 夹具来源\n'
281
+ + ' - **Consequence**: 夹具后果\n - **Remedy**: 夹具处置'],
282
+ ['TEST', '1.5', SIX_DIM_BODY],
283
+ ];
284
+
285
+ const INCREMENT_BODIES = {
286
+ '自检方法': 'brooks-review(夹具声明)。',
287
+ 'LESSONS 扫描': '扫描结果:无 active 条目命中(夹具)。',
288
+ '验证命令': VERIFY_COMMAND_BODY,
289
+ };
290
+
291
+ function defaultBody() {
292
+ return '本段按模板要求填写:实质内容(夹具,非模板原文)。';
293
+ }
294
+
295
+ function bodyFor(key, section, opts) {
296
+ for (const [needle, text] of opts.body ?? []) {
297
+ if (section.name.includes(needle)) return text;
298
+ }
299
+ for (const [docKey, needle, text] of BODY_OVERRIDES) {
300
+ if (docKey === key && section.name.includes(needle)) return text;
301
+ }
302
+ return section.conditional === true ? CONDITIONAL_BODY : defaultBody();
303
+ }
304
+
305
+ // 结构子段的正文:opts.body 的段名片段覆盖优先(构造「2.2 下的发现条目」这类子段正文形态),
306
+ // 其次段级默认正文(BODY_OVERRIDES,如 REVIEW 2.2 的列表项发现),最后才是通用占位正文。
307
+ function subsectionBody(key, name, opts) {
308
+ const override = (opts.body ?? []).find(([needle]) => name.includes(needle));
309
+ if (override) return override[1];
310
+ const registered = BODY_OVERRIDES.find(([docKey, needle]) => docKey === key && name.includes(needle));
311
+ return registered ? registered[2] : '本子段按模板要求填写:实质内容(夹具)。';
312
+ }
313
+
314
+ function matchesAny(name, needles) {
315
+ return (needles ?? []).some((needle) => name.includes(needle));
316
+ }
317
+
318
+ // 渲染工件。opts:
319
+ // title / headerEmpty / omit / rename([片段, 替换标题])/ swap([段A, 段B] 互换位置)/
320
+ // body([片段, 正文])/ subsectionOmit / incrementAfter([增量段, 锚段])/ insertAfter([锚段, 文本])/
321
+ // extra(追加到文末的文本块数组)
322
+ function renderDoc(key, opts = {}) {
323
+ const entry = docEntry(key);
324
+ const sections = (entry.sections ?? [])
325
+ .filter((section) => !matchesAny(section.name, opts.omit))
326
+ .map((section) => ({ ...section, heading: section.name }));
327
+ for (const section of sections) {
328
+ const renamed = (opts.rename ?? []).find(([needle]) => section.name.includes(needle));
329
+ if (renamed) section.heading = renamed[1];
330
+ }
331
+ for (const [a, b] of opts.swap ?? []) {
332
+ const ia = sections.findIndex((section) => section.name.includes(a));
333
+ const ib = sections.findIndex((section) => section.name.includes(b));
334
+ if (ia === -1 || ib === -1) throw new Error('夹具构造失败:swap 段不在登记表 ' + a + ' / ' + b);
335
+ const moved = sections.splice(ia, 1)[0];
336
+ sections.splice(ib, 0, moved);
337
+ }
338
+
339
+ const header = [opts.title !== undefined ? opts.title : docTitle(key), ''];
340
+ for (const field of entry.headerFields ?? []) {
341
+ header.push('- **' + field + '**: ' + (matchesAny(field, opts.headerEmpty) ? '' : (HEADER_VALUES[field] ?? '夹具值')), '');
342
+ }
343
+ if ((entry.headerFields ?? []).length > 0) header.push('---', '');
344
+
345
+ const blocks = [];
346
+ for (const section of sections) {
347
+ const body = bodyFor(key, section, opts);
348
+ const text = ['## ' + section.heading, '', body, ''].join('\n');
349
+ blocks.push({ name: section.name, text });
350
+ for (const [anchor, inserted] of opts.insertAfter ?? []) {
351
+ if (section.name.includes(anchor)) blocks.push({ name: anchor + '#inserted', text: inserted + '\n' });
352
+ }
353
+ // 条件段的正文仍是「不适用」占位 → 父段不适用,其结构子段不必在场;正文被覆盖成实质内容
354
+ // = 父段适用 → 结构子段必须在场(子段缺席即 BLOCK,无 WARN 让步)。不区分这一点会让夹具
355
+ // 自相矛盾:写了实质正文却不带子段,合规判据必然把它判成缺段。
356
+ if (section.conditional === true && body === CONDITIONAL_BODY) continue;
357
+ for (const child of (entry.structureSubsections ?? []).filter((item) => item.parent === section.name)) {
358
+ if (matchesAny(child.name, opts.subsectionOmit)) continue;
359
+ blocks.push({
360
+ name: child.name,
361
+ text: ['### ' + child.name, '', subsectionBody(key, child.name, opts), ''].join('\n'),
362
+ });
363
+ }
364
+ }
365
+
366
+ // 增量段(kind=section):默认把「自检方法」放在「紧随越界检查」这一合法位置(登记表的
367
+ // after-or-end 的 after 分支),其余增量段落文末;incrementAllAtEnd 构造「全部落在文末」的变体,
368
+ // incrementAfter 指定其它位置(用于非法位置的反向构造)。
369
+ const anchors = opts.incrementAllAtEnd === true
370
+ ? []
371
+ : (opts.incrementAfter ?? [['自检方法', '越界检查']]);
372
+ const pending = [];
373
+ for (const increment of entry.increments ?? []) {
374
+ if (increment.kind === 'marker') continue;
375
+ if (matchesAny(increment.section, opts.omit)) continue;
376
+ // 增量段正文同样接受 opts.body 覆盖(命中回应这类「可自定义正文」的判据需要构造正例);
377
+ // INCREMENT_BODIES 保留为兜底——自检方法段的默认正文是 brooks 判据的输入,不能被 defaultBody() 顶掉。
378
+ const override = (opts.body ?? []).find(([needle]) => increment.section.includes(needle));
379
+ const text = ['## ' + increment.section, '',
380
+ override ? override[1] : (INCREMENT_BODIES[increment.section] ?? defaultBody()), ''].join('\n');
381
+ const anchor = anchors.find(([needle]) => increment.section.includes(needle));
382
+ if (anchor) {
383
+ const idx = blocks.findIndex((block) => block.name.includes(anchor[1]));
384
+ if (idx === -1) throw new Error('夹具构造失败:增量段锚点不在登记表 ' + anchor[1]);
385
+ blocks.splice(idx + 1, 0, { name: increment.section, text });
386
+ } else {
387
+ pending.push({ name: increment.section, text });
388
+ }
389
+ }
390
+ blocks.push(...pending);
391
+ for (const extra of opts.extra ?? []) blocks.push({ name: 'extra', text: extra + '\n' });
392
+
393
+ return header.concat(blocks.map((block) => block.text)).join('\n');
394
+ }
395
+
396
+ // ---------- 状态与夹具根 ----------
397
+
398
+ function newChangeState(node) {
399
+ const st = baseState(node);
400
+ st.newChange = true;
401
+ st.enteredNodes = [node];
402
+ return st;
403
+ }
404
+
405
+ function exitNode(dir, node) {
406
+ return runGuard(['exit', node, '--apply'], dir);
407
+ }
408
+
409
+ function writeBaseline(dir) {
410
+ writeFile(dir, 'baseline.js', 'export const baseline = 1;\n');
411
+ }
412
+
413
+ // UI-DESIGN 工件:frontmatter 顶层键(登记表 frontmatterKeys)+ 模板段形。omitKeys 抽掉某个键,
414
+ // 用于「存在但缺 frontmatter 键」的判据;正文按登记表段形渲染。
415
+ function uiDesignDoc(opts = {}, omitKeys = []) {
416
+ const keys = docEntry('UI-DESIGN').frontmatterKeys ?? [];
417
+ const values = {
418
+ name: '夹具项目',
419
+ description: '夹具美学定位:温暖纸面编辑式。',
420
+ colors: ' brand: "oklch(0.62 0.12 250)"\n bg: "oklch(0.98 0.005 90)"',
421
+ typography: ' display:\n fontFamily: "Fixture Serif, serif"',
422
+ spacing: ' base: "4px"\n md: "12px"',
423
+ rounded: ' md: "8px"',
424
+ motion: ' fast: "120ms"',
425
+ shadow: ' sm: "0 1px 2px oklch(0 0 0 / 8%)"',
426
+ };
427
+ const lines = ['---'];
428
+ for (const key of keys) {
429
+ if (omitKeys.includes(key)) continue;
430
+ lines.push(key + ':', values[key] ?? ' fixture: true');
431
+ }
432
+ lines.push('---', '', renderDoc('UI-DESIGN', opts));
433
+ return lines.join('\n');
434
+ }
435
+
436
+ // 前端 change 的声明标记:节点自身协议标记(design → 2-design.md)与 ui-design 技能标记
437
+ // (guarded 绑定要求真实声明)。两者缺一都会先被证据门 / 标记门拦下,掩盖被测的段形判据。
438
+ // 走统一的声明标记夹具(协议派生,不手抄技能/协议清单);前端 = 连条件绑定的 ui-design 一起声明。
439
+ function writeFrontendDesignMarkers(dir) {
440
+ writeNodeDeclarationMarkers(dir, 'design', { frontend: true });
441
+ }
442
+
443
+ // 每个 setup 先清空 change 目录与归档目录:同一夹具根里连续构造多组用例时,上一组残留的工件
444
+ // (UI-DESIGN.md / .skill-loads/ 声明标记)会让「缺件」「缺声明」一类判据形同虚设。
445
+ function resetFixture(dir) {
446
+ for (const rel of [CHANGE_DIR, '.specs/archive']) {
447
+ fs.rmSync(path.join(dir, rel), { recursive: true, force: true });
448
+ }
449
+ }
450
+
451
+ function setupOpen(dir, changeOpts = {}, requirementOpts = {}) {
452
+ resetFixture(dir);
453
+ writeTemplateFixture(dir, 'CHANGE');
454
+ writeTemplateFixture(dir, 'REQUIREMENT');
455
+ writeFile(dir, CHANGE_DIR + '/CHANGE.md', renderDoc('CHANGE', changeOpts));
456
+ writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md', renderDoc('REQUIREMENT', requirementOpts));
457
+ const st = newChangeState('open');
458
+ st.evidence.open = { summary: 'intake complete' };
459
+ writeState(dir, st);
460
+ writeNodeDeclarationMarkers(dir, 'open');
461
+ }
462
+
463
+ function setupDesign(dir, { changeOpts = {}, designOpts = {}, uiDesign = undefined, declareUiDesign = false } = {}) {
464
+ resetFixture(dir);
465
+ writeTemplateFixture(dir, 'CHANGE');
466
+ writeTemplateFixture(dir, 'DESIGN');
467
+ writeFile(dir, CHANGE_DIR + '/CHANGE.md', renderDoc('CHANGE', changeOpts));
468
+ writeFile(dir, CHANGE_DIR + '/DESIGN.md', renderDoc('DESIGN', designOpts));
469
+ if (uiDesign !== undefined) {
470
+ writeTemplateFixture(dir, 'UI-DESIGN');
471
+ writeFile(dir, CHANGE_DIR + '/UI-DESIGN.md', uiDesign);
472
+ }
473
+ const st = newChangeState('design');
474
+ // guarded 绑定的 required-skill 证据:前端 change 必须在证据里声明已加载 ui-design 技能
475
+ st.evidence.design = declareUiDesign
476
+ ? { summary: 'design done', completedChecks: ['required-skill:design.flow-comet-ui-design'] }
477
+ : { summary: 'design done' };
478
+ writeState(dir, st);
479
+ // 前端夹具(uiDesign 在场 = 前端)连条件绑定的 ui-design 一起声明;非前端不写它(本就不要求)。
480
+ writeNodeDeclarationMarkers(dir, 'design', { frontend: uiDesign !== undefined });
481
+ }
482
+
483
+ function setupPlan(dir, taskOpts = {}) {
484
+ resetFixture(dir);
485
+ writeTemplateFixture(dir, 'TASK');
486
+ writeFile(dir, CHANGE_DIR + '/TASK.md', renderDoc('TASK', taskOpts));
487
+ const st = newChangeState('plan');
488
+ st.evidence.plan = { summary: 'plan done' };
489
+ writeState(dir, st);
490
+ writeNodeDeclarationMarkers(dir, 'plan');
491
+ }
492
+
493
+ function setupExecute(dir, summaryOpts = {}) {
494
+ resetFixture(dir);
495
+ writeTemplateFixture(dir, 'SUMMARY');
496
+ writeBaseline(dir);
497
+ writeFile(dir, CHANGE_DIR + '/T01-SUMMARY.md', renderDoc('SUMMARY', summaryOpts));
498
+ writeFile(dir, CHANGE_DIR + '/TASK.md', '# TASK\n\n## 任务清单\n\n' + TASK_DONE);
499
+ const st = newChangeState('execute');
500
+ st.evidence.execute = { summary: 'executed' };
501
+ st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
502
+ writeState(dir, st);
503
+ writeNodeDeclarationMarkers(dir, 'execute');
504
+ }
505
+
506
+ function setupReview(dir, reviewOpts = {}) {
507
+ resetFixture(dir);
508
+ writeTemplateFixture(dir, 'REVIEW');
509
+ writeFile(dir, CHANGE_DIR + '/REVIEW.md', renderDoc('REVIEW', reviewOpts));
510
+ const st = newChangeState('review');
511
+ st.evidence.review = { summary: 'review done' };
512
+ writeState(dir, st);
513
+ writeNodeDeclarationMarkers(dir, 'review');
514
+ }
515
+
516
+ // verify 夹具自带的 AC 覆盖配对(准则清单 + 1.1 矩阵行):verify 出口先跑 AC 覆盖判据,新 change 下
517
+ // 缺 `REQUIREMENT.md` 或矩阵行会在被测的段形判据之前拦下——夹具因此给出可判的最小一对,
518
+ // 覆盖之外的形态(缺段 / 缺子段 / 矩阵段改标题)由各用例自己改写。
519
+ const AC_COVERAGE_REQUIREMENT_BODY = '- **AC-1**: Given 夹具前置 When 夹具动作 Then 夹具结果';
520
+ const AC_COVERAGE_MATRIX_BODY = ['| AC | 类型 | 用例文件 / UAT | 状态 |', '|---|---|---|---|',
521
+ '| AC-1 | unit | baseline.js | ✅ |'].join('\n');
522
+
523
+ function setupVerify(dir, testOpts = {}) {
524
+ resetFixture(dir);
525
+ writeTemplateFixture(dir, 'TEST');
526
+ writeTemplateFixture(dir, 'REQUIREMENT');
527
+ writeBaseline(dir);
528
+ writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md', renderDoc('REQUIREMENT', {
529
+ body: [['验收准则', AC_COVERAGE_REQUIREMENT_BODY]],
530
+ }));
531
+ writeFile(dir, CHANGE_DIR + '/TEST.md', renderDoc('TEST', {
532
+ ...testOpts,
533
+ body: [...(testOpts.body ?? []), ['1.1', AC_COVERAGE_MATRIX_BODY]],
534
+ }));
535
+ writeFile(dir, CHANGE_DIR + '/UAT.md', '# UAT\n\n## 验收结果\n\n- 通过(夹具)。\n');
536
+ const st = newChangeState('verify');
537
+ st.evidence.verify = { summary: 'verified' };
538
+ writeState(dir, st);
539
+ writeNodeDeclarationMarkers(dir, 'verify');
540
+ }
541
+
542
+ const LESSONS_FIXTURE = [
543
+ '# LESSONS — 跨任务失败知识库(夹具)',
544
+ '',
545
+ '## 条目区(夹具)',
546
+ '',
547
+ '### L-501',
548
+ '',
549
+ '- **关键词**: guard, template',
550
+ '',
551
+ '夹具条目正文:判据必须按结构级校验,不做语义判断。',
552
+ '',
553
+ '### L-502',
554
+ '',
555
+ '- **关键词**: archive, nomination',
556
+ '',
557
+ '夹具条目正文:归档提名须留痕。',
558
+ '',
559
+ ].join('\n');
560
+
561
+ function setupArchive(dir, { evidence = {}, lessons = LESSONS_FIXTURE, summaryCount = 2 } = {}) {
562
+ resetFixture(dir);
563
+ writeFile(dir, '.specs/LESSONS.md', lessons);
564
+ for (let i = 1; i <= summaryCount; i += 1) {
565
+ writeFile(dir, CHANGE_DIR + '/T0' + i + '-SUMMARY.md',
566
+ '# SUMMARY: T0' + i + ' - 夹具\n\n## 做了什么\n\n夹具任务。\n');
567
+ }
568
+ writeFile(dir, '.specs/archive/2026-10-20-' + CHANGE_ID + '/KNOWN-ISSUES.md', '# KNOWN-ISSUES\n\n无遗留。\n');
569
+ const st = newChangeState('archive');
570
+ st.evidence.archive = { summary: 'archived', ...evidence };
571
+ writeState(dir, st);
572
+ // 标记写在**活动** change 目录里(真实链路里它随归档动作一起搬家——模拟搬家的用例自己 rename
573
+ // CHANGE_DIR,标记因此天然跟随;找不到活动路径时 findSkillLoadsDir 才回溯归档路径)。
574
+ writeNodeDeclarationMarkers(dir, 'archive', { changeId: CHANGE_ID });
575
+ }
576
+
577
+ function runSideCommand(dir, scriptRel, args) {
578
+ const res = spawnSync(process.execPath, [path.join(SCRIPTS_DIR, scriptRel), ...args], {
579
+ cwd: dir,
580
+ env: { ...process.env, FLOW_COMET_RUN_ROOT: dir, FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) },
581
+ encoding: 'utf8',
582
+ timeout: 60000,
583
+ });
584
+ return { status: res.status ?? 1, output: String(res.stdout || '') + String(res.stderr || '') };
585
+ }
586
+
587
+ function skillBookText(name) {
588
+ return fs.readFileSync(path.join(SKILLS_ROOT, name, 'SKILL.md'), 'utf8');
589
+ }
590
+
591
+ function repoFileText(rel) {
592
+ return fs.readFileSync(path.join(REPO_ROOT, ...rel.split('/')), 'utf8');
593
+ }
594
+
595
+ function repoFileExists(rel) {
596
+ return fs.existsSync(path.join(REPO_ROOT, ...rel.split('/')));
597
+ }
598
+
599
+ // 公开面缺席判据(同一实现驱动真实断言与变异探针):形态判据认定本检出带公开面时(docs/、
600
+ // CONTRIBUTING.md 或 .github/ 任一在场,见 lib 的 publicFaceDocsAbsent),该面任何一份文档缺席都是
601
+ // 判据失效——「两份机制册都被删」若只落一条 SKIP,公开面机制文档整份消失而套件仍绿。缺席的读法
602
+ // 不能由「少了哪份文件」自行决定:只有整份载体俱缺才是合法的「不在本检出」,由调用方输出可见 SKIP
603
+ // 并声明未校验。
604
+ function publicFaceAbsenceProblems(docs) {
605
+ const missing = [...docs].filter(([, text]) => typeof text !== 'string').map(([rel]) => rel);
606
+ if (missing.length === 0) return [];
607
+ return ['公开面文档不在检出面: ' + missing.join('、')
608
+ + '(形态判据认定本检出带公开面,未走跳过通道;文档缺席即判据失效,不是「本次未校验」)'];
609
+ }
610
+
611
+ // 文本判据(同一函数驱动真实断言与变异探针):rules = [{ rel, label, include[], exclude[] }]。
612
+ function textRuleProblems(docs, rules) {
613
+ const problems = [];
614
+ for (const rule of rules) {
615
+ const text = docs.get(rule.rel);
616
+ if (typeof text !== 'string') {
617
+ problems.push(rule.rel + ' 不在判据面内(' + rule.label + ')');
618
+ continue;
619
+ }
620
+ for (const needle of rule.include ?? []) {
621
+ if (!text.includes(needle)) problems.push(rule.rel + ' 缺「' + needle + '」(' + rule.label + ')');
622
+ }
623
+ for (const needle of rule.exclude ?? []) {
624
+ if (text.includes(needle)) problems.push(rule.rel + ' 仍含旧表述「' + needle + '」(' + rule.label + ')');
625
+ }
626
+ }
627
+ return problems;
628
+ }
629
+
630
+ // 变异探针:同一判据函数驱动——正向探针(把目标文字抽掉 / 改回旧表述 ⇒ 必须报),反向探针
631
+ // (把缺失的目标文字补上 ⇒ 必须不再报,证明判据不恒真)。判别力不能只靠「判据能报违规」证。
632
+ function assertProbesDiscriminate(problems, docs, rules, probes) {
633
+ for (const [label, rel, mutate, expected, expectReported = true] of probes) {
634
+ const before = docs.get(rel);
635
+ const probed = new Map(docs).set(rel, mutate(before));
636
+ if (probed.get(rel) === before) {
637
+ problems.push('反向构造前提失效(' + label + '):变异未改变 ' + rel);
638
+ continue;
639
+ }
640
+ const reported = textRuleProblems(probed, rules).some((problem) => problem.includes(expected));
641
+ if (reported !== expectReported) {
642
+ problems.push('反向构造判别力缺失(' + label + ':' + (expectReported ? '未被判违规' : '被误判违规') + ')');
643
+ }
644
+ }
645
+ }
646
+
647
+ // 公开面自检的**形态分派**(判定本体在 lib:publicFaceSelfCheck)——各载体形态各造一个临时根、驱动
648
+ // 同一判定,分派对错因此成为常驻断言,不必等到在包形态里整跑一次套件才知道:
649
+ // ① 包形态(技能树锚在场、docs/ + CONTRIBUTING.md + .github/ 三者俱缺)→ SKIP 通知 + 零问题:
650
+ // 这种载体本来就不带公开面,「受检条目不在场」是它的正常形态;报成幽灵条目会把读者送去修一个
651
+ // 不存在的缺陷;
652
+ // ② 权威源形态完整(受检面文件照真迹复制,计数自然同步)→ 零问题(判据不是恒红的摆设);
653
+ // ③ 同一根上移走一份受检文档(docs/VERSIONS.md)→ 必须报问题并点名该文件——跳过通道只对
654
+ // 「整份公开面不存在」开放,判据没有顺手放宽;
655
+ // ④ 安装副本形态(无技能树锚)→ 词表镜像判据的「不适用」说明 + 零问题;
656
+ // ⑤ 半包形态(docs/ 整份不在,但 CONTRIBUTING.md 或 .github/ 在场)→ 必须照跑全判据并判红:
657
+ // 这两份同样不进 npm tarball,任一在场即证明本检出是仓库(只是被裁坏了);只按 docs/ 分流会让
658
+ // 分支 / 稀疏检出 / 误删把整块判据变成 SKIP 并 exit 0。
659
+ // 形态本身同样由既有判据派生(技能树锚 + publicFaceDocsAbsent),夹具不另写一套形态判据。
660
+
661
+ // 受检面文件清单(照真迹复制的范围)= 公开产物零代号清单 ∪ 计数受检清单 ∪ 词表私有面:
662
+ // 三面齐了同一次判定才可能零问题——少一面就会以问题形态暴露,夹具不会悄悄缩小判据面。
663
+ function countFaceFiles() {
664
+ return [...new Set([
665
+ ...PUBLIC_FACE_CODE_DOCS, ...SCENARIO_COUNT_FILES, ...SYSTEM_TEST_COUNT_FILES, GITHOOKS_CODES_REL,
666
+ ])];
667
+ }
668
+
669
+ function copyRepoFileInto(root, rel) {
670
+ const parts = rel.split('/');
671
+ const dest = path.join(root, ...parts);
672
+ fs.mkdirSync(path.dirname(dest), { recursive: true });
673
+ fs.copyFileSync(path.join(REPO_ROOT, ...parts), dest);
674
+ }
675
+
676
+ async function assertPublicFaceSelfCheckShapes(dir) {
677
+ const shapeRoot = (name, { authoritative = true } = {}) => {
678
+ const root = path.join(dir, 'shape-' + name);
679
+ fs.mkdirSync(root, { recursive: true });
680
+ // 技能树锚点:与真实检出同一相对位置(路径字面量由 lib 单点拥有,不在此重写)
681
+ if (authoritative) writeFile(root, AUTHORITATIVE_SOURCE_ANCHOR_REL, '---\nname: flow-comet\n---\n');
682
+ return root;
683
+ };
684
+ const describe = (result) => result.problems.map((problem) => problem.name + ': ' + problem.error).join('; ')
685
+ || '(零问题)';
686
+ // ① 包形态(docs/ + CONTRIBUTING.md + .github/ 三者俱缺):分派若改成「照跑全套」,这里会报一串
687
+ // 「受检条目文件缺失(幽灵条目)」——正是要拦的形态
688
+ const packaged = await publicFaceSelfCheck({ root: shapeRoot('package') });
689
+ if (packaged.problems.length > 0) {
690
+ throw new Error('包形态(技能树锚在、docs/ 与 CONTRIBUTING.md / .github/ 俱缺)不得报问题——'
691
+ + '受检条目不在场是这种载体的正常形态,报出来就是幽灵条目: ' + describe(packaged));
692
+ }
693
+ if (packaged.skip === null || packaged.skip.reason !== 'package-without-public-face') {
694
+ throw new Error('包形态应命中显式跳过分支(skip.reason=package-without-public-face): '
695
+ + JSON.stringify(packaged.skip));
696
+ }
697
+ if (!packaged.skip.notice.includes('未校验')) {
698
+ throw new Error('包形态的跳过提示必须写明「未校验」(跳过 ≠ 通过): ' + packaged.skip.notice);
699
+ }
700
+ // ② 权威源形态完整:受检面文件照真迹复制,计数自然同步(不硬编码数字)
701
+ const full = shapeRoot('authoritative');
702
+ for (const rel of countFaceFiles()) copyRepoFileInto(full, rel);
703
+ const complete = await publicFaceSelfCheck({ root: full });
704
+ if (complete.problems.length > 0) {
705
+ throw new Error('权威源形态完整(受检面文件照真迹复制)不应报问题: ' + describe(complete));
706
+ }
707
+ // ③ 同一根上移走一份受检文档:跳过通道只对「整份公开面不存在」开放,缺一份必须判红并点名
708
+ const removedDoc = 'docs/VERSIONS.md';
709
+ fs.rmSync(path.join(full, ...removedDoc.split('/')));
710
+ const truncated = await publicFaceSelfCheck({ root: full });
711
+ if (!truncated.problems.some((problem) => problem.error.includes(removedDoc))) {
712
+ throw new Error('权威源形态里移走一份受检文档必须报问题并点名该文件(判据不得因形态分派而放宽): '
713
+ + describe(truncated));
714
+ }
715
+ // ④ 安装副本形态:无技能树锚 = 主仓私有面结构性缺席 → 「不适用」说明,不误红
716
+ const installed = await publicFaceSelfCheck({ root: shapeRoot('installed', { authoritative: false }) });
717
+ if (installed.problems.length > 0 || installed.skip === null
718
+ || installed.skip.reason !== 'installed-copy-without-skill-tree') {
719
+ throw new Error('安装副本形态(无技能树锚)应命中「不适用」分支且零问题: '
720
+ + JSON.stringify(installed.skip) + ' / ' + describe(installed));
721
+ }
722
+ if (!installed.skip.notice.includes('不适用')) {
723
+ throw new Error('安装副本形态的跳过提示必须写明「不适用」(不适用 ≠ 已校验): ' + installed.skip.notice);
724
+ }
725
+ // ⑤ 半包形态(docs/ 整份不在,但 CONTRIBUTING.md 或 .github/ 在场):必须是判红,不得复用包形态的
726
+ // 跳过通道——否则分支 / 稀疏检出 / 误删把 docs/ 拿掉时,计数一致性、公开产物零代号与词表镜像会整块
727
+ // 变成可见 SKIP 并 exit 0。两份载体分开造根:任一单独在场都足以证明本检出是仓库而不是「本来不带
728
+ // 公开面」的 npm 包 / 安装副本(两者都不进 npm tarball;README 会被 npm 强制包含,不作判据)。
729
+ for (const carrier of ['CONTRIBUTING.md', '.github/workflows/ci.yml']) {
730
+ const partial = shapeRoot('docs-less-' + carrier.split('/')[0].replace(/\./g, ''));
731
+ writeFile(partial, carrier, '');
732
+ const partialResult = await publicFaceSelfCheck({ root: partial });
733
+ if (partialResult.skip !== null) {
734
+ throw new Error('docs/ 不在但 ' + carrier + ' 在场不得命中跳过分支(skip.reason='
735
+ + partialResult.skip.reason + ')——该形态下公开面判据会整块变成 SKIP 并 exit 0');
736
+ }
737
+ if (!partialResult.problems.some((problem) => problem.name === '计数一致性')) {
738
+ throw new Error('docs/ 不在但 ' + carrier + ' 在场时必须照跑计数一致性并判红,实际: '
739
+ + describe(partialResult));
740
+ }
741
+ }
742
+ }
743
+
744
+ // 机制表行判据(同一函数驱动真实断言与变异探针)。机制行按**结构**定位,不按「首个含某组词的行」:
745
+ // 文档正文随时可能为另一条修正补进既含「段名」又有 plan 的段落,词形判据会被它抢位(已实证的失效形态)。
746
+ // 结构 = markdown 表格的数据行(表头 + 分隔行 + 连续 | 行);机制行取其中末列(适用面列)点名出口名
747
+ // 最多的那一行——那正是「这套形状校验适用于哪些出口」的口径声明。
748
+ const EXIT_NODES = ['open', 'design', 'plan', 'execute', 'subagent-execute', 'review', 'verify', 'archive'];
749
+
750
+ function markdownTableRows(text) {
751
+ const lines = text.split(/\r?\n/);
752
+ const rows = [];
753
+ for (let i = 0; i + 1 < lines.length; i++) {
754
+ if (!/^\s*\|/.test(lines[i]) || !/^\s*\|[\s:|-]*-[\s:|-]*\|?\s*$/.test(lines[i + 1])) continue;
755
+ let j = i + 2;
756
+ for (; j < lines.length && /^\s*\|/.test(lines[j]); j++) rows.push({ index: j, raw: lines[j] });
757
+ i = j - 1;
758
+ }
759
+ return rows;
760
+ }
761
+
762
+ function markdownCells(raw) {
763
+ // 本仓公开文档的表格单元格不含转义竖线,故按 | 直接切分。
764
+ return raw.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((cell) => cell.trim());
765
+ }
766
+
767
+ function findMechanismRow(text) {
768
+ let best = null;
769
+ for (const row of markdownTableRows(text)) {
770
+ const appliesTo = markdownCells(row.raw).pop() ?? '';
771
+ const exits = EXIT_NODES.filter((node) => appliesTo.includes('`' + node + '`'));
772
+ if (best === null || exits.length > best.exits.length) best = { ...row, appliesTo, exits };
773
+ }
774
+ return best !== null && best.exits.length > 0 ? best : null;
775
+ }
776
+
777
+ // 机制行必须覆盖全部 8 个出口(旧表只列 5 个):抽掉任一出口即判违规,判据不放宽。
778
+ function mechanismRowProblems(docs) {
779
+ const problems = [];
780
+ for (const rel of ['docs/MECHANISM-zh.md', 'docs/MECHANISM.md']) {
781
+ const text = docs.get(rel);
782
+ if (typeof text !== 'string') continue; // 缺席面由调用方的缺席判据逐份点名(本函数只判在场的机制行)
783
+ const row = findMechanismRow(text);
784
+ if (row === null) {
785
+ problems.push(rel + ' 缺「节点文档是否符合模板」机制行(无法核对出口面)');
786
+ continue;
787
+ }
788
+ for (const node of EXIT_NODES) {
789
+ if (!row.exits.includes(node)) problems.push(rel + ' 机制行未覆盖出口 ' + node + '(口径落后于门禁范围)');
790
+ }
791
+ }
792
+ return problems;
793
+ }
794
+
795
+ // 失效形态复现用:旧判据「首个同时含『段名』且匹配 open|design|plan 的行」。只被正锚探针用来确认
796
+ // 「插入的段落确实会被旧判据抢位」——证明正锚构造有效,不参与真实断言。
797
+ function legacyMechanismLine(text) {
798
+ return text.split(/\r?\n/).find((line) => line.includes('段名') && /open|design|plan/.test(line)) ?? '';
799
+ }
800
+
801
+ // ---------- 段体切片形态探针(段体单源锁的判据面) ----------
802
+
803
+ // 一份「按标题切段体」的实现 = 三种写法之一(A/B/C)写在两种位置之一(D = 对象属性箭头);判定粒度是
804
+ // **具名代码单元**(`functionBodies` 切出的顶层函数体、`objectLiteralArrowBodies` 切出的对象属性箭头体),
805
+ // 形态命中按「文件 + 名称」登记,与取用面的「文件 + 符号」同一粒度:
806
+ // A 行扫描:同一单元里三件事齐备——① 段头判定(行首 ATX 标题正则,或以其为模式串的 RegExp
807
+ // 构造)② 在判定处收尾(break)③ 把原始行拼成段体(+= line / push(line…) / slice(…).join(…));
808
+ // B 正则切片:同一单元里出现「从段头截到下一个段头」的正则 idiom——惰性 `[\s\S]` 片段配
809
+ // `(?=…\n## …)` 前瞻,或 `.split(/\n## …/)` 按标题行切;
810
+ // C 字符串字面量切分:段界写成字符串而不是正则——`.split('\n## …')` / `.indexOf('## …')`
811
+ // (B 的判据要求正则字面量,同一件事换个写法就整份躲在锁外);
812
+ // D 位置:以上任一写法写进**对象字面量的内联箭头**(`passes: (t) => { … }`)——顶层函数切分只看
813
+ // `function NAME` / `const NAME = () => {`,属性值的箭头体它看不见。
814
+ // 缺任一件都不算:围栏状态过滤器没有段头判定,条目块收集器不在标题处收尾,键解析器把行拆成字段。
815
+ // 段头判定的正则形态覆盖三种写法:`/^#…`、`/^(#{1,6})…`(标题等级写成捕获组)与 `.startsWith('#')`。
816
+ // 旧判定只认「`/^#` 紧邻」一种形态,`^(#{1,6})` 这种带捕获组的写法整份躲在锁外——context-init 的
817
+ // 私有段体切片正是此形态,受检面扩面时一并修掉。
818
+ const SECTION_HEADING_TEST_RE = /\/\^\(?#{1,6}|['"]\^\(?#{1,6}|\.startsWith\(\s*['"]#/u;
819
+ const SECTION_BREAK_RE = /\bbreak\b/u;
820
+ const SECTION_BODY_ACCUMULATION_RE = /\+=\s*line\b|\.push\(\s*line\b|\.push\(\s*lines\[|\.slice\([^)]*\)\.join\(/u;
821
+
822
+ // 顶层函数体(function 声明 / const NAME = (…) => {…})按花括号配对切。注释与字符串里的花括号会让配对
823
+ // 偏一档,只影响检出精度、不影响判据方向:误报会显式红,漏报由行为断言兜住。
824
+ // 花括号配对切体(唯一一处):从起始行切到配对闭合的那一行(含首末行)。顶层函数体与对象属性箭头体
825
+ // 共用它——两处各写一份配对循环时,其中一处改了口径(例如只认 `}` 起头的行)另一处不会跟上。
826
+ function bracedBodyFrom(lines, startIndex) {
827
+ let depth = 0;
828
+ let started = false;
829
+ const body = [];
830
+ for (let line = startIndex; line < lines.length; line += 1) {
831
+ for (const ch of lines[line]) {
832
+ if (ch === '{') { depth += 1; started = true; } else if (ch === '}') depth -= 1;
833
+ }
834
+ body.push(lines[line]);
835
+ if (started && depth <= 0) break;
836
+ }
837
+ return body.join('\n');
838
+ }
839
+
840
+ function functionBodies(code) {
841
+ const lines = String(code).split('\n');
842
+ const out = [];
843
+ for (let index = 0; index < lines.length; index += 1) {
844
+ const matched = lines[index].match(/^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_$]+)/u)
845
+ ?? lines[index].match(/^(?:export\s+)?const\s+([A-Za-z0-9_$]+)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z0-9_$]+)\s*=>\s*\{/u);
846
+ if (matched === null) continue;
847
+ out.push({ name: matched[1], text: bracedBodyFrom(lines, index) });
848
+ }
849
+ return out;
850
+ }
851
+
852
+ // A 形态(行扫描):在段头判定处 break,再把原始行拼成段体。
853
+ function isLineScanSlicer(unit) {
854
+ return SECTION_HEADING_TEST_RE.test(unit.text)
855
+ && SECTION_BREAK_RE.test(unit.text)
856
+ && SECTION_BODY_ACCUMULATION_RE.test(unit.text);
857
+ }
858
+
859
+ // B 形态(正则切片):段界写在一对正则里——截取式(`[\s\S]` 片段 + 前瞻 `(?=` + 前瞻里出现 `\n##`)
860
+ // 或切分式(`.split(/\n## …/)`)。两条都要求「标题行」在场:没有标题就没有段界,也就不是段体切片——
861
+ // 只按行宽 / 标点切分的实现不在此列。
862
+ const SECTION_SLICE_EXCERPT_RE = /\[\s*\\s\\S\s*\]/u;
863
+ const SECTION_SLICE_FORWARD_LOOK_RE = /\(\?=/u;
864
+ const SECTION_SLICE_HEADING_BOUNDARY_RE = /\\n#{1,6}/u;
865
+ const SECTION_SLICE_SPLIT_RE = /\.split\(\s*\/[^/\n]*\\n#{1,6}/u;
866
+
867
+ function isRegexSlicer(unit) {
868
+ return unit.text.split('\n').some((line) => SECTION_SLICE_EXCERPT_RE.test(line)
869
+ && SECTION_SLICE_FORWARD_LOOK_RE.test(line)
870
+ && SECTION_SLICE_HEADING_BOUNDARY_RE.test(line))
871
+ || SECTION_SLICE_SPLIT_RE.test(unit.text);
872
+ }
873
+
874
+ // C 形态(字符串字面量切分):段界写成字符串字面量——`.split('\n## …')` / `.indexOf('## …')`。
875
+ // 与 B 同义(按标题行切段)而写法不同:B 的两条判据都要求正则字面量,同一件事换个写法就整份在锁外
876
+ // (context-init 的「已锁决策」格式检查正是这一形态,静态锁因此判它绿)。
877
+ const SECTION_SLICE_STRING_BOUNDARY_RES = [
878
+ /\.split\(\s*['"]\\n#{1,6}/u,
879
+ /\.indexOf\(\s*['"]#{1,6}[\s'"]/u,
880
+ ];
881
+
882
+ function isStringLiteralSlicer(unit) {
883
+ return SECTION_SLICE_STRING_BOUNDARY_RES.some((boundary) => boundary.test(unit.text));
884
+ }
885
+
886
+ // 对象字面量内联箭头(`passes: (t) => { … }`):属性值的箭头体。顶层函数切分(functionBodies)只看
887
+ // `function NAME` / `const NAME = () => {`,写进对象属性就躲开了形态面。符号名取属性键——登记粒度与
888
+ // 「文件 + 符号」一致,属性名在同一文件内重名时按「文件 + 属性名」合并(与第二份定义同名的处置相同)。
889
+ function objectLiteralArrowBodies(code) {
890
+ const lines = String(code).split('\n');
891
+ const out = [];
892
+ for (let index = 0; index < lines.length; index += 1) {
893
+ const matched = lines[index].match(/^\s*([A-Za-z0-9_$]+)\s*:\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z0-9_$]+)\s*=>\s*\{/u);
894
+ if (matched === null) continue;
895
+ out.push({ name: matched[1], text: bracedBodyFrom(lines, index) });
896
+ }
897
+ return out;
898
+ }
899
+
900
+ // E 行数组切片:段首用 `findIndex(标题谓词)` 定位、段尾用 `slice(start, …)` 取到——「按标题行切出
901
+ // 一段」的第三种写法。段界判定往往被提成辅助函数(`headingOf` / `sectionEnd` / 导入的 `hasSection9`),
902
+ // 单元里只剩下 `findIndex` + `slice`,于是 A/B/C 三条写法一条也不命中:evolve 的沉淀段切片正是此形态,
903
+ // 旧判据对它整份判绿。判据因此要求三件事同现——`findIndex(`、`slice(`,以及**可达的标题判定**
904
+ // (单元内联的标题正则 / `startsWith('#')`,或单元调用的、同文件内定义的含标题判定的辅助函数)。
905
+ // 边界(如实登记):谓词若完全来自别的模块且不落在同文件辅助上(例如本文件既没有标题正则、也没有
906
+ // 标题辅助),本形态就够不着——登记条目的「合并条件」正是写这种边界的唯一落点,行为断言另兜一层。
907
+ const SECTION_SLICE_FINDINDEX_RE = /\.findIndex\(/u;
908
+ const SECTION_SLICE_ARRAY_CUT_RE = /\.slice\(/u;
909
+
910
+ // 同文件内「含标题判定的辅助函数」名:单元调用它们即视为段界判定可达(把判定提成辅助不等于换了
911
+ // 一件事)。只取顶层声明——对象属性箭头里再套一层标题判定的写法由 D 位置面单独覆盖。
912
+ function headingPredicateNames(code) {
913
+ return functionBodies(code)
914
+ .filter((unit) => SECTION_HEADING_TEST_RE.test(unit.text))
915
+ .map((unit) => unit.name);
916
+ }
917
+
918
+ function mentionsHeadingBoundary(unit, helperNames) {
919
+ if (SECTION_HEADING_TEST_RE.test(unit.text)) return true;
920
+ return helperNames.some((name) => name !== unit.name
921
+ && new RegExp('\\b' + name + '\\b', 'u').test(unit.text));
922
+ }
923
+
924
+ function isLineArraySlicer(unit, helperNames) {
925
+ return SECTION_SLICE_FINDINDEX_RE.test(unit.text)
926
+ && SECTION_SLICE_ARRAY_CUT_RE.test(unit.text)
927
+ && mentionsHeadingBoundary(unit, helperNames);
928
+ }
929
+
930
+ // 形态面 = 两种位置 × 四种写法的全部命中:写法判定各是一份谓词,位置只决定在哪一堆具名单元上套用。
931
+ // 位置面的盲区(D:对象字面量内联箭头)因此不与写法面各写一套——旧的锁只看顶层函数,把同一件事写进
932
+ // 对象属性就整份躲开了。谓词签名(unit, helperNames)统一:E 形态要看「调用的辅助是不是标题判定」,
933
+ // A/B/C 忽略第二个参数(它们只看单元文本)。
934
+ const SECTION_SLICE_FORM_PREDICATES = [isLineScanSlicer, isRegexSlicer, isStringLiteralSlicer, isLineArraySlicer];
935
+
936
+ function sectionSliceHits(code) {
937
+ const helperNames = headingPredicateNames(code);
938
+ const hitsIn = (units) => units
939
+ .filter((unit) => SECTION_SLICE_FORM_PREDICATES.some((matches) => matches(unit, helperNames)))
940
+ .map((unit) => unit.name);
941
+ return [...new Set([...hitsIn(functionBodies(code)), ...hitsIn(objectLiteralArrowBodies(code))])];
942
+ }
943
+
944
+ // 单源的导出符号集:只有它们受「导出实现恰一处 / 不得自带第二份定义 / 必须具名取用」约束。
945
+ const SECTION_SOURCE_SYMBOLS = ['sectionBody', 'scanHeadings'];
946
+
947
+ // 段体单源锁的**登记表**:把面内仍存在的同类实现逐条登记(文件 + 符号 + 理由 + **合并条件**四件齐备)。
948
+ // 登记是让缺口可见,不是放行:
949
+ // · 只覆盖 ③ 形态命中这一条判据;② 的单源符号第二份定义 / 未取用**不接受豁免**——否则登记一个
950
+ // sectionBody 副本就能让真实副本静默通过(旧锁把 `continue` 放在符号判定之前,正是如此);
951
+ // · 条目必须**当场命中**(该文件该函数此刻仍在形态面上):修好或改名后未删 ⇒ 陈旧,判红。
952
+ // · **合并条件必填**:一条登记要回答「什么条件下就该删掉它、改用单源」——只写理由的登记是永久
953
+ // 豁免(缺口从此不可收口),而锁本身判不了「这个缺口还会不会收」,只能要求它写下来并被看见。
954
+ // 受检面 = 引擎实现面(与 `engineScriptTexts` 同一派生口径:顶层入口 ∪ 静态可达模块 ∪ 非套件自持的
955
+ // `lib/**`)。套件自持面(`scenarios/**`、`items/**`、只被套件入口可达的 lib 模块)是夹具与其自身
956
+ // 判据,不在引擎面上——把它们算进来会让锁去登记自己用的行扫描辅助(形态探针本身),判据反而失真。
957
+ const SECTION_SLICE_REGISTRY = [
958
+ {
959
+ file: 'health.mjs',
960
+ symbol: 'collectDebt',
961
+ // 这一条是**能力差异**,不是同一件事的第二份实现:技术债段体的段界要与**段标题自身的层级**比较
962
+ // (`## 技术债` + `### 明细` 里的子标题属于段内,不是段边界——按固定级别截断会把子标题之后的
963
+ // 表格整段丢掉),而这个层级还要随读数回传给「复现命令」(命令里的段级必须取自同一处,否则
964
+ // `## 技术债` 的项目照抄命令就复现不出本报告的读数)。单源的 sectionBody 两项能力都给不了:
965
+ // 它只接受一个固定的结束级别,且只返回段体正文、不返回命中的标题。
966
+ reason: '能力差异:段界要与段标题自身的层级比较,且该层级需回传给「复现命令」——'
967
+ + 'sectionBody 只接受固定结束级别、只返回段体正文,两项都给不了。',
968
+ mergeCondition: 'section-body.mjs 增加「段体 + 命中标题(含层级)」的返回形态后,health.mjs 改用它'
969
+ + '并把段级从同一次命中取回;届时删除本条(陈旧登记判红会提醒)。',
970
+ },
971
+ {
972
+ file: 'evolve.mjs',
973
+ symbol: 'locateSedimentSection',
974
+ // 能力差异:evolve 要的是**行区间**而不是段体正文——沉淀段的候选解析在行数组上做(表格行 / 列表
975
+ // 项 / 围栏块整块),插入点也要落回同一个行数组;段首行(含标题)与「同级或更高级标题」的边界
976
+ // 都由它自己算,层级取自该段标题自身。sectionBody 只给段体字符串、只接受固定结束级别;
977
+ // scanHeadings 给得出围栏外的标题下标,但区间的「按标题层级收尾」仍要消费方自己推。
978
+ reason: '能力差异:消费方要行区间(段首行 + 段尾行)而不是段体正文字符串,段界按段标题自身层级收。',
979
+ mergeCondition: 'section-body.mjs 增加「段体区间(标题行下标 + 段尾下标,按命中标题层级)」的返回形态'
980
+ + '后,evolve 的 locateSedimentSection / findSection 改用它取区间并删除本条;本条是该文件在写面外'
981
+ + '期间的登记,不是收口结论。',
982
+ },
983
+ ];
984
+
985
+ // 段体单源判据(纯函数 + 合成输入可驱动):given = Map(相对路径 → 文本),registry = 登记表。
986
+ // ① 单源模块由**导出面**派生(不写文件名):导出实现恰一处,且 {sectionBody, scanHeadings} 都定义
987
+ // 在那里;
988
+ // ② **取用面** = 面内提到单源符号的模块:必须具名取用,不得自带第二份定义、不得改从别处取用;
989
+ // ③ **形态面** = 面内**全部**模块的全部具名代码单元(顶层函数 ∪ 对象字面量内联箭头)——受检面不再
990
+ // 只是取用面:把一份私有实现搬进一个不引用该符号的模块就躲不开了;形如切段体者只许是单源本身,
991
+ // 其余必须登记。写法面 = A 行扫描 / B 正则切片 / C 字符串字面量切分(B 的判据要求正则字面量,
992
+ // C 是同一件事的另一种写法);位置面 = 顶层函数 / 对象字面量内联箭头(后者是 functionBodies 的盲区)。
993
+ // 返回问题描述数组(空 = 收口)。
994
+ function sectionSingleSourceProblems({ texts: given, registry = SECTION_SLICE_REGISTRY }) {
995
+ const problems = [];
996
+ const exported = [...given.entries()]
997
+ .filter(([, text]) => /export\s+(?:async\s+)?function\s+sectionBody\b|export\s+const\s+sectionBody\s*=/u
998
+ .test(engineCodeText(text)))
999
+ .map(([rel]) => rel);
1000
+ if (exported.length !== 1) {
1001
+ problems.push('sectionBody 的导出实现应恰一处,实际 ' + JSON.stringify(exported));
1002
+ return problems;
1003
+ }
1004
+ const sourceRel = exported[0];
1005
+ const sourceText = given.get(sourceRel) ?? '';
1006
+ for (const symbol of SECTION_SOURCE_SYMBOLS) {
1007
+ if (!engineDefinitionPattern(symbol).test(sourceText)) {
1008
+ problems.push(sourceRel + ' 未定义段体单源的 ' + symbol);
1009
+ }
1010
+ }
1011
+ const mentionRe = /\b(?:sectionBody|scanHeadings)\b/u;
1012
+ const consumers = [...given.keys()].filter((rel) => rel !== sourceRel
1013
+ && mentionRe.test(engineCodeText(given.get(rel) ?? '')));
1014
+ if (consumers.length < 5) {
1015
+ problems.push('段体消费面不足五处(由真实引用派生): ' + JSON.stringify(consumers));
1016
+ }
1017
+ for (const rel of consumers) {
1018
+ const code = engineCodeText(given.get(rel));
1019
+ for (const symbol of SECTION_SOURCE_SYMBOLS) {
1020
+ if (!new RegExp('\\b' + symbol + '\\b', 'u').test(code)) continue;
1021
+ if (engineDefinitionPattern(symbol).test(code)) {
1022
+ problems.push(rel + ' 自带第二份 ' + symbol + ' 定义(应取用单一来源;登记不覆盖单源符号的副本)');
1023
+ continue;
1024
+ }
1025
+ if (!engineImportsSymbolFrom({ text: given.get(rel), consumerRel: rel, symbol, sourceRel, texts: given })) {
1026
+ problems.push(rel + ' 未从 ' + sourceRel + ' 取用 ' + symbol);
1027
+ }
1028
+ }
1029
+ }
1030
+ const hits = [];
1031
+ for (const [rel, text] of given) {
1032
+ if (rel === sourceRel) continue;
1033
+ const code = engineCodeText(text);
1034
+ for (const symbol of sectionSliceHits(code)) {
1035
+ if (hits.some((hit) => hit.rel === rel && hit.symbol === symbol)) continue;
1036
+ hits.push({ rel, symbol });
1037
+ }
1038
+ }
1039
+ for (const hit of hits) {
1040
+ const entry = registry.find((item) => item.file === hit.rel && item.symbol === hit.symbol);
1041
+ if (entry === undefined) {
1042
+ problems.push(hit.rel + ' 自带段体切片实现 ' + hit.symbol
1043
+ + '(段界应只由 ' + sourceRel + ' 决定;确属另一件事则在锁里登记文件 + 符号 + 理由)');
1044
+ continue;
1045
+ }
1046
+ if (SECTION_SOURCE_SYMBOLS.includes(hit.symbol)) {
1047
+ problems.push(hit.rel + ' 的 ' + hit.symbol + ' 是单源符号的副本——登记不能放行真实副本');
1048
+ continue;
1049
+ }
1050
+ if (String(entry.reason ?? '').trim() === '') {
1051
+ problems.push(hit.rel + ' 的 ' + hit.symbol + ' 登记缺理由(登记是让缺口可见,不是静默放行)');
1052
+ }
1053
+ if (String(entry.mergeCondition ?? '').trim() === '') {
1054
+ problems.push(hit.rel + ' 的 ' + hit.symbol + ' 登记缺合并条件(登记要写出「什么条件下收口」,'
1055
+ + '否则这条豁免永远没有到期日)');
1056
+ }
1057
+ }
1058
+ for (const entry of registry) {
1059
+ if (!hits.some((hit) => hit.rel === entry.file && hit.symbol === entry.symbol)) {
1060
+ problems.push('登记已陈旧:' + entry.file + ' 的 ' + entry.symbol
1061
+ + ' 不再是段体切片形态(收口或改名后请删除该登记)');
1062
+ }
1063
+ }
1064
+ return problems;
1065
+ }
1066
+
1067
+ // 本任务收口的三处私有实现(原样搬回):静态判据只读文本、不执行变异体——探针证明「改回私有实现 ⇒
1068
+ // 锁必红」。每条 edits 的锚文本若漂移,调用方报「锚已漂移」(不静默跳过:否则探针会退化成恒绿)。
1069
+ // 旧实现一律用 String.raw 模板保存:里面的 `\uFEFF` / `\r?\n` 是字面量,不该被再次转义。
1070
+ const REVERTED_PRIVATE_SLICERS = [
1071
+ {
1072
+ label: 'guard-uidesign 的「视觉调性」段体改回围栏盲的行扫描',
1073
+ rel: 'lib/guard-uidesign.mjs',
1074
+ symbols: ['visualToneSectionState'],
1075
+ edits: [[
1076
+ String.raw` const body = sectionBody(text, headingPattern, { level: 2, endOnSeparator: false });`,
1077
+ String.raw` let body = null;
1078
+ for (const line of String(text).replace(/\uFEFF/g, '').split(/\r?\n/)) {
1079
+ if (/^##\s+/.test(line)) {
1080
+ if (body !== null) break; // 到达下一个 H2 → 本段结束
1081
+ if (headingPattern.test(line)) body = '';
1082
+ continue;
1083
+ }
1084
+ if (body !== null) body += line + '\n';
1085
+ }`,
1086
+ ]],
1087
+ },
1088
+ {
1089
+ label: 'guard-evidence-gates 的「6 维自查」/「自检方法」段体改回两条正则切片',
1090
+ rel: 'lib/guard-evidence-gates.mjs',
1091
+ symbols: ['summarySixDimBody', 'summarySelfCheckMethodBody'],
1092
+ edits: [
1093
+ [
1094
+ String.raw`function summarySixDimBody(content) {
1095
+ return sectionBody(content, SIX_DIM_HEADING_PATTERN, { level: 2, endOnSeparator: true });
1096
+ }`,
1097
+ String.raw`function summarySixDimBody(content) {
1098
+ const sixDim = content.match(/##\s*6\s*维自查[\s\S]*?(?=\n##\s|\n---|(?![\s\S]))/i);
1099
+ return sixDim === null ? null : sixDim[0];
1100
+ }`,
1101
+ ],
1102
+ [
1103
+ String.raw`function summarySelfCheckMethodBody(content) {
1104
+ return sectionBody(content, SELF_CHECK_METHOD_HEADING_PATTERN, { level: 2, endOnSeparator: true });
1105
+ }`,
1106
+ String.raw`function summarySelfCheckMethodBody(content) {
1107
+ const methodMatch = content.match(/##\s*自检方法(?:[((][^))\n]*[))])?\s*\n([\s\S]*)/i);
1108
+ return methodMatch ? methodMatch[1].split(/\n##\s|\n---/)[0] : null;
1109
+ }`,
1110
+ ],
1111
+ ],
1112
+ },
1113
+ {
1114
+ label: 'context-init 改回同名私有 sectionBody((body, headingName) 变体)',
1115
+ rel: 'context-init.mjs',
1116
+ symbols: ['sectionBody'],
1117
+ edits: [[
1118
+ String.raw`function contextSectionBody(structureText, headingName) {
1119
+ const wanted = normalizeSectionName(headingName);
1120
+ return sectionBody(
1121
+ structureText,
1122
+ (heading) => heading.level === 2 && normalizeSectionName(heading.text) === wanted,
1123
+ { level: 2, endOnSeparator: false },
1124
+ );
1125
+ }`,
1126
+ String.raw`function sectionBody(body, headingName) {
1127
+ const wanted = normalizeSectionName(headingName);
1128
+ const kept = [];
1129
+ let inSection = false;
1130
+ for (const line of String(body ?? '').split('\n')) {
1131
+ const heading = /^(#{1,6})[ \t]+(.+?)[ \t]*$/.exec(line);
1132
+ if (heading) {
1133
+ const level = heading[1].length;
1134
+ if (inSection && level <= 2) break; // 到下一个同级或更高级标题即段结束
1135
+ if (!inSection && level === 2 && normalizeSectionName(heading[2]) === wanted) {
1136
+ inSection = true;
1137
+ continue;
1138
+ }
1139
+ }
1140
+ if (inSection) kept.push(line);
1141
+ }
1142
+ return inSection ? kept.join('\n') : null;
1143
+ }`,
1144
+ ],
1145
+ // 调用点也一并改回旧名:变异体因此是一份自洽的「改动之前的文件」,而不是半截替换。
1146
+ ['contextSectionBody(t, EVOLVE_METADATA_SECTION)', 'sectionBody(t, EVOLVE_METADATA_SECTION)'],
1147
+ ],
1148
+ },
1149
+ ];
1150
+
1151
+ // ---------- 任务对键形态探针(配对键单源锁的判据面) ----------
1152
+
1153
+ // 「任务对键」= 无序任务对的键:两个 id 先比较定序,再用一个**字符串字面量**当分隔符拼起来
1154
+ // (`a < b ? a + '\u0000' + b : b + '\u0000' + a`)。判据按**形态**判定,不看名字也不看分隔符取值:
1155
+ // 历史上的第二份实现叫 `gapPairKey`(与第一份不同名),换 `|` 一类分隔符的漂移也同样是第二份实现——
1156
+ // 按标识符名计数的锚对这两种形态都判绿(这正是本判据要补的盲区)。
1157
+ const PAIR_KEY_ORDER_RE = /\b([A-Za-z0-9_$]+)\s*<\s*([A-Za-z0-9_$]+)\s*\?/u;
1158
+
1159
+ function pairKeyForm(text) {
1160
+ const order = PAIR_KEY_ORDER_RE.exec(String(text ?? ''));
1161
+ if (order === null) return false;
1162
+ const [, left, right] = order;
1163
+ if (left === right) return false;
1164
+ // 分隔符只认「字符串字面量夹在两个标识符之间」:`left + '<任意字面量>' + right`(两种定序各判一次)。
1165
+ // 标识符里的 `$` 是正则元字符:直接拼进模式会被当作串尾锚,含它的键因此被静默漏检(探针的假绿形态)。
1166
+ const escaped = (identifier) => identifier.replace(/\$/gu, '\\$');
1167
+ const joined = (first, second) => new RegExp(
1168
+ '\\b' + escaped(first) + '\\s*\\+\\s*[\'"`][^\'"`]*[\'"`]\\s*\\+\\s*\\b' + escaped(second) + '\\b', 'u');
1169
+ return joined(left, right).test(text) || joined(right, left).test(text);
1170
+ }
1171
+
1172
+ // 引擎注释的「过程叙述」判据(纯函数 + 合成输入可驱动):注释行里不许出现任务号与
1173
+ // 「本任务 / 待收口 / 已收进 / 已照形态」一类改动叙述——注释写的是不变式,不是某一轮改动的日记。
1174
+ // Wave 行写法示例是注释里唯一允许出现任务号的地方(它示范的是输入形态,不是改动历史),故带
1175
+ // `Wave ` / `depends on` / `[P]` 的行跳过。返回命中数组(空 = 收口),每条 { kind, lineNumber, line }。
1176
+ // 受检面是整个引擎实现面(调用方逐文件喂 engineScriptTexts),故命中必须带行号:没有行号的
1177
+ // 「某文件里有一处」等于让接手的人自己再 grep 一次。
1178
+ function commentNarrationHits(text) {
1179
+ const narrative = /本任务|待收口|已收进|已照形态/u;
1180
+ // 任务号 = `T` + 两位数字。紧跟半角冒号的**不是**任务号,而是 ISO 时间戳的时分量
1181
+ // (`2026-02-30T00:00:00Z` 里的 `T00`)——注释里贴时间戳字面量是常态,判据不得把它读成任务号。
1182
+ const taskNumber = /[^A-Za-z]T\d{2}\b(?!:)/u;
1183
+ return String(text).split('\n')
1184
+ .map((line, index) => ({ line, lineNumber: index + 1 }))
1185
+ .filter((entry) => /^\s*\/\//u.test(entry.line))
1186
+ .filter((entry) => !entry.line.includes('Wave ')
1187
+ && !entry.line.includes('depends on') && !entry.line.includes('[P]'))
1188
+ .flatMap(({ line, lineNumber }) => {
1189
+ const hits = [];
1190
+ if (taskNumber.test(line)) hits.push({ kind: '任务号', lineNumber, line: line.trim() });
1191
+ if (narrative.test(line)) hits.push({ kind: '过程叙述', lineNumber, line: line.trim() });
1192
+ return hits;
1193
+ });
1194
+ }
1195
+
1196
+ // 配对键单源判据(纯函数 + 合成输入可驱动):返回问题数组(空 = 收口)。
1197
+ // ① 形态面:「任务对键」形态在引擎面内只许出现一处(键只有一份实现);
1198
+ // ② 落点:那一处必须就在产出第三族的模块里(键与它的生产者同源;落点由定义面反查,不写文件名);
1199
+ // ③ 消费方:补集判据所在的模块不得持有任何键形态——它消费 task-graph 返回的判定(谓词),
1200
+ // 不自己比 id(第二份键的形态一旦漂移,两端键就不再相等,补集判据会静默失效)。
1201
+ function pairKeySingleSourceProblems({ texts }) {
1202
+ const problems = [];
1203
+ const hits = [];
1204
+ for (const [rel, text] of texts) {
1205
+ for (const unit of [...functionBodies(text), ...objectLiteralArrowBodies(text)]) {
1206
+ if (pairKeyForm(unit.text)) hits.push({ rel, symbol: unit.name });
1207
+ }
1208
+ }
1209
+ if (hits.length !== 1) {
1210
+ problems.push('任务对键应恰一处实现,实际: ' + JSON.stringify(hits));
1211
+ return problems;
1212
+ }
1213
+ const producer = engineDefinitionModule('collectCrossTaskConflicts');
1214
+ if (producer === null) {
1215
+ problems.push('第三族产出的定义面不唯一(反查失败): '
1216
+ + JSON.stringify(engineDefinitionHits('collectCrossTaskConflicts')));
1217
+ return problems;
1218
+ }
1219
+ if (hits[0].rel !== producer.file) {
1220
+ problems.push('任务对键落在 ' + hits[0].rel + '(应与第三族产出同源: ' + producer.file + ')');
1221
+ }
1222
+ const consumer = engineDefinitionModule('parallelGapReview');
1223
+ if (consumer !== null && hits.some((hit) => hit.rel === consumer.file)) {
1224
+ problems.push(consumer.file + ' 自建任务对键(补集判据应消费 ' + producer.file + ' 返回的判定)');
1225
+ }
1226
+ return problems;
1227
+ }
1228
+
1229
+ // ---------- 写面元素的取用面(写面单源锁的判据面) ----------
1230
+
1231
+ // 写面元素标签的字面量(元素名大小写无关)。判据按**形态**判定,不看名字与常量名:元素提取的形态是
1232
+ // 同一行里同时出现开标签与闭标签(正则字面量不能跨行),任何消费方自持一份标签正则,代码层就留下这个
1233
+ // 形态——元素名少一个 /i 的副本(大小写敏感)同样被它看见。那种副本让 7 字段门判「字段在场」、写面
1234
+ // 判定判「未知」:任务静默掉出写面判据面(写写重叠漏拦、同文件族漏判、伪并行启发式漏报),而同波同层
1235
+ // 的同文件对反被 [P] 判据当成「可并行」误报,恢复句还把方向指到 depends_on。只提到一次标签的报文 /
1236
+ // 恢复指引不是提取形态(「缺 <write_files> 元素」是在说缺什么,不是在解析它)。
1237
+ const WRITE_FACE_TAG_MENTION_RE = /write_files>/giu;
1238
+ const WRITE_FACE_EXTRACTION_MIN_MENTIONS = 2;
1239
+
1240
+ // 一行里的标签提及次数(剥注释后的代码层):>= 2 即元素提取形态(开 + 闭)。
1241
+ function writeFaceExtractionLines(text) {
1242
+ return engineCodeText(text).split('\n')
1243
+ .filter((line) => (line.match(WRITE_FACE_TAG_MENTION_RE) ?? []).length >= WRITE_FACE_EXTRACTION_MIN_MENTIONS);
1244
+ }
1245
+
1246
+ // 单源面判据(纯函数 + 合成输入可驱动):元素提取形态只许出现在单源模块的代码层(且恰一处),其余模块
1247
+ // 一处都不许有。返回问题数组(空 = 收口)。
1248
+ function writeFaceSourceProblems({ texts, sourceRel }) {
1249
+ const problems = [];
1250
+ for (const [rel, text] of texts) {
1251
+ const extractionLines = writeFaceExtractionLines(text);
1252
+ if (rel === sourceRel) {
1253
+ if (extractionLines.length !== 1) {
1254
+ problems.push(rel + ':写面元素提取应恰一处,实际 ' + extractionLines.length + ' 处(单源面被破坏)');
1255
+ }
1256
+ continue;
1257
+ }
1258
+ if (extractionLines.length > 0) {
1259
+ problems.push(rel + ' 自带写面元素标签提取(' + extractionLines.length + ' 处)——元素提取应取用单源,'
1260
+ + '大小写敏感的副本会让同一份写面在一处判在场、另一处判未知');
1261
+ }
1262
+ }
1263
+ return problems;
1264
+ }
1265
+
1266
+ // 派生面模块的**内存变异体**(data: URL;相对 import 重写为绝对 file: URL):反向构造只改内存里的源
1267
+ // 文本,不落盘、不留残留。变异体因此与真模块共享同一组依赖,行为差异只来自被改动的那处代码。
1268
+ function inlineModuleUrl(source, rel) {
1269
+ const rewritten = source.replace(/(from\s*')(\.[^']*)(')/gu, (whole, head, specifier, tail) =>
1270
+ head + pathToFileURL(path.resolve(SCRIPTS_DIR, path.dirname(rel), specifier)).href + tail);
1271
+ return 'data:text/javascript;charset=utf-8,' + encodeURIComponent(rewritten);
1272
+ }
1273
+
1274
+ export const ENTRIES = [
1275
+
1276
+ // ============================================================================================
1277
+ // 产出物结构(七类工件)
1278
+ // ============================================================================================
1279
+
1280
+ // TA-01 · 七类产出物缺段被拦(AC-1)——每类取一个夹具:缺模板中的一个必填 H2 → BLOCKED,报文含
1281
+ // 模板路径与「缺段」类别计数;首次**不列具体段名**(段名清单留到再犯时给,见 TA-15)。
1282
+ // 反向构造:同夹具补回该段 → 通过(旧逻辑对这批段本就不查,故负例在旧实现上必然放过)。
1283
+ {
1284
+ name: 'TA-01 七类产出物缺必填 H2:各节点出口 BLOCKED(含模板路径与缺段计数),补回后通过',
1285
+ run: async (dir) => {
1286
+ const cases = [
1287
+ { doc: 'CHANGE', node: 'open', omit: '影响面', setup: setupOpen },
1288
+ { doc: 'REQUIREMENT', node: 'open', omit: '非功能性需求', setup: (root, opts) => setupOpen(root, {}, opts) },
1289
+ { doc: 'DESIGN', node: 'design', omit: '风险', setup: (root, opts) => setupDesign(root, { designOpts: opts }) },
1290
+ { doc: 'TASK', node: 'plan', omit: '阻塞日志', setup: setupPlan },
1291
+ { doc: 'SUMMARY', node: 'execute', omit: '是否触发新工作', setup: setupExecute },
1292
+ { doc: 'REVIEW', node: 'review', omit: '总结', setup: setupReview },
1293
+ { doc: 'TEST', node: 'verify', omit: '新增测试登记', setup: setupVerify },
1294
+ ];
1295
+ for (const item of cases) {
1296
+ const label = item.doc + ' 缺「' + item.omit + '」';
1297
+ // ① 负例:缺段 → BLOCKED,且报文带模板路径与缺段类别
1298
+ item.setup(dir, { omit: [item.omit] });
1299
+ const blocked = exitNode(dir, item.node);
1300
+ assertTrue(blocked.status === 1, label + ' 应被拦(exit 1),实际 exit ' + blocked.status + '\n' + blocked.output);
1301
+ assertOut(blocked, 'BLOCKED');
1302
+ assertOut(blocked, 'flow-kit/templates/' + docBase(item.doc));
1303
+ assertTrue(/缺段[^\n]{0,12}\d/.test(blocked.output), label + ' 报文应含「缺段」类别与计数,实际: ' + blocked.output);
1304
+ // 首次不列段名:抽掉的段名不得出现在报文里(否则「先读模板」的引导被绕过)
1305
+ assertNotOut(blocked, item.omit);
1306
+ // ② 反向构造:补回该段 → 通过
1307
+ item.setup(dir);
1308
+ const passed = exitNode(dir, item.node);
1309
+ assertTrue(passed.status === 0, '补回「' + item.omit + '」后应通过,实际 exit ' + passed.status + '\n' + passed.output);
1310
+ assertOut(passed, 'ALL CHECKS PASSED');
1311
+ }
1312
+ },
1313
+ },
1314
+
1315
+ // TA-02 · H3 结构子段纳入、示例条目排除(AC-2)——① TEST 缺 1.5 结构子段 → BLOCKED;
1316
+ // ② SUMMARY 缺「已知接受 + 理由」→ BLOCKED;③ 示例条目(🔴 / ADR- / AC- / L- 形态)未出现
1317
+ // **不算缺段**(正例即「无任何示例条目的工件必须放行」)。
1318
+ {
1319
+ name: 'TA-02 H3 结构子段缺则拦(TEST 1.5 / SUMMARY 已知接受 + 理由),示例条目不参与骨架 + review 出口的 AC 覆盖汇总 WARN(段名走骨架)',
1320
+ run: async (dir) => {
1321
+ // ① TEST 缺结构子段
1322
+ setupVerify(dir, { subsectionOmit: ['测试质量自检'] });
1323
+ const resTest = exitNode(dir, 'verify');
1324
+ assertExit(resTest, 1);
1325
+ assertOut(resTest, '测试质量自检');
1326
+ // ② SUMMARY 缺结构子段
1327
+ setupExecute(dir, { subsectionOmit: ['已知接受'] });
1328
+ const resSummary = exitNode(dir, 'execute');
1329
+ assertExit(resSummary, 1);
1330
+ assertOut(resSummary, '已知接受');
1331
+ // ③ 反向构造:示例条目缺席不算缺段(正例;旧口径把示例当骨架即误拦)
1332
+ const exampleFree = renderDoc('TEST');
1333
+ assertTrue(!/🔴|ADR-\d|L-\d{3}/.test(exampleFree), '夹具前提不成立:正例正文不该含示例条目形态');
1334
+ setupVerify(dir);
1335
+ const resBaseline = exitNode(dir, 'verify');
1336
+ assertExit(resBaseline, 0);
1337
+ assertOut(resBaseline, 'ALL CHECKS PASSED');
1338
+ // ④ 反向构造(判别力):被抽掉的 TEST 子段确实来自登记表骨架,而不是标题巧合
1339
+ const registered = (docEntry('TEST').structureSubsections ?? []).map((s) => s.name).join('\n');
1340
+ assertTrue(registered.includes('测试质量自检'), '登记表未登记 TEST 的 1.5 结构子段——判据无处生根');
1341
+
1342
+ // ⑤~⑧ AC 覆盖与 1.1 矩阵段(review 出口只汇总、不阻断):
1343
+ // · 验收段与 1.1 矩阵段的段名都从骨架派生(模板权威单链,判据不自写标题正则)——省编号 /
1344
+ // 省括号的宽容写法同样命中(⑥),矩阵段换成无关标题即「不可判」而不是「全覆盖」(⑦);
1345
+ // · review 出口对缺覆盖只给**一条**汇总 WARN(列缺失编号),退出码不变(AC-8);
1346
+ // · 无 TEST.md 时不打该 WARN(review 出口今天不要求 TEST.md,判据无从求值就不制造噪音)。
1347
+ const acBody = (ids) => (ids.length > 0
1348
+ ? ids.map((id) => '### ' + id + ' · 夹具准则\n\n- **Given** 夹具前置\n- **When** 夹具动作\n- **Then** 夹具结果').join('\n\n')
1349
+ : '- 本段只写散文、不含任何编号。');
1350
+ const acMatrix = (ids) => ['| AC | 类型 | 用例文件 / UAT | 状态 |', '|---|---|---|---|',
1351
+ ...ids.map((id) => '| ' + id + ' | unit | guard-self-test.mjs | ✅ |')].join('\n');
1352
+ const matrixHeading = '### 1.1 测试矩阵(AC → 用例)';
1353
+ // 夹具:review 节点 + REQUIREMENT(验收段列 acIds)+ TEST(1.1 矩阵只列 coveredIds);
1354
+ // heading 可换掉 1.1 段标题,用于段名宽容与「段缺席」两侧构造。
1355
+ const setupAcReview = (acIds, coveredIds, heading = matrixHeading, matrixBodyOverride = null) => {
1356
+ setupReview(dir);
1357
+ writeTemplateFixture(dir, 'REQUIREMENT');
1358
+ writeTemplateFixture(dir, 'TEST');
1359
+ writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md',
1360
+ renderDoc('REQUIREMENT', { body: [['验收准则', acBody(acIds)]] }));
1361
+ const testDoc = renderDoc('TEST', { body: [['1.1', matrixBodyOverride ?? acMatrix(coveredIds)]] });
1362
+ writeFile(dir, CHANGE_DIR + '/TEST.md',
1363
+ heading === matrixHeading ? testDoc : testDoc.replace(matrixHeading, heading));
1364
+ };
1365
+ const acSummaryLine = (res) => (res.output.match(/缺 AC 覆盖[^\n]*/u) ?? [''])[0];
1366
+ // ⑤ 汇总 WARN:一条(不逐条刷屏)、列缺失编号、不阻断
1367
+ setupAcReview(['AC-1', 'AC-2', 'AC-3'], ['AC-1']);
1368
+ const reviewMissing = runGuard(['exit', 'review'], dir);
1369
+ assertExit(reviewMissing, 0);
1370
+ assertOut(reviewMissing, 'REVIEW WARN: TEST.md 的 1.1 测试矩阵缺 AC 覆盖');
1371
+ assertTrue((reviewMissing.output.match(/缺 AC 覆盖/gu) ?? []).length === 1,
1372
+ 'review 出口只给一条汇总 WARN(不逐条刷屏),实际出现 '
1373
+ + (reviewMissing.output.match(/缺 AC 覆盖/gu) ?? []).length + ' 次');
1374
+ assertTrue(acSummaryLine(reviewMissing).includes('AC-2') && acSummaryLine(reviewMissing).includes('AC-3'),
1375
+ '汇总 WARN 应列出全部缺失编号,实际: ' + acSummaryLine(reviewMissing));
1376
+ assertNotOut(reviewMissing, 'BLOCKED');
1377
+ // ⑥ 段名宽容:省编号、省括号的写法同样命中(定位走骨架 headingPattern,不是写死标题)
1378
+ setupAcReview(['AC-1', 'AC-2'], ['AC-1'], '### 测试矩阵');
1379
+ const reviewLoose = runGuard(['exit', 'review'], dir);
1380
+ assertExit(reviewLoose, 0);
1381
+ assertOut(reviewLoose, 'REVIEW WARN: TEST.md 的 1.1 测试矩阵缺 AC 覆盖');
1382
+ // ⑦ 反向构造(判别力):矩阵段缺席 ⇒ 不可判(打不出缺覆盖),不是「全覆盖」;全量覆盖同理不打 WARN
1383
+ setupAcReview(['AC-1', 'AC-2'], ['AC-1'], '### 覆盖说明');
1384
+ const reviewNoMatrix = runGuard(['exit', 'review'], dir);
1385
+ assertExit(reviewNoMatrix, 0);
1386
+ assertNotOut(reviewNoMatrix, '缺 AC 覆盖');
1387
+ setupAcReview(['AC-1', 'AC-2'], ['AC-1', 'AC-2']);
1388
+ const reviewCovered = runGuard(['exit', 'review'], dir);
1389
+ assertExit(reviewCovered, 0);
1390
+ assertNotOut(reviewCovered, '缺 AC 覆盖');
1391
+ // ⑧ TEST.md 缺席(review 出口不要求它)→ 判据无从求值,不打 WARN、不改变退出码
1392
+ setupReview(dir);
1393
+ const reviewNoTest = runGuard(['exit', 'review'], dir);
1394
+ assertExit(reviewNoTest, 0);
1395
+ assertNotOut(reviewNoTest, '缺 AC 覆盖');
1396
+ assertOut(reviewNoTest, 'ALL CHECKS PASSED');
1397
+ // ⑨ 段体切片的围栏语义(1.1 矩阵段的段界由 lib/section-body.mjs 单点决定):矩阵段里贴了围栏代码块
1398
+ // (块内含 `## `)时,围栏之后的矩阵行仍参与覆盖判定——段体若在示例处截断,一条 AC 都读不到,
1399
+ // 「全覆盖」会被读成「全缺失」。
1400
+ const fencedMatrix = ['```md', '## 代码块里的示例段标题', '```', '', acMatrix(['AC-1', 'AC-2'])].join('\n');
1401
+ setupAcReview(['AC-1', 'AC-2'], [], matrixHeading, fencedMatrix);
1402
+ const reviewFencedMatrix = runGuard(['exit', 'review'], dir);
1403
+ assertExit(reviewFencedMatrix, 0);
1404
+ assertNotOut(reviewFencedMatrix, '缺 AC 覆盖');
1405
+ // ⑩ 分隔线语义保持:1.1 矩阵段不以 `---` 结束(既有语义)——分隔线之后的矩阵行照常参与判定
1406
+ setupAcReview(['AC-1', 'AC-2'], [], matrixHeading, '---\n\n' + acMatrix(['AC-1', 'AC-2']));
1407
+ const reviewRuleMatrix = runGuard(['exit', 'review'], dir);
1408
+ assertExit(reviewRuleMatrix, 0);
1409
+ assertNotOut(reviewRuleMatrix, '缺 AC 覆盖');
1410
+ },
1411
+ },
1412
+
1413
+ // TA-03 · 段序按模板全序(AC-3)——SUMMARY 把「数据库迁移」排到「越界检查」之后 → BLOCKED 且报文
1414
+ // 指明段序偏离。反向构造:同夹具保持模板序 → 通过。
1415
+ {
1416
+ name: 'TA-03 段序偏离模板全序:SUMMARY 数据库迁移排到越界检查之后 → BLOCKED(报文含段序)',
1417
+ run: async (dir) => {
1418
+ setupExecute(dir, { swap: [['数据库迁移', '越界检查']] });
1419
+ const res = exitNode(dir, 'execute');
1420
+ assertExit(res, 1);
1421
+ assertOut(res, 'BLOCKED');
1422
+ assertOut(res, '段序');
1423
+ assertOut(res, '数据库迁移');
1424
+ setupExecute(dir);
1425
+ const ok = exitNode(dir, 'execute');
1426
+ assertExit(ok, 0);
1427
+ assertOut(ok, 'ALL CHECKS PASSED');
1428
+ },
1429
+ },
1430
+
1431
+ // TA-04 · 标题形态与首部字段(AC-4)——① 标题不是模板形态(`# 变更文档`)→ 拦;② 首部
1432
+ // `- **Change ID**:` 有键但值为空 → 视为未填 → 拦。反向构造:两者都合规 → 通过。
1433
+ {
1434
+ name: 'TA-04 标题形态与首部空值:`# 变更文档` / `- **Change ID**:` 空值均拦,合规形态通过',
1435
+ run: async (dir) => {
1436
+ // ① 标题形态
1437
+ setupOpen(dir, { title: '# 变更文档' });
1438
+ const resTitle = exitNode(dir, 'open');
1439
+ assertExit(resTitle, 1);
1440
+ assertOut(resTitle, 'CHANGE');
1441
+ // ② 首部有键无值(旧口径只查键在场 → 必然放过)
1442
+ setupOpen(dir, { headerEmpty: ['Change ID'] });
1443
+ const resHeader = exitNode(dir, 'open');
1444
+ assertExit(resHeader, 1);
1445
+ assertOut(resHeader, 'Change ID');
1446
+ // ③ 反向构造:标题与首部合规 → 通过
1447
+ setupOpen(dir);
1448
+ const ok = exitNode(dir, 'open');
1449
+ assertExit(ok, 0);
1450
+ assertOut(ok, 'ALL CHECKS PASSED');
1451
+ },
1452
+ },
1453
+
1454
+ // TA-05 · 无条件段空正文被拦 + 六词白名单(AC-5)——CHANGE 的「影响面」空白 → BLOCKED;
1455
+ // 同段写 无 / N/A / 不适用 / — / 未涉及 / 无变更 任一 → 通过(逐词对照组)。
1456
+ {
1457
+ name: 'TA-05 无条件段空正文:影响面空白拦,六个白名单词逐一放行',
1458
+ run: async (dir) => {
1459
+ // ① 空白正文(含仅空白行)
1460
+ setupOpen(dir, { body: [['影响面', ' \n\n\t']] });
1461
+ const blank = exitNode(dir, 'open');
1462
+ assertExit(blank, 1);
1463
+ assertOut(blank, 'BLOCKED');
1464
+ assertOut(blank, '影响面');
1465
+ // ② 六词白名单(单变量:只改该段正文)
1466
+ for (const word of ['无', 'N/A', '不适用', '—', '未涉及', '无变更']) {
1467
+ setupOpen(dir, { body: [['影响面', word]] });
1468
+ const res = exitNode(dir, 'open');
1469
+ assertTrue(res.status === 0, '白名单词「' + word + '」应放行,实际 exit ' + res.status + '\n' + res.output);
1470
+ assertOut(res, 'ALL CHECKS PASSED');
1471
+ }
1472
+ // ③ 反向构造(判别力):白名单是**整段取值**而非子串——含白名单词的真实句子仍算已填,不误拦
1473
+ setupOpen(dir, { body: [['影响面', '无变更风险;影响 CHANGE 与 REQUIREMENT 两份工件。']] });
1474
+ const ok = exitNode(dir, 'open');
1475
+ assertTrue(ok.status === 0, '含白名单词的真实句子应放行(判据不得退化为子串命中),实际 exit '
1476
+ + ok.status + '\n' + ok.output);
1477
+ },
1478
+ },
1479
+
1480
+ // TA-06 · 照抄模板正文被拦(AC-6)——① 含待填位的模板正文(尖括号占位 / 复选框)逐字相同 →
1481
+ // 判未填 → BLOCKED;② 模板正文为成品形态(示例表格行)同样逐字比对——SUMMARY「改动文件」照抄
1482
+ // 模板里的示例文件清单(别的项目的文件)→ BLOCKED;两处各配「改写一个字符 → 通过」的单变量对照。
1483
+ {
1484
+ name: 'TA-06 与模板该段逐字相同判未填:照抄占位符拦,改写后通过',
1485
+ run: async (dir) => {
1486
+ const verbatim = templateSectionBody('CHANGE', '影响面');
1487
+ assertTrue(verbatim.trim() !== '', '夹具前提不成立:模板「影响面」段正文为空,无法构造逐字相同夹具');
1488
+ // ① 逐字相同 → 拦
1489
+ setupOpen(dir, { body: [['影响面', verbatim]] });
1490
+ const copied = exitNode(dir, 'open');
1491
+ assertExit(copied, 1);
1492
+ assertOut(copied, 'BLOCKED');
1493
+ // ② 反向构造:改写一个字符 → 通过
1494
+ const rewritten = verbatim + '(已按本 change 实际情况改写)';
1495
+ assertTrue(rewritten !== verbatim, '夹具前提不成立:改写未改变正文');
1496
+ setupOpen(dir, { body: [['影响面', rewritten]] });
1497
+ const ok = exitNode(dir, 'open');
1498
+ assertExit(ok, 0);
1499
+ assertOut(ok, 'ALL CHECKS PASSED');
1500
+ // ③ 模板正文为成品形态:示例表格行(无尖括号占位 / 复选框)照抄同样判未填。
1501
+ // 夹具自建该段正文(示例文件清单是「已填好的别的项目」形态),模板夹具与工件写同一内容。
1502
+ const exampleTable = [
1503
+ '| 文件 | 性质 | 说明 |',
1504
+ '|---|---|---|',
1505
+ '| `src/example/Fixture.ts` | 新增 | 模板示例行:实现夹具能力 |',
1506
+ '| `src/example/fixture.test.ts` | 新增 | 模板示例行:单元测试 |',
1507
+ ].join('\n');
1508
+ setupExecute(dir);
1509
+ writeTableTemplateFixture(dir, 'SUMMARY', '改动文件', exampleTable);
1510
+ writeFile(dir, CHANGE_DIR + '/T01-SUMMARY.md', renderDoc('SUMMARY', { body: [['改动文件', exampleTable]] }));
1511
+ const copiedTable = exitNode(dir, 'execute');
1512
+ assertExit(copiedTable, 1);
1513
+ assertOut(copiedTable, '改动文件');
1514
+ assertOut(copiedTable, '逐字');
1515
+ // ④ 反向构造(判别力):只改表格里一个值(换成本任务自己的文件)→ 通过
1516
+ const rewrittenTable = exampleTable.replace('src/example/Fixture.ts', 'src/real/Real.ts');
1517
+ assertTrue(rewrittenTable !== exampleTable, '夹具前提不成立:改写未改变示例表');
1518
+ writeFile(dir, CHANGE_DIR + '/T01-SUMMARY.md', renderDoc('SUMMARY', { body: [['改动文件', rewrittenTable]] }));
1519
+ const okTable = exitNode(dir, 'execute');
1520
+ assertExit(okTable, 0);
1521
+ assertOut(okTable, 'ALL CHECKS PASSED');
1522
+ },
1523
+ },
1524
+
1525
+ // TA-07 · 条件段标题必须在场(AC-7)——① CHANGE 缺「视觉调性」标题 → BLOCKED(标题缺席);
1526
+ // ② 标题在场、正文写「不适用」→ 通过。反向构造即 ②。
1527
+ {
1528
+ name: 'TA-07 条件段标题必须在场:CHANGE 缺视觉调性拦,正文写不适用放行',
1529
+ run: async (dir) => {
1530
+ // ① 标题缺席
1531
+ setupOpen(dir, { omit: ['视觉调性'] });
1532
+ const missing = exitNode(dir, 'open');
1533
+ assertExit(missing, 1);
1534
+ assertOut(missing, '视觉调性');
1535
+ // ② 标题在场 + 正文不适用 → 通过
1536
+ setupOpen(dir, { body: [['视觉调性', '不适用']] });
1537
+ const ok = exitNode(dir, 'open');
1538
+ assertExit(ok, 0);
1539
+ assertOut(ok, 'ALL CHECKS PASSED');
1540
+ // ③ 反向构造(判别力):把「视觉调性」改名成核心词不同的形态 ⇒ 等价于标题缺席,仍须拦
1541
+ setupOpen(dir, { rename: [['视觉调性', '视觉风格']] });
1542
+ const renamed = exitNode(dir, 'open');
1543
+ assertExit(renamed, 1);
1544
+ },
1545
+ },
1546
+
1547
+ // TA-08 · 条件子段与父段豁免(AC-8)+ 可选段语义(C-1)——① 前端 change 的 UI-DESIGN 缺
1548
+ // `### Button (Primary)` → BLOCKED(注意 Primary / Secondary 归一后同键:只写 Secondary 不得算
1549
+ // Primary 在场);② 非前端 change 的 TEST 第 4 轮整段 N/A 且缺 4.1~4.4 子段 → 通过(父段 N/A →
1550
+ // 子段不要求);⑤⑥ UI-DESIGN §0(optional)整段删除合法,但保留标题就得填;⑦ 四种包裹
1551
+ // 符号(**N/A** / > N/A / - N/A / (N/A))都算整段不适用、⑦b `**N/A**(理由)`(闭合标记后紧跟
1552
+ // 说明)同样算整段不适用、⑧ 「**见 N/A**」不算(不吞真句子;它是 ⑦b 的过度接受反锚)且报文
1553
+ // 给出与判据一致的规范写法;⑨⑩ 缺子段时点名「实际挂在 X 段下」/「实际在文末」;⑪ 补充提示只对
1554
+ // 父段正文的 N/A 意图痕迹发声(④ 是它的负锚:普通正文不弹),且父段名取模板里的真实段名。
1555
+ {
1556
+ name: 'TA-08 条件子段与父段豁免:UI-DESIGN 缺 Button (Primary) 拦;TEST 第 4 轮 N/A 放行',
1557
+ run: async (dir) => {
1558
+ const frontendChange = { body: [['视觉调性', '- **选定**:6 有机 / Organic\n- **理由**:前端夹具']] };
1559
+ // ① 前端 change:缺 Button (Primary)(同段保留 Button (Secondary) 作单变量对照)
1560
+ setupDesign(dir, {
1561
+ changeOpts: frontendChange,
1562
+ uiDesign: uiDesignDoc({ subsectionOmit: ['Button (Primary)'] }),
1563
+ declareUiDesign: true,
1564
+ });
1565
+ writeFrontendDesignMarkers(dir);
1566
+ const resUi = exitNode(dir, 'design');
1567
+ assertExit(resUi, 1);
1568
+ assertOut(resUi, 'Button (Primary)');
1569
+ // ② 反向构造:补回 Primary(Secondary 同时在场)→ 通过
1570
+ setupDesign(dir, { changeOpts: frontendChange, uiDesign: uiDesignDoc(), declareUiDesign: true });
1571
+ writeFrontendDesignMarkers(dir);
1572
+ const okUi = exitNode(dir, 'design');
1573
+ assertExit(okUi, 0);
1574
+ // ③ 非前端 change:第 4 轮父段 N/A、缺 4.1~4.4 子段 → 通过(默认夹具即此形态)
1575
+ setupVerify(dir);
1576
+ const okTest = exitNode(dir, 'verify');
1577
+ assertExit(okTest, 0);
1578
+ assertOut(okTest, 'ALL CHECKS PASSED');
1579
+ // ④ 反向构造(判别力):把第 4 轮改成有实质内容 → 其结构子段重新变为必填 → 缺子段必拦;
1580
+ // 同时是「若要整段不适用」补充提示的负锚——正文是普通说明、没有 N/A 意图痕迹,漏写子段时
1581
+ // 报文不得带这条提示(提示只对当事人想写 N/A 却写不规范的情形发声)。
1582
+ setupVerify(dir, { body: [['兼容性测试', '实测了三种视口组合的兼容性结论。']], subsectionOmit: ['跨浏览器'] });
1583
+ const resRound4 = exitNode(dir, 'verify');
1584
+ assertExit(resRound4, 1);
1585
+ assertOut(resRound4, '跨浏览器');
1586
+ assertNotOut(resRound4, '若要整段不适用');
1587
+ assertNotOut(resRound4, '父段「」');
1588
+ // ⑤ 可选段(optional)语义:UI-DESIGN §0 是模板自述「greenfield 删掉此段」的可选段——
1589
+ // 整段缺席合法,不得报「条件段标题缺席」(与 conditional 分流;conditional 仍要求标题在场,见 TA-07)。
1590
+ setupDesign(dir, {
1591
+ changeOpts: frontendChange,
1592
+ uiDesign: uiDesignDoc({ omit: ['0. 视觉语汇对齐'] }),
1593
+ declareUiDesign: true,
1594
+ });
1595
+ writeFrontendDesignMarkers(dir);
1596
+ const okOptional = exitNode(dir, 'design');
1597
+ assertExit(okOptional, 0);
1598
+ assertOut(okOptional, 'ALL CHECKS PASSED');
1599
+ // ⑥ 反向构造(判别力):保留 §0 标题但正文空、且不带 0.1~0.3 子段 → 必拦
1600
+ // (可选段「保留即须填」——缺席与留空壳是两件事)
1601
+ setupDesign(dir, {
1602
+ changeOpts: frontendChange,
1603
+ uiDesign: uiDesignDoc({ body: [['视觉语汇对齐', ' ']], subsectionOmit: ['0.1', '0.2', '0.3'] }),
1604
+ declareUiDesign: true,
1605
+ });
1606
+ writeFrontendDesignMarkers(dir);
1607
+ const resEmptyOptional = exitNode(dir, 'design');
1608
+ assertExit(resEmptyOptional, 1);
1609
+ assertOut(resEmptyOptional, '0.1');
1610
+ // ⑦ 整段不适用的包裹符号(AC-8):粗体 / 引用 / 列表 / 括号四种写法都是同一个词的包装——
1611
+ // 第 4 轮正文写成这些形态、其结构子段 4.1~4.4 全缺席 → 不报缺子段(父段豁免生效)。
1612
+ for (const wrapped of ['**N/A**', '> N/A', '- N/A', '(N/A)']) {
1613
+ setupVerify(dir, { body: [['兼容性测试', wrapped]], subsectionOmit: ['4.1', '4.2', '4.3', '4.4'] });
1614
+ const resWrapped = exitNode(dir, 'verify');
1615
+ assertTrue(resWrapped.status === 0, '第 4 轮正文「' + wrapped + '」应视为整段不适用、豁免结构子段,实际 exit '
1616
+ + resWrapped.status + '\n' + resWrapped.output);
1617
+ assertOut(resWrapped, 'ALL CHECKS PASSED');
1618
+ }
1619
+ // ⑦b 闭合标记后紧跟说明(正例锚):`**N/A**(本轮无变更)` 是「整段不适用 + 为什么」的合法
1620
+ // 书写形态。旧实现只剥尾部的**裸**闭合标记,标记之后一有文字裸文本就变成 `N/A**(…)`、
1621
+ // 白名单词后不再紧邻边界 ⇒ 判已填、子段照旧要求(报文还写着「不要加粗或引用」,与判据相反)。
1622
+ setupVerify(dir, { body: [['兼容性测试', '**N/A**(本轮无变更)']], subsectionOmit: ['4.1', '4.2', '4.3', '4.4'] });
1623
+ const resClosedNote = exitNode(dir, 'verify');
1624
+ assertTrue(resClosedNote.status === 0,
1625
+ '第 4 轮正文「**N/A**(本轮无变更)」应视为整段不适用、豁免结构子段,实际 exit '
1626
+ + resClosedNote.status + '\n' + resClosedNote.output);
1627
+ assertOut(resClosedNote, 'ALL CHECKS PASSED');
1628
+ // ⑧ 反例(AC-9):包装里是「见 N/A」这类真句子(剥掉包装后开头不是白名单词)→ 仍报缺子段。
1629
+ // 它是 ⑦b 的**过度接受**反锚:容忍「闭合标记后紧跟说明」不得顺手把「包装里包着真句子」也
1630
+ // 放行——区别在开头是不是白名单词,不在有没有包裹符号。
1631
+ // 父段有正文却不落白名单,报文同时给出**与判据一致**的规范写法(AC-10):包裹符号本身就被
1632
+ // 接受(旧报文写「不要加粗或引用」,与判据相反);要跟说明就写在闭合标记之后(⑦b 的形态)。
1633
+ setupVerify(dir, { body: [['兼容性测试', '**见 N/A**']], subsectionOmit: ['4.1', '4.2', '4.3', '4.4'] });
1634
+ const resSentence = exitNode(dir, 'verify');
1635
+ assertExit(resSentence, 1);
1636
+ assertOut(resSentence, '缺结构子段');
1637
+ assertOut(resSentence, '4.1');
1638
+ assertOut(resSentence, '若要整段不适用,请让整段以 N/A 开头');
1639
+ assertOut(resSentence, '包裹符号本身就被接受');
1640
+ assertOut(resSentence, '`**N/A**(理由)`');
1641
+ assertNotOut(resSentence, '不要加粗或引用');
1642
+ assertNotOut(resSentence, '父段「」');
1643
+ // ⑨ 诊断一(挂错父段):4.3 实际写在「第 5 轮 · 可观测性验证」下 → 报文点名实际归属
1644
+ // (只加定位说明,不改归属算法)。
1645
+ setupVerify(dir, {
1646
+ body: [['兼容性测试', '实测了三种视口组合的兼容性结论。']],
1647
+ subsectionOmit: ['4.3'],
1648
+ insertAfter: [['可观测性验证', '### 4.3 数据迁移(涉及 schema 变更必填)\n\n夹具:误挂在第 5 轮下的子段。\n']],
1649
+ });
1650
+ const resMisplaced = exitNode(dir, 'verify');
1651
+ assertExit(resMisplaced, 1);
1652
+ assertOut(resMisplaced, '缺结构子段');
1653
+ assertOut(resMisplaced, '实际挂在');
1654
+ assertOut(resMisplaced, '第 5 轮 · 可观测性验证 段下');
1655
+ // ⑩ 诊断一(文末):4.4 被贴到模板骨架之外(文末「附录」段之下)→ 报文写「实际在文末」。
1656
+ setupVerify(dir, {
1657
+ body: [['兼容性测试', '实测了三种视口组合的兼容性结论。']],
1658
+ subsectionOmit: ['4.4'],
1659
+ extra: ['## 附录\n\n### 4.4 跨版本\n\n夹具:误贴在文末的子段。'],
1660
+ });
1661
+ const resTail = exitNode(dir, 'verify');
1662
+ assertExit(resTail, 1);
1663
+ assertOut(resTail, '缺结构子段');
1664
+ assertOut(resTail, '实际在文末');
1665
+ // ⑪ 正锚(④ 的对称面):父段正文留下 N/A 意图痕迹(「(说明:N/A)」这类带前置说明词、
1666
+ // 不在整段白名单里的写法)→ 子段仍要求,报文给出规范写法;父段名取模板里的真实段名,
1667
+ // 空父段名「父段「」」对定位毫无价值,两处都不许出现。
1668
+ setupVerify(dir, { body: [['兼容性测试', '(说明:N/A)']], subsectionOmit: ['4.1', '4.2', '4.3', '4.4'] });
1669
+ const resIntent = exitNode(dir, 'verify');
1670
+ assertExit(resIntent, 1);
1671
+ assertOut(resIntent, '若要整段不适用,请让整段以 N/A 开头');
1672
+ assertOut(resIntent, '包裹符号本身就被接受');
1673
+ assertOut(resIntent, '父段「第 4 轮 · 兼容性测试」');
1674
+ assertNotOut(resIntent, '父段「」');
1675
+ },
1676
+ },
1677
+
1678
+ // TA-09 · 段名宽容四变体(AC-9)——省括号 / 括号不同 / 大小写不同 → 均通过;核心词不同
1679
+ // (`0.5 架构对齐`)→ BLOCKED。
1680
+ // 正例的两个条件父段(`0.5 既有架构对齐` / `9. 架构沉淀建议`)都给实质正文 = 父段适用 → 其结构
1681
+ // 子段(0.5.1~0.5.3 与 9.1~9.5)必须同时在场的合规形态;只改父段标题的写法,不得动子段。
1682
+ {
1683
+ name: 'TA-09 段名宽容:省括号/换括号/大小写三变体通过,核心词不同的段名拦',
1684
+ run: async (dir) => {
1685
+ const variants = [
1686
+ ['省括号', '0.5 既有架构对齐'],
1687
+ ['括号不同', '0.5 既有架构对齐(brownfield 场景夹具说明)'],
1688
+ ['形态差异', '0.5 既有架构对齐(B2 老项目护栏)'],
1689
+ ['大小写', '0.5 既有架构对齐(BROWNFIELD 必填)'],
1690
+ ];
1691
+ // 两个条件父段的实质正文(父段适用 → 登记表列出的结构子段逐条要求)
1692
+ const applicableBodies = [
1693
+ ['既有架构对齐', '本 change 触碰的既有模块与沿用对照见下表(夹具)。'],
1694
+ ['架构沉淀建议', '本 change 有可复用的沉淀候选,逐项见各子段(夹具)。'],
1695
+ ];
1696
+ for (const [label, heading] of variants) {
1697
+ setupDesign(dir, {
1698
+ designOpts: {
1699
+ rename: [['既有架构对齐', heading]],
1700
+ body: applicableBodies,
1701
+ },
1702
+ });
1703
+ const res = exitNode(dir, 'design');
1704
+ assertTrue(res.status === 0, '段名宽容变体「' + label + '」(' + heading + ')应通过,实际 exit '
1705
+ + res.status + '\n' + res.output);
1706
+ assertOut(res, 'ALL CHECKS PASSED');
1707
+ }
1708
+ // 反向构造(判别力):父段适用却抽掉结构子段 → 必拦(证明子段要求真的在跑,正例不是空转)
1709
+ setupDesign(dir, {
1710
+ designOpts: { body: applicableBodies, subsectionOmit: ['0.5.2'] },
1711
+ });
1712
+ const resSubsection = exitNode(dir, 'design');
1713
+ assertExit(resSubsection, 1);
1714
+ assertOut(resSubsection, '0.5.2');
1715
+ // 反向构造:核心词不同(既有架构对齐 → 架构对齐)→ 拦
1716
+ setupDesign(dir, {
1717
+ designOpts: {
1718
+ rename: [['既有架构对齐', '0.5 架构对齐']],
1719
+ body: applicableBodies,
1720
+ },
1721
+ });
1722
+ const resCore = exitNode(dir, 'design');
1723
+ assertExit(resCore, 1);
1724
+ assertOut(resCore, 'BLOCKED');
1725
+ },
1726
+ },
1727
+
1728
+ // TA-10 · 模板外多余段允许(AC-10)——TEST 含模板之外的 `## Findings`(工具输出原样贴入)→ 通过,
1729
+ // 且该段不参与段序判定(把它插在模板段中间也不得触发段序偏离)。
1730
+ {
1731
+ name: 'TA-10 模板外多余段:TEST 插入 ## Findings 放行且不参与段序判定',
1732
+ run: async (dir) => {
1733
+ const findings = '## Findings\n\n工具输出原样贴入:0 findings(夹具)。';
1734
+ setupVerify(dir, { insertAfter: [['功能测试', findings]] });
1735
+ const res = exitNode(dir, 'verify');
1736
+ assertExit(res, 0);
1737
+ assertOut(res, 'ALL CHECKS PASSED');
1738
+ assertNotOut(res, '段序');
1739
+ // 反向构造(判别力):多余段若真的参与排序,把它换成模板段的错位顺序必须被判段序偏离
1740
+ // (下面这组是错位形态 → 必拦;两侧共用同一判据,证明上一条不是判据空转)
1741
+ setupVerify(dir, { swap: [['回归保护', '本次测试范围声明']] });
1742
+ const resOrder = exitNode(dir, 'verify');
1743
+ assertExit(resOrder, 1);
1744
+ },
1745
+ },
1746
+
1747
+ // TA-11 · 旧 change 只告警(AC-11)——旧 change(无 newChange 标记)同构缺段 → 不阻断并输出 WARN;
1748
+ // 反向构造:同一夹具置 newChange → BLOCKED。
1749
+ // ⑤ 追加「视觉调性」段体的围栏语义:段里贴了含 `## ` 的围栏示例时,示例之后的「不适用」声明
1750
+ // 仍要被读到(段界只由围栏外的标题决定)。
1751
+ {
1752
+ name: 'TA-11 旧 change 同构缺段只 WARN 不阻断;同一夹具新 change 必 BLOCKED;视觉调性段内的围栏示例不截断',
1753
+ run: async (dir) => {
1754
+ const missing = { omit: ['影响面'] };
1755
+ // ① 新 change:拦(对照基准——同一份缺损工件)
1756
+ setupOpen(dir, missing);
1757
+ const newRes = exitNode(dir, 'open');
1758
+ assertExit(newRes, 1);
1759
+ // ② 旧 change:WARN 不阻断(唯一差异 = state 缺 newChange 标记)
1760
+ setupOpen(dir, missing);
1761
+ const legacy = baseState('open');
1762
+ legacy.evidence.open = { summary: 'intake complete' };
1763
+ writeState(dir, legacy);
1764
+ const legacyRes = exitNode(dir, 'open');
1765
+ assertExit(legacyRes, 0);
1766
+ assertOut(legacyRes, 'WARN');
1767
+ assertNotOut(legacyRes, 'BLOCKED');
1768
+ // ③ design 侧段缺席:同一判据——CHANGE.md「视觉调性」段缺席,新 change 由 uidesign 门兜底拦,
1769
+ // 不再默认判非前端(段缺席与段内声明「不适用」是两件事,只有后者是决策)。
1770
+ setupDesign(dir, { changeOpts: { omit: ['视觉调性'] } });
1771
+ const designNew = exitNode(dir, 'design');
1772
+ assertExit(designNew, 1);
1773
+ assertOut(designNew, '「视觉调性」段缺席');
1774
+ assertOut(designNew, '新 change 须显式标注「不适用」');
1775
+ // ④ 反向构造(同一份缺损工件,唯一差异 = state 缺 newChange 标记):旧 change 兼容跳过、不阻断。
1776
+ setupDesign(dir, { changeOpts: { omit: ['视觉调性'] } });
1777
+ const designLegacy = baseState('design');
1778
+ designLegacy.evidence.design = { summary: 'design done' };
1779
+ writeState(dir, designLegacy);
1780
+ const designLegacyRes = exitNode(dir, 'design');
1781
+ assertExit(designLegacyRes, 0);
1782
+ assertOut(designLegacyRes, '旧 change 兼容');
1783
+ // ⑤ 段体围栏语义:「视觉调性」段里贴一段含 `## ` 的围栏示例,「不适用」声明写在围栏**之后**
1784
+ // ⇒ 段体不被示例里的标题截断,判据仍读到声明(围栏是正文示例,不是段界)。旧的按行扫描
1785
+ // 在这里截断段体 → 标记消失 → 判成前端 → 要求一份本不该存在的 UI-DESIGN.md(BLOCKED)。
1786
+ setupDesign(dir, {
1787
+ changeOpts: {
1788
+ body: [['视觉调性',
1789
+ '- **选定**:6 有机 / Organic\n\n```md\n## 示例段(围栏内,不是段界)\n```\n\n- 适用性:不适用(CLI 工具,无用户可见界面)']],
1790
+ },
1791
+ });
1792
+ writeFrontendDesignMarkers(dir);
1793
+ const fencedTone = exitNode(dir, 'design');
1794
+ assertExit(fencedTone, 0);
1795
+ assertOut(fencedTone, 'UI-DESIGN: skipped(非前端)');
1796
+ },
1797
+ },
1798
+
1799
+ // TA-12 · 增量段合法位置(AC-12)——①②④⑤ 合法位置通过;③ 自检方法夹在中间 → BLOCKED。
1800
+ // 合法位置:紧随越界检查 / 文末 / 验证命令标题后紧跟代码块 / LESSONS 扫描位于自检方法之后。
1801
+ // ⑥ 追加 SUMMARY 两条段体切片的围栏语义:6 维自查 / 自检方法段内的围栏示例不截断段体。
1802
+ {
1803
+ name: 'TA-12 增量段位置:紧随越界检查/文末/验证命令+代码块/LESSONS 扫描在后均通过,夹中间拦;6 维自查/自检方法段内围栏示例不截断',
1804
+ run: async (dir) => {
1805
+ // ① 紧随越界检查(默认渲染即此形态)
1806
+ setupExecute(dir);
1807
+ const afterBounds = exitNode(dir, 'execute');
1808
+ assertExit(afterBounds, 0);
1809
+ assertOut(afterBounds, 'ALL CHECKS PASSED');
1810
+ // ② 位于文末(两个增量段都落在骨架段之后,自检方法在最末之前 —— 登记表的 end 分支)
1811
+ setupExecute(dir, { incrementAllAtEnd: true });
1812
+ const atEnd = exitNode(dir, 'execute');
1813
+ assertExit(atEnd, 0);
1814
+ assertOut(atEnd, 'ALL CHECKS PASSED');
1815
+ // ④ 验证命令标题后紧跟代码块(TEST 默认渲染即此形态)
1816
+ setupVerify(dir);
1817
+ const verifyCmd = exitNode(dir, 'verify');
1818
+ assertExit(verifyCmd, 0);
1819
+ assertOut(verifyCmd, 'ALL CHECKS PASSED');
1820
+ // ⑤ LESSONS 扫描位于自检方法之后(默认渲染即此形态)
1821
+ const summaryText = renderDoc('SUMMARY');
1822
+ assertTrue(summaryText.indexOf('## LESSONS 扫描') > summaryText.indexOf('## 自检方法'),
1823
+ '夹具前提不成立:LESSONS 扫描应位于自检方法之后');
1824
+ // ③ 反向构造:自检方法夹在 6 维自查与数据库迁移之间 → BLOCKED
1825
+ setupExecute(dir, { incrementAfter: [['自检方法', '6 维自查']] });
1826
+ const inMiddle = exitNode(dir, 'execute');
1827
+ assertExit(inMiddle, 1);
1828
+ assertOut(inMiddle, 'BLOCKED');
1829
+ assertOut(inMiddle, '自检方法');
1830
+ // ⑥ 段体围栏语义(SUMMARY 的两条切片):6 维自查 / 自检方法段里各贴一段含 `## ` 的围栏示例,
1831
+ // 方法声明写在围栏**之后** ⇒ 段体不被示例里的标题截断,六维实质内容与声明都仍被读到。
1832
+ // 旧的两条正则在示例处截断段体 → 「6 维自查段无实质内容」/「缺 ## 自检方法 段」(BLOCKED)。
1833
+ const fencedBlock = '```md\n## 示例段(围栏内,不是段界)\n```\n\n';
1834
+ setupExecute(dir, {
1835
+ body: [
1836
+ ['6 维自查', fencedBlock + SIX_DIM_BODY],
1837
+ ['自检方法', fencedBlock + 'brooks-review(夹具声明)'],
1838
+ ],
1839
+ });
1840
+ const fencedExecute = exitNode(dir, 'execute');
1841
+ assertExit(fencedExecute, 0);
1842
+ assertOut(fencedExecute, 'ALL CHECKS PASSED');
1843
+ assertNotOut(fencedExecute, '6 维自查段无实质内容');
1844
+ },
1845
+ },
1846
+
1847
+ // ============================================================================================
1848
+ // 加载链与协议面
1849
+ // ============================================================================================
1850
+
1851
+ // TA-13 · 加载链(AC-13)——入口的两条指针(步骤权威 / 段形权威)与声明面:
1852
+ // ① `entry <内置节点>` 先打 `READ PROMPT:` 再打 `READ TEMPLATE:`,顺序按输出行索引判
1853
+ // (不是只查两行在不在——行序是语义的一部分);
1854
+ // ② 声明别的节点的协议文件(open 声明 execute 的 4-dev.md)→ 入口 BLOCK,报文点名「与节点协议文件不符」;
1855
+ // ②c 一个标记声明**多份**协议(0-change.md + 4-dev.md)→ 入口逐份核对,第二份越界同样 BLOCK 并
1856
+ // 点名 4-dev.md(只读 protocol 单值的实现只看第一份,这条会绿);两份都在面内 ⇒ 放行;
1857
+ // ③ design 的 2a-ui-design.md 是条件提示词(属该节点协议面)→ 不拦;入口按前端判据追出条件行
1858
+ // (非前端不打印,反向构造即同一夹具只改「视觉调性」);换成无关文件 → 拦;
1859
+ // ④ record 缺 `--templates` 声明 → BLOCK,补上 → 放行;⑤ explain 现问输出 `TEMPLATE:` 行。
1860
+ // 反向构造:②③ 各用真实 skill-load 只改 --prompt(其余参数不变)构造正例——排除「标记存在与否」
1861
+ // 这另一变量;① 另带「同一判据 + 变异探针」,对调两条指针后判据必须翻假,否则顺序断言退化成包含断言。
1862
+ // 声明面走真实命令而非手写标记:标记形态由生产写入路径产生,正是场景最容易与真实链路分叉的地方。
1863
+ {
1864
+ name: 'TA-13 加载链:entry 先 READ PROMPT 后 READ TEMPLATE,--prompt 错路径入口拦(条件提示词放行),record 缺 --templates 拦,explain 有 TEMPLATE 行',
1865
+ run: async (dir) => {
1866
+ // 声明走真实命令 skill-load(而不是手写标记 JSON):标记形态(protocol 取 basename、templates
1867
+ // 清单)由生产写入路径产生,入口判据读到的就是真实链路的形态。
1868
+ const skillLoad = (node, skill, prompt, templates) => runState(
1869
+ ['skill-load', node, skill, '--prompt', 'flow-kit/prompts/' + prompt, '--templates', templates],
1870
+ dir,
1871
+ );
1872
+ // 反例标记只能手写:skill-load 对新 change 拒绝「缺模板」的声明(那正是 ④ 要构造的缺陷态)。
1873
+ const writeMarker = (node, skill, protocol) => writeFile(
1874
+ dir,
1875
+ CHANGE_DIR + '/.skill-loads/' + node + '-' + skill + '.json',
1876
+ JSON.stringify({ node, skill, protocol, at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n',
1877
+ );
1878
+ const removeMarker = (node, skill) => fs.rmSync(
1879
+ path.join(dir, CHANGE_DIR, '.skill-loads', node + '-' + skill + '.json'),
1880
+ { force: true },
1881
+ );
1882
+ // 行序判据(单一函数供正向断言与变异探针共用):两条指针都在场,且全部提示词行在全部模板行之前。
1883
+ const lineIndexes = (lines, prefix) => lines
1884
+ .map((line, index) => (line.startsWith(prefix) ? index : -1))
1885
+ .filter((index) => index !== -1);
1886
+ const promptLinesBeforeTemplates = (text) => {
1887
+ const lines = text.split('\n');
1888
+ const promptAt = lineIndexes(lines, 'READ PROMPT:');
1889
+ const templateAt = lineIndexes(lines, 'READ TEMPLATE:');
1890
+ return promptAt.length > 0 && templateAt.length > 0
1891
+ && Math.max(...promptAt) < Math.min(...templateAt);
1892
+ };
1893
+
1894
+ // ① 顺序:open 是两提示词 + 两模板的节点,取「最后一条提示词 < 第一条模板」的收敛形态
1895
+ setupOpen(dir);
1896
+ const load = skillLoad('open', 'flow-comet-change', '0-change.md', 'CHANGE.md,REQUIREMENT.md');
1897
+ assertExit(load, 0);
1898
+ assertOut(load, 'SKILL-LOAD: open flow-comet-change');
1899
+ const entry = runGuard(['entry', 'open'], dir);
1900
+ assertExit(entry, 0);
1901
+ assertOut(entry, 'READ PROMPT: flow-kit/prompts/0-change.md');
1902
+ assertOut(entry, 'READ PROMPT: flow-kit/prompts/1-requirement.md');
1903
+ assertOut(entry, 'READ TEMPLATE: flow-kit/templates/CHANGE.md');
1904
+ assertTrue(promptLinesBeforeTemplates(entry.output),
1905
+ '入口两条指针顺序错:READ PROMPT 行应全部先于 READ TEMPLATE 行\n实际输出:\n' + entry.output);
1906
+ // 反向构造(同一判据 + 变异探针):对调两串标签后同一判据必须翻假
1907
+ const swapped = entry.output.replace(/READ (PROMPT|TEMPLATE):/g,
1908
+ (match, label) => 'READ ' + (label === 'PROMPT' ? 'TEMPLATE' : 'PROMPT') + ':');
1909
+ assertTrue(swapped !== entry.output, '变异探针前提失效:入口输出里没有可对调的两条指针');
1910
+ assertTrue(!promptLinesBeforeTemplates(swapped), '顺序判据不具判别力:对调两条指针后仍判通过');
1911
+
1912
+ // ①b 指针不校验文件在否:模板整体缺席时两行照常打印——指针标识的是「该读哪份模板」,文件
1913
+ // 缺席由产出物门禁的「未校验(模板缺失)」报告(公开文档的口径以此为准)。
1914
+ fs.rmSync(path.join(dir, 'flow-kit'), { recursive: true, force: true });
1915
+ assertTrue(!fs.existsSync(path.join(dir, 'flow-kit', 'templates', 'CHANGE.md')),
1916
+ '夹具前提失效:模板文件应确实不在磁盘上(否则本条退化成「指针必指向已有文件」的旧表述)');
1917
+ const noTemplateEntry = runGuard(['entry', 'open'], dir);
1918
+ assertExit(noTemplateEntry, 0);
1919
+ assertOut(noTemplateEntry, 'READ TEMPLATE: flow-kit/templates/CHANGE.md');
1920
+ assertOut(noTemplateEntry, 'READ PROMPT: flow-kit/prompts/0-change.md');
1921
+
1922
+ // ② 错路径:open 声明 execute 的协议文件 4-dev.md → 入口 BLOCK(报文点名不符)
1923
+ // 声明命令本身只校验 flow-kit/prompts/ 前缀,归属判定由入口负责——故这里真实命令成功、入口拦。
1924
+ assertExit(skillLoad('open', 'flow-comet-change', '4-dev.md', 'CHANGE.md,REQUIREMENT.md'), 0);
1925
+ const wrongPrompt = runGuard(['entry', 'open'], dir);
1926
+ assertExit(wrongPrompt, 1);
1927
+ assertOut(wrongPrompt, 'BLOCKED');
1928
+ assertOut(wrongPrompt, '与节点协议文件不符');
1929
+ assertOut(wrongPrompt, '4-dev.md');
1930
+ // 反向构造:真实命令只把 --prompt 改回本节点协议文件 → 放行(拦点是被声明的路径,不是标记存在性)
1931
+ assertExit(skillLoad('open', 'flow-comet-change', '0-change.md', 'CHANGE.md,REQUIREMENT.md'), 0);
1932
+ const correctedPrompt = runGuard(['entry', 'open'], dir);
1933
+ assertExit(correctedPrompt, 0);
1934
+ assertNotOut(correctedPrompt, '与节点协议文件不符');
1935
+ // ②b 入口只认活动路径(in-place 扩展):同样的错路径声明只存在于归档目录(真实的归档形态
1936
+ // <日期>-<本 change>)时,入口不追溯归档——那一轮没在活动目录里声明,就没有可核对的声明;
1937
+ // 归档里的声明属于归档前的执行者,拿它判当前节点会把「没声明」判成「声明过」。判据可证伪:
1938
+ // 一旦入口改去读归档,这条错路径声明会当场 BLOCK。
1939
+ const loadsDir = path.join(dir, CHANGE_DIR, '.skill-loads');
1940
+ const loadsAside = path.join(dir, '.specs', 'loads-aside');
1941
+ fs.renameSync(loadsDir, loadsAside);
1942
+ writeFile(dir, '.specs/archive/2026-10-01-' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
1943
+ JSON.stringify({
1944
+ node: 'open', skill: 'flow-comet-change', protocol: '4-dev.md',
1945
+ templates: ['CHANGE', 'REQUIREMENT'], at: '2026-08-01T00:00:00.000Z',
1946
+ }, null, 2) + '\n');
1947
+ const archivedDeclaration = runGuard(['entry', 'open'], dir);
1948
+ assertExit(archivedDeclaration, 0);
1949
+ assertNotOut(archivedDeclaration, '与节点协议文件不符');
1950
+ // 复位:归档诱饵撤掉、活动声明标记归位——③ 起按「已声明」继续
1951
+ fs.rmSync(path.join(dir, '.specs', 'archive'), { recursive: true, force: true });
1952
+ fs.renameSync(loadsAside, loadsDir);
1953
+
1954
+ // ②c 多 --prompt:一个标记可声明多份协议,入口必须**逐份**核对。只读 protocol 单值的实现只看
1955
+ // 第一份 ⇒ 第二份落在节点协议面外也照样放行(记下的是「声明过」,不是「声明对」)。第一份是
1956
+ // open 的协议文件、第二份是 execute 的 4-dev.md → BLOCKED 且点名 4-dev.md。
1957
+ const multiPrompt = (prompts) => runState([
1958
+ 'skill-load', 'open', 'flow-comet-change',
1959
+ ...prompts.flatMap((prompt) => ['--prompt', 'flow-kit/prompts/' + prompt]),
1960
+ '--templates', 'CHANGE.md,REQUIREMENT.md',
1961
+ ], dir);
1962
+ assertExit(multiPrompt(['0-change.md', '4-dev.md']), 0);
1963
+ const multiPromptEntry = runGuard(['entry', 'open'], dir);
1964
+ assertExit(multiPromptEntry, 1);
1965
+ assertOut(multiPromptEntry, 'BLOCKED');
1966
+ assertOut(multiPromptEntry, '与节点协议文件不符');
1967
+ assertOut(multiPromptEntry, '4-dev.md');
1968
+ // 反向构造(单变量 = 被声明的路径):两条 --prompt 都落在 open 的协议面内 ⇒ 放行。拦点因此是
1969
+ // 「哪一份被声明」,不是「声明了几份」。
1970
+ assertExit(multiPrompt(['0-change.md', '1-requirement.md']), 0);
1971
+ const multiPromptOk = runGuard(['entry', 'open'], dir);
1972
+ assertExit(multiPromptOk, 0);
1973
+ assertNotOut(multiPromptOk, '与节点协议文件不符');
1974
+
1975
+ // ③ 条件提示词不误拦 + 按前端判定打印:design 声明 2a-ui-design.md(条件提示词,属该节点协议面)
1976
+ // → 放行;前端 change 的入口追出条件行(与条件模板行对称),非前端 change 不打印。
1977
+ const frontendChange = { body: [['视觉调性', '- **选定**:6 有机 / Organic\n- **理由**:前端夹具']] };
1978
+ const conditionalPromptLine = 'READ PROMPT(条件提示词): flow-kit/prompts/2a-ui-design.md(仅前端 change)';
1979
+ // 条件行判据:逐行精确匹配(不用「包含文件名」的宽写法——标签或尾注漂移同样该红)。
1980
+ const hasConditionalPromptLine = (text) => text.split(/\r?\n/).includes(conditionalPromptLine);
1981
+ setupDesign(dir, { changeOpts: frontendChange });
1982
+ assertExit(skillLoad('design', 'flow-comet-design', '2-design.md', 'DESIGN.md'), 0);
1983
+ assertExit(skillLoad('design', 'flow-comet-ui-design', '2a-ui-design.md', 'DESIGN.md,UI-DESIGN.md'), 0);
1984
+ const conditionalOk = runGuard(['entry', 'design'], dir);
1985
+ assertExit(conditionalOk, 0);
1986
+ assertNotOut(conditionalOk, '与节点协议文件不符');
1987
+ assertOut(conditionalOk, 'READ PROMPT: flow-kit/prompts/2-design.md');
1988
+ assertTrue(hasConditionalPromptLine(conditionalOk.output),
1989
+ '前端 change 的 entry 未打印条件提示词行 ' + JSON.stringify(conditionalPromptLine)
1990
+ + '\n实际输出:\n' + conditionalOk.output);
1991
+ // 反向构造(同一判据 + 单变量):只把「视觉调性」改成「不适用」→ 前端判据为假,条件行必须消失
1992
+ // (实现若无视判据无条件打印,此处必红);必填提示词行不受影响。
1993
+ setupDesign(dir, { changeOpts: { body: [['视觉调性', '不适用']] } });
1994
+ assertExit(skillLoad('design', 'flow-comet-design', '2-design.md', 'DESIGN.md'), 0);
1995
+ assertExit(skillLoad('design', 'flow-comet-ui-design', '2a-ui-design.md', 'DESIGN.md,UI-DESIGN.md'), 0);
1996
+ const conditionalSkipped = runGuard(['entry', 'design'], dir);
1997
+ assertExit(conditionalSkipped, 0);
1998
+ assertOut(conditionalSkipped, 'READ PROMPT: flow-kit/prompts/2-design.md');
1999
+ assertTrue(!hasConditionalPromptLine(conditionalSkipped.output),
2000
+ '非前端 change 的 entry 不应打印条件提示词行\n实际输出:\n' + conditionalSkipped.output);
2001
+ // 反向构造:真实命令只把 --prompt 换成无关文件 → 同一夹具立刻拦
2002
+ assertExit(skillLoad('design', 'flow-comet-ui-design', '3-task.md', 'DESIGN.md,UI-DESIGN.md'), 0);
2003
+ const conditionalWrong = runGuard(['entry', 'design'], dir);
2004
+ assertExit(conditionalWrong, 1);
2005
+ assertOut(conditionalWrong, 'BLOCKED');
2006
+ assertOut(conditionalWrong, '与节点协议文件不符');
2007
+ assertOut(conditionalWrong, '3-task.md');
2008
+ // 移除条件提示词声明,④⑤ 回到单声明形态(与原有 record / explain 断言同形)
2009
+ removeMarker('design', 'flow-comet-ui-design');
2010
+
2011
+ // ④ 标记缺模板声明 → record BLOCKED 且提示 --templates;反向构造:声明了模板 → 放行
2012
+ writeMarker('design', 'flow-comet-design', '2-design.md');
2013
+ const recordBlocked = runState(['record', 'design', '{"summary":"design done"}'], dir);
2014
+ assertExit(recordBlocked, 1);
2015
+ assertOut(recordBlocked, '--templates');
2016
+ // 重新声明指引同时给出 --prompt:模板与提示词是同一次声明的两面,而 skill-load 重跑会覆写
2017
+ // 同一标记——只补 --templates 会把 protocol 写成 null,下一次 exit 反被判「缺协议声明标记」。
2018
+ // 记录侧没有 skill 名(只有它仍是 <skill> 占位);提示词路径必须是真实路径,不是占位符。
2019
+ assertOut(recordBlocked, '--prompt flow-kit/prompts/2-design.md');
2020
+ assertNotOut(recordBlocked, '--prompt <');
2021
+ assertExit(skillLoad('design', 'flow-comet-design', '2-design.md', 'DESIGN.md'), 0);
2022
+ const recordOk = runState(['record', 'design', '{"summary":"design done"}'], dir);
2023
+ assertExit(recordOk, 0);
2024
+ assertNotOut(recordOk, 'BLOCKED');
2025
+
2026
+ // ⑤ explain 现问输出模板行
2027
+ const explain = runState(['explain', 'design'], dir);
2028
+ assertExit(explain, 0);
2029
+ assertOut(explain, 'TEMPLATE:');
2030
+ assertOut(explain, 'flow-kit/templates/DESIGN.md');
2031
+ },
2032
+ },
2033
+
2034
+ // TA-14 · 自定义协议按声明决定(AC-14)——① 自定义节点未声明模板 → 不校验(结构缺损也放行);
2035
+ // ② 同节点声明了模板 → 校验(同样的缺损 → BLOCKED);③ 内置节点未声明 → BLOCKED。
2036
+ {
2037
+ name: 'TA-14 自定义协议三态:未声明不校验 / 声明则校验 / 内置节点未声明拦',
2038
+ run: async (dir) => {
2039
+ const protocolWith = (templates) => {
2040
+ const proto = customProtocol();
2041
+ proto.nodes[0].outputSchemas = ['compose.change.v1'];
2042
+ proto.outputSchemas = [{
2043
+ id: 'compose.change.v1',
2044
+ description: 'CHANGE.md(自定义节点产物)',
2045
+ artifacts: [{
2046
+ id: 'change-doc', kind: 'file', required: true,
2047
+ paths: ['<change-id>/CHANGE.md'], pathBase: 'specs-root',
2048
+ }],
2049
+ evidence: [{ id: 'change-summary', required: true }],
2050
+ }];
2051
+ if (templates !== undefined) proto.nodes[0].templates = templates;
2052
+ return proto;
2053
+ };
2054
+ const writeProtocol = (proto) => writeFile(dir, 'reference/workflow-protocol.json', JSON.stringify(proto, null, 2) + '\n');
2055
+ const writeCustomFixture = () => {
2056
+ writeTemplateFixture(dir, 'CHANGE');
2057
+ writeFile(dir, changeDirOf(), renderDoc('CHANGE', { omit: ['影响面'] }));
2058
+ const st = baseState('brainstorm');
2059
+ st.activeChange = CHANGE_ID;
2060
+ st.newChange = true;
2061
+ st.enteredNodes = ['brainstorm'];
2062
+ st.evidence.brainstorm = { summary: 'notes done' };
2063
+ writeState(dir, st);
2064
+ };
2065
+ function changeDirOf() { return CHANGE_DIR + '/CHANGE.md'; }
2066
+ // ① 未声明 → 不校验
2067
+ writeProtocol(protocolWith(undefined));
2068
+ writeCustomFixture();
2069
+ const undeclared = runGuard(['exit', 'brainstorm'], dir);
2070
+ assertExit(undeclared, 0);
2071
+ assertNotOut(undeclared, 'BLOCKED');
2072
+ // ② 声明了模板 → 校验(同样的结构缺损 → 拦)
2073
+ writeProtocol(protocolWith(['CHANGE']));
2074
+ writeCustomFixture();
2075
+ const declared = runGuard(['exit', 'brainstorm'], dir);
2076
+ assertExit(declared, 1);
2077
+ assertOut(declared, 'BLOCKED');
2078
+ // ③ 反向构造:内置节点缺模板声明 → 拦(把内置协议副本的节点声明删掉)
2079
+ writeProtocol((() => {
2080
+ const builtin = JSON.parse(fs.readFileSync(path.join(SCRIPTS_DIR, '..', 'reference', 'workflow-protocol.json'), 'utf8'));
2081
+ for (const node of builtin.nodes) delete node.templates;
2082
+ return builtin;
2083
+ })());
2084
+ setupOpen(dir, { omit: ['影响面'] });
2085
+ const builtinUndeclared = runGuard(['exit', 'open'], dir);
2086
+ assertExit(builtinUndeclared, 1);
2087
+ assertOut(builtinUndeclared, 'BLOCKED');
2088
+ // ④ 声明命令的形态(唯一构造器的直接判据):内置节点拼该节点**全部**协议文件的真实路径
2089
+ // (与入口 READ PROMPT 同源)与该节点的模板全清单;自定义节点没有内置提示词映射 → 不拼
2090
+ // (不编造路径,也不打占位符)。只带首份协议 / 漏模板清单都是「照抄走不通」的形态,逐条断死。
2091
+ // 构造器同时产出**脚本路径**(平台化 + 引号)与**协议上下文**(本次运行解析到的协议不是内置
2092
+ // 默认时才带 --protocol):状态命令族与守卫族取的是这一处,裸脚本名 / 无协议上下文的形态不再存在
2093
+ // ——「照抄能跑通」的行为证据在场景 100(解析打印文本 → 真执行)。
2094
+ const { declarationSkillTargets } = await import('../protocol-utils.mjs');
2095
+ const { declarationCommand } = await import('../lib/state-explain.mjs');
2096
+ const declarationContext = (protocolPath) => ({
2097
+ scriptsDir: path.join(dir, '.claude', 'skills', 'flow-comet', 'scripts'),
2098
+ runRoot: dir,
2099
+ packageRoot: path.join(dir, '.claude', 'skills', 'flow-comet'),
2100
+ protocolPath,
2101
+ });
2102
+ // 内置默认协议 = **本次运行的那个安装根**自己的 reference/workflow-protocol.json(不是权威源
2103
+ // 那一份):判据比较的就是这两个路径,故夹具必须按「该安装根的内置默认」构造。
2104
+ const installedSkillRoot = path.join(dir, '.claude', 'skills', 'flow-comet');
2105
+ const builtinContext = declarationContext(path.join(installedSkillRoot, 'reference', 'workflow-protocol.json'));
2106
+ const executeCommand = declarationCommand({
2107
+ node: { id: 'execute' }, skill: 'flow-comet-dev', context: builtinContext });
2108
+ assertTrue(executeCommand.startsWith('node "'),
2109
+ '声明命令应以 node "<脚本路径>" 起头(裸脚本名照抄 command not found),实际: ' + executeCommand);
2110
+ assertTrue(executeCommand.includes('/workflow-state.mjs" skill-load execute flow-comet-dev'
2111
+ + ' --prompt flow-kit/prompts/4-dev.md --templates SUMMARY.md'),
2112
+ '内置节点的声明命令应带脚本路径、全部协议文件与模板全清单,实际: ' + executeCommand);
2113
+ // 协议上下文按「本次运行解析到的是不是内置默认」决定:内置默认加载它只是噪音,自定义协议
2114
+ // 不随命令走则照抄解析到另一份(状态命令族没有 state 绑定这一来源)。
2115
+ assertTrue(!executeCommand.includes('--protocol'),
2116
+ '内置默认协议时声明命令不应带 --protocol,实际: ' + executeCommand);
2117
+ const customProtocolContext = declarationCommand({
2118
+ node: { id: 'execute' }, skill: 'flow-comet-dev', context: declarationContext(path.join(dir, 'custom-protocol.json')) });
2119
+ assertTrue(customProtocolContext.includes('--protocol "custom-protocol.json"'),
2120
+ '自定义协议下声明命令必须自带协议上下文(持久化相对形态),实际: ' + customProtocolContext);
2121
+ // open:一条命令带该节点两份协议(旧形态只带首份 0-change.md——照抄后 exit 仍点名 1-requirement.md)
2122
+ const openCommand = declarationCommand({
2123
+ node: { id: 'open' }, skill: 'flow-comet-requirement', context: builtinContext });
2124
+ assertTrue(openCommand.includes(' skill-load open flow-comet-requirement'
2125
+ + ' --prompt flow-kit/prompts/0-change.md --prompt flow-kit/prompts/1-requirement.md'
2126
+ + ' --templates CHANGE.md,REQUIREMENT.md'),
2127
+ 'open 的声明命令应带该节点全部协议文件与模板全清单,实际: ' + openCommand);
2128
+ const customCommand = declarationCommand({
2129
+ node: { id: 'brainstorm', templates: ['CHANGE'] }, skill: 'fixture-skill', context: builtinContext });
2130
+ assertTrue(customCommand.includes(' skill-load brainstorm fixture-skill --templates CHANGE.md')
2131
+ && !customCommand.includes('--prompt'),
2132
+ '自定义节点无内置提示词映射时不应拼 --prompt,实际: ' + customCommand);
2133
+ // 装配单源:命令构造器在引擎面只此一处定义(第二份装配 = 同一件事的第二种文本形态,
2134
+ // 而两种文本只有一种能执行——这正是本判据要防的形态)。
2135
+ const constructorHits = engineDefinitionHits('declarationCommand');
2136
+ assertTrue(constructorHits.length === 1 && constructorHits[0].count === 1,
2137
+ '声明命令的构造器应恰一处定义,实际: ' + JSON.stringify(constructorHits));
2138
+ // 声明的目标技能:每个 guarded 必需技能各一条(open 两条);条件绑定(design 的 ui-design)不在
2139
+ // 同步面展开——它是否适用要判前端,展开权归判得了该判据的出口。
2140
+ // 目标集取自协议节点本身(guarded 必需技能是协议面的事实,不是测试里另编的一份)
2141
+ const builtinOpenNode = JSON.parse(fs.readFileSync(
2142
+ path.join(SCRIPTS_DIR, '..', 'reference', 'workflow-protocol.json'), 'utf8')).nodes.find((node) => node.id === 'open');
2143
+ const openTargets = declarationSkillTargets(builtinOpenNode);
2144
+ assertTrue(openTargets.join(',') === 'flow-comet-change,flow-comet-requirement',
2145
+ 'open 的声明目标应是两个 guarded 必需技能,实际: ' + openTargets.join(','));
2146
+ const designTargets = declarationSkillTargets({
2147
+ id: 'design',
2148
+ implementation: { skill: 'flow-comet-design' },
2149
+ requiredSkillCalls: [
2150
+ { skill: 'flow-comet-design', enforcement: 'guarded', scope: 'main' },
2151
+ { skill: 'flow-comet-ui-design', enforcement: 'guarded', scope: 'main' },
2152
+ ],
2153
+ });
2154
+ assertTrue(designTargets.join(',') === 'flow-comet-design',
2155
+ 'design 的同步面声明目标应只含无条件必需技能(ui-design 由判得了前端的出口展开),实际: '
2156
+ + designTargets.join(','));
2157
+
2158
+ // ⑤ --preflight 与自定义协议的组合(in-place 扩展):结构预检的**声明工件**判据必须来自命令行
2159
+ // 指定的那份协议。造法 = 内置协议副本 + 给 open 节点追加一件只在这份协议里声明的 file 类产物,
2160
+ // 同一夹具跑两次、唯一变量是 --protocol:不指这份协议时没人会去查那件产物,指了就按它拦。
2161
+ // 环境变量(= 上面的对照侧)先复位成**未经改写的**内置副本——本场景 ③ 曾把该副本的模板声明
2162
+ // 改过,带着它做对照就不是单变量了。故「忽略 CLI 参数」与「内置判据写死」两种退化都会让第一次
2163
+ // 调用变成通过(或缺件不被点名)。
2164
+ const builtinProtocolCopy = JSON.parse(
2165
+ fs.readFileSync(path.join(SCRIPTS_DIR, '..', 'reference', 'workflow-protocol.json'), 'utf8'));
2166
+ writeFile(dir, 'reference/workflow-protocol.json', JSON.stringify(builtinProtocolCopy, null, 2) + '\n');
2167
+ const protocolWithExtraArtifact = {
2168
+ ...builtinProtocolCopy,
2169
+ nodes: builtinProtocolCopy.nodes.map((node) => (node.id === 'open'
2170
+ ? { ...node, outputSchemas: [...node.outputSchemas, 'fixture.extra-artifact.v1'] }
2171
+ : node)),
2172
+ outputSchemas: [...builtinProtocolCopy.outputSchemas, {
2173
+ id: 'fixture.extra-artifact.v1',
2174
+ description: '协议追加的 open 产物(只在本自定义协议里声明)',
2175
+ artifacts: [{
2176
+ id: 'custom-evidence', kind: 'file', required: true,
2177
+ paths: ['<change-id>/custom-evidence.md'], pathBase: 'specs-root',
2178
+ }],
2179
+ evidence: [],
2180
+ }],
2181
+ };
2182
+ const customProtocolFile = path.join(dir, 'reference', 'custom-preflight-protocol.json');
2183
+ writeFile(dir, 'reference/custom-preflight-protocol.json', JSON.stringify(protocolWithExtraArtifact, null, 2) + '\n');
2184
+ setupOpen(dir);
2185
+ const customPreflight = runGuard(['exit', 'open', '--preflight', '--protocol', customProtocolFile], dir);
2186
+ assertExit(customPreflight, 1);
2187
+ assertOut(customPreflight, '声明工件缺失');
2188
+ assertOut(customPreflight, '.specs/' + CHANGE_ID + '/custom-evidence.md');
2189
+ assertTrue(!fs.existsSync(path.join(dir, CHANGE_DIR, '.template-hints.json')),
2190
+ '--preflight 不得写提示账本(自定义协议下同样是只读)');
2191
+ // 反向对照(单变量 = 少一个 --protocol):同一夹具、同一节点、同一命令形态 → 内置副本里没有
2192
+ // 这件产物,故不报缺件(同时排除「预检本来就一律报缺件」这一读法)。
2193
+ const builtinPreflight = runGuard(['exit', 'open', '--preflight'], dir);
2194
+ assertExit(builtinPreflight, 0);
2195
+ assertNotOut(builtinPreflight, 'custom-evidence.md');
2196
+ // 正例:按自定义协议声明的路径补上该产物 → 同一命令转为通过(判据跟着协议走,不是恒拦)
2197
+ writeFile(dir, CHANGE_DIR + '/custom-evidence.md', '# 追加产物\n\n自定义协议声明的结构输入。\n');
2198
+ const satisfiedPreflight = runGuard(['exit', 'open', '--preflight', '--protocol', customProtocolFile], dir);
2199
+ assertExit(satisfiedPreflight, 0);
2200
+ assertOut(satisfiedPreflight, 'ALL CHECKS PASSED');
2201
+
2202
+ // ⑥ 参数面收紧(in-place 扩展):同一命令形态、同一夹具,只改参数的拼写——单横线疑似旗标
2203
+ // (`-apply` 单横线笔误 / `-h`)与节点之后的多余位置参数,修复前都被静默忽略(`-apply` 既不
2204
+ // 落盘也不报错,看起来像一次成功的预演;多余的裸词同样无人认领)。现在两者一律是用法错误、
2205
+ // 非零退出,且不得进入任何门禁链——参数面因此与「已知旗标 + 一个节点名」逐字对得上。
2206
+ const singleDashFlag = runGuard(['exit', 'open', '--preflight', '-apply'], dir);
2207
+ assertExit(singleDashFlag, 1);
2208
+ assertOut(singleDashFlag, '用法错误');
2209
+ assertOut(singleDashFlag, '-apply');
2210
+ assertNotOut(singleDashFlag, 'ALL CHECKS PASSED');
2211
+ const shortFlag = runGuard(['exit', 'open', '-h'], dir);
2212
+ assertExit(shortFlag, 1);
2213
+ assertOut(shortFlag, '用法错误');
2214
+ assertOut(shortFlag, '-h');
2215
+ // 多余位置参数:--protocol 的取值不算位置参数(两者在同一命令里并存,判据不得把取值当多余项)。
2216
+ const extraOperand = runGuard(
2217
+ ['exit', 'open', '--preflight', '--protocol', customProtocolFile, 'extra-operand'], dir);
2218
+ assertExit(extraOperand, 1);
2219
+ assertOut(extraOperand, '用法错误');
2220
+ assertOut(extraOperand, 'extra-operand');
2221
+ assertNotOut(extraOperand, 'ALL CHECKS PASSED');
2222
+ // 正对照:同一夹具的合法形态(--protocol 取值 + 无多余操作数)仍然通过——上面三条不是
2223
+ // 「预检一律失败」的同义反复。
2224
+ const legalAgain = runGuard(['exit', 'open', '--preflight', '--protocol', customProtocolFile], dir);
2225
+ assertExit(legalAgain, 0);
2226
+ assertOut(legalAgain, 'ALL CHECKS PASSED');
2227
+ },
2228
+ },
2229
+
2230
+ // TA-15 · 报错两阶段与记忆(AC-15)——同一工件首次因缺段被拦:只给模板路径 + 类别计数,不列段名;
2231
+ // 再犯:列出段名;工件通过后标记清除。反向构造:修复后复检 + 标记文件不再记录该工件。
2232
+ // 记忆按**文件**计:execute 出口的多份 *-SUMMARY.md 共用同一个模板键,各份必须独立记忆——同一次
2233
+ // 出口各自首败不互相升级,修好一份即释放该份的键(不许被另一份的失败永久保键)。
2234
+ {
2235
+ name: 'TA-15 两阶段报错:首次不列段名、再犯列段名、通过后清标记(多份 SUMMARY 各记各的)',
2236
+ run: async (dir) => {
2237
+ // 单份工件的失败行(同一份工件在报告里占一行;用于按文件断言,避免整串输出互相串味)
2238
+ const failureLine = (res, file) => res.output.split(/\r?\n/)
2239
+ .find((line) => line.includes(file + ' 模板结构校验失败')) ?? '';
2240
+ setupExecute(dir, { omit: ['是否触发新工作'] });
2241
+ const first = exitNode(dir, 'execute');
2242
+ assertExit(first, 1);
2243
+ assertOut(first, 'BLOCKED');
2244
+ assertNotOut(first, '是否触发新工作');
2245
+ const hintFile = path.join(dir, CHANGE_DIR, '.template-hints.json');
2246
+ assertTrue(fs.existsSync(hintFile), '首次结构失败应写入 .specs/<change>/.template-hints.json(跨两次 exit 记忆)');
2247
+ const second = exitNode(dir, 'execute');
2248
+ assertExit(second, 1);
2249
+ assertOut(second, '是否触发新工作');
2250
+ // 反向构造:工件通过 → 标记清除
2251
+ setupExecute(dir);
2252
+ const passed = exitNode(dir, 'execute');
2253
+ assertExit(passed, 0);
2254
+ assertOut(passed, 'ALL CHECKS PASSED');
2255
+ const cleared = !fs.existsSync(hintFile)
2256
+ || !JSON.stringify(JSON.parse(fs.readFileSync(hintFile, 'utf8'))).toUpperCase().includes('SUMMARY');
2257
+ assertTrue(cleared, '工件通过后应清除该工件的两阶段标记,实际: '
2258
+ + (fs.existsSync(hintFile) ? fs.readFileSync(hintFile, 'utf8') : '(文件已删)'));
2259
+ // ⑤ 两份 SUMMARY 同一次出口各自首败 → 都不升级(后一份不许继承前一份刚写下的键)
2260
+ const omitSection = (res, file) => {
2261
+ const line = failureLine(res, file);
2262
+ assertTrue(line !== '', '两份 SUMMARY 都应出现在同一次出口的失败报告里(缺 ' + file + ')');
2263
+ return line.includes('是否触发新工作');
2264
+ };
2265
+ setupExecute(dir, { omit: ['是否触发新工作'] });
2266
+ writeFile(dir, CHANGE_DIR + '/T02-SUMMARY.md', renderDoc('SUMMARY', { omit: ['是否触发新工作'] }));
2267
+ const pairFirst = exitNode(dir, 'execute');
2268
+ assertExit(pairFirst, 1);
2269
+ assertTrue(!omitSection(pairFirst, 'T01-SUMMARY.md'), 'T01 首败不应列段名: ' + failureLine(pairFirst, 'T01-SUMMARY.md'));
2270
+ assertTrue(!omitSection(pairFirst, 'T02-SUMMARY.md'),
2271
+ 'T02 首败不应列段名(另一份刚写下的键不许把它升级成再犯): ' + failureLine(pairFirst, 'T02-SUMMARY.md'));
2272
+ const pairKeys = Object.keys(JSON.parse(fs.readFileSync(hintFile, 'utf8')));
2273
+ for (const file of ['T01-SUMMARY.md', 'T02-SUMMARY.md']) {
2274
+ assertTrue(pairKeys.some((key) => key.includes(file)),
2275
+ '记忆账本应按文件分开记录(缺 ' + file + '): ' + pairKeys.join(', '));
2276
+ }
2277
+ // ⑥ 反向构造:两份都再犯 → 两份都列段名(按文件记忆不削弱「再犯」判据)
2278
+ const pairSecond = exitNode(dir, 'execute');
2279
+ assertExit(pairSecond, 1);
2280
+ for (const file of ['T01-SUMMARY.md', 'T02-SUMMARY.md']) {
2281
+ assertTrue(omitSection(pairSecond, file), file + ' 再犯应列出段名: ' + failureLine(pairSecond, file));
2282
+ }
2283
+ // ⑦ 修好一份、另一份仍红 → 修好的那份释放记忆键;再坏一次仍算首败(同一次出口里的另一份
2284
+ // 仍在失败,不许把它拖回再犯)。
2285
+ writeFile(dir, CHANGE_DIR + '/T01-SUMMARY.md', renderDoc('SUMMARY'));
2286
+ const oneFixed = exitNode(dir, 'execute');
2287
+ assertExit(oneFixed, 1); // T02 仍缺段:出口照常拦
2288
+ assertTrue(omitSection(oneFixed, 'T02-SUMMARY.md'),
2289
+ '仍失败的 T02 应保持再犯形态: ' + failureLine(oneFixed, 'T02-SUMMARY.md'));
2290
+ const afterFixKeys = Object.keys(JSON.parse(fs.readFileSync(hintFile, 'utf8')));
2291
+ assertTrue(!afterFixKeys.some((key) => key.includes('T01-SUMMARY.md')),
2292
+ '修好的 T01 应释放其记忆键(不许靠 T02 的失败永久保键): ' + afterFixKeys.join(', '));
2293
+ writeFile(dir, CHANGE_DIR + '/T01-SUMMARY.md', renderDoc('SUMMARY', { omit: ['是否触发新工作'] }));
2294
+ const brokeAgain = exitNode(dir, 'execute');
2295
+ assertExit(brokeAgain, 1);
2296
+ assertTrue(!omitSection(brokeAgain, 'T01-SUMMARY.md'),
2297
+ '释放后再次坏掉应按首败处理(不列段名): ' + failureLine(brokeAgain, 'T01-SUMMARY.md'));
2298
+
2299
+ // ⑧ --preflight 与完整 exit 的两阶段差异(in-place 扩展):预检只读、不维护提示账本,故同一
2300
+ // 节点连跑两次预检都停在报文的**首段**(只报类别计数);写账本的是完整 exit,它才在第二次
2301
+ // 点名段名。两侧都得锁住——预检若改成写账本,第二次预检会提前把段名用掉(「先读模板」的
2302
+ // 引导被绕开);完整 exit 若不写账本,第二次仍只报计数(两阶段报错退化成单阶段)。
2303
+ setupExecute(dir, { omit: ['是否触发新工作'] });
2304
+ assertTrue(!fs.existsSync(hintFile), '夹具起点不应有提示账本');
2305
+ const preFirst = runGuard(['exit', 'execute', '--preflight'], dir);
2306
+ assertExit(preFirst, 1);
2307
+ assertOut(preFirst, '缺段 1 项');
2308
+ assertNotOut(preFirst, '是否触发新工作');
2309
+ assertTrue(!fs.existsSync(hintFile), '--preflight 不得写提示账本(首段形态的前提)');
2310
+ const preSecond = runGuard(['exit', 'execute', '--preflight'], dir);
2311
+ assertExit(preSecond, 1);
2312
+ assertOut(preSecond, '缺段 1 项');
2313
+ assertNotOut(preSecond, '是否触发新工作');
2314
+ assertTrue(!fs.existsSync(hintFile), '第二次 --preflight 仍不得写提示账本(不升级成列段名)');
2315
+ // 同一节点、同一工件、同一缺损:完整 exit 首次只报计数并开账本,第二次点名段名。
2316
+ const fullFirst = exitNode(dir, 'execute');
2317
+ assertExit(fullFirst, 1);
2318
+ assertOut(fullFirst, '缺段 1 项');
2319
+ assertNotOut(fullFirst, '是否触发新工作');
2320
+ assertTrue(fs.existsSync(hintFile), '完整 exit 首次失败应写提示账本(再犯才有「再犯」可言)');
2321
+ const fullSecond = exitNode(dir, 'execute');
2322
+ assertExit(fullSecond, 1);
2323
+ assertOut(fullSecond, '缺段 1 项: 是否触发新工作');
2324
+ },
2325
+ },
2326
+
2327
+ // TA-16 · REVIEW 发现必须在模板位置(AC-16)——① 发现写在 `## 发现` 而 `### 2.2` 下无条目
2328
+ // → BLOCKED 并提示迁移到 2.2;② 按模板写在 2.2 → 通过;③ 模板范例形态(`### 🔴 …` + 粗体
2329
+ // 字段)同样是「发现」——缺处置标记 → BLOCKED(修复前该形态整段静默空过 = RED),同内容改回
2330
+ // 列表项 → 同样 BLOCKED(书写形态不改变判别力),带处置标记的 H3 条目 → 通过;④ H3 Major
2331
+ // [转待办] 无用户裁决 → BLOCKED,同段裁决 + [升级] 承接 → 通过(严重度按标题前缀派生)。
2332
+ {
2333
+ name: 'TA-16 REVIEW 发现位置:写在 ## 发现 而 2.2 空则拦,写在 2.2 通过',
2334
+ run: async (dir) => {
2335
+ // ① 发现写在模板外的段
2336
+ setupReview(dir, {
2337
+ body: [['2.2', '(夹具:本段无条目。)']],
2338
+ extra: ['## 发现\n\n- **F1 · 夹具发现**:写在模板外的发现条目 [已修]'],
2339
+ });
2340
+ const misplaced = exitNode(dir, 'review');
2341
+ assertExit(misplaced, 1);
2342
+ assertOut(misplaced, 'BLOCKED');
2343
+ assertOut(misplaced, '2.2');
2344
+ // ② 反向构造:按模板写在 2.2 → 通过
2345
+ setupReview(dir);
2346
+ const ok = exitNode(dir, 'review');
2347
+ assertExit(ok, 0);
2348
+ assertOut(ok, 'ALL CHECKS PASSED');
2349
+ // ③ H3 + 粗体字段形态(模板 2.2 的书写范例)缺处置标记 → BLOCKED
2350
+ const h3Finding = [
2351
+ '### 🔴 C-2 · 夹具 H3 形态的发现:按模板范例书写',
2352
+ '**Symptom**:某处存在一个可记录的衰退风险',
2353
+ '**Source**:夹具来源',
2354
+ '**Consequence**:若不修会怎样',
2355
+ '**Remedy**:怎么改',
2356
+ '**生成 fix 任务**:T-FIX-99',
2357
+ ].join('\n');
2358
+ setupReview(dir, { body: [['2.2', h3Finding]] });
2359
+ const h3Missing = exitNode(dir, 'review');
2360
+ assertExit(h3Missing, 1);
2361
+ assertOut(h3Missing, 'BLOCKED');
2362
+ assertOut(h3Missing, '发现区 1 项'); // H3 条目被计入发现(未识别时计数为 0)
2363
+ // ④ 同内容换回列表项形态 → 同样被拦(同一判据对两种写法同等判别)
2364
+ setupReview(dir, {
2365
+ body: [['2.2', '- **C-2 · 夹具 H3 形态的发现:按模板范例书写**:某处存在一个可记录的衰退风险']],
2366
+ });
2367
+ const listMissing = exitNode(dir, 'review');
2368
+ assertExit(listMissing, 1);
2369
+ assertOut(listMissing, 'BLOCKED');
2370
+ assertOut(listMissing, '发现区 1 项');
2371
+ // ⑤ 反向构造:H3 条目在标题行带处置标记 → 通过
2372
+ setupReview(dir, { body: [['2.2', h3Finding.replace('按模板范例书写', '按模板范例书写 [已修]')]] });
2373
+ const h3Done = exitNode(dir, 'review');
2374
+ assertExit(h3Done, 0);
2375
+ assertOut(h3Done, 'ALL CHECKS PASSED');
2376
+ // ⑥ H3 Major [转待办] 无用户裁决记录 → BLOCKED
2377
+ setupReview(dir, {
2378
+ body: [['2.2', ['### 🟡 M-2 · 夹具 H3 形态的延期 [转待办]',
2379
+ '**Symptom**:某处问题', '**Remedy**:下一 change 首修'].join('\n')]],
2380
+ });
2381
+ const h3Deferred = exitNode(dir, 'review');
2382
+ assertExit(h3Deferred, 1);
2383
+ assertOut(h3Deferred, 'BLOCKED');
2384
+ assertOut(h3Deferred, 'M-2'); // 严重度按 H3 标题前缀派生 → 计入 Major 延期门禁
2385
+ assertOut(h3Deferred, '用户裁决');
2386
+ // ⑦ 反向构造:同段用户裁决 + [升级] 承接 → 通过
2387
+ setupReview(dir, {
2388
+ body: [['2.2', ['### 🟡 M-2 · 夹具 H3 形态的延期 [升级] [转待办](用户裁决:接受延期,下一 change 首修)',
2389
+ '**Symptom**:某处问题'].join('\n')]],
2390
+ });
2391
+ const h3Adjudicated = exitNode(dir, 'review');
2392
+ assertExit(h3Adjudicated, 0);
2393
+ assertOut(h3Adjudicated, 'ALL CHECKS PASSED');
2394
+ // ⑧ 段体切片的围栏语义(发现区的段界由 lib/section-body.mjs 单点决定):条目正文里贴了 Markdown
2395
+ // 代码块时,围栏内的 `## ` 不是发现区的段界。修复前它是——发现区被重置成「非发现区」,围栏
2396
+ // 之后的发现条目整段消失,「每条发现必须有处置标记」那道门禁因此对它们形同虚设。
2397
+ const fencedFindings = [
2398
+ '### 🔴 C-3 · 夹具发现:条目正文里贴了一段 Markdown 示例',
2399
+ '**Symptom**:示例代码块里出现段标题',
2400
+ '',
2401
+ '```md',
2402
+ '## 代码块里的示例段标题',
2403
+ '```',
2404
+ '',
2405
+ '- **C-4 · 围栏之后的发现:缺处置标记**:修复前这条整段消失',
2406
+ ].join('\n');
2407
+ setupReview(dir, { body: [['2.2', fencedFindings]] });
2408
+ const fencedMissing = exitNode(dir, 'review');
2409
+ assertExit(fencedMissing, 1);
2410
+ assertOut(fencedMissing, '发现区 2 项'); // 两条都在发现区内(修复前只数到围栏之前那条)
2411
+ // ⑨ 围栏外的同级标题照常结束发现区:`## 结论` 之后的列表项不是 2.2 的发现
2412
+ setupReview(dir, { body: [['2.2', h3Finding + '\n\n## 结论\n\n- **C-9 · 段外条目:缺处置标记**']] });
2413
+ const outsideFindings = exitNode(dir, 'review');
2414
+ assertExit(outsideFindings, 1);
2415
+ assertOut(outsideFindings, '发现区 1 项'); // 段外那条不计入(计入则为 2 项)
2416
+ // ⑩ 分隔线语义保持:`---` 不结束发现区(2.2 段内的分隔线是正文,既有语义)
2417
+ setupReview(dir, { body: [['2.2', h3Finding + '\n\n---\n\n- **C-8 · 分隔线之后的发现:缺处置标记**']] });
2418
+ const afterRule = exitNode(dir, 'review');
2419
+ assertExit(afterRule, 1);
2420
+ assertOut(afterRule, '发现区 2 项'); // 分隔线之后的条目仍计入(计入才说明分隔线不结束发现区)
2421
+ },
2422
+ },
2423
+
2424
+ // ============================================================================================
2425
+ // LESSONS:旧形态迁移 / 开工扫描 / 归档提名
2426
+ // ============================================================================================
2427
+
2428
+ // TA-17 · LESSONS 旧形态在 open / verify / archive 三处出口被拦(AC-17)——报文逐行给出
2429
+ // 「文件:行号 → 应改成 ### L-NNN」;迁移后三处通过。
2430
+ {
2431
+ name: 'TA-17 LESSONS 旧形态(## L-NNN)在 open/verify/archive 三处出口拦并给逐行改法',
2432
+ run: async (dir) => {
2433
+ const legacyLessons = [
2434
+ '# LESSONS — 跨任务失败知识库(夹具)',
2435
+ '',
2436
+ '## 条目区(夹具)',
2437
+ '',
2438
+ '## L-501',
2439
+ '',
2440
+ '- **关键词**: guard, template',
2441
+ '',
2442
+ '夹具旧形态条目。',
2443
+ '',
2444
+ ].join('\n');
2445
+ // ① open 出口
2446
+ setupOpen(dir);
2447
+ writeFile(dir, '.specs/LESSONS.md', legacyLessons);
2448
+ const resOpen = exitNode(dir, 'open');
2449
+ assertExit(resOpen, 1);
2450
+ assertOut(resOpen, 'LESSONS.md');
2451
+ assertOut(resOpen, '### L-501');
2452
+ assertTrue(/LESSONS\.md:\d+/.test(resOpen.output), '报文应逐行给出「文件:行号」,实际: ' + resOpen.output);
2453
+ // ② verify 出口
2454
+ setupVerify(dir);
2455
+ writeFile(dir, '.specs/LESSONS.md', legacyLessons);
2456
+ const resVerify = exitNode(dir, 'verify');
2457
+ assertExit(resVerify, 1);
2458
+ assertOut(resVerify, '### L-501');
2459
+ // ③ archive 出口
2460
+ setupArchive(dir, { lessons: legacyLessons });
2461
+ const resArchive = exitNode(dir, 'archive');
2462
+ assertExit(resArchive, 1);
2463
+ assertOut(resArchive, '### L-501');
2464
+ // ④ 反向构造:迁移(改级 + 留在条目区)后三处通过——archive 一侧须同时给出齐全的归档提名
2465
+ // 证据(TA-19 起「缺 lessonsNomination 即拦」是独立判据,本条只验证旧形态迁移已消失)。
2466
+ setupOpen(dir);
2467
+ writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
2468
+ assertExit(exitNode(dir, 'open'), 0);
2469
+ setupVerify(dir);
2470
+ writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
2471
+ assertExit(exitNode(dir, 'verify'), 0);
2472
+ setupArchive(dir, {
2473
+ evidence: { lessonsNomination: { scanned: 2, nominated: ['L-501'], reasonIfNone: '' } },
2474
+ });
2475
+ const archiveOk = exitNode(dir, 'archive');
2476
+ assertExit(archiveOk, 0);
2477
+ // ⑤ C20 字段键:新 change 的模板形态新条目缺 5 键任一 → BLOCKED(字段键从 LESSONS 模板的
2478
+ // 「条目格式」书写样例派生,不在门禁里写第二份字面清单;模板夹具在场是判据可派生前提)。
2479
+ setupVerify(dir);
2480
+ writeTemplateFixture(dir, 'LESSONS');
2481
+ writeFile(dir, '.specs/LESSONS.md', [
2482
+ '# LESSONS — 跨任务失败知识库(夹具)',
2483
+ '',
2484
+ '## 条目区(夹具)',
2485
+ '',
2486
+ '### L-503 · [proc] 夹具新条目只有标题与关键词行',
2487
+ '',
2488
+ '- **关键词**: fixture field gate',
2489
+ '',
2490
+ '夹具条目正文:只有关键词行,缺其余字段键。',
2491
+ '',
2492
+ ].join('\n'));
2493
+ const missingFields = exitNode(dir, 'verify');
2494
+ assertExit(missingFields, 1);
2495
+ assertOut(missingFields, 'BLOCKED');
2496
+ assertOut(missingFields, 'L-503');
2497
+ assertOut(missingFields, '首发');
2498
+ // ⑤c runRoot 与 cwd 漂移:字段键从 runRoot 下的模板派生——guard 可能在与项目根不同的 cwd
2499
+ // 被调起(运行上下文由 FLOW_COMET_RUN_ROOT 给定)。按 cwd 解析会在模板在场时也判「模板缺失」,
2500
+ // C20 随之静默退化为未校验;反向断言同一份夹具不得出现该降级行。
2501
+ const cwdOffset = path.join(dir, 'cwd-offset');
2502
+ fs.mkdirSync(cwdOffset, { recursive: true });
2503
+ const drift = spawnSync(process.execPath, [path.join(SCRIPTS_DIR, 'workflow-guard.mjs'), 'exit', 'verify', '--apply'], {
2504
+ cwd: cwdOffset,
2505
+ env: { ...process.env, FLOW_COMET_RUN_ROOT: dir, FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) },
2506
+ encoding: 'utf8',
2507
+ timeout: 60000,
2508
+ });
2509
+ const driftRes = { status: drift.status ?? 1, output: String(drift.stdout ?? '') + String(drift.stderr ?? '') };
2510
+ assertExit(driftRes, 1);
2511
+ assertOut(driftRes, 'BLOCKED');
2512
+ assertOut(driftRes, 'L-503');
2513
+ assertNotOut(driftRes, 'LESSONS 条目字段 未校验(模板缺失)');
2514
+ // ⑤b 新条目只有标题与正文(无任何字段键)同样 BLOCKED——正面回应「新条目可绕过关键词扫描」的
2515
+ // 失效模式(修复前整类条目静默通过 = RED)。
2516
+ writeFile(dir, '.specs/LESSONS.md', [
2517
+ '# LESSONS — 跨任务失败知识库(夹具)',
2518
+ '',
2519
+ '## 条目区(夹具)',
2520
+ '',
2521
+ '### L-506 · [proc] 夹具只有标题与正文的新条目',
2522
+ '',
2523
+ '夹具条目正文:一个字段键都没有。',
2524
+ '',
2525
+ ].join('\n'));
2526
+ const noFieldKeys = exitNode(dir, 'verify');
2527
+ assertExit(noFieldKeys, 1);
2528
+ assertOut(noFieldKeys, 'BLOCKED');
2529
+ assertOut(noFieldKeys, 'L-506');
2530
+ // ⑥ 迁移形态旧条目(`### L-NNN:` 冒号标题,迁移保留原标题形态)缺字段 → 只 WARN,不阻断
2531
+ setupVerify(dir);
2532
+ writeTemplateFixture(dir, 'LESSONS');
2533
+ writeFile(dir, '.specs/LESSONS.md', [
2534
+ '# LESSONS — 跨任务失败知识库(夹具)',
2535
+ '',
2536
+ '## 条目区(夹具)',
2537
+ '',
2538
+ '### L-504: 夹具迁移形态条目',
2539
+ '',
2540
+ '夹具迁移条目正文:迁移保留原标题形态,无字段行。',
2541
+ '',
2542
+ ].join('\n'));
2543
+ const migratedOld = exitNode(dir, 'verify');
2544
+ assertExit(migratedOld, 0);
2545
+ assertOut(migratedOld, 'L-504');
2546
+ assertOut(migratedOld, 'WARN');
2547
+ // ⑦ 反向构造:新条目补全 5 键 → 通过
2548
+ writeFile(dir, '.specs/LESSONS.md', [
2549
+ '# LESSONS — 跨任务失败知识库(夹具)',
2550
+ '',
2551
+ '## 条目区(夹具)',
2552
+ '',
2553
+ '### L-505 · [proc] 夹具完整条目',
2554
+ '',
2555
+ '- **首发**: ' + CHANGE_ID + ' · T01 · 2026-10-20',
2556
+ '- **上次复核**: 2026-10-20',
2557
+ '- **适用栈**: Node 18+ / 夹具',
2558
+ '- **状态**: active',
2559
+ '- **关键词**: fixture complete entry',
2560
+ '',
2561
+ '夹具条目正文。',
2562
+ '',
2563
+ ].join('\n'));
2564
+ const fieldsOk = exitNode(dir, 'verify');
2565
+ assertExit(fieldsOk, 0);
2566
+ assertOut(fieldsOk, 'ALL CHECKS PASSED');
2567
+ },
2568
+ },
2569
+
2570
+ // TA-18 · 开工前 LESSONS 扫描可核对(AC-18)——① SUMMARY 缺 `## LESSONS 扫描` → BLOCKED;
2571
+ // ② 引擎按任务 write_files 命中某条关键词、而 SUMMARY 未逐条回应该编号 → BLOCKED;补齐后通过。
2572
+ {
2573
+ name: 'TA-18 LESSONS 扫描:缺声明段拦;命中条目未回应拦;补齐并逐条回应后通过',
2574
+ run: async (dir) => {
2575
+ // ① 缺 ## LESSONS 扫描 段(登记为 SUMMARY 的必填增量段)
2576
+ setupExecute(dir, { omit: ['LESSONS 扫描'] });
2577
+ writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
2578
+ const missingSection = exitNode(dir, 'execute');
2579
+ assertExit(missingSection, 1);
2580
+ assertOut(missingSection, 'LESSONS 扫描');
2581
+ // ② 声明段在场但命中条目未回应
2582
+ setupExecute(dir);
2583
+ writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
2584
+ writeFile(dir, CHANGE_DIR + '/TASK.md', '# TASK\n\n## 任务清单\n\n'
2585
+ + '<task id="T01" status="done"><action>改模板保真门禁</action>'
2586
+ + '<write_files>scripts/lib/guard-template-fidelity.mjs</write_files>'
2587
+ + '<verify>node --check baseline.js</verify></task>\n');
2588
+ const unanswered = exitNode(dir, 'execute');
2589
+ assertExit(unanswered, 1);
2590
+ assertOut(unanswered, 'L-501');
2591
+ // ③ 反向构造:逐条回应命中编号 → 通过
2592
+ setupExecute(dir, { body: [['LESSONS 扫描', '- L-501:已读并声明差异(夹具回应)。']] });
2593
+ writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
2594
+ writeFile(dir, CHANGE_DIR + '/TASK.md', '# TASK\n\n## 任务清单\n\n'
2595
+ + '<task id="T01" status="done"><action>改模板保真门禁</action>'
2596
+ + '<write_files>scripts/lib/guard-template-fidelity.mjs</write_files>'
2597
+ + '<verify>node --check baseline.js</verify></task>\n');
2598
+ const answered = exitNode(dir, 'execute');
2599
+ assertExit(answered, 0);
2600
+ assertOut(answered, 'ALL CHECKS PASSED');
2601
+
2602
+ // 段体切片的围栏语义(LESSONS 扫描段的段界由 lib/section-body.mjs 单点决定):回应写在围栏代码块
2603
+ // 之后仍算数(围栏内的 `## ` 不结束段体);围栏外的分隔线照常结束段体。
2604
+ const lessonsScanTask = () => writeFile(dir, CHANGE_DIR + '/TASK.md', '# TASK\n\n## 任务清单\n\n'
2605
+ + '<task id="T01" status="done"><action>改模板保真门禁</action>'
2606
+ + '<write_files>scripts/lib/guard-template-fidelity.mjs</write_files>'
2607
+ + '<verify>node --check baseline.js</verify></task>\n');
2608
+ // ④ 围栏(反引号)内含二级标题 → 段体不被截断,围栏之后的回应仍被读到
2609
+ setupExecute(dir, { body: [['LESSONS 扫描',
2610
+ '```md\n## 代码块里的示例段标题\n```\n\n- L-501:已读并声明差异(围栏之后的回应)。']] });
2611
+ writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
2612
+ lessonsScanTask();
2613
+ const fencedScan = exitNode(dir, 'execute');
2614
+ assertExit(fencedScan, 0);
2615
+ assertOut(fencedScan, 'ALL CHECKS PASSED');
2616
+ // ⑤ 围栏(波浪号)同理:两种围栏记号同口径
2617
+ setupExecute(dir, { body: [['LESSONS 扫描',
2618
+ '~~~md\n## 代码块里的示例段标题\n~~~\n\n- L-501:已读并声明差异(波浪号围栏之后的回应)。']] });
2619
+ writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
2620
+ lessonsScanTask();
2621
+ const tildeScan = exitNode(dir, 'execute');
2622
+ assertExit(tildeScan, 0);
2623
+ assertOut(tildeScan, 'ALL CHECKS PASSED');
2624
+ // ⑥ 反向构造:围栏外的分隔线结束段体 —— 回应落在分隔线之后 ⇒ 等于没回应 ⇒ BLOCKED
2625
+ setupExecute(dir, { body: [['LESSONS 扫描',
2626
+ '夹具说明(本段到这里结束)。\n\n---\n\n- L-501:已读并声明差异(分隔线之后的回应)。']] });
2627
+ writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
2628
+ lessonsScanTask();
2629
+ const ruleClosedScan = exitNode(dir, 'execute');
2630
+ assertExit(ruleClosedScan, 1);
2631
+ assertOut(ruleClosedScan, 'L-501');
2632
+ },
2633
+ },
2634
+
2635
+ // TA-19 · 归档提名留痕并核对(AC-19)——缺 lessonsNomination / 提名编号不存在 / 扫描份数不符
2636
+ // 三者均 BLOCKED;补齐并核对一致后通过(三负一正)。
2637
+ {
2638
+ name: 'TA-19 归档提名:缺字段/编号不存在/份数不符三负例拦,补齐后通过',
2639
+ run: async (dir) => {
2640
+ // ① 缺 lessonsNomination 字段
2641
+ setupArchive(dir);
2642
+ const missingField = exitNode(dir, 'archive');
2643
+ assertExit(missingField, 1);
2644
+ assertOut(missingField, 'BLOCKED');
2645
+ assertOut(missingField, 'lessonsNomination');
2646
+ // ② 提名编号在 LESSONS 中不存在
2647
+ setupArchive(dir, {
2648
+ evidence: { lessonsNomination: { scanned: 2, nominated: ['L-999'], reasonIfNone: '' } },
2649
+ });
2650
+ const unknownId = exitNode(dir, 'archive');
2651
+ assertExit(unknownId, 1);
2652
+ assertOut(unknownId, 'L-999');
2653
+ // ③ 扫描份数 ≠ 该 change 内 *-SUMMARY.md 数量(夹具 2 份,声明 3)
2654
+ setupArchive(dir, {
2655
+ evidence: { lessonsNomination: { scanned: 3, nominated: ['L-501'], reasonIfNone: '' } },
2656
+ });
2657
+ const countMismatch = exitNode(dir, 'archive');
2658
+ assertExit(countMismatch, 1);
2659
+ // ④ 反向构造:三项一致 → 通过
2660
+ setupArchive(dir, {
2661
+ evidence: { lessonsNomination: { scanned: 2, nominated: ['L-501'], reasonIfNone: '' } },
2662
+ });
2663
+ const ok = exitNode(dir, 'archive');
2664
+ assertExit(ok, 0);
2665
+ assertOut(ok, 'ALL CHECKS PASSED');
2666
+ // ④b 份数只数本 change 的归档目录(in-place 扩展):归档移动已发生(活动目录不在原位)时,
2667
+ // 同后缀诱饵——名字以 -<本 change> 结尾的别的 change 归档目录——既有份数不得被数进来,也不得
2668
+ // 在本 change 归档目录缺席时充当「有目录可数」。归档目录按 <日期>-<本 change> 精确形态定位。
2669
+ setupArchive(dir, {
2670
+ evidence: { lessonsNomination: { scanned: 2, nominated: ['L-501'], reasonIfNone: '' } },
2671
+ });
2672
+ const archiveRoot = path.join(dir, '.specs', 'archive');
2673
+ // 归档移动:活动目录整体搬成 .specs/archive/2026-10-21-<本 change>/(2 份 SUMMARY 随目录走),
2674
+ // 归档产物 KNOWN-ISSUES.md 也归位到这一份目录,诱饵目录只放 3 份别人的 SUMMARY。
2675
+ fs.renameSync(path.join(dir, CHANGE_DIR), path.join(archiveRoot, '2026-10-21-' + CHANGE_ID));
2676
+ fs.renameSync(path.join(archiveRoot, '2026-10-20-' + CHANGE_ID, 'KNOWN-ISSUES.md'),
2677
+ path.join(archiveRoot, '2026-10-21-' + CHANGE_ID, 'KNOWN-ISSUES.md'));
2678
+ fs.rmSync(path.join(archiveRoot, '2026-10-20-' + CHANGE_ID), { recursive: true, force: true });
2679
+ for (let i = 1; i <= 3; i += 1) {
2680
+ writeFile(dir, '.specs/archive/2026-10-20-other-' + CHANGE_ID + '/T0' + i + '-SUMMARY.md',
2681
+ '# SUMMARY\n\n## 做了什么\n\n诱饵归档的份数。\n');
2682
+ }
2683
+ const ownArchiveCount = runGuard(['exit', 'archive'], dir);
2684
+ assertExit(ownArchiveCount, 0);
2685
+ assertOut(ownArchiveCount, 'ALL CHECKS PASSED');
2686
+ // 反向构造(同一判据 + 单变量):本 change 的归档目录缺席、同后缀诱饵仍在场——份数不可核对
2687
+ // (null),不得退回数诱饵的 3 份。修复前 .find 命中诱饵,3 份与声明一致就整体放行:份数对账
2688
+ // 拿别人的归档作证。这里声明正好写 3,放行即证明数的是诱饵。
2689
+ fs.renameSync(path.join(archiveRoot, '2026-10-21-' + CHANGE_ID, 'KNOWN-ISSUES.md'),
2690
+ path.join(archiveRoot, '2026-10-20-other-' + CHANGE_ID, 'KNOWN-ISSUES.md'));
2691
+ fs.rmSync(path.join(archiveRoot, '2026-10-21-' + CHANGE_ID), { recursive: true, force: true });
2692
+ const decoyOnlyState = newChangeState('archive');
2693
+ decoyOnlyState.evidence.archive = {
2694
+ summary: 'archived',
2695
+ lessonsNomination: { scanned: 3, nominated: [], reasonIfNone: '无新增条目' },
2696
+ };
2697
+ writeState(dir, decoyOnlyState);
2698
+ const decoyOnly = runGuard(['exit', 'archive'], dir);
2699
+ assertExit(decoyOnly, 1);
2700
+ assertOut(decoyOnly, '工件目录缺失');
2701
+ assertNotOut(decoyOnly, 'ALL CHECKS PASSED');
2702
+ // ⑤ 扫描份数的**类型**在写入前就拦(in-place 扩展):scanned 是出口按**数值**比对的字段
2703
+ // (份数相等才算留痕成立),故字符串 "2" 必须被 record 拒。修复前它能落库成功、要等到 archive
2704
+ // 出口才因 "2" !== 2 炸——正是 record 形状校验要消灭的「错误延后暴露」(出错的是 record,
2705
+ // 报错的却是 exit)。判据仍只判类型:取值是否等于 SUMMARY 份数归出口(③),不在这里重复业务规则。
2706
+ writeFile(dir, '.specs/LESSONS.md', LESSONS_FIXTURE);
2707
+ const recordState = baseState('archive');
2708
+ recordState.evidence.archive = { summary: 'archived' };
2709
+ writeState(dir, recordState);
2710
+ const stringScanned = runState(['record', 'archive',
2711
+ '{"summary":"archived","lessonsNomination":{"scanned":"2","nominated":[],"reasonIfNone":"无新增条目"}}'], dir);
2712
+ assertExit(stringScanned, 1);
2713
+ assertOut(stringScanned, 'lessonsNomination.scanned');
2714
+ assertOut(stringScanned, '必须是数字(当前是 string)');
2715
+ const afterReject = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
2716
+ assertTrue(afterReject.evidence.archive.lessonsNomination === undefined,
2717
+ '类型非法的载荷不得落库: ' + JSON.stringify(afterReject.evidence.archive));
2718
+ // 反向构造(单变量:只把 "2" 改成 2):同一载荷 record 通过并原样写入——判据只判类型,
2719
+ // 不新增业务规则,合法载荷不因这条形状校验变得不可写。
2720
+ const numericScanned = runState(['record', 'archive',
2721
+ '{"summary":"archived","lessonsNomination":{"scanned":2,"nominated":[],"reasonIfNone":"无新增条目"}}'], dir);
2722
+ assertExit(numericScanned, 0);
2723
+ const afterAccept = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
2724
+ assertTrue(afterAccept.evidence.archive.lessonsNomination?.scanned === 2,
2725
+ '类型合法的载荷应原样写入 scanned: ' + JSON.stringify(afterAccept.evidence.archive));
2726
+ },
2727
+ },
2728
+
2729
+ // ============================================================================================
2730
+ // 项目级工件 / 降级面 / 治理
2731
+ // ============================================================================================
2732
+
2733
+ // TA-20 · 项目级工件的触发点(AC-20)——① CONTEXT 存在但缺模板段 → open 出口拦;
2734
+ // ② UI-DESIGN 存在但缺 frontmatter 键 → 前端 change 的 design 出口拦;
2735
+ // ③ `.specs/ARCHITECTURE.md` 缺段 → 侧命令报告列出结构问题但**不阻断**(只读);
2736
+ // ④ CONTEXT 的「evolve 元数据」段体:段内围栏示例不截断段体,围栏里的样例字段也不算数据。
2737
+ {
2738
+ name: 'TA-20 项目级工件:CONTEXT 缺段拦、UI-DESIGN 缺 frontmatter 键拦、ARCHITECTURE 只读报告;CONTEXT 元数据段内围栏示例不截断、样例字段不算数据',
2739
+ run: async (dir) => {
2740
+ // ① CONTEXT 缺段(文件存在才查)——段清单基准来自 CONTEXT 模板,故夹具根必须带模板:
2741
+ // 模板缺席时判据按 C9 整体跳过并显式「未校验(模板缺失)」,该形态由 TA-21 覆盖。
2742
+ setupOpen(dir);
2743
+ writeTemplateFixture(dir, 'CONTEXT');
2744
+ writeFile(dir, '.specs/CONTEXT.md', '# CONTEXT — 项目共享上下文\n\n## 项目概要\n\n夹具。\n');
2745
+ const resContext = exitNode(dir, 'open');
2746
+ assertExit(resContext, 1);
2747
+ assertOut(resContext, 'CONTEXT');
2748
+ // ② UI-DESIGN 缺 frontmatter 键(motion)
2749
+ setupDesign(dir, {
2750
+ changeOpts: { body: [['视觉调性', '- **选定**:6 有机 / Organic\n- **理由**:前端夹具']] },
2751
+ uiDesign: uiDesignDoc({}, ['motion']),
2752
+ declareUiDesign: true,
2753
+ });
2754
+ writeFrontendDesignMarkers(dir);
2755
+ const resUiKey = exitNode(dir, 'design');
2756
+ assertExit(resUiKey, 1);
2757
+ assertOut(resUiKey, 'motion');
2758
+ // ③ ARCHITECTURE 缺段 → 侧命令只读报告(不阻断)。模板夹具必须在场:骨架不可派生时报告走
2759
+ // 「未校验(模板缺失)」分支,此时只断言「结构问题」在降级面上空转——真实比对分支才是被测面。
2760
+ // 夹具自带 §3 的占位 ADR 条目(TEMPLATE_BODY_FIXTURES)——没有 vendored 模板的检出按登记表
2761
+ // 合成的模板因此与真迹同构,§3 字段键派生同样真跑(不会退化成「结构问题依据」里的未校验)。
2762
+ writeTemplateFixture(dir, 'ARCHITECTURE');
2763
+ writeFile(dir, '.specs/ARCHITECTURE.md', '# ARCHITECTURE — 项目级系统架构(活文档)\n\n## 1. 系统概览\n\n夹具。\n');
2764
+ const side = runSideCommand(dir, 'evolve.mjs', ['scan', '--root', dir, '--stdout']);
2765
+ assertExit(side, 0);
2766
+ assertOut(side, '结构问题');
2767
+ assertOut(side, 'ARCHITECTURE');
2768
+ assertOut(side, '缺 H2 段 7/8'); // 8 个 H2 段只写了 1 个
2769
+ assertOut(side, '2. 模块清单'); // 逐条列出缺哪个段名,不是只报数量
2770
+ assertNotOut(side, '未校验'); // 走的是真实比对分支,不是模板缺席降级
2771
+ assertNotOut(side, 'BLOCKED'); // 只读报告:结构问题不进退出码、不阻断
2772
+ // 反向构造(判别力):按模板补齐 8 个 H2 段 → 同一判据报 0 项(证明「缺段」不是常量输出)
2773
+ writeFile(dir, '.specs/ARCHITECTURE.md', renderDoc('ARCHITECTURE'));
2774
+ const sideOk = runSideCommand(dir, 'evolve.mjs', ['scan', '--root', dir, '--stdout']);
2775
+ assertExit(sideOk, 0);
2776
+ assertOut(sideOk, '结构问题(.specs/ARCHITECTURE.md):0 项');
2777
+ // ④ CONTEXT 的「evolve 元数据」段体:段界由 lib/section-body.mjs 单点决定(本任务把
2778
+ // context-init 的同名私有实现收进单源)。两条腿——
2779
+ // ① 段里贴了含 `## ` 的围栏示例、三字段写在示例**之后** ⇒ 段体不被示例里的标题截断,
2780
+ // 校验通过(INIT-DONE);
2781
+ // ② 三字段只写在围栏**内** ⇒ 仍判缺字段(围栏里的书写样例不是数据——段体切片之前结构文本
2782
+ // 已剥离围栏,这条钉住了「别为了省事直接拿原文切片」这个错法)。
2783
+ const ctxRoot = path.join(dir, 'ctx-init');
2784
+ fs.mkdirSync(path.join(ctxRoot, 'reference'), { recursive: true });
2785
+ fs.copyFileSync(scenarioProtocolPath(dir), scenarioProtocolPath(ctxRoot));
2786
+ const contextDoc = (fieldsInFence) => [
2787
+ '# CONTEXT',
2788
+ '## 项目概要', 'x',
2789
+ '## 技术栈', 'x',
2790
+ '## 域语言', '| 术语 | 定义 |', '|---|---|', '| 例 | 定义 |',
2791
+ '## 已锁决策', '- [2026-08-01] 决策一',
2792
+ '## 默认偏好', 'x',
2793
+ '## 既有抽象索引', 'x',
2794
+ '## evolve 元数据', '',
2795
+ '```md',
2796
+ '## 示例段(围栏内,不是段界)',
2797
+ ...(fieldsInFence
2798
+ ? ['- **last_evolve_at**: 2026-09-01T10:00:00+08:00', '- **scanner**: fixture', '- **下次建议**: 无']
2799
+ : []),
2800
+ '```',
2801
+ ...(fieldsInFence
2802
+ ? []
2803
+ : ['', '- **last_evolve_at**: 2026-09-01T10:00:00+08:00', '- **scanner**: fixture', '- **下次建议**: 无']),
2804
+ '## intel-scan 元数据',
2805
+ '- **last_intel_scan**: x', '- **scanner**: x', '- **下次重扫建议**: x',
2806
+ '',
2807
+ ].join('\n');
2808
+ writeFile(ctxRoot, '.specs/CONTEXT.md', contextDoc(false));
2809
+ const ctxFenced = runState(['init', CHANGE_ID + '-ctx', '--init-context'], ctxRoot);
2810
+ assertExit(ctxFenced, 0);
2811
+ assertOut(ctxFenced, 'INIT-DONE');
2812
+ assertNotOut(ctxFenced, 'INIT-VALIDATE-FAILED');
2813
+ writeFile(ctxRoot, '.specs/CONTEXT.md', contextDoc(true));
2814
+ const ctxFencedOnly = runState(['init', CHANGE_ID + '-ctx2', '--init-context'], ctxRoot);
2815
+ assertExit(ctxFencedOnly, 0);
2816
+ assertOut(ctxFencedOnly, 'INIT-VALIDATE-FAILED');
2817
+ assertOut(ctxFencedOnly, 'evolve 元数据');
2818
+ },
2819
+ },
2820
+
2821
+ // TA-21 · 模板缺席时降级并显式声明(AC-21)——夹具根没有 flow-kit/templates/ → 不阻断,输出显式
2822
+ // 「未校验(模板缺失)」。反向构造:模板在场时同一工件必被拦(证明不是判据空转)。
2823
+ // ③④ 追加「段名清单单一来源」:模板缺席时仍要生效的四份段名清单(SUMMARY 段序兜底 / open·design 段名回退 /
2824
+ // LESSONS 扫描段名 / SUMMARY 必填三段)只许骨架模块登记一份——静态单源锁 + 行为侧反向构造。
2825
+ // ⑤ 追加「段体切片单源锁」的静态面:受检面 = 引擎实现面(不再只是取用面),形态面含行扫描与正则
2826
+ // 切片两种;仍存在的同类实现逐条登记(文件 + 符号 + 理由),并配回退探针证明锁看得见它们。
2827
+ // 写法面追加字符串字面量切分、位置面追加对象字面量内联箭头(各有合成切片探针):字面量切分写在
2828
+ // 属性箭头里正是静态锁此前的盲区——引擎里因此留着第二份段体切片而判据全绿。
2829
+ // ⑦ 追加「配对键单源」:第三族的任务对键只在 task-graph 表达一次,[P] 判据的补集消费它返回的判定;
2830
+ // 反向构造三层(换名字 / 换分隔符的第二份键 + 形态漂移的行为变异体)证明补集断言真的敏感。
2831
+ {
2832
+ name: 'TA-21 模板缺席降级:不阻断且显式输出「未校验(模板缺失)」;模板在场时同夹具被拦;段名清单 / 段体切片 / 任务对键 / 写面元素 / 运行根的单源锁(受检面 = 引擎实现面)+ 运行根隔离(真跑 CLI)',
2833
+ run: async (dir) => {
2834
+ // ① 模板缺席:只写工件,不写 flow-kit/templates/
2835
+ writeFile(dir, CHANGE_DIR + '/CHANGE.md', renderDoc('CHANGE', { omit: ['影响面'] }));
2836
+ writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md', renderDoc('REQUIREMENT'));
2837
+ const st = newChangeState('open');
2838
+ st.evidence.open = { summary: 'intake complete' };
2839
+ writeState(dir, st);
2840
+ writeNodeDeclarationMarkers(dir, 'open');
2841
+ const degraded = exitNode(dir, 'open');
2842
+ assertExit(degraded, 0);
2843
+ assertOut(degraded, '未校验');
2844
+ assertOut(degraded, '模板缺失');
2845
+ assertNotOut(degraded, 'BLOCKED');
2846
+ // ② 反向构造:模板在场 → 同一工件被拦(缺段判据确实在跑)
2847
+ setupOpen(dir, { omit: ['影响面'] });
2848
+ const blocked = exitNode(dir, 'open');
2849
+ assertExit(blocked, 1);
2850
+ assertOut(blocked, 'BLOCKED');
2851
+
2852
+ // ③ 段名清单单一来源静态锁:四份清单的定义面必须落在**骨架模块**(由骨架实现符号
2853
+ // `buildSkeleton` 反查,不写文件名),消费面由文本里的真实引用派生(模块搬迁 / 新增消费方
2854
+ // 不必改锚)。消费方只取用:自带第二份定义、或改从别处取用,都由同一判据判定违规。
2855
+ const skeletonModule = engineDefinitionModule('buildSkeleton');
2856
+ assertTrue(skeletonModule !== null,
2857
+ '骨架实现的定义面应恰一处(反查失败): ' + JSON.stringify(engineDefinitionHits('buildSkeleton')));
2858
+ const texts = engineScriptTexts();
2859
+ const segmentSymbols = [
2860
+ 'LEGACY_SUMMARY_ORDER',
2861
+ 'TEMPLATE_FALLBACK_SECTION_PATTERNS',
2862
+ 'LESSONS_SCAN_SECTION',
2863
+ 'SUMMARY_REQUIRED_SECTIONS',
2864
+ 'WAVE_SECTION_NAME',
2865
+ ];
2866
+ const issues = [];
2867
+ // ③0 夹具能力自检(反向构造的前提,先于被测面):摘 import 要覆盖三种位置——名前 / 名后 / 唯一项。
2868
+ // 夹具此前只处理「逗号相邻」:单名单行 import 摘不动,反向构造于是报「前提失效(变异未改变
2869
+ // 文件)」而不是真回归(锁在说谎,L-151)。三份合成 import 逐份验「名字真的没了、语句还在」。
2870
+ const dropProbeSymbol = segmentSymbols[0];
2871
+ for (const dropForm of [
2872
+ 'import { ' + dropProbeSymbol + ', otherName } from "./x.mjs";',
2873
+ 'import { otherName, ' + dropProbeSymbol + ' } from "./x.mjs";',
2874
+ 'import { ' + dropProbeSymbol + ' } from "./x.mjs";',
2875
+ ]) {
2876
+ const dropped = dropNamedImport(dropForm, dropProbeSymbol);
2877
+ assertTrue(!new RegExp('\\b' + dropProbeSymbol + '\\b').test(dropped)
2878
+ && /^import\s*\{[^}]*\}\s*from\s*"\.\/x\.mjs";$/u.test(dropped.trim()),
2879
+ '夹具摘 import 漏了一种位置(原样 ' + JSON.stringify(dropForm) + ' → 摘后 ' + JSON.stringify(dropped)
2880
+ + '):反向构造会退化成前提失效,锁的判别力无从证明');
2881
+ }
2882
+ // ③0b 共享段标题谓词(「这一行是不是登记的某段」的唯一判定 = normalizeHeading 相等 + 级别):
2883
+ // 定义面恰一处,波次门与 AC 门都具名取用。反向构造走**唯一项** import——夹具摘不动时这一格
2884
+ // 会一直绿,正是上一轮那条接缝(引擎迁就夹具)的闭合断言:原样零问题、摘掉 import 必报「未从」。
2885
+ const sharedPredicate = engineDefinitionModule('headingPredicate');
2886
+ assertTrue(sharedPredicate !== null,
2887
+ '共享段标题谓词的定义面应恰一处(波次门与 AC 门同一口径): '
2888
+ + JSON.stringify(engineDefinitionHits('headingPredicate')));
2889
+ const sharedPredicateProblems = singleSourceImportProblems({
2890
+ symbol: 'headingPredicate', sourceRel: sharedPredicate.file, texts,
2891
+ });
2892
+ assertTrue(sharedPredicateProblems.length === 0,
2893
+ '段标题谓词单源违规(两道门必须从同一处取用): ' + sharedPredicateProblems.join(' | '));
2894
+ const soleItemText = 'import { headingPredicate } from "./guard-artifact-skeleton.mjs";\n'
2895
+ + 'export const probeHeadingJudged = headingPredicate;\n';
2896
+ const soleItemDropped = dropNamedImport(soleItemText, 'headingPredicate');
2897
+ assertTrue(soleItemDropped !== soleItemText,
2898
+ '夹具摘不动唯一项 import(单名、单行):反向构造会退化成前提失效,锁的判别力无从证明');
2899
+ const soleItemProblems = (consumerText) => singleSourceImportProblems({
2900
+ symbol: 'headingPredicate',
2901
+ sourceRel: sharedPredicate.file,
2902
+ texts: new Map([[sharedPredicate.file, sharedPredicate.text], ['lib/probe-consumer.mjs', consumerText]]),
2903
+ });
2904
+ assertTrue(soleItemProblems(soleItemText).length === 0,
2905
+ '唯一项 import 的原样文本被判违规(探针前提不成立): ' + JSON.stringify(soleItemProblems(soleItemText)));
2906
+ assertTrue(soleItemProblems(soleItemDropped).some((problem) => problem.includes('未从')),
2907
+ '唯一项 import 摘除后取用面判据未发声(夹具摘不动时反向构造形同虚设): '
2908
+ + JSON.stringify(soleItemProblems(soleItemDropped)));
2909
+ for (const symbol of segmentSymbols) {
2910
+ const lookup = engineDefinitionModule(symbol);
2911
+ if (lookup === null) {
2912
+ issues.push(symbol + ' 的定义面不唯一(应恰一处): ' + JSON.stringify(engineDefinitionHits(symbol)));
2913
+ continue;
2914
+ }
2915
+ if (lookup.file !== skeletonModule.file) {
2916
+ issues.push(symbol + ' 的清单落在 ' + lookup.file + '(唯一来源应是骨架模块 ' + skeletonModule.file + ')');
2917
+ }
2918
+ for (const problem of singleSourceImportProblems({ symbol, sourceRel: lookup.file, texts })) {
2919
+ issues.push(problem);
2920
+ }
2921
+ }
2922
+ assertTrue(issues.length === 0, '段名清单单源违规: ' + issues.join(' | '));
2923
+
2924
+ // ③a 登记名与模板实际段名一致(模板在场时对账):段名登记成常量之后,模板若把该段改名,登记值
2925
+ // 就成了新的静默源——判据仍按一个不存在的段名读,换个标题写法即「未校验」放行。对账用共享归一
2926
+ // 做比较(编号前缀 / 尾部括号 / 闭合 ATX 不算差异),并配反向构造(改一个字不得被判成一致)。
2927
+ // 模板缺席(本检出无 vendored flow-kit)时退到登记表的段名清单,并显式声明降级来源:模板侧
2928
+ // 一致性由发版期指纹作业保证,SKIP = 未校验,不是通过。
2929
+ const waveSectionNorm = normalizeHeading(WAVE_SECTION_NAME);
2930
+ const waveNameMatches = (names) => names.some((name) => normalizeHeading(name) === waveSectionNorm);
2931
+ const registryTaskNames = (docEntry('TASK').sections ?? []).map((section) => section.name);
2932
+ assertTrue(waveNameMatches(registryTaskNames),
2933
+ '波次段名登记值与登记表的 TASK 段名不一致(登记值 ' + JSON.stringify(WAVE_SECTION_NAME)
2934
+ + ' 不在 ' + JSON.stringify(registryTaskNames) + ')——段名只有一处登记,改一处即可');
2935
+ assertTrue(!waveNameMatches(registryTaskNames.map((name) => name.replace('波次划分', '波次分配'))),
2936
+ '段名对账判据不具判别力:改一个字的段名与登记值被判成一致(比较退化成恒真)');
2937
+ const vendoredTaskTemplate = path.join(REPO_ROOT, 'flow-kit', 'templates', 'TASK.md');
2938
+ if (fs.existsSync(vendoredTaskTemplate)) {
2939
+ const templateHeadings = fs.readFileSync(vendoredTaskTemplate, 'utf8').split(/\r?\n/u)
2940
+ .filter((line) => /^##\s+/u.test(line))
2941
+ .map((line) => line.replace(/^##\s+/u, '').trim());
2942
+ assertTrue(waveNameMatches(templateHeadings),
2943
+ '波次段名登记值与 TASK 模板的实际段名不一致(模板段名 ' + JSON.stringify(templateHeadings)
2944
+ + ' 不含登记值 ' + JSON.stringify(WAVE_SECTION_NAME) + ')——模板改名时须同批更新登记值');
2945
+ } else {
2946
+ console.log('SKIP: 波次段名与 TASK 模板对账(本检出无 vendored flow-kit 模板)'
2947
+ + '——已退到登记表段名对账;模板侧一致性由发版期指纹作业保证(SKIP = 未校验,不是通过)');
2948
+ }
2949
+
2950
+ // ③b 反向构造(同一判据驱动 · 逐项改坏输入 ⇒ 必报,还原 ⇒ 复绿):四份清单逐份证明判别力,
2951
+ // 不是「只有某一份碰巧被测到」。
2952
+ {
2953
+ const sourceRel = skeletonModule.file;
2954
+ const sourceText = texts.get(sourceRel);
2955
+ for (const symbol of segmentSymbols) {
2956
+ const consumer = [...texts.keys()].find((rel) => rel !== sourceRel
2957
+ && new RegExp('import\\s*\\{[^}]*\\b' + symbol + '\\b').test(texts.get(rel)));
2958
+ if (consumer === undefined) {
2959
+ issues.push('反向构造前提不成立:找不到 ' + symbol + ' 的具名取用消费方');
2960
+ continue;
2961
+ }
2962
+ const consumerText = texts.get(consumer);
2963
+ // 探针对象带 changed(变异落在哪个文件),前提检查按它判定——不拿展示用 label 当控制流。
2964
+ const probes = [
2965
+ ['消费方自带第二份定义',
2966
+ new Map(texts).set(consumer, consumerText + '\nconst ' + symbol + ' = [];\n'), '自带第二份', consumer],
2967
+ ['源侧定义被抽掉(单源面被破坏)',
2968
+ new Map(texts).set(sourceRel,
2969
+ sourceText.replace('export const ' + symbol + ' =', 'const renamedSegmentOrderProbe =')),
2970
+ '单一来源被破坏', sourceRel],
2971
+ ['消费方不再取用(import 被抽掉)',
2972
+ new Map(texts).set(consumer, dropNamedImport(consumerText, symbol)), '未从', consumer],
2973
+ ];
2974
+ for (const [label, mutated, expected, changed] of probes) {
2975
+ if (mutated.get(changed) === texts.get(changed)) {
2976
+ issues.push(symbol + ' 反向构造前提失效(' + label + '):变异未改变 ' + changed);
2977
+ continue;
2978
+ }
2979
+ const reported = singleSourceImportProblems({ symbol, sourceRel, texts: mutated });
2980
+ if (!reported.some((problem) => problem.includes(expected))) {
2981
+ issues.push(symbol + ' 反向构造判别力缺失(' + label + ' 未被判违规)');
2982
+ }
2983
+ }
2984
+ if (singleSourceImportProblems({ symbol, sourceRel, texts }).length !== 0) {
2985
+ issues.push(symbol + ' 反向构造还原后未复绿(判据受输入顺序影响)');
2986
+ }
2987
+ }
2988
+ assertTrue(issues.length === 0, '段名清单单源锁反向构造失败: ' + issues.join(' | '));
2989
+ }
2990
+
2991
+ // ④ 行为侧反向构造:模板缺席时 SUMMARY 的段序判据确实吃清单——负例(段序偏离)被拦、
2992
+ // 正例(按模板段序)通过;清单若与真实段序脱节,两格至少一格红(清单不是摆设)。
2993
+ const executeState = () => {
2994
+ const next = newChangeState('execute');
2995
+ next.evidence.execute = { summary: 'executed' };
2996
+ next.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
2997
+ return next;
2998
+ };
2999
+ resetFixture(dir);
3000
+ writeBaseline(dir);
3001
+ writeFile(dir, CHANGE_DIR + '/TASK.md', '# TASK\n\n## 任务清单\n\n' + TASK_DONE);
3002
+ // 负例:把「做了什么」挪到「越界检查」之后 → 偏离兜底段序 → BLOCKED(模板缺席也判)
3003
+ writeFile(dir, CHANGE_DIR + '/T01-SUMMARY.md', renderDoc('SUMMARY', { swap: [['做了什么', '越界检查']] }));
3004
+ writeState(dir, executeState());
3005
+ writeNodeDeclarationMarkers(dir, 'execute');
3006
+ const outOfOrder = exitNode(dir, 'execute');
3007
+ assertExit(outOfOrder, 1);
3008
+ assertOut(outOfOrder, '未校验');
3009
+ assertOut(outOfOrder, '段序');
3010
+ // 正例:段序按清单 → 通过
3011
+ writeFile(dir, CHANGE_DIR + '/T01-SUMMARY.md', renderDoc('SUMMARY'));
3012
+ writeState(dir, executeState());
3013
+ writeNodeDeclarationMarkers(dir, 'execute');
3014
+ const ordered = exitNode(dir, 'execute');
3015
+ assertExit(ordered, 0);
3016
+ assertOut(ordered, 'ALL CHECKS PASSED');
3017
+
3018
+ // ⑤ 模板整份缺席:命名段检查**全部跳过**(含 pick 类)。夹具:没有
3019
+ // flow-kit/templates/,且 CHANGE.md 连 `## Why` 都没有——旧实现拿
3020
+ // `TEMPLATE_FALLBACK_SECTION_PATTERNS.changeWhy` 判「缺必填段」而 BLOCKED,与「模板缺失全部
3021
+ // 跳过」相反。跳过后必须放行,且输出仍显式声明未校验(跳过可见、不是静默通过,L-079)。
3022
+ fs.rmSync(path.join(dir, 'flow-kit'), { recursive: true, force: true });
3023
+ resetFixture(dir);
3024
+ writeFile(dir, CHANGE_DIR + '/CHANGE.md', renderDoc('CHANGE', { omit: ['Why'] }));
3025
+ writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md', renderDoc('REQUIREMENT'));
3026
+ const openState = () => {
3027
+ const next = newChangeState('open');
3028
+ next.evidence.open = { summary: 'intake complete' };
3029
+ return next;
3030
+ };
3031
+ writeState(dir, openState());
3032
+ writeNodeDeclarationMarkers(dir, 'open');
3033
+ const noFallback = exitNode(dir, 'open');
3034
+ assertExit(noFallback, 0);
3035
+ assertNotOut(noFallback, '缺必填段');
3036
+ assertOut(noFallback, '未校验');
3037
+ assertOut(noFallback, '模板缺失');
3038
+
3039
+ // ⑥ C9 后半句(反向构造):模板**在场**但该段名缺席(上游改版)⇒ 命名段 fallback 仍生效。
3040
+ // 同一缺 Why 的工件在「模板不含 Why」的夹具上必须被拦——否则「整份缺席不回落」会被写成
3041
+ // 「干脆不查」。
3042
+ resetFixture(dir);
3043
+ writeTemplateFixtureOmittingSection(dir, 'CHANGE', 'Why');
3044
+ writeFile(dir, CHANGE_DIR + '/CHANGE.md', renderDoc('CHANGE', { omit: ['Why'] }));
3045
+ writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md', renderDoc('REQUIREMENT'));
3046
+ writeState(dir, openState());
3047
+ writeNodeDeclarationMarkers(dir, 'open');
3048
+ const fallbackStill = exitNode(dir, 'open');
3049
+ assertExit(fallbackStill, 1);
3050
+ assertOut(fallbackStill, '缺必填段');
3051
+
3052
+ // ⑦ 判据形态(同一 pick 的两态):整份模板缺席 ⇒ 返回显式「跳过」判据(`skip` 标记 +
3053
+ // `.test` 恒真),不是 fallback 正则、也不是 null——消费方里有闭包外直接 `.test` 的调用点
3054
+ // (「视觉调性」段读取),返回 null 会把「跳过」退化成 TypeError 崩溃(未校验变失败)。
3055
+ const routing = await import('../lib/guard-routing.mjs');
3056
+ const underivedPatterns = await routing.templateSectionPatterns({ runRoot: path.join(dir, 'bare-root') });
3057
+ const skippedPick = underivedPatterns.pick('change', ['Why'], routing.TEMPLATE_FALLBACK_SECTION_PATTERNS.changeWhy);
3058
+ assertTrue(skippedPick !== routing.TEMPLATE_FALLBACK_SECTION_PATTERNS.changeWhy
3059
+ && skippedPick?.skip === true
3060
+ && skippedPick.test('不含 Why 的夹具正文(旧实现据此判缺段)') === true,
3061
+ '整份模板缺席时 pick 应返回显式跳过判据(不回落 fallback),实际: ' + String(skippedPick));
3062
+ const derivedPatterns = await routing.templateSectionPatterns({ runRoot: dir });
3063
+ const fallbackPick = derivedPatterns.pick('change', ['Why'], routing.TEMPLATE_FALLBACK_SECTION_PATTERNS.changeWhy);
3064
+ assertTrue(fallbackPick instanceof RegExp && fallbackPick.test('## Why(为什么做)'),
3065
+ '模板在场但缺该段名时 pick 仍回落 fallback 正则(C9 后半句),实际: ' + String(fallbackPick));
3066
+
3067
+ // ⑥b 轮廓解析跨围栏(段体单源化的**行为面**):把某段的标题只写在**围栏示例**里、真段删掉
3068
+ // ——围栏里的标题不开段,缺段必须照样判出。旧 parseOutline 按行扫 `^##`(围栏盲):
3069
+ // 示例里的标题被读成真实段,缺段被静默放过(假绿)。它是段序 / 空正文 / 增量段位置的
3070
+ // 共同输入,同一份盲区在那三处也会各自变成假绿——所以这里钉的是轮廓解析本身。
3071
+ resetFixture(dir);
3072
+ writeTemplateFixture(dir, 'CHANGE');
3073
+ // 段名取模板里**最后一个**必需段:把它的标题只写进围栏示例(放在它前面那段里)——示例行
3074
+ // 被读成真实段时它落在自己的模板位置上,段序判据不出声,缺段就此静默放过(正是假绿形态)。
3075
+ writeFile(dir, CHANGE_DIR + '/CHANGE.md', renderDoc('CHANGE', {
3076
+ omit: ['风险与未知'],
3077
+ body: [['验收线', ['验收线(夹具)。', '',
3078
+ '```markdown', '## 风险与未知', '示例:围栏内的段标题', '```', ''].join('\n')]],
3079
+ }));
3080
+ writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md', renderDoc('REQUIREMENT'));
3081
+ writeState(dir, openState());
3082
+ writeNodeDeclarationMarkers(dir, 'open');
3083
+ const fencedOutline = exitNode(dir, 'open');
3084
+ assertExit(fencedOutline, 1);
3085
+ assertOut(fencedOutline, '缺段');
3086
+ assertNotOut(fencedOutline, 'BLOCKED: CHANGE.md 模板结构校验失败: 段序');
3087
+
3088
+ // ⑤ 段体切片单源锁:受检面 = **引擎实现面**(`engineScriptTexts`:顶层入口 ∪ 静态可达模块 ∪
3089
+ // 非套件自持的 `lib/**`)——不再是「提到 sectionBody 的取用面」:把一份私有实现搬进面内一个
3090
+ // 不引用该符号的模块(健康巡检、任一 guard 模块)就躲不开了。三条判据:① 单源模块由导出面派生
3091
+ // (不写文件名),{sectionBody, scanHeadings}
3092
+ // 都定义在那里;② 取用面:提到单源符号的模块必须具名取用、不得自带第二份定义;③ 形态面:
3093
+ // 面内任一函数的任一形态(行扫描 / 正则切片 / 字符串字面量 / 行数组切片)若在切段体,只许是
3094
+ // 单源本身,否则必须登记(SECTION_SLICE_REGISTRY:文件 + 符号 + 理由 + 合并条件;陈旧登记判红)。
3095
+ // 反向构造:合成切片放进「不引用单源符号」的模块(证明受检面比取用面宽)/ 改 import 来源 /
3096
+ // 第二份定义 / 本任务收口的三处各自改回私有实现 / 登记放行真实副本 / 陈旧登记 / 缺理由登记
3097
+ // ——逐条证明判别力,还原 ⇒ 复绿。
3098
+ {
3099
+ const texts = engineScriptTexts();
3100
+ const baseProblems = sectionSingleSourceProblems({ texts });
3101
+ assertTrue(baseProblems.length === 0, '段体单源违规: ' + baseProblems.join(' | '));
3102
+ const probeIssues = [];
3103
+ // 探针打在**登记之外**的消费方上,否则变异会被登记豁免吃掉、退化成恒绿。
3104
+ const consumers = [...texts.keys()].filter((rel) => /\b(?:sectionBody|scanHeadings)\b/u
3105
+ .test(engineCodeText(texts.get(rel) ?? '')));
3106
+ const probeRel = consumers.find((rel) => !SECTION_SLICE_REGISTRY.some((entry) => entry.file === rel));
3107
+ const probeText = texts.get(probeRel);
3108
+ const probeSlicer = [
3109
+ 'function probeSectionBody(content) {',
3110
+ ' const body = [];',
3111
+ ' for (const line of String(content).split(/\\n/)) {',
3112
+ ' if (/^##\\s/u.test(line)) break;',
3113
+ ' body.push(line);',
3114
+ ' }',
3115
+ ' return body.join("\\n");',
3116
+ '}',
3117
+ ].join('\n');
3118
+ // 受检面必须比取用面宽(否则「形态面」只是换名字的取用面):把同一份合成切片放进一个从不引用
3119
+ // 单源符号的模块,判据仍须点名它。这条同时钉住了 SECTION_SLICE_REGISTRY 的登记面——那几条
3120
+ // 命中都不 import sectionBody,一旦受检面退回取用面,它们会立刻变成陈旧登记(也是红的)。
3121
+ const shadowRel = SECTION_SLICE_REGISTRY[0].file;
3122
+ assertTrue(!/\b(?:sectionBody|scanHeadings)\b/u.test(engineCodeText(texts.get(shadowRel) ?? '')),
3123
+ '受检面扩面的前提失效:' + shadowRel + ' 引用了单源符号(形态面与取用面不再可区分)');
3124
+ const shadowProblems = sectionSingleSourceProblems({
3125
+ texts: new Map(texts).set(shadowRel, (texts.get(shadowRel) ?? '') + '\n' + probeSlicer),
3126
+ });
3127
+ if (!shadowProblems.some((problem) => problem.includes(shadowRel) && problem.includes('probeSectionBody'))) {
3128
+ probeIssues.push('受检面退回了取用面:' + shadowRel + ' 里的合成切片未被判红('
3129
+ + JSON.stringify(shadowProblems) + ')');
3130
+ }
3131
+ // 取用面两格:改 import 来源(单符号 import 摘名字靠不住,换来源才是同一件事的可靠构造)/
3132
+ // 自带第二份定义。
3133
+ const referenced = SECTION_SOURCE_SYMBOLS.find((symbol) => new RegExp('\\b' + symbol + '\\b', 'u')
3134
+ .test(engineCodeText(probeText))) ?? 'sectionBody';
3135
+ const retargeted = probeText.replace(/(from\s*'[^']*)section-body\.mjs'/u, "$1section-body-absent.mjs'");
3136
+ const takenProbes = [
3137
+ ['消费方不再从单源取用(import 来源被换掉)', retargeted, '未从'],
3138
+ ['消费方自带第二份定义', probeText + '\nfunction ' + referenced + '() { return null; }\n', '自带第二份'],
3139
+ ];
3140
+ for (const [label, mutatedText, expected] of takenProbes) {
3141
+ if (mutatedText === probeText) {
3142
+ probeIssues.push(label + ':变异未改变 ' + probeRel);
3143
+ continue;
3144
+ }
3145
+ const reported = sectionSingleSourceProblems({ texts: new Map(texts).set(probeRel, mutatedText) });
3146
+ if (!reported.some((problem) => problem.includes(probeRel) && problem.includes(expected))) {
3147
+ probeIssues.push(label + ':未被判违规(' + JSON.stringify(reported) + ')');
3148
+ }
3149
+ }
3150
+ // 写法面两格(C 字符串字面量切分 / D 对象字面量内联箭头)各一份**合成实现**放进取用面之外的
3151
+ // 模块 ⇒ 判据必须点名它们:旧锁对这两种写法都判绿(B 的判据只认正则字面量,functionBodies 只看
3152
+ // 顶层声明),「锁看不见」于是无从发现——这一格是这两种写法的常驻判别力锚。
3153
+ const syntheticSlicers = [
3154
+ ['C 字符串字面量切分', 'probeStringSlicer', [
3155
+ 'function probeStringSlicer(content) {',
3156
+ ' return (String(content).split("## S")[1] ?? "").split("\\n##")[0];',
3157
+ '}',
3158
+ ].join('\n')],
3159
+ ['D 对象字面量内联箭头', 'probeInlineSlicer', [
3160
+ 'const probeChecks = [',
3161
+ ' {',
3162
+ ' probeInlineSlicer: (text) => {',
3163
+ ' const seg = (text.split("## 已锁决策")[1] ?? "").split("\\n##")[0];',
3164
+ ' return seg.length >= 0;',
3165
+ ' },',
3166
+ ' },',
3167
+ '];',
3168
+ ].join('\n')],
3169
+ ];
3170
+ for (const [label, symbol, synthetic] of syntheticSlicers) {
3171
+ const reported = sectionSingleSourceProblems({
3172
+ texts: new Map(texts).set(shadowRel, (texts.get(shadowRel) ?? '') + '\n' + synthetic),
3173
+ });
3174
+ if (!reported.some((problem) => problem.includes(shadowRel) && problem.includes(symbol))) {
3175
+ probeIssues.push('形态面未覆盖「' + label + '」:' + shadowRel + ' 里的合成切片 ' + symbol
3176
+ + ' 未被判红(' + JSON.stringify(reported) + ')');
3177
+ }
3178
+ }
3179
+ // 形态面:本任务收口的三处各自改回私有实现 ⇒ 锁必红(变异体 = 删掉的旧实现原文)。
3180
+ const revertedTexts = new Map();
3181
+ for (const reverted of REVERTED_PRIVATE_SLICERS) {
3182
+ // 变异体按 LF 归一后再套用(工作树是 CRLF,锚文本写的是 LF):不归一时整段锚永远找不到,
3183
+ // 探针会以「锚已漂移」红——那红说的是行尾,不是判据。
3184
+ const original = (texts.get(reverted.rel) ?? '').replace(/\r\n/gu, '\n');
3185
+ let mutated = original;
3186
+ for (const [from, to] of reverted.edits) {
3187
+ if (!mutated.includes(from)) {
3188
+ probeIssues.push(reverted.label + ':锚已漂移(' + reverted.rel + ' 里找不到待替换片段)');
3189
+ continue;
3190
+ }
3191
+ mutated = mutated.split(from).join(to);
3192
+ }
3193
+ if (mutated === original) {
3194
+ probeIssues.push(reverted.label + ':变异未改变 ' + reverted.rel);
3195
+ continue;
3196
+ }
3197
+ revertedTexts.set(reverted.rel, mutated);
3198
+ const reported = sectionSingleSourceProblems({ texts: new Map(texts).set(reverted.rel, mutated) });
3199
+ for (const symbol of reverted.symbols) {
3200
+ if (!reported.some((problem) => problem.includes(reverted.rel) && problem.includes(symbol))) {
3201
+ probeIssues.push(reverted.label + ':锁没看见 ' + reverted.rel + ' 的 ' + symbol
3202
+ + '(' + JSON.stringify(reported) + ')');
3203
+ }
3204
+ }
3205
+ }
3206
+ // 登记机制本身的五格:陈旧登记判红 / 缺理由判红 / 缺合并条件判红(登记要写到期的条件,
3207
+ // 不是永久豁免)/ **登记不能放行真实副本**(给 context-init 的私有 sectionBody 配一条登记,
3208
+ // 判据仍须报「自带第二份定义」——登记只覆盖形态命中)/ 登记条目必须**当场命中**(删掉
3209
+ // evolve.mjs 的那条 ⇒ 判据点名它的 locateSedimentSection,证明 E 形态真的落在形态面上)。
3210
+ const staleRegistry = [...SECTION_SLICE_REGISTRY, {
3211
+ file: 'lib/guard-uidesign.mjs', symbol: 'visualToneSectionState', reason: '(探针)已收口处仍登记',
3212
+ }];
3213
+ const staleProblems = sectionSingleSourceProblems({ texts, registry: staleRegistry });
3214
+ if (!staleProblems.some((problem) => problem.includes('登记已陈旧') && problem.includes('visualToneSectionState'))) {
3215
+ probeIssues.push('陈旧登记未被判红(已收口的视觉调性段体仍登记): ' + JSON.stringify(staleProblems));
3216
+ }
3217
+ const noReasonProblems = sectionSingleSourceProblems({
3218
+ texts,
3219
+ registry: [{ ...SECTION_SLICE_REGISTRY[0], reason: ' ' }],
3220
+ });
3221
+ if (!noReasonProblems.some((problem) => problem.includes('登记缺理由'))) {
3222
+ probeIssues.push('缺理由登记未被判红: ' + JSON.stringify(noReasonProblems));
3223
+ }
3224
+ const noMergeProblems = sectionSingleSourceProblems({
3225
+ texts,
3226
+ registry: [{ ...SECTION_SLICE_REGISTRY[0], mergeCondition: ' ' }],
3227
+ });
3228
+ if (!noMergeProblems.some((problem) => problem.includes('登记缺合并条件'))) {
3229
+ probeIssues.push('缺合并条件的登记未被判红(永久豁免没到期日): ' + JSON.stringify(noMergeProblems));
3230
+ }
3231
+ // 登记条目必须当场命中:evolve.mjs 的 E 形态(findIndex + slice + 可达标题判定)是这一条
3232
+ // 的判别锚——删掉登记 ⇒ 判据必须点名它,否则那条登记是装饰、E 形态整份在锁外。
3233
+ const evolveEntry = SECTION_SLICE_REGISTRY.find((entry) => entry.file === 'evolve.mjs');
3234
+ if (evolveEntry === undefined) {
3235
+ probeIssues.push('登记表缺 evolve.mjs 的段体切片登记(E 形态没有登记条目)');
3236
+ } else {
3237
+ const unregistered = sectionSingleSourceProblems({
3238
+ texts,
3239
+ registry: SECTION_SLICE_REGISTRY.filter((entry) => entry !== evolveEntry),
3240
+ });
3241
+ if (!unregistered.some((problem) => problem.includes('evolve.mjs')
3242
+ && problem.includes(evolveEntry.symbol))) {
3243
+ probeIssues.push('E 形态未被形态面看见:删掉 evolve.mjs 的登记后判据仍不点名 '
3244
+ + evolveEntry.symbol + '(' + JSON.stringify(unregistered) + ')');
3245
+ }
3246
+ }
3247
+ const lenientProblems = sectionSingleSourceProblems({
3248
+ texts: new Map(texts).set('context-init.mjs', revertedTexts.get('context-init.mjs') ?? ''),
3249
+ registry: [...SECTION_SLICE_REGISTRY, {
3250
+ file: 'context-init.mjs', symbol: 'sectionBody', reason: '(探针)给真实副本配一条登记',
3251
+ }],
3252
+ });
3253
+ if (!lenientProblems.some((problem) => problem.includes('context-init.mjs')
3254
+ && problem.includes('第二份 sectionBody'))) {
3255
+ probeIssues.push('登记放行了真实副本(context-init 的私有 sectionBody 配登记后仍须判红): '
3256
+ + JSON.stringify(lenientProblems));
3257
+ }
3258
+ if (sectionSingleSourceProblems({ texts }).length !== 0) probeIssues.push('还原后未复绿(判据受输入顺序影响)');
3259
+ assertTrue(probeIssues.length === 0, '段体单源锁反向构造失败: ' + probeIssues.join(' | '));
3260
+ }
3261
+
3262
+ // ⑥ 段体契约(单源的语义面,八格逐条对照):围栏内的标题与分隔线不结束段体;围栏外的同级标题
3263
+ // 与分隔线按 options 结束;结束标题的级别按 options;段缺席返回 null(与「段在场正文为空」
3264
+ // 可区分——调用方据此判「未校验」而不是「没写」)。
3265
+ {
3266
+ const sectionModule = await import('../lib/section-body.mjs');
3267
+ const contract = [
3268
+ ['围栏内的二级标题不结束段体',
3269
+ '## S\n\n```md\n## 块内标题\n```\n\n正文\n\n## T\n', /^##\s*S/u, {},
3270
+ '\n```md\n## 块内标题\n```\n\n正文\n'],
3271
+ ['波浪号围栏同口径',
3272
+ '## S\n\n~~~md\n## 块内标题\n~~~\n\n正文\n', /^##\s*S/u, {}, '\n~~~md\n## 块内标题\n~~~\n\n正文\n'],
3273
+ ['围栏外的同级标题结束段体',
3274
+ '## S\n\n正文\n\n## T\n\n别段\n', /^##\s*S/u, {}, '\n正文\n'],
3275
+ ['分隔线结束段体(默认)',
3276
+ '## S\n\n正文\n\n---\n\n尾\n', /^##\s*S/u, {}, '\n正文\n'],
3277
+ ['分隔线不结束段体(endOnSeparator: false)',
3278
+ '## S\n\n正文\n\n---\n\n尾\n', /^##\s*S/u, { endOnSeparator: false },
3279
+ '\n正文\n\n---\n\n尾\n'],
3280
+ ['三级标题不结束二级段体(level: 2)',
3281
+ '## S\n\n正文\n\n### 子\n\n子正文\n', /^##\s*S/u, {},
3282
+ '\n正文\n\n### 子\n\n子正文\n'],
3283
+ ['同级标题结束三级段体(level: 3)',
3284
+ '### S\n\n正文\n\n### T\n\n别段\n', /^###\s*S/u, { level: 3 }, '\n正文\n'],
3285
+ ['段缺席返回 null',
3286
+ '## 其他\n\n正文\n', /^##\s*S/u, {}, null],
3287
+ ];
3288
+ for (const [label, docText, pattern, options, expected] of contract) {
3289
+ const actual = sectionModule.sectionBody(docText, pattern, options);
3290
+ assertTrue(actual === expected,
3291
+ '段体契约(' + label + '): 期望 ' + JSON.stringify(expected) + ',实际 ' + JSON.stringify(actual));
3292
+ }
3293
+ }
3294
+
3295
+ // ⑦ 配对键单源(P8):第三族(同文件跨任务)的「任务对键」只在 task-graph 表达一次;[P] 判据的
3296
+ // 补集(写面重叠 ⇒ 不该被要求标 [P])消费 task-graph 返回的判定,不自己再建一份键——第二份键
3297
+ // 的形态一旦漂移(换分隔符 / 换定序),两端键不再相等,补集静默失效(重叠的一对被当成「本可
3298
+ // 并行」)。反向构造三层:静态两格(换名字的第二份键 / 换分隔符的漂移形态都必红)+ 行为一格
3299
+ // (把补集判据改回自建键且形态漂移 ⇒ 重叠对被误报,补集断言必红)。
3300
+ {
3301
+ const texts = engineScriptTexts();
3302
+ const baseProblems = pairKeySingleSourceProblems({ texts });
3303
+ assertTrue(baseProblems.length === 0, '任务对键单源违规: ' + baseProblems.join(' | '));
3304
+ const waveRel = (engineDefinitionModule('parallelGapReview') ?? {}).file;
3305
+ assertTrue(typeof waveRel === 'string', '补集判据的定义面不唯一(反查失败): '
3306
+ + JSON.stringify(engineDefinitionHits('parallelGapReview')));
3307
+ const waveText = texts.get(waveRel) ?? '';
3308
+ const secondKeyMutants = [
3309
+ ['换名字的第二份键(历史上删掉的 gapPairKey 原形)',
3310
+ '\nfunction gapPairKey(left, right) {\n'
3311
+ + ' return left < right ? left + "\\u0000" + right : right + "\\u0000" + left;\n}\n'],
3312
+ ['换分隔符的漂移形态(判据不看分隔符取值)',
3313
+ '\nfunction probePairKey(a, b) {\n return a < b ? a + "|" + b : b + "|" + a;\n}\n'],
3314
+ ];
3315
+ for (const [label, injected] of secondKeyMutants) {
3316
+ const reported = pairKeySingleSourceProblems({ texts: new Map(texts).set(waveRel, waveText + injected) });
3317
+ assertTrue(reported.some((problem) => problem.includes(waveRel)),
3318
+ '配对键单源锁看不见「' + label + '」: ' + JSON.stringify(reported));
3319
+ }
3320
+ // 行为面:同一对任务(同波同层、写同一个文件、都没标 parallel)在两支下对照——真实模块里补集
3321
+ // 判据把这对排除(写面重叠的一对不是「可并行」);变异体(补集判据改回自建键 + 分隔符漂移)
3322
+ // 里两端键对不上 ⇒ 同一对被误报成「可并行却未标 [P]」⇒ 补集断言变红。
3323
+ const overlapTask = (id) => '<task id="' + id + '" status="pending"><action>实现 ' + id
3324
+ + '</action><write_files>src/shared.mjs</write_files><verify>node --check src/shared.mjs</verify>'
3325
+ + '<depends_on></depends_on></task>\n';
3326
+ const overlapTaskContent = '# TASK\n\n## 波次划分\n\nWave 1: T01, T02\n\n## 任务清单\n\n'
3327
+ + overlapTask('T01') + overlapTask('T02');
3328
+ const overlapBlocks = taskBlocks(overlapTaskContent);
3329
+ const waveModule = await import('../lib/wave-projection.mjs');
3330
+ const overlapWaves = waveModule.waveProjectionReview({
3331
+ taskContent: overlapTaskContent, blocks: overlapBlocks,
3332
+ });
3333
+ assertTrue(overlapWaves.waves instanceof Map && overlapWaves.waves.size === 2,
3334
+ '夹具前提失效:波次分组应可判(' + JSON.stringify([...((overlapWaves.waves) ?? [])]) + ')');
3335
+ const realGaps = waveModule.parallelGapReview({
3336
+ taskContent: overlapTaskContent, blocks: overlapBlocks, waves: overlapWaves.waves,
3337
+ });
3338
+ assertTrue(realGaps.gaps.length === 0,
3339
+ '补集判据失效:写面重叠(同一文件)的一对被要求标 [P](' + JSON.stringify(realGaps.gaps) + ')');
3340
+ // 写面未知 ≠ 写面不重叠:同波同层、其中一方**没有** write_files 的一对不在「可并行却未标 [P]」
3341
+ // 的判据面上——写面未知意味着「不能断言不重叠」,不是「不重叠」。候选判据若只按波次/层级/
3342
+ // status/修复族过滤,就会把「没写写面」读成「写面不重叠」,把这一对报成漏标 [P],恢复句还让
3343
+ // 作者补 depends_on(真正缺的是 write_files 字段)。判据面因此与 task-graph 的参与者判据对齐:
3344
+ // 没有写面的任务不参与「可并行」的断言。
3345
+ const unknownWriteTask = (id) => '<task id="' + id + '" status="pending"><action>实现 ' + id
3346
+ + '</action><verify>node --check src/a.mjs</verify><depends_on></depends_on></task>\n';
3347
+ const unknownWriteContent = '# TASK\n\n## 波次划分\n\nWave 1: T01, T02\n\n## 任务清单\n\n'
3348
+ + '<task id="T01" status="pending"><action>实现 T01</action><write_files>src/a.mjs</write_files>'
3349
+ + '<verify>node --check src/a.mjs</verify><depends_on></depends_on></task>\n'
3350
+ + unknownWriteTask('T02');
3351
+ const unknownWriteBlocks = taskBlocks(unknownWriteContent);
3352
+ const unknownWaves = waveModule.waveProjectionReview({
3353
+ taskContent: unknownWriteContent, blocks: unknownWriteBlocks,
3354
+ });
3355
+ assertTrue(unknownWaves.waves instanceof Map && unknownWaves.waves.size === 2,
3356
+ '夹具前提失效:写面未知那一格的波次分组应可判('
3357
+ + JSON.stringify([...((unknownWaves.waves) ?? [])]) + ')');
3358
+ const unknownGaps = waveModule.parallelGapReview({
3359
+ taskContent: unknownWriteContent, blocks: unknownWriteBlocks, waves: unknownWaves.waves,
3360
+ });
3361
+ assertTrue(unknownGaps.gaps.length === 0,
3362
+ '写面未知被当成「写面不重叠」:没有 write_files 的任务被要求标 [P]'
3363
+ + '(写面未知时不能断言可并行,恢复句还会指错方向): ' + JSON.stringify(unknownGaps.gaps));
3364
+ // 注释写不变式,不写过程:引擎注释里不留任务号与改动叙述——接手的人读到的是约束,不是某一轮
3365
+ // 改动的日记。受检面 = **引擎实现面**(与本节其余格子同一派生口径:入口 ∪ 静态可达模块 ∪
3366
+ // 非套件自持的 lib/ 模块),逐文件扫:判据只扫一个模块、注释却宣称「引擎注释」时,覆盖面只
3367
+ // 存在于注释里。判据是具名纯函数(见 commentNarrationHits),正向断言之外配三条探针:叙述
3368
+ // 混回去必须被检出、任务号混回去必须被检出(否则「零命中」可能是谓词根本认不出东西),而
3369
+ // 注释里贴 ISO 时间戳字面量(`2026-02-30T00:00:00Z` 的 `T00`)不得被读成任务号。
3370
+ const narrations = [];
3371
+ for (const [rel, text] of texts) {
3372
+ for (const hit of commentNarrationHits(text)) {
3373
+ narrations.push(rel + ':' + hit.lineNumber + ' [' + hit.kind + '] ' + hit.line);
3374
+ }
3375
+ }
3376
+ assertTrue(narrations.length === 0,
3377
+ '引擎注释里出现任务号 / 过程叙述(应写不变式): ' + JSON.stringify(narrations, null, 1));
3378
+ assertTrue(commentNarrationHits('// 本任务里已照形态加过一支。\n').length > 0,
3379
+ '注释叙述判据不具判别力:混入「本任务 / 已照形态」的注释没有被检出');
3380
+ assertTrue(commentNarrationHits('// 旧条目判定含 T11 的迁移保留形态。\n').length > 0,
3381
+ '注释叙述判据不具判别力:混入任务号的注释没有被检出');
3382
+ assertTrue(commentNarrationHits('// V8 对 `2026-02-30T00:00:00Z` 会静默滚到 3 月 2 日。\n').length === 0,
3383
+ '注释叙述判据把注释里的 ISO 时间戳字面量读成了任务号(假阳性)');
3384
+ // 变异体经 inlineModuleUrl 只在内存里编译(不落盘、不留残留)。
3385
+ // 变异 = 把「取单源判定」换回「两端各算一次键」,并只让**消费方**那一端漂移(生产方仍用
3386
+ // task-graph 的 NUL 形态):这正是第二份键实现存在的真实风险——改一端、漏一端,键就不再相等。
3387
+ // 两处锚各自只改一处代码位置(不搬动实参行),变异体因此语法完整、只把键的两份形态造出来。
3388
+ const decisionAnchor = ' const { isOverlappingPair } = collectCrossTaskConflicts({';
3389
+ const gapsAnchor = ' const gaps = [];';
3390
+ assertTrue(waveText.includes(decisionAnchor) && waveText.includes(gapsAnchor),
3391
+ '反向构造前提失效:' + waveRel + ' 未按单源形态取用第三族判定(锚已漂移)');
3392
+ const driftedText = waveText
3393
+ .replace(decisionAnchor, ' const probeResult = collectCrossTaskConflicts({')
3394
+ .replace(gapsAnchor, [
3395
+ " const producerPairKey = (a, b) => (a < b ? a + '\\u0000' + b : b + '\\u0000' + a);",
3396
+ " const consumerPairKey = (a, b) => (a < b ? a + '|' + b : b + '|' + a);",
3397
+ ' const overlappingPairs = new Set(probeResult.conflicts.map((conflict)'
3398
+ + ' => producerPairKey(conflict.a, conflict.b)));',
3399
+ ' const isOverlappingPair = (a, b) => overlappingPairs.has(consumerPairKey(a, b));',
3400
+ ' const gaps = [];',
3401
+ ].join('\n'));
3402
+ assertTrue(driftedText !== waveText, '反向构造前提失效:变异未改变 ' + waveRel);
3403
+ const driftedModule = await import(inlineModuleUrl(driftedText, waveRel));
3404
+ const driftedGaps = driftedModule.parallelGapReview({
3405
+ taskContent: overlapTaskContent, blocks: overlapBlocks, waves: overlapWaves.waves,
3406
+ });
3407
+ assertTrue(driftedGaps.gaps.length > 0,
3408
+ '反向构造失效:补集判据改回「自建键 + 分隔符漂移」后,写面重叠的一对没有被误报——'
3409
+ + '说明该断言对任务对键的形态不敏感(' + JSON.stringify(driftedGaps.gaps) + ')');
3410
+ }
3411
+
3412
+ // ⑧ 写面元素的取用面(task-graph 的路径解析 / plan 出口的伪并行启发式):写面判定在
3413
+ // lib/lessons-hits.mjs 已只有一份实现,两处消费方却各自拿着**大小写敏感**的标签正则——混合
3414
+ // 大小写时 7 字段门判「字段在场」、写面判定判「未知」,任务静默掉出判据面:写写重叠漏拦、
3415
+ // 同文件族漏判、伪并行启发式漏报,而同波同层的同文件对反被 [P] 判据当成「可并行」误报。
3416
+ // 三条面:结构锁(标签字面量只许在单源模块)+ 行为(混合大小写与全小写写法在四条判据上给出
3417
+ // 同一结论)+ 反向构造(把取用改回大小写敏感 ⇒ 锁与行为断言都必红)。
3418
+ {
3419
+ const faceTexts = engineScriptTexts();
3420
+ const faceSource = engineDefinitionModule('taskWriteFilesById');
3421
+ assertTrue(faceSource !== null,
3422
+ '写面元素提取(taskWriteFilesById)的定义面应恰一处(反查失败): '
3423
+ + JSON.stringify(engineDefinitionHits('taskWriteFilesById')));
3424
+ const faceTagProblems = writeFaceSourceProblems({ texts: faceTexts, sourceRel: faceSource.file });
3425
+ assertTrue(faceTagProblems.length === 0, '写面元素标签单源违规: ' + faceTagProblems.join(' | '));
3426
+ const faceTakenProblems = singleSourceImportProblems({
3427
+ symbol: 'taskWriteFilesById', sourceRel: faceSource.file, texts: faceTexts,
3428
+ });
3429
+ assertTrue(faceTakenProblems.length === 0,
3430
+ '写面元素提取应只有一处实现且消费方都从它取用:\n' + faceTakenProblems.join('\n'));
3431
+ // 反向构造两格(互不覆盖):① 消费方保留取用、另带一份大小写敏感的标签正则——副本溜回来的
3432
+ // 真实形态,由形态锁点名;② 消费方摘掉单源取用而仍引用该符号,由取用面锁点名。
3433
+ const faceProbes = [];
3434
+ const carriedCopy = '\nconst probeWriteFilesFace = (block) => String(block).match(/<write_files>([\\s\\S]*?)<\\/write_files>/);\n';
3435
+ for (const rel of ['lib/task-graph.mjs', 'lib/guard-gates.mjs']) {
3436
+ const original = faceTexts.get(rel) ?? '';
3437
+ const carriedProblems = writeFaceSourceProblems({
3438
+ texts: new Map(faceTexts).set(rel, original + carriedCopy), sourceRel: faceSource.file,
3439
+ });
3440
+ if (!carriedProblems.some((problem) => problem.includes(rel))) {
3441
+ faceProbes.push(rel + ':副本(保留取用 + 自持标签正则)未被形态锁点名');
3442
+ }
3443
+ const droppedProblems = singleSourceImportProblems({
3444
+ symbol: 'taskWriteFilesById', sourceRel: faceSource.file,
3445
+ texts: new Map(faceTexts).set(rel, dropNamedImport(original, 'taskWriteFilesById')),
3446
+ });
3447
+ if (!droppedProblems.some((problem) => problem.includes(rel))) {
3448
+ faceProbes.push(rel + ':摘掉单源取用后未被取用面锁点名');
3449
+ }
3450
+ }
3451
+ assertTrue(faceProbes.length === 0, '写面单源锁反向构造失败: ' + faceProbes.join(' | '));
3452
+
3453
+ // 行为面:混合大小写写面与全小写写法必须给出同一结论(全小写格是夹具前提,混合格是断言)。
3454
+ // 写写强判(并行对)与同文件族(串行对)各一格——两族都由 task-graph 的路径解析供数。
3455
+ const faceBlock = (id, tag, attrs) => '<task id="' + id + '"' + attrs + ' status="pending">'
3456
+ + '<action>实现 ' + id + '</action><' + tag + '>src/shared.mjs</' + tag + '>'
3457
+ + '<verify>node --check src/shared.mjs</verify></task>\n';
3458
+ const facePlan = (tag, attrs) => '# TASK\n\n## 任务清单\n\n'
3459
+ + faceBlock('W01', tag, attrs) + faceBlock('W02', tag, attrs);
3460
+ const faceRoot = (label) => path.join(dir, 'write-face-' + label);
3461
+ const conflictsIn = async (module, label, planText) => {
3462
+ writeFile(faceRoot(label), '.specs/' + CHANGE_ID + '/TASK.md', planText);
3463
+ return module.findParallelWriteConflicts(path.join(faceRoot(label), '.specs', CHANGE_ID));
3464
+ };
3465
+ const taskGraph = await import('../lib/task-graph.mjs');
3466
+ const lowerParallel = await conflictsIn(taskGraph, 'lower-parallel', facePlan('write_files', ' parallel="true"'));
3467
+ assertTrue(lowerParallel.writeConflicts.length === 1,
3468
+ '夹具前提失效:全小写写面的同文件并行对未被写写强判检出('
3469
+ + JSON.stringify(lowerParallel.writeConflicts) + ')');
3470
+ const upperParallel = await conflictsIn(taskGraph, 'upper-parallel', facePlan('WRITE_FILES', ' parallel="true"'));
3471
+ assertTrue(upperParallel.writeConflicts.length === 1,
3472
+ '混合大小写写面的同文件并行对逃过写写强判(元素名大小写无关,同一份写面应判重叠): '
3473
+ + JSON.stringify(upperParallel.writeConflicts));
3474
+ const lowerSerial = await conflictsIn(taskGraph, 'lower-serial', facePlan('write_files', ''));
3475
+ assertTrue(lowerSerial.crossTaskConflicts.length === 1,
3476
+ '夹具前提失效:全小写写面的同文件串行对未被同文件族检出('
3477
+ + JSON.stringify(lowerSerial.crossTaskConflicts) + ')');
3478
+ const upperSerial = await conflictsIn(taskGraph, 'upper-serial', facePlan('WRITE_FILES', ''));
3479
+ assertTrue(upperSerial.crossTaskConflicts.length === 1,
3480
+ '混合大小写写面的同文件串行对逃过同文件族(同文件且无依赖路径,应判冲突): '
3481
+ + JSON.stringify(upperSerial.crossTaskConflicts));
3482
+
3483
+ // [P] 判据:写面重叠的一对不该被要求标 [P](写面未知 ≠ 写面不重叠),写面互不重叠的一对必须
3484
+ // 照常点名——后半格钉住「不是把混合写法整片排除出判据面」。
3485
+ const waveFace = await import('../lib/wave-projection.mjs');
3486
+ const gapsFor = (tag, leftWrite, rightWrite) => {
3487
+ const block = (id, writePath) => '<task id="' + id + '" status="pending"><action>实现 ' + id
3488
+ + '</action><' + tag + '>' + writePath + '</' + tag + '><verify>node --check ' + writePath
3489
+ + '</verify><depends_on></depends_on></task>\n';
3490
+ const content = '# TASK\n\n## 波次划分\n\nWave 1: G01, G02\n\n## 任务清单\n\n'
3491
+ + block('G01', leftWrite) + block('G02', rightWrite);
3492
+ const blocks = taskBlocks(content);
3493
+ const review = waveFace.waveProjectionReview({ taskContent: content, blocks });
3494
+ return waveFace.parallelGapReview({ taskContent: content, blocks, waves: review.waves });
3495
+ };
3496
+ assertTrue(gapsFor('write_files', 'src/shared.mjs', 'src/shared.mjs').gaps.length === 0,
3497
+ '夹具前提失效:全小写写面重叠的一对被 [P] 判据要求标 [P]');
3498
+ const upperOverlapGaps = gapsFor('WRITE_FILES', 'src/shared.mjs', 'src/shared.mjs');
3499
+ assertTrue(upperOverlapGaps.gaps.length === 0,
3500
+ '混合大小写写面重叠的一对被 [P] 判据误报为「可并行却未标 [P]」——写面未知被当成写面不重叠: '
3501
+ + JSON.stringify(upperOverlapGaps.gaps));
3502
+ const upperDistinctGaps = gapsFor('WRITE_FILES', 'src/a.mjs', 'src/b.mjs');
3503
+ assertTrue(upperDistinctGaps.gaps.length === 1,
3504
+ '混合大小写写面互不重叠的一对未被 [P] 判据点名——判据应正常参与,不是把混合写法整片排除: '
3505
+ + JSON.stringify(upperDistinctGaps.gaps));
3506
+
3507
+ // 伪并行启发式:仅写测试产物的并行任务必须照样进集合(掉出去 = 告警静默消失),混有生产文件的
3508
+ // 并行任务不进集合(不是把混合写法整片标成伪并行)。
3509
+ const guardGates = await import('../lib/guard-gates.mjs');
3510
+ const testOnlyFor = (tag) => {
3511
+ const content = '# TASK\n\n## 任务清单\n\n'
3512
+ + '<task id="P-MIX" parallel="true" status="pending"><action>实现 P-MIX</action><' + tag
3513
+ + '>tests/test_mix.mjs</' + tag + '><verify>node --check tests/test_mix.mjs</verify></task>\n'
3514
+ + '<task id="P-PROD" parallel="true" status="pending"><action>实现 P-PROD</action><' + tag
3515
+ + '>src/mix.mjs\ntests/test_mix2.mjs</' + tag + '><verify>node --check src/mix.mjs</verify></task>\n';
3516
+ return guardGates.collectTestOnlyParallelIds({ taskContent: content, blocks: taskBlocks(content) });
3517
+ };
3518
+ assertTrue(JSON.stringify(testOnlyFor('write_files')) === JSON.stringify(['P-MIX']),
3519
+ '夹具前提失效:全小写写面的纯测试面并行任务未进伪并行集合('
3520
+ + JSON.stringify(testOnlyFor('write_files')) + ')');
3521
+ assertTrue(JSON.stringify(testOnlyFor('WRITE_FILES')) === JSON.stringify(['P-MIX']),
3522
+ '混合大小写写面的纯测试面并行任务掉出伪并行集合(元素名大小写无关,应照样告警): '
3523
+ + JSON.stringify(testOnlyFor('WRITE_FILES')));
3524
+
3525
+ // 行为面反向构造:把 task-graph 的写面取用改回大小写敏感的自持正则 ⇒ 同一份混合大小写夹具在
3526
+ // 变异体上重新「看不见重叠」,上面那两条行为断言因此确实对取用面敏感(不是恒绿)。
3527
+ const taskGraphRel = engineDefinitionModule('findParallelWriteConflicts')?.file;
3528
+ assertTrue(typeof taskGraphRel === 'string',
3529
+ '写写强判的定义面不唯一(反查失败): '
3530
+ + JSON.stringify(engineDefinitionHits('findParallelWriteConflicts')));
3531
+ const taskGraphText = faceTexts.get(taskGraphRel) ?? '';
3532
+ const faceAnchor = ' const writeFaces = taskWriteFilesById(text);';
3533
+ assertTrue(taskGraphText.includes(faceAnchor),
3534
+ '反向构造前提失效:' + taskGraphRel + ' 未按单源形态取用写面元素(锚已漂移)');
3535
+ const driftedFaceText = taskGraphText.replace(faceAnchor, [
3536
+ ' const writeFaces = new Map();',
3537
+ ' for (const probeBlock of allBlocks) {',
3538
+ ' const probeAttrs = taskOpeningAttrs(probeBlock);',
3539
+ ' const probeMatch = probeBlock.match(/<write_files>([\\s\\S]*?)<\\/write_files>/);',
3540
+ ' if (probeAttrs && probeAttrs.id && probeMatch) writeFaces.set(probeAttrs.id, probeMatch[1]);',
3541
+ ' }',
3542
+ ].join('\n'));
3543
+ assertTrue(driftedFaceText !== taskGraphText, '反向构造前提失效:变异未改变 ' + taskGraphRel);
3544
+ const driftedFaceModule = await import(inlineModuleUrl(driftedFaceText, taskGraphRel));
3545
+ const driftedUpper = await conflictsIn(driftedFaceModule, 'upper-parallel-drift', facePlan('WRITE_FILES', ' parallel="true"'));
3546
+ assertTrue(driftedUpper.writeConflicts.length === 0,
3547
+ '反向构造失效:写面取用改回大小写敏感后,混合大小写夹具仍被检出重叠——'
3548
+ + '该断言对取用面不敏感(' + JSON.stringify(driftedUpper.writeConflicts) + ')');
3549
+ }
3550
+ // ⑧ 运行根单源 + 隔离(行为面在前、结构锁在后):「这次调用把哪个目录当项目根」曾被两处各自
3551
+ // 回答——守卫族读 FLOW_COMET_RUN_ROOT,状态命令族直接用进程 cwd。用变量把实验指向临时目录
3552
+ // 时,状态命令仍在 cwd 仓库里建分支、把正在跑的 change 的 state 覆盖成新 change 的初始状态
3553
+ // (数据覆盖,靠备份才恢复)。本格先真跑命令证明「设了变量就只作用于那个根」,再用单源锁
3554
+ // 钉住「解析只许有一处实现」。
3555
+ {
3556
+ const rootsDir = path.join(dir, 'run-root-isolation');
3557
+ const cwdRepo = path.join(rootsDir, 'cwd-repo');
3558
+ const envRoot = path.join(rootsDir, 'env-root');
3559
+ const asRes = (res) => ({ status: res.status ?? 1, output: String(res.stdout ?? '') + String(res.stderr ?? '') });
3560
+ const gitOut = (repo, ...args) => {
3561
+ const res = spawnSync('git', args, { cwd: repo, encoding: 'utf8', timeout: 60000 });
3562
+ if ((res.status ?? 1) !== 0) throw new Error('夹具 git ' + args.join(' ') + ' 失败: ' + String(res.stderr ?? ''));
3563
+ return String(res.stdout ?? '').trim();
3564
+ };
3565
+ const stateFileAt = (root) => path.join(root, '.flow-comet', 'flow-comet-state.json');
3566
+ const stateBytesAt = (root) => fs.readFileSync(stateFileAt(root));
3567
+ const stateAt = (root) => JSON.parse(fs.readFileSync(stateFileAt(root), 'utf8'));
3568
+ // 两个真实 git 仓库:cwd 侧带活跃 change(state + 工件 + 声明标记),变量侧是空仓库。协议副本各放
3569
+ // 一份——受保护读取要求协议位于所属运行根内,两侧各有一份才能分别作真实命令的输入。
3570
+ for (const repo of [cwdRepo, envRoot]) {
3571
+ fs.mkdirSync(path.join(repo, 'reference'), { recursive: true });
3572
+ fs.copyFileSync(scenarioProtocolPath(dir), path.join(repo, 'reference', 'workflow-protocol.json'));
3573
+ gitOut(repo, 'init', '-q');
3574
+ gitOut(repo, '-c', 'user.name=fixture', '-c', 'user.email=fixture@example.com',
3575
+ 'commit', '--allow-empty', '-m', 'init');
3576
+ }
3577
+ writeState(cwdRepo, {
3578
+ ...baseState('open'),
3579
+ activeChange: 'live-change',
3580
+ newChange: true,
3581
+ status: 'running',
3582
+ enteredNodes: ['open'],
3583
+ evidence: {
3584
+ open: { summary: 'live' },
3585
+ 'subagent-execute': {
3586
+ handoffRequests: { 'LIVE-01': { description: 'live', requestedAt: '2026-08-01T00:00:00.000Z' } },
3587
+ },
3588
+ },
3589
+ });
3590
+ writeFile(cwdRepo, '.specs/live-change/CHANGE.md', '# CHANGE\n\n## Why(为什么做)\nlive\n');
3591
+ writeNodeDeclarationMarkers(cwdRepo, 'open', { changeId: 'live-change' });
3592
+ const cwdStateBefore = stateBytesAt(cwdRepo);
3593
+ const cwdHeadBefore = gitOut(cwdRepo, 'rev-parse', 'HEAD');
3594
+ const cwdBranchBefore = gitOut(cwdRepo, 'rev-parse', '--abbrev-ref', 'HEAD');
3595
+ // 状态命令一律以 cwd = 仓库、运行根 = 变量指向的那个仓库发起(真实隔离场景的形态)。
3596
+ const inEnvRoot = (script, args) => asRes(spawnSync(process.execPath, [script, ...args], {
3597
+ cwd: cwdRepo,
3598
+ env: {
3599
+ ...process.env,
3600
+ FLOW_COMET_RUN_ROOT: envRoot,
3601
+ // 协议取运行根相对形态:同一个调用里,命令字面不必随根变化——变的是「哪一个是根」。
3602
+ FLOW_COMET_PROTOCOL: 'reference/workflow-protocol.json',
3603
+ },
3604
+ encoding: 'utf8',
3605
+ timeout: 60000,
3606
+ }));
3607
+
3608
+ // ① init:state 落点与分支判定/创建都跟运行根走
3609
+ const initIsolated = inEnvRoot(STATE, ['init', 'fresh-change']);
3610
+ assertExit(initIsolated, 0);
3611
+ assertOut(initIsolated, 'Initialized: fresh-change');
3612
+ assertTrue(fs.existsSync(stateFileAt(envRoot)),
3613
+ '设置 FLOW_COMET_RUN_ROOT 后 init 未把 state 写到该根(写到了进程 cwd)——临时实验会覆盖真实 change 的 state');
3614
+ assertTrue(stateAt(envRoot).activeChange === 'fresh-change',
3615
+ '运行根下的 state 未记录新 change: ' + JSON.stringify(stateAt(envRoot).activeChange));
3616
+ assertTrue(fs.existsSync(path.join(envRoot, '.specs', 'fresh-change')), 'init 未在运行根下建 change 目录');
3617
+ assertTrue(gitOut(envRoot, 'rev-parse', '--abbrev-ref', 'HEAD') === 'change/fresh-change',
3618
+ '分支未按运行根创建/切换(HEAD = ' + gitOut(envRoot, 'rev-parse', '--abbrev-ref', 'HEAD') + ')');
3619
+
3620
+ // ② cwd 侧:state 字节、HEAD、当前分支零改动;也不得在 cwd 仓库新建同名分支
3621
+ assertTrue(stateBytesAt(cwdRepo).equals(cwdStateBefore),
3622
+ 'cwd 仓库的 state 字节被改写——设置运行根后状态命令仍写到了进程 cwd');
3623
+ assertTrue(gitOut(cwdRepo, 'rev-parse', 'HEAD') === cwdHeadBefore, 'cwd 仓库的 HEAD 被移动');
3624
+ assertTrue(gitOut(cwdRepo, 'rev-parse', '--abbrev-ref', 'HEAD') === cwdBranchBefore,
3625
+ 'cwd 仓库的当前分支被切换: ' + gitOut(cwdRepo, 'rev-parse', '--abbrev-ref', 'HEAD'));
3626
+ assertTrue(gitOut(cwdRepo, 'branch', '--list', 'change/fresh-change') === '',
3627
+ 'cwd 仓库里出现了本该建在运行根的分支 change/fresh-change');
3628
+
3629
+ // ③ status / record:读写的都是运行根那一个 state
3630
+ const statusIsolated = inEnvRoot(STATE, ['status']);
3631
+ assertTrue(statusIsolated.status === 0, 'status 应成功: ' + statusIsolated.output);
3632
+ assertOut(statusIsolated, '"change": "fresh-change"');
3633
+ assertNotOut(statusIsolated, 'live-change');
3634
+ assertTrue(stateBytesAt(cwdRepo).equals(cwdStateBefore), 'status 改写了 cwd 仓库的 state');
3635
+ // record 目标取零模板节点:声明门会按节点模板清单核对标记,本格不引入模板面——只要标记在场,
3636
+ // 记录结果就只取决于「读到的是哪一个 state」。
3637
+ writeNodeDeclarationMarkers(envRoot, 'verify', { changeId: 'fresh-change' });
3638
+ const recordIsolated = inEnvRoot(STATE, ['record', 'verify', '{"summary":"run-root record"}']);
3639
+ assertExit(recordIsolated, 0);
3640
+ assertOut(recordIsolated, 'EVIDENCE: verify');
3641
+ assertTrue(stateAt(envRoot).evidence?.verify?.summary === 'run-root record',
3642
+ 'record 未写入运行根的 state: ' + JSON.stringify(stateAt(envRoot).evidence));
3643
+ assertTrue(stateBytesAt(cwdRepo).equals(cwdStateBefore), 'record 改写了 cwd 仓库的 state');
3644
+
3645
+ // ④ 委托入口(第三个取用面):status 只读,用它证明它也认同一处解析——两侧 state 各带一个可
3646
+ // 区分的活跃 change 与委托记录,读错根会立刻显形。
3647
+ const handoffIsolated = inEnvRoot(HANDOFF, ['status']);
3648
+ assertTrue(handoffIsolated.status === 0, 'handoff status 应成功: ' + handoffIsolated.output);
3649
+ assertOut(handoffIsolated, '"activeChange": "fresh-change"');
3650
+ assertNotOut(handoffIsolated, 'LIVE-01');
3651
+
3652
+ // ⑤ 反向构造(同一夹具、去掉变量):解析退回进程 cwd —— 上面「cwd 零改动」三条断言正是会红的
3653
+ // 那三条;这里直接证明夹具确实能把 cwd 侧改写照出来(不是恒绿)。
3654
+ const envRootStateBefore = stateBytesAt(envRoot);
3655
+ const noRootInit = asRes(spawnSync(process.execPath, [STATE, 'init', 'cwd-change'], {
3656
+ cwd: cwdRepo,
3657
+ env: {
3658
+ ...process.env,
3659
+ FLOW_COMET_RUN_ROOT: '',
3660
+ FLOW_COMET_PROTOCOL: 'reference/workflow-protocol.json',
3661
+ },
3662
+ encoding: 'utf8',
3663
+ timeout: 60000,
3664
+ }));
3665
+ assertExit(noRootInit, 0);
3666
+ assertTrue(stateAt(cwdRepo).activeChange === 'cwd-change',
3667
+ '反向构造前提失效:无变量时 init 未写回 cwd 仓库,上面「cwd 零改动」断言无判别力');
3668
+ assertTrue(gitOut(cwdRepo, 'rev-parse', '--abbrev-ref', 'HEAD') === 'change/cwd-change',
3669
+ '反向构造前提失效:无变量时未在 cwd 仓库建分支');
3670
+ assertTrue(stateBytesAt(envRoot).equals(envRootStateBefore), '无变量的那次 init 改写了运行根的 state');
3671
+
3672
+ // ⑥ 单源结构锁:运行根解析只许一处实现,状态命令族两个入口与守卫族运行根模块一律具名取用。
3673
+ // 反向构造:摘 import ⇒ 「未从」;注入第二份定义 ⇒ 被点名;原样 ⇒ 复绿。
3674
+ const runRootSymbol = 'resolveRunRoot';
3675
+ const runRootModule = engineDefinitionModule(runRootSymbol);
3676
+ assertTrue(runRootModule !== null,
3677
+ '运行根解析的定义面应恰一处: ' + JSON.stringify(engineDefinitionHits(runRootSymbol)));
3678
+ const runRootTexts = engineScriptTexts();
3679
+ const runRootProblems = singleSourceImportProblems({
3680
+ symbol: runRootSymbol, sourceRel: runRootModule.file, texts: runRootTexts,
3681
+ });
3682
+ assertTrue(runRootProblems.length === 0, '运行根单源违规: ' + runRootProblems.join(' | '));
3683
+ const runRootProbes = [];
3684
+ for (const consumerRel of ['workflow-state.mjs', 'workflow-handoff.mjs', 'lib/guard-state-io.mjs']) {
3685
+ const consumerText = runRootTexts.get(consumerRel) ?? '';
3686
+ if (!new RegExp('\\b' + runRootSymbol + '\\b', 'u').test(engineCodeText(consumerText))) {
3687
+ runRootProbes.push(consumerRel + ' 不再取用单一来源的运行根解析');
3688
+ continue;
3689
+ }
3690
+ const droppedText = dropNamedImport(consumerText, runRootSymbol);
3691
+ if (droppedText === consumerText) {
3692
+ runRootProbes.push(consumerRel + ' 的 import 摘不动(反向构造会退化为前提失效)');
3693
+ continue;
3694
+ }
3695
+ const droppedProblems = singleSourceImportProblems({
3696
+ symbol: runRootSymbol, sourceRel: runRootModule.file,
3697
+ texts: new Map(runRootTexts).set(consumerRel, droppedText),
3698
+ });
3699
+ if (!droppedProblems.some((problem) => problem.includes(consumerRel) && problem.includes('未从'))) {
3700
+ runRootProbes.push(consumerRel + ' 摘掉单源取用后未被取用面锁点名');
3701
+ }
3702
+ }
3703
+ const injectedProblems = singleSourceImportProblems({
3704
+ symbol: runRootSymbol, sourceRel: runRootModule.file,
3705
+ texts: new Map(runRootTexts).set('lib/probe-run-root.mjs',
3706
+ 'export function ' + runRootSymbol + '() { return process.cwd(); }\n'),
3707
+ });
3708
+ if (!injectedProblems.some((problem) => problem.includes('lib/probe-run-root.mjs') && problem.includes('自带第二份'))) {
3709
+ runRootProbes.push('第二份实现注入后未被单源锁点名(锁对新增实现面没有判别力)');
3710
+ }
3711
+ assertTrue(runRootProbes.length === 0, '运行根单源锁反向构造失败: ' + runRootProbes.join(' | '));
3712
+ }
3713
+ },
3714
+ },
3715
+
3716
+ // TA-22 · 版本漂移在发版期被发现(AC-22)——登记表记录的模板指纹与锁定快照不一致 → 漂移可判;
3717
+ // 一致时零漂移。反向构造:改写一个字节后 drift 必为 true(同一判据函数)。
3718
+ // 指纹判据的输入必须是模板真迹:没有 vendored 模板的检出(CI 全新检出)里夹具按登记表合成段形,
3719
+ // 合成文本的 sha 与登记表锁定的 sha 天然不可比——此时「一致 → 无漂移」无从执行,不得当作通过
3720
+ // (未验证 ≠ 通过),也不得据此断言漂移(登记表并没有错)。真迹在场才全强度执行,否则可见 SKIP。
3721
+ {
3722
+ name: 'TA-22 指纹漂移:模板与锁定快照一致判无漂移,改一字节判漂移(模板非真迹时显式 SKIP)',
3723
+ run: async (dir) => {
3724
+ const skeleton = await import('../lib/guard-artifact-skeleton.mjs');
3725
+ // 骨架按项目根缓存——漂移对比必须落在另一个项目根上,否则读到的是缓存值(判据空转)
3726
+ const cleanRoot = path.join(dir, 'clean');
3727
+ const driftRoot = path.join(dir, 'drift');
3728
+ const realTemplateRel = docRel('SUMMARY');
3729
+ const realTemplatePresent = fs.existsSync(path.join(REPO_ROOT, ...realTemplateRel.split('/')));
3730
+ // ① 一致 → drift === false
3731
+ writeFile(cleanRoot, realTemplateRel, templateFixtureText('SUMMARY'));
3732
+ const clean = await skeleton.templateFingerprint('SUMMARY', { runRoot: cleanRoot });
3733
+ assertTrue(clean.derived === true, '模板在场时骨架应可派生(derived=true),实际: ' + JSON.stringify(clean));
3734
+ if (realTemplatePresent) {
3735
+ assertTrue(clean.drift === false, '模板与登记表指纹一致时应判无漂移,实际: ' + JSON.stringify(clean));
3736
+ // ② 反向构造:改一个字节 → drift === true
3737
+ writeFile(driftRoot, realTemplateRel, templateFixtureText('SUMMARY') + '\n漂移探针。\n');
3738
+ const drifted = await skeleton.templateFingerprint('SUMMARY', { runRoot: driftRoot });
3739
+ assertTrue(drifted.drift === true, '模板被改写后应判漂移,实际: ' + JSON.stringify(drifted));
3740
+ } else {
3741
+ console.log('SKIP: TA-22 的指纹漂移判据(模板非真迹:本检出无 vendored ' + realTemplateRel
3742
+ + ',夹具按登记表合成段形,实测 sha ' + clean.actualSha256 + ' 与登记表锁定 '
3743
+ + clean.recordedSha256 + ' 不可比)——本次检出未执行「一致 → 无漂移 / 改一字节 → 漂移」,'
3744
+ + '请在权威源检出重跑本套件(未验证 ≠ 通过)');
3745
+ }
3746
+ // ②b 指纹归一化:BOM / 行尾是检出噪音——同一内容的 LF 形态与 BOM+CRLF 形态必须同指纹
3747
+ // (归一化由骨架模块单实现)。反向构造:内容真变一行 → 指纹必不同,证明「同值」不是恒等判据。
3748
+ const lfText = templateFixtureText('SUMMARY').replace(/^\uFEFF/u, '').replace(/\r\n?/gu, '\n');
3749
+ const bomCrlfText = '\uFEFF' + lfText.replace(/\n/gu, '\r\n');
3750
+ assertTrue(bomCrlfText.startsWith('\uFEFF') && bomCrlfText.includes('\r\n'),
3751
+ '夹具前提不成立:BOM+CRLF 形态未构造出来');
3752
+ const crlfRoot = path.join(dir, 'crlf');
3753
+ writeFile(crlfRoot, docRel('SUMMARY'), bomCrlfText);
3754
+ const byCrlf = await skeleton.templateFingerprint('SUMMARY', { runRoot: crlfRoot });
3755
+ assertTrue(byCrlf.derived === true, 'BOM+CRLF 模板应仍可派生,实际: ' + JSON.stringify(byCrlf));
3756
+ assertTrue(byCrlf.actualSha256 === clean.actualSha256,
3757
+ 'BOM+CRLF 与 LF 形态应同指纹(行尾/BOM 不改变指纹),实际: '
3758
+ + byCrlf.actualSha256 + ' vs ' + clean.actualSha256);
3759
+ // 反向构造(判别力):同一构造再加一行 → 指纹必不同(否则「同值」可能只是判据恒等)
3760
+ const mutatedRoot = path.join(dir, 'crlf-mutated');
3761
+ writeFile(mutatedRoot, docRel('SUMMARY'), bomCrlfText + '\n归一化探针。\n');
3762
+ const byMutated = await skeleton.templateFingerprint('SUMMARY', { runRoot: mutatedRoot });
3763
+ assertTrue(byMutated.actualSha256 !== clean.actualSha256,
3764
+ '内容多一行后指纹必须不同(归一化不得吞掉内容),实际仍为 ' + byMutated.actualSha256);
3765
+
3766
+ // ③ 关外键:登记表没有的模板键 → 显式未知(不静默当作「无漂移」)
3767
+ const unknown = await skeleton.templateFingerprint('NO-SUCH-TEMPLATE', { runRoot: cleanRoot });
3768
+ assertTrue(unknown.derived === false && unknown.reason === 'unknown-key',
3769
+ '未知模板键应显式标注 unknown-key,实际: ' + JSON.stringify(unknown));
3770
+ // ④ 发版期检查接线:CI 已包含登记表指纹比对步骤。CI workflow 属主仓分发面(安装副本无
3771
+ // `.github/`):结构性缺席时输出可见 SKIP(未验证 ≠ 通过),不让缺席把整条场景判红。
3772
+ const ciRel = '.github/workflows/ci.yml';
3773
+ if (!repoFileExists(ciRel)) {
3774
+ console.log('SKIP: TA-22 的发版期检查接线面(' + ciRel + ' 不在本检出)——本次检出未校验 CI 是否比对'
3775
+ + '登记表指纹,请在权威源检出重跑本套件(未验证 ≠ 通过)');
3776
+ } else {
3777
+ assertTrue(repoFileText(ciRel).includes('artifact-templates.json'),
3778
+ '发版期检查应比对登记表指纹(CI 需引用 reference/artifact-templates.json)');
3779
+ }
3780
+
3781
+ // ⑤ 登记表与模板分叉(正例):登记表登记的段在模板里不存在(模板回退 / 上游删段)⇒ 按模板为准忽略
3782
+ // 并**可见 WARN**,不阻断。旧实现把这批登记项静默丢弃(`registered` 标志算出后无消费方),
3783
+ // 登记表滞后因此不可见。单位面看骨架把这类段单独报出;端到端看门禁真实发声且不阻断。
3784
+ const staleRoot = path.join(dir, 'stale');
3785
+ writeTemplateFixtureOmittingSection(staleRoot, 'CHANGE', '视觉调性');
3786
+ const stale = await skeleton.buildSkeleton('CHANGE', { runRoot: staleRoot });
3787
+ const toneEntry = (docEntry('CHANGE').sections ?? []).find((section) => section.name.includes('视觉调性'));
3788
+ assertTrue(toneEntry !== undefined, '登记表 CHANGE 缺「视觉调性」段(夹具前提不成立)');
3789
+ assertTrue(stale.derived === true, '模板仍在场(只少一段)时应可派生,实际: ' + JSON.stringify(stale));
3790
+ assertTrue((stale.registryOnlySections ?? []).includes(toneEntry.name),
3791
+ '登记表多出的段应被单独报出(不是静默丢弃),实际: ' + JSON.stringify(stale.registryOnlySections));
3792
+ resetFixture(dir);
3793
+ writeTemplateFixtureOmittingSection(dir, 'CHANGE', '视觉调性');
3794
+ writeFile(dir, CHANGE_DIR + '/CHANGE.md', renderDoc('CHANGE'));
3795
+ writeFile(dir, CHANGE_DIR + '/REQUIREMENT.md', renderDoc('REQUIREMENT'));
3796
+ const openState = () => {
3797
+ const next = newChangeState('open');
3798
+ next.evidence.open = { summary: 'intake complete' };
3799
+ return next;
3800
+ };
3801
+ writeState(dir, openState());
3802
+ writeNodeDeclarationMarkers(dir, 'open');
3803
+ const warned = exitNode(dir, 'open');
3804
+ assertExit(warned, 0);
3805
+ assertOut(warned, 'TEMPLATE-REGISTRY WARN');
3806
+ assertOut(warned, '视觉调性');
3807
+ assertNotOut(warned, 'BLOCKED');
3808
+
3809
+ // ⑥ 登记表与模板分叉(反例):登记表与模板一致 ⇒ 同一门禁不得发声(WARN 是滞后信号,不是常驻噪音,
3810
+ // 否则真信号会被自己淹没)。
3811
+ setupOpen(dir);
3812
+ const fresh = await skeleton.buildSkeleton('CHANGE', { runRoot: dir });
3813
+ assertTrue(fresh.registryOnlySections.length === 0,
3814
+ '登记表与模板一致时不得报「多出的段」,实际: ' + JSON.stringify(fresh.registryOnlySections));
3815
+ const quiet = exitNode(dir, 'open');
3816
+ assertExit(quiet, 0);
3817
+ assertNotOut(quiet, 'TEMPLATE-REGISTRY WARN');
3818
+ },
3819
+ },
3820
+
3821
+ // TA-23 · 覆盖声明与同步面(AC-23)——7 册「必填段清单」两栏表与引擎一致;14 册锚句在场;
3822
+ // Guardrails 表中被新门禁覆盖的行不再声称「guard 不校验」;verify 册 UAT 的「验收结果」改为仅存在性;
3823
+ // 入口册覆盖声明四要素齐备。全部为仓库级文本断言,逐条带变异探针。
3824
+ {
3825
+ name: 'TA-23 覆盖声明与同步面:7 册两栏表、14 册锚句、Guardrails 同步、UAT 仅存在性',
3826
+ run: () => {
3827
+ const twoColumnBooks = [
3828
+ 'flow-comet-open', 'flow-comet-design', 'flow-comet-plan', 'flow-comet-execute',
3829
+ 'flow-comet-review', 'flow-comet-verify', 'flow-comet-subagent-execute',
3830
+ ];
3831
+ const books = new Map();
3832
+ for (const name of twoColumnBooks) books.set(name + '/SKILL.md', skillBookText(name));
3833
+ books.set('flow-comet/SKILL.md', skillBookText('flow-comet'));
3834
+ books.set('flow-comet-review/SKILL.md', skillBookText('flow-comet-review'));
3835
+ books.set('flow-comet-verify/SKILL.md', skillBookText('flow-comet-verify'));
3836
+ books.set('flow-comet-archive/SKILL.md', skillBookText('flow-comet-archive'));
3837
+
3838
+ const rules = [];
3839
+ for (const name of twoColumnBooks) {
3840
+ rules.push({
3841
+ rel: name + '/SKILL.md',
3842
+ label: '两栏表(左无条件段 / 右条件段与增量段)',
3843
+ include: ['无条件段', '增量段', 'flow-kit/templates/'],
3844
+ });
3845
+ }
3846
+ rules.push({
3847
+ rel: 'flow-comet/SKILL.md',
3848
+ label: '覆盖声明四要素',
3849
+ include: ['只读', '不采用', '沿用', '以本节为准'],
3850
+ });
3851
+ // phase-gated 反转句:四要素在场不等于方向反转还在——「本仓是 phase-gated」对抗上游 artifact-first 的那句是
3852
+ // 覆盖声明的实质(既引用上游又表态取向),抽掉它四要素仍全在,故单独锚。
3853
+ rules.push({
3854
+ rel: 'flow-comet/SKILL.md',
3855
+ label: 'phase-gated 反转句',
3856
+ include: ['artifact-first', '本仓是 **phase-gated**:8 节点 entry/exit 门'],
3857
+ });
3858
+ // 方向反转之外还须说明阶段门与工件门的关系:只有「有门」说不出门守的是什么,抽掉该句入口册
3859
+ // 读起来就像拿阶段门替代工件(「阶段门 = 工件检查的替代品」正是本仓要挡的过度解读)。
3860
+ rules.push({
3861
+ rel: 'flow-comet/SKILL.md',
3862
+ label: '阶段门与工件门的关系句',
3863
+ include: ['阶段门是工件门的加强,不是替代'],
3864
+ });
3865
+ rules.push({
3866
+ rel: 'flow-comet-review/SKILL.md',
3867
+ label: 'Guardrails 行与新门禁同步',
3868
+ include: ['test-pyramid-checked'],
3869
+ exclude: ['test-pyramid-checked` | TEST.md 5-round completeness verified | 执行纪律(review 把关),guard 不校验'],
3870
+ });
3871
+ rules.push({
3872
+ rel: 'flow-comet-verify/SKILL.md',
3873
+ label: 'Guardrails 行与新门禁同步 + UAT 仅存在性',
3874
+ include: ['lessons-nominated', '仅存在性'],
3875
+ });
3876
+ rules.push({
3877
+ rel: 'flow-comet-archive/SKILL.md',
3878
+ label: 'Guardrails 行与新门禁同步',
3879
+ include: ['changelog-updated'],
3880
+ exclude: ['changelog-updated` | CHANGELOG.md has new entry | 执行纪律(review 把关),guard 不校验'],
3881
+ });
3882
+
3883
+ const problems = textRuleProblems(books, rules);
3884
+ // 变异探针:正向(抽掉目标文字 ⇒ 必报)与反向(补上缺失文字 ⇒ 不再报,证判据不恒真)。
3885
+ // 预期片段一律取报文里的成句形态(缺「X」/ 仍含旧表述),避免与规则标签串混淆。
3886
+ assertProbesDiscriminate(problems, books, rules, [
3887
+ ['抽掉两栏表左栏', 'flow-comet-open/SKILL.md', (text) => text.replace(/无条件段/g, '必填段'), '缺「无条件段」'],
3888
+ ['抽掉两栏表右栏', 'flow-comet-design/SKILL.md', (text) => text.replace(/增量段/g, '追加段'), '缺「增量段」'],
3889
+ ['补上两栏表', 'flow-comet-plan/SKILL.md',
3890
+ (text) => text + '\n| 左栏:无条件段 | 右栏:条件段 / 增量段(flow-kit/templates/ 派生) |\n', '缺「无条件段」', false],
3891
+ ['抽掉覆盖声明要素', 'flow-comet/SKILL.md', (text) => text.replace(/以本节为准/g, ''), '缺「以本节为准」'],
3892
+ ['补上覆盖声明要素', 'flow-comet/SKILL.md', (text) => text + '\n与本册冲突时以本节为准。\n沿用项见上表。\n', '缺「以本节为准」', false],
3893
+ ['抽掉 phase-gated 反转句', 'flow-comet/SKILL.md',
3894
+ (text) => text.replace('本仓是 **phase-gated**:8 节点 entry/exit 门', '本仓方向与上游一致'),
3895
+ '缺「本仓是 **phase-gated**:8 节点 entry/exit 门」'],
3896
+ ['抽掉阶段门关系句', 'flow-comet/SKILL.md',
3897
+ (text) => text.replace('阶段门是工件门的加强,不是替代', ''),
3898
+ '缺「阶段门是工件门的加强,不是替代」'],
3899
+ ['Guardrails 行改回旧表述', 'flow-comet-review/SKILL.md',
3900
+ (text) => text.replace('test-pyramid-checked',
3901
+ 'test-pyramid-checked` | TEST.md 5-round completeness verified | 执行纪律(review 把关),guard 不校验'), 'guard 不校验'],
3902
+ ['补上 UAT 仅存在性', 'flow-comet-verify/SKILL.md',
3903
+ (text) => text + '\nUAT.md 的 `## 验收结果` 段仅存在性校验。\n', '缺「仅存在性」', false],
3904
+ ]);
3905
+ if (problems.length > 0) throw new Error('覆盖声明与同步面不符: ' + problems.join('; '));
3906
+ },
3907
+ },
3908
+
3909
+ // TA-24 · 公开面不再说假话(AC-24)——5 对双语公开文本的覆盖表述与实际门禁范围一致:不再有
3910
+ // 「完全继承 / 段名在运行时派生」这类 overclaim;机制册的「哪些节点查段名」表覆盖全部出口;
3911
+ // 故障排查给出两阶段报错指引;工件保真条点明本仓增量段。
3912
+ //
3913
+ // 缺席的**两种读法**(判据面形态先判,再判内容):本检出带公开面(docs/、CONTRIBUTING.md 或
3914
+ // .github/ 任一在场)时,该面任何一份文档缺席都是判据失效——「两份机制册都被删」= 公开面机制
3915
+ // 文档不在检出面,判红,不能只落一条 SKIP;只有整份载体俱缺(安装副本只带技能树、npm 包按 files
3916
+ // 白名单不含 docs/ 与 CONTRIBUTING / .github)才是合法的「本检出没有这一面」,此时输出可见 SKIP
3917
+ // 并明确写「本次未校验」,仍不算通过。
3918
+ {
3919
+ name: 'TA-24 公开面口径:5 对双语去除 overclaim,机制表覆盖全出口,缺席即红(整面缺席才 SKIP)',
3920
+ run: async (dir) => {
3921
+ const pairs = [
3922
+ ['README.md', 'README-zh.md'],
3923
+ ['CONTRIBUTING.md', 'CONTRIBUTING-zh.md'],
3924
+ ['docs/USAGE.md', 'docs/USAGE-zh.md'],
3925
+ ['docs/MECHANISM.md', 'docs/MECHANISM-zh.md'],
3926
+ ['docs/TROUBLESHOOTING.md', 'docs/TROUBLESHOOTING-zh.md'],
3927
+ ];
3928
+ // 形态判据先于内容判据:公开面载体整份缺席 = 本检出不含公开文档(安装副本 / npm 包形态),
3929
+ // 整面输出一条可见 SKIP——不是「已校验」,也不把合法形态判红。判据本体走 lib 的
3930
+ // publicFaceDocsAbsent(与底部自检、场景 105 同一实现):本场景不再自持第二套(曾按
3931
+ // docs/authority-map.json 在不在分流);单看 docs/ 也不够——它被裁掉而 CONTRIBUTING.md /
3932
+ // .github/ 还在时,这五对文档的判据会整块变成 SKIP。
3933
+ if (publicFaceDocsAbsent(REPO_ROOT)) {
3934
+ console.log('SKIP: TA-24 的公开面口径判据(此形态不含公开文档:docs/、CONTRIBUTING.md 与 .github/'
3935
+ + ' 都不在本检出)——本次检出未校验 5 对双语公开文档的 overclaim / 机制表 / 排查指引口径,'
3936
+ + '请在权威源检出重跑本套件(未验证 ≠ 通过)');
3937
+ return;
3938
+ }
3939
+ // 形态分派自身的常驻判别力锚:临时根上驱动同一判定,分派对错不再只能靠「在包形态里整跑一次
3940
+ // 套件」才知道。夹具的「完整形态」从本检出的公开面真迹复制,故只在声明了公开面的检出上跑。
3941
+ await assertPublicFaceSelfCheckShapes(dir);
3942
+ // 判据面完整在册(缺席用 null 占位而不是从集合里删掉):缺席由下面的缺席判据逐份点名,
3943
+ // 「少了哪份文件」因此是**判据事实**,不是可以静默缩小的受检面。
3944
+ const docs = new Map();
3945
+ for (const [en, zh] of pairs) {
3946
+ for (const rel of [en, zh]) docs.set(rel, repoFileExists(rel) ? repoFileText(rel) : null);
3947
+ }
3948
+ const problems = publicFaceAbsenceProblems(docs);
3949
+ // 缺席判据的变异探针(同一实现、纯内存):抽掉两份机制册 ⇒ 必须报「不在检出面」。修复前
3950
+ // 「两份机制册都被删」只落一条 SKIP(缺席被读成未校验),公开面机制文档整份消失而套件仍绿。
3951
+ // 缺失在判据面里表现为「键在场、文本为 null」(与真实路径同一形态:文件不在 ≠ 键被删)。
3952
+ const shrunk = new Map(docs);
3953
+ for (const rel of ['docs/MECHANISM.md', 'docs/MECHANISM-zh.md']) shrunk.set(rel, null);
3954
+ const absenceProbe = publicFaceAbsenceProblems(shrunk);
3955
+ if (absenceProbe.length === 0 || !absenceProbe[0].includes('docs/MECHANISM.md')) {
3956
+ problems.push('反向构造判别力缺失(抽掉两份机制册未被判「不在检出面」)');
3957
+ }
3958
+ const rules = [
3959
+ { rel: 'README-zh.md', label: '去 overclaim(继承表述)', exclude: ['完全继承'] },
3960
+ { rel: 'README.md', label: '去 overclaim(继承表述)', exclude: ['inherits its artifacts and rules'] },
3961
+ { rel: 'CONTRIBUTING-zh.md', label: '段名来源改为上游模板 + 本仓增量', exclude: ['段名在运行时从 vendored 模板派生'] },
3962
+ { rel: 'docs/USAGE-zh.md', label: '工件保真条点明增量段', include: ['增量段'] },
3963
+ { rel: 'docs/TROUBLESHOOTING-zh.md', label: '两阶段报错指引', include: ['两阶段'] },
3964
+ { rel: 'docs/MECHANISM-zh.md', label: '机制表覆盖全出口', include: ['段名是否符合模板'] },
3965
+ ];
3966
+ // 内容判据跑全表(不再按「本检出有没有这份文件」缩小):缺席的文档在规则面里报「不在判据面内」,
3967
+ // 缺席本身已由上方缺席判据逐份点名——受检面不因文件消失而静默变窄。
3968
+ problems.push(...textRuleProblems(docs, rules));
3969
+ // 机制行的出口清单覆盖:行按结构定位(机制表里适用面最宽的那行),8 个出口一个都不能少。
3970
+ problems.push(...mechanismRowProblems(docs));
3971
+ // 机制行判据自己的变异探针(同一函数驱动)——词形定位的失效形态与「判据恒真」各配一条:
3972
+ // 正锚:把「含『段名』且提到 plan」的段落插到机制表之前,结构定位不得被抢位;
3973
+ // 反向:从机制行抽掉一个出口 ⇒ 必须报「未覆盖出口」。
3974
+ const zhMechanism = docs.get('docs/MECHANISM-zh.md');
3975
+ if (typeof zhMechanism === 'string') {
3976
+ const hijack = '结构预检只跑结构那一半:缺 H2 段只按类别报计数,具体段名留到节点收尾的完整 `exit`;'
3977
+ + '`plan` 节点的任务块另查七字段。';
3978
+ const hijacked = hijack + '\n' + zhMechanism;
3979
+ // 正锚比对「定位到哪一行」,不比对报文——否则真实断言先红时探针会被遮蔽,看不出判别力。
3980
+ const beforeRow = findMechanismRow(zhMechanism);
3981
+ const afterRow = findMechanismRow(hijacked);
3982
+ if (legacyMechanismLine(hijacked) === legacyMechanismLine(zhMechanism)) {
3983
+ problems.push('正锚构造前提失效(段名段落未被词形判据抢位)');
3984
+ } else if (beforeRow === null || afterRow === null || afterRow.index !== beforeRow.index + 1) {
3985
+ problems.push('机制行定位被抢位:插入的「段名 + plan」段落改写了定位结果');
3986
+ }
3987
+ if (beforeRow === null) {
3988
+ problems.push('反向构造前提失效(未定位到机制行)');
3989
+ } else {
3990
+ const lines = zhMechanism.split(/\r?\n/);
3991
+ lines[beforeRow.index] = lines[beforeRow.index].replace('`execute`', '');
3992
+ const gutted = lines.join('\n');
3993
+ if (gutted === zhMechanism) {
3994
+ problems.push('反向构造前提失效(机制行未发生变化)');
3995
+ } else if (!mechanismRowProblems(new Map(docs).set('docs/MECHANISM-zh.md', gutted))
3996
+ .some((problem) => problem.includes('未覆盖出口 execute'))) {
3997
+ problems.push('反向构造判别力缺失(抽掉出口 execute 未被判违规)');
3998
+ }
3999
+ }
4000
+ }
4001
+ // 变异探针:正向(overclaim 写回 / 口径改回旧形态)与反向(补上缺失口径 ⇒ 不再报)。
4002
+ // 文本探针只在该文档真实在场时执行:缺席的文档无法被「改写」,其缺席已由缺席判据判红。
4003
+ const activeProbes = [
4004
+ ['overclaim 写回', 'README-zh.md', (text) => text + '\n工件与规则完全继承。\n', '仍含旧表述「完全继承」'],
4005
+ ['段名来源改回运行时派生', 'CONTRIBUTING-zh.md',
4006
+ (text) => text + '\n段名在运行时从 vendored 模板派生。\n', '仍含旧表述「段名在运行时从 vendored 模板派生」'],
4007
+ ['补上两阶段指引', 'docs/TROUBLESHOOTING-zh.md',
4008
+ (text) => text + '\n## 缺段报错(两阶段)\n\n首次只给模板路径与类别计数,再犯才列段名。\n', '缺「两阶段」', false],
4009
+ ['补上增量段口径', 'docs/USAGE-zh.md',
4010
+ (text) => text + '\n工件保真 = 上游模板段 + 本仓增量段。\n', '缺「增量段」', false],
4011
+ ].filter(([, rel]) => typeof docs.get(rel) === 'string');
4012
+ assertProbesDiscriminate(problems, docs, rules, activeProbes);
4013
+ if (problems.length > 0) throw new Error('公开面口径不符: ' + problems.join('; '));
4014
+ },
4015
+ },
4016
+
4017
+ // TA-25 · 治理落盘(AC-25)——4 条 ADR 在场;已锁决策 / 定义更新;机制册新增条目;发布清单增
4018
+ // 模板指纹检查项;主仓指导文件的 guard 校验描述同步;债务账本登记本批债务。
4019
+ // 维护者面(docs/internal、.specs)整组缺席时输出可见 SKIP(未验证 ≠ 通过)。
4020
+ {
4021
+ name: 'TA-25 治理落盘:4 条 ADR + 已锁决策/机制册/发布清单/指导文件同步 + 债务登记',
4022
+ run: () => {
4023
+ const problems = [];
4024
+ // 治理落盘面 = 维护者主树面(docs/internal/ + CLAUDE.md + .specs 流程工件面)。安装副本
4025
+ // 结构性缺席该面时输出一条可见 SKIP(未验证 ≠ 通过):载体自带的 CONTEXT / ADR 与本仓治理
4026
+ // 面同名不同物,不能拿它们当本批落盘证据,也不该因它们的存在把场景判红。
4027
+ if (!maintainerFacePresent()) {
4028
+ console.log('SKIP: TA-25 的治理落盘判据(docs/internal/ 维护者面与 .specs 流程工件面结构性缺席)——'
4029
+ + '本次检出未校验 4 条 ADR、已锁决策/机制册/发布清单/指导文件同步与债务登记,请在维护者主树重跑本套件(未验证 ≠ 通过)');
4030
+ return;
4031
+ }
4032
+ // ① 4 条 ADR 在场(编号 + 主题骨架)
4033
+ const adrDir = path.join(REPO_ROOT, '.specs', 'adr');
4034
+ const adrNumbers = ['018', '019', '020', '021'];
4035
+ if (!fs.existsSync(adrDir)) {
4036
+ console.log('SKIP: 治理落盘判据——.specs/adr/ 不在本检出(流程工件面缺席,未验证 ≠ 通过)');
4037
+ } else {
4038
+ const files = fs.readdirSync(adrDir);
4039
+ for (const number of adrNumbers) {
4040
+ if (!files.some((name) => name.startsWith('ADR-' + number + '-'))) {
4041
+ problems.push('缺 ADR-' + number + '(本批治理决策应落盘 4 条)');
4042
+ }
4043
+ }
4044
+ }
4045
+ // ② 维护者文档面(docs/internal 缺席 → 整组可见 SKIP)
4046
+ const maintainerDocs = [
4047
+ 'docs/internal/ARCHITECTURE.md',
4048
+ 'docs/internal/MECHANISM.md',
4049
+ 'docs/internal/DOC-CHECKLIST.md',
4050
+ 'docs/internal/ROADMAP.md',
4051
+ ];
4052
+ const present = maintainerDocs.filter(repoFileExists);
4053
+ if (present.length !== maintainerDocs.length) {
4054
+ console.log('SKIP: 治理落盘判据——docs/internal/ 维护者面缺席(' + maintainerDocs.filter((rel) => !repoFileExists(rel)).join('、')
4055
+ + ');本次检出未校验该面,请回维护者主树重跑');
4056
+ } else {
4057
+ const docs = new Map(maintainerDocs.map((rel) => [rel, repoFileText(rel)]));
4058
+ const rules = [
4059
+ {
4060
+ rel: 'docs/internal/ARCHITECTURE.md',
4061
+ label: '已锁决策补模板权威与结构级校验边界',
4062
+ include: ['已锁决策', '模板', '结构级'],
4063
+ },
4064
+ { rel: 'docs/internal/MECHANISM.md', label: '机制册新增模板权威条目', include: ['模板权威'] },
4065
+ { rel: 'docs/internal/DOC-CHECKLIST.md', label: '发布期登记表指纹检查项', include: ['指纹'] },
4066
+ ];
4067
+ problems.push(...textRuleProblems(docs, rules));
4068
+ // ③ 债务账本登记——账本段内至少三行分别指向模板 / 指纹 / 骨架三类债务主题
4069
+ const roadmap = docs.get('docs/internal/ROADMAP.md') ?? '';
4070
+ const ledger = roadmap.split(/^## /m).find((chunk) => chunk.startsWith('债务账本')) ?? '';
4071
+ const debtLines = ledger.split(/\r?\n/).filter((line) => /模板|指纹|骨架/.test(line) && /^\|/.test(line)).length;
4072
+ if (debtLines < 3) {
4073
+ problems.push('债务账本应登记本批 3 条债务(模板/指纹/骨架 相关行),实际 ' + debtLines + ' 行');
4074
+ }
4075
+ assertProbesDiscriminate(problems, docs, rules, [
4076
+ ['补上模板指纹检查项', 'docs/internal/DOC-CHECKLIST.md',
4077
+ (text) => text + '\n- 发布期比对条件段登记表的模板指纹。\n', '缺「指纹」', false],
4078
+ ['补上机制册条目', 'docs/internal/MECHANISM.md',
4079
+ (text) => text + '\n## 模板权威(版本漂移检查)\n', '缺「模板权威」', false],
4080
+ ]);
4081
+ }
4082
+ // ④ CONTEXT 的已锁决策段(流程工件面)
4083
+ if (!repoFileExists('.specs/CONTEXT.md')) {
4084
+ console.log('SKIP: 治理落盘判据——.specs/CONTEXT.md 不在本检出(流程工件面缺席,未验证 ≠ 通过)');
4085
+ } else {
4086
+ const context = repoFileText('.specs/CONTEXT.md');
4087
+ if (!context.includes('## 已锁决策')) problems.push('.specs/CONTEXT.md 缺「## 已锁决策」段');
4088
+ if (!context.includes('模板')) problems.push('.specs/CONTEXT.md 已锁决策/定义未更新模板权威口径');
4089
+ }
4090
+ // ⑤ 主仓指导文件的 guard 校验描述同步(维护者面:缺席即跳过并可见)
4091
+ if (!repoFileExists('CLAUDE.md')) {
4092
+ console.log('SKIP: 治理落盘判据——CLAUDE.md 不在本检出(主仓私有面缺席,未验证 ≠ 通过)');
4093
+ } else {
4094
+ const guide = repoFileText('CLAUDE.md');
4095
+ if (!guide.includes('模板')) problems.push('CLAUDE.md 的 guard 校验描述未同步模板权威口径');
4096
+ }
4097
+ if (problems.length > 0) throw new Error('治理落盘不符: ' + problems.join('; '));
4098
+ },
4099
+ },
4100
+ ];