flow-comet 1.6.2 → 1.6.4

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 (107) hide show
  1. package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
  2. package/.flow-comet/skills/flow-comet/SKILL.md +64 -46
  3. package/.flow-comet/skills/flow-comet/reference/KNOWN-ISSUES-template.md +1 -1
  4. package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +32 -0
  5. package/.flow-comet/skills/flow-comet/reference/dirty-worktree.md +1 -1
  6. package/.flow-comet/skills/flow-comet/{GUIDANCE.md → reference/entry-detail.md} +18 -28
  7. package/.flow-comet/skills/flow-comet/reference/fix-loop.md +57 -0
  8. package/.flow-comet/skills/flow-comet/reference/platform-facts.md +58 -0
  9. package/.flow-comet/skills/flow-comet/reference/replan.md +23 -0
  10. package/.flow-comet/skills/flow-comet/scripts/comet-check.mjs +5 -4
  11. package/.flow-comet/skills/flow-comet/scripts/comet-hook-guard.mjs +266 -25
  12. package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +2 -2
  13. package/.flow-comet/skills/flow-comet/scripts/evolve.mjs +6 -6
  14. package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +67 -16325
  15. package/.flow-comet/skills/flow-comet/scripts/health.mjs +1 -1
  16. package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +1030 -0
  17. package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +830 -0
  18. package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +781 -0
  19. package/.flow-comet/skills/flow-comet/scripts/items/d.mjs +99 -0
  20. package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +185 -0
  21. package/.flow-comet/skills/flow-comet/scripts/items/f.mjs +90 -0
  22. package/.flow-comet/skills/flow-comet/scripts/items/g.mjs +59 -0
  23. package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +815 -0
  24. package/.flow-comet/skills/flow-comet/scripts/items/i.mjs +77 -0
  25. package/.flow-comet/skills/flow-comet/scripts/items/j.mjs +75 -0
  26. package/.flow-comet/skills/flow-comet/scripts/items/k.mjs +1427 -0
  27. package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +275 -0
  28. package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +614 -0
  29. package/.flow-comet/skills/flow-comet/scripts/lib/count-derivation.mjs +97 -0
  30. package/.flow-comet/skills/flow-comet/scripts/lib/fix-loop-node.mjs +196 -0
  31. package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +553 -0
  32. package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +837 -0
  33. package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +404 -0
  34. package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +404 -0
  35. package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +302 -0
  36. package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +133 -0
  37. package/.flow-comet/skills/flow-comet/scripts/lib/reentry-node.mjs +237 -0
  38. package/.flow-comet/skills/flow-comet/scripts/lib/replan-node.mjs +209 -0
  39. package/.flow-comet/skills/flow-comet/scripts/lib/state-branch.mjs +49 -0
  40. package/.flow-comet/skills/flow-comet/scripts/lib/state-bridgecheck.mjs +201 -0
  41. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +141 -0
  42. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +700 -0
  43. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +578 -0
  44. package/.flow-comet/skills/flow-comet/scripts/lib/state-determine.mjs +52 -0
  45. package/.flow-comet/skills/flow-comet/scripts/lib/state-evolve-hint.mjs +55 -0
  46. package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +106 -0
  47. package/.flow-comet/skills/flow-comet/scripts/lib/state-intelscan.mjs +58 -0
  48. package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +147 -0
  49. package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +189 -0
  50. package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +1441 -0
  51. package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +471 -0
  52. package/.flow-comet/skills/flow-comet/scripts/lib/test-assertions.mjs +509 -0
  53. package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +1228 -0
  54. package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +237 -0
  55. package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +2484 -0
  56. package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +2 -2
  57. package/.flow-comet/skills/flow-comet/scripts/route-node.mjs +73 -1077
  58. package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +966 -0
  59. package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1233 -0
  60. package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1382 -0
  61. package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +483 -0
  62. package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +1388 -0
  63. package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +1466 -0
  64. package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +1364 -0
  65. package/.flow-comet/skills/flow-comet/scripts/scenarios/h.mjs +1287 -0
  66. package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +1436 -0
  67. package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +1384 -0
  68. package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +1338 -0
  69. package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +1484 -0
  70. package/.flow-comet/skills/flow-comet/scripts/scenarios/m.mjs +971 -0
  71. package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +14 -1
  72. package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +58 -6692
  73. package/.flow-comet/skills/flow-comet/scripts/time-utils.mjs +4 -4
  74. package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +151 -2428
  75. package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +116 -9
  76. package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +29 -2086
  77. package/.flow-comet/skills/flow-comet-archive/SKILL.md +10 -19
  78. package/.flow-comet/skills/flow-comet-change/SKILL.md +2 -3
  79. package/.flow-comet/skills/flow-comet-compose/SKILL.md +1 -1
  80. package/.flow-comet/skills/flow-comet-design/SKILL.md +6 -6
  81. package/.flow-comet/skills/flow-comet-execute/SKILL.md +58 -16
  82. package/.flow-comet/skills/flow-comet-integration/SKILL.md +8 -5
  83. package/.flow-comet/skills/flow-comet-open/SKILL.md +5 -1
  84. package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +1 -1
  85. package/.flow-comet/skills/flow-comet-plan/SKILL.md +8 -8
  86. package/.flow-comet/skills/flow-comet-review/SKILL.md +9 -12
  87. package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +59 -16
  88. package/.flow-comet/skills/flow-comet-task/SKILL.md +3 -2
  89. package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +3 -3
  90. package/.flow-comet/skills/flow-comet-verify/SKILL.md +8 -17
  91. package/README.md +53 -70
  92. package/package.json +3 -2
  93. package/scripts/dsh-bridge.mjs +59 -26
  94. package/scripts/lib/installer-cleanup.mjs +152 -0
  95. package/scripts/lib/installer-flowkit.mjs +119 -0
  96. package/scripts/lib/installer-hooks.mjs +363 -0
  97. package/scripts/lib/installer-loader.mjs +220 -0
  98. package/scripts/lib/installer-migrate.mjs +236 -0
  99. package/scripts/lib/installer-platforms.mjs +314 -0
  100. package/scripts/prepare-env.mjs +36 -1164
  101. package/.flow-comet/skills/flow-comet/reference/TEST-MATRIX.md +0 -116
  102. package/.flow-comet/skills/flow-comet/reference/composition-report.md +0 -65
  103. package/.flow-comet/skills/flow-comet/reference/dsh-platform.md +0 -184
  104. package/.flow-comet/skills/flow-comet/reference/resolved-skills.json +0 -661
  105. package/.flow-comet/skills/flow-comet/reference/skill-review.md +0 -13
  106. package/.flow-comet/skills/flow-comet/reference/subagents/script-author.md +0 -7
  107. package/.flow-comet/skills/flow-comet/reference/worktree-notes.md +0 -70
@@ -0,0 +1,1364 @@
1
+ // 场景组 g — 安装器新链路 · 写写重叠 · 漂移容忍 · directOverride 授权约束
2
+ // 元素形态:`{ name, run }`;计数由 `lib/count-derivation.mjs` 从本目录聚合,不手抄数字。
3
+ // 组界按场景名前缀与文件内既有分段划,与入口 `SCENARIOS` 的拼接顺序一致。
4
+
5
+ import fs from 'fs';
6
+ import path from 'path';
7
+ import { execFileSync, spawnSync } from 'child_process';
8
+ import { createHash } from 'crypto';
9
+ import { pathToFileURL } from 'url';
10
+ import {
11
+ assertExit,
12
+ assertNotOut,
13
+ assertOut,
14
+ baseState,
15
+ copyTreePortable,
16
+ runGuard,
17
+ runHook,
18
+ writeFile,
19
+ writeState,
20
+ } from '../lib/test-helpers.mjs';
21
+ import {
22
+ CHANGE_ID,
23
+ PREPARE_ENV,
24
+ REPO_ROOT,
25
+ SCRIPTS_DIR,
26
+ bridgeStampSyncProblems,
27
+ bridgeStampSyncSubAnchorCases,
28
+ fixtureBridgeBaseVersion,
29
+ fixtureIsBridgeDevVersion,
30
+ handoffFor,
31
+ runBridgeCheck,
32
+ runPlanExit,
33
+ runPrepareEnv,
34
+ strictSummary,
35
+ summaryContent,
36
+ writeBridgeFixture,
37
+ writeIntakeArtifacts,
38
+ } from '../lib/test-fixtures.mjs';
39
+ import {
40
+ assertInstalledCopyBridgeVersionCase,
41
+ bridgeCopyVersionSubAnchorCases,
42
+ runGuardWithProtocol,
43
+ runStateWithProtocol,
44
+ } from '../lib/test-assertions.mjs';
45
+ import {
46
+ globEquivalenceProblems,
47
+ } from '../lib/text-anchor-checks.mjs';
48
+
49
+ export const ENTRIES = [
50
+
51
+ // ---------- 场景(installer 新链路——flow-kit 获取五态 / bridge-check 六态 / 他方保持 / 强制回退) ----------
52
+
53
+ // 185: flow-kit 新装——目标缺失 → clone + detached checkout 到锁定 commit。
54
+ // 克隆源:仓库内 vendored 上游副本在场时经 git 标准 insteadOf 机制本地克隆(HEAD 即锁定点,
55
+ // 离线可复现);副本缺席(如 CI 全新检出)时真实 clone 上游——与 CI installer 链路同前提。
56
+ {
57
+ name: '185 flow-kit 新装:clone 后 detached checkout 锁定点',
58
+ run: (dir) => {
59
+ if (!fs.existsSync(PREPARE_ENV)) return;
60
+ const proj = path.join(dir, 'proj');
61
+ fs.mkdirSync(proj, { recursive: true });
62
+ const localUpstream = path.join(REPO_ROOT, 'flow-kit');
63
+ const env = {};
64
+ if (fs.existsSync(path.join(localUpstream, '.git'))) {
65
+ env.GIT_CONFIG_COUNT = '1';
66
+ env.GIT_CONFIG_KEY_0 = 'url.' + localUpstream.replace(/\\/g, '/') + '.insteadOf';
67
+ env.GIT_CONFIG_VALUE_0 = 'https://github.com/rihebty/flow-kit.git';
68
+ }
69
+ const res = runPrepareEnv(['--target', proj, '--platform', 'dsh'], dir, { DSH_HOME: path.join(dir, 'dshhome'), ...env });
70
+ assertExit(res, 0);
71
+ assertOut(res, '[flow-comet] 已获取 flow-kit(锁定 9b5dda7)');
72
+ const fk = path.join(proj, 'flow-kit');
73
+ const head = execFileSync('git', ['-C', fk, 'rev-parse', 'HEAD'], { encoding: 'utf8', timeout: 60000 }).trim();
74
+ if (head !== '9b5dda7206ae841230f118348d660ad8d0ae2830') throw new Error('flow-kit HEAD 非锁定点: ' + head);
75
+ let symref = '';
76
+ try {
77
+ symref = execFileSync('git', ['-C', fk, 'symbolic-ref', '-q', 'HEAD'], { encoding: 'utf8', timeout: 60000 }).trim();
78
+ } catch { /* detached 状态:symbolic-ref 非零,保持空 */ }
79
+ if (symref !== '') throw new Error('flow-kit HEAD 未处于 detached: ' + symref);
80
+ },
81
+ },
82
+
83
+ // 186: flow-kit 已存在且 origin 匹配上游 → 只读报告 HEAD 与锁定点差异影响,绝不改动。
84
+ // 夹具 = 本地真实 git 仓库 + origin 指向真实上游 URL(归属判定走本地 config,零网络),
85
+ // HEAD 落在非锁定点提交上 → 断言差异影响输出且安装器不改动用户克隆(非破坏语义)。
86
+ {
87
+ name: '186 flow-kit 已存在:只读报告差异且不动用户克隆',
88
+ run: (dir) => {
89
+ if (!fs.existsSync(PREPARE_ENV)) return;
90
+ const proj = path.join(dir, 'proj');
91
+ fs.mkdirSync(proj, { recursive: true });
92
+ const fk = path.join(proj, 'flow-kit');
93
+ fs.mkdirSync(fk, { recursive: true });
94
+ execFileSync('git', ['-C', fk, 'init', '-q'], { encoding: 'utf8', timeout: 60000 });
95
+ fs.writeFileSync(path.join(fk, 'fixture.txt'), 'mine\n', 'utf8');
96
+ execFileSync('git', ['-C', fk, 'add', 'fixture.txt'], { encoding: 'utf8', timeout: 60000 });
97
+ execFileSync('git', ['-C', fk, '-c', 'user.name=fixture', '-c', 'user.email=fixture@example.com', 'commit', '-q', '-m', 'fixture'], { encoding: 'utf8', timeout: 60000 });
98
+ execFileSync('git', ['-C', fk, 'remote', 'add', 'origin', 'https://github.com/rihebty/flow-kit.git'], { encoding: 'utf8', timeout: 60000 });
99
+ const headBefore = execFileSync('git', ['-C', fk, 'rev-parse', 'HEAD'], { encoding: 'utf8', timeout: 60000 }).trim();
100
+ const res = runPrepareEnv(['--target', proj, '--platform', 'dsh'], dir, { DSH_HOME: path.join(dir, 'dshhome') });
101
+ assertExit(res, 0);
102
+ assertOut(res, '已有 flow-kit(HEAD=' + headBefore.slice(0, 7) + ',推荐锁定点=9b5dda7)');
103
+ assertOut(res, '差异影响');
104
+ const headAfter = execFileSync('git', ['-C', fk, 'rev-parse', 'HEAD'], { encoding: 'utf8', timeout: 60000 }).trim();
105
+ if (headAfter !== headBefore) throw new Error('安装器改动了用户克隆 HEAD: ' + headAfter);
106
+ if (!fs.existsSync(path.join(fk, 'fixture.txt'))) throw new Error('安装器删除了用户文件');
107
+ },
108
+ },
109
+
110
+ // 187: flow-kit 同名非上游目录 → 跳过 + 手动指引,绝不改动、绝不注入 .git(归属判定读本地
111
+ // config 零网络;无 .git → 保守落入非上游分支)。
112
+ {
113
+ name: '187 flow-kit 同名非上游目录:跳过并指引且不触碰用户目录',
114
+ run: (dir) => {
115
+ if (!fs.existsSync(PREPARE_ENV)) return;
116
+ const proj = path.join(dir, 'proj');
117
+ fs.mkdirSync(proj, { recursive: true });
118
+ const fk = path.join(proj, 'flow-kit');
119
+ fs.mkdirSync(fk, { recursive: true });
120
+ fs.writeFileSync(path.join(fk, 'user-asset.txt'), 'do not touch\n', 'utf8');
121
+ const res = runPrepareEnv(['--target', proj, '--platform', 'dsh'], dir, { DSH_HOME: path.join(dir, 'dshhome') });
122
+ assertExit(res, 0);
123
+ assertOut(res, '目录存在但非上游克隆,已跳过');
124
+ assertOut(res, '手动获取指引');
125
+ assertOut(res, 'git clone https://github.com/rihebty/flow-kit.git');
126
+ if (fs.readFileSync(path.join(fk, 'user-asset.txt'), 'utf8') !== 'do not touch\n') throw new Error('用户资产被改动');
127
+ if (fs.existsSync(path.join(fk, '.git'))) throw new Error('安装器向用户目录注入了 .git');
128
+ },
129
+ },
130
+
131
+ // 188: flow-kit clone/checkout 失败(git 官方配置注入机制让 clone 走不可达代理)→
132
+ // WARN + 手动指引,不抛错不阻断,其余安装职责照常、exit 0(网络失败兜底)。
133
+ {
134
+ name: '188 flow-kit 网络失败:WARN 继续且其余安装职责照常 exit 0',
135
+ run: (dir) => {
136
+ if (!fs.existsSync(PREPARE_ENV)) return;
137
+ const proj = path.join(dir, 'proj');
138
+ fs.mkdirSync(proj, { recursive: true });
139
+ const res = runPrepareEnv(['--target', proj, '--platform', 'dsh'], dir, {
140
+ DSH_HOME: path.join(dir, 'dshhome'),
141
+ GIT_CONFIG_COUNT: '1',
142
+ GIT_CONFIG_KEY_0: 'http.proxy',
143
+ GIT_CONFIG_VALUE_0: 'http://127.0.0.1:9',
144
+ });
145
+ assertExit(res, 0);
146
+ assertOut(res, '[flow-comet] 警告: flow-kit 自动获取失败');
147
+ assertOut(res, '手动获取指引');
148
+ assertOut(res, '已准备环境');
149
+ if (!fs.existsSync(path.join(proj, '.dsh', 'skills', 'flow-comet', 'SKILL.md'))) throw new Error('安装器其余职责未继续');
150
+ if (fs.existsSync(path.join(proj, 'flow-kit'))) throw new Error('失败后不应残留半成品 flow-kit 目录');
151
+ },
152
+ },
153
+
154
+ // 189: --purge --yes 后 flow-kit 原样存在(清理域语义:purge 清单永不包含 flow-kit—
155
+ // 删除清单段逐字断言无 flow-kit 字样,目录与内容保持)。
156
+ {
157
+ name: '189 flow-kit 不属清理域:purge 后原样存在且删除清单无 flow-kit',
158
+ run: (dir) => {
159
+ if (!fs.existsSync(PREPARE_ENV)) return;
160
+ const proj = path.join(dir, 'proj');
161
+ fs.mkdirSync(proj, { recursive: true });
162
+ const fk = path.join(proj, 'flow-kit');
163
+ fs.mkdirSync(fk, { recursive: true });
164
+ fs.writeFileSync(path.join(fk, 'sentinel.txt'), 'keep me\n', 'utf8');
165
+ const res = runPrepareEnv(['--target', proj, '--platform', 'dsh', '--purge', '--yes'], dir, { DSH_HOME: path.join(dir, 'dshhome') });
166
+ assertExit(res, 0);
167
+ assertOut(res, '警告: --purge 将删除');
168
+ const segStart = res.output.indexOf('警告: --purge 将删除');
169
+ const segEnd = res.output.indexOf('已删除,开始重新生成。');
170
+ if (segStart < 0 || segEnd < 0 || segEnd < segStart) throw new Error('purge 删除清单段未找到');
171
+ const purgeList = res.output.slice(segStart, segEnd);
172
+ if (purgeList.includes('flow-kit')) throw new Error('purge 删除清单包含 flow-kit: ' + purgeList);
173
+ if (!fs.existsSync(path.join(fk, 'sentinel.txt'))) throw new Error('purge 后 flow-kit 目录丢失');
174
+ if (fs.readFileSync(path.join(fk, 'sentinel.txt'), 'utf8') !== 'keep me\n') throw new Error('purge 后 flow-kit 内容被改动');
175
+ if (!fs.existsSync(path.join(proj, '.dsh', 'skills', 'flow-comet', 'SKILL.md'))) throw new Error('purge 重建未完成');
176
+ },
177
+ },
178
+
179
+ // 190: bridge-check 健康——全检查通过 exit 0。夹具按安装器实际写入形态构造
180
+ // (insert 条目 + file:// 引用 + BRIDGE_VERSION 戳 = 权威源 INSTALLED_VERSION 同值)。
181
+ {
182
+ name: '190 bridge-check 健康:全检查通过 exit 0',
183
+ run: (dir) => {
184
+ const { dshHome } = writeBridgeFixture(dir);
185
+ const res = runBridgeCheck(dir, dshHome);
186
+ assertExit(res, 0);
187
+ assertOut(res, '[OK] loader 文件存在');
188
+ assertOut(res, '[OK] cordis.patch.yml 托管块');
189
+ assertOut(res, '[OK] 块内 file:// 目标可达');
190
+ assertOut(res, '[OK] 重复注册检查');
191
+ assertOut(res, '[OK] 版本一致性');
192
+ assertOut(res, 'bridge-check: 健康(全部检查通过)——exit 0');
193
+ },
194
+ },
195
+
196
+ // 191: bridge-check 文件缺失——loader 缺失时存在性检查与 file:// 目标可达性双 FAIL exit 1。
197
+ {
198
+ name: '191 bridge-check 文件缺失:loader 与 file:// 目标双 FAIL exit 1',
199
+ run: (dir) => {
200
+ const { dshHome } = writeBridgeFixture(dir, { skipLoader: true });
201
+ const res = runBridgeCheck(dir, dshHome);
202
+ assertExit(res, 1);
203
+ assertOut(res, '[FAIL] loader 文件缺失');
204
+ assertOut(res, '[FAIL] 托管块指向的 loader 文件缺失');
205
+ assertOut(res, 'bridge-check: 失配 2 项——exit 1');
206
+ },
207
+ },
208
+
209
+ // 192: bridge-check 未挂载——loader 存在但托管块缺失 FAIL exit 1(不会监听任何项目)。
210
+ {
211
+ name: '192 bridge-check 未挂载:托管块缺失 FAIL exit 1',
212
+ run: (dir) => {
213
+ const { dshHome } = writeBridgeFixture(dir, {
214
+ patchContent: "- id: other-plugin\n name: 'file:///C:/plugins/other-plugin.mjs'\n",
215
+ });
216
+ const res = runBridgeCheck(dir, dshHome);
217
+ assertExit(res, 1);
218
+ assertOut(res, '[FAIL] 未挂载');
219
+ assertOut(res, 'bridge-check: 失配 1 项——exit 1');
220
+ },
221
+ },
222
+
223
+ // 193: bridge-check 版本比较语义——dev 态后缀归一后按基础版本比较。子锚:
224
+ // ① 载体原始戳(权威源=发布标记 / 安装副本=dev 戳)vs 不可识别戳 → 原始戳配对 +
225
+ // 归一基础版本双打印,FAIL exit 1(保留 raw-stamp pairing);
226
+ // ② release 态严格相等(两原始值逐字相同)→ 既有 `==` 报告健康 exit 0(release 语义不变);
227
+ // ③ dev 态安装副本形态(INSTALLED_VERSION=<发布>-<N>-g<hash>)vs 同基础 loader → 归一后健康 exit 0;
228
+ // ④ 两侧均带 dev 后缀且基础版本一致 → 归一后健康 exit 0;
229
+ // ⑤ 基础版本不同(两侧均可带 dev 后缀)→ 归一后仍 FAIL exit 1(双值双打印);
230
+ // ⑥ 语义化预发布标识(-rc.N)不属 dev 态后缀、不得剥离 → 仍 FAIL exit 1;
231
+ // ⑦ release 对 release 失配 → 归一不误判健康,仍 FAIL exit 1。
232
+ // 期望值从载体自身 INSTALLED_VERSION 归一出的基础版本派生——权威源(发布标记)与安装副本
233
+ // (git describe dev 戳)两载体形态均可移植;不得再以原始戳冒充归一后的期望值。
234
+ {
235
+ name: '193 bridge-check 版本比较:dev 态同基础健康 / 基础失配与预发布仍 FAIL exit 1',
236
+ run: (dir) => {
237
+ // ⑧ 便携复制锚:源路径含非 ASCII 字符时仍能完整复制技能树——旧实现用 fs.cpSync,在 Windows 上
238
+ // 会让进程静默崩溃(中文路径项目内本套件曾中断于本场景)。比对用「相对路径 + 条目类型 +
239
+ // 内容哈希(文件)/ 链接目标(符号链接)」全量清单:只比条目数会放过「少一个、多一个改名」
240
+ // 这类等数错误,也无法发现内容被改写。
241
+ {
242
+ const cjkSource = path.join(dir, '源-中文-技能树');
243
+ const cjkTarget = path.join(dir, '复制-目标');
244
+ copyTreePortable(path.join(SCRIPTS_DIR, '..'), cjkSource);
245
+ copyTreePortable(cjkSource, cjkTarget);
246
+ const listTree = (root, base = '', out = []) => {
247
+ for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
248
+ const rel = base ? base + '/' + entry.name : entry.name;
249
+ const full = path.join(root, entry.name);
250
+ if (entry.isDirectory()) listTree(full, rel, out);
251
+ else if (entry.isSymbolicLink()) out.push('link ' + rel + ' -> ' + fs.readlinkSync(full));
252
+ else out.push('file ' + rel + ' ' + createHash('sha256').update(fs.readFileSync(full)).digest('hex'));
253
+ }
254
+ return out.sort();
255
+ };
256
+ const expected = listTree(path.join(SCRIPTS_DIR, '..'));
257
+ const actual = listTree(cjkTarget);
258
+ if (expected.length !== actual.length) {
259
+ throw new Error('非 ASCII 源路径的递归复制条目数不一致:期望 ' + expected.length + ',实际 ' + actual.length);
260
+ }
261
+ for (let i = 0; i < expected.length; i += 1) {
262
+ if (expected[i] !== actual[i]) {
263
+ throw new Error('非 ASCII 源路径的递归复制内容不一致(第 ' + (i + 1) + ' 项):期望 ' + expected[i] + ',实际 ' + actual[i]);
264
+ }
265
+ }
266
+ }
267
+ // ⑨ 便携复制的**使用面**锚:会复制目录的模块必须走同一个便携实现。⑧ 只证明工具本身可用,
268
+ // 锚不住「谁在用它」——system-fixtures 与 items/k 曾直接用 fs.cpSync,中文路径检出里整套
269
+ // 会静默中断(无失败报告、无总结行,最容易被误读成通过)。
270
+ //
271
+ // 判据形状(两轮外部审查共指出四条逃逸/误报路径,均已按下述规则收口):
272
+ // · **全树扫描**:不再有文件清单——写死清单会漏掉新增的复制模块。
273
+ // · **只在代码行上匹配**(跳过注释行):注释里写个调用样子不该把套件判红(本锚第一版就
274
+ // 因此把自己判成违规——注释里写了带括号的调用形态字面量)。
275
+ // · **要求调用形态**:点号访问、方括号访问、裸标识符调用三种写法都要带左括号才算;
276
+ // 光是一个引号里的属性读不算(否则字符串与说明文字会误报)。
277
+ // · **补「导入绑定」这一路**:解构导入(`import { … } from 'fs'`)含 `as` 别名先在导入处
278
+ // 拦下——裸标识符调用的唯一来路就是它,拦住导入即等于拦住别名写法。导入规则同样只看
279
+ // 代码行:本注释第一版把导入写法当例子写在注释里,锚又把自己判成了违规。
280
+ //
281
+ // **判据的诚实边界**:动态拼名(`fs['cp' + 'Sync']`)不在覆盖内——那是刻意规避,名称型回归
282
+ // 守卫不承担这个职责(要覆盖它得引入解析器,而全仓只允许一个第三方依赖)。其它复制通道
283
+ // (`fs.cp` 等)同理:**先补 Windows + 非 ASCII 源路径的实测**,再决定是否纳入本判据——
284
+ // 不要把「没测过」当成「没问题」,也不要在没有实测的情况下扩大模式。
285
+ {
286
+ const cpName = 'cp' + 'Sync';
287
+ const isCommentLine = (line) => /^\s*(\/\/|\/\*|\*)/.test(line);
288
+ const codeOnly = (text) => text.split(/\r?\n/).filter((l) => !isCommentLine(l)).join('\n');
289
+ const cpCalls = new RegExp(
290
+ '\\.' + cpName + '\\s*\\('
291
+ + '|\\[\\s*[\'"]' + cpName + '[\'"]\\s*\\]\\s*\\('
292
+ + '|(?:^|[^\\w.$])' + cpName + '\\s*\\(',
293
+ );
294
+ const cpImport = new RegExp('\\b' + cpName + '\\b[^;]*from\\s*[\'"]');
295
+ const offenders = [];
296
+ const walkScripts = (root) => {
297
+ for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
298
+ const full = path.join(root, entry.name);
299
+ if (entry.isDirectory()) walkScripts(full);
300
+ else if (entry.name.endsWith('.mjs')) {
301
+ const text = fs.readFileSync(full, 'utf8');
302
+ const code = codeOnly(text);
303
+ if (cpCalls.test(code) || cpImport.test(code)) offenders.push(full);
304
+ }
305
+ }
306
+ };
307
+ walkScripts(SCRIPTS_DIR);
308
+ if (offenders.length) {
309
+ throw new Error('仍在直接使用 cpSync 复制目录(中文路径检出会静默崩溃,请走 copyTreePortable):'
310
+ + offenders.map((f) => path.relative(SCRIPTS_DIR, f).replace(/\\/g, '/')).join(', '));
311
+ }
312
+ const defs = [];
313
+ // 针同样拼接:本断言自身就在这个文件里,整字面量会自指命中(实测踩到过一次)。
314
+ const defNeedle = 'export function copy' + 'TreePortable';
315
+ const walkDefs = (root) => {
316
+ for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
317
+ const full = path.join(root, entry.name);
318
+ if (entry.isDirectory()) walkDefs(full);
319
+ else if (entry.name.endsWith('.mjs') && fs.readFileSync(full, 'utf8').includes(defNeedle)) defs.push(full);
320
+ }
321
+ };
322
+ walkDefs(SCRIPTS_DIR);
323
+ if (defs.length !== 1 || path.basename(defs[0]) !== 'test-helpers.mjs') {
324
+ throw new Error('copyTreePortable 的定义必须是唯一且落在 test-helpers.mjs,实际:'
325
+ + (defs.map((f) => path.basename(f)).join(', ') || '零处'));
326
+ }
327
+ }
328
+ const { dshHome, installedVersion } = writeBridgeFixture(dir, { loaderStamp: '9.9.9-fixture-skew' });
329
+ const baseVersion = fixtureBridgeBaseVersion(installedVersion);
330
+ const skew = runBridgeCheck(dir, dshHome);
331
+ assertExit(skew, 1);
332
+ assertOut(skew, '[FAIL] 版本偏斜: loader BRIDGE_VERSION=9.9.9-fixture-skew != 项目 INSTALLED_VERSION=' + installedVersion + '(归一基础版本: loader=9.9.9-fixture-skew / installed=' + baseVersion + ')——两值如上');
333
+ assertOut(skew, 'bridge-check: 失配 1 项——exit 1');
334
+
335
+ // ②~⑦ 安装副本子锚表:执行器逐个跑真实 CLI;期望值均由 baseVersion / devVersion 派生。
336
+ const devVersion = fixtureIsBridgeDevVersion(installedVersion)
337
+ ? installedVersion
338
+ : baseVersion + '-11-g93d96c0';
339
+ for (const subAnchor of bridgeCopyVersionSubAnchorCases(baseVersion, devVersion)) {
340
+ assertInstalledCopyBridgeVersionCase(dir, subAnchor);
341
+ }
342
+ },
343
+ },
344
+
345
+ // 194: bridge-check 重复注册——托管块之外另有同 id 注册行 FAIL exit 1(块内安装器固有
346
+ // 条目不计)。outsideBlock 追加在块后——块外扫描精确捕获。
347
+ {
348
+ name: '194 bridge-check 重复注册:托管块外同 id 注册行 FAIL exit 1',
349
+ run: (dir) => {
350
+ const { dshHome } = writeBridgeFixture(dir, {
351
+ outsideBlock: "\n- id: dsh-flow-comet-bridge\n name: 'file:///C:/plugins/dup.mjs'\n",
352
+ });
353
+ const res = runBridgeCheck(dir, dshHome);
354
+ assertExit(res, 1);
355
+ assertOut(res, '[FAIL] 重复注册: cordis.patch.yml 托管块外另有 1 处同 id 注册行');
356
+ assertOut(res, 'bridge-check: 失配 1 项——exit 1');
357
+ },
358
+ },
359
+
360
+ // 195: bridge-check 不适用——项目根无 .dsh/skills/flow-comet → 不适用 exit 0(AC-11)。
361
+ {
362
+ name: '195 bridge-check 不适用:非 dsh 项目 exit 0',
363
+ run: (dir) => {
364
+ const res = runBridgeCheck(dir, path.join(dir, 'dshhome'));
365
+ assertExit(res, 0);
366
+ assertOut(res, '[NA] bridge-check: 不适用(本项目未安装 dsh 平台副本)');
367
+ assertOut(res, 'bridge-check: 不适用(exit 0)');
368
+ },
369
+ },
370
+
371
+ // 196: 他方插件与他方注册行在安装与清理两个相中原样保持——$DSH_HOME/plugins/ 下非
372
+ // flow-comet 插件文件与 cordis.patch.yml 托管块外他方注册行均不得被安装/清理触碰
373
+ // (读-合并-写 + 只清托管块的非破坏语义;清理 = 删生成物后重建,托管块重新注入属预期,
374
+ // 他方注册行逐字保持)。
375
+ {
376
+ name: '196 dsh 他方插件与他方注册行在安装与清理双相中原样保持',
377
+ run: (dir) => {
378
+ if (!fs.existsSync(PREPARE_ENV)) return;
379
+ const proj = path.join(dir, 'proj');
380
+ fs.mkdirSync(proj, { recursive: true });
381
+ const dshHome = path.join(dir, 'dshhome');
382
+ const otherLoader = '// other plugin fixture\nexport const name = \'other-plugin\';\n';
383
+ const otherPatch = "- id: other-plugin\n name: 'file:///C:/plugins/other-plugin.mjs'\n";
384
+ writeFile(dshHome, 'plugins/other-plugin.mjs', otherLoader);
385
+ writeFile(dshHome, 'cordis.patch.yml', otherPatch);
386
+ const otherBefore = fs.readFileSync(path.join(dshHome, 'plugins', 'other-plugin.mjs'), 'utf8');
387
+ const patchBefore = fs.readFileSync(path.join(dshHome, 'cordis.patch.yml'), 'utf8');
388
+ // 相 1 安装:loader 复制 + 托管块注入,他方内容保持
389
+ const r1 = runPrepareEnv(['--target', proj, '--platform', 'dsh'], dir, { DSH_HOME: dshHome });
390
+ assertExit(r1, 0);
391
+ assertOut(r1, '桥接 loader 首次安装');
392
+ assertOut(r1, '托管块注入完成');
393
+ if (fs.readFileSync(path.join(dshHome, 'plugins', 'other-plugin.mjs'), 'utf8') !== otherBefore) throw new Error('安装相后他方插件被改动');
394
+ const patchAfterInstall = fs.readFileSync(path.join(dshHome, 'cordis.patch.yml'), 'utf8');
395
+ if (!patchAfterInstall.includes('- id: other-plugin') || !patchAfterInstall.includes("name: 'file:///C:/plugins/other-plugin.mjs'")) {
396
+ throw new Error('安装相后他方注册行丢失: ' + patchAfterInstall);
397
+ }
398
+ if (!patchAfterInstall.includes('# --- flow-comet managed ---')) throw new Error('安装相后托管块未注入');
399
+ // 相 2 清理重装:purge 只清托管块与 loader 后重建(生成物域),他方内容保持
400
+ const r2 = runPrepareEnv(['--target', proj, '--platform', 'dsh', '--purge', '--yes'], dir, { DSH_HOME: dshHome });
401
+ assertExit(r2, 0);
402
+ if (fs.readFileSync(path.join(dshHome, 'plugins', 'other-plugin.mjs'), 'utf8') !== otherBefore) throw new Error('清理相后他方插件被改动');
403
+ const patchAfterPurge = fs.readFileSync(path.join(dshHome, 'cordis.patch.yml'), 'utf8');
404
+ // purge = 删生成物后重建:托管块重新注入属预期;他方注册行必须逐字保持(含换行边界)
405
+ if (!patchAfterPurge.startsWith(patchBefore.trim() + '\n\n')) throw new Error('清理相后他方注册行被改动: ' + JSON.stringify(patchAfterPurge));
406
+ if (!patchAfterPurge.includes('# --- flow-comet managed ---')) throw new Error('清理相后托管块未重建注入');
407
+ if (!fs.existsSync(path.join(proj, '.dsh', 'skills', 'flow-comet', 'SKILL.md'))) throw new Error('清理相后重建未完成');
408
+ },
409
+ },
410
+
411
+ // 197: FORCE_READLINE 强制回退——env 开关置 1 时即便 clack 可加载也直接走 readline
412
+ // 序号/逗号多选(仅测试面的回退测试钩子)。wrapper 注入 TTY 标志 + stdin 输入选择 dsh,
413
+ // 断言 readline 序号提示出现、clack 主路径提示不出现、选择后安装真实生效。
414
+ {
415
+ name: '197 prepare-env 强制回退:FORCE_READLINE 走 readline 序号提示且不走 clack',
416
+ run: (dir) => {
417
+ if (!fs.existsSync(PREPARE_ENV)) return;
418
+ const proj = path.join(dir, 'proj');
419
+ fs.mkdirSync(proj, { recursive: true });
420
+ // 非上游 flow-kit 预置——隔离网络,断言聚焦交互分支
421
+ const fk = path.join(proj, 'flow-kit');
422
+ fs.mkdirSync(fk, { recursive: true });
423
+ fs.writeFileSync(path.join(fk, 'sentinel.txt'), 'keep\n', 'utf8');
424
+ const dshHome = path.join(dir, 'dshhome');
425
+ const wrapper = path.join(dir, 'readline-wrapper.mjs');
426
+ fs.writeFileSync(wrapper,
427
+ "import { pathToFileURL } from 'url';\n" +
428
+ "Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });\n" +
429
+ "process.argv = [process.argv[0], process.env.FC_PREPARE_ENV, '--target', process.env.FC_TARGET];\n" +
430
+ "await import(pathToFileURL(process.env.FC_PREPARE_ENV).href);\n", 'utf8');
431
+ const res = spawnSync(process.execPath, [wrapper], {
432
+ cwd: dir,
433
+ input: '3\n', // readline 多选:输入序号 3 = dsh
434
+ env: {
435
+ ...process.env,
436
+ FLOW_COMET_FORCE_READLINE: '1',
437
+ DSH_HOME: dshHome,
438
+ FC_PREPARE_ENV: PREPARE_ENV,
439
+ FC_TARGET: proj,
440
+ },
441
+ encoding: 'utf8',
442
+ timeout: 120000,
443
+ });
444
+ const status = res.status ?? 1;
445
+ const out = String(res.stdout || '') + String(res.stderr || '');
446
+ if (status !== 0) throw new Error('强制回退路径 exit ' + status + '\n' + out);
447
+ if (!out.includes('输入序号或平台名(逗号分隔多选)或回车')) throw new Error('未出现 readline 序号提示:\n' + out);
448
+ if (out.includes('方向键移动、空格勾选')) throw new Error('强制回退仍走了 clack 主路径:\n' + out);
449
+ if (!fs.existsSync(path.join(proj, '.dsh', 'skills', 'flow-comet', 'SKILL.md'))) throw new Error('readline 选择 dsh 后未安装 dsh 平台');
450
+ },
451
+ },
452
+
453
+ // 时序收敛回归锚(AC-5 事故回放):多趟拓扑(并行开路 → 串行衔接 → 并行收尾 → 串行收尾),
454
+ // 逐节点真实走 guard exit --apply 后运行 workflow-state next——断言两者路由结果逐节点一致。
455
+ // 修复前 guard 出口镜像缺「串行 pending → execute」回流(并行收尾完成后直接落到 review,
456
+ // 与权威 next 的 execute 回流偏差)——本场景对未修复引擎为 RED(预期中间态)。
457
+ {
458
+ name: '198 多趟出口路由时序收敛:逐节点 exit --apply 后 next 输出 NODE 与 guard 出口 NODE 一致',
459
+ run: (dir) => {
460
+ const writeTask = (statusMap) => {
461
+ const blk = (id, parallel, deps) =>
462
+ '<task id="' + id + '"' + (parallel ? ' parallel="true"' : '') +
463
+ ' status="' + (statusMap[id] === 'done' ? 'done' : 'pending') + '">' +
464
+ '<action>实现 ' + id + '</action><write_files>src/' + id.toLowerCase() + '.mjs</write_files>' +
465
+ '<verify>node --check src/' + id.toLowerCase() + '.mjs</verify>' +
466
+ (deps ? '<depends_on>' + deps + '</depends_on>' : '') + '</task>\n';
467
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
468
+ blk('P01', true, '') + blk('P02', true, '') +
469
+ blk('S01', false, 'P01,P02') +
470
+ blk('P03', true, 'S01') + blk('P04', true, 'S01') +
471
+ blk('S02', false, 'P03,P04'));
472
+ };
473
+ const readStateObj = () => JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
474
+ // appendEvidence 顶层浅合并 + handoffResult 深层合并:多趟委托下 subagent-execute 的
475
+ // handoffResult 是跨趟累积的委托结果库(越俎代庖检测按全部 done 任务查记录)——整体
476
+ // 覆盖会丢失已委托任务记录(与真实链路 handoff 逐趟追加不一致)。其它节点 evidence
477
+ // 为 summary 对象,浅合并语义与整体赋值等价。
478
+ const appendEvidence = (node, evidence) => {
479
+ const o = readStateObj();
480
+ const prev = o.evidence[node] || {};
481
+ const merged = { ...prev, ...evidence };
482
+ if (evidence.handoffResult && typeof evidence.handoffResult === 'object') {
483
+ merged.handoffResult = { ...(prev.handoffResult || {}), ...evidence.handoffResult };
484
+ }
485
+ o.evidence[node] = merged;
486
+ writeState(dir, o);
487
+ };
488
+ const writeSummary = (ids) => { for (const id of ids) writeFile(dir, '.specs/' + CHANGE_ID + '/' + id + '-SUMMARY.md', summaryContent()); };
489
+ const nodeOf = (out) => (out.match(/^NODE: ([a-z-]+)$/m) || [])[1] ?? null;
490
+ const assertConverge = (guardRes) => {
491
+ assertExit(guardRes, 0);
492
+ const gNode = nodeOf(guardRes.output);
493
+ const nextRes = runStateWithProtocol(dir, ['next']);
494
+ assertExit(nextRes, 0);
495
+ const sNode = nodeOf(nextRes.output);
496
+ if (gNode !== sNode) {
497
+ throw new Error('guard 出口 NODE(' + gNode + ') != next 输出 NODE(' + sNode +
498
+ ')——时序收敛断言失败\nguard 输出:\n' + guardRes.output + '\nnext 输出:\n' + nextRes.output);
499
+ }
500
+ };
501
+ // 预置 open 产物(CHANGE + REQUIREMENT);design/plan 产物在各自出口前写入(真实链路时序)
502
+ writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## Why(为什么做)\n\nx\n\n## 范围(Scope)\n');
503
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## 用户故事(User Story)\n\nx\n\n## 验收准则(AC)\n\n- Given x When y Then z');
504
+ writeState(dir, baseState('open'));
505
+ assertExit(runGuard(['entry', 'open'], dir), 0);
506
+ // ① open 出口 → design
507
+ appendEvidence('open', { summary: 'intake complete' });
508
+ assertConverge(runGuard(['exit', 'open', '--apply'], dir));
509
+ // ② design 出口 → plan
510
+ assertExit(runGuard(['entry', 'design'], dir), 0);
511
+ writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# DESIGN\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## 0. 技术栈选型\n\nNode(纯脚本)\n\n## 决策清单\n\n- [ ] 决策 1');
512
+ appendEvidence('design', { summary: 'design complete' });
513
+ assertConverge(runGuard(['exit', 'design', '--apply'], dir));
514
+ const assertExitRouted = (res, nodeId) => { assertExit(res, 0); if (nodeId) assertOut(res, 'NODE: ' + nodeId); };
515
+ // ③ plan 出口(首波并行可委托)→ subagent-execute(guard 路由跳转;next 侧仅对「直接后继
516
+ // 推进」态可确认输出,委托跳转态不在收敛断言面——收敛锚设在 next 可确认的直接后继/回流态)
517
+ assertExit(runGuard(['entry', 'plan'], dir), 0);
518
+ writeTask({ P01: 'pending', P02: 'pending', S01: 'pending', P03: 'pending', P04: 'pending', S02: 'pending' });
519
+ appendEvidence('plan', { summary: 'plan complete' });
520
+ assertExitRouted(runGuard(['exit', 'plan', '--apply'], dir), 'subagent-execute');
521
+ // ④ 第一波并行委托完成 → 趟间回串行(guard 路由 execute)
522
+ assertExit(runGuard(['entry', 'subagent-execute'], dir), 0);
523
+ writeTask({ P01: 'done', P02: 'done', S01: 'pending', P03: 'pending', P04: 'pending', S02: 'pending' });
524
+ writeSummary(['P01', 'P02']);
525
+ // handoff evidence 构造与既有委托出口场景一致合法形态:非空 summary 满足
526
+ // flowkit.handoff.v1 的 schema evidence 前置校验(missingRequiredSchemaEvidence 中
527
+ // summary 视同满足),handoffResult 满足越俎代庖检测的委托结果记录——guard exit 才
528
+ // 能通过证据前置校验并真正断言路由收敛(缺 summary 时前置 BLOCK,属场景构造缺陷)。
529
+ appendEvidence('subagent-execute', { summary: 'wave1 delegated and collected', handoffResult: handoffFor(['P01', 'P02']) });
530
+ assertExitRouted(runGuard(['exit', 'subagent-execute', '--apply'], dir), 'execute');
531
+ // ⑤ 串行衔接完成 → 第二波并行可委托(guard 路由 subagent-execute)
532
+ assertExit(runGuard(['entry', 'execute'], dir), 0);
533
+ writeTask({ P01: 'done', P02: 'done', S01: 'done', P03: 'pending', P04: 'pending', S02: 'pending' });
534
+ writeSummary(['S01']);
535
+ // 串行衔接任务由 execute 完成,但 subagent 统一委托语义下 execute 出口的越俎代庖检测
536
+ // 要求**所有** done 任务在 subagent-execute 的 handoffResult 有委托记录(真实链路
537
+ // completeTasks 同形态)——追加该任务记录(handoffResult 深层合并保留既有记录)。
538
+ appendEvidence('subagent-execute', { handoffResult: handoffFor(['S01']) });
539
+ appendEvidence('execute', { summary: 'serial wave complete' });
540
+ assertExitRouted(runGuard(['exit', 'execute', '--apply'], dir), 'subagent-execute');
541
+ // ⑥ 第二波并行委托完成 → 收尾串行 pending 应回流 execute(修复核心断言)
542
+ assertExit(runGuard(['entry', 'subagent-execute'], dir), 0);
543
+ writeTask({ P01: 'done', P02: 'done', S01: 'done', P03: 'done', P04: 'done', S02: 'pending' });
544
+ writeSummary(['P03', 'P04']);
545
+ // 与 ④ 同形态(既有合法委托出口形态):非空 summary + handoffResult,guard exit 通过
546
+ // 证据前置校验后才能真正收敛断言(AC-5 时序收敛)。
547
+ appendEvidence('subagent-execute', { summary: 'wave2 delegated and collected', handoffResult: handoffFor(['P03', 'P04']) });
548
+ assertConverge(runGuard(['exit', 'subagent-execute', '--apply'], dir));
549
+ // ⑦ 收尾串行完成 → review
550
+ assertExit(runGuard(['entry', 'execute'], dir), 0);
551
+ writeTask({ P01: 'done', P02: 'done', S01: 'done', P03: 'done', P04: 'done', S02: 'done' });
552
+ writeSummary(['S02']);
553
+ // 同 ⑤:收尾串行任务委托记录追加(深层合并后全部 done 任务均在 handoffResult,
554
+ // execute 出口越俎代庖检测通过)。
555
+ appendEvidence('subagent-execute', { handoffResult: handoffFor(['S02']) });
556
+ appendEvidence('execute', { summary: 'final serial complete' });
557
+ assertConverge(runGuard(['exit', 'execute', '--apply'], dir));
558
+ // ⑧ review → verify
559
+ assertExit(runGuard(['entry', 'review'], dir), 0);
560
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
561
+ '# REVIEW\n\n## 发现\n\n### Critical\n\n- 无\n\n### Major\n\n- 无\n\n### Minor\n\n- 无\n\n## 结论\n\nreview passed,无遗留问题。\n');
562
+ appendEvidence('review', { summary: 'review complete' });
563
+ assertConverge(runGuard(['exit', 'review', '--apply'], dir));
564
+ // ⑨ verify → archive
565
+ assertExit(runGuard(['entry', 'verify'], dir), 0);
566
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TEST.md', '# TEST\n\n## 验证命令\n\n```\necho ok\n```\n');
567
+ writeFile(dir, '.specs/' + CHANGE_ID + '/UAT.md', '# UAT\n\n## 验收\n\n- 通过\n');
568
+ appendEvidence('verify', { summary: 'verify complete' });
569
+ assertConverge(runGuard(['exit', 'verify', '--apply'], dir));
570
+ // ⑩ archive 出口 → 全部完成(两侧均 NEXT: done)
571
+ assertExit(runGuard(['entry', 'archive'], dir), 0);
572
+ writeFile(dir, '.specs/archive/2026-08-28-' + CHANGE_ID + '/KNOWN-ISSUES.md', '# 遗留问题\n\n无。\n');
573
+ appendEvidence('archive', { summary: 'archive complete' });
574
+ const res = runGuard(['exit', 'archive', '--apply'], dir);
575
+ assertExit(res, 0);
576
+ assertOut(res, 'NEXT: done');
577
+ const nextRes = runStateWithProtocol(dir, ['next']);
578
+ assertExit(nextRes, 0);
579
+ assertOut(nextRes, 'NEXT: done');
580
+ },
581
+ },
582
+
583
+ // 199: purge 时目标无 flow-kit → 不得获取也不得创建(清理域语义:purge 只清理、不产生
584
+ // 新产物)。注入不可达 http.proxy(与「网络失败 WARN 继续」场景同技法)——若 purge 路径仍调 ensureFlowKit,
585
+ // 会触发 clone 失败 WARN「flow-kit 自动获取失败」→ 断言“该 WARN 不出现 + 已获取不出现 +
586
+ // 无 flow-kit 目录”即对当前实现 RED。
587
+ {
588
+ name: '199 prepare-env purge 不触碰 flow-kit:purge 且无 flow-kit 不获取不创建',
589
+ run: (dir) => {
590
+ if (!fs.existsSync(PREPARE_ENV)) return;
591
+ const proj = path.join(dir, 'proj');
592
+ fs.mkdirSync(proj, { recursive: true });
593
+ const res = runPrepareEnv(['--target', proj, '--platform', 'dsh', '--purge', '--yes'], dir, {
594
+ DSH_HOME: path.join(dir, 'dshhome'),
595
+ GIT_CONFIG_COUNT: '1',
596
+ GIT_CONFIG_KEY_0: 'http.proxy',
597
+ GIT_CONFIG_VALUE_0: 'http://127.0.0.1:9',
598
+ });
599
+ assertExit(res, 0);
600
+ assertNotOut(res, '已获取 flow-kit');
601
+ assertNotOut(res, 'flow-kit 自动获取失败');
602
+ if (fs.existsSync(path.join(proj, 'flow-kit'))) throw new Error('purge 后创建了 flow-kit 目录');
603
+ },
604
+ },
605
+
606
+ // 200: 版本戳形态校验——已装 loader 标记行非语义化版本(如 beta,无数字主形)→ 提取失败
607
+ // 警告 + 跳过版本比对 + 照常覆盖;不得作为合法版本进入 compare(畸形值 parseInt 得 NaN,
608
+ // 会产生升/降级方向的错误结论)。覆盖断言从权威源动态提取版本值(单一来源——值随发布
609
+ // 更新时本场景无需同步;断言意图 = 「覆盖后 loader 版本戳 == 权威源文件版本戳」)。
610
+ {
611
+ name: '200 prepare-env 版本戳形态:畸形标记(beta)走提取失败警告而非版本比对',
612
+ run: (dir) => {
613
+ if (!fs.existsSync(PREPARE_ENV)) return;
614
+ const proj = path.join(dir, 'proj');
615
+ fs.mkdirSync(proj, { recursive: true });
616
+ const dshHome = path.join(dir, 'dshhome');
617
+ writeFile(dshHome, 'plugins/dsh-flow-comet-bridge.mjs',
618
+ '// dsh bridge loader fixture (malformed stamp)\n// BRIDGE_VERSION: beta\n' +
619
+ "export const name = 'dsh-flow-comet-bridge';\nexport const version = '0.0.0-fixture';\n");
620
+ const res = runPrepareEnv(['--target', proj, '--platform', 'dsh'], dir, { DSH_HOME: dshHome });
621
+ assertExit(res, 0);
622
+ assertOut(res, '版本戳提取失败');
623
+ assertNotOut(res, '桥接 loader 升级');
624
+ assertNotOut(res, '桥接 loader 降级');
625
+ const srcText = fs.readFileSync(path.join(path.dirname(PREPARE_ENV), 'dsh-bridge.mjs'), 'utf8');
626
+ const srcStamp = /^\/\/ BRIDGE_VERSION: (\S+)$/m.exec(srcText);
627
+ if (!srcStamp) throw new Error('权威源 loader 未提取到版本戳(场景前置失效)');
628
+ const installed = fs.readFileSync(path.join(dshHome, 'plugins', 'dsh-flow-comet-bridge.mjs'), 'utf8');
629
+ if (!installed.includes('BRIDGE_VERSION: ' + srcStamp[1])) throw new Error('覆盖后 loader 版本戳非权威源值');
630
+ // 子断言(发布同步守卫):权威源 loader 的标记行、导出常量与载体 INSTALLED_VERSION
631
+ // 三处按 **bridge-check 既有语义**比较(MECHANISM 二·二十七「bridge-check 基础版本归一」:
632
+ // 剥离 dev 态后缀 `-<N>-g<hash>`、按基础版本比较;预发布标识不剥离)——任一处基础版本漂移
633
+ // 时安装副本的 bridge-check 会在已装项目报版本偏斜(上方断言只证明「覆盖 == 权威源文件」,
634
+ // 无法捕获跨文件/跨值分叉)。旧严格全等使主仓「dev 态副本 + 权威源」形态结构性必红(F6);
635
+ // 归一后 dev 态同基础判同步,真实漂移仍必报(判别力见下方子锚表)。
636
+ const installedVersion = fs.readFileSync(path.join(SCRIPTS_DIR, '..', 'INSTALLED_VERSION'), 'utf8').trim();
637
+ const exportMatch = /^export const version = '([^']+)';$/m.exec(srcText);
638
+ if (!exportMatch) throw new Error('权威源 loader 未提取到 export version(场景前置失效)');
639
+ const syncProblems = bridgeStampSyncProblems(srcStamp[1], exportMatch[1], installedVersion);
640
+ if (syncProblems.length > 0) {
641
+ throw new Error(
642
+ '权威源版本三处基础版本不一致(标记行=' + srcStamp[1] + ' / export=' + exportMatch[1] +
643
+ ' / INSTALLED_VERSION=' + installedVersion + ')——发布同步遗漏(bridge-check 会在安装副本报版本偏斜):' +
644
+ syncProblems.join(';')
645
+ );
646
+ }
647
+ // in-place 锚(F6:发布同步守卫判别力双向证明,不新增顶层编号)——权威源 loader 的发布戳
648
+ // 与 dev 态副本 INSTALLED_VERSION 必须按 bridge-check 既有语义比较:剥离 dev 态后缀按基础
649
+ // 版本判同步(锚表正例即该真实形态),真实漂移(基础版本不同 / 发布版对发布版 / 预发布标识
650
+ // 不剥离)仍必报。
651
+ const baseVersion = fixtureBridgeBaseVersion(installedVersion);
652
+ for (const subAnchor of bridgeStampSyncSubAnchorCases(baseVersion, installedVersion)) {
653
+ const synced = subAnchor.problems.length === 0;
654
+ if (synced !== subAnchor.expectSync) {
655
+ throw new Error('发布同步守卫子锚失败(' + subAnchor.label + '):期望'
656
+ + (subAnchor.expectSync ? '同步' : '报漂移') + ',实际 problems=' + JSON.stringify(subAnchor.problems));
657
+ }
658
+ }
659
+ },
660
+ },
661
+
662
+ // 201: bridge-check 目标一致性——托管块 file:// 指向存在但非期望的 loader 文件
663
+ // (可达性成立、目标错误):不可报健康(必须 FAIL——解码目标与期望 loaderPath 不符,exit 1)。
664
+ {
665
+ name: '201 bridge-check 可达但目标错误:file:// 指向非期望 loader FAIL exit 1',
666
+ run: (dir) => {
667
+ const wrong = path.join(dir, 'dshhome', 'plugins', 'some-other-loader.mjs');
668
+ fs.mkdirSync(path.dirname(wrong), { recursive: true });
669
+ fs.writeFileSync(wrong, '// some other loader\n', 'utf8');
670
+ const fileUrl = pathToFileURL(wrong).href;
671
+ const { dshHome } = writeBridgeFixture(dir, {
672
+ patchContent:
673
+ '# --- flow-comet managed ---\n- insert:\n - id: dsh-flow-comet-bridge\n name: \'' +
674
+ fileUrl.replace(/'/g, "''") + '\'\n# --- end flow-comet managed ---\n',
675
+ });
676
+ const res = runBridgeCheck(dir, dshHome);
677
+ assertExit(res, 1);
678
+ assertOut(res, '[FAIL]');
679
+ assertNotOut(res, '健康(全部检查通过)');
680
+ },
681
+ },
682
+
683
+ // 202: 并行文件依赖检测前移(write∩write 强判)——两个同波次 parallel pending 任务
684
+ // write_files 重叠(链式重命名的 .txt 事故面:任务 A 写 bak_a.txt、任务 B 也写 bak_a.txt,
685
+ // 无 depends_on):新 change 的 plan 出口应 BLOCKED(含任务 id 对、重叠路径、恢复指引
686
+ // 「补显式 depends_on 或拆串行」)。修复前 plan 出口无此检测 = 预期 RED(重叠静默放行)。
687
+ // 引号形态:P02 用单引号属性(XML 合法形态)——属性不解析会让 P02 退化为非并行 → 重叠漏判
688
+ // (本场景退出码/消息断言即 RED),与 TASK_VALID_PS 的路由断言构成两条下游消费路径的覆盖。
689
+ // in-place 扩展(glob 形态盲区闭合):单侧含元字符 ⇒ 用该侧模式匹配另一侧字面路径(段内 `*`
690
+ // 不跨 `/`);段数不等 / 段内不匹配 ⇒ 不重叠放行;双侧 glob ⇒ 保守判重叠;补依赖路径 ⇒ 放行
691
+ // (判据不恒真空过)。反向构造:把重叠判定回退成逐字相等 ⇒ ③/③d 必红。
692
+ {
693
+ name: '202 plan exit 写写重叠:字面/glob 单侧与双侧/段内不跨斜杠/补依赖路径(含恢复)',
694
+ run: (dir) => {
695
+ const st = baseState('plan');
696
+ st.evidence.plan = { summary: 'plan done' };
697
+ st.newChange = true;
698
+ writeState(dir, st);
699
+ const tasks =
700
+ '<task id="P01" parallel="true" status="pending"><action>实现 P01</action><write_files>bak_a.txt</write_files><verify>node --check bak_a.txt</verify></task>\n' +
701
+ "<task id='P02' parallel='true' status='pending'><action>实现 P02</action><write_files>bak_a.txt</write_files><verify>node --check bak_a.txt</verify></task>\n";
702
+ const res = runPlanExit(dir, tasks);
703
+ assertExit(res, 1);
704
+ assertOut(res, 'BLOCKED');
705
+ assertOut(res, 'P01×P02');
706
+ assertOut(res, 'bak_a.txt');
707
+ assertOut(res, 'depends_on');
708
+
709
+ // ③ glob 形态重叠(单侧元字符 × 字面路径):修复前逐字相等判定漏检 ⇒ 静默放行
710
+ const globTasks = (firstWrite, secondWrite, secondDeps = '') =>
711
+ '<task id="G01" parallel="true" status="pending"><action>实现 G01</action><write_files>' + firstWrite + '</write_files><verify>node --check src/x.mjs</verify></task>\n' +
712
+ '<task id="G02" parallel="true" status="pending"><action>实现 G02</action><write_files>' + secondWrite + '</write_files><verify>node --check src/x.mjs</verify>' + secondDeps + '</task>\n';
713
+ const globOverlap = runPlanExit(dir, globTasks('src/*.mjs', 'src/foo.mjs'));
714
+ assertExit(globOverlap, 1);
715
+ assertOut(globOverlap, 'BLOCKED');
716
+ assertOut(globOverlap, 'G01×G02');
717
+ assertOut(globOverlap, 'src/*.mjs');
718
+ assertOut(globOverlap, 'src/foo.mjs');
719
+ assertOut(globOverlap, 'depends_on');
720
+ // ③b 段内 `*` 不跨 `/`:段数不等 ⇒ 不重叠 ⇒ 放行
721
+ const depthMismatch = runPlanExit(dir, globTasks('src/*.mjs', 'src/deep/foo.mjs'));
722
+ assertExit(depthMismatch, 0);
723
+ assertNotOut(depthMismatch, 'BLOCKED');
724
+ // ③c 段内模式不匹配(扩展名不符)⇒ 不重叠 ⇒ 放行
725
+ const suffixMismatch = runPlanExit(dir, globTasks('src/*.mjs', 'src/foo.js'));
726
+ assertExit(suffixMismatch, 0);
727
+ assertNotOut(suffixMismatch, 'BLOCKED');
728
+ // ③d 双侧 glob ⇒ 保守视为重叠(宁可误拦不可漏检——漏检正是本判据要修的缺陷)
729
+ const doubleGlob = runPlanExit(dir, globTasks('src/*.mjs', 'src/*.js'));
730
+ assertExit(doubleGlob, 1);
731
+ assertOut(doubleGlob, 'BLOCKED');
732
+ assertOut(doubleGlob, 'G01×G02');
733
+ assertOut(doubleGlob, '∩');
734
+ // ③e 恢复路径一:补显式 depends_on(重叠路径不改,不是靠改路径避开重叠)⇒ 放行
735
+ const directDep = runPlanExit(dir, globTasks('src/*.mjs', 'src/foo.mjs', '<depends_on>G01</depends_on>'));
736
+ assertExit(directDep, 0);
737
+ assertNotOut(directDep, 'BLOCKED');
738
+ // ③f 恢复路径二:经中间任务补依赖路径(G02 → M01 → G01)⇒ 依赖拓扑下不再同趟 ⇒ 放行
739
+ const transitiveDep = runPlanExit(dir,
740
+ '<task id="G01" parallel="true" status="pending"><action>实现 G01</action><write_files>src/*.mjs</write_files><verify>node --check src/x.mjs</verify></task>\n' +
741
+ '<task id="M01" status="pending"><action>实现 M01</action><write_files>src/mid.mjs</write_files><verify>node --check src/mid.mjs</verify><depends_on>G01</depends_on></task>\n' +
742
+ '<task id="G02" parallel="true" status="pending"><action>实现 G02</action><write_files>src/foo.mjs</write_files><verify>node --check src/x.mjs</verify><depends_on>M01</depends_on></task>\n');
743
+ assertExit(transitiveDep, 0);
744
+ assertNotOut(transitiveDep, 'BLOCKED');
745
+
746
+ // ③g 等价性锚(in-place 扩展):段内 glob 语义的两处实现——route-node 的计划期重叠判定
747
+ // (collectPathOverlaps)与 workflow-handoff 的提交子集校验(matchWriteFilePattern)
748
+ // ——对同一 (声明, 字面) 矩阵必须同判。两侧各测一侧不叫等价:此锚同一矩阵两侧求值。
749
+ // 反向构造内建:矩阵里每一格都先断「两侧同判」,任一侧语义漂移即红(判别力由同一判据驱动)。
750
+ const globProblems = globEquivalenceProblems(dir);
751
+ if (globProblems.length > 0) {
752
+ throw new Error('段内 glob 语义两处实现等价性锚失败: ' + globProblems.join('; '));
753
+ }
754
+ },
755
+ },
756
+
757
+ // 203: 写写强判分级(渐进)——同拓扑旧 change(无 newChange 标记):plan 出口应 WARN 渐进
758
+ // 不 BLOCK(与依赖环分级同先例)。修复前 plan 出口无检测 = 预期 RED(无 WARN 亦无 BLOCK)。
759
+ {
760
+ name: '203 plan exit 兼容:旧 change 写写重叠不 BLOCK(渐进 WARN)',
761
+ run: (dir) => {
762
+ const st = baseState('plan');
763
+ st.evidence.plan = { summary: 'plan done' };
764
+ writeState(dir, st);
765
+ const tasks =
766
+ '<task id="P01" parallel="true" status="pending"><action>实现 P01</action><write_files>bak_a.txt</write_files><verify>node --check bak_a.txt</verify></task>\n' +
767
+ '<task id="P02" parallel="true" status="pending"><action>实现 P02</action><write_files>bak_a.txt</write_files><verify>node --check bak_a.txt</verify></task>\n';
768
+ const res = runPlanExit(dir, tasks);
769
+ assertExit(res, 0);
770
+ assertNotOut(res, 'BLOCKED');
771
+ assertOut(res, 'WARN');
772
+ assertOut(res, 'P01×P02');
773
+ assertOut(res, 'bak_a.txt');
774
+ },
775
+ },
776
+
777
+ // 204: 扩展名白名单闭合——txt/无扩展名写路径重叠同等检出(不再被标准扩展名白名单漏检)。
778
+ // 拓扑:P01 与 P02 重叠于 notes.txt,P03 与 P04 重叠于无扩展名路径 RELEASE。
779
+ {
780
+ name: '204 plan exit BLOCKED:txt/无扩展名写路径重叠检出(扩展名闭合)',
781
+ run: (dir) => {
782
+ const st = baseState('plan');
783
+ st.evidence.plan = { summary: 'plan done' };
784
+ st.newChange = true;
785
+ writeState(dir, st);
786
+ const tasks =
787
+ '<task id="P01" parallel="true" status="pending"><action>实现 P01</action><write_files>notes.txt</write_files><verify>node --check notes.txt</verify></task>\n' +
788
+ '<task id="P02" parallel="true" status="pending"><action>实现 P02</action><write_files>notes.txt</write_files><verify>node --check notes.txt</verify></task>\n' +
789
+ '<task id="P03" parallel="true" status="pending"><action>实现 P03</action><write_files>RELEASE</write_files><verify>node --check RELEASE</verify></task>\n' +
790
+ '<task id="P04" parallel="true" status="pending"><action>实现 P04</action><write_files>RELEASE</write_files><verify>node --check RELEASE</verify></task>\n';
791
+ const res = runPlanExit(dir, tasks);
792
+ assertExit(res, 1);
793
+ assertOut(res, 'BLOCKED');
794
+ assertOut(res, 'notes.txt');
795
+ assertOut(res, 'RELEASE');
796
+ },
797
+ },
798
+
799
+ // 205: read∩write 弱判(渐进提示,触发面=仅无显式 depends_on 关联的并行对)——
800
+ // ① 无关联对:一方 read_files 命中对方 write_files → WARN 提示(新 change 亦不 BLOCK);
801
+ // ② 有显式关联(依赖已声明)→ 探测跳过 → 零新增告警(既有合法拓扑断言不变)。
802
+ // 修复前无此弱判 = 预期 RED(无 read∩write WARN)。
803
+ {
804
+ name: '205 plan exit 弱判:read∩write 无显式关联对 WARN 不 BLOCK;有显式关联零告警',
805
+ run: (dir) => {
806
+ const st = baseState('plan');
807
+ st.evidence.plan = { summary: 'plan done' };
808
+ st.newChange = true;
809
+ writeState(dir, st);
810
+ // ① 无显式关联对:P01 读 shared-context.md,P02 写同路径 → WARN 提示级(不 BLOCK)
811
+ const weak =
812
+ '<task id="P01" parallel="true" status="pending"><action>实现 P01</action><read_files>shared-context.md</read_files><write_files>src/p1.mjs</write_files><verify>node --check src/p1.mjs</verify></task>\n' +
813
+ '<task id="P02" parallel="true" status="pending"><action>实现 P02</action><write_files>shared-context.md</write_files><verify>node --check shared-context.md</verify></task>\n';
814
+ const res = runPlanExit(dir, weak);
815
+ assertExit(res, 0);
816
+ assertNotOut(res, 'BLOCKED');
817
+ assertOut(res, 'read∩write');
818
+ assertOut(res, 'P01×P02');
819
+ assertOut(res, 'shared-context.md');
820
+ // ② 有显式关联(P02 depends_on P01 → 跨趟非同波次并行对)→ read∩write 探测跳过 → 零告警
821
+ const associated =
822
+ '<task id="P01" parallel="true" status="pending"><action>实现 P01</action><read_files>shared-context.md</read_files><write_files>src/p1.mjs</write_files><verify>node --check src/p1.mjs</verify></task>\n' +
823
+ '<task id="P02" parallel="true" status="pending"><action>实现 P02</action><write_files>shared-context.md</write_files><verify>node --check shared-context.md</verify><depends_on>P01</depends_on></task>\n';
824
+ const res2 = runPlanExit(dir, associated);
825
+ assertExit(res2, 0);
826
+ assertNotOut(res2, 'read∩write');
827
+ assertNotOut(res2, 'BLOCKED');
828
+ },
829
+ },
830
+
831
+ // 206: 委托前行为保持锚 + 伪并行并存不干扰——① subagent-execute 委托前写写重叠仍 BLOCKED
832
+ // (第二道拦截不变);② 修复写写重叠后 plan 出口放行,且仅写测试产物的并行任务仍触发伪并行
833
+ // WARN(渐进提示不阻断)——新检测与既有检测并存不干扰。
834
+ {
835
+ name: '206 委托前写写拦截保持锚 + 伪并行并存不干扰',
836
+ run: (dir) => {
837
+ // ① 委托前锚:同波次并行 pending 写写重叠 → entry subagent-execute 仍 BLOCKED
838
+ const st = baseState('subagent-execute');
839
+ st.newChange = true;
840
+ writeState(dir, st);
841
+ const conflictTasksForDelegation =
842
+ '<task id="P01" parallel="true" status="pending"><action>实现 P01</action><write_files>bak_a.txt</write_files><verify>node --check bak_a.txt</verify></task>\n' +
843
+ '<task id="P02" parallel="true" status="pending"><action>实现 P02</action><write_files>bak_a.txt</write_files><verify>node --check bak_a.txt</verify></task>\n';
844
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n## 任务清单\n\n' + conflictTasksForDelegation);
845
+ const resDeleg = runGuard(['entry', 'subagent-execute'], dir);
846
+ assertExit(resDeleg, 1);
847
+ assertOut(resDeleg, 'BLOCKED');
848
+ assertOut(resDeleg, 'write_files 冲突');
849
+ // ② 伪并行并存:修复重叠(各写各的)后 plan 出口放行,且仅写测试产物的并行任务
850
+ // 仍触发伪并行 WARN——新检测与既有检测并存不干扰
851
+ const st2 = baseState('plan');
852
+ st2.evidence.plan = { summary: 'plan done' };
853
+ st2.newChange = true;
854
+ writeState(dir, st2);
855
+ const coexisting =
856
+ '<task id="P01" parallel="true" status="pending"><action>实现 P01</action><write_files>src/p1.mjs</write_files><verify>node --check src/p1.mjs</verify></task>\n' +
857
+ '<task id="P02" parallel="true" status="pending"><action>实现 P02</action><write_files>tests/test_p2.mjs</write_files><verify>node --check tests/test_p2.mjs</verify></task>\n';
858
+ const resPlan = runPlanExit(dir, coexisting);
859
+ assertExit(resPlan, 0);
860
+ assertOut(resPlan, 'ALL CHECKS PASSED');
861
+ assertOut(resPlan, '伪并行检测');
862
+ assertNotOut(resPlan, 'BLOCKED');
863
+ },
864
+ },
865
+
866
+ // 207: 多趟平行转换门禁共用路由后继——各转换点 exit --apply 后 next 可达且与 guard NEXT
867
+ // 一致(时序锚完整化:既有收敛场景曾把「plan→subagent-execute」「subagent-execute→execute」
868
+ // 两个平行转换点排除在收敛断言面外——next 侧正常推进豁免只认静态直接后继,平行转换被误拦
869
+ // 为「疑似未 exit」;本场景把全转换链纳入收敛断言,覆盖平行跳转与趟间回流)。
870
+ {
871
+ name: '207 多趟平行转换 next 可达且与 guard NEXT 一致(完整时序锚)',
872
+ run: (dir) => {
873
+ const writeTask = (statusMap) => {
874
+ const blk = (id, parallel, deps) =>
875
+ '<task id="' + id + '"' + (parallel ? ' parallel="true"' : '') +
876
+ ' status="' + (statusMap[id] === 'done' ? 'done' : 'pending') + '">' +
877
+ '<action>实现 ' + id + '</action><write_files>src/' + id.toLowerCase() + '.mjs</write_files>' +
878
+ '<verify>node --check src/' + id.toLowerCase() + '.mjs</verify>' +
879
+ (deps ? '<depends_on>' + deps + '</depends_on>' : '') + '</task>\n';
880
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
881
+ blk('P01', true, '') + blk('P02', true, '') +
882
+ blk('S01', false, 'P01,P02') +
883
+ blk('P03', true, 'S01') + blk('P04', true, 'S01') +
884
+ blk('S02', false, 'P03,P04'));
885
+ };
886
+ const readStateObj = () => JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
887
+ const appendEvidence = (node, evidence) => {
888
+ const o = readStateObj();
889
+ const prev = o.evidence[node] || {};
890
+ const merged = { ...prev, ...evidence };
891
+ if (evidence.handoffResult && typeof evidence.handoffResult === 'object') {
892
+ merged.handoffResult = { ...(prev.handoffResult || {}), ...evidence.handoffResult };
893
+ }
894
+ o.evidence[node] = merged;
895
+ writeState(dir, o);
896
+ };
897
+ const writeSummary = (ids) => { for (const id of ids) writeFile(dir, '.specs/' + CHANGE_ID + '/' + id + '-SUMMARY.md', summaryContent()); };
898
+ const nodeOf = (out) => (out.match(/^NODE: ([a-z-]+)$/m) || [])[1] ?? null;
899
+ const assertConverge = (guardRes) => {
900
+ assertExit(guardRes, 0);
901
+ const gNode = nodeOf(guardRes.output);
902
+ const nextRes = runStateWithProtocol(dir, ['next']);
903
+ assertExit(nextRes, 0);
904
+ const sNode = nodeOf(nextRes.output);
905
+ if (gNode !== sNode) {
906
+ throw new Error('guard 出口 NODE(' + gNode + ') != next 输出 NODE(' + sNode +
907
+ ')——完整时序锚断言失败\nguard 输出:\n' + guardRes.output + '\nnext 输出:\n' + nextRes.output);
908
+ }
909
+ };
910
+ // 前序产物(open/design/plan 产物门控按文件推导——与既有收敛场景同形态;DESIGN/TASK 在
911
+ // 各自节点出口前写入,路由转换按真实时序推进)
912
+ writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## Why(为什么做)\n\nx\n\n## 范围(Scope)\n');
913
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## 用户故事(User Story)\n\nx\n\n## 验收准则(AC)\n\n- Given x When y Then z');
914
+ writeState(dir, baseState('open'));
915
+ // ① open 出口 → design(收敛)
916
+ appendEvidence('open', { summary: 'intake complete' });
917
+ assertExit(runGuard(['entry', 'open'], dir), 0);
918
+ assertConverge(runGuard(['exit', 'open', '--apply'], dir));
919
+ // ② design 出口 → plan(收敛;DESIGN 产物在本节点出口前写入——真实时序)
920
+ writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# DESIGN\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## 0. 技术栈选型\n\nNode(纯脚本)\n\n## 决策清单\n\n- [ ] 决策 1');
921
+ appendEvidence('design', { summary: 'design complete' });
922
+ assertExit(runGuard(['entry', 'design'], dir), 0);
923
+ assertConverge(runGuard(['exit', 'design', '--apply'], dir));
924
+ // ③ plan 出口 → subagent-execute(平行转换点——修复前 next 误拦「疑似未 exit」)
925
+ writeTask({ P01: 'pending', P02: 'pending', S01: 'pending', P03: 'pending', P04: 'pending', S02: 'pending' });
926
+ appendEvidence('plan', { summary: 'plan complete' });
927
+ assertExit(runGuard(['entry', 'plan'], dir), 0);
928
+ assertConverge(runGuard(['exit', 'plan', '--apply'], dir));
929
+ // ④ 首波并行委托完成 → 趟间回串行 execute(平行回流点——修复前同样误拦)
930
+ writeTask({ P01: 'done', P02: 'done', S01: 'pending', P03: 'pending', P04: 'pending', S02: 'pending' });
931
+ writeSummary(['P01', 'P02']);
932
+ appendEvidence('subagent-execute', { summary: 'wave 1 delegated and collected', handoffResult: handoffFor(['P01', 'P02']) });
933
+ assertExit(runGuard(['entry', 'subagent-execute'], dir), 0);
934
+ assertConverge(runGuard(['exit', 'subagent-execute', '--apply'], dir));
935
+ // ⑤ 串行衔接完成 → 第二波并行可委托(execute → subagent-execute)
936
+ writeTask({ P01: 'done', P02: 'done', S01: 'done', P03: 'pending', P04: 'pending', S02: 'pending' });
937
+ writeSummary(['S01']);
938
+ appendEvidence('subagent-execute', { handoffResult: handoffFor(['S01']) });
939
+ appendEvidence('execute', { summary: 'serial wave complete' });
940
+ assertExit(runGuard(['entry', 'execute'], dir), 0);
941
+ assertConverge(runGuard(['exit', 'execute', '--apply'], dir));
942
+ // ⑥ 第二波并行委托完成 → 收尾串行回流 execute(平行回流点)
943
+ writeTask({ P01: 'done', P02: 'done', S01: 'done', P03: 'done', P04: 'done', S02: 'pending' });
944
+ writeSummary(['P03', 'P04']);
945
+ appendEvidence('subagent-execute', { summary: 'wave 2 delegated and collected', handoffResult: handoffFor(['P03', 'P04']) });
946
+ assertExit(runGuard(['entry', 'subagent-execute'], dir), 0);
947
+ assertConverge(runGuard(['exit', 'subagent-execute', '--apply'], dir));
948
+ // ⑦ 收尾串行完成 → review
949
+ writeTask({ P01: 'done', P02: 'done', S01: 'done', P03: 'done', P04: 'done', S02: 'done' });
950
+ writeSummary(['S02']);
951
+ appendEvidence('subagent-execute', { handoffResult: handoffFor(['S02']) });
952
+ appendEvidence('execute', { summary: 'final serial wave complete' });
953
+ assertExit(runGuard(['entry', 'execute'], dir), 0);
954
+ assertConverge(runGuard(['exit', 'execute', '--apply'], dir));
955
+ // ⑧ review → verify
956
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
957
+ '# REVIEW\n\n## 发现\n\n### Critical\n\n- 无\n\n### Major\n\n- 无\n\n### Minor\n\n- 无\n\n## 结论\n\nreview passed。\n');
958
+ appendEvidence('review', { summary: 'review complete' });
959
+ assertExit(runGuard(['entry', 'review'], dir), 0);
960
+ assertConverge(runGuard(['exit', 'review', '--apply'], dir));
961
+ // ⑨ verify → archive
962
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TEST.md', '# TEST\n\n## 验证命令\n\n```\necho ok\n```\n');
963
+ writeFile(dir, '.specs/' + CHANGE_ID + '/UAT.md', '# UAT\n\n## 验收\n\n- 通过\n');
964
+ appendEvidence('verify', { summary: 'verify complete' });
965
+ assertExit(runGuard(['entry', 'verify'], dir), 0);
966
+ assertConverge(runGuard(['exit', 'verify', '--apply'], dir));
967
+ // ⑩ archive 出口 → 完成(两侧均 NEXT: done)
968
+ writeFile(dir, '.specs/archive/2026-08-28-' + CHANGE_ID + '/KNOWN-ISSUES.md', '# 遗留问题\n\n无。\n');
969
+ appendEvidence('archive', { summary: 'archive complete' });
970
+ assertExit(runGuard(['entry', 'archive'], dir), 0);
971
+ const resArch = runGuard(['exit', 'archive', '--apply'], dir);
972
+ assertExit(resArch, 0);
973
+ assertOut(resArch, 'NEXT: done');
974
+ const nextRes = runStateWithProtocol(dir, ['next']);
975
+ assertExit(nextRes, 0);
976
+ assertOut(nextRes, 'NEXT: done');
977
+ },
978
+ },
979
+
980
+ // 208: record 后未 exit 先 next 不提前校正到路由后继(反死结锚——平行转换点:进行中
981
+ // 节点保护此前只认静态直接后继,推导落子在 subagent-execute 时保护失效,currentNode 被
982
+ // 提前校正 → 随后 exit plan 的 currentNode 匹配必 BLOCK → 死结)。
983
+ {
984
+ name: '208 record 后未 exit 先 next 不漂移死结:后续 exit 仍可',
985
+ run: (dir) => {
986
+ // 前序产物(open/design 已完成,plan 已进入并 record——未 exit)
987
+ writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## Why(为什么做)\n\nx\n\n## 范围(Scope)\n');
988
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## 用户故事(User Story)\n\nx\n\n## 验收准则(AC)\n\n- Given x When y Then z');
989
+ writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# DESIGN\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## 0. 技术栈选型\n\nNode(纯脚本)\n\n## 决策清单\n\n- [ ] 决策 1');
990
+ // 平行转换前夜:并行任务存在且可委托(无依赖待满足)
991
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
992
+ '<task id="P01" parallel="true" status="pending"><action>实现 P01</action><write_files>src/p1.mjs</write_files><verify>node --check src/p1.mjs</verify></task>\n' +
993
+ '<task id="P02" parallel="true" status="pending"><action>实现 P02</action><write_files>src/p2.mjs</write_files><verify>node --check src/p2.mjs</verify></task>\n' +
994
+ '<task id="S01" parallel="false" status="pending"><action>实现 S01</action><write_files>src/s1.mjs</write_files><verify>node --check src/s1.mjs</verify><depends_on>P01,P02</depends_on></task>\n');
995
+ const st = baseState('plan');
996
+ st.completedNodes = ['open', 'design'];
997
+ st.enteredNodes = ['open', 'design', 'plan'];
998
+ st.evidence = {
999
+ open: { summary: 'open complete' },
1000
+ design: { summary: 'design complete' },
1001
+ plan: { summary: 'plan complete' },
1002
+ };
1003
+ st.newChange = true;
1004
+ writeState(dir, st);
1005
+ // ① record 后未 exit 先 next:不把 currentNode 提前校正到 subagent-execute(路由后继)
1006
+ const r1 = runStateWithProtocol(dir, ['next']);
1007
+ assertExit(r1, 0);
1008
+ assertOut(r1, 'NODE: plan');
1009
+ const stAfterNext = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
1010
+ if (stAfterNext.currentNode !== 'plan') {
1011
+ throw new Error('record 后未 exit 先 next 不应提前校正 currentNode(应保持 plan),实际: ' + stAfterNext.currentNode);
1012
+ }
1013
+ // ② 后续 exit plan --apply 仍可(进行中节点保护 → 未漂移 → currentNode 匹配)
1014
+ assertExit(runGuard(['entry', 'plan'], dir), 0);
1015
+ const rExit = runGuard(['exit', 'plan', '--apply'], dir);
1016
+ assertExit(rExit, 0);
1017
+ assertOut(rExit, 'ALL CHECKS PASSED');
1018
+ // ③ exit 推进后 next 路由到 subagent-execute(平行转换点——与 guard 出口一致)
1019
+ const r2 = runStateWithProtocol(dir, ['next']);
1020
+ assertExit(r2, 0);
1021
+ assertOut(r2, 'NODE: subagent-execute');
1022
+ },
1023
+ },
1024
+
1025
+ // 209: exit 漂移容忍正例——currentNode 已漂移到文件推导下一节点(execute 证据/产物齐→路由已指向
1026
+ // review)且本节点证据+产物齐 → 容错 exit execute --apply 可过(补欠账)——BLOCK 不再只有
1027
+ // 不可行的 advance/select 指引(修复锚)。修复前 currentNode 校验必 BLOCK → RED。
1028
+ {
1029
+ name: '209 exit 漂移容忍:currentNode 已为文件推导下一节点且证据/产物齐 → exit 可过',
1030
+ run: (dir) => {
1031
+ writeIntakeArtifacts(dir);
1032
+ // TASK 全 done(T01 串行)+ SUMMARY(execute 产物门控)
1033
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
1034
+ '<task id="T01" status="done"><action>实现 T01</action><write_files>src/t1.mjs</write_files><verify>node --check src/t1.mjs</verify></task>\n');
1035
+ // 新 change 严格模板保真:SUMMARY 须 `# SUMMARY:` 标题 + 首部 4 字段 + 段序(模板保真场景同款合法形态)
1036
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
1037
+ ['# SUMMARY: T01 - 实现 T01', '',
1038
+ '- **Change ID**: ' + CHANGE_ID, '- **Task ID**: T01', '- **完成时间**: 2026-08-29 10:00', '- **AI 角色**: Dev',
1039
+ '', '---', '',
1040
+ '## 做了什么\n\n实现 T01(TDD:先写失败场景再实现)。',
1041
+ '## 改动文件\n\n| 文件 | 性质 | 说明 |\n|---|---|---|\n| src/t1.mjs | 修改 | 实现 T01 |',
1042
+ '## verify 输出\n\n```\nnode --check src/t1.mjs\n```',
1043
+ '## 6 维自查\n\n- 功能: 通过(brooks-review 已跑)\n- 性能: 无影响\n- 安全: 无影响\n- 兼容: 通过\n- 可观测: 通过\n- 可维护: 通过',
1044
+ '## 越界检查\n\n仅修改 src/t1.mjs,无越界。',
1045
+ '## 自检方法\n\nbrooks-review', '',
1046
+ ].join('\n'));
1047
+ // 漂移态:completedNodes=[open,design,plan](execute 未 completed——欠账),currentNode=review
1048
+ // (路由已越过 execute——execute 证据/产物齐);evidence.execute + enteredNodes 含 execute(防 R2 拦)
1049
+ const st = baseState('review');
1050
+ st.completedNodes = ['open', 'design', 'plan'];
1051
+ st.enteredNodes = ['open', 'design', 'plan', 'execute', 'review'];
1052
+ st.evidence = {
1053
+ open: { summary: 'open done' },
1054
+ design: { summary: 'design done' },
1055
+ plan: { summary: 'plan done' },
1056
+ execute: { summary: 'executed', parallelTakeoverApproved: true },
1057
+ };
1058
+ st.newChange = true;
1059
+ writeState(dir, st);
1060
+ const res = runGuard(['exit', 'execute', '--apply'], dir);
1061
+ assertExit(res, 0);
1062
+ assertNotOut(res, 'BLOCKED: currentNode');
1063
+ assertOut(res, '容错');
1064
+ const stAfter = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
1065
+ if (!stAfter.completedNodes.includes('execute')) {
1066
+ throw new Error('容错 exit execute --apply 后 completedNodes 应含 execute(欠账补齐);实际: ' + stAfter.completedNodes.join(','));
1067
+ }
1068
+ },
1069
+ },
1070
+
1071
+ // 210: exit 漂移容忍反例——currentNode 已漂移但本节点证据/产物不齐 → 仍 BLOCK(容错不放开未完成)
1072
+ {
1073
+ name: '210 exit 漂移仍 BLOCK:漂移但证据/产物不齐(容错不放开未完成)',
1074
+ run: (dir) => {
1075
+ writeIntakeArtifacts(dir);
1076
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
1077
+ '<task id="T01" status="done"><action>实现 T01</action><write_files>src/t1.mjs</write_files><verify>node --check src/t1.mjs</verify></task>\n');
1078
+ // 漂移态同 209,但 execute 产物缺失(T01 宣称 done 却无 SUMMARY 文件)——证据虽在,
1079
+ // 产物不齐 → 容错判定 tolerable=false → 仍 BLOCK(容错不放开未完成;反过度修复锚)。
1080
+ // 注意:证据缺失面由前置证据校验先命中(BLOCKED: missing evidence),本场景故意给证据、
1081
+ // 只缺产物——让漂移容错判定真正走到边界,验证「漂移但产物不齐不收容」。
1082
+ const st = baseState('review');
1083
+ st.completedNodes = ['open', 'design', 'plan'];
1084
+ st.enteredNodes = ['open', 'design', 'plan', 'execute', 'review'];
1085
+ st.evidence = {
1086
+ open: { summary: 'open done' },
1087
+ design: { summary: 'design done' },
1088
+ plan: { summary: 'plan done' },
1089
+ execute: { summary: 'executed' },
1090
+ };
1091
+ st.newChange = true;
1092
+ writeState(dir, st);
1093
+ const res = runGuard(['exit', 'execute', '--apply'], dir);
1094
+ assertExit(res, 1);
1095
+ assertOut(res, 'BLOCKED: currentNode is review');
1096
+ assertNotOut(res, 'ALL CHECKS PASSED');
1097
+ },
1098
+ },
1099
+
1100
+ // 211: 路由诊断静默扩展——剩余 pending 全串行(P→S 收尾转换:并行已全 done、
1101
+ // 仅剩串行 pending、无缺 status 畸形块)→ ROUTE WARN 静默(「全 done 静默」锚扩展为
1102
+ // 「剩余全串行」也静默——P→S 收尾不再输出噪音;修复前按「无 parallel pending」判定仍报 → RED)
1103
+ {
1104
+ name: '211 路由诊断静默:剩余 pending 全串行(P→S 收尾转换)无 ROUTE WARN',
1105
+ run: (dir) => {
1106
+ writeIntakeArtifacts(dir);
1107
+ const st = baseState('plan');
1108
+ st.completedNodes = ['open', 'design'];
1109
+ st.evidence.plan = { summary: 'executed' };
1110
+ writeState(dir, st);
1111
+ // 并行任务已 done、串行尾任务 pending(全串行剩余、无缺 status 畸形块)→ M4 静默
1112
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
1113
+ '<task id="P01" parallel="true" status="done">\n <action>do</action>\n <verify>echo ok</verify>\n</task>\n' +
1114
+ '<task id="S01" parallel="false" status="pending">\n <action>do serial</action>\n <verify>echo ok</verify>\n</task>\n');
1115
+ const res = runGuardWithProtocol(dir, ['exit', 'plan', '--apply']);
1116
+ assertExit(res, 0);
1117
+ assertNotOut(res, 'ROUTE WARN');
1118
+ assertOut(res, 'ALL CHECKS PASSED');
1119
+ },
1120
+ },
1121
+
1122
+ // 212: 路由诊断保持(M4 反例)——存在缺 status 的 parallel 块(畸形/旧模板形态)且存在串行
1123
+ // pending 时 ROUTE WARN 仍报(结构校验严格保持——缺 status 不视为 pending,不因 M4 误静音;
1124
+ // 判定载体:parallel 标记在场对照 + 真畸形块驱动 WARN)
1125
+ {
1126
+ name: '212 路由诊断保持:parallel 缺 status(畸形块)仍报 ROUTE WARN',
1127
+ run: (dir) => {
1128
+ writeIntakeArtifacts(dir);
1129
+ const st = baseState('plan');
1130
+ st.completedNodes = ['open', 'design'];
1131
+ st.evidence.plan = { summary: 'executed' };
1132
+ writeState(dir, st);
1133
+ // 正常并行任务 done + 畸形并行任务(parallel="true" 无 status)+ 串行尾任务 pending → WARN 保持
1134
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
1135
+ '<task id="P01" parallel="true" status="done">\n <action>do</action>\n <verify>echo ok</verify>\n</task>\n' +
1136
+ '<task id="P03" parallel="true">\n <action>do malformed parallel</action>\n <verify>echo ok</verify>\n</task>\n' +
1137
+ '<task id="S02" parallel="false" status="pending">\n <action>do serial</action>\n <verify>echo ok</verify>\n</task>\n');
1138
+ const res = runGuardWithProtocol(dir, ['exit', 'plan', '--apply']);
1139
+ assertExit(res, 0);
1140
+ assertOut(res, 'ROUTE WARN');
1141
+ },
1142
+ },
1143
+
1144
+ // 213: directOverride 授权约束正例——协调者显式授权留痕在场(executionMode=direct +
1145
+ // directOverride=true + 授权审计字段 directOverrideAt/来源)→ execute 出口通过(direct 是
1146
+ // 用户决策点,授权留痕即合法路径;修复前出口无授权校验——GREEN 后本场景仍恒过,防过度修复)。
1147
+ {
1148
+ name: '213 directOverride 授权约束正例:协调者授权 + direct → exit 通过',
1149
+ run: (dir) => {
1150
+ const st = baseState('execute');
1151
+ st.completedNodes = ['open', 'design', 'plan'];
1152
+ st.enteredNodes = ['open', 'design', 'plan', 'execute'];
1153
+ st.evidence = {
1154
+ open: { summary: 'open done' },
1155
+ design: { summary: 'design done' },
1156
+ plan: { summary: 'plan done' },
1157
+ execute: { summary: 'executed' },
1158
+ };
1159
+ st.executionMode = 'direct';
1160
+ st.directOverride = true;
1161
+ st.directOverrideAt = '2026-08-29T10:00:00.000Z';
1162
+ st.directOverrideSource = 'execution-mode';
1163
+ st.newChange = true;
1164
+ writeState(dir, st);
1165
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
1166
+ '<task id="S01" status="done"><action>实现 S01</action><write_files>src/s1.mjs</write_files><verify>node --check src/s1.mjs</verify></task>\n');
1167
+ writeFile(dir, '.specs/' + CHANGE_ID + '/S01-SUMMARY.md', strictSummary('S01'));
1168
+ const res = runGuard(['exit', 'execute', '--apply'], dir);
1169
+ assertExit(res, 0);
1170
+ assertNotOut(res, 'BLOCKED');
1171
+ assertOut(res, 'ALL CHECKS PASSED');
1172
+ },
1173
+ },
1174
+
1175
+ // 214: directOverride 授权约束负例——执行者自切 direct 无授权审计记录(executionMode=direct +
1176
+ // directOverride=true 但无 directOverrideAt)→ execute 出口 BLOCKED(direct 是用户决策点,
1177
+ // 不可自决——机制约束)+ 恢复指引(协调者显式授权 / 回 subagent)。修复前出口无校验 → RED。
1178
+ {
1179
+ name: '214 directOverride 授权约束负例:执行者自切 direct 无授权 → exit BLOCKED',
1180
+ run: (dir) => {
1181
+ const st = baseState('execute');
1182
+ st.completedNodes = ['open', 'design', 'plan'];
1183
+ st.enteredNodes = ['open', 'design', 'plan', 'execute'];
1184
+ st.evidence = {
1185
+ open: { summary: 'open done' },
1186
+ design: { summary: 'design done' },
1187
+ plan: { summary: 'plan done' },
1188
+ execute: { summary: 'executed' },
1189
+ };
1190
+ st.executionMode = 'direct';
1191
+ st.directOverride = true;
1192
+ // 无 directOverrideAt 授权审计记录(执行者自切/修复前遗留形态)
1193
+ st.newChange = true;
1194
+ writeState(dir, st);
1195
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
1196
+ '<task id="S01" status="done"><action>实现 S01</action><write_files>src/s1.mjs</write_files><verify>node --check src/s1.mjs</verify></task>\n');
1197
+ const res = runGuard(['exit', 'execute', '--apply'], dir);
1198
+ assertExit(res, 1);
1199
+ assertOut(res, 'BLOCKED');
1200
+ assertOut(res, 'directOverride');
1201
+ assertOut(res, '授权');
1202
+ },
1203
+ },
1204
+
1205
+ // 215: directOverride 越界检测——绕过脚本直接改 state 文件(工具写 .flow-comet/flow-comet-state.json,
1206
+ // 无授权)→ hook BLOCK(state 文件禁手动工具写——机器字段由脚本通道管理;修复前 direct 模式
1207
+ // 白名单 [''] 允许写 state → 越权写入口 fail-open → RED)。
1208
+ {
1209
+ name: '215 directOverride 越界:直接改 state 文件无授权 → hook BLOCK',
1210
+ run: (dir) => {
1211
+ const st = baseState('execute');
1212
+ st.status = 'running';
1213
+ st.executionMode = 'direct';
1214
+ st.directOverride = true;
1215
+ st.directOverrideAt = '2026-08-29T10:00:00.000Z';
1216
+ writeState(dir, st);
1217
+ const stateFile = path.join(dir, '.flow-comet', 'flow-comet-state.json');
1218
+ const res = runHook(['before_tool'], dir,
1219
+ { tool_name: 'Write', tool_input: { file_path: stateFile } });
1220
+ assertExit(res, 2);
1221
+ assertOut(res, 'BLOCKED');
1222
+ assertOut(res, 'flow-comet-state.json');
1223
+ },
1224
+ },
1225
+
1226
+ // 216: directOverride 授权约束恢复——BLOCK 后按指引① 协调者 execution-mode direct(脚本写入
1227
+ // 授权留痕)→ exit 通过;② 回 subagent(清除 directOverride 与授权留痕,handoff 在场)→ exit
1228
+ // 也通过——两条恢复路径都闭合(修复前无 BLOCK 无从恢复 → RED)。
1229
+ {
1230
+ name: '216 directOverride 恢复:BLOCK 后补授权 / 回 subagent → exit 通过',
1231
+ run: (dir) => {
1232
+ const buildState = () => {
1233
+ const st = baseState('execute');
1234
+ st.completedNodes = ['open', 'design', 'plan'];
1235
+ st.enteredNodes = ['open', 'design', 'plan', 'execute'];
1236
+ st.evidence = {
1237
+ open: { summary: 'open done' },
1238
+ design: { summary: 'design done' },
1239
+ plan: { summary: 'plan done' },
1240
+ execute: { summary: 'executed' },
1241
+ 'subagent-execute': { summary: 'delegated', handoffResult: handoffFor(['S01']) },
1242
+ };
1243
+ st.newChange = true;
1244
+ return st;
1245
+ };
1246
+ const writeTask = () => writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
1247
+ '<task id="S01" status="done"><action>实现 S01</action><write_files>src/s1.mjs</write_files><verify>node --check src/s1.mjs</verify></task>\n');
1248
+ const readState = () => JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
1249
+ // ① 复现 BLOCK(direct 无授权)
1250
+ const st1 = buildState();
1251
+ st1.executionMode = 'direct';
1252
+ st1.directOverride = true;
1253
+ writeState(dir, st1);
1254
+ writeTask();
1255
+ const rBlock = runGuard(['exit', 'execute', '--apply'], dir);
1256
+ assertExit(rBlock, 1);
1257
+ assertOut(rBlock, 'BLOCKED');
1258
+ // ② 恢复路径一:协调者 execution-mode direct(脚本写入授权留痕)→ exit 通过
1259
+ writeFile(dir, '.specs/' + CHANGE_ID + '/S01-SUMMARY.md', strictSummary('S01'));
1260
+ const auth = runStateWithProtocol(dir, ['execution-mode', 'direct']);
1261
+ assertExit(auth, 0);
1262
+ assertOut(auth, 'DIRECT-AUTH');
1263
+ const st2 = readState();
1264
+ if (typeof st2.directOverrideAt !== 'string' || st2.directOverrideAt.trim() === '') {
1265
+ throw new Error('授权后 state 应含 directOverrideAt 审计字段: ' + JSON.stringify(st2.directOverrideAt));
1266
+ }
1267
+ const rAuth = runGuard(['exit', 'execute', '--apply'], dir);
1268
+ assertExit(rAuth, 0);
1269
+ assertOut(rAuth, 'ALL CHECKS PASSED');
1270
+ // ③ 恢复路径二:回 subagent(清除 directOverride 与授权留痕)→ exit 通过
1271
+ const back = runStateWithProtocol(dir, ['execution-mode', 'subagent']);
1272
+ assertExit(back, 0);
1273
+ const st3 = readState();
1274
+ if (st3.directOverride !== false || st3.directOverrideAt !== undefined) {
1275
+ throw new Error('回 subagent 应清除 directOverride 与授权审计字段: ' + JSON.stringify({ directOverride: st3.directOverride, directOverrideAt: st3.directOverrideAt }));
1276
+ }
1277
+ const rBack = runGuard(['exit', 'execute', '--apply'], dir);
1278
+ assertExit(rBack, 0);
1279
+ assertOut(rBack, 'ALL CHECKS PASSED');
1280
+ },
1281
+ },
1282
+
1283
+ // 217: hook state 文件拦截的大小写变体闭合——win32/darwin 文件系统大小写
1284
+ // 不敏感,`.Flow-Comet/Flow-Comet-State.json` 与机器状态文件(.flow-comet/flow-comet-state.json)
1285
+ // 指向同一实体;修复前 blockedStateFileTarget
1286
+ // 精确等值比较 → 变体绕过 W4 防线(direct 白名单 [''] 放行)→ 预期 RED(期望 exit 2 实际 exit 0)。
1287
+ // 其他平台(大小写敏感文件系统)变体是不同文件,不属机器状态文件 → 放行(与「其他平台保持等值
1288
+ // 比较」语义一致,平台分支断言防 CI 误报)。
1289
+ {
1290
+ name: '217 hook state 拦截:大小写变体路径 BLOCK(win32/darwin;其他平台放行)',
1291
+ run: (dir) => {
1292
+ const st = baseState('execute');
1293
+ st.status = 'running';
1294
+ st.executionMode = 'direct';
1295
+ st.directOverride = true;
1296
+ st.directOverrideAt = '2026-08-29T10:00:00.000Z';
1297
+ writeState(dir, st);
1298
+ // 变体形态必须跟随机器状态文件的实际相对路径(命名空间 .flow-comet/flow-comet-state.json)
1299
+ const caseVariant = path.join(dir, '.Flow-Comet', 'Flow-Comet-State.json');
1300
+ const res = runHook(['before_tool'], dir,
1301
+ { tool_name: 'Write', tool_input: { file_path: caseVariant } });
1302
+ if (process.platform === 'win32' || process.platform === 'darwin') {
1303
+ assertExit(res, 2);
1304
+ assertOut(res, 'BLOCKED');
1305
+ assertOut(res, '.Flow-Comet/Flow-Comet-State.json');
1306
+ } else {
1307
+ assertNotOut(res, 'BLOCKED');
1308
+ }
1309
+ },
1310
+ },
1311
+
1312
+ // 218: execute 完成判定 fail-closed——pending===0 不足为凭:缺/未知 status
1313
+ // 的任务既非 pending 也非 done,畸形块若被跳过,会在另一任务已产 SUMMARY 时把完成态误判为
1314
+ // 「任务全部 done」→ 提前路由 review。修复前 resolveNextNode 在 done=1 / attrs=2 时跳过畸形块
1315
+ // 按「全 done」推进 → NODE: review(误路由 → 预期 RED);修复后 done !== attrsList.length
1316
+ // → 回 execute(不提前放行到后置节点)。
1317
+ {
1318
+ name: '218 route-node 完成判定:done 任务 + 畸形块(缺 status) → next 仍回 execute',
1319
+ run: (dir) => {
1320
+ writeIntakeArtifacts(dir);
1321
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
1322
+ '<task id="T01" status="done"><action>实现 T01</action><write_files>src/t1.mjs</write_files><verify>node --check src/t1.mjs</verify></task>\n' +
1323
+ '<task id="T02" parallel="true"><action>实现 T02</action><write_files>src/t2.mjs</write_files><verify>node --check src/t2.mjs</verify></task>\n');
1324
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
1325
+ writeState(dir, {
1326
+ activeChange: CHANGE_ID,
1327
+ currentNode: 'execute',
1328
+ completedNodes: ['open', 'design', 'plan'],
1329
+ evidence: { open: { summary: 'o' }, design: { summary: 'd' }, plan: { summary: 'p' } },
1330
+ verifyFailures: 0,
1331
+ executionMode: 'subagent',
1332
+ directOverride: false,
1333
+ });
1334
+ const res = runStateWithProtocol(dir, ['next']);
1335
+ assertExit(res, 0);
1336
+ assertOut(res, 'NODE: execute');
1337
+ assertNotOut(res, 'NODE: review');
1338
+ },
1339
+ },
1340
+
1341
+ // 219: 并行文件依赖检测路径归一化闭合——重叠比较只用原始字符串时,
1342
+ // `src/a.mjs` vs `src/./a.mjs`(`.` 段变体——同一路径的两种写法)不判重叠 → 变体绕过
1343
+ // 写写强判(修复前 plan 出口漏检 → 预期 RED:期望 BLOCKED 实际放行)。修复后路径解析先
1344
+ // 归一化(分隔符统一 `/`、解 `.` 段、`..` 逃出项目根按越界处理不参与比较),归一化集合
1345
+ // 用于写写强判与读写弱判——与委托入口共用同一函数,两侧同语义。
1346
+ {
1347
+ name: '219 plan exit BLOCKED:路径变体重叠检出(src/a.mjs × src/./a.mjs)',
1348
+ run: (dir) => {
1349
+ const st = baseState('plan');
1350
+ st.evidence.plan = { summary: 'plan done' };
1351
+ st.newChange = true;
1352
+ writeState(dir, st);
1353
+ const tasks =
1354
+ '<task id="P01" parallel="true" status="pending"><action>实现 P01</action><write_files>src/a.mjs</write_files><verify>node --check src/a.mjs</verify></task>\n' +
1355
+ '<task id="P02" parallel="true" status="pending"><action>实现 P02</action><write_files>src/./a.mjs</write_files><verify>node --check src/./a.mjs</verify></task>\n';
1356
+ const res = runPlanExit(dir, tasks);
1357
+ assertExit(res, 1);
1358
+ assertOut(res, 'BLOCKED');
1359
+ assertOut(res, 'P01×P02');
1360
+ assertOut(res, 'src/a.mjs');
1361
+ assertOut(res, 'depends_on');
1362
+ },
1363
+ },
1364
+ ];