flow-comet 1.6.4 → 1.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (85) hide show
  1. package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
  2. package/.flow-comet/skills/flow-comet/SKILL.md +36 -6
  3. package/.flow-comet/skills/flow-comet/reference/artifact-template-overlay.md +154 -0
  4. package/.flow-comet/skills/flow-comet/reference/artifact-templates.json +387 -0
  5. package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +1 -1
  6. package/.flow-comet/skills/flow-comet/reference/entry-detail.md +29 -4
  7. package/.flow-comet/skills/flow-comet/reference/workflow-protocol.json +22 -0
  8. package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +26 -23
  9. package/.flow-comet/skills/flow-comet/scripts/evolve.mjs +174 -0
  10. package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +17 -95
  11. package/.flow-comet/skills/flow-comet/scripts/health.mjs +28 -4
  12. package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +136 -19
  13. package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +54 -18
  14. package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +6 -6
  15. package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +52 -10
  16. package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +25 -10
  17. package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +4 -2
  18. package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +21 -13
  19. package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +163 -0
  20. package/.flow-comet/skills/flow-comet/scripts/lib/ac-coverage.mjs +317 -0
  21. package/.flow-comet/skills/flow-comet/scripts/lib/guard-artifact-skeleton.mjs +448 -0
  22. package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +396 -27
  23. package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +1035 -172
  24. package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +129 -98
  25. package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +8 -6
  26. package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +797 -232
  27. package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +91 -22
  28. package/.flow-comet/skills/flow-comet/scripts/lib/lessons-hits.mjs +160 -0
  29. package/.flow-comet/skills/flow-comet/scripts/lib/run-root.mjs +21 -0
  30. package/.flow-comet/skills/flow-comet/scripts/lib/section-body.mjs +92 -0
  31. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +69 -13
  32. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +454 -135
  33. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +66 -0
  34. package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +109 -13
  35. package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +55 -2
  36. package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +149 -34
  37. package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +79 -9
  38. package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +84 -31
  39. package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +78 -8
  40. package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +60 -3
  41. package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +167 -3
  42. package/.flow-comet/skills/flow-comet/scripts/lib/wave-projection.mjs +341 -0
  43. package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +287 -0
  44. package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +1454 -16
  45. package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1202 -8
  46. package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1205 -77
  47. package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +753 -5
  48. package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +52 -11
  49. package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +582 -3
  50. package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +9 -1
  51. package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +5 -0
  52. package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +22 -6
  53. package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +2 -0
  54. package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +18 -5
  55. package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +4100 -0
  56. package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +135 -0
  57. package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +6 -5
  58. package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +203 -4
  59. package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +312 -63
  60. package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +5 -2
  61. package/.flow-comet/skills/flow-comet-archive/SKILL.md +6 -2
  62. package/.flow-comet/skills/flow-comet-change/SKILL.md +6 -2
  63. package/.flow-comet/skills/flow-comet-design/GUIDANCE.md +13 -3
  64. package/.flow-comet/skills/flow-comet-design/SKILL.md +15 -8
  65. package/.flow-comet/skills/flow-comet-dev/SKILL.md +1 -1
  66. package/.flow-comet/skills/flow-comet-evolve/SKILL.md +1 -0
  67. package/.flow-comet/skills/flow-comet-execute/SKILL.md +42 -15
  68. package/.flow-comet/skills/flow-comet-health/SKILL.md +1 -1
  69. package/.flow-comet/skills/flow-comet-integration/SKILL.md +1 -1
  70. package/.flow-comet/skills/flow-comet-open/GUIDANCE.md +14 -4
  71. package/.flow-comet/skills/flow-comet-open/SKILL.md +11 -9
  72. package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +13 -3
  73. package/.flow-comet/skills/flow-comet-plan/SKILL.md +21 -10
  74. package/.flow-comet/skills/flow-comet-requirement/SKILL.md +1 -1
  75. package/.flow-comet/skills/flow-comet-review/SKILL.md +33 -18
  76. package/.flow-comet/skills/flow-comet-subagent-execute/GUIDANCE.md +13 -3
  77. package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +44 -16
  78. package/.flow-comet/skills/flow-comet-task/SKILL.md +3 -2
  79. package/.flow-comet/skills/flow-comet-test/SKILL.md +6 -2
  80. package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +2 -2
  81. package/.flow-comet/skills/flow-comet-verify/SKILL.md +12 -8
  82. package/README.md +3 -3
  83. package/package.json +1 -1
  84. package/scripts/dsh-bridge.mjs +2 -2
  85. package/scripts/lib/installer-flowkit.mjs +43 -3
@@ -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,117 @@ import {
26
32
  TASK_TFIX,
27
33
  composeState,
28
34
  customProtocol,
35
+ customProtocolWithSkillCall,
36
+ dropNamedImport,
37
+ engineCodeText,
38
+ engineScriptTexts,
29
39
  handoffFor,
40
+ scriptTreeFiles,
30
41
  summaryContent,
31
42
  writeCustomProtocol,
43
+ writeNodeDeclarationMarkers,
32
44
  } from '../lib/test-fixtures.mjs';
45
+ // 单一来源静态锁(write_files 条目切分只有一处实现):与套件其它单源锚共用同一判据实现。
46
+ import { singleSourceImportProblems } from '../lib/text-anchor-checks.mjs';
33
47
  import {
48
+ assertStateBytesUnchanged,
49
+ readStateBytes,
50
+ requireRouteNodeExport,
34
51
  runGuardWithProtocol,
35
52
  runStateWithProtocol,
53
+ scenarioProtocolPath,
36
54
  } from '../lib/test-assertions.mjs';
55
+ // 恢复指引的路径形态参照物:打印出来的命令必须与 scriptCommand 的产物逐字一致(同一推导,不另写一份)。
56
+ import { scriptCommand } from '../lib/state-explain.mjs';
57
+
58
+ // ---------- 打印出来的命令:解析 → 真实执行(本组锚点;命令形态必须可复制、可执行) ----------
59
+ //
60
+ // 背景:运行期消息曾把脚本命令写成未加引号的单一平台字面量,测试只断言字面串、随后改用 harness
61
+ // 的绝对路径执行,于是「打印出来的那条命令」从未被真正执行过(形似全绿)。链路的三个夹具——按安装
62
+ // 布局复制技能树、把打印命令切成 argv、真实执行打印文本——由两组场景共用,单一来源在
63
+ // lib/test-helpers.mjs;本段只留本组自有的一件:跑副本脚本,以及命令形态(引号 / 分词 / 路径
64
+ // 可解析)的断言。
65
+
66
+ // 跑指定脚本(副本形态):cwd = 夹具根(与 run* 助手同一运行根口径)。
67
+ function runScriptCopy(scriptPath, args, root, envOverrides = {}) {
68
+ const res = spawnSync(process.execPath, [scriptPath, ...args], {
69
+ cwd: root,
70
+ env: { ...process.env, ...envOverrides },
71
+ encoding: 'utf8',
72
+ timeout: 60000,
73
+ });
74
+ return { status: res.status ?? 1, output: String(res.stdout || '') + String(res.stderr || '') };
75
+ }
76
+
77
+ // 打印命令的形态解析(下面两条断言的共用前半段):① 脚本路径整条加双引号;② 分词后脚本参数恰
78
+ // 好是那一条路径(引号被剥离、空格不裂开);③ 路径按**当前运行形态**解析后真实存在。不写死任
79
+ // 何平台根:只问「能不能解析到脚本」,不问它以哪个平台目录开头。hint 是形态说明,只拼进不可解
80
+ // 析报文——两种形态都可接受时,让失败消息说清放宽的是哪两种。
81
+ function parsePrintedCommandScript(command, root, label, hint = '') {
82
+ const match = command.match(/^node "([^"]+)"(?: .*)?$/);
83
+ if (!match) {
84
+ throw new Error(label + ' 的脚本路径未整条加双引号(安装根含空格时会被 shell 分词): ' + command);
85
+ }
86
+ const printedScript = match[1];
87
+ const argv = splitPrintedCommand(command);
88
+ if (argv[1] !== printedScript) {
89
+ throw new Error(label + ' 的脚本路径被分词拆开: ' + JSON.stringify(argv));
90
+ }
91
+ const resolved = path.resolve(root, printedScript);
92
+ if (!fs.existsSync(resolved)) {
93
+ throw new Error(label + ' 的脚本路径按当前运行形态不可解析' + hint + ': ' + printedScript + ' → ' + resolved);
94
+ }
95
+ return { printedScript, resolved };
96
+ }
97
+
98
+ // 期望脚本同一性断言(夹具内的运行形态已知时使用):④ 解析结果与期望副本是同一文件。
99
+ function assertPrintedCommandResolves(command, root, expectedScript, label) {
100
+ const { printedScript, resolved } = parsePrintedCommandScript(command, root, label);
101
+ if (fs.realpathSync(resolved) !== fs.realpathSync(expectedScript)) {
102
+ throw new Error(label + ' 解析到了别的脚本: ' + resolved + '(期望 ' + expectedScript + ')');
103
+ }
104
+ return printedScript;
105
+ }
106
+
107
+ // 恢复段里「哪些行是可执行命令」的判据(两处恢复段共用):命令行 = 行首即 node + 引号脚本路径,
108
+ // 其余行是步骤标注与说明。判据分两半——① 可执行行集合与期望逐字相等(多一行说明被拼进命令、或少
109
+ // 一行命令,照抄都会断);② 说明行不得出现命令形态(说明接回命令行尾时,整行丢给 shell 会把说明当
110
+ // 成参数,命令看起来在场、照抄即失败)。返回命令行(调用方随后逐条真实执行——「能解析」不等于「能跑」)。
111
+ function shellCommandLines(block) {
112
+ return String(block ?? '').split(/\r?\n/u)
113
+ .filter((line) => /^\s*node\s+"/u.test(line))
114
+ .map((line) => line.trim());
115
+ }
116
+
117
+ function assertRecoveryCommandLines(block, expected, label) {
118
+ const commands = shellCommandLines(block);
119
+ assertTrue(commands.length === expected.length && commands.every((line, index) => line === expected[index]),
120
+ label + ':恢复段的可执行行应恰好是期望的命令(顺序一致):\n命令=' + JSON.stringify(commands)
121
+ + '\n期望=' + JSON.stringify(expected) + '\n原文:\n' + block);
122
+ for (const line of String(block ?? '').split(/\r?\n/u)) {
123
+ if (line.trim() === '' || /^\s*node\s+"/u.test(line)) continue;
124
+ assertTrue(!/node\s+"[^"]+"/u.test(line),
125
+ label + ':说明行里出现了命令文本(命令须单独成行,否则整行不可执行): ' + line);
126
+ }
127
+ return commands;
128
+ }
129
+
130
+ // 安装根形态断言(运行形态由脚本自定位决定、夹具无从预知时使用):④ 解析出的命令脚本必须是真实
131
+ // 存在的 <scriptName>,且落在 flow-comet 技能树内。两种正确形态都放行——安装副本按**运行中脚本
132
+ // 所在的安装根**推出的路径(.claude / .agents / .dsh 乃至用户级安装),以及权威源写出的设计形态
133
+ // .claude/skills/…(在夹具里解析到技能树副本)。命令是否真的能在当前安装里照抄执行,由调用方随后
134
+ // 执行**打印出来的那条文本**证明——本断言不拿 harness 的脚本路径替代它。
135
+ function assertPrintedCommandTargetsInstalledScript(command, root, scriptName, label) {
136
+ const { printedScript, resolved } = parsePrintedCommandScript(command, root, label,
137
+ '(允许安装根形态或 fixture 设计形态)');
138
+ if (path.basename(resolved) !== scriptName) {
139
+ throw new Error(label + ' 解析到的不是 ' + scriptName + '(允许安装根形态或 fixture 设计形态): ' + resolved);
140
+ }
141
+ if (!resolved.split(/[\\/]+/).includes('flow-comet')) {
142
+ throw new Error(label + ' 解析到的脚本不在 flow-comet 技能树内(允许安装根形态或 fixture 设计形态): ' + resolved);
143
+ }
144
+ return printedScript;
145
+ }
37
146
 
38
147
  export const ENTRIES = [
39
148
 
@@ -41,7 +150,7 @@ export const ENTRIES = [
41
150
 
42
151
  // 34: subagent-execute exit 通过——handoff result 的 completedChecks 含 required-skill 条目 → exit 0
43
152
  {
44
- name: '34 subagent-execute exit 通过:handoff 含 completedChecks',
153
+ name: '34 subagent-execute exit 通过:handoff 含 completedChecks + 缺证据恢复命令可照抄执行',
45
154
  run: (dir) => {
46
155
  const st = baseState('subagent-execute');
47
156
  st.evidence['subagent-execute'] = {
@@ -53,6 +162,520 @@ export const ENTRIES = [
53
162
  const res = runGuard(['exit', 'subagent-execute'], dir);
54
163
  assertExit(res, 0);
55
164
  assertOut(res, 'ALL CHECKS PASSED');
165
+
166
+ // ---------- 缺证据阻塞给出可复制恢复命令(in-place 扩展;不新增场景条目) ----------
167
+ // ① 移除 evidence.summary(record 只写 summary 的合法路径)→ exit 命中 missing Output
168
+ // Schema evidence;BLOCKED 行之后必须给出可照抄的恢复命令,照抄执行后同一 exit 通过。
169
+ const stateFile = path.join(dir, '.flow-comet', 'flow-comet-state.json');
170
+ const stNoEvidence = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
171
+ delete stNoEvidence.evidence['subagent-execute'].summary;
172
+ writeState(dir, stNoEvidence);
173
+ // 前提:本节点还没有技能加载声明标记(record 的前置门)——报文必须把这道前置条件一并给全。
174
+ const loadsDir = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
175
+ if (fs.existsSync(loadsDir)) {
176
+ throw new Error('夹具前提不成立:缺声明分支要求 .skill-loads/ 不存在(实际: ' + loadsDir + ')');
177
+ }
178
+ const resNoEvidence = runGuard(['exit', 'subagent-execute'], dir);
179
+ assertExit(resNoEvidence, 1);
180
+ assertOut(resNoEvidence, 'BLOCKED: missing Output Schema evidence');
181
+ assertOut(resNoEvidence, '{"summary":"<本节点完成摘要>"}');
182
+ assertOut(resNoEvidence, '后重试 exit');
183
+ // ② 恢复命令**从输出解析**(不再与字面串比对——字面量断言正是此前漏检的成因)。缺技能加载声明
184
+ // 时照抄 record 会被它自己的前置门拦下(「节点缺少技能加载声明标记」),半步恢复 = 还得去另一条
185
+ // 报文里找 skill-load 命令;故两条命令必须落在**同一段「恢复:」**里(本段 = 输出里最后一条恢复段,
186
+ // 该段之后引擎直接退出)。
187
+ const recoveryStart = resNoEvidence.output.lastIndexOf('恢复:');
188
+ const recoveryBlock = recoveryStart < 0 ? '' : resNoEvidence.output.slice(recoveryStart);
189
+ if (recoveryBlock === '') {
190
+ throw new Error('BLOCKED 输出缺恢复段:\n' + resNoEvidence.output);
191
+ }
192
+ const recordCommand = (recoveryBlock.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
193
+ const skillLoadCommand = (recoveryBlock.match(/^\s*(node "[^"]+" skill-load [^\n]+)$/m) || [])[1];
194
+ if (!recordCommand) {
195
+ throw new Error('BLOCKED 输出的恢复段缺可解析的 record 命令:\n' + resNoEvidence.output);
196
+ }
197
+ if (!skillLoadCommand) {
198
+ throw new Error('缺技能加载声明时恢复段必须同时给出 skill-load 命令'
199
+ + '(否则照抄 record 会被它的前置门拦下,第二步的命令又落在另一条报文里):\n' + resNoEvidence.output);
200
+ }
201
+ // 恢复段的可执行行 = 这两条命令,顺序即执行顺序;其余行都是说明——说明不得带命令形态(同一行里
202
+ // 「命令 + 说明」整行丢给 shell 会把说明当成参数,正是可照抄性失效的形态)。
203
+ assertRecoveryCommandLines(recoveryBlock, [skillLoadCommand, recordCommand], '缺声明的缺证据恢复段');
204
+ // 协议上下文跟「本次实际用到的协议」走,不跟来源走:本段的协议来自调用方环境(runGuard 注入
205
+ // FLOW_COMET_PROTOCOL = 夹具内的协议副本),它不是内置默认那一份——副本路径与内置默认不同,
206
+ // 照抄时不带 --protocol 就会按同一套优先级重新解析。故命令必须自带协议路径(与「协议来自
207
+ // state」那条同一判据,见本场景末尾;来源是 env 时此前只印命令,照抄即落到默认协议)。
208
+ for (const [label, recoveredCommand] of [['record', recordCommand], ['skill-load', skillLoadCommand]]) {
209
+ if (!recoveredCommand.includes(' --protocol "reference/workflow-protocol.json"')) {
210
+ throw new Error('协议来自环境变量且不是内置默认时,恢复段的 ' + label + ' 命令必须自带 '
211
+ + '--protocol "reference/workflow-protocol.json"(否则照抄时协议上下文丢失): ' + recoveredCommand);
212
+ }
213
+ }
214
+ // ③ 两条命令的脚本路径逐字等于 scriptCommand 的产物(路径与引号只有一处实现——换一种拼法在此判红)。
215
+ const printedPathPrefix = scriptCommand({ scriptsDir: SCRIPTS_DIR, runRoot: dir, script: 'workflow-state.mjs' });
216
+ for (const [label, recoveredCommand] of [['record', recordCommand], ['skill-load', skillLoadCommand]]) {
217
+ if (!recoveredCommand.startsWith(printedPathPrefix + ' ')) {
218
+ throw new Error('恢复段的 ' + label + ' 命令脚本路径应逐字等于 scriptCommand 产物 '
219
+ + printedPathPrefix + ',实际: ' + recoveredCommand);
220
+ }
221
+ }
222
+ // 安装布局:权威源 = 设计形态(安装器把它装到平台根下);把本套件技能树按该布局复制进夹具,
223
+ // 权威源形态打印的相对路径才可解析。两种正确形态都放行——① 安装副本:命令路径按**运行中脚本
224
+ // 所在的安装根**推导(<安装根>/.claude/skills/… 的绝对路径——副本里照抄可执行的就是这条);
225
+ // ② 权威源:设计形态 .claude/skills/…(在夹具里解析到上面这份副本)。断言只问「解析到的是不
226
+ // 是真实存在的 workflow-state.mjs」——存在性 + 脚本名 + 随后真执行打印文本(不拿 harness 的
227
+ // 路径替代),不把路径钉成 fixture 路径(L-072:布局感知缺失会让安装副本套件变红)。
228
+ installSkillTreeCopy(dir, path.join('.claude', 'skills'));
229
+ assertPrintedCommandTargetsInstalledScript(recordCommand, dir, 'workflow-state.mjs', '恢复命令');
230
+ assertPrintedCommandTargetsInstalledScript(skillLoadCommand, dir, 'workflow-state.mjs', '前置声明命令');
231
+ // ④ 照抄打印出来的两条命令并真实执行(不是 harness 的绝对脚本路径):按报文给出的执行顺序
232
+ // 先声明、再 record。走通这两步才说明「一条报文 = 一条恢复路径」。
233
+ // 环境变量清空:协议上下文只能来自命令本身——命令没带 --protocol 时这一步会落到内置默认协议
234
+ // (项目根之外)而不是夹具里的那份,照抄即失败。
235
+ const resDeclared = runPrintedCommand(skillLoadCommand, dir, {
236
+ FLOW_COMET_RUN_ROOT: dir,
237
+ FLOW_COMET_PROTOCOL: '',
238
+ });
239
+ assertExit(resDeclared, 0);
240
+ assertOut(resDeclared, 'SKILL-LOAD: subagent-execute');
241
+ const declaredMarkers = fs.readdirSync(loadsDir)
242
+ .filter((name) => name.startsWith('subagent-execute-') && name.endsWith('.json'));
243
+ if (declaredMarkers.length === 0) {
244
+ throw new Error('照抄前置声明命令后应有 .skill-loads/subagent-execute-*.json'
245
+ + '(record 前置门按该前缀判定): ' + JSON.stringify(fs.readdirSync(loadsDir)));
246
+ }
247
+ const resRecoveredByCommand = runPrintedCommand(recordCommand, dir, {
248
+ FLOW_COMET_RUN_ROOT: dir,
249
+ FLOW_COMET_PROTOCOL: '',
250
+ });
251
+ assertExit(resRecoveredByCommand, 0);
252
+ const stRecovered = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
253
+ if (stRecovered.evidence['subagent-execute'].summary !== '<本节点完成摘要>') {
254
+ throw new Error('照抄恢复命令后 evidence.summary 未按打印载荷写入,实际: '
255
+ + JSON.stringify(stRecovered.evidence['subagent-execute']));
256
+ }
257
+ const resEvidenceRecovered = runGuard(['exit', 'subagent-execute'], dir);
258
+ assertExit(resEvidenceRecovered, 0);
259
+ assertOut(resEvidenceRecovered, 'ALL CHECKS PASSED');
260
+ // ⑤ 声明已在场 → 恢复段收敛回一条 record(不多给一步):同样的缺证据阻塞,恢复段里不得再出现
261
+ // skill-load 步骤。断言只看恢复段,别的门的提示不在本断言范围。
262
+ const stAgain = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
263
+ delete stAgain.evidence['subagent-execute'].summary;
264
+ writeState(dir, stAgain);
265
+ const resDeclaredMissing = runGuard(['exit', 'subagent-execute'], dir);
266
+ assertExit(resDeclaredMissing, 1);
267
+ assertOut(resDeclaredMissing, 'BLOCKED: missing Output Schema evidence');
268
+ const declaredRecoveryStart = resDeclaredMissing.output.lastIndexOf('恢复:');
269
+ const declaredRecovery = declaredRecoveryStart < 0 ? '' : resDeclaredMissing.output.slice(declaredRecoveryStart);
270
+ const singleRecordCommand = (declaredRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
271
+ if (!singleRecordCommand) {
272
+ throw new Error('已有声明时恢复段缺 record 命令:\n' + resDeclaredMissing.output);
273
+ }
274
+ // 恢复段的两行结构:说明行(「照抄下面的命令…」)+ 命令行 + 说明行(怎么执行)。命令行单独成行,
275
+ // 整行丢给 shell 才是那条可执行的命令——这是「照抄即通」的形态判据(执行面由下面那行证明)。
276
+ assertRecoveryCommandLines(declaredRecovery, [singleRecordCommand], '已有声明的缺证据恢复段');
277
+ if (!declaredRecovery.startsWith('恢复: ')) {
278
+ throw new Error('已有声明时恢复段应以「恢复:」开口:\n' + declaredRecovery);
279
+ }
280
+ if (/第一步|第二步/s.test(declaredRecovery)) {
281
+ throw new Error('已有声明时恢复段不得再给分步标注(不给多余步骤):\n' + declaredRecovery);
282
+ }
283
+ if (/skill-load\s/.test(declaredRecovery)) {
284
+ throw new Error('已有声明时恢复段不得再给 skill-load 步骤:\n' + declaredRecovery);
285
+ }
286
+ // 复位:照抄该 record 把证据补回去,后续段从「证据齐 + 有声明」的形态继续
287
+ assertExit(runPrintedCommand(singleRecordCommand, dir, {
288
+ FLOW_COMET_RUN_ROOT: dir,
289
+ FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir),
290
+ }), 0);
291
+
292
+ // ---------- 开工前可见的 LESSONS 命中集(原位扩展;不新增场景条目) ----------
293
+ // 出口按「任务 write_files 的路径段(过停用词)× .specs/LESSONS.md 条目的关键词行」重算命中集
294
+ // (前 5 条),并要求 SUMMARY 的 ## LESSONS 扫描 段逐条回应这些编号;执行者开工时看不到这个
295
+ // 集合,只能按自己对任务主题的理解扫,两套口径只在出口对齐 —— 本段做对账:request 打印的
296
+ // 命中集必须与出口重算的逐条一致(同一份命中算法驱动两处,各算一套必在此红)。
297
+ const lessonsLedger = [
298
+ '# LESSONS — 跨任务失败知识库(夹具)',
299
+ '',
300
+ '## 条目区(夹具)',
301
+ '',
302
+ '### L-501 · [proc] 门禁按结构级校验',
303
+ '',
304
+ '- **关键词**: guard, template',
305
+ '',
306
+ '夹具条目正文:判据按结构级校验,不做语义判断。',
307
+ '',
308
+ '### L-502 · [test] 归档提名须留痕',
309
+ '',
310
+ '- **关键词**: template, archive',
311
+ '',
312
+ '夹具条目正文:归档提名须留痕。',
313
+ '',
314
+ '### L-503 · [doc] 与任务写路径无交集的条目',
315
+ '',
316
+ '- **关键词**: nomination, release',
317
+ '',
318
+ '夹具条目正文:本条与任务写路径无交集,不得出现在命中集里(反向构造)。',
319
+ '',
320
+ ].join('\n');
321
+ writeFile(dir, '.specs/LESSONS.md', lessonsLedger);
322
+ // 任务的写面换成与教训册关键词有交集的路径:夹具路径 src/p1.mjs 的词元是 p1,长度不足被过滤
323
+ // —— 命中集恒空,锚不出差异。
324
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
325
+ + '<task id="P01" status="done" parallel="true"><action>改模板保真门禁</action>'
326
+ + '<write_files>scripts/lib/guard-template-fidelity.mjs</write_files>'
327
+ + '<verify>node --check src/p1.mjs</verify></task>\n');
328
+ writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', summaryContent());
329
+ // ① 出口重算:扫描段没回应命中条目 → 逐条列出编号(旧 change 渐进不阻断)
330
+ const exitLessons = runGuard(['exit', 'subagent-execute'], dir);
331
+ assertOut(exitLessons, '未回应命中条目 L-501');
332
+ const exitHitIds = ((exitLessons.output.match(/未回应命中条目 ([^\n]*)/) || [])[1] || '').match(/L-\d+/g) || [];
333
+ assertEqual(exitHitIds.length, 2, '出口重算的命中条目数');
334
+ // ② request 开工前打印同一集合,顺序也一致(共享词多者在前)
335
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/subagent-execute-flow-comet-dev.json',
336
+ JSON.stringify({ node: 'subagent-execute', skill: 'flow-comet-dev', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
337
+ const reqLessons = runHandoff(['request', 'P01', 'lesson hits preview'], dir);
338
+ assertExit(reqLessons, 0);
339
+ assertOut(reqLessons, 'LESSONS-HITS: 2 条');
340
+ assertOut(reqLessons, '这些条目须在 SUMMARY 的 `## LESSONS 扫描` 段逐条回应');
341
+ const requestHitIds = reqLessons.output.split('\n')
342
+ .filter((line) => /^ {2}- L-\d+ · /.test(line))
343
+ .map((line) => (line.match(/L-\d+/) || [])[0]);
344
+ assertEqual(JSON.stringify(requestHitIds), JSON.stringify(exitHitIds),
345
+ 'request 的命中集必须与出口重算逐条一致(同一函数驱动)');
346
+ assertNotOut(reqLessons, 'L-503');
347
+ // ③ 教训册不可读 → 一行降级提示:request 不失败、不编造条目
348
+ fs.rmSync(path.join(dir, '.specs', 'LESSONS.md'));
349
+ const reqNoLedger = runHandoff(['request', 'P01', 'ledger missing'], dir);
350
+ assertExit(reqNoLedger, 0);
351
+ assertOut(reqNoLedger, 'LESSONS-HITS: 无法计算');
352
+ assertNotOut(reqNoLedger, 'L-501');
353
+ // ④ 边界:任务本身不声明写面 → 明确「无可回应条目」,不静默跳过(教训册先复位,命中的判据
354
+ // 才只剩「任务没有写面」这一条)
355
+ writeFile(dir, '.specs/LESSONS.md', lessonsLedger);
356
+ // 原位扩展(写面提取单一来源 / 不跨任务):把**未声明写面**的任务放在声明了写面的任务之前——
357
+ // 按块取的提取不越过 </task>,缺失就是缺失;旧实现用「<task id=…> 到全文下一个 <write_files>」
358
+ // 的单条非贪婪正则,会取到下一个任务的写面:同一次 request 一边打印「未声明 write_files」,
359
+ // 一边把下一个任务的路径记成本任务的提交边界(提交子集校验随后按别人的白名单放行)。
360
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
361
+ + '<task id="P03" status="done" parallel="true"><action>无写文件任务</action>'
362
+ + '<verify>node --check src/p3.mjs</verify></task>\n'
363
+ + '<task id="P04" status="pending" parallel="true"><action>相邻任务</action>'
364
+ + '<write_files>src/p04.mjs</write_files><verify>node --check src/p04.mjs</verify></task>\n');
365
+ const reqNoWriteFiles = runHandoff(['request', 'P03', 'no write files'], dir);
366
+ assertExit(reqNoWriteFiles, 0);
367
+ assertOut(reqNoWriteFiles, '无可回应条目(任务 P03 未声明 write_files)');
368
+ // 同一次 request 的另一半:写面不可解析 → 渐进提示(旧 change 不阻断),且不记录写面
369
+ assertOut(reqNoWriteFiles, '委托任务不可解析');
370
+ const stNoWrite = JSON.parse(readStateBytes(dir));
371
+ const reqNoWrite = stNoWrite.evidence?.['subagent-execute']?.handoffRequests?.P03;
372
+ if (!reqNoWrite) {
373
+ throw new Error('写面不可解析的 request 仍应照常记录(旧 change 渐进),实际 evidence: '
374
+ + JSON.stringify(stNoWrite.evidence));
375
+ }
376
+ if (Array.isArray(reqNoWrite.writeFiles) && reqNoWrite.writeFiles.length > 0) {
377
+ throw new Error('未声明写面的任务不得记录写面,实际: ' + JSON.stringify(reqNoWrite.writeFiles));
378
+ }
379
+ if (JSON.stringify(stNoWrite).includes('src/p04.mjs')) {
380
+ throw new Error('未声明写面的任务把相邻任务的路径记进了 state(跨任务取值): ' + JSON.stringify(reqNoWrite));
381
+ }
382
+ // 同一份 TASK 在**新 change** 下:写面缺失必须在入口 BLOCK——旧实现借来相邻任务的写面,request
383
+ // 因而放行,越界要等到提交子集校验才炸。BLOCK 路径 state 字节零改写。
384
+ const newChangeState = baseState('subagent-execute');
385
+ newChangeState.newChange = true;
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 boundBlocked = runGuard(['exit', 'brainstorm'], dir, { FLOW_COMET_PROTOCOL: '' });
483
+ assertExit(boundBlocked, 1);
484
+ assertOut(boundBlocked, 'BLOCKED: missing Output Schema evidence: compose.notes.v1.notes-summary');
485
+ const boundRecoveryStart = boundBlocked.output.lastIndexOf('恢复:');
486
+ const boundRecovery = boundRecoveryStart < 0 ? '' : boundBlocked.output.slice(boundRecoveryStart);
487
+ const boundRecordCommand = (boundRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
488
+ const boundSkillLoadCommand = (boundRecovery.match(/^\s*(node "[^"]+" skill-load [^\n]+)$/m) || [])[1];
489
+ if (!boundRecordCommand || !boundSkillLoadCommand) {
490
+ throw new Error('state 绑定自定义协议的恢复段必须同时给出 skill-load 与 record 命令:\n' + boundBlocked.output);
491
+ }
492
+ // ① 正例:两条命令都带 --protocol(state 绑定的路径)。不带时照抄执行会落到 env/默认协议,
493
+ // brainstorm 在默认 8 节点协议里不存在——恢复路径断在第一句话。
494
+ for (const [label, boundCommand] of [['record', boundRecordCommand], ['skill-load', boundSkillLoadCommand]]) {
495
+ if (!boundCommand.includes(' --protocol "' + boundProtocolRel + '"')) {
496
+ throw new Error('协议来自 state.protocolPath 时,恢复段的 ' + label + ' 命令必须自带 --protocol "'
497
+ + boundProtocolRel + '"(否则照抄时协议上下文丢失): ' + boundCommand);
498
+ }
499
+ }
500
+ // ② 照抄执行(无环境变量——协议上下文只能来自命令本身):两步都要真实走通。
501
+ const boundDeclared = runPrintedCommand(boundSkillLoadCommand, dir, {
502
+ FLOW_COMET_RUN_ROOT: dir,
503
+ FLOW_COMET_PROTOCOL: '',
504
+ });
505
+ assertExit(boundDeclared, 0);
506
+ assertOut(boundDeclared, 'SKILL-LOAD: brainstorm');
507
+ const boundRecorded = runPrintedCommand(boundRecordCommand, dir, {
508
+ FLOW_COMET_RUN_ROOT: dir,
509
+ FLOW_COMET_PROTOCOL: '',
510
+ });
511
+ assertExit(boundRecorded, 0);
512
+ const boundStateAfter = JSON.parse(readStateBytes(dir));
513
+ assertEqual(boundStateAfter.evidence?.brainstorm?.summary, '<本节点完成摘要>',
514
+ '照抄的 record 命令写入的 evidence(协议上下文须随命令到达)');
515
+ // ③ 一条报文走完即闭合:同一 exit 不再报缺证据
516
+ const boundPassed = runGuard(['exit', 'brainstorm'], dir, { FLOW_COMET_PROTOCOL: '' });
517
+ assertExit(boundPassed, 0);
518
+ assertOut(boundPassed, 'ALL CHECKS PASSED');
519
+
520
+ // ④ 第三种来源:--protocol CLI(state 无绑定、环境变量为空)——判据不看来源,命令同样自带该
521
+ // 协议路径。这正是缺陷形态的原点:用 --protocol 调 guard 时,恢复命令曾不带协议上下文,照抄
522
+ // 一步就落到 env/默认协议(自定义协议里才有的节点名在那份协议里不存在)。
523
+ writeState(dir, composeState({ currentNode: 'brainstorm', evidence: { brainstorm: {} } }));
524
+ const cliBlocked = runGuard(['exit', 'brainstorm', '--protocol', boundProtocolRel], dir, { FLOW_COMET_PROTOCOL: '' });
525
+ assertExit(cliBlocked, 1);
526
+ assertOut(cliBlocked, 'BLOCKED: missing Output Schema evidence: compose.notes.v1.notes-summary');
527
+ const cliRecoveryStart = cliBlocked.output.lastIndexOf('恢复:');
528
+ const cliRecovery = cliRecoveryStart < 0 ? '' : cliBlocked.output.slice(cliRecoveryStart);
529
+ const cliRecordCommand = (cliRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
530
+ if (!cliRecordCommand) {
531
+ throw new Error('协议来自 --protocol CLI 时,恢复段必须给出可照抄的 record 命令:\n' + cliBlocked.output);
532
+ }
533
+ if (!cliRecordCommand.includes(' --protocol "' + boundProtocolRel + '"')) {
534
+ throw new Error('协议来自 --protocol CLI 时,恢复段的 record 命令必须自带 --protocol "'
535
+ + boundProtocolRel + '"(照抄时协议上下文只能来自命令本身): ' + cliRecordCommand);
536
+ }
537
+ const cliRecorded = runPrintedCommand(cliRecordCommand, dir, {
538
+ FLOW_COMET_RUN_ROOT: dir,
539
+ FLOW_COMET_PROTOCOL: '',
540
+ });
541
+ assertExit(cliRecorded, 0);
542
+ assertEqual(JSON.parse(readStateBytes(dir)).evidence?.brainstorm?.summary, '<本节点完成摘要>',
543
+ '照抄 CLI 来源下打印的 record 命令写入的 evidence');
544
+
545
+ // ⑤ 负例:协议来自内置默认(无 CLI、无 state 绑定、无环境变量)→ 命令不加 --protocol。
546
+ // 用安装副本自身的脚本跑:权威源检出的内置协议落在夹具根之外(协议读取要求协议在项目根内),
547
+ // 副本形态才等价于真实安装——默认解析落到的正是包内协议。
548
+ const defaultState = baseState('subagent-execute');
549
+ defaultState.evidence['subagent-execute'] = { handoffResult: handoffFor(['P01']) };
550
+ writeState(dir, defaultState);
551
+ fs.rmSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true, force: true });
552
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
553
+ const defaultBlocked = runScriptCopy(
554
+ path.join(dir, '.claude', 'skills', 'flow-comet', 'scripts', 'workflow-guard.mjs'),
555
+ ['exit', 'subagent-execute'],
556
+ dir,
557
+ { FLOW_COMET_RUN_ROOT: dir, FLOW_COMET_PROTOCOL: '' },
558
+ );
559
+ assertExit(defaultBlocked, 1);
560
+ assertOut(defaultBlocked, 'BLOCKED: missing Output Schema evidence');
561
+ const defaultRecoveryStart = defaultBlocked.output.lastIndexOf('恢复:');
562
+ const defaultRecovery = defaultRecoveryStart < 0 ? '' : defaultBlocked.output.slice(defaultRecoveryStart);
563
+ const defaultRecordCommand = (defaultRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
564
+ const defaultSkillLoadCommand = (defaultRecovery.match(/^\s*(node "[^"]+" skill-load [^\n]+)$/m) || [])[1];
565
+ if (!defaultRecordCommand || !defaultSkillLoadCommand) {
566
+ throw new Error('内置默认协议下 BLOCKED 输出的恢复段缺可解析命令:\n' + defaultBlocked.output);
567
+ }
568
+ for (const [label, defaultCommand] of [['record', defaultRecordCommand], ['skill-load', defaultSkillLoadCommand]]) {
569
+ if (defaultCommand.includes('--protocol')) {
570
+ throw new Error('协议来自内置默认时,恢复段的 ' + label + ' 命令不应加 --protocol: ' + defaultCommand);
571
+ }
572
+ }
573
+
574
+ // ---------- 完全没有证据对象:恢复段同样要是可照抄命令(原位扩展;不新增场景条目) ----------
575
+ // 另一个门禁点:节点连 evidence 对象都没有时,前置的「缺证据」门先命中(早于 Output Schema
576
+ // 证据门)。两处说的是同一件事(节点已完成、证据不在),恢复段必须同形——命令形态一致,缺
577
+ // 声明时**同样按执行顺序给两步**。各写一份时,一处两步、另一处只剩 record:照抄第一条就撞
578
+ // record 自己的声明门,第二步的命令还落在另一条报文里(要两次往返还走不通一条路)。
579
+ writeState(dir, baseState('subagent-execute'));
580
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
581
+ const noEvidenceBlocked = runGuard(['exit', 'subagent-execute'], dir);
582
+ assertExit(noEvidenceBlocked, 1);
583
+ assertOut(noEvidenceBlocked, 'BLOCKED: missing evidence for Node subagent-execute.');
584
+ // ① 命令不是孤立的一句:先点名缺的是这个节点的证据对象
585
+ assertOut(noEvidenceBlocked, '该节点已完成但缺证据记录');
586
+ const noEvidenceRecoveryStart = noEvidenceBlocked.output.lastIndexOf('恢复:');
587
+ const noEvidenceRecovery = noEvidenceRecoveryStart < 0
588
+ ? ''
589
+ : noEvidenceBlocked.output.slice(noEvidenceRecoveryStart);
590
+ const noEvidenceRecordCommand = (noEvidenceRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
591
+ if (!noEvidenceRecordCommand) {
592
+ throw new Error('完全没有证据对象时,恢复段必须给出可照抄的 record 命令:\n' + noEvidenceBlocked.output);
593
+ }
594
+ // ② 证据整体缺席 + 缺声明 ⇒ 恢复段必须是**两步**(本格核心):先声明技能加载、再补证据。
595
+ // 只给 record 时,照抄第一步就撞 record 自己的前置门(「节点缺少技能加载声明标记」),第二步
596
+ // 的命令还落在另一条报文里——要两次往返才走通。
597
+ const noEvidenceSkillLoadCommand =
598
+ (noEvidenceRecovery.match(/^\s*(node "[^"]+" skill-load [^\n]+)$/m) || [])[1];
599
+ if (!noEvidenceSkillLoadCommand) {
600
+ throw new Error('证据整体缺席且缺技能加载声明时,恢复段必须同时给出 skill-load 命令'
601
+ + '(否则照抄 record 会被它的前置门拦下,第二步的命令又落在另一条报文里):\n'
602
+ + noEvidenceBlocked.output);
603
+ }
604
+ const noEvidenceSkillAt = noEvidenceRecovery.indexOf(noEvidenceSkillLoadCommand);
605
+ const noEvidenceRecordAt = noEvidenceRecovery.indexOf(noEvidenceRecordCommand);
606
+ if (!(noEvidenceSkillAt >= 0 && noEvidenceRecordAt > noEvidenceSkillAt)) {
607
+ throw new Error('证据缺席的恢复段应按执行顺序排列:skill-load(声明技能加载)在前、'
608
+ + 'record(补证据)在后——顺序反了执行者照抄会先撞前置门:\n' + noEvidenceRecovery);
609
+ }
610
+ // ③ 与缺 Output Schema 字段那条同一构造:两条命令的脚本路径逐字等于 scriptCommand 的产物、
611
+ // 协议上下文随命令走(照抄时不带 --protocol 就落到另一份协议)
612
+ const noEvidencePathPrefix = scriptCommand({ scriptsDir: SCRIPTS_DIR, runRoot: dir, script: 'workflow-state.mjs' });
613
+ for (const [label, noEvidenceCommand] of [['record', noEvidenceRecordCommand], ['skill-load', noEvidenceSkillLoadCommand]]) {
614
+ if (!noEvidenceCommand.startsWith(noEvidencePathPrefix + ' ')) {
615
+ throw new Error('恢复段的 ' + label + ' 命令脚本路径应逐字等于 scriptCommand 产物 '
616
+ + noEvidencePathPrefix + ',实际: ' + noEvidenceCommand);
617
+ }
618
+ if (!noEvidenceCommand.includes(' --protocol "reference/workflow-protocol.json"')) {
619
+ throw new Error('协议不是内置默认时,恢复段的 ' + label + ' 命令必须自带 --protocol: ' + noEvidenceCommand);
620
+ }
621
+ }
622
+ // ④ 照抄打印出来的两条命令并真实执行(环境变量清空——协议上下文只能来自命令本身):按报文给的
623
+ // 顺序走完两步,同一 exit 通过,这条报文才是一条完整的恢复路径。
624
+ const noEvidenceDeclared = runPrintedCommand(noEvidenceSkillLoadCommand, dir, {
625
+ FLOW_COMET_RUN_ROOT: dir,
626
+ FLOW_COMET_PROTOCOL: '',
627
+ });
628
+ assertExit(noEvidenceDeclared, 0);
629
+ assertOut(noEvidenceDeclared, 'SKILL-LOAD: subagent-execute');
630
+ const noEvidenceRecovered = runPrintedCommand(noEvidenceRecordCommand, dir, {
631
+ FLOW_COMET_RUN_ROOT: dir,
632
+ FLOW_COMET_PROTOCOL: '',
633
+ });
634
+ assertExit(noEvidenceRecovered, 0);
635
+ assertEqual(JSON.parse(readStateBytes(dir)).evidence?.['subagent-execute']?.summary, '<本节点完成摘要>',
636
+ '照抄前置门的 record 命令写入的 evidence(协议上下文须随命令到达)');
637
+ const noEvidencePassed = runGuard(['exit', 'subagent-execute'], dir);
638
+ assertExit(noEvidencePassed, 0);
639
+ assertOut(noEvidencePassed, 'ALL CHECKS PASSED');
640
+ // ⑤ 声明已在场(上一步刚声明)⇒ 同一门禁点收敛回一条 record:不多给一步(否则把「已经做过
641
+ // 的事」再让人做一遍)。断言只看恢复段。
642
+ writeState(dir, baseState('subagent-execute'));
643
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
644
+ const declaredNoEvidence = runGuard(['exit', 'subagent-execute'], dir);
645
+ assertExit(declaredNoEvidence, 1);
646
+ const declaredNoEvidenceStart = declaredNoEvidence.output.lastIndexOf('恢复:');
647
+ const declaredNoEvidenceBlock = declaredNoEvidenceStart < 0
648
+ ? ''
649
+ : declaredNoEvidence.output.slice(declaredNoEvidenceStart);
650
+ if (!declaredNoEvidenceBlock.includes(noEvidenceRecordCommand)) {
651
+ throw new Error('已有声明时,缺证据的恢复段应仍给出同一条 record 命令:\n' + declaredNoEvidence.output);
652
+ }
653
+ if (/skill-load\s/.test(declaredNoEvidenceBlock) || /第一步|第二步/.test(declaredNoEvidenceBlock)) {
654
+ throw new Error('已有技能声明时恢复段不得再给 skill-load 步骤:\n' + declaredNoEvidenceBlock);
655
+ }
656
+ // ⑥ 反例:内置默认协议下同一门禁点的命令不加 --protocol(照抄时默认解析落到的就是同一份)
657
+ writeState(dir, baseState('subagent-execute'));
658
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
659
+ const defaultNoEvidenceBlocked = runScriptCopy(
660
+ path.join(dir, '.claude', 'skills', 'flow-comet', 'scripts', 'workflow-guard.mjs'),
661
+ ['exit', 'subagent-execute'],
662
+ dir,
663
+ { FLOW_COMET_RUN_ROOT: dir, FLOW_COMET_PROTOCOL: '' },
664
+ );
665
+ assertExit(defaultNoEvidenceBlocked, 1);
666
+ assertOut(defaultNoEvidenceBlocked, 'BLOCKED: missing evidence for Node subagent-execute.');
667
+ const defaultNoEvidenceStart = defaultNoEvidenceBlocked.output.lastIndexOf('恢复:');
668
+ const defaultNoEvidenceRecovery = defaultNoEvidenceStart < 0
669
+ ? ''
670
+ : defaultNoEvidenceBlocked.output.slice(defaultNoEvidenceStart);
671
+ const defaultNoEvidenceCommand =
672
+ (defaultNoEvidenceRecovery.match(/^\s*(node "[^"]+" record [^\n]*)$/m) || [])[1];
673
+ if (!defaultNoEvidenceCommand) {
674
+ throw new Error('完全没有证据对象时恢复段缺可解析的 record 命令:\n' + defaultNoEvidenceBlocked.output);
675
+ }
676
+ if (defaultNoEvidenceCommand.includes('--protocol')) {
677
+ throw new Error('协议来自内置默认时,没有证据对象那条恢复命令不应加 --protocol: ' + defaultNoEvidenceCommand);
678
+ }
56
679
  },
57
680
  },
58
681
 
@@ -114,18 +737,62 @@ export const ENTRIES = [
114
737
  // → 两次均通过;且 evidence 中 redEvidence/greenEvidence 附带 recordedAt 时间戳
115
738
  // (重录保留 red 首次记录时间,green 为补录时间——时序可审计)
116
739
  {
117
- name: '38 handoff red 先于 green 通过(redEvidence/greenEvidence 附带 recordedAt)',
740
+ name: '38 handoff red 先于 green 通过(recordedAt)+ result PREFLIGHT 命令平台化并被真实执行',
118
741
  run: (dir) => {
119
742
  writeState(dir, baseState('subagent-execute'));
120
743
  fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
121
744
  const redOnly = '{"redEvidence":{"command":"node --check src/p1.mjs"}}';
122
- const res1 = runHandoff(['result', 'P01', redOnly], dir);
745
+ const res1 = runHandoff(['result', 'P01', redOnly], dir, {
746
+ FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir),
747
+ });
123
748
  assertExit(res1, 0);
124
749
  assertOut(res1, 'HANDOFF RESULT: P01');
750
+ // ③ 缺证据的 WARN 点名 Return Contract 的 shape(只差 command 时不必猜字段怎么填)
751
+ assertOut(res1, 'HANDOFF WARN: P01 缺 greenEvidence');
752
+ assertOut(res1, '{command, output}');
753
+ assertOut(res1, 'command 与 output 两个字段');
125
754
  const both = '{"redEvidence":{"command":"node --check src/p1.mjs"},"greenEvidence":{"command":"node --check src/p1.mjs"}}';
126
- const res2 = runHandoff(['result', 'P01', both], dir);
755
+ const res2 = runHandoff(['result', 'P01', both], dir, {
756
+ FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir),
757
+ });
127
758
  assertExit(res2, 0);
128
759
  assertOut(res2, 'HANDOFF RESULT: P01');
760
+ // result 成功路径在 HANDOFF RESULT 之后追加 PREFLIGHT(SUMMARY 结构预检提示)——节点取路由
761
+ // 视图(与 next 的 NODE / status.routeNode 同源),不是 state.currentNode 原值;该行不得改写
762
+ // 既有 HANDOFF RESULT 前缀,也不得出现在失败路径。--preflight 只跑结构性门禁,与「完整 exit
763
+ // (不带 --apply)才是全链预演」两句必须同行,否则同一个 PREFLIGHT 指了两条命令。
764
+ assertOut(res2, 'PREFLIGHT: SUMMARY 结构尚未校验');
765
+ assertOut(res2, '做结构预检(只跑结构性门禁,不写 state、不推进状态)');
766
+ assertOut(res2, '完整 exit(不带 --apply)是节点收尾的全链预演');
767
+ // 路由视图的独立参照:status 是只读视图,其 routeNode 就是 next 会打印的节点。
768
+ const routeView = runState(['status'], dir);
769
+ assertExit(routeView, 0);
770
+ const routeNode = (routeView.output.match(/"routeNode":\s*"([^"]+)"/) ?? [])[1];
771
+ if (!routeNode) {
772
+ throw new Error('status 缺 routeNode(无法独立核对 PREFLIGHT 节点):\n' + routeView.output);
773
+ }
774
+ // PREFLIGHT 命令同样从输出解析(不再与字面串比对):加引号的脚本路径 + exit <路由视图节点> --preflight。
775
+ const preflightCommand = (res2.output.match(/PREFLIGHT: SUMMARY 结构尚未校验——可运行 (node .+?) 做结构预检/) || [])[1];
776
+ if (!preflightCommand) {
777
+ throw new Error('PREFLIGHT 行缺可解析的 exit 命令:\n' + res2.output);
778
+ }
779
+ const printedNode = preflightCommand.match(/^node "[^"]+" exit (\S+) --preflight$/);
780
+ if (!printedNode) {
781
+ throw new Error('PREFLIGHT 命令形态应为「整条加引号的脚本路径 + exit <节点> --preflight」,实际: ' + preflightCommand);
782
+ }
783
+ if (printedNode[1] !== routeNode) {
784
+ throw new Error('PREFLIGHT 节点应取路由视图(与 status.routeNode 同源):'
785
+ + JSON.stringify(printedNode[1]) + ' vs ' + JSON.stringify(routeNode));
786
+ }
787
+ const rawCurrentNode = JSON.parse(readStateBytes(dir)).currentNode;
788
+ if (printedNode[1] === rawCurrentNode) {
789
+ throw new Error('PREFLIGHT 节点不得取 state.currentNode 原值(该夹具的路由视图与 state 原值不同): ' + rawCurrentNode);
790
+ }
791
+ const resultLineAt = res2.output.indexOf('HANDOFF RESULT: P01');
792
+ const preflightLineAt = res2.output.indexOf('PREFLIGHT:');
793
+ if (!(resultLineAt >= 0 && preflightLineAt > resultLineAt)) {
794
+ throw new Error('PREFLIGHT 行必须追加在 HANDOFF RESULT 之后(既有前缀不得改写):\n' + res2.output);
795
+ }
129
796
  const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
130
797
  const rec = st.evidence['subagent-execute'].handoffResult['P01'].result;
131
798
  if (!rec.redEvidence.recordedAt || typeof rec.redEvidence.recordedAt !== 'string') {
@@ -134,6 +801,66 @@ export const ENTRIES = [
134
801
  if (!rec.greenEvidence.recordedAt || typeof rec.greenEvidence.recordedAt !== 'string') {
135
802
  throw new Error('greenEvidence 未附带 recordedAt: ' + JSON.stringify(rec.greenEvidence));
136
803
  }
804
+
805
+ // 协议不可读的降级形态(result 成功路径):不拿 state.currentNode 原值凑一条可能指错节点的
806
+ // 命令,只留「先确认协议可读」的指引与全链预演说明——提示面不得反过来让已落盘的成功路径失败,
807
+ // 也不得在无法解析路由视图时编造节点。
808
+ const noProtocol = runHandoff(['result', 'P01', both], dir);
809
+ assertExit(noProtocol, 0);
810
+ assertOut(noProtocol, 'PREFLIGHT: SUMMARY 结构尚未校验');
811
+ assertOut(noProtocol, '暂时无法解析路由节点');
812
+ assertOut(noProtocol, '完整 exit(不带 --apply)是节点收尾的全链预演');
813
+ assertNotOut(noProtocol, '可运行 node');
814
+
815
+ // ---------- PREFLIGHT 命令的真实执行(安装副本 + 含空格的路径;in-place 扩展) ----------
816
+ // ④ 平台化推导必须是**运行形态**的结果,而不是写死的平台字面量:把技能树复制到运行根下
817
+ // 含空格的相对目录,用副本自身跑 workflow-handoff —— 打印出的路径须带那个空格、整条加引号、
818
+ // 分词后仍是单一脚本参数,并在夹具里真实跑起来(缺引号时这条命令当场作废)。
819
+ const spaceSkillCopy = installSkillTreeCopy(dir, 'user install');
820
+ const resCopy = runScriptCopy(path.join(spaceSkillCopy, 'scripts', 'workflow-handoff.mjs'),
821
+ ['result', 'P01', both], dir, {
822
+ FLOW_COMET_RUN_ROOT: dir,
823
+ FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir),
824
+ });
825
+ assertExit(resCopy, 0);
826
+ assertOut(resCopy, 'HANDOFF RESULT: P01');
827
+ const copyPreflightCommand = (resCopy.output.match(/PREFLIGHT: SUMMARY 结构尚未校验——可运行 (node .+?) 做结构预检/) || [])[1];
828
+ if (!copyPreflightCommand) {
829
+ throw new Error('副本形态的 PREFLIGHT 行缺可解析的 exit 命令:\n' + resCopy.output);
830
+ }
831
+ const stateFile = path.join(dir, '.flow-comet', 'flow-comet-state.json');
832
+ const printedGuardScript = assertPrintedCommandResolves(copyPreflightCommand, dir,
833
+ path.join(spaceSkillCopy, 'scripts', 'workflow-guard.mjs'), 'PREFLIGHT 命令(安装副本形态)');
834
+ if (!printedGuardScript.includes(' ')) {
835
+ throw new Error('该形态的脚本路径应含空格(引号契约的判别场景),实际: ' + printedGuardScript);
836
+ }
837
+ const stateBytesBeforePreflight = fs.readFileSync(stateFile, 'utf8');
838
+ const resPreflight = runPrintedCommand(copyPreflightCommand, dir, {
839
+ FLOW_COMET_RUN_ROOT: dir,
840
+ FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir),
841
+ });
842
+ // 预检 = 只跑结构性门禁、不推进状态:须有真实门禁判决(该夹具本身不完整,通过/阻塞都算真跑),
843
+ // 且 state 字节零改写。
844
+ if (!/(ALL CHECKS PASSED|BLOCKED:)/.test(resPreflight.output)) {
845
+ throw new Error('PREFLIGHT 命令未真正跑到出口门禁(无门禁判决): exit ' + resPreflight.status
846
+ + '\n' + resPreflight.output);
847
+ }
848
+ if (fs.readFileSync(stateFile, 'utf8') !== stateBytesBeforePreflight) {
849
+ throw new Error('PREFLIGHT(--preflight)不得改写 state');
850
+ }
851
+
852
+ // ---------- 无活跃 change 的预检不得报「通过」(in-place 扩展;不新增场景条目) ----------
853
+ // 预检的子判据都按 change 定位(声明工件 / 骨架 / 段 / TASK 字段),没有 activeChange 时它们各自
854
+ // 早退——于是零判据跑完还打印 ALL CHECKS PASSED:这是「没看」被报成「看过且通过」,与只读命令
855
+ // 应有的结论(同 state 的完整 exit 是 BLOCKED)相互矛盾。判据:无可判结构面 → 非零退出且不得
856
+ // 出现通过结论;上面那段(有 activeChange 的真实预检)即「正常 change 不受影响」的对照。
857
+ const noChangeState = baseState('open');
858
+ delete noChangeState.activeChange;
859
+ writeState(dir, noChangeState);
860
+ const noChangePreflight = runGuard(['exit', 'open', '--preflight'], dir);
861
+ assertExit(noChangePreflight, 1);
862
+ assertOut(noChangePreflight, 'PREFLIGHT: 未校验(无活跃 change,没有可判的结构面)');
863
+ assertNotOut(noChangePreflight, 'ALL CHECKS PASSED');
137
864
  },
138
865
  },
139
866
 
@@ -151,6 +878,8 @@ export const ENTRIES = [
151
878
  const res2 = runHandoff(['result', 'P01', backfill], dir);
152
879
  assertExit(res2, 1);
153
880
  assertOut(res2, 'redEvidence 事后补录');
881
+ // 拦截路径不打印 PREFLIGHT(提示只在「结果已记录、可以预检了」的成功路径出现)
882
+ assertNotOut(res2, 'PREFLIGHT');
154
883
  },
155
884
  },
156
885
 
@@ -183,7 +912,7 @@ export const ENTRIES = [
183
912
 
184
913
  // 41: execute exit BLOCKED——TASK.md 任务内容实际变化(改 action 文本)→ 签名不同 → 严格拦截
185
914
  {
186
- name: '41 execute exit BLOCKED:任务内容变化签名不同',
915
+ name: '41 execute exit BLOCKED:任务内容变化签名不同 + replan 重签事实说明',
187
916
  run: (dir) => {
188
917
  const st = baseState('execute');
189
918
  st.evidence.execute = { summary: 'executed' };
@@ -201,6 +930,42 @@ export const ENTRIES = [
201
930
  const res = runGuard(['exit', 'execute'], dir);
202
931
  assertExit(res, 1);
203
932
  assertOut(res, 'TASK.md 任务集被修改');
933
+
934
+ // ---------- replan 成功行说明「重签了什么、没有做什么」(in-place 扩展) ----------
935
+ // ② 签名不一致 BLOCK 后的合规出路是 replan:成功行保持既有 REPLAN: 前缀不变,其后追加
936
+ // 一行事实说明——已重签 state.taskHash(值前缀标出版本),且 TASK.md 内容未改写、plan
937
+ // 节点证据未重记(防执行者误以为 replan 会重写计划工件或重跑 plan 出口)。
938
+ const resReplan = runStateWithProtocol(dir, ['replan', '任务集按实测修订', '--authorized-by', 'user-approval']);
939
+ assertExit(resReplan, 0);
940
+ assertOut(resReplan, 'REPLAN: execute');
941
+ assertOut(resReplan, '已重签 state.taskHash(值前缀 ');
942
+ assertOut(resReplan, 'TASK.md 内容未改写');
943
+ assertOut(resReplan, 'plan 节点证据未重记');
944
+ // 版本前缀从**实际签名**派生,不写死 v1:——算法升版时这里不会假红。
945
+ // 判据三点:① 行在场且带前缀;② 打印前缀 == 当前 TASK.md 签名的版本前缀;③ 落盘值等于签名。
946
+ const taskHashLine = resReplan.output.split(/\r?\n/).find((line) => line.startsWith('TASKHASH: '));
947
+ if (!taskHashLine) {
948
+ throw new Error('replan 成功行后缺 TASKHASH 事实说明:\n' + resReplan.output);
949
+ }
950
+ const printedSignaturePrefix = (taskHashLine.match(/值前缀 (v\d+:)/) ?? [])[1];
951
+ const replanTaskText = fs.readFileSync(path.join(dir, '.specs', CHANGE_ID, 'TASK.md'), 'utf8');
952
+ const actualSignature = String(requireRouteNodeExport('taskSetSignature')(replanTaskText));
953
+ const actualSignaturePrefix = actualSignature.split(':')[0] + ':';
954
+ if (printedSignaturePrefix !== actualSignaturePrefix) {
955
+ throw new Error('TASKHASH 行打印的版本前缀应与实际签名一致(算法升版不得假红):'
956
+ + JSON.stringify(printedSignaturePrefix) + ' vs ' + JSON.stringify(actualSignaturePrefix)
957
+ + '(实际签名 ' + actualSignature + ')');
958
+ }
959
+ const replanPersisted = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
960
+ if (replanPersisted.taskHash !== actualSignature) {
961
+ throw new Error('replan 重签的 state.taskHash 应等于当前 TASK.md 的实际签名:'
962
+ + JSON.stringify(replanPersisted.taskHash) + ' vs ' + JSON.stringify(actualSignature));
963
+ }
964
+ const replanLineAt = resReplan.output.indexOf('REPLAN: execute');
965
+ const replanDetailAt = resReplan.output.indexOf('已重签 state.taskHash');
966
+ if (!(replanLineAt >= 0 && replanDetailAt > replanLineAt)) {
967
+ throw new Error('replan 事实说明必须在 REPLAN 成功行之后(前缀语义不变):\n' + resReplan.output);
968
+ }
204
969
  },
205
970
  },
206
971
 
@@ -386,7 +1151,7 @@ export const ENTRIES = [
386
1151
  // next 重新路由回 subagent-execute(多趟循环路由——委托进入谓词每趟重新求值,单趟限制已移除);
387
1152
  // entry subagent-execute 仍放行(completedNodes 含该节点允许重入——每趟完整 entry 检查不绕过)
388
1153
  {
389
- name: '49 next 二次路由回 subagent-execute + entry 重入(多趟语义)',
1154
+ name: '49 next 二次路由回 subagent-execute + entry 重入(多趟语义)+ 归属受阻后 record+exit 恢复',
390
1155
  run: (dir) => {
391
1156
  writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n');
392
1157
  writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n');
@@ -404,6 +1169,134 @@ export const ENTRIES = [
404
1169
  const res2 = runGuard(['entry', 'subagent-execute'], dir);
405
1170
  assertExit(res2, 0);
406
1171
  assertOut(res2, 'ENTRY OK');
1172
+
1173
+ // ---------- request 归属受阻的新恢复路径(in-place 扩展) ----------
1174
+ // ④ 串行 pending 任务在 subagent-execute 发起 request → 归属门禁 BLOCK。报文不再承诺
1175
+ // 「先 next 再 entry 目标节点」(当前节点已 entry 未 exit 时会被节点顺序门拦),改为
1176
+ // 「先对当前节点 record + exit(退出后路由自动前进到目标节点)」;并断言按此指引真能走通。
1177
+ const stateFile = path.join(dir, '.flow-comet', 'flow-comet-state.json');
1178
+ const loadsDir = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
1179
+ fs.mkdirSync(loadsDir, { recursive: true });
1180
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/subagent-execute-flow-comet-dev.json',
1181
+ JSON.stringify({
1182
+ node: 'subagent-execute',
1183
+ skill: 'flow-comet-dev',
1184
+ protocol: '4-dev.md',
1185
+ templates: ['SUMMARY'],
1186
+ at: '2026-08-01T00:00:00.000Z',
1187
+ }, null, 2) + '\n');
1188
+ writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n');
1189
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n');
1190
+ writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# DESIGN\n\n## 0. 技术栈\n');
1191
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
1192
+ + '<task id="S01" parallel="false" status="pending">\n'
1193
+ + ' <name>串行任务 S01</name>\n'
1194
+ + ' <read_files>.specs/' + CHANGE_ID + '/TASK.md</read_files>\n'
1195
+ + ' <write_files>src/s01.mjs</write_files>\n'
1196
+ + ' <action>实现 S01</action>\n'
1197
+ + ' <verify>node --check src/s01.mjs</verify>\n'
1198
+ + ' <done>完成 S01</done>\n'
1199
+ + ' <depends_on></depends_on>\n'
1200
+ + '</task>\n');
1201
+ const reqState = baseState('subagent-execute');
1202
+ reqState.newChange = true;
1203
+ reqState.completedNodes = ['open', 'design', 'plan'];
1204
+ reqState.evidence = {
1205
+ open: { summary: 'open done' },
1206
+ design: { summary: 'design done' },
1207
+ plan: { summary: 'plan done' },
1208
+ };
1209
+ writeState(dir, reqState);
1210
+ // 真实 entry(记录 enteredNodes + 任务集签名;request 前置门要求本节点声明标记,已写)
1211
+ assertExit(runGuardWithProtocol(dir, ['entry', 'subagent-execute']), 0);
1212
+ // 开工前的 LESSONS 命中集是只读信息:教训册在场时 request 打印本任务的命中集(本夹具任务的写面
1213
+ // 词元 s01 命中条目 L-601);下面同时锚定它不改写 state、不改写教训册。
1214
+ const lessonsFile = path.join(dir, '.specs', 'LESSONS.md');
1215
+ writeFile(dir, '.specs/LESSONS.md', '# LESSONS\n\n## 条目区(夹具)\n\n### L-601 · [proc] 委托边界须留痕\n\n- **关键词**: s01 委托边界\n');
1216
+ const lessonsBytesBefore = fs.readFileSync(lessonsFile, 'utf8');
1217
+ // ---------- 声明标记必须属于本 change(原位扩展;不新增场景条目) ----------
1218
+ // 归档兜底只认本 change 自己的声明目录:活动 .skill-loads 在场时不再回溯归档(record 前置门
1219
+ // 与委托前置门同一份判据)。委托前置门曾经自持一份扫描,会扫遍所有后缀匹配 -<change-id> 的
1220
+ // 归档目录——别的 change 归档里的同名标记也能替本节点作证,等于在门禁上留了一个放行口。
1221
+ const decoyEntry = '2026-01-01-other-' + CHANGE_ID;
1222
+ writeFile(dir, '.specs/archive/' + decoyEntry + '/.skill-loads/subagent-execute-flow-comet-dev.json',
1223
+ JSON.stringify({ node: 'subagent-execute', skill: 'flow-comet-dev', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
1224
+ // 本 change 只声明了别的节点:把本节点标记临时改名,活动目录仍在场
1225
+ const activeMarker = path.join(loadsDir, 'subagent-execute-flow-comet-dev.json');
1226
+ const otherNodeMarker = path.join(loadsDir, 'plan-flow-comet-plan.json');
1227
+ fs.renameSync(activeMarker, otherNodeMarker);
1228
+ const bytesBeforeDecoy = fs.readFileSync(stateFile, 'utf8');
1229
+ const resDecoy = runHandoff(['request', 'S01', 'serial slice'], dir,
1230
+ { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) });
1231
+ assertExit(resDecoy, 1);
1232
+ assertOut(resDecoy, 'BLOCKED: 节点 subagent-execute 缺少技能加载声明标记');
1233
+ assertNotOut(resDecoy, 'HANDOFF REQUEST');
1234
+ if (fs.readFileSync(stateFile, 'utf8') !== bytesBeforeDecoy) {
1235
+ throw new Error('缺声明 BLOCK 必须 state 字节零改写(别的 change 归档标记不得替本节点作证)');
1236
+ }
1237
+ // 活动 .skill-loads/ 不存在(新 change 尚未声明的真实初始态)时,归档兜底同样不得把「同后缀
1238
+ // 但不同 change」的归档目录认作本 change:上面那条诱饵只在活动目录在场时被「活动优先」挡住,
1239
+ // 活动目录一撤,后缀匹配仍会命中 2026-01-01-other-<change-id>——别的 change 的声明替本节点作证,
1240
+ // 委托前置门于是放行(实测该形态打印出 HANDOFF REQUEST)。归档目录必须是 <YYYY-MM-DD>-<本
1241
+ // change> 的精确形态才作数。
1242
+ const loadsAside = path.join(dir, '.specs', 'loads-aside');
1243
+ fs.renameSync(loadsDir, loadsAside);
1244
+ const bytesBeforeSuffixDecoy = fs.readFileSync(stateFile, 'utf8');
1245
+ const resSuffixDecoy = runHandoff(['request', 'S01', 'serial slice'], dir,
1246
+ { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) });
1247
+ assertExit(resSuffixDecoy, 1);
1248
+ assertOut(resSuffixDecoy, 'BLOCKED: 节点 subagent-execute 缺少技能加载声明标记');
1249
+ assertNotOut(resSuffixDecoy, 'HANDOFF REQUEST');
1250
+ if (fs.readFileSync(stateFile, 'utf8') !== bytesBeforeSuffixDecoy) {
1251
+ throw new Error('同后缀异 change 的归档目录不得替本节点作证:BLOCK 必须 state 字节零改写');
1252
+ }
1253
+ fs.renameSync(loadsAside, loadsDir);
1254
+ // 复位:本节点标记归位、归档诱饵撤掉——后续段按「已声明」继续
1255
+ fs.renameSync(otherNodeMarker, activeMarker);
1256
+ fs.rmSync(path.join(dir, '.specs', 'archive'), { recursive: true, force: true });
1257
+ const bytesBeforeRequest = fs.readFileSync(stateFile, 'utf8');
1258
+ const resOwnership = runHandoff(['request', 'S01', 'serial slice'], dir,
1259
+ { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) });
1260
+ assertExit(resOwnership, 1);
1261
+ assertOut(resOwnership, 'BLOCKED: 任务 S01(串行 pending)应归属节点 execute');
1262
+ // 新指引:先 record + exit 当前节点;不再承诺「先 next 再 entry 目标节点」
1263
+ assertOut(resOwnership, '先对当前节点 subagent-execute record + exit');
1264
+ assertOut(resOwnership, '不要在未 exit 前 entry 目标节点');
1265
+ assertOut(resOwnership, 'workflow-state next');
1266
+ // 同口径:entry 只在当前节点 exit 之后才允许——断言顺序句里的条件分句与前后次序,
1267
+ // 不再裸断 'entry execute'(禁止句也会命中它,断言不出「让你 entry」与「禁止现在 entry」)。
1268
+ const ownershipGuide = resOwnership.output.split('\n').find((line) => line.includes('恢复指引:'));
1269
+ if (!ownershipGuide) {
1270
+ throw new Error('归属受阻输出缺恢复指引行:\n' + resOwnership.output);
1271
+ }
1272
+ assertOut(resOwnership, '等当前节点 exit 后,再用 workflow-state entry execute');
1273
+ if (!(ownershipGuide.indexOf('record + exit') >= 0
1274
+ && ownershipGuide.indexOf('record + exit') < ownershipGuide.indexOf('entry execute'))) {
1275
+ throw new Error('恢复指引顺序错误:entry 目标节点必须排在 record + exit 之后:' + ownershipGuide);
1276
+ }
1277
+ assertNotOut(resOwnership, '查看当前路由,按 NODE 输出进入');
1278
+ assertNotOut(resOwnership, 'HANDOFF REQUEST');
1279
+ // 命中集在归属门禁之前打印(BLOCK 路径不落 state):打印面只读——state 字节零改写、教训册字节零改写
1280
+ assertOut(resOwnership, 'LESSONS-HITS: 1 条');
1281
+ assertOut(resOwnership, 'L-601');
1282
+ if (fs.readFileSync(lessonsFile, 'utf8') !== lessonsBytesBefore) {
1283
+ throw new Error('开工前的命中集打印不得改写教训册');
1284
+ }
1285
+ if (fs.readFileSync(stateFile, 'utf8') !== bytesBeforeRequest) {
1286
+ throw new Error('归属受阻 BLOCK 必须 state 字节零改写(含开工前打印的命中集)');
1287
+ }
1288
+ // 照报文操作:record 当前节点 + exit --apply(退出后路由自动前进到目标节点)
1289
+ assertExit(runStateWithProtocol(dir, ['record', 'subagent-execute', '{"summary":"串行任务需回 execute 节点执行"}']), 0);
1290
+ const exitOwnership = runGuardWithProtocol(dir, ['exit', 'subagent-execute', '--apply']);
1291
+ assertExit(exitOwnership, 0);
1292
+ const stateAfterRecovery = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
1293
+ if (stateAfterRecovery.currentNode !== 'execute') {
1294
+ throw new Error('按新指引 record+exit 后 currentNode 应前进到 execute,实际: '
1295
+ + JSON.stringify(stateAfterRecovery.currentNode));
1296
+ }
1297
+ const nextAfterRecovery = runStateWithProtocol(dir, ['next']);
1298
+ assertExit(nextAfterRecovery, 0);
1299
+ assertOut(nextAfterRecovery, 'NODE: execute');
407
1300
  },
408
1301
  },
409
1302
 
@@ -640,6 +1533,54 @@ export const ENTRIES = [
640
1533
  if (ev.completedChecks === undefined) {
641
1534
  throw new Error('completedChecks 丢失(payload 未解析为对象): ' + JSON.stringify(ev));
642
1535
  }
1536
+
1537
+ // ---------- 载荷形状校验(in-place 扩展;不新增场景条目) ----------
1538
+ // 缺陷形态:summary 写成对象/数组/数字或空串时,record 照样把它写进 evidence。下游 exit 只看到
1539
+ // 「没有非空字符串 summary」,于是报 requires evidence: <schema>——出错的是 record、报错的却是
1540
+ // exit,执行者要自己反推「载荷该是什么形状」。以下断言把报错锁在坏载荷落库之前:点名字段路径
1541
+ // 与当前类型、给出可照抄的正确形态,且 state 字节零改写。
1542
+ const beforeBytes = readStateBytes(dir);
1543
+ const malformed = [
1544
+ { payload: '{"summary":{"nested":"object"}}', expect: 'summary: 必须是字符串(当前是 object)' },
1545
+ { payload: '{"summary":["lane"]}', expect: 'summary: 必须是字符串(当前是 array)' },
1546
+ { payload: '{"summary":42}', expect: 'summary: 必须是字符串(当前是 number)' },
1547
+ { payload: '{"summary":""}', expect: 'summary: 必须是非空字符串(当前是空串)' },
1548
+ { payload: '{"summary":"x","completedChecks":[{"id":"a"}]}', expect: 'completedChecks[0]: 必须是字符串(当前是 object)' },
1549
+ {
1550
+ payload: '{"summary":"x","lessonsNomination":{"nominated":[{"id":"a"}],"reasonIfNone":""}}',
1551
+ expect: 'lessonsNomination.nominated[0]: 必须是字符串(当前是 object)',
1552
+ },
1553
+ ];
1554
+ let lastMalformed = null;
1555
+ for (const item of malformed) {
1556
+ const res = runState(['record', 'open', item.payload, '--protocol', custom], dir);
1557
+ assertExit(res, 1);
1558
+ assertOut(res, item.expect);
1559
+ assertStateBytesUnchanged(
1560
+ dir,
1561
+ beforeBytes,
1562
+ '形状非法的载荷必须在写入前被拒(' + item.payload + ')',
1563
+ );
1564
+ lastMalformed = res;
1565
+ }
1566
+ // 报文还得给「该写成什么」:只有一句「不合法」等于让执行者再猜一次。
1567
+ assertOut(lastMalformed, '\'{"summary":"<本节点完成摘要>"}\'');
1568
+ assertOut(lastMalformed, '--json-file');
1569
+ assertOut(lastMalformed, 'cmd.exe');
1570
+ // 正锚:类型合法的载荷逐字通过(校验只判类型,不新增业务规则)
1571
+ const okPayload = JSON.stringify({
1572
+ summary: '形状合法',
1573
+ completedChecks: ['unit-tests'],
1574
+ lessonsNomination: { scanned: 0, nominated: [], reasonIfNone: '无新增条目' },
1575
+ });
1576
+ const okRes = runState(['record', 'open', okPayload, '--protocol', custom], dir);
1577
+ assertExit(okRes, 0);
1578
+ const okEvidence = JSON.parse(readStateBytes(dir)).evidence.open;
1579
+ if (okEvidence.summary !== '形状合法'
1580
+ || okEvidence.lessonsNomination.reasonIfNone !== '无新增条目'
1581
+ || !Array.isArray(okEvidence.completedChecks)) {
1582
+ throw new Error('类型合法的载荷未被原样写入: ' + JSON.stringify(okEvidence));
1583
+ }
643
1584
  },
644
1585
  },
645
1586
 
@@ -912,9 +1853,13 @@ export const ENTRIES = [
912
1853
  },
913
1854
  },
914
1855
 
915
- // 80: handoff result commitHash 存在性校验——不存在 → HANDOFF ERROR(固化:校验已存在(W2-D),经确认)
1856
+ // 80: handoff result 的 Return Contract 校验——① 无效 commitHash → HANDOFF ERROR(固化:校验已存在(W2-D),经确认);
1857
+ // ② 形状校验:与 record 共用 state-schema.evidencePayloadProblems,畸形契约在写盘**之前**被拒(exit 1 +
1858
+ // 点名字段路径与当前类型 + 可照抄形态),state 字节零改写——问题不再延后到出口门禁才暴露;
1859
+ // 非对象载荷(字符串 / 数组 / null / 数字)在入口即拒(与 record 入口同一判据,形状表对非对象按设计放行);
1860
+ // ③ 零提交语义(request 记 noCommit)与合法契约不受形状校验影响。
916
1861
  {
917
- name: '80 handoff result 无效 commitHash → ERROR(batch-H 固化)',
1862
+ name: '80 handoff result 契约校验:无效 commitHash → ERROR;非对象与畸形形状写入前拒绝',
918
1863
  run: (dir) => {
919
1864
  writeState(dir, baseState('subagent-execute'));
920
1865
  fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
@@ -931,6 +1876,255 @@ export const ENTRIES = [
931
1876
  const res = runHandoff(['result', 'T01', payload], dir);
932
1877
  assertExit(res, 0);
933
1878
  assertOut(res, 'HANDOFF ERROR: commitHash 无效或 git show 失败');
1879
+ // 形状校验的「字节零改写」基线:① 已落 T01 的 result(HANDOFF ERROR 不阻断记录),
1880
+ // 此后每次形状拒绝都不得改动这几行。
1881
+ const before = readStateBytes(dir);
1882
+ // ② 形状非法 → 写入前拒绝(每条都点名「字段路径 + 当前类型」,且 state 字节零改写):
1883
+ // completedChecks 的对象元素(既有踩坑形态)、redEvidence 传字符串(应为对象容器)、
1884
+ // commitHash 传数字(零提交只豁免「字段缺席」,不豁免「类型错误」)、status 非字符串与
1885
+ // 字符串但不在契约既有取值集合(DONE | DONE_WITH_CONCERNS | BLOCKED | NEEDS_CONTEXT)。
1886
+ const malformed = [
1887
+ { payload: '{"status":"DONE","completedChecks":[{"id":"required-skill:subagent-execute.flow-comet-dev"}]}', expect: 'completedChecks[0]: 必须是字符串(当前是 object)' },
1888
+ { payload: '{"status":"DONE","redEvidence":"node --check src/t2.mjs"}', expect: 'redEvidence: 必须是对象(当前是 string)' },
1889
+ { payload: '{"status":"DONE","commitHash":1234567}', expect: 'commitHash: 必须是字符串(当前是 number)' },
1890
+ { payload: '{"status":42}', expect: 'status: 必须是字符串(当前是 number)' },
1891
+ { payload: '{"status":"OK"}', expect: 'status: 不属于允许取值(当前是 OK)' },
1892
+ ];
1893
+ let lastMalformed = null;
1894
+ for (const item of malformed) {
1895
+ const res = runHandoff(['result', 'T02', item.payload], dir);
1896
+ assertExit(res, 1);
1897
+ assertOut(res, item.expect);
1898
+ assertStateBytesUnchanged(dir, before, 'handoff result 形状校验拒绝(' + item.payload + ')');
1899
+ lastMalformed = res;
1900
+ }
1901
+ // 报文还得给「该写成什么」:只有一句「不合法」等于让执行者再猜一次。
1902
+ assertOut(lastMalformed, '"completedChecks":["required-skill:subagent-execute.flow-comet-dev"]');
1903
+ assertOut(lastMalformed, 'DONE_WITH_CONCERNS');
1904
+ assertOut(lastMalformed, '--json-file');
1905
+ // ②b 非对象契约(字符串 / 数组 / null / 数字)在入口即拒——与 record 入口同一判据。形状表只判
1906
+ // 「对象各字段的类型」,载荷不是对象时它按设计返回空表;旧实现在这里放行,于是字符串或数组被
1907
+ // 原样存进 handoffResult,问题延后到出口门禁(那里只会说「缺 greenEvidence」「缺 completedChecks」
1908
+ // ——出错的是 result、报错的却是 exit)。JSON 解析失败且不形似对象字面量的纯文本走同一条拒路:
1909
+ // 旧语义「解析失败则存原始字符串」正是同一形态的延后。判据在任何写盘之前 → 逐条断言报文与字节零改写。
1910
+ const nonObjectContracts = [
1911
+ { payload: '"just a string result"', type: 'string' },
1912
+ { payload: 'just a plain text result', type: 'string' },
1913
+ { payload: '[{"status":"DONE"}]', type: 'array' },
1914
+ { payload: 'null', type: 'null' },
1915
+ { payload: '42', type: 'number' },
1916
+ ];
1917
+ let lastNonObject = null;
1918
+ for (const item of nonObjectContracts) {
1919
+ const res = runHandoff(['result', 'T05', item.payload], dir);
1920
+ assertExit(res, 1);
1921
+ assertOut(res, 'result 契约必须是对象(当前是 ' + item.type + ')');
1922
+ assertStateBytesUnchanged(dir, before, 'handoff result 非对象契约(' + item.payload + ')');
1923
+ lastNonObject = res;
1924
+ }
1925
+ // 非对象的拒绝同样要给「该写成什么」:可照抄的对象形态,以及引号被 shell 吞掉时的旁路
1926
+ assertOut(lastNonObject, '"completedChecks":["required-skill:subagent-execute.flow-comet-dev"]');
1927
+ assertOut(lastNonObject, '--json-file');
1928
+ // ③ 零提交语义保持可用:request 记 noCommit:true → 契约无 commitHash 照常记录(形状校验不误伤)
1929
+ const zeroState = JSON.parse(before);
1930
+ // T04 的请求同样要在场:result 缺 request 现已先于提交子集校验被拦,而本段断言的是
1931
+ // 「合法完整契约 + 提交子集校验」这条既有路径——故其 request 带真实 write_files(非零提交)。
1932
+ zeroState.evidence['subagent-execute'].handoffRequests = {
1933
+ T03: { description: 'zero commit', noCommit: true },
1934
+ T04: { description: 'valid contract', writeFiles: ['src/x.mjs'] },
1935
+ };
1936
+ writeState(dir, zeroState);
1937
+ const zero = runHandoff(['result', 'T03', '{"status":"DONE","completedChecks":["required-skill:subagent-execute.flow-comet-dev"]}'], dir);
1938
+ assertExit(zero, 0);
1939
+ assertOut(zero, 'HANDOFF RESULT: T03');
1940
+ // ④ 合法完整契约照常通过(commitHash 取夹具仓库的真实提交)
1941
+ const headHash = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
1942
+ const good = runHandoff(['result', 'T04', JSON.stringify({
1943
+ status: 'DONE_WITH_CONCERNS',
1944
+ commitHash: headHash,
1945
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
1946
+ redEvidence: { command: 'echo red', output: 'red' },
1947
+ greenEvidence: { command: 'echo green', output: 'green' },
1948
+ })], dir);
1949
+ assertExit(good, 0);
1950
+ assertOut(good, 'HANDOFF RESULT: T04');
1951
+ // ⑤ 委托记账:result 必须有对应的 request(新 change BLOCK / 旧 change WARN)——判定在**任何
1952
+ // 写盘之前**,且先于零提交语义与提交子集校验,两个旁路因此由同一处拦下:
1953
+ // · 零提交形态(契约无 commitHash):无 request 时 isZeroCommit 恒为 false,旧实现静默落库;
1954
+ // · 只提交自身 <task>-SUMMARY.md:无 request 时 writeFiles 允许列表为空,只剩 summaryExact
1955
+ // 一条豁免,旧实现的子集校验因此零越界放行。
1956
+ const ledgerPayload = (taskId, hash) => JSON.stringify({
1957
+ status: 'DONE',
1958
+ taskId,
1959
+ ...(hash ? { commitHash: hash } : {}),
1960
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
1961
+ redEvidence: { command: 'echo red', output: 'red' },
1962
+ greenEvidence: { command: 'echo green', output: 'green' },
1963
+ });
1964
+ // 只含自身 SUMMARY 的提交:旧实现正是靠 summaryExact 豁免放行的那条路径
1965
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T06-SUMMARY.md', '# SUMMARY: T06\n');
1966
+ execFileSync('git', ['add', '.specs/' + CHANGE_ID + '/T06-SUMMARY.md'], { cwd: dir });
1967
+ execFileSync('git', ['-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-q', '-m', 'summary only'], { cwd: dir });
1968
+ const summaryHash = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
1969
+ const ledgerState = JSON.parse(readStateBytes(dir));
1970
+ ledgerState.newChange = true;
1971
+ const ledgerRequests = ledgerState.evidence['subagent-execute'].handoffRequests || {};
1972
+ if (Object.prototype.hasOwnProperty.call(ledgerRequests, 'T06')) {
1973
+ throw new Error('夹具前提不成立:T06 不应已有 request(本段构造的是缺 request 的 result)');
1974
+ }
1975
+ writeState(dir, ledgerState);
1976
+ const ledgerBytes = readStateBytes(dir);
1977
+ const missingRequest = [
1978
+ { label: '零提交形态(契约无 commitHash)', payload: ledgerPayload('T06') },
1979
+ { label: '只提交自身 SUMMARY', payload: ledgerPayload('T06', summaryHash) },
1980
+ ];
1981
+ let missingRequestOutput = '';
1982
+ for (const item of missingRequest) {
1983
+ const res = runHandoff(['result', 'T06', item.payload], dir);
1984
+ assertExit(res, 1);
1985
+ // 报文点名任务 + 恢复段;且拦下它的不是零提交分支、也不是提交子集校验(判据必须靠前)。
1986
+ assertOut(res, 'BLOCKED: 任务 T06 的 result 没有对应的委托 request');
1987
+ assertOut(res, '再重录 result');
1988
+ // 恢复句给的是命令形态:任务号已填、脚本路径由 scriptCommand 装配;占位符 <description> 不得
1989
+ // 出现在命令里(bash 下 `<` 是输入重定向——占位符让「照抄」变成一条必然失败的命令行)。
1990
+ assertOut(res, ' request T06');
1991
+ assertNotOut(res, '<description>');
1992
+ assertNotOut(res, 'HANDOFF RESULT');
1993
+ assertNotOut(res, 'HANDOFF 零提交');
1994
+ assertNotOut(res, '提交文件超出 writeFiles 范围');
1995
+ assertStateBytesUnchanged(dir, ledgerBytes, '缺 request 的 result 被拦(' + item.label + ')');
1996
+ missingRequestOutput = res.output;
1997
+ }
1998
+ const missingRequestStart = missingRequestOutput.lastIndexOf('恢复:');
1999
+ const missingRequestRecovery = missingRequestStart < 0 ? '' : missingRequestOutput.slice(missingRequestStart);
2000
+ const requestRecoveryLine = (missingRequestRecovery.match(/^\s*(node "[^"]+" request T06)$/m) || [])[1];
2001
+ assertTrue(typeof requestRecoveryLine === 'string',
2002
+ '缺 request 的恢复段必须给出可照抄的 request 命令(行首 = node + 引号脚本路径):\n' + missingRequestOutput);
2003
+ assertRecoveryCommandLines(missingRequestRecovery, [requestRecoveryLine], '缺 request 的 result 恢复段');
2004
+ // 旧 change 同样的输入只 WARN(渐进,不阻断既有流程)
2005
+ const legacyLedger = JSON.parse(ledgerBytes);
2006
+ delete legacyLedger.newChange;
2007
+ writeState(dir, legacyLedger);
2008
+ const legacy = runHandoff(['result', 'T06', ledgerPayload('T06', summaryHash)], dir);
2009
+ assertExit(legacy, 0);
2010
+ assertOut(legacy, 'HANDOFF WARN: T06');
2011
+ assertOut(legacy, '没有对应的委托 request');
2012
+ assertOut(legacy, 'HANDOFF RESULT: T06');
2013
+ // 有 request 的 result 照常通过(零提交语义不变:noCommit 请求 + 无 commitHash 契约)
2014
+ const withRequest = JSON.parse(readStateBytes(dir));
2015
+ withRequest.newChange = true;
2016
+ withRequest.evidence['subagent-execute'].handoffRequests = {
2017
+ ...withRequest.evidence['subagent-execute'].handoffRequests,
2018
+ T08: { description: 'delegated', noCommit: true },
2019
+ };
2020
+ writeState(dir, withRequest);
2021
+ const recorded = runHandoff(['result', 'T08', ledgerPayload('T08')], dir);
2022
+ assertExit(recorded, 0);
2023
+ assertOut(recorded, 'HANDOFF RESULT: T08');
2024
+ assertNotOut(recorded, '没有对应的委托 request');
2025
+ // ⑤b 照抄恢复段的那条命令**真执行**:「能解析」不是判据,能跑通并把 request 落到 state 才是。
2026
+ // 随后同一条 result 不再撞「没有对应的委托 request」(这一格判的不是它之后还有多少门)。
2027
+ // T06 按并行任务落夹具:归属门把并行任务判给 subagent-execute(串行任务归属 execute),
2028
+ // 节点与 currentNode 不一致会先被归属门拦下,测不到恢复命令本身。
2029
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
2030
+ + '<task id="T06" parallel="true" status="pending"><action>委托边界</action>'
2031
+ + '<write_files>src/t06.mjs</write_files><verify>node --check src/t06.mjs</verify>'
2032
+ + '<depends_on></depends_on></task>\n');
2033
+ const execState = baseState('subagent-execute');
2034
+ execState.newChange = true;
2035
+ execState.evidence['subagent-execute'] = { summary: 'delegated' };
2036
+ writeState(dir, execState);
2037
+ writeNodeDeclarationMarkers(dir, 'subagent-execute');
2038
+ installSkillTreeCopy(dir, path.join('.claude', 'skills'));
2039
+ assertPrintedCommandTargetsInstalledScript(requestRecoveryLine, dir, 'workflow-handoff.mjs', '缺 request 的恢复命令');
2040
+ const rerunRequest = runPrintedCommand(requestRecoveryLine, dir, {
2041
+ FLOW_COMET_RUN_ROOT: dir,
2042
+ FLOW_COMET_PROTOCOL: '',
2043
+ });
2044
+ assertExit(rerunRequest, 0);
2045
+ assertOut(rerunRequest, 'HANDOFF REQUEST: T06');
2046
+ const afterRequest = JSON.parse(readStateBytes(dir));
2047
+ assertTrue(afterRequest.evidence?.['subagent-execute']?.handoffRequests?.T06 !== undefined,
2048
+ '照抄恢复命令后 handoffRequests 应落下 T06 记录: '
2049
+ + JSON.stringify(afterRequest.evidence?.['subagent-execute']?.handoffRequests));
2050
+ const afterRequestResult = runHandoff(['result', 'T06', ledgerPayload('T06')], dir);
2051
+ assertNotOut(afterRequestResult, '没有对应的委托 request');
2052
+ // ⑥ 越界报文的事实陈述(只补事实、不改判定):request 记的是**发起委托那一刻的写面快照**,
2053
+ // TASK.md 的写面可以被 replan 改写。两者不一致时,越界报文追加一行**可观测事实**(快照 ≠
2054
+ // 当前该任务写面)+ **条件式成因**(若计划经 replan 变更过写面 → 重新 request 后再记
2055
+ // result),并保留「回退越界文件」为首选指引。判据只能证明两侧不一致,不能证明成因——对
2056
+ // 真越界,让人先重跑 request 会把越界文件写进允许列表,所以「记录早于 replan」不得写成断言。
2057
+ // 两者一致(普通真越界)不打印诊断行,判定仍是原来的新 change BLOCK / 旧 change WARN。
2058
+ // 夹具判别力:TASK.md 里 T09 的写面是 replan 后扩过的(含 rogue.js),T10 的写面与 request
2059
+ // 逐字一致;若诊断按「全文第一个写面」而非「该任务的写面」比对,T10 会误报。
2060
+ const repo = (args) => spawnSync('git', ['-c', 'user.email=t@t', '-c', 'user.name=t', ...args], { cwd: dir, encoding: 'utf8' });
2061
+ writeFile(dir, 'allowed.js', 'export const allowed = 1;\n');
2062
+ writeFile(dir, 'rogue.js', 'export const rogue = 1;\n');
2063
+ repo(['add', 'allowed.js', 'rogue.js']);
2064
+ repo(['commit', '-qm', 'replan 之后才进写面']);
2065
+ const replannedHash = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
2066
+ writeFile(dir, 'stray.js', 'export const stray = 1;\n');
2067
+ repo(['add', 'stray.js']);
2068
+ repo(['commit', '-qm', 'stray']);
2069
+ const strayHash = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
2070
+ const taskWithWriteFiles = (id, files) => '<task id="' + id + '" status="pending"><action>写面边界</action>'
2071
+ + '<write_files>\n' + files.join('\n') + '\n</write_files>'
2072
+ + '<verify>node --check allowed.js</verify></task>\n';
2073
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
2074
+ + taskWithWriteFiles('T09', ['allowed.js', 'rogue.js'])
2075
+ + taskWithWriteFiles('T10', ['allowed.js']));
2076
+ const replanState = baseState('subagent-execute');
2077
+ replanState.newChange = true;
2078
+ replanState.evidence['subagent-execute'] = {
2079
+ handoffRequests: {
2080
+ T09: { description: 'replan 扩写面前的快照', writeFiles: ['allowed.js'] },
2081
+ T10: { description: '写面未变更', writeFiles: ['allowed.js'] },
2082
+ },
2083
+ handoffResult: {},
2084
+ };
2085
+ writeState(dir, replanState);
2086
+ const boundaryPayload = (id, hash) => JSON.stringify({
2087
+ status: 'DONE',
2088
+ taskId: id,
2089
+ commitHash: hash,
2090
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
2091
+ redEvidence: { command: 'node --check allowed.js', output: 'no output(RED 锚点)' },
2092
+ greenEvidence: { command: 'node --check allowed.js', output: 'ok' },
2093
+ });
2094
+ const staleSnapshotFact = '诊断: 该任务的委托快照与当前 TASK.md 该任务的写面不一致';
2095
+ const staleSnapshotCause = '成因未判定;若计划经 replan 变更过写面,出路是重新发起委托(命令如下)后再记录 result';
2096
+ // ① 旧快照(request 只允许 allowed.js,TASK.md 已扩到 rogue.js)→ 仍 BLOCK,且要点明可观测事实
2097
+ const staleSnapshot = runHandoff(['result', 'T09', boundaryPayload('T09', replannedHash)], dir);
2098
+ assertExit(staleSnapshot, 1);
2099
+ assertOut(staleSnapshot, 'BLOCKED: 提交文件超出 writeFiles 范围: rogue.js');
2100
+ assertOut(staleSnapshot, staleSnapshotFact);
2101
+ // 成因是条件式而非断言:「若计划经 replan 变更过写面」才是成因,且再给一条无 replan 时的出路
2102
+ assertOut(staleSnapshot, staleSnapshotCause);
2103
+ assertOut(staleSnapshot, '若无 replan,越界文件仍不在该任务写面内');
2104
+ // 出路是**可照抄的命令**(不是脚本名):任务号已填、行首即命令——说明行与命令行分开。
2105
+ const staleRecoveryLine = (staleSnapshot.output.match(/^\s*(node "[^"]+" request T09)$/m) || [])[1];
2106
+ assertTrue(typeof staleRecoveryLine === 'string',
2107
+ '越界诊断给出的「重新发起委托」不是可照抄命令:\n' + staleSnapshot.output);
2108
+ // 首选指引仍是「回退越界文件」(恢复行在前,诊断行只在其后补事实)
2109
+ assertOut(staleSnapshot, '恢复: 回退越界文件或扩展 write_files');
2110
+ assertOut(staleSnapshot, '按上面的「回退越界文件」处理');
2111
+ // 反向构造:把可能写成事实的旧措辞不得回归(判据只能证明不一致,证明不了「记录早于 replan」)
2112
+ assertNotOut(staleSnapshot, '早于最近一次 replan');
2113
+ // ② 写面一致的真越界 → 仍是原报文,不得混入事实陈述(否则该行不再有判别力)
2114
+ const genuineOverrun = runHandoff(['result', 'T10', boundaryPayload('T10', strayHash)], dir);
2115
+ assertExit(genuineOverrun, 1);
2116
+ assertOut(genuineOverrun, 'BLOCKED: 提交文件超出 writeFiles 范围: stray.js');
2117
+ assertOut(genuineOverrun, '恢复: 回退越界文件或扩展 write_files');
2118
+ assertNotOut(genuineOverrun, staleSnapshotFact);
2119
+ // ③ 判定语义不变:同一份旧快照在旧 change 上只 WARN(诊断行随报文出现,结果照常落库)
2120
+ const legacySnapshot = JSON.parse(readStateBytes(dir));
2121
+ delete legacySnapshot.newChange;
2122
+ writeState(dir, legacySnapshot);
2123
+ const legacyWarn = runHandoff(['result', 'T09', boundaryPayload('T09', replannedHash)], dir);
2124
+ assertExit(legacyWarn, 0);
2125
+ assertOut(legacyWarn, 'HANDOFF WARN: 提交文件超出 writeFiles 范围: rogue.js');
2126
+ assertOut(legacyWarn, staleSnapshotCause);
2127
+ assertOut(legacyWarn, 'HANDOFF RESULT: T09');
934
2128
  },
935
2129
  },
936
2130