flow-comet 1.6.5 → 1.8.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 (89) hide show
  1. package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
  2. package/.flow-comet/skills/flow-comet/SKILL.md +32 -18
  3. package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +2 -2
  4. package/.flow-comet/skills/flow-comet/reference/decision-points.md +5 -5
  5. package/.flow-comet/skills/flow-comet/reference/dirty-worktree.md +1 -1
  6. package/.flow-comet/skills/flow-comet/reference/entry-detail.md +30 -11
  7. package/.flow-comet/skills/flow-comet/reference/fix-loop.md +4 -4
  8. package/.flow-comet/skills/flow-comet/reference/init-detection.md +1 -1
  9. package/.flow-comet/skills/flow-comet/reference/platform-facts.md +2 -2
  10. package/.flow-comet/skills/flow-comet/reference/post-archive-handoff.md +264 -0
  11. package/.flow-comet/skills/flow-comet/reference/recovery.md +1 -1
  12. package/.flow-comet/skills/flow-comet/reference/replan.md +1 -1
  13. package/.flow-comet/skills/flow-comet/scripts/comet-check.mjs +1 -0
  14. package/.flow-comet/skills/flow-comet/scripts/comet-hook-guard.mjs +270 -30
  15. package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +26 -23
  16. package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +14 -94
  17. package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +122 -11
  18. package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +79 -40
  19. package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +11 -9
  20. package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +52 -10
  21. package/.flow-comet/skills/flow-comet/scripts/items/f.mjs +1 -1
  22. package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +128 -56
  23. package/.flow-comet/skills/flow-comet/scripts/items/k.mjs +357 -3
  24. package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +26 -1
  25. package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +6 -2
  26. package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +29 -21
  27. package/.flow-comet/skills/flow-comet/scripts/lib/ac-coverage.mjs +317 -0
  28. package/.flow-comet/skills/flow-comet/scripts/lib/fix-loop-node.mjs +4 -15
  29. package/.flow-comet/skills/flow-comet/scripts/lib/guard-artifact-skeleton.mjs +47 -5
  30. package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +357 -219
  31. package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +725 -309
  32. package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +182 -54
  33. package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +8 -6
  34. package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +224 -83
  35. package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +17 -28
  36. package/.flow-comet/skills/flow-comet/scripts/lib/lessons-hits.mjs +160 -0
  37. package/.flow-comet/skills/flow-comet/scripts/lib/run-root.mjs +21 -0
  38. package/.flow-comet/skills/flow-comet/scripts/lib/section-body.mjs +92 -0
  39. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +61 -33
  40. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +663 -205
  41. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +68 -9
  42. package/.flow-comet/skills/flow-comet/scripts/lib/state-determine.mjs +11 -4
  43. package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +92 -13
  44. package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +232 -11
  45. package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +140 -74
  46. package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +8 -4
  47. package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +84 -31
  48. package/.flow-comet/skills/flow-comet/scripts/lib/test-assertions.mjs +0 -3
  49. package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +248 -24
  50. package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +63 -3
  51. package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +181 -8
  52. package/.flow-comet/skills/flow-comet/scripts/lib/wave-projection.mjs +340 -0
  53. package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +132 -20
  54. package/.flow-comet/skills/flow-comet/scripts/route-node.mjs +12 -5
  55. package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +1564 -54
  56. package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1489 -38
  57. package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1466 -243
  58. package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +743 -24
  59. package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +220 -92
  60. package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +657 -21
  61. package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +41 -27
  62. package/.flow-comet/skills/flow-comet/scripts/scenarios/h.mjs +285 -9
  63. package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +7 -6
  64. package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +21 -15
  65. package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +8 -5
  66. package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +45 -36
  67. package/.flow-comet/skills/flow-comet/scripts/scenarios/m.mjs +2 -2
  68. package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +2381 -85
  69. package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +135 -2
  70. package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +143 -16
  71. package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +339 -103
  72. package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +5 -2
  73. package/.flow-comet/skills/flow-comet-archive/SKILL.md +33 -11
  74. package/.flow-comet/skills/flow-comet-change/SKILL.md +1 -1
  75. package/.flow-comet/skills/flow-comet-design/SKILL.md +5 -3
  76. package/.flow-comet/skills/flow-comet-dev/SKILL.md +2 -2
  77. package/.flow-comet/skills/flow-comet-execute/SKILL.md +37 -13
  78. package/.flow-comet/skills/flow-comet-integration/SKILL.md +10 -4
  79. package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +1 -1
  80. package/.flow-comet/skills/flow-comet-plan/SKILL.md +13 -6
  81. package/.flow-comet/skills/flow-comet-review/SKILL.md +21 -12
  82. package/.flow-comet/skills/flow-comet-subagent-execute/GUIDANCE.md +1 -1
  83. package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +43 -18
  84. package/.flow-comet/skills/flow-comet-task/SKILL.md +4 -2
  85. package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +2 -2
  86. package/.flow-comet/skills/flow-comet-verify/SKILL.md +1 -1
  87. package/README.md +2 -2
  88. package/package.json +1 -1
  89. package/scripts/dsh-bridge.mjs +238 -21
@@ -6,19 +6,25 @@ import fs from 'fs';
6
6
  import path from 'path';
7
7
  import { execFileSync, spawnSync } from 'child_process';
8
8
  import {
9
+ assertEqual,
9
10
  assertExit,
10
11
  assertNotOut,
11
12
  assertOut,
13
+ assertTrue,
12
14
  baseState,
15
+ installSkillTreeCopy,
13
16
  runGuard,
14
17
  runHandoff,
15
18
  runHook,
19
+ runPrintedCommand,
16
20
  runState,
21
+ splitPrintedCommand,
17
22
  writeFile,
18
23
  writeState,
19
24
  } from '../lib/test-helpers.mjs';
20
25
  import {
21
26
  CHANGE_ID,
27
+ SCRIPTS_DIR,
22
28
  TASK_DONE,
23
29
  TASK_P1,
24
30
  TASK_P2_PENDING,
@@ -26,14 +32,119 @@ import {
26
32
  TASK_TFIX,
27
33
  composeState,
28
34
  customProtocol,
35
+ customProtocolWithSkillCall,
36
+ dropNamedImport,
37
+ engineCodeText,
38
+ engineScriptTexts,
29
39
  handoffFor,
40
+ scriptTreeFiles,
41
+ strictSummary,
30
42
  summaryContent,
31
43
  writeCustomProtocol,
44
+ writeNodeDeclarationMarkers,
32
45
  } from '../lib/test-fixtures.mjs';
46
+ // 单一来源静态锁(write_files 条目切分只有一处实现):与套件其它单源锚共用同一判据实现。
47
+ import { singleSourceImportProblems } from '../lib/text-anchor-checks.mjs';
33
48
  import {
49
+ assertStateBytesUnchanged,
50
+ parseStatusJson,
51
+ readStateBytes,
52
+ requireRouteNodeExport,
34
53
  runGuardWithProtocol,
35
54
  runStateWithProtocol,
55
+ scenarioProtocolPath,
36
56
  } from '../lib/test-assertions.mjs';
57
+ // 恢复指引的路径形态参照物:打印出来的命令必须与 scriptCommand 的产物逐字一致(同一推导,不另写一份)。
58
+ import { scriptCommand } from '../lib/state-explain.mjs';
59
+
60
+ // ---------- 打印出来的命令:解析 → 真实执行(本组锚点;命令形态必须可复制、可执行) ----------
61
+ //
62
+ // 背景:运行期消息曾把脚本命令写成未加引号的单一平台字面量,测试只断言字面串、随后改用 harness
63
+ // 的绝对路径执行,于是「打印出来的那条命令」从未被真正执行过(形似全绿)。链路的三个夹具——按安装
64
+ // 布局复制技能树、把打印命令切成 argv、真实执行打印文本——由两组场景共用,单一来源在
65
+ // lib/test-helpers.mjs;本段只留本组自有的一件:跑副本脚本,以及命令形态(引号 / 分词 / 路径
66
+ // 可解析)的断言。
67
+
68
+ // 跑指定脚本(副本形态):cwd = 夹具根(与 run* 助手同一运行根口径)。
69
+ function runScriptCopy(scriptPath, args, root, envOverrides = {}) {
70
+ const res = spawnSync(process.execPath, [scriptPath, ...args], {
71
+ cwd: root,
72
+ env: { ...process.env, ...envOverrides },
73
+ encoding: 'utf8',
74
+ timeout: 60000,
75
+ });
76
+ return { status: res.status ?? 1, output: String(res.stdout || '') + String(res.stderr || '') };
77
+ }
78
+
79
+ // 打印命令的形态解析(下面两条断言的共用前半段):① 脚本路径整条加双引号;② 分词后脚本参数恰
80
+ // 好是那一条路径(引号被剥离、空格不裂开);③ 路径按**当前运行形态**解析后真实存在。不写死任
81
+ // 何平台根:只问「能不能解析到脚本」,不问它以哪个平台目录开头。hint 是形态说明,只拼进不可解
82
+ // 析报文——两种形态都可接受时,让失败消息说清放宽的是哪两种。
83
+ function parsePrintedCommandScript(command, root, label, hint = '') {
84
+ const match = command.match(/^node "([^"]+)"(?: .*)?$/);
85
+ if (!match) {
86
+ throw new Error(label + ' 的脚本路径未整条加双引号(安装根含空格时会被 shell 分词): ' + command);
87
+ }
88
+ const printedScript = match[1];
89
+ const argv = splitPrintedCommand(command);
90
+ if (argv[1] !== printedScript) {
91
+ throw new Error(label + ' 的脚本路径被分词拆开: ' + JSON.stringify(argv));
92
+ }
93
+ const resolved = path.resolve(root, printedScript);
94
+ if (!fs.existsSync(resolved)) {
95
+ throw new Error(label + ' 的脚本路径按当前运行形态不可解析' + hint + ': ' + printedScript + ' → ' + resolved);
96
+ }
97
+ return { printedScript, resolved };
98
+ }
99
+
100
+ // 期望脚本同一性断言(夹具内的运行形态已知时使用):④ 解析结果与期望副本是同一文件。
101
+ function assertPrintedCommandResolves(command, root, expectedScript, label) {
102
+ const { printedScript, resolved } = parsePrintedCommandScript(command, root, label);
103
+ if (fs.realpathSync(resolved) !== fs.realpathSync(expectedScript)) {
104
+ throw new Error(label + ' 解析到了别的脚本: ' + resolved + '(期望 ' + expectedScript + ')');
105
+ }
106
+ return printedScript;
107
+ }
108
+
109
+ // 恢复段里「哪些行是可执行命令」的判据(两处恢复段共用):命令行 = 行首即 node + 引号脚本路径,
110
+ // 其余行是步骤标注与说明。判据分两半——① 可执行行集合与期望逐字相等(多一行说明被拼进命令、或少
111
+ // 一行命令,照抄都会断);② 说明行不得出现命令形态(说明接回命令行尾时,整行丢给 shell 会把说明当
112
+ // 成参数,命令看起来在场、照抄即失败)。返回命令行(调用方随后逐条真实执行——「能解析」不等于「能跑」)。
113
+ function shellCommandLines(block) {
114
+ return String(block ?? '').split(/\r?\n/u)
115
+ .filter((line) => /^\s*node\s+"/u.test(line))
116
+ .map((line) => line.trim());
117
+ }
118
+
119
+ function assertRecoveryCommandLines(block, expected, label) {
120
+ const commands = shellCommandLines(block);
121
+ assertTrue(commands.length === expected.length && commands.every((line, index) => line === expected[index]),
122
+ label + ':恢复段的可执行行应恰好是期望的命令(顺序一致):\n命令=' + JSON.stringify(commands)
123
+ + '\n期望=' + JSON.stringify(expected) + '\n原文:\n' + block);
124
+ for (const line of String(block ?? '').split(/\r?\n/u)) {
125
+ if (line.trim() === '' || /^\s*node\s+"/u.test(line)) continue;
126
+ assertTrue(!/node\s+"[^"]+"/u.test(line),
127
+ label + ':说明行里出现了命令文本(命令须单独成行,否则整行不可执行): ' + line);
128
+ }
129
+ return commands;
130
+ }
131
+
132
+ // 安装根形态断言(运行形态由脚本自定位决定、夹具无从预知时使用):④ 解析出的命令脚本必须是真实
133
+ // 存在的 <scriptName>,且落在 flow-comet 技能树内。两种正确形态都放行——安装副本按**运行中脚本
134
+ // 所在的安装根**推出的路径(.claude / .agents / .dsh 乃至用户级安装),以及权威源写出的设计形态
135
+ // .claude/skills/…(在夹具里解析到技能树副本)。命令是否真的能在当前安装里照抄执行,由调用方随后
136
+ // 执行**打印出来的那条文本**证明——本断言不拿 harness 的脚本路径替代它。
137
+ function assertPrintedCommandTargetsInstalledScript(command, root, scriptName, label) {
138
+ const { printedScript, resolved } = parsePrintedCommandScript(command, root, label,
139
+ '(允许安装根形态或 fixture 设计形态)');
140
+ if (path.basename(resolved) !== scriptName) {
141
+ throw new Error(label + ' 解析到的不是 ' + scriptName + '(允许安装根形态或 fixture 设计形态): ' + resolved);
142
+ }
143
+ if (!resolved.split(/[\\/]+/).includes('flow-comet')) {
144
+ throw new Error(label + ' 解析到的脚本不在 flow-comet 技能树内(允许安装根形态或 fixture 设计形态): ' + resolved);
145
+ }
146
+ return printedScript;
147
+ }
37
148
 
38
149
  export const ENTRIES = [
39
150
 
@@ -41,8 +152,10 @@ export const ENTRIES = [
41
152
 
42
153
  // 34: subagent-execute exit 通过——handoff result 的 completedChecks 含 required-skill 条目 → exit 0
43
154
  {
44
- name: '34 subagent-execute exit 通过:handoff 含 completedChecks',
155
+ name: '34 subagent-execute exit 通过:handoff 含 completedChecks + 缺证据恢复命令可照抄执行',
45
156
  run: (dir) => {
157
+ writeNodeDeclarationMarkers(dir, 'subagent-execute');
158
+ writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', strictSummary('P01'));
46
159
  const st = baseState('subagent-execute');
47
160
  st.evidence['subagent-execute'] = {
48
161
  summary: 'delegated and collected',
@@ -53,6 +166,519 @@ export const ENTRIES = [
53
166
  const res = runGuard(['exit', 'subagent-execute'], dir);
54
167
  assertExit(res, 0);
55
168
  assertOut(res, 'ALL CHECKS PASSED');
169
+
170
+ // ---------- 缺证据阻塞给出可复制恢复命令(in-place 扩展;不新增场景条目) ----------
171
+ // ① 移除 evidence.summary(record 只写 summary 的合法路径)→ exit 命中 missing Output
172
+ // Schema evidence;BLOCKED 行之后必须给出可照抄的恢复命令,照抄执行后同一 exit 通过。
173
+ const stateFile = path.join(dir, '.flow-comet', 'flow-comet-state.json');
174
+ const stNoEvidence = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
175
+ delete stNoEvidence.evidence['subagent-execute'].summary;
176
+ writeState(dir, stNoEvidence);
177
+ // 前提:本节点还没有技能加载声明标记(record 的前置门)——报文必须把这道前置条件一并给全。
178
+ const loadsDir = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
179
+ // ① 的正例已写入声明标记;② 要测「缺声明」分支,故显式清掉(单轨下声明是出口硬前置)
180
+ fs.rmSync(loadsDir, { recursive: true, force: true });
181
+ if (fs.existsSync(loadsDir)) {
182
+ throw new Error('夹具前提不成立:缺声明分支要求 .skill-loads/ 不存在(实际: ' + loadsDir + ')');
183
+ }
184
+ const resNoEvidence = runGuard(['exit', 'subagent-execute'], dir);
185
+ assertExit(resNoEvidence, 1);
186
+ assertOut(resNoEvidence, 'BLOCKED: missing Output Schema evidence');
187
+ assertOut(resNoEvidence, '{"summary":"<本节点完成摘要>"}');
188
+ assertOut(resNoEvidence, '后重试 exit');
189
+ // ② 恢复命令**从输出解析**(不再与字面串比对——字面量断言正是此前漏检的成因)。缺技能加载声明
190
+ // 时照抄 record 会被它自己的前置门拦下(「节点缺少技能加载声明标记」),半步恢复 = 还得去另一条
191
+ // 报文里找 skill-load 命令;故两条命令必须落在**同一段「恢复:」**里(本段 = 输出里最后一条恢复段,
192
+ // 该段之后引擎直接退出)。
193
+ const recoveryStart = resNoEvidence.output.lastIndexOf('恢复:');
194
+ const recoveryBlock = recoveryStart < 0 ? '' : resNoEvidence.output.slice(recoveryStart);
195
+ if (recoveryBlock === '') {
196
+ throw new Error('BLOCKED 输出缺恢复段:\n' + resNoEvidence.output);
197
+ }
198
+ const recordCommand = (recoveryBlock.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
199
+ const skillLoadCommand = (recoveryBlock.match(/^\s*(node "[^"]+" skill-load [^\n]+)$/m) || [])[1];
200
+ if (!recordCommand) {
201
+ throw new Error('BLOCKED 输出的恢复段缺可解析的 record 命令:\n' + resNoEvidence.output);
202
+ }
203
+ if (!skillLoadCommand) {
204
+ throw new Error('缺技能加载声明时恢复段必须同时给出 skill-load 命令'
205
+ + '(否则照抄 record 会被它的前置门拦下,第二步的命令又落在另一条报文里):\n' + resNoEvidence.output);
206
+ }
207
+ // 恢复段的可执行行 = 这两条命令,顺序即执行顺序;其余行都是说明——说明不得带命令形态(同一行里
208
+ // 「命令 + 说明」整行丢给 shell 会把说明当成参数,正是可照抄性失效的形态)。
209
+ assertRecoveryCommandLines(recoveryBlock, [skillLoadCommand, recordCommand], '缺声明的缺证据恢复段');
210
+ // 协议上下文跟「本次实际用到的协议」走,不跟来源走:本段的协议来自调用方环境(runGuard 注入
211
+ // FLOW_COMET_PROTOCOL = 夹具内的协议副本),它不是内置默认那一份——副本路径与内置默认不同,
212
+ // 照抄时不带 --protocol 就会按同一套优先级重新解析。故命令必须自带协议路径(与「协议来自
213
+ // state」那条同一判据,见本场景末尾;来源是 env 时此前只印命令,照抄即落到默认协议)。
214
+ for (const [label, recoveredCommand] of [['record', recordCommand], ['skill-load', skillLoadCommand]]) {
215
+ if (!recoveredCommand.includes(' --protocol "reference/workflow-protocol.json"')) {
216
+ throw new Error('协议来自环境变量且不是内置默认时,恢复段的 ' + label + ' 命令必须自带 '
217
+ + '--protocol "reference/workflow-protocol.json"(否则照抄时协议上下文丢失): ' + recoveredCommand);
218
+ }
219
+ }
220
+ // ③ 两条命令的脚本路径逐字等于 scriptCommand 的产物(路径与引号只有一处实现——换一种拼法在此判红)。
221
+ const printedPathPrefix = scriptCommand({ scriptsDir: SCRIPTS_DIR, runRoot: dir, script: 'workflow-state.mjs' });
222
+ for (const [label, recoveredCommand] of [['record', recordCommand], ['skill-load', skillLoadCommand]]) {
223
+ if (!recoveredCommand.startsWith(printedPathPrefix + ' ')) {
224
+ throw new Error('恢复段的 ' + label + ' 命令脚本路径应逐字等于 scriptCommand 产物 '
225
+ + printedPathPrefix + ',实际: ' + recoveredCommand);
226
+ }
227
+ }
228
+ // 安装布局:权威源 = 设计形态(安装器把它装到平台根下);把本套件技能树按该布局复制进夹具,
229
+ // 权威源形态打印的相对路径才可解析。两种正确形态都放行——① 安装副本:命令路径按**运行中脚本
230
+ // 所在的安装根**推导(<安装根>/.claude/skills/… 的绝对路径——副本里照抄可执行的就是这条);
231
+ // ② 权威源:设计形态 .claude/skills/…(在夹具里解析到上面这份副本)。断言只问「解析到的是不
232
+ // 是真实存在的 workflow-state.mjs」——存在性 + 脚本名 + 随后真执行打印文本(不拿 harness 的
233
+ // 路径替代),不把路径钉成 fixture 路径(L-072:布局感知缺失会让安装副本套件变红)。
234
+ installSkillTreeCopy(dir, path.join('.claude', 'skills'));
235
+ assertPrintedCommandTargetsInstalledScript(recordCommand, dir, 'workflow-state.mjs', '恢复命令');
236
+ assertPrintedCommandTargetsInstalledScript(skillLoadCommand, dir, 'workflow-state.mjs', '前置声明命令');
237
+ // ④ 照抄打印出来的两条命令并真实执行(不是 harness 的绝对脚本路径):按报文给出的执行顺序
238
+ // 先声明、再 record。走通这两步才说明「一条报文 = 一条恢复路径」。
239
+ // 环境变量清空:协议上下文只能来自命令本身——命令没带 --protocol 时这一步会落到内置默认协议
240
+ // (项目根之外)而不是夹具里的那份,照抄即失败。
241
+ const resDeclared = runPrintedCommand(skillLoadCommand, dir, {
242
+ FLOW_COMET_RUN_ROOT: dir,
243
+ FLOW_COMET_PROTOCOL: '',
244
+ });
245
+ assertExit(resDeclared, 0);
246
+ assertOut(resDeclared, 'SKILL-LOAD: subagent-execute');
247
+ const declaredMarkers = fs.readdirSync(loadsDir)
248
+ .filter((name) => name.startsWith('subagent-execute-') && name.endsWith('.json'));
249
+ if (declaredMarkers.length === 0) {
250
+ throw new Error('照抄前置声明命令后应有 .skill-loads/subagent-execute-*.json'
251
+ + '(record 前置门按该前缀判定): ' + JSON.stringify(fs.readdirSync(loadsDir)));
252
+ }
253
+ const resRecoveredByCommand = runPrintedCommand(recordCommand, dir, {
254
+ FLOW_COMET_RUN_ROOT: dir,
255
+ FLOW_COMET_PROTOCOL: '',
256
+ });
257
+ assertExit(resRecoveredByCommand, 0);
258
+ const stRecovered = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
259
+ if (stRecovered.evidence['subagent-execute'].summary !== '<本节点完成摘要>') {
260
+ throw new Error('照抄恢复命令后 evidence.summary 未按打印载荷写入,实际: '
261
+ + JSON.stringify(stRecovered.evidence['subagent-execute']));
262
+ }
263
+ const resEvidenceRecovered = runGuard(['exit', 'subagent-execute'], dir);
264
+ assertExit(resEvidenceRecovered, 0);
265
+ assertOut(resEvidenceRecovered, 'ALL CHECKS PASSED');
266
+ // ⑤ 声明已在场 → 恢复段收敛回一条 record(不多给一步):同样的缺证据阻塞,恢复段里不得再出现
267
+ // skill-load 步骤。断言只看恢复段,别的门的提示不在本断言范围。
268
+ const stAgain = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
269
+ delete stAgain.evidence['subagent-execute'].summary;
270
+ writeState(dir, stAgain);
271
+ const resDeclaredMissing = runGuard(['exit', 'subagent-execute'], dir);
272
+ assertExit(resDeclaredMissing, 1);
273
+ assertOut(resDeclaredMissing, 'BLOCKED: missing Output Schema evidence');
274
+ const declaredRecoveryStart = resDeclaredMissing.output.lastIndexOf('恢复:');
275
+ const declaredRecovery = declaredRecoveryStart < 0 ? '' : resDeclaredMissing.output.slice(declaredRecoveryStart);
276
+ const singleRecordCommand = (declaredRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
277
+ if (!singleRecordCommand) {
278
+ throw new Error('已有声明时恢复段缺 record 命令:\n' + resDeclaredMissing.output);
279
+ }
280
+ // 恢复段的两行结构:说明行(「照抄下面的命令…」)+ 命令行 + 说明行(怎么执行)。命令行单独成行,
281
+ // 整行丢给 shell 才是那条可执行的命令——这是「照抄即通」的形态判据(执行面由下面那行证明)。
282
+ assertRecoveryCommandLines(declaredRecovery, [singleRecordCommand], '已有声明的缺证据恢复段');
283
+ if (!declaredRecovery.startsWith('恢复: ')) {
284
+ throw new Error('已有声明时恢复段应以「恢复:」开口:\n' + declaredRecovery);
285
+ }
286
+ if (/第一步|第二步/s.test(declaredRecovery)) {
287
+ throw new Error('已有声明时恢复段不得再给分步标注(不给多余步骤):\n' + declaredRecovery);
288
+ }
289
+ if (/skill-load\s/.test(declaredRecovery)) {
290
+ throw new Error('已有声明时恢复段不得再给 skill-load 步骤:\n' + declaredRecovery);
291
+ }
292
+ // 复位:照抄该 record 把证据补回去,后续段从「证据齐 + 有声明」的形态继续
293
+ assertExit(runPrintedCommand(singleRecordCommand, dir, {
294
+ FLOW_COMET_RUN_ROOT: dir,
295
+ FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir),
296
+ }), 0);
297
+
298
+ // ---------- 开工前可见的 LESSONS 命中集(原位扩展;不新增场景条目) ----------
299
+ // 出口按「任务 write_files 的路径段(过停用词)× .specs/LESSONS.md 条目的关键词行」重算命中集
300
+ // (前 5 条),并要求 SUMMARY 的 ## LESSONS 扫描 段逐条回应这些编号;执行者开工时看不到这个
301
+ // 集合,只能按自己对任务主题的理解扫,两套口径只在出口对齐 —— 本段做对账:request 打印的
302
+ // 命中集必须与出口重算的逐条一致(同一份命中算法驱动两处,各算一套必在此红)。
303
+ const lessonsLedger = [
304
+ '# LESSONS — 跨任务失败知识库(夹具)',
305
+ '',
306
+ '## 条目区(夹具)',
307
+ '',
308
+ '### L-501 · [proc] 门禁按结构级校验',
309
+ '',
310
+ '- **关键词**: guard, template',
311
+ '',
312
+ '夹具条目正文:判据按结构级校验,不做语义判断。',
313
+ '',
314
+ '### L-502 · [test] 归档提名须留痕',
315
+ '',
316
+ '- **关键词**: template, archive',
317
+ '',
318
+ '夹具条目正文:归档提名须留痕。',
319
+ '',
320
+ '### L-503 · [doc] 与任务写路径无交集的条目',
321
+ '',
322
+ '- **关键词**: nomination, release',
323
+ '',
324
+ '夹具条目正文:本条与任务写路径无交集,不得出现在命中集里(反向构造)。',
325
+ '',
326
+ ].join('\n');
327
+ writeFile(dir, '.specs/LESSONS.md', lessonsLedger);
328
+ // 任务的写面换成与教训册关键词有交集的路径:夹具路径 src/p1.mjs 的词元是 p1,长度不足被过滤
329
+ // —— 命中集恒空,锚不出差异。
330
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
331
+ + '<task id="P01" status="done" parallel="true"><action>改模板保真门禁</action>'
332
+ + '<write_files>scripts/lib/guard-template-fidelity.mjs</write_files>'
333
+ + '<verify>node --check src/p1.mjs</verify></task>\n');
334
+ writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', strictSummary('T01'));
335
+ // ① 出口重算:扫描段没回应命中条目 → 逐条列出编号(旧 change 渐进不阻断)
336
+ const exitLessons = runGuard(['exit', 'subagent-execute'], dir);
337
+ assertOut(exitLessons, '未回应命中条目 L-501');
338
+ const exitHitIds = ((exitLessons.output.match(/未回应命中条目 ([^\n]*)/) || [])[1] || '').match(/L-\d+/g) || [];
339
+ assertEqual(exitHitIds.length, 2, '出口重算的命中条目数');
340
+ // ② request 开工前打印同一集合,顺序也一致(共享词多者在前)
341
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/subagent-execute-flow-comet-dev.json',
342
+ JSON.stringify({ node: 'subagent-execute', skill: 'flow-comet-dev', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
343
+ const reqLessons = runHandoff(['request', 'P01', 'lesson hits preview'], dir);
344
+ assertExit(reqLessons, 0);
345
+ assertOut(reqLessons, 'LESSONS-HITS: 2 条');
346
+ assertOut(reqLessons, '这些条目须在 SUMMARY 的 `## LESSONS 扫描` 段逐条回应');
347
+ const requestHitIds = reqLessons.output.split('\n')
348
+ .filter((line) => /^ {2}- L-\d+ · /.test(line))
349
+ .map((line) => (line.match(/L-\d+/) || [])[0]);
350
+ assertEqual(JSON.stringify(requestHitIds), JSON.stringify(exitHitIds),
351
+ 'request 的命中集必须与出口重算逐条一致(同一函数驱动)');
352
+ assertNotOut(reqLessons, 'L-503');
353
+ // ③ 教训册不可读 → 一行降级提示:request 不失败、不编造条目
354
+ fs.rmSync(path.join(dir, '.specs', 'LESSONS.md'));
355
+ const reqNoLedger = runHandoff(['request', 'P01', 'ledger missing'], dir);
356
+ assertExit(reqNoLedger, 0);
357
+ assertOut(reqNoLedger, 'LESSONS-HITS: 无法计算');
358
+ assertNotOut(reqNoLedger, 'L-501');
359
+ // ④ 边界:任务本身不声明写面 → 明确「无可回应条目」,不静默跳过(教训册先复位,命中的判据
360
+ // 才只剩「任务没有写面」这一条)
361
+ writeFile(dir, '.specs/LESSONS.md', lessonsLedger);
362
+ // 原位扩展(写面提取单一来源 / 不跨任务):把**未声明写面**的任务放在声明了写面的任务之前——
363
+ // 按块取的提取不越过 </task>,缺失就是缺失;旧实现用「<task id=…> 到全文下一个 <write_files>」
364
+ // 的单条非贪婪正则,会取到下一个任务的写面:同一次 request 一边打印「未声明 write_files」,
365
+ // 一边把下一个任务的路径记成本任务的提交边界(提交子集校验随后按别人的白名单放行)。
366
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
367
+ + '<task id="P03" status="done" parallel="true"><action>无写文件任务</action>'
368
+ + '<verify>node --check src/p3.mjs</verify></task>\n'
369
+ + '<task id="P04" status="pending" parallel="true"><action>相邻任务</action>'
370
+ + '<write_files>src/p04.mjs</write_files><verify>node --check src/p04.mjs</verify></task>\n');
371
+ // 单轨:写面不可解析一律 BLOCK(不再有「旧 change 渐进记录」这一侧)
372
+ const reqNoWriteFiles = runHandoff(['request', 'P03', 'no write files'], dir);
373
+ assertExit(reqNoWriteFiles, 1);
374
+ assertOut(reqNoWriteFiles, 'BLOCKED: 委托任务不可解析');
375
+ const stNoWrite = JSON.parse(readStateBytes(dir));
376
+ if (stNoWrite.evidence?.['subagent-execute']?.handoffRequests?.P03) {
377
+ throw new Error('写面不可解析的 request 不得落库,实际 evidence: '
378
+ + JSON.stringify(stNoWrite.evidence));
379
+ }
380
+ if (JSON.stringify(stNoWrite).includes('src/p04.mjs')) {
381
+ throw new Error('未声明写面的任务把相邻任务的路径记进了 state(跨任务取值): ' + JSON.stringify(stNoWrite));
382
+ }
383
+ // 同一份 TASK 在**新 change** 下:写面缺失必须在入口 BLOCK——旧实现借来相邻任务的写面,request
384
+ // 因而放行,越界要等到提交子集校验才炸。BLOCK 路径 state 字节零改写。
385
+ const newChangeState = baseState('subagent-execute');
386
+ writeState(dir, newChangeState);
387
+ const bytesBeforeBlock = readStateBytes(dir);
388
+ const reqNoWriteNew = runHandoff(['request', 'P03', 'no write files new change'], dir);
389
+ assertExit(reqNoWriteNew, 1);
390
+ assertOut(reqNoWriteNew, 'BLOCKED: 委托任务不可解析');
391
+ assertStateBytesUnchanged(dir, bytesBeforeBlock, '写面缺失的新 change request');
392
+ // ⑤ 边界:TASK.md 里没有该任务(写面由显式参数给出)→ 同样给出明确说明
393
+ const reqNoTask = runHandoff(['request', 'P99', 'no such task', '--write-files', 'src/p99.mjs'], dir);
394
+ assertExit(reqNoTask, 0);
395
+ assertOut(reqNoTask, '无可回应条目(TASK.md 无匹配任务 P99)');
396
+
397
+ // ---------- write_files 条目切分单一来源(原位扩展;不新增场景条目) ----------
398
+ // 条目边界(剥 HTML 注释 → 行切 → 分号容错切 → trim → 滤空)此前有**三份**:本文件的本地
399
+ // writeFilesEntries、plan 出口伪并行启发式的内联链、task-graph 的 parsePaths。三处各自自洽时,
400
+ // 同一份写面会在不同门禁里变成不同条目集(注释里的词被当成路径、分号行只取首项),而两处不会
401
+ // 同时红——所以「谁越界」「哪一对并行任务重叠」可以互相矛盾却全绿。
402
+ // ① 行为:request 记录的允许列表 = 共享切分的产物(注释不进入条目、分号行二次切分、空行滤掉)
403
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
404
+ + '<task id="P05" status="pending"><action>写面切分夹具</action>'
405
+ + '<write_files>\n'
406
+ + ' <!-- 夹具注释:注释里的 src/ghost.mjs 不得成为条目 -->\n'
407
+ + ' src/a.mjs; src/b.mjs\n'
408
+ + '\n'
409
+ + ' src/c.mjs\n'
410
+ + '</write_files><verify>node --check src/a.mjs</verify></task>\n');
411
+ const reqSplit = runHandoff(['request', 'P05', 'write files split'], dir);
412
+ assertExit(reqSplit, 0);
413
+ const splitRecorded = JSON.parse(readStateBytes(dir))
414
+ .evidence?.['subagent-execute']?.handoffRequests?.P05?.writeFiles;
415
+ assertEqual(JSON.stringify(splitRecorded), JSON.stringify(['src/a.mjs', 'src/b.mjs', 'src/c.mjs']),
416
+ 'request 记录的写面条目(剥注释 / 分号二次切分 / 滤空后的规范形态)');
417
+ // ② 结构锚:条目切分只有一处定义,且三个消费方都从它取用(新增第四处或退回内联副本即红)
418
+ const splitTexts = engineScriptTexts();
419
+ const splitProblems = singleSourceImportProblems({
420
+ symbol: 'writeFilesEntries',
421
+ sourceRel: 'lib/lessons-hits.mjs',
422
+ texts: splitTexts,
423
+ });
424
+ assertTrue(splitProblems.length === 0,
425
+ 'write_files 条目切分应只有一处实现且消费方都从它取用:\n' + splitProblems.join('\n'));
426
+ // ③ 反向构造(判别力):把某个消费方的具名取用摘掉 → 结构锚必须报出来(否则 ② 只是「看起来有」)
427
+ const splitMutated = new Map(splitTexts);
428
+ splitMutated.set('workflow-handoff.mjs',
429
+ dropNamedImport(splitMutated.get('workflow-handoff.mjs'), 'writeFilesEntries'));
430
+ const splitMutatedProblems = singleSourceImportProblems({
431
+ symbol: 'writeFilesEntries',
432
+ sourceRel: 'lib/lessons-hits.mjs',
433
+ texts: splitMutated,
434
+ });
435
+ assertTrue(splitMutatedProblems.some((problem) => problem.includes('workflow-handoff.mjs')),
436
+ '摘掉消费方的具名取用后结构锚未报出(判据没有判别力): ' + JSON.stringify(splitMutatedProblems));
437
+
438
+ // ---------- 打印命令链的夹具单一来源(原位扩展;不新增场景条目) ----------
439
+ // 「按安装布局复制技能树 → 把打印命令切成 argv → 真实执行打印文本」这三个夹具此前在委托链路组
440
+ // 与声明恢复组各有一份(逐字复制、含注释):同一条命令在两组的判据里各自演化,任一侧漂移都不会
441
+ // 让另一侧变红。判据 = 三个夹具的定义只有一处(lib/test-helpers.mjs),凡在代码里引用它们的模块
442
+ // 都从那里具名取用——落点与消费方都由真实形态派生,新增第三份复制即红。既有断言只看行为(各组
443
+ // 自己的照抄闭环),两组行为都自洽时漂移是静默的,故这一层结构锚不能省。
444
+ const chainFixtures = ['installSkillTreeCopy', 'splitPrintedCommand', 'runPrintedCommand'];
445
+ const chainSourceRel = 'lib/test-helpers.mjs';
446
+ const treeTexts = new Map(scriptTreeFiles()
447
+ .map((rel) => [rel, fs.readFileSync(path.join(SCRIPTS_DIR, rel), 'utf8')]));
448
+ for (const symbol of chainFixtures) {
449
+ const chainProblems = singleSourceImportProblems({ symbol, sourceRel: chainSourceRel, texts: treeTexts });
450
+ assertTrue(chainProblems.length === 0, '打印命令链的夹具 ' + symbol + ' 应只有一处实现、且引用方都从 '
451
+ + chainSourceRel + ' 取用:\n' + chainProblems.join('\n'));
452
+ // 反向构造(判别力):摘掉某个真实消费方的具名取用 → 结构锚必须点名它(否则上一条只是「看起来有」)
453
+ const symbolRe = new RegExp('\\b' + symbol + '\\b');
454
+ const consumerRel = [...treeTexts.keys()].find((rel) =>
455
+ rel !== chainSourceRel && symbolRe.test(engineCodeText(treeTexts.get(rel))));
456
+ if (!consumerRel) {
457
+ throw new Error('反向构造的前提不成立:' + symbol + ' 在 ' + chainSourceRel + ' 之外没有代码层消费者');
458
+ }
459
+ const mutated = new Map(treeTexts).set(consumerRel, dropNamedImport(treeTexts.get(consumerRel), symbol));
460
+ const reported = singleSourceImportProblems({ symbol, sourceRel: chainSourceRel, texts: mutated });
461
+ assertTrue(reported.some((problem) => problem.includes(consumerRel)),
462
+ '摘掉 ' + consumerRel + ' 的具名取用后结构锚未点名它(判据没有判别力): ' + JSON.stringify(reported));
463
+ }
464
+
465
+ // ---------- 协议上下文随恢复命令传播(原位扩展;不新增场景条目) ----------
466
+ // guard 解析协议的顺序包含 state.protocolPath(init 持久化绑定),而 workflow-state /
467
+ // workflow-handoff 只走 --protocol CLI → FLOW_COMET_PROTOCOL → 内置默认,不读 state 绑定。
468
+ // 于是照抄 guard 打印的恢复命令时协议上下文丢失:自定义协议的节点名在 env/默认协议里不存在,
469
+ // 第一步就撞「skill-load node 非法」——报文给了命令,命令却跑不进同一个协议。
470
+ // 判据:协议来自 state → 命令自带 --protocol 且照抄可执行;来自 env / 内置默认 → 不加
471
+ // (协议上下文已由调用方的命令或环境携带,重复印一遍只是噪音)。
472
+ const boundProtocolRel = 'custom-protocol.json';
473
+ writeFile(dir, boundProtocolRel, JSON.stringify(customProtocolWithSkillCall(), null, 2) + '\n');
474
+ writeFile(dir, '.specs/compose-demo/notes.md', '# notes\n');
475
+ // evidence 在场才走得出前置的「无证据」门(那条报文不打印可照抄命令):本段要考的是
476
+ // Output Schema evidence 缺失时的两步恢复,故放一个空证据对象,缺的正是 schema 要求的字段。
477
+ writeState(dir, composeState({ currentNode: 'brainstorm', protocolPath: boundProtocolRel, evidence: { brainstorm: {} } }));
478
+ const boundLoadsDir = path.join(dir, '.specs', 'compose-demo', '.skill-loads');
479
+ if (fs.existsSync(boundLoadsDir)) {
480
+ throw new Error('夹具前提不成立:缺声明分支要求 .skill-loads/ 不存在(实际: ' + boundLoadsDir + ')');
481
+ }
482
+ const boundState = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
483
+ boundState.enteredNodes = ['brainstorm'];
484
+ writeState(dir, boundState);
485
+ const boundBlocked = runGuard(['exit', 'brainstorm'], dir, { FLOW_COMET_PROTOCOL: '' });
486
+ assertExit(boundBlocked, 1);
487
+ assertOut(boundBlocked, 'BLOCKED: missing Output Schema evidence: compose.notes.v1.notes-summary');
488
+ const boundRecoveryStart = boundBlocked.output.lastIndexOf('恢复:');
489
+ const boundRecovery = boundRecoveryStart < 0 ? '' : boundBlocked.output.slice(boundRecoveryStart);
490
+ const boundRecordCommand = (boundRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
491
+ const boundSkillLoadCommand = (boundRecovery.match(/^\s*(node "[^"]+" skill-load [^\n]+)$/m) || [])[1];
492
+ if (!boundRecordCommand || !boundSkillLoadCommand) {
493
+ throw new Error('state 绑定自定义协议的恢复段必须同时给出 skill-load 与 record 命令:\n' + boundBlocked.output);
494
+ }
495
+ // ① 正例:两条命令都带 --protocol(state 绑定的路径)。不带时照抄执行会落到 env/默认协议,
496
+ // brainstorm 在默认 8 节点协议里不存在——恢复路径断在第一句话。
497
+ for (const [label, boundCommand] of [['record', boundRecordCommand], ['skill-load', boundSkillLoadCommand]]) {
498
+ if (!boundCommand.includes(' --protocol "' + boundProtocolRel + '"')) {
499
+ throw new Error('协议来自 state.protocolPath 时,恢复段的 ' + label + ' 命令必须自带 --protocol "'
500
+ + boundProtocolRel + '"(否则照抄时协议上下文丢失): ' + boundCommand);
501
+ }
502
+ }
503
+ // ② 照抄执行(无环境变量——协议上下文只能来自命令本身):两步都要真实走通。
504
+ const boundDeclared = runPrintedCommand(boundSkillLoadCommand, dir, {
505
+ FLOW_COMET_RUN_ROOT: dir,
506
+ FLOW_COMET_PROTOCOL: '',
507
+ });
508
+ assertExit(boundDeclared, 0);
509
+ assertOut(boundDeclared, 'SKILL-LOAD: brainstorm');
510
+ const boundRecorded = runPrintedCommand(boundRecordCommand, dir, {
511
+ FLOW_COMET_RUN_ROOT: dir,
512
+ FLOW_COMET_PROTOCOL: '',
513
+ });
514
+ assertExit(boundRecorded, 0);
515
+ const boundStateAfter = JSON.parse(readStateBytes(dir));
516
+ assertEqual(boundStateAfter.evidence?.brainstorm?.summary, '<本节点完成摘要>',
517
+ '照抄的 record 命令写入的 evidence(协议上下文须随命令到达)');
518
+ // ③ 一条报文走完即闭合:同一 exit 不再报缺证据
519
+ const boundPassed = runGuard(['exit', 'brainstorm'], dir, { FLOW_COMET_PROTOCOL: '' });
520
+ assertExit(boundPassed, 0);
521
+ assertOut(boundPassed, 'ALL CHECKS PASSED');
522
+
523
+ // ④ 第三种来源:--protocol CLI(state 无绑定、环境变量为空)——判据不看来源,命令同样自带该
524
+ // 协议路径。这正是缺陷形态的原点:用 --protocol 调 guard 时,恢复命令曾不带协议上下文,照抄
525
+ // 一步就落到 env/默认协议(自定义协议里才有的节点名在那份协议里不存在)。
526
+ writeState(dir, composeState({ currentNode: 'brainstorm', evidence: { brainstorm: {} }, enteredNodes: ['brainstorm'] }));
527
+ const cliBlocked = runGuard(['exit', 'brainstorm', '--protocol', boundProtocolRel], dir, { FLOW_COMET_PROTOCOL: '' });
528
+ assertExit(cliBlocked, 1);
529
+ assertOut(cliBlocked, 'BLOCKED: missing Output Schema evidence: compose.notes.v1.notes-summary');
530
+ const cliRecoveryStart = cliBlocked.output.lastIndexOf('恢复:');
531
+ const cliRecovery = cliRecoveryStart < 0 ? '' : cliBlocked.output.slice(cliRecoveryStart);
532
+ const cliRecordCommand = (cliRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
533
+ if (!cliRecordCommand) {
534
+ throw new Error('协议来自 --protocol CLI 时,恢复段必须给出可照抄的 record 命令:\n' + cliBlocked.output);
535
+ }
536
+ if (!cliRecordCommand.includes(' --protocol "' + boundProtocolRel + '"')) {
537
+ throw new Error('协议来自 --protocol CLI 时,恢复段的 record 命令必须自带 --protocol "'
538
+ + boundProtocolRel + '"(照抄时协议上下文只能来自命令本身): ' + cliRecordCommand);
539
+ }
540
+ const cliRecorded = runPrintedCommand(cliRecordCommand, dir, {
541
+ FLOW_COMET_RUN_ROOT: dir,
542
+ FLOW_COMET_PROTOCOL: '',
543
+ });
544
+ assertExit(cliRecorded, 0);
545
+ assertEqual(JSON.parse(readStateBytes(dir)).evidence?.brainstorm?.summary, '<本节点完成摘要>',
546
+ '照抄 CLI 来源下打印的 record 命令写入的 evidence');
547
+
548
+ // ⑤ 负例:协议来自内置默认(无 CLI、无 state 绑定、无环境变量)→ 命令不加 --protocol。
549
+ // 用安装副本自身的脚本跑:权威源检出的内置协议落在夹具根之外(协议读取要求协议在项目根内),
550
+ // 副本形态才等价于真实安装——默认解析落到的正是包内协议。
551
+ const defaultState = baseState('subagent-execute');
552
+ defaultState.evidence['subagent-execute'] = { handoffResult: handoffFor(['P01']) };
553
+ writeState(dir, defaultState);
554
+ fs.rmSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true, force: true });
555
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
556
+ const defaultBlocked = runScriptCopy(
557
+ path.join(dir, '.claude', 'skills', 'flow-comet', 'scripts', 'workflow-guard.mjs'),
558
+ ['exit', 'subagent-execute'],
559
+ dir,
560
+ { FLOW_COMET_RUN_ROOT: dir, FLOW_COMET_PROTOCOL: '' },
561
+ );
562
+ assertExit(defaultBlocked, 1);
563
+ assertOut(defaultBlocked, 'BLOCKED: missing Output Schema evidence');
564
+ const defaultRecoveryStart = defaultBlocked.output.lastIndexOf('恢复:');
565
+ const defaultRecovery = defaultRecoveryStart < 0 ? '' : defaultBlocked.output.slice(defaultRecoveryStart);
566
+ const defaultRecordCommand = (defaultRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
567
+ const defaultSkillLoadCommand = (defaultRecovery.match(/^\s*(node "[^"]+" skill-load [^\n]+)$/m) || [])[1];
568
+ if (!defaultRecordCommand || !defaultSkillLoadCommand) {
569
+ throw new Error('内置默认协议下 BLOCKED 输出的恢复段缺可解析命令:\n' + defaultBlocked.output);
570
+ }
571
+ for (const [label, defaultCommand] of [['record', defaultRecordCommand], ['skill-load', defaultSkillLoadCommand]]) {
572
+ if (defaultCommand.includes('--protocol')) {
573
+ throw new Error('协议来自内置默认时,恢复段的 ' + label + ' 命令不应加 --protocol: ' + defaultCommand);
574
+ }
575
+ }
576
+
577
+ // ---------- 完全没有证据对象:恢复段同样要是可照抄命令(原位扩展;不新增场景条目) ----------
578
+ // 另一个门禁点:节点连 evidence 对象都没有时,前置的「缺证据」门先命中(早于 Output Schema
579
+ // 证据门)。两处说的是同一件事(节点已完成、证据不在),恢复段必须同形——命令形态一致,缺
580
+ // 声明时**同样按执行顺序给两步**。各写一份时,一处两步、另一处只剩 record:照抄第一条就撞
581
+ // record 自己的声明门,第二步的命令还落在另一条报文里(要两次往返还走不通一条路)。
582
+ writeState(dir, baseState('subagent-execute'));
583
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
584
+ const noEvidenceBlocked = runGuard(['exit', 'subagent-execute'], dir);
585
+ assertExit(noEvidenceBlocked, 1);
586
+ assertOut(noEvidenceBlocked, 'BLOCKED: missing evidence for Node subagent-execute.');
587
+ // ① 命令不是孤立的一句:先点名缺的是这个节点的证据对象
588
+ assertOut(noEvidenceBlocked, '该节点已完成但缺证据记录');
589
+ const noEvidenceRecoveryStart = noEvidenceBlocked.output.lastIndexOf('恢复:');
590
+ const noEvidenceRecovery = noEvidenceRecoveryStart < 0
591
+ ? ''
592
+ : noEvidenceBlocked.output.slice(noEvidenceRecoveryStart);
593
+ const noEvidenceRecordCommand = (noEvidenceRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
594
+ if (!noEvidenceRecordCommand) {
595
+ throw new Error('完全没有证据对象时,恢复段必须给出可照抄的 record 命令:\n' + noEvidenceBlocked.output);
596
+ }
597
+ // ② 证据整体缺席 + 缺声明 ⇒ 恢复段必须是**两步**(本格核心):先声明技能加载、再补证据。
598
+ // 只给 record 时,照抄第一步就撞 record 自己的前置门(「节点缺少技能加载声明标记」),第二步
599
+ // 的命令还落在另一条报文里——要两次往返才走通。
600
+ const noEvidenceSkillLoadCommand =
601
+ (noEvidenceRecovery.match(/^\s*(node "[^"]+" skill-load [^\n]+)$/m) || [])[1];
602
+ if (!noEvidenceSkillLoadCommand) {
603
+ throw new Error('证据整体缺席且缺技能加载声明时,恢复段必须同时给出 skill-load 命令'
604
+ + '(否则照抄 record 会被它的前置门拦下,第二步的命令又落在另一条报文里):\n'
605
+ + noEvidenceBlocked.output);
606
+ }
607
+ const noEvidenceSkillAt = noEvidenceRecovery.indexOf(noEvidenceSkillLoadCommand);
608
+ const noEvidenceRecordAt = noEvidenceRecovery.indexOf(noEvidenceRecordCommand);
609
+ if (!(noEvidenceSkillAt >= 0 && noEvidenceRecordAt > noEvidenceSkillAt)) {
610
+ throw new Error('证据缺席的恢复段应按执行顺序排列:skill-load(声明技能加载)在前、'
611
+ + 'record(补证据)在后——顺序反了执行者照抄会先撞前置门:\n' + noEvidenceRecovery);
612
+ }
613
+ // ③ 与缺 Output Schema 字段那条同一构造:两条命令的脚本路径逐字等于 scriptCommand 的产物、
614
+ // 协议上下文随命令走(照抄时不带 --protocol 就落到另一份协议)
615
+ const noEvidencePathPrefix = scriptCommand({ scriptsDir: SCRIPTS_DIR, runRoot: dir, script: 'workflow-state.mjs' });
616
+ for (const [label, noEvidenceCommand] of [['record', noEvidenceRecordCommand], ['skill-load', noEvidenceSkillLoadCommand]]) {
617
+ if (!noEvidenceCommand.startsWith(noEvidencePathPrefix + ' ')) {
618
+ throw new Error('恢复段的 ' + label + ' 命令脚本路径应逐字等于 scriptCommand 产物 '
619
+ + noEvidencePathPrefix + ',实际: ' + noEvidenceCommand);
620
+ }
621
+ if (!noEvidenceCommand.includes(' --protocol "reference/workflow-protocol.json"')) {
622
+ throw new Error('协议不是内置默认时,恢复段的 ' + label + ' 命令必须自带 --protocol: ' + noEvidenceCommand);
623
+ }
624
+ }
625
+ // ④ 照抄打印出来的两条命令并真实执行(环境变量清空——协议上下文只能来自命令本身):按报文给的
626
+ // 顺序走完两步,同一 exit 通过,这条报文才是一条完整的恢复路径。
627
+ const noEvidenceDeclared = runPrintedCommand(noEvidenceSkillLoadCommand, dir, {
628
+ FLOW_COMET_RUN_ROOT: dir,
629
+ FLOW_COMET_PROTOCOL: '',
630
+ });
631
+ assertExit(noEvidenceDeclared, 0);
632
+ assertOut(noEvidenceDeclared, 'SKILL-LOAD: subagent-execute');
633
+ const noEvidenceRecovered = runPrintedCommand(noEvidenceRecordCommand, dir, {
634
+ FLOW_COMET_RUN_ROOT: dir,
635
+ FLOW_COMET_PROTOCOL: '',
636
+ });
637
+ assertExit(noEvidenceRecovered, 0);
638
+ assertEqual(JSON.parse(readStateBytes(dir)).evidence?.['subagent-execute']?.summary, '<本节点完成摘要>',
639
+ '照抄前置门的 record 命令写入的 evidence(协议上下文须随命令到达)');
640
+ const noEvidencePassed = runGuard(['exit', 'subagent-execute'], dir);
641
+ assertExit(noEvidencePassed, 0);
642
+ assertOut(noEvidencePassed, 'ALL CHECKS PASSED');
643
+ // ⑤ 声明已在场(上一步刚声明)⇒ 同一门禁点收敛回一条 record:不多给一步(否则把「已经做过
644
+ // 的事」再让人做一遍)。断言只看恢复段。
645
+ writeState(dir, baseState('subagent-execute'));
646
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
647
+ const declaredNoEvidence = runGuard(['exit', 'subagent-execute'], dir);
648
+ assertExit(declaredNoEvidence, 1);
649
+ const declaredNoEvidenceStart = declaredNoEvidence.output.lastIndexOf('恢复:');
650
+ const declaredNoEvidenceBlock = declaredNoEvidenceStart < 0
651
+ ? ''
652
+ : declaredNoEvidence.output.slice(declaredNoEvidenceStart);
653
+ if (!declaredNoEvidenceBlock.includes(noEvidenceRecordCommand)) {
654
+ throw new Error('已有声明时,缺证据的恢复段应仍给出同一条 record 命令:\n' + declaredNoEvidence.output);
655
+ }
656
+ if (/skill-load\s/.test(declaredNoEvidenceBlock) || /第一步|第二步/.test(declaredNoEvidenceBlock)) {
657
+ throw new Error('已有技能声明时恢复段不得再给 skill-load 步骤:\n' + declaredNoEvidenceBlock);
658
+ }
659
+ // ⑥ 反例:内置默认协议下同一门禁点的命令不加 --protocol(照抄时默认解析落到的就是同一份)
660
+ writeState(dir, baseState('subagent-execute'));
661
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
662
+ const defaultNoEvidenceBlocked = runScriptCopy(
663
+ path.join(dir, '.claude', 'skills', 'flow-comet', 'scripts', 'workflow-guard.mjs'),
664
+ ['exit', 'subagent-execute'],
665
+ dir,
666
+ { FLOW_COMET_RUN_ROOT: dir, FLOW_COMET_PROTOCOL: '' },
667
+ );
668
+ assertExit(defaultNoEvidenceBlocked, 1);
669
+ assertOut(defaultNoEvidenceBlocked, 'BLOCKED: missing evidence for Node subagent-execute.');
670
+ const defaultNoEvidenceStart = defaultNoEvidenceBlocked.output.lastIndexOf('恢复:');
671
+ const defaultNoEvidenceRecovery = defaultNoEvidenceStart < 0
672
+ ? ''
673
+ : defaultNoEvidenceBlocked.output.slice(defaultNoEvidenceStart);
674
+ const defaultNoEvidenceCommand =
675
+ (defaultNoEvidenceRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
676
+ if (!defaultNoEvidenceCommand) {
677
+ throw new Error('完全没有证据对象时恢复段缺可解析的 record 命令:\n' + defaultNoEvidenceBlocked.output);
678
+ }
679
+ if (defaultNoEvidenceCommand.includes('--protocol')) {
680
+ throw new Error('协议来自内置默认时,没有证据对象那条恢复命令不应加 --protocol: ' + defaultNoEvidenceCommand);
681
+ }
56
682
  },
57
683
  },
58
684
 
@@ -114,18 +740,64 @@ export const ENTRIES = [
114
740
  // → 两次均通过;且 evidence 中 redEvidence/greenEvidence 附带 recordedAt 时间戳
115
741
  // (重录保留 red 首次记录时间,green 为补录时间——时序可审计)
116
742
  {
117
- name: '38 handoff red 先于 green 通过(redEvidence/greenEvidence 附带 recordedAt)',
743
+ name: '38 handoff red 先于 green 通过(recordedAt)+ result PREFLIGHT 命令平台化并被真实执行',
118
744
  run: (dir) => {
745
+ writeNodeDeclarationMarkers(dir, 'subagent-execute');
119
746
  writeState(dir, baseState('subagent-execute'));
120
747
  fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
121
748
  const redOnly = '{"redEvidence":{"command":"node --check src/p1.mjs"}}';
122
- const res1 = runHandoff(['result', 'P01', redOnly], dir);
749
+ assertExit(runHandoff(['request', 'P01', 'delegate', '--write-files', 'src/p1.mjs'], dir, { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) }), 0);
750
+ const res1 = runHandoff(['result', 'P01', redOnly], dir, {
751
+ FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir),
752
+ });
123
753
  assertExit(res1, 0);
124
754
  assertOut(res1, 'HANDOFF RESULT: P01');
755
+ // ③ 缺证据的 WARN 点名 Return Contract 的 shape(只差 command 时不必猜字段怎么填)
756
+ assertOut(res1, 'HANDOFF WARN: P01 缺 greenEvidence');
757
+ assertOut(res1, '{command, output}');
758
+ assertOut(res1, 'command 与 output 两个字段');
125
759
  const both = '{"redEvidence":{"command":"node --check src/p1.mjs"},"greenEvidence":{"command":"node --check src/p1.mjs"}}';
126
- const res2 = runHandoff(['result', 'P01', both], dir);
760
+ const res2 = runHandoff(['result', 'P01', both], dir, {
761
+ FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir),
762
+ });
127
763
  assertExit(res2, 0);
128
764
  assertOut(res2, 'HANDOFF RESULT: P01');
765
+ // result 成功路径在 HANDOFF RESULT 之后追加 PREFLIGHT(SUMMARY 结构预检提示)——节点取路由
766
+ // 视图(与 next 的 NODE / status.routeNode 同源),不是 state.currentNode 原值;该行不得改写
767
+ // 既有 HANDOFF RESULT 前缀,也不得出现在失败路径。--preflight 只跑结构性门禁,与「完整 exit
768
+ // (不带 --apply)才是全链预演」两句必须同行,否则同一个 PREFLIGHT 指了两条命令。
769
+ assertOut(res2, 'PREFLIGHT: SUMMARY 结构尚未校验');
770
+ assertOut(res2, '做结构预检(只跑结构性门禁,不写 state、不推进状态)');
771
+ assertOut(res2, '完整 exit(不带 --apply)是节点收尾的全链预演');
772
+ // 路由视图的独立参照:status 是只读视图,其 routeNode 就是 next 会打印的节点。
773
+ const routeView = runState(['status'], dir);
774
+ assertExit(routeView, 0);
775
+ const routeNode = (routeView.output.match(/"routeNode":\s*"([^"]+)"/) ?? [])[1];
776
+ if (!routeNode) {
777
+ throw new Error('status 缺 routeNode(无法独立核对 PREFLIGHT 节点):\n' + routeView.output);
778
+ }
779
+ // PREFLIGHT 命令同样从输出解析(不再与字面串比对):加引号的脚本路径 + exit <路由视图节点> --preflight。
780
+ const preflightCommand = (res2.output.match(/PREFLIGHT: SUMMARY 结构尚未校验——可运行 (node .+?) 做结构预检/) || [])[1];
781
+ if (!preflightCommand) {
782
+ throw new Error('PREFLIGHT 行缺可解析的 exit 命令:\n' + res2.output);
783
+ }
784
+ const printedNode = preflightCommand.match(/^node "[^"]+" exit (\S+) --preflight$/);
785
+ if (!printedNode) {
786
+ throw new Error('PREFLIGHT 命令形态应为「整条加引号的脚本路径 + exit <节点> --preflight」,实际: ' + preflightCommand);
787
+ }
788
+ if (printedNode[1] !== routeNode) {
789
+ throw new Error('PREFLIGHT 节点应取路由视图(与 status.routeNode 同源):'
790
+ + JSON.stringify(printedNode[1]) + ' vs ' + JSON.stringify(routeNode));
791
+ }
792
+ const rawCurrentNode = JSON.parse(readStateBytes(dir)).currentNode;
793
+ if (printedNode[1] === rawCurrentNode) {
794
+ throw new Error('PREFLIGHT 节点不得取 state.currentNode 原值(该夹具的路由视图与 state 原值不同): ' + rawCurrentNode);
795
+ }
796
+ const resultLineAt = res2.output.indexOf('HANDOFF RESULT: P01');
797
+ const preflightLineAt = res2.output.indexOf('PREFLIGHT:');
798
+ if (!(resultLineAt >= 0 && preflightLineAt > resultLineAt)) {
799
+ throw new Error('PREFLIGHT 行必须追加在 HANDOFF RESULT 之后(既有前缀不得改写):\n' + res2.output);
800
+ }
129
801
  const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
130
802
  const rec = st.evidence['subagent-execute'].handoffResult['P01'].result;
131
803
  if (!rec.redEvidence.recordedAt || typeof rec.redEvidence.recordedAt !== 'string') {
@@ -134,6 +806,66 @@ export const ENTRIES = [
134
806
  if (!rec.greenEvidence.recordedAt || typeof rec.greenEvidence.recordedAt !== 'string') {
135
807
  throw new Error('greenEvidence 未附带 recordedAt: ' + JSON.stringify(rec.greenEvidence));
136
808
  }
809
+
810
+ // 协议不可读的降级形态(result 成功路径):不拿 state.currentNode 原值凑一条可能指错节点的
811
+ // 命令,只留「先确认协议可读」的指引与全链预演说明——提示面不得反过来让已落盘的成功路径失败,
812
+ // 也不得在无法解析路由视图时编造节点。
813
+ const noProtocol = runHandoff(['result', 'P01', both], dir);
814
+ assertExit(noProtocol, 0);
815
+ assertOut(noProtocol, 'PREFLIGHT: SUMMARY 结构尚未校验');
816
+ assertOut(noProtocol, '暂时无法解析路由节点');
817
+ assertOut(noProtocol, '完整 exit(不带 --apply)是节点收尾的全链预演');
818
+ assertNotOut(noProtocol, '可运行 node');
819
+
820
+ // ---------- PREFLIGHT 命令的真实执行(安装副本 + 含空格的路径;in-place 扩展) ----------
821
+ // ④ 平台化推导必须是**运行形态**的结果,而不是写死的平台字面量:把技能树复制到运行根下
822
+ // 含空格的相对目录,用副本自身跑 workflow-handoff —— 打印出的路径须带那个空格、整条加引号、
823
+ // 分词后仍是单一脚本参数,并在夹具里真实跑起来(缺引号时这条命令当场作废)。
824
+ const spaceSkillCopy = installSkillTreeCopy(dir, 'user install');
825
+ const resCopy = runScriptCopy(path.join(spaceSkillCopy, 'scripts', 'workflow-handoff.mjs'),
826
+ ['result', 'P01', both], dir, {
827
+ FLOW_COMET_RUN_ROOT: dir,
828
+ FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir),
829
+ });
830
+ assertExit(resCopy, 0);
831
+ assertOut(resCopy, 'HANDOFF RESULT: P01');
832
+ const copyPreflightCommand = (resCopy.output.match(/PREFLIGHT: SUMMARY 结构尚未校验——可运行 (node .+?) 做结构预检/) || [])[1];
833
+ if (!copyPreflightCommand) {
834
+ throw new Error('副本形态的 PREFLIGHT 行缺可解析的 exit 命令:\n' + resCopy.output);
835
+ }
836
+ const stateFile = path.join(dir, '.flow-comet', 'flow-comet-state.json');
837
+ const printedGuardScript = assertPrintedCommandResolves(copyPreflightCommand, dir,
838
+ path.join(spaceSkillCopy, 'scripts', 'workflow-guard.mjs'), 'PREFLIGHT 命令(安装副本形态)');
839
+ if (!printedGuardScript.includes(' ')) {
840
+ throw new Error('该形态的脚本路径应含空格(引号契约的判别场景),实际: ' + printedGuardScript);
841
+ }
842
+ const stateBytesBeforePreflight = fs.readFileSync(stateFile, 'utf8');
843
+ const resPreflight = runPrintedCommand(copyPreflightCommand, dir, {
844
+ FLOW_COMET_RUN_ROOT: dir,
845
+ FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir),
846
+ });
847
+ // 预检 = 只跑结构性门禁、不推进状态:须有真实门禁判决(该夹具本身不完整,通过/阻塞都算真跑),
848
+ // 且 state 字节零改写。
849
+ if (!/(ALL CHECKS PASSED|BLOCKED:)/.test(resPreflight.output)) {
850
+ throw new Error('PREFLIGHT 命令未真正跑到出口门禁(无门禁判决): exit ' + resPreflight.status
851
+ + '\n' + resPreflight.output);
852
+ }
853
+ if (fs.readFileSync(stateFile, 'utf8') !== stateBytesBeforePreflight) {
854
+ throw new Error('PREFLIGHT(--preflight)不得改写 state');
855
+ }
856
+
857
+ // ---------- 无活跃 change 的预检不得报「通过」(in-place 扩展;不新增场景条目) ----------
858
+ // 预检的子判据都按 change 定位(声明工件 / 骨架 / 段 / TASK 字段),没有 activeChange 时它们各自
859
+ // 早退——于是零判据跑完还打印 ALL CHECKS PASSED:这是「没看」被报成「看过且通过」,与只读命令
860
+ // 应有的结论(同 state 的完整 exit 是 BLOCKED)相互矛盾。判据:无可判结构面 → 非零退出且不得
861
+ // 出现通过结论;上面那段(有 activeChange 的真实预检)即「正常 change 不受影响」的对照。
862
+ const noChangeState = baseState('open');
863
+ delete noChangeState.activeChange;
864
+ writeState(dir, noChangeState);
865
+ const noChangePreflight = runGuard(['exit', 'open', '--preflight'], dir);
866
+ assertExit(noChangePreflight, 1);
867
+ assertOut(noChangePreflight, 'PREFLIGHT: 未校验(无活跃 change,没有可判的结构面)');
868
+ assertNotOut(noChangePreflight, 'ALL CHECKS PASSED');
137
869
  },
138
870
  },
139
871
 
@@ -142,15 +874,19 @@ export const ENTRIES = [
142
874
  {
143
875
  name: '39 handoff BLOCKED:greenEvidence 后同批补录 redEvidence',
144
876
  run: (dir) => {
877
+ writeNodeDeclarationMarkers(dir, 'subagent-execute');
145
878
  writeState(dir, baseState('subagent-execute'));
146
879
  fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
147
880
  const greenOnly = '{"greenEvidence":{"command":"node --check src/p1.mjs"}}';
881
+ assertExit(runHandoff(['request', 'P01', 'delegate', '--write-files', 'src/p1.mjs'], dir, { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) }), 0);
148
882
  const res1 = runHandoff(['result', 'P01', greenOnly], dir);
149
883
  assertExit(res1, 0);
150
884
  const backfill = '{"greenEvidence":{"command":"node --check src/p1.mjs"},"redEvidence":{"command":"node --check src/p1.mjs"}}';
151
885
  const res2 = runHandoff(['result', 'P01', backfill], dir);
152
886
  assertExit(res2, 1);
153
887
  assertOut(res2, 'redEvidence 事后补录');
888
+ // 拦截路径不打印 PREFLIGHT(提示只在「结果已记录、可以预检了」的成功路径出现)
889
+ assertNotOut(res2, 'PREFLIGHT');
154
890
  },
155
891
  },
156
892
 
@@ -161,7 +897,10 @@ export const ENTRIES = [
161
897
  {
162
898
  name: '40 execute exit 通过:TASK LF→CRLF 行尾变化签名一致',
163
899
  run: (dir) => {
900
+ // 单轨夹具前置:direct 模式(本格测签名判定,不涉及委托归属)+ 声明齐备
901
+ writeNodeDeclarationMarkers(dir, 'execute');
164
902
  const st = baseState('execute');
903
+ st.executionMode = 'direct';
165
904
  st.evidence.execute = { summary: 'executed' };
166
905
  writeState(dir, st);
167
906
  // LF 版本任务集(enter 时记录签名)
@@ -170,8 +909,8 @@ export const ENTRIES = [
170
909
  assertExit(runGuard(['entry', 'execute'], dir), 0);
171
910
  // 同一任务集改写为 CRLF 行尾(仅行尾差异,逻辑内容不变)
172
911
  writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskLF.replace(/\n/g, '\r\n'));
173
- writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
174
- writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', summaryContent()); // M2: 新 change 强制 done 任务须有 SUMMARY
912
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
913
+ writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', strictSummary('T01')); // M2: 新 change 强制 done 任务须有 SUMMARY
175
914
  const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
176
915
  st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'P01']) };
177
916
  writeState(dir, st2);
@@ -183,7 +922,7 @@ export const ENTRIES = [
183
922
 
184
923
  // 41: execute exit BLOCKED——TASK.md 任务内容实际变化(改 action 文本)→ 签名不同 → 严格拦截
185
924
  {
186
- name: '41 execute exit BLOCKED:任务内容变化签名不同',
925
+ name: '41 execute exit BLOCKED:任务内容变化签名不同 + replan 重签事实说明',
187
926
  run: (dir) => {
188
927
  const st = baseState('execute');
189
928
  st.evidence.execute = { summary: 'executed' };
@@ -194,13 +933,49 @@ export const ENTRIES = [
194
933
  // 逻辑内容变化(T01 action 文本被改),行尾保持 LF 不变
195
934
  const changed = taskLF.replace('实现 T01', '实现 T01 并补充单元测试');
196
935
  writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', changed);
197
- writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
936
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
198
937
  const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
199
938
  st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'P01']) };
200
939
  writeState(dir, st2);
201
940
  const res = runGuard(['exit', 'execute'], dir);
202
941
  assertExit(res, 1);
203
942
  assertOut(res, 'TASK.md 任务集被修改');
943
+
944
+ // ---------- replan 成功行说明「重签了什么、没有做什么」(in-place 扩展) ----------
945
+ // ② 签名不一致 BLOCK 后的合规出路是 replan:成功行保持既有 REPLAN: 前缀不变,其后追加
946
+ // 一行事实说明——已重签 state.taskHash(值前缀标出版本),且 TASK.md 内容未改写、plan
947
+ // 节点证据未重记(防执行者误以为 replan 会重写计划工件或重跑 plan 出口)。
948
+ const resReplan = runStateWithProtocol(dir, ['replan', '任务集按实测修订', '--authorized-by', 'user-approval']);
949
+ assertExit(resReplan, 0);
950
+ assertOut(resReplan, 'REPLAN: execute');
951
+ assertOut(resReplan, '已重签 state.taskHash(值前缀 ');
952
+ assertOut(resReplan, 'TASK.md 内容未改写');
953
+ assertOut(resReplan, 'plan 节点证据未重记');
954
+ // 版本前缀从**实际签名**派生,不写死 v1:——算法升版时这里不会假红。
955
+ // 判据三点:① 行在场且带前缀;② 打印前缀 == 当前 TASK.md 签名的版本前缀;③ 落盘值等于签名。
956
+ const taskHashLine = resReplan.output.split(/\r?\n/).find((line) => line.startsWith('TASKHASH: '));
957
+ if (!taskHashLine) {
958
+ throw new Error('replan 成功行后缺 TASKHASH 事实说明:\n' + resReplan.output);
959
+ }
960
+ const printedSignaturePrefix = (taskHashLine.match(/值前缀 (v\d+:)/) ?? [])[1];
961
+ const replanTaskText = fs.readFileSync(path.join(dir, '.specs', CHANGE_ID, 'TASK.md'), 'utf8');
962
+ const actualSignature = String(requireRouteNodeExport('taskSetSignature')(replanTaskText));
963
+ const actualSignaturePrefix = actualSignature.split(':')[0] + ':';
964
+ if (printedSignaturePrefix !== actualSignaturePrefix) {
965
+ throw new Error('TASKHASH 行打印的版本前缀应与实际签名一致(算法升版不得假红):'
966
+ + JSON.stringify(printedSignaturePrefix) + ' vs ' + JSON.stringify(actualSignaturePrefix)
967
+ + '(实际签名 ' + actualSignature + ')');
968
+ }
969
+ const replanPersisted = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
970
+ if (replanPersisted.taskHash !== actualSignature) {
971
+ throw new Error('replan 重签的 state.taskHash 应等于当前 TASK.md 的实际签名:'
972
+ + JSON.stringify(replanPersisted.taskHash) + ' vs ' + JSON.stringify(actualSignature));
973
+ }
974
+ const replanLineAt = resReplan.output.indexOf('REPLAN: execute');
975
+ const replanDetailAt = resReplan.output.indexOf('已重签 state.taskHash');
976
+ if (!(replanLineAt >= 0 && replanDetailAt > replanLineAt)) {
977
+ throw new Error('replan 事实说明必须在 REPLAN 成功行之后(前缀语义不变):\n' + resReplan.output);
978
+ }
204
979
  },
205
980
  },
206
981
 
@@ -253,7 +1028,10 @@ export const ENTRIES = [
253
1028
  {
254
1029
  name: '44 execute exit 通过:追加 completed_at 标记属性签名一致',
255
1030
  run: (dir) => {
1031
+ // 单轨夹具前置:direct 模式 + 声明齐备(同上)
1032
+ writeNodeDeclarationMarkers(dir, 'execute');
256
1033
  const st = baseState('execute');
1034
+ st.executionMode = 'direct';
257
1035
  st.evidence.execute = { summary: 'executed' };
258
1036
  writeState(dir, st);
259
1037
  const taskLF = '# TASK\n\n' + TASK_DONE + TASK_P1;
@@ -262,8 +1040,8 @@ export const ENTRIES = [
262
1040
  // 子代理标记 task done:T01 开标签追加 completed_at 属性(其余逻辑内容不变)
263
1041
  const marked = taskLF.replace('id="T01"', 'id="T01" completed_at="2026-08-07"');
264
1042
  writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', marked);
265
- writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
266
- writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', summaryContent()); // M2: 新 change 强制 done 任务须有 SUMMARY
1043
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
1044
+ writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', strictSummary('T01')); // M2: 新 change 强制 done 任务须有 SUMMARY
267
1045
  const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
268
1046
  st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'P01']) };
269
1047
  writeState(dir, st2);
@@ -289,7 +1067,7 @@ export const ENTRIES = [
289
1067
  .replace('id="T01"', 'id="T01" completed_at="2026-08-07"')
290
1068
  .replace('实现 T01', '实现 T01(改)');
291
1069
  writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', changed);
292
- writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
1070
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
293
1071
  const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
294
1072
  st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'P01']) };
295
1073
  writeState(dir, st2);
@@ -352,12 +1130,19 @@ export const ENTRIES = [
352
1130
  {
353
1131
  name: '48 execute exit BLOCKED:record 覆盖 handoff(越俎代庖)',
354
1132
  run: (dir) => {
1133
+ writeNodeDeclarationMarkers(dir, 'execute');
1134
+ writeNodeDeclarationMarkers(dir, 'subagent-execute');
355
1135
  const st = baseState('execute');
356
1136
  st.evidence.execute = { summary: 'executed' };
357
1137
  writeState(dir, st);
358
1138
  writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
359
- writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
1139
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
360
1140
  // ① workflow-handoff result 正确记录 T01 的 Return Contract(含 completedChecks)
1141
+ // 单轨:result 必须有对应 request(未记录的委托不能回传结果)——夹具补同一份事实
1142
+ const pre48 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
1143
+ pre48.evidence['subagent-execute'] = pre48.evidence['subagent-execute'] || {};
1144
+ pre48.evidence['subagent-execute'].handoffRequests = { T01: { description: 'delegate', writeFiles: ['src/t1.mjs'] } };
1145
+ writeState(dir, pre48);
361
1146
  const res = runHandoff(['result', 'T01', JSON.stringify({
362
1147
  commitHash: 'abcd1234',
363
1148
  completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
@@ -375,6 +1160,10 @@ export const ENTRIES = [
375
1160
  throw new Error('record 未整体覆盖 handoffResult(T01 应被覆盖丢失): ' + JSON.stringify(st2.evidence['subagent-execute']));
376
1161
  }
377
1162
  // ③ exit execute:T01 done 但 handoff 已被覆盖丢失 → 越俎代庖 BLOCK
1163
+ // (单轨:record 的覆盖写把 request 一起清掉,否则先撞「在飞委托」——被测的是越俎代庖这一门)
1164
+ const preExit2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
1165
+ delete preExit2.evidence['subagent-execute'].handoffRequests;
1166
+ writeState(dir, preExit2);
378
1167
  const res2 = runGuard(['exit', 'execute'], dir);
379
1168
  assertExit(res2, 1);
380
1169
  assertOut(res2, '越俎代庖');
@@ -386,7 +1175,7 @@ export const ENTRIES = [
386
1175
  // next 重新路由回 subagent-execute(多趟循环路由——委托进入谓词每趟重新求值,单趟限制已移除);
387
1176
  // entry subagent-execute 仍放行(completedNodes 含该节点允许重入——每趟完整 entry 检查不绕过)
388
1177
  {
389
- name: '49 next 二次路由回 subagent-execute + entry 重入(多趟语义)',
1178
+ name: '49 next 二次路由回 subagent-execute + entry 重入(多趟语义)+ 归属受阻后 record+exit 恢复',
390
1179
  run: (dir) => {
391
1180
  writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n');
392
1181
  writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n');
@@ -404,6 +1193,133 @@ export const ENTRIES = [
404
1193
  const res2 = runGuard(['entry', 'subagent-execute'], dir);
405
1194
  assertExit(res2, 0);
406
1195
  assertOut(res2, 'ENTRY OK');
1196
+
1197
+ // ---------- request 归属受阻的新恢复路径(in-place 扩展) ----------
1198
+ // ④ 串行 pending 任务在 subagent-execute 发起 request → 归属门禁 BLOCK。报文不再承诺
1199
+ // 「先 next 再 entry 目标节点」(当前节点已 entry 未 exit 时会被节点顺序门拦),改为
1200
+ // 「先对当前节点 record + exit(退出后路由自动前进到目标节点)」;并断言按此指引真能走通。
1201
+ const stateFile = path.join(dir, '.flow-comet', 'flow-comet-state.json');
1202
+ const loadsDir = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
1203
+ fs.mkdirSync(loadsDir, { recursive: true });
1204
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/subagent-execute-flow-comet-dev.json',
1205
+ JSON.stringify({
1206
+ node: 'subagent-execute',
1207
+ skill: 'flow-comet-dev',
1208
+ protocol: '4-dev.md',
1209
+ templates: ['SUMMARY'],
1210
+ at: '2026-08-01T00:00:00.000Z',
1211
+ }, null, 2) + '\n');
1212
+ writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n');
1213
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n');
1214
+ writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# DESIGN\n\n## 0. 技术栈\n');
1215
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
1216
+ + '<task id="S01" parallel="false" status="pending">\n'
1217
+ + ' <name>串行任务 S01</name>\n'
1218
+ + ' <read_files>.specs/' + CHANGE_ID + '/TASK.md</read_files>\n'
1219
+ + ' <write_files>src/s01.mjs</write_files>\n'
1220
+ + ' <action>实现 S01</action>\n'
1221
+ + ' <verify>node --check src/s01.mjs</verify>\n'
1222
+ + ' <done>完成 S01</done>\n'
1223
+ + ' <depends_on></depends_on>\n'
1224
+ + '</task>\n');
1225
+ const reqState = baseState('subagent-execute');
1226
+ reqState.completedNodes = ['open', 'design', 'plan'];
1227
+ reqState.evidence = {
1228
+ open: { summary: 'open done' },
1229
+ design: { summary: 'design done' },
1230
+ plan: { summary: 'plan done' },
1231
+ };
1232
+ writeState(dir, reqState);
1233
+ // 真实 entry(记录 enteredNodes + 任务集签名;request 前置门要求本节点声明标记,已写)
1234
+ assertExit(runGuardWithProtocol(dir, ['entry', 'subagent-execute']), 0);
1235
+ // 开工前的 LESSONS 命中集是只读信息:教训册在场时 request 打印本任务的命中集(本夹具任务的写面
1236
+ // 词元 s01 命中条目 L-601);下面同时锚定它不改写 state、不改写教训册。
1237
+ const lessonsFile = path.join(dir, '.specs', 'LESSONS.md');
1238
+ writeFile(dir, '.specs/LESSONS.md', '# LESSONS\n\n## 条目区(夹具)\n\n### L-601 · [proc] 委托边界须留痕\n\n- **关键词**: s01 委托边界\n');
1239
+ const lessonsBytesBefore = fs.readFileSync(lessonsFile, 'utf8');
1240
+ // ---------- 声明标记必须属于本 change(原位扩展;不新增场景条目) ----------
1241
+ // 归档兜底只认本 change 自己的声明目录:活动 .skill-loads 在场时不再回溯归档(record 前置门
1242
+ // 与委托前置门同一份判据)。委托前置门曾经自持一份扫描,会扫遍所有后缀匹配 -<change-id> 的
1243
+ // 归档目录——别的 change 归档里的同名标记也能替本节点作证,等于在门禁上留了一个放行口。
1244
+ const decoyEntry = '2026-01-01-other-' + CHANGE_ID;
1245
+ writeFile(dir, '.specs/archive/' + decoyEntry + '/.skill-loads/subagent-execute-flow-comet-dev.json',
1246
+ JSON.stringify({ node: 'subagent-execute', skill: 'flow-comet-dev', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
1247
+ // 本 change 只声明了别的节点:把本节点标记临时改名,活动目录仍在场
1248
+ const activeMarker = path.join(loadsDir, 'subagent-execute-flow-comet-dev.json');
1249
+ const otherNodeMarker = path.join(loadsDir, 'plan-flow-comet-plan.json');
1250
+ fs.renameSync(activeMarker, otherNodeMarker);
1251
+ const bytesBeforeDecoy = fs.readFileSync(stateFile, 'utf8');
1252
+ const resDecoy = runHandoff(['request', 'S01', 'serial slice'], dir,
1253
+ { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) });
1254
+ assertExit(resDecoy, 1);
1255
+ assertOut(resDecoy, 'BLOCKED: 节点 subagent-execute 缺少技能加载声明标记');
1256
+ assertNotOut(resDecoy, 'HANDOFF REQUEST');
1257
+ if (fs.readFileSync(stateFile, 'utf8') !== bytesBeforeDecoy) {
1258
+ throw new Error('缺声明 BLOCK 必须 state 字节零改写(别的 change 归档标记不得替本节点作证)');
1259
+ }
1260
+ // 活动 .skill-loads/ 不存在(新 change 尚未声明的真实初始态)时,归档兜底同样不得把「同后缀
1261
+ // 但不同 change」的归档目录认作本 change:上面那条诱饵只在活动目录在场时被「活动优先」挡住,
1262
+ // 活动目录一撤,后缀匹配仍会命中 2026-01-01-other-<change-id>——别的 change 的声明替本节点作证,
1263
+ // 委托前置门于是放行(实测该形态打印出 HANDOFF REQUEST)。归档目录必须是 <YYYY-MM-DD>-<本
1264
+ // change> 的精确形态才作数。
1265
+ const loadsAside = path.join(dir, '.specs', 'loads-aside');
1266
+ fs.renameSync(loadsDir, loadsAside);
1267
+ const bytesBeforeSuffixDecoy = fs.readFileSync(stateFile, 'utf8');
1268
+ const resSuffixDecoy = runHandoff(['request', 'S01', 'serial slice'], dir,
1269
+ { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) });
1270
+ assertExit(resSuffixDecoy, 1);
1271
+ assertOut(resSuffixDecoy, 'BLOCKED: 节点 subagent-execute 缺少技能加载声明标记');
1272
+ assertNotOut(resSuffixDecoy, 'HANDOFF REQUEST');
1273
+ if (fs.readFileSync(stateFile, 'utf8') !== bytesBeforeSuffixDecoy) {
1274
+ throw new Error('同后缀异 change 的归档目录不得替本节点作证:BLOCK 必须 state 字节零改写');
1275
+ }
1276
+ fs.renameSync(loadsAside, loadsDir);
1277
+ // 复位:本节点标记归位、归档诱饵撤掉——后续段按「已声明」继续
1278
+ fs.renameSync(otherNodeMarker, activeMarker);
1279
+ fs.rmSync(path.join(dir, '.specs', 'archive'), { recursive: true, force: true });
1280
+ const bytesBeforeRequest = fs.readFileSync(stateFile, 'utf8');
1281
+ const resOwnership = runHandoff(['request', 'S01', 'serial slice'], dir,
1282
+ { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) });
1283
+ assertExit(resOwnership, 1);
1284
+ assertOut(resOwnership, 'BLOCKED: 任务 S01(串行 pending)应归属节点 execute');
1285
+ // 新指引:先 record + exit 当前节点;不再承诺「先 next 再 entry 目标节点」
1286
+ assertOut(resOwnership, '先对当前节点 subagent-execute record + exit');
1287
+ assertOut(resOwnership, '不要在未 exit 前 entry 目标节点');
1288
+ assertOut(resOwnership, 'workflow-state next');
1289
+ // 同口径:entry 只在当前节点 exit 之后才允许——断言顺序句里的条件分句与前后次序,
1290
+ // 不再裸断 'entry execute'(禁止句也会命中它,断言不出「让你 entry」与「禁止现在 entry」)。
1291
+ const ownershipGuide = resOwnership.output.split('\n').find((line) => line.includes('恢复指引:'));
1292
+ if (!ownershipGuide) {
1293
+ throw new Error('归属受阻输出缺恢复指引行:\n' + resOwnership.output);
1294
+ }
1295
+ assertOut(resOwnership, '等当前节点 exit 后,再用 workflow-state entry execute');
1296
+ if (!(ownershipGuide.indexOf('record + exit') >= 0
1297
+ && ownershipGuide.indexOf('record + exit') < ownershipGuide.indexOf('entry execute'))) {
1298
+ throw new Error('恢复指引顺序错误:entry 目标节点必须排在 record + exit 之后:' + ownershipGuide);
1299
+ }
1300
+ assertNotOut(resOwnership, '查看当前路由,按 NODE 输出进入');
1301
+ assertNotOut(resOwnership, 'HANDOFF REQUEST');
1302
+ // 命中集在归属门禁之前打印(BLOCK 路径不落 state):打印面只读——state 字节零改写、教训册字节零改写
1303
+ assertOut(resOwnership, 'LESSONS-HITS: 1 条');
1304
+ assertOut(resOwnership, 'L-601');
1305
+ if (fs.readFileSync(lessonsFile, 'utf8') !== lessonsBytesBefore) {
1306
+ throw new Error('开工前的命中集打印不得改写教训册');
1307
+ }
1308
+ if (fs.readFileSync(stateFile, 'utf8') !== bytesBeforeRequest) {
1309
+ throw new Error('归属受阻 BLOCK 必须 state 字节零改写(含开工前打印的命中集)');
1310
+ }
1311
+ // 照报文操作:record 当前节点 + exit --apply(退出后路由自动前进到目标节点)
1312
+ assertExit(runStateWithProtocol(dir, ['record', 'subagent-execute', '{"summary":"串行任务需回 execute 节点执行"}']), 0);
1313
+ const exitOwnership = runGuardWithProtocol(dir, ['exit', 'subagent-execute', '--apply']);
1314
+ assertExit(exitOwnership, 0);
1315
+ const stateAfterRecovery = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
1316
+ if (stateAfterRecovery.currentNode !== 'execute') {
1317
+ throw new Error('按新指引 record+exit 后 currentNode 应前进到 execute,实际: '
1318
+ + JSON.stringify(stateAfterRecovery.currentNode));
1319
+ }
1320
+ const nextAfterRecovery = runStateWithProtocol(dir, ['next']);
1321
+ assertExit(nextAfterRecovery, 0);
1322
+ assertOut(nextAfterRecovery, 'NODE: execute');
407
1323
  },
408
1324
  },
409
1325
 
@@ -545,11 +1461,14 @@ export const ENTRIES = [
545
1461
  },
546
1462
  },
547
1463
 
548
- // ---------- 场景(归档完成态不兜底识别残留目录) ----------
1464
+ // ---------- 场景(归档完成态不兜底识别残留目录 / 身份只由状态判定) ----------
549
1465
 
550
- // 59: state 为归档完成态(completed + activeChange null)→ .specs/ 顶层残留目录(含 TASK.md)不被兜底识别
1466
+ // 59: state 为归档完成态(completed + activeChange null)→ .specs/ 顶层残留目录(含 TASK.md)不被兜底识别。
1467
+ // 原位扩展(身份与位置分离):在办只由状态判定(activeChange 非空 ∧ status≠completed),目录位置
1468
+ // 只是存储位置;`.specs/` 扫描是「state 丢失」的恢复通道,**不是第二身份来源**。移入同一场景的理由 =
1469
+ // 判据同一:本场景已是「身份从哪里来」的锚点,位置解析只是同一事实的另一半(不新增场景)。
551
1470
  {
552
- name: '59 归档后残留目录不误判为 active',
1471
+ name: '59 归档后残留目录不误判为 active + 身份只由状态判定(目录缺失/移动后)',
553
1472
  run: (dir) => {
554
1473
  writeState(dir, composeState({ status: 'completed', activeChange: null, currentNode: null }));
555
1474
  writeFile(dir, '.specs/stale/CHANGE.md', '# CHANGE\n## Why\nx\n');
@@ -558,6 +1477,153 @@ export const ENTRIES = [
558
1477
  assertExit(res, 0);
559
1478
  assertOut(res, 'no-change');
560
1479
  assertNotOut(res, 'stale');
1480
+
1481
+ // ---------- 身份与位置(原位扩展 · ① 目录缺失 fail-closed / ② 移动后同一结论 / ③ 推导读归档产物) ----------
1482
+ // 三格按「修复前会得到什么答案」构造:修复前 findActiveChange 把「进行中」绑在**活动目录存在**上,
1483
+ // 活动目录不在就落到 `.specs/` 扫描分支——上一步留下的 .specs/stale(有 TASK.md)因此会接管身份
1484
+ // (把 stale 当成本 change)或干脆返回 null(打 no-change)。两种都是假答案:身份来自 state,位置
1485
+ // 解析不到时必须 fail-closed 点名两处路径,不得假装「没有在办 change」。
1486
+ const MOVED = 'loc-moved';
1487
+ const ARCHIVE_REL = '.specs/archive/2026-11-05-' + MOVED;
1488
+ const completedAll = ['open', 'design', 'plan', 'execute', 'subagent-execute', 'review', 'verify'];
1489
+ const locationState = (changeName) => {
1490
+ const evidence = {};
1491
+ for (const nodeId of completedAll) evidence[nodeId] = { summary: nodeId + ' done' };
1492
+ return {
1493
+ activeChange: changeName,
1494
+ currentNode: 'archive',
1495
+ completedNodes: completedAll.slice(),
1496
+ evidence,
1497
+ verifyFailures: 0,
1498
+ executionMode: 'subagent',
1499
+ directOverride: false,
1500
+ enteredNodes: completedAll.concat('archive'),
1501
+ status: 'running',
1502
+ createdAt: '2026-11-01T00:00:00Z',
1503
+ branchMode: false,
1504
+ enablePrReview: false,
1505
+ branchPrefix: 'change/',
1506
+ };
1507
+ };
1508
+ // ① running-orphan:两处目录都没有(活动目录 + 归档目录)→ 三命令 fail-closed,且不得假装 no-change。
1509
+ // 诱饵 .specs/stale 仍在场:state 有在办 change 时扫描结果不得接管身份(否则 status 报 stale)。
1510
+ writeState(dir, locationState('loc-orphan'));
1511
+ const orphanBytes = readStateBytes(dir);
1512
+ const orphanStatus = runStateWithProtocol(dir, ['status']);
1513
+ assertExit(orphanStatus, 1);
1514
+ assertOut(orphanStatus, 'BLOCKED: change 目录缺失');
1515
+ assertOut(orphanStatus, '.specs/loc-orphan');
1516
+ assertOut(orphanStatus, '.specs/archive/');
1517
+ assertNotOut(orphanStatus, 'no-change');
1518
+ assertNotOut(orphanStatus, '"change": "stale"');
1519
+ const orphanNext = runStateWithProtocol(dir, ['next']);
1520
+ assertExit(orphanNext, 1);
1521
+ assertOut(orphanNext, 'BLOCKED: change 目录缺失');
1522
+ assertNotOut(orphanNext, 'NEXT: done');
1523
+ assertNotOut(orphanNext, 'NODE: ');
1524
+ const orphanRecord = runStateWithProtocol(dir, ['record', 'archive', '{"summary":"orphan"}']);
1525
+ assertExit(orphanRecord, 1);
1526
+ assertOut(orphanRecord, 'BLOCKED: change 目录缺失');
1527
+ assertStateBytesUnchanged(dir, orphanBytes, '目录缺失时 record 不得改写 state');
1528
+
1529
+ // ② running-moved:同一份 state + 同一份完整产物集,先跑「移动前」再跑「移动后」——两条命令在
1530
+ // 两种位置下必须给出**同一结论**(在办 / archive 节点 / 下一步 exit),差别只在落点路径。
1531
+ const artifacts = {
1532
+ 'CHANGE.md': '# CHANGE\n\n## Why\n\nx\n',
1533
+ 'REQUIREMENT.md': '# REQUIREMENT\n\n## 用户故事\n\nx\n\n## 验收准则(AC)\n\n- Given x When y Then z\n',
1534
+ 'DESIGN.md': '# DESIGN\n\n## 决策清单\n\n- 单轨\n',
1535
+ 'TASK.md': '# TASK\n\n' + TASK_DONE,
1536
+ 'T01-SUMMARY.md': '# SUMMARY: T01 - 夹具\n\n## 做了什么\n\nx\n',
1537
+ 'REVIEW.md': '# REVIEW\n\n## 汇总\n\n- 通过\n',
1538
+ 'TEST.md': '# TEST\n\n## 验证命令\n\n```bash\necho ok\n```\n',
1539
+ 'UAT.md': '# UAT\n\n## 验收结果\n\n- 通过\n',
1540
+ 'KNOWN-ISSUES.md': '# KNOWN-ISSUES\n\n无遗留问题\n',
1541
+ };
1542
+ for (const [name, content] of Object.entries(artifacts)) {
1543
+ writeFile(dir, '.specs/' + MOVED + '/' + name, content);
1544
+ }
1545
+ // 归档节点的技能加载声明(随目录一起搬家——真实归档动作下标记天然跟随)
1546
+ writeNodeDeclarationMarkers(dir, 'archive', { changeId: MOVED });
1547
+ writeState(dir, locationState(MOVED));
1548
+ const beforeStatus = runStateWithProtocol(dir, ['status']);
1549
+ assertExit(beforeStatus, 0);
1550
+ const beforeJson = parseStatusJson(beforeStatus);
1551
+ assertEqual(beforeJson.status, 'running', '移动前 status.status');
1552
+ assertEqual(beforeJson.change, MOVED, '移动前 status.change');
1553
+ assertEqual(beforeJson.currentNode, 'archive', '移动前 status.currentNode(产物推导)');
1554
+ assertEqual(beforeJson.routeNode, 'archive', '移动前 status.routeNode');
1555
+ assertEqual(beforeJson.artifactRoot, '.specs/' + MOVED, '移动前 artifactRoot = 活动目录');
1556
+ const beforeNext = runStateWithProtocol(dir, ['next']);
1557
+ assertExit(beforeNext, 0);
1558
+ assertTrue(/^NODE: archive$/m.test(beforeNext.output), '移动前 next 应报 NODE: archive\n' + beforeNext.output);
1559
+ // 真实归档动作:目录整体搬进 .specs/archive/<日期>-<change-id>/
1560
+ fs.mkdirSync(path.join(dir, '.specs', 'archive'), { recursive: true });
1561
+ fs.renameSync(path.join(dir, '.specs', MOVED), path.join(dir, '.specs', 'archive', '2026-11-05-' + MOVED));
1562
+ const movedStatus = runStateWithProtocol(dir, ['status']);
1563
+ assertExit(movedStatus, 0);
1564
+ const movedJson = parseStatusJson(movedStatus);
1565
+ assertEqual(movedJson.status, 'running', '移动后 status 仍报进行中(不得回落到 no-change)');
1566
+ assertEqual(movedJson.change, MOVED, '移动后的身份 = state.activeChange');
1567
+ // ③ 节点推导读归档产物:产物随目录搬进归档后仍被认到 ⇒ 推导落在 archive;读不到会回退 open。
1568
+ assertEqual(movedJson.currentNode, 'archive', '移动后 currentNode 必须按归档产物推导(不得回退 open)');
1569
+ assertEqual(movedJson.routeNode, 'archive', '移动后 routeNode(= next 的 NODE 行)');
1570
+ assertEqual(movedJson.artifactRoot, ARCHIVE_REL, '移动后 artifactRoot = 解析到的归档目录');
1571
+ assertNotOut(movedStatus, 'no-change');
1572
+ assertOut(movedStatus, 'ROUTE: ');
1573
+ const movedNext = runStateWithProtocol(dir, ['next']);
1574
+ assertExit(movedNext, 0);
1575
+ assertTrue(/^NODE: archive$/m.test(movedNext.output), '移动后 next 应报 NODE: archive(不推 open)\n' + movedNext.output);
1576
+ assertNotOut(movedNext, 'NEXT: done');
1577
+ assertNotOut(movedNext, 'NODE: open');
1578
+ // record 的尾部节点视图与 next / status 同源:移动后不得打印 NODE: open(那是「归档产物没被认到」的
1579
+ // 典型假答案),证据照常写入 state,且不得重建活动目录(位置只读)。
1580
+ const movedRecord = runStateWithProtocol(dir, ['record', 'archive', '{"summary":"archived"}']);
1581
+ assertExit(movedRecord, 0);
1582
+ assertOut(movedRecord, 'EVIDENCE: archive');
1583
+ assertTrue(/^NODE: archive$/m.test(movedRecord.output), '移动后 record 的尾部视图不得回退 open\n' + movedRecord.output);
1584
+ if (fs.existsSync(path.join(dir, '.specs', MOVED))) {
1585
+ throw new Error('移动后 record 重建了活动目录: .specs/' + MOVED + '/');
1586
+ }
1587
+ if (!fs.existsSync(path.join(dir, '.specs', 'archive', '2026-11-05-' + MOVED))) {
1588
+ throw new Error('移动后归档目录应仍在: ' + ARCHIVE_REL);
1589
+ }
1590
+
1591
+ // ---------- ④ 节点顺序门禁的恢复句同样按目录在哪分叉(原位扩展:同一分叉的第四处消费方) ----------
1592
+ // 第四次出现的同一问题:这条 BLOCK 报告的是「该节点从未 exit」,出口侧(guard-gates /
1593
+ // guard-evidence-gates)早已按目录在哪换一种说法,next 侧却还在固定推销 advance / select。
1594
+ // 归档态下 select 要求活动目录在场、advance 的产物推导读活动路径——两条都走不通,报文只能给
1595
+ // 可执行的那一步(把目录移回活动位置)。活动态对照必须**逐字不变**(同一句话仍给 advance /
1596
+ // select),否则「归档态收敛」是用活动态退化换来的。
1597
+ const ORDER = 'loc-order';
1598
+ const orderState = () => {
1599
+ const state = locationState(ORDER);
1600
+ // 顺序门禁的触发条件 = currentNode 未 exit(不在 completedNodes)且无任何证据。已完成节点
1601
+ // 的证据必须在场,否则 lastEvidence 校验不通过、判定会落到别的分支。
1602
+ state.currentNode = 'execute';
1603
+ state.completedNodes = ['open', 'design'];
1604
+ state.evidence = { open: { summary: 'open done' }, design: { summary: 'design done' } };
1605
+ state.enteredNodes = ['open', 'design'];
1606
+ return state;
1607
+ };
1608
+ // 活动态对照:活动目录在场 → 恢复句仍是 advance / select
1609
+ fs.mkdirSync(path.join(dir, '.specs', ORDER), { recursive: true });
1610
+ writeState(dir, orderState());
1611
+ const activeOrderNext = runStateWithProtocol(dir, ['next']);
1612
+ assertExit(activeOrderNext, 1);
1613
+ assertOut(activeOrderNext, 'BLOCKED: 疑似未 exit 节点 execute');
1614
+ assertOut(activeOrderNext, 'advance');
1615
+ assertOut(activeOrderNext, 'select(切换 change)');
1616
+ assertNotOut(activeOrderNext, '移回活动位置');
1617
+ // 归档态:目录真实搬进归档 → 恢复句换成唯一可执行的那一步,不再推荐 advance / select
1618
+ fs.renameSync(path.join(dir, '.specs', ORDER), path.join(dir, '.specs', 'archive', '2026-11-06-' + ORDER));
1619
+ writeState(dir, orderState());
1620
+ const archivedOrderNext = runStateWithProtocol(dir, ['next']);
1621
+ assertExit(archivedOrderNext, 1);
1622
+ assertOut(archivedOrderNext, 'BLOCKED: 疑似未 exit 节点 execute');
1623
+ assertOut(archivedOrderNext, '移回活动位置');
1624
+ assertOut(archivedOrderNext, '.specs/' + ORDER + '/');
1625
+ assertNotOut(archivedOrderNext, 'advance');
1626
+ assertNotOut(archivedOrderNext, 'select(切换 change)');
561
1627
  },
562
1628
  },
563
1629
 
@@ -640,6 +1706,54 @@ export const ENTRIES = [
640
1706
  if (ev.completedChecks === undefined) {
641
1707
  throw new Error('completedChecks 丢失(payload 未解析为对象): ' + JSON.stringify(ev));
642
1708
  }
1709
+
1710
+ // ---------- 载荷形状校验(in-place 扩展;不新增场景条目) ----------
1711
+ // 缺陷形态:summary 写成对象/数组/数字或空串时,record 照样把它写进 evidence。下游 exit 只看到
1712
+ // 「没有非空字符串 summary」,于是报 requires evidence: <schema>——出错的是 record、报错的却是
1713
+ // exit,执行者要自己反推「载荷该是什么形状」。以下断言把报错锁在坏载荷落库之前:点名字段路径
1714
+ // 与当前类型、给出可照抄的正确形态,且 state 字节零改写。
1715
+ const beforeBytes = readStateBytes(dir);
1716
+ const malformed = [
1717
+ { payload: '{"summary":{"nested":"object"}}', expect: 'summary: 必须是字符串(当前是 object)' },
1718
+ { payload: '{"summary":["lane"]}', expect: 'summary: 必须是字符串(当前是 array)' },
1719
+ { payload: '{"summary":42}', expect: 'summary: 必须是字符串(当前是 number)' },
1720
+ { payload: '{"summary":""}', expect: 'summary: 必须是非空字符串(当前是空串)' },
1721
+ { payload: '{"summary":"x","completedChecks":[{"id":"a"}]}', expect: 'completedChecks[0]: 必须是字符串(当前是 object)' },
1722
+ {
1723
+ payload: '{"summary":"x","lessonsNomination":{"nominated":[{"id":"a"}],"reasonIfNone":""}}',
1724
+ expect: 'lessonsNomination.nominated[0]: 必须是字符串(当前是 object)',
1725
+ },
1726
+ ];
1727
+ let lastMalformed = null;
1728
+ for (const item of malformed) {
1729
+ const res = runState(['record', 'open', item.payload, '--protocol', custom], dir);
1730
+ assertExit(res, 1);
1731
+ assertOut(res, item.expect);
1732
+ assertStateBytesUnchanged(
1733
+ dir,
1734
+ beforeBytes,
1735
+ '形状非法的载荷必须在写入前被拒(' + item.payload + ')',
1736
+ );
1737
+ lastMalformed = res;
1738
+ }
1739
+ // 报文还得给「该写成什么」:只有一句「不合法」等于让执行者再猜一次。
1740
+ assertOut(lastMalformed, '\'{"summary":"<本节点完成摘要>"}\'');
1741
+ assertOut(lastMalformed, '--json-file');
1742
+ assertOut(lastMalformed, 'cmd.exe');
1743
+ // 正锚:类型合法的载荷逐字通过(校验只判类型,不新增业务规则)
1744
+ const okPayload = JSON.stringify({
1745
+ summary: '形状合法',
1746
+ completedChecks: ['unit-tests'],
1747
+ lessonsNomination: { scanned: 0, nominated: [], reasonIfNone: '无新增条目' },
1748
+ });
1749
+ const okRes = runState(['record', 'open', okPayload, '--protocol', custom], dir);
1750
+ assertExit(okRes, 0);
1751
+ const okEvidence = JSON.parse(readStateBytes(dir)).evidence.open;
1752
+ if (okEvidence.summary !== '形状合法'
1753
+ || okEvidence.lessonsNomination.reasonIfNone !== '无新增条目'
1754
+ || !Array.isArray(okEvidence.completedChecks)) {
1755
+ throw new Error('类型合法的载荷未被原样写入: ' + JSON.stringify(okEvidence));
1756
+ }
643
1757
  },
644
1758
  },
645
1759
 
@@ -788,10 +1902,10 @@ export const ENTRIES = [
788
1902
 
789
1903
  // ---------- 场景(builtin 降级须含缓存尝试证据) ----------
790
1904
 
791
- // 74: builtin-quickcheck 声明 + 不可用原因但无缓存尝试证据 → BROOKS-LINT WARN
792
- // (:防「未尝试 Read 插件缓存协议文件」的偷懒降级——修复前不校验 = RED)
1905
+ // 74: builtin-quickcheck 声明 + 不可用原因但无缓存尝试证据 → BLOCKED
1906
+ // (防「未尝试 Read 插件缓存协议文件」的偷懒降级——判据为 BLOCK,无渐进侧)
793
1907
  {
794
- name: '74 builtin 无缓存尝试证据 → WARN',
1908
+ name: '74 builtin 无缓存尝试证据 → BLOCKED',
795
1909
  run: (dir) => {
796
1910
  const st = baseState('execute');
797
1911
  st.evidence.execute = { summary: 'executed' };
@@ -802,8 +1916,9 @@ export const ENTRIES = [
802
1916
  method: '## 自检方法\n\nbuiltin-quickcheck — brooks-lint 不可用(Skill 仅返回占位,插件执行体未加载),按协议降级内置 R1~R6 快查',
803
1917
  }));
804
1918
  const res = runGuard(['exit', 'execute'], dir);
805
- assertExit(res, 0);
806
- assertOut(res, 'BROOKS-LINT WARN');
1919
+ assertExit(res, 1);
1920
+ assertOut(res, 'BLOCKED');
1921
+ assertOut(res, '缓存尝试证据');
807
1922
  },
808
1923
  },
809
1924
 
@@ -812,6 +1927,7 @@ export const ENTRIES = [
812
1927
  {
813
1928
  name: '75 cache-brooks 声明 → 放行',
814
1929
  run: (dir) => {
1930
+ writeNodeDeclarationMarkers(dir, 'execute');
815
1931
  const st = baseState('execute');
816
1932
  st.evidence.execute = { summary: 'executed' };
817
1933
  st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
@@ -833,6 +1949,7 @@ export const ENTRIES = [
833
1949
  {
834
1950
  name: '76 builtin 含缓存尝试证据 → 无 WARN',
835
1951
  run: (dir) => {
1952
+ writeNodeDeclarationMarkers(dir, 'execute');
836
1953
  const st = baseState('execute');
837
1954
  st.evidence.execute = { summary: 'executed' };
838
1955
  st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
@@ -873,6 +1990,7 @@ export const ENTRIES = [
873
1990
  {
874
1991
  name: '78 路由诊断:有 pending 无可委托并行 WARN 在场 / 无可解析 pending 静默',
875
1992
  run: (dir) => {
1993
+ writeNodeDeclarationMarkers(dir, 'plan');
876
1994
  const st = baseState('plan');
877
1995
  st.completedNodes = ['open', 'design'];
878
1996
  st.evidence.plan = { summary: 'executed' };
@@ -912,10 +2030,15 @@ export const ENTRIES = [
912
2030
  },
913
2031
  },
914
2032
 
915
- // 80: handoff result commitHash 存在性校验——不存在 → HANDOFF ERROR(固化:校验已存在(W2-D),经确认)
2033
+ // 80: handoff result 的 Return Contract 校验——① 无效 commitHash → HANDOFF ERROR(固化:校验已存在(W2-D),经确认);
2034
+ // ② 形状校验:与 record 共用 state-schema.evidencePayloadProblems,畸形契约在写盘**之前**被拒(exit 1 +
2035
+ // 点名字段路径与当前类型 + 可照抄形态),state 字节零改写——问题不再延后到出口门禁才暴露;
2036
+ // 非对象载荷(字符串 / 数组 / null / 数字)在入口即拒(与 record 入口同一判据,形状表对非对象按设计放行);
2037
+ // ③ 零提交语义(request 记 noCommit)与合法契约不受形状校验影响。
916
2038
  {
917
- name: '80 handoff result 无效 commitHash → ERROR(batch-H 固化)',
2039
+ name: '80 handoff result 契约校验:无效 commitHash → ERROR;非对象与畸形形状写入前拒绝',
918
2040
  run: (dir) => {
2041
+ writeNodeDeclarationMarkers(dir, 'subagent-execute');
919
2042
  writeState(dir, baseState('subagent-execute'));
920
2043
  fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
921
2044
  execFileSync('git', ['init', '-q'], { cwd: dir });
@@ -928,28 +2051,270 @@ export const ENTRIES = [
928
2051
  completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
929
2052
  riskSignals: ['none'],
930
2053
  });
2054
+ assertExit(runHandoff(['request', 'T01', 'delegate', '--write-files', 'src/t1.mjs'], dir, { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) }), 0);
931
2055
  const res = runHandoff(['result', 'T01', payload], dir);
932
2056
  assertExit(res, 0);
933
2057
  assertOut(res, 'HANDOFF ERROR: commitHash 无效或 git show 失败');
934
- },
935
- },
936
-
937
- // 81: entry/exit WARN COUNT 汇总行——构造 BROOKS-LINT WARN → exit 输出 WARN COUNT
938
- // ( F:可观测性——修复前无汇总行 = RED)
2058
+ // 形状校验的「字节零改写」基线:① 已落 T01 的 result(HANDOFF ERROR 不阻断记录),
2059
+ // 此后每次形状拒绝都不得改动这几行。
2060
+ const before = readStateBytes(dir);
2061
+ // ② 形状非法 → 写入前拒绝(每条都点名「字段路径 + 当前类型」,且 state 字节零改写):
2062
+ // completedChecks 的对象元素(既有踩坑形态)、redEvidence 传字符串(应为对象容器)、
2063
+ // commitHash 传数字(零提交只豁免「字段缺席」,不豁免「类型错误」)、status 非字符串与
2064
+ // 字符串但不在契约既有取值集合(DONE | DONE_WITH_CONCERNS | BLOCKED | NEEDS_CONTEXT)。
2065
+ const malformed = [
2066
+ { payload: '{"status":"DONE","completedChecks":[{"id":"required-skill:subagent-execute.flow-comet-dev"}]}', expect: 'completedChecks[0]: 必须是字符串(当前是 object)' },
2067
+ { payload: '{"status":"DONE","redEvidence":"node --check src/t2.mjs"}', expect: 'redEvidence: 必须是对象(当前是 string)' },
2068
+ { payload: '{"status":"DONE","commitHash":1234567}', expect: 'commitHash: 必须是字符串(当前是 number)' },
2069
+ { payload: '{"status":42}', expect: 'status: 必须是字符串(当前是 number)' },
2070
+ { payload: '{"status":"OK"}', expect: 'status: 不属于允许取值(当前是 OK)' },
2071
+ ];
2072
+ let lastMalformed = null;
2073
+ for (const item of malformed) {
2074
+ const res = runHandoff(['result', 'T02', item.payload], dir);
2075
+ assertExit(res, 1);
2076
+ assertOut(res, item.expect);
2077
+ assertStateBytesUnchanged(dir, before, 'handoff result 形状校验拒绝(' + item.payload + ')');
2078
+ lastMalformed = res;
2079
+ }
2080
+ // 报文还得给「该写成什么」:只有一句「不合法」等于让执行者再猜一次。
2081
+ assertOut(lastMalformed, '"completedChecks":["required-skill:subagent-execute.flow-comet-dev"]');
2082
+ assertOut(lastMalformed, 'DONE_WITH_CONCERNS');
2083
+ assertOut(lastMalformed, '--json-file');
2084
+ // ②b 非对象契约(字符串 / 数组 / null / 数字)在入口即拒——与 record 入口同一判据。形状表只判
2085
+ // 「对象各字段的类型」,载荷不是对象时它按设计返回空表;旧实现在这里放行,于是字符串或数组被
2086
+ // 原样存进 handoffResult,问题延后到出口门禁(那里只会说「缺 greenEvidence」「缺 completedChecks」
2087
+ // ——出错的是 result、报错的却是 exit)。JSON 解析失败且不形似对象字面量的纯文本走同一条拒路:
2088
+ // 旧语义「解析失败则存原始字符串」正是同一形态的延后。判据在任何写盘之前 → 逐条断言报文与字节零改写。
2089
+ const nonObjectContracts = [
2090
+ { payload: '"just a string result"', type: 'string' },
2091
+ { payload: 'just a plain text result', type: 'string' },
2092
+ { payload: '[{"status":"DONE"}]', type: 'array' },
2093
+ { payload: 'null', type: 'null' },
2094
+ { payload: '42', type: 'number' },
2095
+ ];
2096
+ let lastNonObject = null;
2097
+ for (const item of nonObjectContracts) {
2098
+ const res = runHandoff(['result', 'T05', item.payload], dir);
2099
+ assertExit(res, 1);
2100
+ assertOut(res, 'result 契约必须是对象(当前是 ' + item.type + ')');
2101
+ assertStateBytesUnchanged(dir, before, 'handoff result 非对象契约(' + item.payload + ')');
2102
+ lastNonObject = res;
2103
+ }
2104
+ // 非对象的拒绝同样要给「该写成什么」:可照抄的对象形态,以及引号被 shell 吞掉时的旁路
2105
+ assertOut(lastNonObject, '"completedChecks":["required-skill:subagent-execute.flow-comet-dev"]');
2106
+ assertOut(lastNonObject, '--json-file');
2107
+ // ③ 零提交语义保持可用:request 记 noCommit:true → 契约无 commitHash 照常记录(形状校验不误伤)
2108
+ const zeroState = JSON.parse(before);
2109
+ // T04 的请求同样要在场:result 缺 request 现已先于提交子集校验被拦,而本段断言的是
2110
+ // 「合法完整契约 + 提交子集校验」这条既有路径——故其 request 带真实 write_files(非零提交)。
2111
+ zeroState.evidence['subagent-execute'].handoffRequests = {
2112
+ T03: { description: 'zero commit', noCommit: true },
2113
+ T04: { description: 'valid contract', writeFiles: ['src/x.mjs'] },
2114
+ };
2115
+ writeState(dir, zeroState);
2116
+ const zero = runHandoff(['result', 'T03', '{"status":"DONE","completedChecks":["required-skill:subagent-execute.flow-comet-dev"]}'], dir);
2117
+ assertExit(zero, 0);
2118
+ assertOut(zero, 'HANDOFF RESULT: T03');
2119
+ // ④ 合法完整契约照常通过(commitHash 取夹具仓库的真实提交)
2120
+ const headHash = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
2121
+ const good = runHandoff(['result', 'T04', JSON.stringify({
2122
+ status: 'DONE_WITH_CONCERNS',
2123
+ commitHash: headHash,
2124
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
2125
+ redEvidence: { command: 'echo red', output: 'red' },
2126
+ greenEvidence: { command: 'echo green', output: 'green' },
2127
+ })], dir);
2128
+ assertExit(good, 0);
2129
+ assertOut(good, 'HANDOFF RESULT: T04');
2130
+ // ⑤ 委托记账:result 必须有对应的 request(新 change BLOCK / 旧 change WARN)——判定在**任何
2131
+ // 写盘之前**,且先于零提交语义与提交子集校验,两个旁路因此由同一处拦下:
2132
+ // · 零提交形态(契约无 commitHash):无 request 时 isZeroCommit 恒为 false,旧实现静默落库;
2133
+ // · 只提交自身 <task>-SUMMARY.md:无 request 时 writeFiles 允许列表为空,只剩 summaryExact
2134
+ // 一条豁免,旧实现的子集校验因此零越界放行。
2135
+ const ledgerPayload = (taskId, hash) => JSON.stringify({
2136
+ status: 'DONE',
2137
+ taskId,
2138
+ ...(hash ? { commitHash: hash } : {}),
2139
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
2140
+ redEvidence: { command: 'echo red', output: 'red' },
2141
+ greenEvidence: { command: 'echo green', output: 'green' },
2142
+ });
2143
+ // 只含自身 SUMMARY 的提交:旧实现正是靠 summaryExact 豁免放行的那条路径
2144
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T06-SUMMARY.md', '# SUMMARY: T06\n');
2145
+ execFileSync('git', ['add', '.specs/' + CHANGE_ID + '/T06-SUMMARY.md'], { cwd: dir });
2146
+ execFileSync('git', ['-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-q', '-m', 'summary only'], { cwd: dir });
2147
+ const summaryHash = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
2148
+ const ledgerState = JSON.parse(readStateBytes(dir));
2149
+ const ledgerRequests = ledgerState.evidence['subagent-execute'].handoffRequests || {};
2150
+ if (Object.prototype.hasOwnProperty.call(ledgerRequests, 'T06')) {
2151
+ throw new Error('夹具前提不成立:T06 不应已有 request(本段构造的是缺 request 的 result)');
2152
+ }
2153
+ writeState(dir, ledgerState);
2154
+ const ledgerBytes = readStateBytes(dir);
2155
+ const missingRequest = [
2156
+ { label: '零提交形态(契约无 commitHash)', payload: ledgerPayload('T06') },
2157
+ { label: '只提交自身 SUMMARY', payload: ledgerPayload('T06', summaryHash) },
2158
+ ];
2159
+ let missingRequestOutput = '';
2160
+ for (const item of missingRequest) {
2161
+ const res = runHandoff(['result', 'T06', item.payload], dir);
2162
+ assertExit(res, 1);
2163
+ // 报文点名任务 + 恢复段;且拦下它的不是零提交分支、也不是提交子集校验(判据必须靠前)。
2164
+ assertOut(res, 'BLOCKED: 任务 T06 的 result 没有对应的委托 request');
2165
+ assertOut(res, '再重录 result');
2166
+ // 恢复句给的是命令形态:任务号已填、脚本路径由 scriptCommand 装配;占位符 <description> 不得
2167
+ // 出现在命令里(bash 下 `<` 是输入重定向——占位符让「照抄」变成一条必然失败的命令行)。
2168
+ assertOut(res, ' request T06');
2169
+ assertNotOut(res, '<description>');
2170
+ assertNotOut(res, 'HANDOFF RESULT');
2171
+ assertNotOut(res, 'HANDOFF 零提交');
2172
+ assertNotOut(res, '提交文件超出 writeFiles 范围');
2173
+ assertStateBytesUnchanged(dir, ledgerBytes, '缺 request 的 result 被拦(' + item.label + ')');
2174
+ missingRequestOutput = res.output;
2175
+ }
2176
+ const missingRequestStart = missingRequestOutput.lastIndexOf('恢复:');
2177
+ const missingRequestRecovery = missingRequestStart < 0 ? '' : missingRequestOutput.slice(missingRequestStart);
2178
+ const requestRecoveryLine = (missingRequestRecovery.match(/^\s*(node "[^"]+" request T06)$/m) || [])[1];
2179
+ assertTrue(typeof requestRecoveryLine === 'string',
2180
+ '缺 request 的恢复段必须给出可照抄的 request 命令(行首 = node + 引号脚本路径):\n' + missingRequestOutput);
2181
+ assertRecoveryCommandLines(missingRequestRecovery, [requestRecoveryLine], '缺 request 的 result 恢复段');
2182
+ // 同一输入(无任何新旧标记字段)→ 同判 BLOCKED(单轨:无渐进放行侧)
2183
+ const legacyLedger = JSON.parse(ledgerBytes);
2184
+ writeState(dir, legacyLedger);
2185
+ const legacy = runHandoff(['result', 'T06', ledgerPayload('T06', summaryHash)], dir);
2186
+ assertExit(legacy, 1);
2187
+ assertOut(legacy, 'BLOCKED: 任务 T06 的 result 没有对应的委托 request');
2188
+ // 有 request 的 result 照常通过(零提交语义不变:noCommit 请求 + 无 commitHash 契约)
2189
+ const withRequest = JSON.parse(readStateBytes(dir));
2190
+ withRequest.evidence['subagent-execute'].handoffRequests = {
2191
+ ...withRequest.evidence['subagent-execute'].handoffRequests,
2192
+ T08: { description: 'delegated', noCommit: true },
2193
+ };
2194
+ writeState(dir, withRequest);
2195
+ const recorded = runHandoff(['result', 'T08', ledgerPayload('T08')], dir);
2196
+ assertExit(recorded, 0);
2197
+ assertOut(recorded, 'HANDOFF RESULT: T08');
2198
+ assertNotOut(recorded, '没有对应的委托 request');
2199
+ // ⑤b 照抄恢复段的那条命令**真执行**:「能解析」不是判据,能跑通并把 request 落到 state 才是。
2200
+ // 随后同一条 result 不再撞「没有对应的委托 request」(这一格判的不是它之后还有多少门)。
2201
+ // T06 按并行任务落夹具:归属门把并行任务判给 subagent-execute(串行任务归属 execute),
2202
+ // 节点与 currentNode 不一致会先被归属门拦下,测不到恢复命令本身。
2203
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
2204
+ + '<task id="T06" parallel="true" status="pending"><action>委托边界</action>'
2205
+ + '<write_files>src/t06.mjs</write_files><verify>node --check src/t06.mjs</verify>'
2206
+ + '<depends_on></depends_on></task>\n');
2207
+ const execState = baseState('subagent-execute');
2208
+ execState.evidence['subagent-execute'] = { summary: 'delegated' };
2209
+ writeState(dir, execState);
2210
+ writeNodeDeclarationMarkers(dir, 'subagent-execute');
2211
+ installSkillTreeCopy(dir, path.join('.claude', 'skills'));
2212
+ assertPrintedCommandTargetsInstalledScript(requestRecoveryLine, dir, 'workflow-handoff.mjs', '缺 request 的恢复命令');
2213
+ const rerunRequest = runPrintedCommand(requestRecoveryLine, dir, {
2214
+ FLOW_COMET_RUN_ROOT: dir,
2215
+ FLOW_COMET_PROTOCOL: '',
2216
+ });
2217
+ assertExit(rerunRequest, 0);
2218
+ assertOut(rerunRequest, 'HANDOFF REQUEST: T06');
2219
+ const afterRequest = JSON.parse(readStateBytes(dir));
2220
+ assertTrue(afterRequest.evidence?.['subagent-execute']?.handoffRequests?.T06 !== undefined,
2221
+ '照抄恢复命令后 handoffRequests 应落下 T06 记录: '
2222
+ + JSON.stringify(afterRequest.evidence?.['subagent-execute']?.handoffRequests));
2223
+ const afterRequestResult = runHandoff(['result', 'T06', ledgerPayload('T06')], dir);
2224
+ assertNotOut(afterRequestResult, '没有对应的委托 request');
2225
+ // ⑥ 越界报文的事实陈述(只补事实、不改判定):request 记的是**发起委托那一刻的写面快照**,
2226
+ // TASK.md 的写面可以被 replan 改写。两者不一致时,越界报文追加一行**可观测事实**(快照 ≠
2227
+ // 当前该任务写面)+ **条件式成因**(若计划经 replan 变更过写面 → 重新 request 后再记
2228
+ // result),并保留「回退越界文件」为首选指引。判据只能证明两侧不一致,不能证明成因——对
2229
+ // 真越界,让人先重跑 request 会把越界文件写进允许列表,所以「记录早于 replan」不得写成断言。
2230
+ // 两者一致(普通真越界)不打印诊断行,判定仍是原来的新 change BLOCK / 旧 change WARN。
2231
+ // 夹具判别力:TASK.md 里 T09 的写面是 replan 后扩过的(含 rogue.js),T10 的写面与 request
2232
+ // 逐字一致;若诊断按「全文第一个写面」而非「该任务的写面」比对,T10 会误报。
2233
+ const repo = (args) => spawnSync('git', ['-c', 'user.email=t@t', '-c', 'user.name=t', ...args], { cwd: dir, encoding: 'utf8' });
2234
+ writeFile(dir, 'allowed.js', 'export const allowed = 1;\n');
2235
+ writeFile(dir, 'rogue.js', 'export const rogue = 1;\n');
2236
+ repo(['add', 'allowed.js', 'rogue.js']);
2237
+ repo(['commit', '-qm', 'replan 之后才进写面']);
2238
+ const replannedHash = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
2239
+ writeFile(dir, 'stray.js', 'export const stray = 1;\n');
2240
+ repo(['add', 'stray.js']);
2241
+ repo(['commit', '-qm', 'stray']);
2242
+ const strayHash = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
2243
+ const taskWithWriteFiles = (id, files) => '<task id="' + id + '" status="pending"><action>写面边界</action>'
2244
+ + '<write_files>\n' + files.join('\n') + '\n</write_files>'
2245
+ + '<verify>node --check allowed.js</verify></task>\n';
2246
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
2247
+ + taskWithWriteFiles('T09', ['allowed.js', 'rogue.js'])
2248
+ + taskWithWriteFiles('T10', ['allowed.js']));
2249
+ const replanState = baseState('subagent-execute');
2250
+ replanState.evidence['subagent-execute'] = {
2251
+ handoffRequests: {
2252
+ T09: { description: 'replan 扩写面前的快照', writeFiles: ['allowed.js'] },
2253
+ T10: { description: '写面未变更', writeFiles: ['allowed.js'] },
2254
+ },
2255
+ handoffResult: {},
2256
+ };
2257
+ writeState(dir, replanState);
2258
+ const boundaryPayload = (id, hash) => JSON.stringify({
2259
+ status: 'DONE',
2260
+ taskId: id,
2261
+ commitHash: hash,
2262
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
2263
+ redEvidence: { command: 'node --check allowed.js', output: 'no output(RED 锚点)' },
2264
+ greenEvidence: { command: 'node --check allowed.js', output: 'ok' },
2265
+ });
2266
+ const staleSnapshotFact = '诊断: 该任务的委托快照与当前 TASK.md 该任务的写面不一致';
2267
+ const staleSnapshotCause = '成因未判定;若计划经 replan 变更过写面,出路是重新发起委托(命令如下)后再记录 result';
2268
+ // ① 旧快照(request 只允许 allowed.js,TASK.md 已扩到 rogue.js)→ 仍 BLOCK,且要点明可观测事实
2269
+ const staleSnapshot = runHandoff(['result', 'T09', boundaryPayload('T09', replannedHash)], dir);
2270
+ assertExit(staleSnapshot, 1);
2271
+ assertOut(staleSnapshot, 'BLOCKED: 提交文件超出 writeFiles 范围: rogue.js');
2272
+ assertOut(staleSnapshot, staleSnapshotFact);
2273
+ // 成因是条件式而非断言:「若计划经 replan 变更过写面」才是成因,且再给一条无 replan 时的出路
2274
+ assertOut(staleSnapshot, staleSnapshotCause);
2275
+ assertOut(staleSnapshot, '若无 replan,越界文件仍不在该任务写面内');
2276
+ // 出路是**可照抄的命令**(不是脚本名):任务号已填、行首即命令——说明行与命令行分开。
2277
+ const staleRecoveryLine = (staleSnapshot.output.match(/^\s*(node "[^"]+" request T09)$/m) || [])[1];
2278
+ assertTrue(typeof staleRecoveryLine === 'string',
2279
+ '越界诊断给出的「重新发起委托」不是可照抄命令:\n' + staleSnapshot.output);
2280
+ // 首选指引仍是「回退越界文件」(恢复行在前,诊断行只在其后补事实)
2281
+ assertOut(staleSnapshot, '恢复: 回退越界文件或扩展 write_files');
2282
+ assertOut(staleSnapshot, '按上面的「回退越界文件」处理');
2283
+ // 反向构造:把可能写成事实的旧措辞不得回归(判据只能证明不一致,证明不了「记录早于 replan」)
2284
+ assertNotOut(staleSnapshot, '早于最近一次 replan');
2285
+ // ② 写面一致的真越界 → 仍是原报文,不得混入事实陈述(否则该行不再有判别力)
2286
+ const genuineOverrun = runHandoff(['result', 'T10', boundaryPayload('T10', strayHash)], dir);
2287
+ assertExit(genuineOverrun, 1);
2288
+ assertOut(genuineOverrun, 'BLOCKED: 提交文件超出 writeFiles 范围: stray.js');
2289
+ assertOut(genuineOverrun, '恢复: 回退越界文件或扩展 write_files');
2290
+ assertNotOut(genuineOverrun, staleSnapshotFact);
2291
+ // ③ 同一份旧快照(无任何新旧标记字段)→ 同判 BLOCKED(单轨:无渐进放行侧)
2292
+ const legacySnapshot = JSON.parse(readStateBytes(dir));
2293
+ writeState(dir, legacySnapshot);
2294
+ const legacyWarn = runHandoff(['result', 'T09', boundaryPayload('T09', replannedHash)], dir);
2295
+ assertExit(legacyWarn, 1);
2296
+ assertOut(legacyWarn, 'BLOCKED: 提交文件超出 writeFiles 范围: rogue.js');
2297
+ assertOut(legacyWarn, staleSnapshotCause);
2298
+ },
2299
+ },
2300
+
2301
+ // 81: entry/exit WARN COUNT 汇总行——构造 SIGNATURE-ALGO WARN(跨算法版本签名,提示级)→ exit 输出
2302
+ // WARN COUNT(可观测性:提示级判据不静默)
939
2303
  {
940
2304
  name: '81 exit 输出 WARN COUNT 汇总',
941
2305
  run: (dir) => {
2306
+ writeNodeDeclarationMarkers(dir, 'execute');
942
2307
  const st = baseState('execute');
943
2308
  st.evidence.execute = { summary: 'executed' };
944
2309
  st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
2310
+ // 跨算法版本的签名:值不可比 → SIGNATURE-ALGO WARN(仍为提示级),用来驱动 WARN COUNT 汇总行
2311
+ st.taskHash = 'v0:' + '0'.repeat(64);
945
2312
  writeState(dir, st);
946
2313
  writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
947
- writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent({
948
- method: '## 自检方法\n\nbuiltin-quickcheck — brooks-lint 不可用(Skill 仅返回占位,插件执行体未加载),按协议降级内置 R1~R6 快查',
949
- }));
2314
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
950
2315
  const res = runGuardWithProtocol(dir, ['exit', 'execute']);
951
2316
  assertExit(res, 0);
952
- assertOut(res, 'BROOKS-LINT WARN');
2317
+ assertOut(res, 'SIGNATURE-ALGO WARN');
953
2318
  assertOut(res, 'WARN COUNT:');
954
2319
  },
955
2320
  },
@@ -991,7 +2356,7 @@ export const ENTRIES = [
991
2356
  runStateWithProtocol(dir, ['init', CHANGE_ID, '--init-skip']);
992
2357
  const st1 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
993
2358
  if (st1.ai_context_doc !== 'none') throw new Error('ai_context_doc 应为 none');
994
- const res2 = runStateWithProtocol(dir, ['init', CHANGE_ID + '-2']);
2359
+ const res2 = runStateWithProtocol(dir, ['init', CHANGE_ID + '-2', '--replace', CHANGE_ID, '--reason', '验证跳过记忆跨 change 生效']);
995
2360
  if (res2.output.includes('INIT-NEEDED') || res2.output.includes('INIT-HINT')) throw new Error('下次 init 不应再提示');
996
2361
  },
997
2362
  },
@@ -1090,7 +2455,7 @@ export const ENTRIES = [
1090
2455
  if (st.last_intel_scan) throw new Error('校验失败不应写 last_intel_scan');
1091
2456
  // ② 段名变体(含正文提及)不满足必填段
1092
2457
  writeFile(dir, '.specs/CONTEXT.md', '# CONTEXT\n## 项目概要\nx\n## 技术栈补充\nx\n## 域语言说明\n| 术语 | 定义 |\n|---|---|\n| 例 | 定义 |\n## 已锁决策说明\n- [2026-08-01] 决策一\n## 默认偏好补充\nx\n## 既有抽象索引附录\nx\n## intel-scan 元数据附录\n- **last_intel_scan**: x\n- **scanner**: x\n- **下次重扫建议**: x\n正文提及 域语言 与 默认偏好 与 既有抽象索引(文本非标题)。\n');
1093
- res = runStateWithProtocol(dir, ['init', CHANGE_ID + '-2', '--init-context']);
2458
+ res = runStateWithProtocol(dir, ['init', CHANGE_ID + '-2', '--init-context', '--replace', CHANGE_ID, '--reason', '验证 CONTEXT 校验跨 change 复跑']);
1094
2459
  assertExit(res, 0);
1095
2460
  assertOut(res, 'INIT-VALIDATE-FAILED');
1096
2461
  st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
@@ -1112,7 +2477,7 @@ export const ENTRIES = [
1112
2477
  '~~~text', '## 默认偏好', '~~~',
1113
2478
  '',
1114
2479
  ].join('\n'));
1115
- res = runStateWithProtocol(dir, ['init', CHANGE_ID + '-3', '--init-context']);
2480
+ res = runStateWithProtocol(dir, ['init', CHANGE_ID + '-3', '--init-context', '--replace', CHANGE_ID + '-2', '--reason', '验证围栏段名判定跨 change 复跑']);
1116
2481
  assertExit(res, 0);
1117
2482
  assertOut(res, 'INIT-VALIDATE-FAILED');
1118
2483
  st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
@@ -1164,16 +2529,101 @@ export const ENTRIES = [
1164
2529
  },
1165
2530
  },
1166
2531
 
1167
- // 95: init 同 id 重跑(.specs/<id>/ 已存在)→ WARN 防护输出且不阻断(F)
2532
+ // 95: init 与既有 change 的关系——同 id 重跑仍是 WARN 不阻断;**另一个 change 在途**时
2533
+ // 默认阻断(state 字节零改写 + 两条可照抄的出路);只有 --replace <在途 change> --reason <非空
2534
+ // 原因> 才放行,放行前把旧 state **按原始字节**快照到旧 change 目录的 recovery/(BOM / CRLF 一律
2535
+ // 不改)并写同前缀 .md 记录;RECOVERY 块给出快照路径与回滚命令,回滚命令照抄真执行后旧状态逐
2536
+ // 字节恢复。反向构造:闸门缺席(实现退化为直接覆盖)时第一条阻断断言必红。
1168
2537
  {
1169
- name: '95 init 同 id 重跑 → WARN 防护不阻断',
2538
+ name: '95 init 与既有 change:同 id 重跑不阻断 / 在途 change 默认阻断 / --replace 留档与回滚可执行',
1170
2539
  run: (dir) => {
2540
+ const stateFile = path.join(dir, '.flow-comet', 'flow-comet-state.json');
2541
+ const recoveryDirOf = (changeName) => path.join(dir, '.specs', changeName, 'recovery');
2542
+ // RECOVERY 块按行标签取值(快照 / 记录 / 回滚)——取值形态就是执行者要照抄的文本
2543
+ const recoveryLine = (res, label) => {
2544
+ const line = res.output.split('\n').find((row) => row.startsWith('RECOVERY: ' + label + ' '));
2545
+ if (!line) throw new Error('输出缺少 RECOVERY: ' + label + ' 行\n实际输出:\n' + res.output);
2546
+ return line.slice(('RECOVERY: ' + label + ' ').length).trim();
2547
+ };
2548
+ const runRootPath = (displayPath) => path.join(dir, ...displayPath.split('/'));
2549
+
1171
2550
  writeFile(dir, 'package.json', '{"name":"x"}');
1172
- runStateWithProtocol(dir, ['init', CHANGE_ID]);
2551
+ // ① 正常 init(无在途 change):零留档、零新参数要求——输出与既有断言一致
2552
+ const first = runStateWithProtocol(dir, ['init', CHANGE_ID]);
2553
+ assertExit(first, 0);
2554
+ assertOut(first, 'Initialized: ' + CHANGE_ID);
2555
+ assertNotOut(first, 'RECOVERY');
2556
+ assertTrue(!fs.existsSync(recoveryDirOf(CHANGE_ID)), '无在途 change 的正常 init 不应创建 recovery/');
2557
+
2558
+ // ② 同 id 重跑:既有 WARN 防护不阻断(行为不变,也不留档)
1173
2559
  const res = runStateWithProtocol(dir, ['init', CHANGE_ID]);
1174
2560
  assertExit(res, 0);
1175
2561
  assertOut(res, 'WARN: change ' + CHANGE_ID + ' 已存在');
1176
2562
  assertOut(res, '重置节点状态');
2563
+ assertNotOut(res, 'BLOCKED');
2564
+ assertTrue(!fs.existsSync(recoveryDirOf(CHANGE_ID)), '同 id 重跑不应留档');
2565
+
2566
+ // ③ 另一个 change 在途 → 默认阻断:非零退出 + 点名在途 change + 两条出路;state 字节零改写
2567
+ const blockedBytes = readStateBytes(dir);
2568
+ const blocked = runStateWithProtocol(dir, ['init', 'other-change']);
2569
+ assertExit(blocked, 1);
2570
+ assertOut(blocked, 'BLOCKED: 在途 change "' + CHANGE_ID + '" 尚未完成');
2571
+ assertOut(blocked, '--replace ' + CHANGE_ID);
2572
+ assertOut(blocked, '--reason');
2573
+ assertOut(blocked, 'workflow-state.mjs" status');
2574
+ assertStateBytesUnchanged(dir, blockedBytes, '在途 change + init 默认阻断');
2575
+ assertTrue(!fs.existsSync(recoveryDirOf('other-change')), '阻断路径不得创建留档');
2576
+
2577
+ // ④ 显式放行的形态约束(缺 --reason / 空白 reason / --replace 名不符 / 空 --replace 值):
2578
+ // 一律 BLOCK 且零改写、零留档
2579
+ const badShapes = [
2580
+ { args: ['init', 'other-change', '--replace', CHANGE_ID], label: '缺 --reason' },
2581
+ { args: ['init', 'other-change', '--replace', CHANGE_ID, '--reason', ' '], label: '空白 --reason' },
2582
+ { args: ['init', 'other-change', '--replace', 'not-the-active-one', '--reason', 'x'], label: '--replace 名不符' },
2583
+ { args: ['init', 'other-change', '--replace'], label: '空 --replace 值' },
2584
+ { args: ['init', 'other-change', '--replace', CHANGE_ID, '--reason', '--init-skip'], label: '--reason 的值位是另一个选项' },
2585
+ ];
2586
+ for (const shape of badShapes) {
2587
+ const bad = runStateWithProtocol(dir, shape.args);
2588
+ assertExit(bad, 1);
2589
+ assertOut(bad, 'BLOCKED');
2590
+ assertStateBytesUnchanged(dir, blockedBytes, '放行形态不合法(' + shape.label + ')');
2591
+ assertTrue(!fs.existsSync(recoveryDirOf(CHANGE_ID)), '形态不合法不得留档(' + shape.label + ')');
2592
+ }
2593
+
2594
+ // ⑤ 旧状态换成可辨识形态(BOM + CRLF):逐字节判据必须能看见这两类字节,否则「逐字节」退化成「JSON 相等」
2595
+ const oldState = { ...baseState('design'), status: 'running', evidence: { design: { summary: '旧进度' } } };
2596
+ const oldBytes = Buffer.from('\uFEFF' + JSON.stringify(oldState, null, 2).replace(/\n/g, '\r\n') + '\r\n', 'utf8');
2597
+ fs.writeFileSync(stateFile, oldBytes);
2598
+
2599
+ // ⑥ 正确 --replace + --reason → 留档(逐字节)+ 记录 + RECOVERY 块 + 新 change 正常初始化
2600
+ const replaced = runStateWithProtocol(dir, ['init', 'new-change', '--replace', CHANGE_ID, '--reason', '切换到新 change']);
2601
+ assertExit(replaced, 0);
2602
+ assertOut(replaced, 'Initialized: new-change');
2603
+ assertOut(replaced, 'RECOVERY: 在途 change "' + CHANGE_ID + '" 的状态已留档');
2604
+ const snapshotDisplay = recoveryLine(replaced, '快照');
2605
+ const recordDisplay = recoveryLine(replaced, '记录');
2606
+ const rollbackCommand = recoveryLine(replaced, '回滚');
2607
+ assertTrue(snapshotDisplay.endsWith('-pre-init.state.json'), '快照文件名应为 <时间戳>-pre-init.state.json: ' + snapshotDisplay);
2608
+ assertEqual(snapshotDisplay.replace(/-pre-init\.state\.json$/, '-pre-init.md'), recordDisplay, '记录与快照同前缀');
2609
+ assertTrue(snapshotDisplay.startsWith('.specs/' + CHANGE_ID + '/recovery/'), '快照应落在旧 change 目录的 recovery/: ' + snapshotDisplay);
2610
+ assertTrue(Buffer.compare(fs.readFileSync(runRootPath(snapshotDisplay)), oldBytes) === 0,
2611
+ '快照必须是旧状态文件的逐字节副本(BOM / 行尾不得改写)');
2612
+ const recordText = fs.readFileSync(runRootPath(recordDisplay), 'utf8');
2613
+ assertTrue(recordText.includes('init 目标') && recordText.includes('new-change'), '记录缺 init 目标');
2614
+ assertTrue(recordText.includes('currentNode') && recordText.includes('design'), '记录缺旧 currentNode');
2615
+ assertTrue(recordText.includes('running'), '记录缺旧 status');
2616
+ assertTrue(recordText.includes('切换到新 change'), '记录缺原因');
2617
+ assertTrue(recordText.includes(snapshotDisplay), '记录缺快照路径');
2618
+ assertTrue(recordText.includes(rollbackCommand), '记录缺回滚命令');
2619
+ const newState = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
2620
+ assertEqual(newState.activeChange, 'new-change', '放行后新 change 应正常初始化');
2621
+ assertEqual(newState.currentNode, 'open', '新 change 节点应为协议首节点');
2622
+
2623
+ // ⑦ 回滚命令照抄真执行 → 旧状态逐字节恢复(打印出来的文本本身就是可执行命令)
2624
+ const rolled = runPrintedCommand(rollbackCommand, dir);
2625
+ assertExit(rolled, 0);
2626
+ assertTrue(Buffer.compare(fs.readFileSync(stateFile), oldBytes) === 0, '回滚命令未把旧状态逐字节恢复');
1177
2627
  },
1178
2628
  },
1179
2629
 
@@ -1183,6 +2633,7 @@ export const ENTRIES = [
1183
2633
  {
1184
2634
  name: '96 自检方法段后续行声明 → 放行',
1185
2635
  run: (dir) => {
2636
+ writeNodeDeclarationMarkers(dir, 'execute');
1186
2637
  const st = baseState('execute');
1187
2638
  st.evidence.execute = { summary: 'executed' };
1188
2639
  st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };