flow-comet 1.6.3 → 1.6.5

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 (106) hide show
  1. package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
  2. package/.flow-comet/skills/flow-comet/SKILL.md +21 -3
  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/entry-detail.md +8 -2
  6. package/.flow-comet/skills/flow-comet/reference/workflow-protocol.json +22 -0
  7. package/.flow-comet/skills/flow-comet/scripts/comet-hook-guard.mjs +11 -13
  8. package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +2 -2
  9. package/.flow-comet/skills/flow-comet/scripts/evolve.mjs +180 -6
  10. package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +69 -18878
  11. package/.flow-comet/skills/flow-comet/scripts/health.mjs +29 -5
  12. package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +1053 -0
  13. package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +830 -0
  14. package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +781 -0
  15. package/.flow-comet/skills/flow-comet/scripts/items/d.mjs +99 -0
  16. package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +185 -0
  17. package/.flow-comet/skills/flow-comet/scripts/items/f.mjs +90 -0
  18. package/.flow-comet/skills/flow-comet/scripts/items/g.mjs +59 -0
  19. package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +817 -0
  20. package/.flow-comet/skills/flow-comet/scripts/items/i.mjs +77 -0
  21. package/.flow-comet/skills/flow-comet/scripts/items/j.mjs +75 -0
  22. package/.flow-comet/skills/flow-comet/scripts/items/k.mjs +1427 -0
  23. package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +275 -0
  24. package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +618 -0
  25. package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +154 -0
  26. package/.flow-comet/skills/flow-comet/scripts/lib/count-derivation.mjs +97 -0
  27. package/.flow-comet/skills/flow-comet/scripts/lib/fix-loop-node.mjs +196 -0
  28. package/.flow-comet/skills/flow-comet/scripts/lib/guard-artifact-skeleton.mjs +406 -0
  29. package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +756 -0
  30. package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +1235 -0
  31. package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +384 -0
  32. package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +404 -0
  33. package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +714 -0
  34. package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +204 -0
  35. package/.flow-comet/skills/flow-comet/scripts/lib/reentry-node.mjs +237 -0
  36. package/.flow-comet/skills/flow-comet/scripts/lib/replan-node.mjs +209 -0
  37. package/.flow-comet/skills/flow-comet/scripts/lib/state-branch.mjs +49 -0
  38. package/.flow-comet/skills/flow-comet/scripts/lib/state-bridgecheck.mjs +201 -0
  39. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +179 -0
  40. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +714 -0
  41. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +578 -0
  42. package/.flow-comet/skills/flow-comet/scripts/lib/state-determine.mjs +52 -0
  43. package/.flow-comet/skills/flow-comet/scripts/lib/state-evolve-hint.mjs +55 -0
  44. package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +123 -0
  45. package/.flow-comet/skills/flow-comet/scripts/lib/state-intelscan.mjs +58 -0
  46. package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +147 -0
  47. package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +249 -0
  48. package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +1505 -0
  49. package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +471 -0
  50. package/.flow-comet/skills/flow-comet/scripts/lib/test-assertions.mjs +509 -0
  51. package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +1248 -0
  52. package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +237 -0
  53. package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +2493 -0
  54. package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +214 -2
  55. package/.flow-comet/skills/flow-comet/scripts/route-node.mjs +72 -1123
  56. package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +976 -0
  57. package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1233 -0
  58. package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1382 -0
  59. package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +483 -0
  60. package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +1398 -0
  61. package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +1466 -0
  62. package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +1367 -0
  63. package/.flow-comet/skills/flow-comet/scripts/scenarios/h.mjs +1287 -0
  64. package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +1436 -0
  65. package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +1384 -0
  66. package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +1338 -0
  67. package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +1492 -0
  68. package/.flow-comet/skills/flow-comet/scripts/scenarios/m.mjs +971 -0
  69. package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +2125 -0
  70. package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +1 -1
  71. package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +59 -7559
  72. package/.flow-comet/skills/flow-comet/scripts/time-utils.mjs +4 -4
  73. package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +223 -2476
  74. package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +5 -5
  75. package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +27 -2190
  76. package/.flow-comet/skills/flow-comet-archive/SKILL.md +6 -2
  77. package/.flow-comet/skills/flow-comet-change/SKILL.md +6 -2
  78. package/.flow-comet/skills/flow-comet-design/GUIDANCE.md +13 -3
  79. package/.flow-comet/skills/flow-comet-design/SKILL.md +15 -8
  80. package/.flow-comet/skills/flow-comet-dev/SKILL.md +1 -1
  81. package/.flow-comet/skills/flow-comet-evolve/SKILL.md +1 -0
  82. package/.flow-comet/skills/flow-comet-execute/SKILL.md +13 -10
  83. package/.flow-comet/skills/flow-comet-health/SKILL.md +1 -1
  84. package/.flow-comet/skills/flow-comet-integration/SKILL.md +1 -1
  85. package/.flow-comet/skills/flow-comet-open/GUIDANCE.md +14 -4
  86. package/.flow-comet/skills/flow-comet-open/SKILL.md +11 -9
  87. package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +13 -3
  88. package/.flow-comet/skills/flow-comet-plan/SKILL.md +11 -7
  89. package/.flow-comet/skills/flow-comet-requirement/SKILL.md +1 -1
  90. package/.flow-comet/skills/flow-comet-review/SKILL.md +15 -9
  91. package/.flow-comet/skills/flow-comet-subagent-execute/GUIDANCE.md +13 -3
  92. package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +11 -8
  93. package/.flow-comet/skills/flow-comet-task/SKILL.md +1 -1
  94. package/.flow-comet/skills/flow-comet-test/SKILL.md +6 -2
  95. package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +2 -2
  96. package/.flow-comet/skills/flow-comet-verify/SKILL.md +12 -8
  97. package/README.md +52 -69
  98. package/package.json +3 -2
  99. package/scripts/dsh-bridge.mjs +2 -2
  100. package/scripts/lib/installer-cleanup.mjs +152 -0
  101. package/scripts/lib/installer-flowkit.mjs +159 -0
  102. package/scripts/lib/installer-hooks.mjs +363 -0
  103. package/scripts/lib/installer-loader.mjs +220 -0
  104. package/scripts/lib/installer-migrate.mjs +236 -0
  105. package/scripts/lib/installer-platforms.mjs +314 -0
  106. package/scripts/prepare-env.mjs +21 -1313
@@ -0,0 +1,1398 @@
1
+ // 场景组 e — 单一来源静态锁 · 零提交滥用负例 · 模板保真扩展 · verify 降级
2
+ // 元素形态:`{ name, run }`;计数由 `lib/count-derivation.mjs` 从本目录聚合,不手抄数字。
3
+ // 组界:场景序列按组文件规模上限连续分区——本文件头部两项(154 · 155)落在 scenarios/d.mjs 尾部;
4
+ // 分区只搬文件,场景名/内容与拼接顺序不变(见 scenarios/d.mjs 头注)。
5
+
6
+ import fs from 'fs';
7
+ import path from 'path';
8
+ import { execFileSync, spawnSync } from 'child_process';
9
+ import {
10
+ assertEqual,
11
+ assertExit,
12
+ assertNotOut,
13
+ assertOut,
14
+ assertTrue,
15
+ baseState,
16
+ runGuard,
17
+ runHandoff,
18
+ runState,
19
+ writeFile,
20
+ writeState,
21
+ } from '../lib/test-helpers.mjs';
22
+ import {
23
+ CHANGE_ID,
24
+ REPO_ROOT,
25
+ SCRIPTS_DIR,
26
+ TASK_DONE,
27
+ TASK_SERIAL_PENDING,
28
+ engineConsumersOf,
29
+ engineDefinitionHits,
30
+ engineDefinitionModule,
31
+ engineScriptTexts,
32
+ dropNamedImport,
33
+ handoffFor,
34
+ makeTmp,
35
+ runPlanExit,
36
+ writeIntakeArtifacts,
37
+ } from '../lib/test-fixtures.mjs';
38
+ import {
39
+ assertRevocationAudit,
40
+ readScenarioState,
41
+ runGuardWithProtocol,
42
+ runStateWithProtocol,
43
+ scenarioProtocolPath,
44
+ } from '../lib/test-assertions.mjs';
45
+ import {
46
+ singleSourceImportProblems,
47
+ skillLoadingWordingProblems,
48
+ twoLayerEntryProblems,
49
+ } from '../lib/text-anchor-checks.mjs';
50
+
51
+ export const ENTRIES = [
52
+
53
+ // ---------- 场景(mechanism-skill-robustness 试先行 RED:共享判定单一来源 / --json-file 消息分级 /
54
+ // 启发式安全侧边界锚定 / 零提交正式语义 / SUMMARY·TASK7·三文档模板保真 / 技能加载前置门 /
55
+ // next·entry 输出点名 / 技能加载措辞 / next 进行中节点保护扩展) ----------
56
+
57
+ // 156: 疑似对象启发式安全侧边界锚定(设计语义 / AC-4)——内联纯文本恰好以 [ 开头 → 启发式判为
58
+ // 疑似对象、JSON.parse 失败 → fail-closed(exit 1 + 提示、不落库)。当前即如此 → 本场景 GREEN
59
+ {
60
+ name: '156 启发式安全侧边界:内联纯文本以 [ 开头 → fail-closed(锚定现状)',
61
+ run: (dir) => {
62
+ const st = baseState('open');
63
+ st.evidence.open = { summary: 'intake complete' };
64
+ writeState(dir, st);
65
+ const res = runStateWithProtocol(dir, ['record', 'open', '[plain-text-not-json']);
66
+ assertExit(res, 1);
67
+ if (!/--json-file|not valid JSON|不是合法 JSON/.test(res.output)) {
68
+ throw new Error('fail-closed 应有提示(--json-file / not valid JSON / 不是合法 JSON),实际输出: ' + res.output);
69
+ }
70
+ // fail-closed:evidence 不被污染
71
+ const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
72
+ if (!st2.evidence.open || st2.evidence.open.summary !== 'intake complete') {
73
+ throw new Error('纯文本以 [ 开头应 fail-closed 不落库,state 被污染: ' + JSON.stringify(st2.evidence.open));
74
+ }
75
+ },
76
+ },
77
+
78
+ // 157: 零提交任务正例(设计语义 / AC-5 / AC-7)——① request write_files 为空 + 契约显式 noCommit +
79
+ // result 无任何提交 → 跳过提交文件子集校验并输出可审计"零提交"提示(不误 BLOCK);
80
+ // ② 真实 request(F-6):临时 git 仓 + .gitignore 忽略 .specs/,TASK write_files 全为字面
81
+ // .specs/... 路径 → 引擎记 handoffRequests.<id>.noCommit=true(可证明全部 gitignored);
82
+ // result 回传无 commitHash 的零提交契约 → 记录成功、输出"零提交"、无 HANDOFF ERROR。
83
+ // 修复前 request 只认「<write_files> 元素存在且为空」→ ② 无 noCommit → 预期 RED。
84
+ {
85
+ name: '157 零提交正例:空 write_files 跳过校验;全字面 gitignored 真实 request 记 noCommit',
86
+ run: (dir) => {
87
+ // ① 空 write_files 既有正例(request 落库夹具;零回归锚)
88
+ const st = baseState('subagent-execute');
89
+ st.newChange = true;
90
+ st.evidence['subagent-execute'] = { handoffRequests: { T01: { description: 'zero-commit task', writeFiles: [] } } };
91
+ writeState(dir, st);
92
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n<task id="T01" status="done"><action>only docs already tracked</action><write_files></write_files><verify>node --check src/t1.mjs</verify></task>\n');
93
+ const res = runHandoff(['result', 'T01', JSON.stringify({
94
+ status: 'DONE', taskId: 'T01', noCommit: true,
95
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
96
+ redEvidence: { command: 'node --check src/t1.mjs', output: 'no output(RED 锚点)' },
97
+ greenEvidence: { command: 'node --check src/t1.mjs', output: 'ok' },
98
+ })], dir);
99
+ assertExit(res, 0);
100
+ assertOut(res, '零提交');
101
+ // ② 全字面 gitignored 正例:临时 git 仓 + .gitignore 忽略 .specs/;真实 request 自动解析 TASK.md
102
+ execFileSync('git', ['init'], { cwd: dir, stdio: 'ignore' });
103
+ const git = (...args) => execFileSync('git', args, { cwd: dir, stdio: 'ignore' });
104
+ writeFile(dir, '.gitignore', '.specs/\n');
105
+ writeFile(dir, 'baseline.js', 'export const baseline = 1;\n');
106
+ git('add', '.gitignore', 'baseline.js');
107
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '-m', 'init baseline');
108
+ // write_files 全为字面 .specs/...(被 .gitignore 忽略;不要求预先存在——check-ignore 按规则判)
109
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
110
+ + '<task id="T02" status="done"><action>写变更内部面工件</action>'
111
+ + '<write_files>\n.specs/' + CHANGE_ID + '/notes/T02.md\n.specs/' + CHANGE_ID + '/T02-SUMMARY.md\n</write_files>'
112
+ + '<verify>node --check baseline.js</verify></task>\n');
113
+ fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
114
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/subagent-execute-flow-comet-dev.json',
115
+ JSON.stringify({ node: 'subagent-execute', skill: 'flow-comet-dev', protocol: '4-dev.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
116
+ const st2 = baseState('subagent-execute');
117
+ st2.newChange = true;
118
+ writeState(dir, st2);
119
+ const resReq = runHandoff(['request', 'T02', 'delegate docs-only slice'], dir);
120
+ assertExit(resReq, 0);
121
+ assertOut(resReq, 'HANDOFF REQUEST: T02');
122
+ // 先断资格落库(RED 取证点:修复前 request 只认空 write_files → 此断言先红),后断审计文案
123
+ const stAfter = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
124
+ const req = stAfter.evidence['subagent-execute'].handoffRequests.T02;
125
+ if (!req || req.noCommit !== true) {
126
+ throw new Error('全字面 gitignored write_files 应记 noCommit:true,实际 ' + JSON.stringify(req));
127
+ }
128
+ assertOut(resReq, '零提交资格');
129
+ const resZero = runHandoff(['result', 'T02', JSON.stringify({
130
+ status: 'DONE', taskId: 'T02', noCommit: true,
131
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
132
+ redEvidence: { command: 'node --check baseline.js', output: 'no output(RED 锚点)' },
133
+ greenEvidence: { command: 'node --check baseline.js', output: 'ok' },
134
+ })], dir);
135
+ assertExit(resZero, 0);
136
+ assertOut(resZero, '零提交');
137
+ assertNotOut(resZero, 'HANDOFF ERROR');
138
+ // ③ m-13 result 重验失败(.gitignore 变化)新 change:HANDOFF ERROR + request.noCommit 置 false
139
+ // + 不落/不覆盖 result(资格建立后把 .specs/ 从忽略规则移除 → 重验失败)
140
+ const statePath = path.join(dir, '.flow-comet', 'flow-comet-state.json');
141
+ const priorCompletedAt = JSON.parse(fs.readFileSync(statePath, 'utf8'))
142
+ .evidence['subagent-execute'].handoffResult.T02.completedAt;
143
+ writeFile(dir, '.gitignore', 'baseline-only\n');
144
+ const resRevalBlock = runHandoff(['result', 'T02', JSON.stringify({
145
+ status: 'DONE', taskId: 'T02', noCommit: true,
146
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
147
+ redEvidence: { command: 'node --check baseline.js', output: 'ok' },
148
+ greenEvidence: { command: 'node --check baseline.js', output: 'ok' },
149
+ })], dir);
150
+ assertExit(resRevalBlock, 1);
151
+ assertOut(resRevalBlock, 'HANDOFF ERROR');
152
+ assertOut(resRevalBlock, 'noCommit=false');
153
+ assertOut(resRevalBlock, '不落 result');
154
+ const stRevalBlock = JSON.parse(fs.readFileSync(statePath, 'utf8'));
155
+ const reqBlocked = stRevalBlock.evidence['subagent-execute'].handoffRequests.T02;
156
+ if (!reqBlocked || reqBlocked.noCommit !== false) {
157
+ throw new Error('result 重验失败应把 request.noCommit 置 false,实际 ' + JSON.stringify(reqBlocked));
158
+ }
159
+ if (stRevalBlock.evidence['subagent-execute'].handoffResult.T02.completedAt !== priorCompletedAt) {
160
+ throw new Error('新 change result 重验失败不得覆盖既有 handoffResult(completedAt 变化)');
161
+ }
162
+ // F6 审计:忽略规则变化(过期资格)撤销必须留 at/reason,且失败类别与既有归类一致
163
+ assertRevocationAudit(reqBlocked, 'stale-eligibility', '157③ 新 change .gitignore 变化');
164
+ assertOut(resRevalBlock, 'revokedAt=');
165
+ assertOut(resRevalBlock, 'revokeReason=stale-eligibility');
166
+ // ④ 旧 change 同构造:HANDOFF WARN + 照常落 result + noCommit 同样置 false(渐进兼容)
167
+ writeFile(dir, '.gitignore', '.specs/\n'); // 恢复忽略规则 → 重新 request 取得资格
168
+ const stReReq = JSON.parse(fs.readFileSync(statePath, 'utf8'));
169
+ delete stReReq.newChange; // 旧 change = 缺省/null(validator 不接受 false)
170
+ writeState(dir, stReReq);
171
+ assertExit(runHandoff(['request', 'T02', 'delegate docs-only slice again'], dir), 0);
172
+ const stReReqAfter = JSON.parse(fs.readFileSync(statePath, 'utf8'));
173
+ if (stReReqAfter.evidence['subagent-execute'].handoffRequests.T02.noCommit !== true) {
174
+ throw new Error('恢复忽略规则后重新 request 应重新取得 noCommit 资格,实际 '
175
+ + JSON.stringify(stReReqAfter.evidence['subagent-execute'].handoffRequests.T02));
176
+ }
177
+ const legacyCompletedAt = stReReqAfter.evidence['subagent-execute'].handoffResult.T02.completedAt;
178
+ writeFile(dir, '.gitignore', 'baseline-only\n');
179
+ const resRevalWarn = runHandoff(['result', 'T02', JSON.stringify({
180
+ status: 'DONE', taskId: 'T02', noCommit: true,
181
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
182
+ redEvidence: { command: 'node --check baseline.js', output: 'ok' },
183
+ greenEvidence: { command: 'node --check baseline.js', output: 'ok' },
184
+ })], dir);
185
+ assertExit(resRevalWarn, 0);
186
+ assertOut(resRevalWarn, 'HANDOFF WARN');
187
+ assertOut(resRevalWarn, 'noCommit=false');
188
+ const stRevalWarn = JSON.parse(fs.readFileSync(statePath, 'utf8'));
189
+ if (stRevalWarn.evidence['subagent-execute'].handoffRequests.T02.noCommit !== false) {
190
+ throw new Error('旧 change 重验失败同样应撤销 request.noCommit,实际 '
191
+ + JSON.stringify(stRevalWarn.evidence['subagent-execute'].handoffRequests.T02));
192
+ }
193
+ // F6 审计:旧 change 渐进撤销同样必须留 at/reason(与失败类别对应)
194
+ assertRevocationAudit(stRevalWarn.evidence['subagent-execute'].handoffRequests.T02,
195
+ 'stale-eligibility', '157④ 旧 change .gitignore 变化');
196
+ assertOut(resRevalWarn, 'revokeReason=stale-eligibility');
197
+ const legacyResult = stRevalWarn.evidence['subagent-execute'].handoffResult.T02;
198
+ if (!legacyResult || legacyResult.completedAt === legacyCompletedAt || legacyResult.result.noCommit !== true) {
199
+ throw new Error('旧 change 重验失败应照常落 result(渐进),实际 ' + JSON.stringify(legacyResult));
200
+ }
201
+ },
202
+ },
203
+
204
+ // 158: 零提交滥用负例(设计语义 / AC-6 / AC-8)——① write_files 非空任务的结果契约声称 noCommit
205
+ // → 不得借零提交声明绕过真实提交检查:仍走完整提交文件子集校验(越界 → 新 change BLOCK),且输出
206
+ // 可审计的"零提交声明与 write_files 非空矛盾"提示;
207
+ // ② F-6 请求侧 fail-closed:glob 魔法 / 路径越界(../)/ 非 git 仓 / 非 git top-level 的 runRoot
208
+ // → request 不记 noCommit(不阻断原流程、仍记 writeFiles);
209
+ // ③ 请求无资格 + 契约声称 noCommit → 仍完整校验(WARN + 越界 BLOCK,零提交声明无效)。
210
+ {
211
+ name: '158 零提交滥用负例:非空声称 noCommit 仍完整校验;glob/越界/非 git/非 top-level 请求不记 noCommit',
212
+ run: (dir) => {
213
+ const g = (args) => spawnSync('git', args, { cwd: dir, encoding: 'utf8' });
214
+ g(['init', '-q']);
215
+ g(['config', 'user.email', 't@t']);
216
+ g(['config', 'user.name', 't']);
217
+ writeFile(dir, 'allowed.js', 'export const allowed = 1;\n');
218
+ writeFile(dir, 'rogue.js', 'export const rogue = 1;\n');
219
+ g(['add', 'allowed.js', 'rogue.js']);
220
+ g(['commit', '-qm', 'init']);
221
+ const hash = g(['rev-parse', 'HEAD']).stdout.trim();
222
+ const st = baseState('subagent-execute');
223
+ st.newChange = true;
224
+ st.evidence['subagent-execute'] = { handoffRequests: { T01: { description: 'normal task', writeFiles: ['allowed.js'] } } };
225
+ writeState(dir, st);
226
+ const res = runHandoff(['result', 'T01', JSON.stringify({
227
+ status: 'DONE', taskId: 'T01', noCommit: true, commitHash: hash,
228
+ changedFiles: ['allowed.js', 'rogue.js'],
229
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
230
+ redEvidence: { command: 'node --check allowed.js', output: 'no output(RED 锚点)' },
231
+ greenEvidence: { command: 'node --check allowed.js', output: 'ok' },
232
+ })], dir);
233
+ assertExit(res, 1);
234
+ assertOut(res, '超出 writeFiles 范围');
235
+ assertOut(res, '零提交');
236
+ // ② F-6 请求侧 fail-closed:不具资格形态 → request 不记 noCommit、不阻断原流程。
237
+ // 夹具加强:.gitignore 同时忽略 src/gen/ 与 .specs/——globs/子目录锚的路径在缺判定时会
238
+ // 被 git check-ignore 命中,故必须由字面/包含判定本身拒绝,锚才具备判别力(可反向构造红)。
239
+ writeFile(dir, '.gitignore', 'src/gen/\n.specs/\n');
240
+ // 请求夹具(旧 change 语义:技能加载门 WARN 渐进,不干扰本锚)
241
+ writeState(dir, baseState('subagent-execute'));
242
+ const readReq = (id) => {
243
+ const s = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
244
+ return (s.evidence['subagent-execute'].handoffRequests || {})[id];
245
+ };
246
+ const requestWithWriteFiles = (id, writeFilesElement) => {
247
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
248
+ + '<task id="' + id + '" status="done"><action>边界任务</action>'
249
+ + '<write_files>' + writeFilesElement + '</write_files>'
250
+ + '<verify>node --check allowed.js</verify></task>\n');
251
+ const r = runHandoff(['request', id, 'boundary slice'], dir);
252
+ assertExit(r, 0);
253
+ return r;
254
+ };
255
+ // ②a glob 魔法 `*` → 无可证明资格(不展开 glob、不享受零提交)
256
+ const resGlob = requestWithWriteFiles('T02', 'src/gen/*.mjs');
257
+ assertNotOut(resGlob, 'HANDOFF ERROR');
258
+ const reqGlob = readReq('T02');
259
+ if (!reqGlob || reqGlob.noCommit === true) {
260
+ throw new Error('glob write_files 不应具备零提交资格,实际 ' + JSON.stringify(reqGlob));
261
+ }
262
+ if (!Array.isArray(reqGlob.writeFiles) || reqGlob.writeFiles[0] !== 'src/gen/*.mjs') {
263
+ throw new Error('不具资格也不得丢失 writeFiles 记录: ' + JSON.stringify(reqGlob.writeFiles));
264
+ }
265
+ // ②b 路径越界(../ 逃逸 runRoot)→ 无资格
266
+ requestWithWriteFiles('T03', '../../outside.md');
267
+ const reqEscape = readReq('T03');
268
+ if (!reqEscape || reqEscape.noCommit === true) {
269
+ throw new Error('../ 逃逸 write_files 不应具备零提交资格,实际 ' + JSON.stringify(reqEscape));
270
+ }
271
+ // ②c 非 git 仓(独立临时目录,无 .git)→ 无资格;场景自建临时目录须自清理
272
+ //(运行器只回收场景主目录;残留校验会抓走漏——故 try/finally 内自删)
273
+ const nonGit = makeTmp();
274
+ try {
275
+ writeFile(nonGit, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
276
+ + '<task id="T04" status="done"><action>边界任务</action>'
277
+ + '<write_files>.specs/' + CHANGE_ID + '/x.md</write_files>'
278
+ + '<verify>node --check allowed.js</verify></task>\n');
279
+ writeState(nonGit, baseState('subagent-execute'));
280
+ const resNonGit = runHandoff(['request', 'T04', 'non-git slice'], nonGit);
281
+ assertExit(resNonGit, 0);
282
+ const stNonGit = JSON.parse(fs.readFileSync(path.join(nonGit, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
283
+ const reqNonGit = stNonGit.evidence['subagent-execute'].handoffRequests.T04;
284
+ if (!reqNonGit || reqNonGit.noCommit === true) {
285
+ throw new Error('非 git 仓不应具备零提交资格,实际 ' + JSON.stringify(reqNonGit));
286
+ }
287
+ } finally {
288
+ fs.rmSync(nonGit, { recursive: true, force: true });
289
+ }
290
+ // ②d runRoot 非 git top-level(仓内子目录)→ 无资格
291
+ writeFile(dir, 'sub/.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
292
+ + '<task id="T05" status="done"><action>边界任务</action>'
293
+ + '<write_files>.specs/' + CHANGE_ID + '/x.md</write_files>'
294
+ + '<verify>node --check allowed.js</verify></task>\n');
295
+ const sub = path.join(dir, 'sub');
296
+ writeState(sub, baseState('subagent-execute'));
297
+ const resSub = runHandoff(['request', 'T05', 'subdir slice'], sub);
298
+ assertExit(resSub, 0);
299
+ const stSub = JSON.parse(fs.readFileSync(path.join(sub, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
300
+ const reqSub = stSub.evidence['subagent-execute'].handoffRequests.T05;
301
+ if (!reqSub || reqSub.noCommit === true) {
302
+ throw new Error('runRoot 非 git top-level 不应具备零提交资格,实际 ' + JSON.stringify(reqSub));
303
+ }
304
+ // ②e/②f m-13 symlink/junction 逃逸(Windows junction 先例):request 时刻逐段 lstat
305
+ // 拒绝 symlink/junction 祖先;result 时刻对资格重验——资格建立后把真实目录替换为
306
+ // junction 指向 runRoot 外 → 新 change HANDOFF ERROR、noCommit 撤销、不落 result。
307
+ const outsideDir = makeTmp();
308
+ const linkPathA = path.join(dir, 'linked-out');
309
+ const linkPathB = path.join(dir, 'linked-out2');
310
+ const linkType = process.platform === 'win32' ? 'junction' : 'dir';
311
+ try {
312
+ writeFile(outsideDir, 'escape.md', 'outside\n');
313
+ // ②e request 资格拒绝:write_files 祖先段为 junction(目标在 runRoot 外),即使
314
+ // .gitignore 命中该路径也不得授予零提交(旧实现只看 check-ignore → noCommit:true = RED)
315
+ fs.symlinkSync(outsideDir, linkPathA, linkType);
316
+ writeFile(dir, '.gitignore', 'linked-out/\n');
317
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
318
+ + '<task id="T06" status="done"><action>symlink 边界任务</action>'
319
+ + '<write_files>linked-out/escape.md</write_files>'
320
+ + '<verify>node --check allowed.js</verify></task>\n');
321
+ writeState(dir, baseState('subagent-execute'));
322
+ const resLink = runHandoff(['request', 'T06', 'symlink slice'], dir);
323
+ assertExit(resLink, 0);
324
+ const stLink = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
325
+ const reqLink = stLink.evidence['subagent-execute'].handoffRequests.T06;
326
+ if (!reqLink || reqLink.noCommit === true) {
327
+ throw new Error('symlink/junction 祖先不得具备零提交资格(fail-closed),实际 ' + JSON.stringify(reqLink));
328
+ }
329
+ // ②f result 重验拒绝:先以真实目录建立资格,再把目录替换为 junction → 重验失败
330
+ writeFile(dir, 'linked-out2/escape.md', 'inside\n');
331
+ writeFile(dir, '.gitignore', 'linked-out2/\n');
332
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
333
+ + '<task id="T07" status="done"><action>junction 重验边界任务</action>'
334
+ + '<write_files>linked-out2/escape.md</write_files>'
335
+ + '<verify>node --check allowed.js</verify></task>\n');
336
+ fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
337
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/subagent-execute-flow-comet-dev.json',
338
+ JSON.stringify({ node: 'subagent-execute', skill: 'flow-comet-dev', protocol: '4-dev.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
339
+ const stReqLink = baseState('subagent-execute');
340
+ stReqLink.newChange = true;
341
+ writeState(dir, stReqLink);
342
+ const resReqLink = runHandoff(['request', 'T07', 'junction revalidate slice'], dir);
343
+ assertExit(resReqLink, 0);
344
+ const stReqLinkAfter = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
345
+ if (stReqLinkAfter.evidence['subagent-execute'].handoffRequests.T07.noCommit !== true) {
346
+ throw new Error('真实目录 + 命中忽略规则时 request 应取得 noCommit 资格,实际 '
347
+ + JSON.stringify(stReqLinkAfter.evidence['subagent-execute'].handoffRequests.T07));
348
+ }
349
+ fs.rmSync(linkPathB, { recursive: true, force: true });
350
+ fs.symlinkSync(outsideDir, linkPathB, linkType);
351
+ const resRevalLink = runHandoff(['result', 'T07', JSON.stringify({
352
+ status: 'DONE', taskId: 'T07', noCommit: true,
353
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
354
+ redEvidence: { command: 'node --check allowed.js', output: 'ok' },
355
+ greenEvidence: { command: 'node --check allowed.js', output: 'ok' },
356
+ })], dir);
357
+ assertExit(resRevalLink, 1);
358
+ assertOut(resRevalLink, 'HANDOFF ERROR');
359
+ assertOut(resRevalLink, 'noCommit=false');
360
+ const stRevalLink = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
361
+ if (stRevalLink.evidence['subagent-execute'].handoffRequests.T07.noCommit !== false) {
362
+ throw new Error('junction 逃逸重验失败应撤销 request.noCommit,实际 '
363
+ + JSON.stringify(stRevalLink.evidence['subagent-execute'].handoffRequests.T07));
364
+ }
365
+ // F6 审计:symlink/junction 逃逸撤销留 at/reason,类别与既有失败归类一致
366
+ assertRevocationAudit(stRevalLink.evidence['subagent-execute'].handoffRequests.T07,
367
+ 'symlink-junction-escape', '158②f junction/symlink 重验');
368
+ assertOut(resRevalLink, 'revokeReason=symlink-junction-escape');
369
+ if (stRevalLink.evidence['subagent-execute'].handoffResult?.T07) {
370
+ throw new Error('junction 逃逸重验失败不得落 handoffResult');
371
+ }
372
+ } finally {
373
+ for (const linkPath of [linkPathA, linkPathB]) {
374
+ try { fs.unlinkSync(linkPath); } catch { try { fs.rmdirSync(linkPath); } catch { /* 已移除 */ } }
375
+ }
376
+ fs.rmSync(outsideDir, { recursive: true, force: true });
377
+ }
378
+ // ③ 请求无资格(glob)+ 契约声称 noCommit → 仍完整提交文件子集校验(越界新 change BLOCK)
379
+ const stIneligible = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
380
+ stIneligible.newChange = true;
381
+ writeState(dir, stIneligible);
382
+ writeFile(dir, 'src/deep/rogue.js', 'export const deepRogue = 1;\n');
383
+ g(['add', 'src/deep/rogue.js']);
384
+ g(['commit', '-qm', 'deep rogue']);
385
+ const deepHash = g(['rev-parse', 'HEAD']).stdout.trim();
386
+ const resIneligible = runHandoff(['result', 'T02', JSON.stringify({
387
+ status: 'DONE', taskId: 'T02', noCommit: true, commitHash: deepHash,
388
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
389
+ redEvidence: { command: 'node --check allowed.js', output: 'ok' },
390
+ greenEvidence: { command: 'node --check allowed.js', output: 'ok' },
391
+ })], dir);
392
+ assertExit(resIneligible, 1);
393
+ assertOut(resIneligible, '契约声明零提交但 write_files 非空');
394
+ assertOut(resIneligible, '超出 writeFiles 范围');
395
+ },
396
+ },
397
+
398
+ // 159: SUMMARY 模板保真(设计语义 / AC-7)——execute 出口每份 *-SUMMARY.md 须含 `# SUMMARY:` 标题 +
399
+ // 首部 4 字段(Change ID/Task ID/完成时间/AI 角色)+ 段序(含 flow-comet 增量 ## 自检方法 段)。
400
+ // 缺任一:新 change BLOCK(exit 1 + 缺失点与恢复指引);合法变体(编号前缀/括号后缀/大小写)通过;
401
+ // 旧 change → WARN 渐进。当前 guard 只查 verify输出/6维自查/越界检查 3 段存在 → 缺标题等场景 RED。
402
+ // ⑫⑬ 追加 6 维自查段提取的段尾判定回归锚(段内大写 Z 早于方法名 ⇒ 不得误拦;方法声明真缺席 ⇒
403
+ // 仍须 BLOCK)——与模板保真共用同一新 change 严格出口链路。
404
+ {
405
+ name: '159 execute exit SUMMARY 模板保真:缺标题/首部/段序新 BLOCK,合法变体通过,旧 WARN;6 维段内大写 Z 不误拦 + 未声明仍 BLOCK',
406
+ run: (dir) => {
407
+ const marker = () => {
408
+ fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
409
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/execute-flow-comet-dev.json',
410
+ JSON.stringify({ node: 'execute', skill: 'flow-comet-dev', protocol: '4-dev.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
411
+ };
412
+ const header = [
413
+ '- **Change ID**: ' + CHANGE_ID,
414
+ '- **Task ID**: T01',
415
+ '- **完成时间**: 2026-08-20 10:00',
416
+ '- **AI 角色**: Dev',
417
+ ].join('\n');
418
+ const sectionText = {
419
+ what: '## 做了什么\n\n实现 T01(TDD:先写失败场景再实现)。',
420
+ files: '## 改动文件\n\n| 文件 | 性质 | 说明 |\n|---|---|---|\n| src/t1.mjs | 修改 | 实现 T01 |',
421
+ verify: '## verify 输出\n\n```\nnode --check src/t1.mjs\n```',
422
+ sixDim: '## 6 维自查\n\n- 功能: 通过(brooks-review 已跑)\n- 性能: 无影响\n- 安全: 无影响\n- 兼容: 通过\n- 可观测: 通过\n- 可维护: 通过'
423
+ + '\n\n### 已知接受 + 理由\n\n- 无(夹具)。\n\n### 已知小问题\n\n- 无(夹具)。',
424
+ db: '## 数据库迁移\n\nN/A:本任务无 schema 变更。',
425
+ bounds: '## 越界检查\n\n仅修改 src/t1.mjs,无越界。',
426
+ breaking: '## 破坏性变更\n\nN/A:本任务不涉及破坏性变更。',
427
+ deviation: '## 决策与偏离\n\n无偏离。',
428
+ newWork: '## 是否触发新工作\n\n无。',
429
+ done: '## 完成判定\n\n- TASK.md 中对应任务已勾选:是',
430
+ method: '## 自检方法\n\nbrooks-review',
431
+ // LESSONS 扫描 = 登记的增量段(位于自检方法之后或文末)——SUMMARY 出口的必填增量段,
432
+ // 夹具缺它会被增量段门禁拦下,掩盖本场景被测的标题/首部/段序判据。
433
+ lessons: '## LESSONS 扫描\n\n无 active 条目命中(夹具)。',
434
+ };
435
+ // 模板序 = flow-kit/templates/SUMMARY.md 全部 H2(含 5 个条件段);## 自检方法 不属骨架,
436
+ // 单独按位置校核(紧随 ## 越界检查、或位于骨架段全部之后两种合法位置;其后允许跟登记的
437
+ // 增量段 ## LESSONS 扫描)。
438
+ const skeletonOrder = [sectionText.what, sectionText.files, sectionText.verify, sectionText.sixDim,
439
+ sectionText.db, sectionText.bounds, sectionText.breaking, sectionText.deviation, sectionText.newWork, sectionText.done];
440
+ const fullSections = [...skeletonOrder, sectionText.method, sectionText.lessons]; // 自检方法在骨架段之后(合法位置一)
441
+ const afterBoundsSections = [
442
+ ...skeletonOrder.slice(0, 6), sectionText.method, sectionText.lessons, ...skeletonOrder.slice(6),
443
+ ]; // 紧随越界(合法位置二)
444
+ const illegalSelfSections = [
445
+ ...skeletonOrder.slice(0, 4), sectionText.method, sectionText.lessons, ...skeletonOrder.slice(4),
446
+ ]; // 自检方法夹在中间(非法)
447
+ const missingTailSections = [...skeletonOrder.slice(0, 9), sectionText.method, sectionText.lessons]; // 缺尾段 完成判定
448
+ const outOfOrderSections = [
449
+ ...skeletonOrder.slice(0, 5), sectionText.bounds, sectionText.db, ...skeletonOrder.slice(6),
450
+ sectionText.method, sectionText.lessons,
451
+ ]; // 数据库迁移排到越界检查之后(段序偏离)
452
+ const compose = (title, order) =>
453
+ [title, '', header, '', '---', '', order.join('\n\n')].join('\n');
454
+ const setupExecute = (newChange) => {
455
+ const st = baseState('execute');
456
+ st.evidence.execute = { summary: 'executed' };
457
+ st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
458
+ if (newChange) { st.newChange = true; st.enteredNodes = ['execute']; }
459
+ writeState(dir, st);
460
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
461
+ marker();
462
+ };
463
+ // ① 新 change:缺 `# SUMMARY:` 标题(段齐全)→ BLOCK
464
+ setupExecute(true);
465
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# T01-SUMMARY', fullSections));
466
+ const res1 = runGuard(['exit', 'execute'], dir);
467
+ assertExit(res1, 1);
468
+ assertOut(res1, 'BLOCKED');
469
+ assertOut(res1, '# SUMMARY:');
470
+ // ② 新 change:标题在但首部缺字段(仅 2 字段)→ BLOCK
471
+ const headerMissing = [
472
+ '- **Change ID**: ' + CHANGE_ID,
473
+ '- **Task ID**: T01',
474
+ ].join('\n');
475
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
476
+ ['# SUMMARY: T01 - 实现 T01', '', headerMissing, '', '---', '', fullSections.join('\n\n')].join('\n'));
477
+ const res2 = runGuard(['exit', 'execute'], dir);
478
+ assertExit(res2, 1);
479
+ assertOut(res2, 'BLOCKED');
480
+ // ③ 新 change:段序乱(自检方法提前、做了什么滞后)→ BLOCK
481
+ const scrambled = [
482
+ sectionText.verify, sectionText.bounds, sectionText.sixDim, sectionText.method, sectionText.lessons,
483
+ sectionText.what, sectionText.files, sectionText.db, sectionText.breaking,
484
+ sectionText.deviation, sectionText.newWork, sectionText.done,
485
+ ];
486
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# SUMMARY: T01 - 实现 T01', scrambled));
487
+ const res3 = runGuard(['exit', 'execute'], dir);
488
+ assertExit(res3, 1);
489
+ assertOut(res3, 'BLOCKED');
490
+ // ④ 合法变体:大小写(# Summary: …)→ 通过
491
+ setupExecute(true);
492
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# Summary: T01 - 实现 T01', fullSections));
493
+ const res4 = runGuard(['exit', 'execute'], dir);
494
+ assertExit(res4, 0);
495
+ assertOut(res4, 'ALL CHECKS PASSED');
496
+ // ⑤ 合法变体:括号后缀 → 通过
497
+ setupExecute(true);
498
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# SUMMARY: T01 - 实现 T01(含说明括号)', fullSections));
499
+ const res5 = runGuard(['exit', 'execute'], dir);
500
+ assertExit(res5, 0);
501
+ assertOut(res5, 'ALL CHECKS PASSED');
502
+ // ⑥ 旧 change:缺标题 → WARN 渐进不阻断
503
+ setupExecute(false);
504
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# T01-SUMMARY', fullSections));
505
+ const res6 = runGuard(['exit', 'execute'], dir);
506
+ assertExit(res6, 0);
507
+ assertOut(res6, 'WARN');
508
+ // ⑦ 起:写入 SUMMARY 模板副本——M1 全骨架硬阻断只在 runRoot 内存在
509
+ // flow-kit/templates/SUMMARY.md 时生效(模板缺失仅内置骨架提示,不新增 BLOCK)。
510
+ // 维护者工作副本含 vendored flow-kit → 复制真实模板;CI 全新检出 flow-kit 被
511
+ // .gitignore 排除(不可分发)→ 用与真实模板 H2 逐字对齐的内置镜像(skeleton 派生结果
512
+ // 等价),保证硬阻断锚在两级载体都可执行、不静默跳过。
513
+ const realSummaryTemplate = path.join(REPO_ROOT, 'flow-kit', 'templates', 'SUMMARY.md');
514
+ const summaryTemplateFixture = fs.existsSync(realSummaryTemplate)
515
+ ? fs.readFileSync(realSummaryTemplate, 'utf8')
516
+ : [
517
+ '# SUMMARY: <T01 - 任务名>',
518
+ '',
519
+ '## 做了什么(一段话)',
520
+ '',
521
+ '## 改动文件',
522
+ '',
523
+ '## verify 输出(必填)',
524
+ '',
525
+ '## 6 维自查(生产代码改动必填 · 来自 4-dev 步骤 4)',
526
+ '',
527
+ '## 数据库迁移(涉及 schema 变更必填 · 来自 4-dev 步骤 1.7 / R4.5)',
528
+ '',
529
+ '## 越界检查(必填 · 来自 4-dev 步骤 5 / R6.5 / B3 老项目护栏)',
530
+ '',
531
+ '## 破坏性变更(涉及破坏性改动必填 · 来自 4-dev 步骤 1.8 / R4.6 / B4 老项目护栏)',
532
+ '',
533
+ '## 决策与偏离(如有)',
534
+ '',
535
+ '## 是否触发新工作',
536
+ '',
537
+ '## 完成判定',
538
+ '',
539
+ ].join('\n');
540
+ writeFile(dir, 'flow-kit/templates/SUMMARY.md', summaryTemplateFixture);
541
+ // ⑦ 新 change 缺尾段(完成判定)→ BLOCK + 缺段 + 「补 N/A 段」恢复指引
542
+ setupExecute(true);
543
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# SUMMARY: T01 - 实现 T01', missingTailSections));
544
+ const res7 = runGuard(['exit', 'execute'], dir);
545
+ assertExit(res7, 1);
546
+ assertOut(res7, 'BLOCKED');
547
+ assertOut(res7, '完成判定');
548
+ assertOut(res7, 'N/A');
549
+ // ⑧ 段序偏离(数据库迁移排到越界检查之后)→ BLOCK + 段序 + 缺段点可定位
550
+ setupExecute(true);
551
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# SUMMARY: T01 - 实现 T01', outOfOrderSections));
552
+ const res8 = runGuard(['exit', 'execute'], dir);
553
+ assertExit(res8, 1);
554
+ assertOut(res8, 'BLOCKED');
555
+ assertOut(res8, '段序');
556
+ assertOut(res8, '数据库迁移');
557
+ // ⑨ 合法位置一:## 自检方法 位于文末 → 通过(真实模板在场)
558
+ setupExecute(true);
559
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# SUMMARY: T01 - 实现 T01', fullSections));
560
+ const res9 = runGuard(['exit', 'execute'], dir);
561
+ assertExit(res9, 0);
562
+ assertOut(res9, 'ALL CHECKS PASSED');
563
+ assertNotOut(res9, 'BLOCKED');
564
+ // ⑩ 合法位置二:## 自检方法 紧随 ## 越界检查 之后 → 通过(真实模板在场)
565
+ setupExecute(true);
566
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# SUMMARY: T01 - 实现 T01', afterBoundsSections));
567
+ const res10 = runGuard(['exit', 'execute'], dir);
568
+ assertExit(res10, 0);
569
+ assertOut(res10, 'ALL CHECKS PASSED');
570
+ assertNotOut(res10, 'BLOCKED');
571
+ // ⑪ 自检方法位置非法(夹在 6 维自查与数据库迁移之间)→ BLOCK
572
+ setupExecute(true);
573
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# SUMMARY: T01 - 实现 T01', illegalSelfSections));
574
+ const res11 = runGuard(['exit', 'execute'], dir);
575
+ assertExit(res11, 1);
576
+ assertOut(res11, 'BLOCKED');
577
+ assertOut(res11, '自检方法');
578
+ // ⑫ 6 维自查段提取的段尾判定(常驻回归锚 · 假阳性误拦位点):段内**早于**方法名出现大写 Z
579
+ // (机检标记字面量形态)——串尾若被写成字面字符 Z,惰性段体在段内首个 Z 处提前收尾,
580
+ // 段内的方法声明被截掉 ⇒ 出口误判「6 维自查未声明自检方法」而 BLOCK。
581
+ // 单变量对照:与 ⑨/⑩ 的无 Z 合规基线相比只多一行 Z 说明(同一份 dims 原文逐字不变),
582
+ // 两者都必须 PASS——即该行不得改变判定(既不放宽也不误拦)。
583
+ const zNote = '> 本任务 diff 属零逻辑改动(机检标记 ZERO-LOGIC-CHANGE-OK),按协议执行 PR Review。';
584
+ const withSixDim = (six) => fullSections.map((s) => (s === sectionText.sixDim ? six : s));
585
+ const sixDimZFirst = sectionText.sixDim.replace('## 6 维自查\n\n', '## 6 维自查\n\n' + zNote + '\n\n');
586
+ assertTrue(sixDimZFirst !== sectionText.sixDim, '单变量前提不成立:6 维自查段标题形态变化,Z 说明行未插入');
587
+ assertEqual(sixDimZFirst.replace('## 6 维自查\n\n' + zNote + '\n\n', '## 6 维自查\n\n'),
588
+ sectionText.sixDim, '单变量前提不成立:Z 说明行不是与无 Z 基线的唯一差异');
589
+ assertTrue(sixDimZFirst.indexOf(zNote) < sixDimZFirst.indexOf('brooks-review'),
590
+ '夹具形态前提不成立:Z 说明行须早于方法声明,否则段尾截断不影响该声明(锚零判别力)');
591
+ setupExecute(true);
592
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# SUMMARY: T01 - 实现 T01', fullSections));
593
+ const res12Base = runGuard(['exit', 'execute'], dir);
594
+ assertExit(res12Base, 0);
595
+ assertOut(res12Base, 'ALL CHECKS PASSED');
596
+ setupExecute(true);
597
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# SUMMARY: T01 - 实现 T01', withSixDim(sixDimZFirst)));
598
+ const res12 = runGuard(['exit', 'execute'], dir);
599
+ assertExit(res12, 0);
600
+ assertOut(res12, 'ALL CHECKS PASSED');
601
+ assertNotOut(res12, 'BLOCKED');
602
+ // ⑬ 判据未放宽对照 + 抽掉必报自证:同 ⑫ 夹具仅抽掉 6 维段内的方法声明行(其余逐字不变)
603
+ // ⇒ 6 维自查段确实未声明自检方法 ⇒ 仍须 BLOCK,且拦因须落在该判据上(而非段空 / 段缺席)。
604
+ const sixDimNoDecl = sixDimZFirst.replace('- 功能: 通过(brooks-review 已跑)', '- 功能: 通过(内置快查)');
605
+ assertTrue(sixDimNoDecl !== sixDimZFirst, '对照夹具前提不成立:6 维段内方法声明行未命中');
606
+ setupExecute(true);
607
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', compose('# SUMMARY: T01 - 实现 T01', withSixDim(sixDimNoDecl)));
608
+ const res13 = runGuard(['exit', 'execute'], dir);
609
+ assertExit(res13, 1);
610
+ assertOut(res13, '6 维自查未声明使用 /brooks-review');
611
+ },
612
+ },
613
+
614
+ // 160: plan exit TASK 7 字段完整性(设计语义 / AC-8)——每个 <task> 须含 name/read_files/
615
+ // write_files/action/verify/done/depends_on。缺任一:新 BLOCK;旧 WARN。当前 guard 只查
616
+ // <verify> 存在 → 缺 write_files 场景新 change 应 BLOCK 却放行 → 预期 RED。
617
+ {
618
+ name: '160 plan exit TASK 7 字段:缺 write_files 新 BLOCK / 旧 WARN',
619
+ run: (dir) => {
620
+ const missingWrite =
621
+ '<task id="T01" status="pending"><name>任务一</name><read_files>src/*</read_files><action>实现 T01</action><verify>node --check src/t1.mjs</verify><done>AC-1</done><depends_on></depends_on></task>\n';
622
+ const addPlanMarker = () => {
623
+ fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
624
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/plan-flow-comet-task.json',
625
+ JSON.stringify({ node: 'plan', skill: 'flow-comet-task', protocol: '3-task.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
626
+ };
627
+ // ① 新 change:缺 write_files → BLOCK(含字段名)
628
+ const st = baseState('plan');
629
+ st.evidence.plan = { summary: 'plan done' };
630
+ st.newChange = true;
631
+ writeState(dir, st);
632
+ addPlanMarker();
633
+ const res = runPlanExit(dir, missingWrite);
634
+ assertExit(res, 1);
635
+ assertOut(res, 'BLOCKED');
636
+ assertOut(res, 'write_files');
637
+ // ② 旧 change:同构造 → WARN 渐进不阻断
638
+ const stOld = baseState('plan');
639
+ stOld.evidence.plan = { summary: 'plan done' };
640
+ writeState(dir, stOld);
641
+ addPlanMarker();
642
+ const resOld = runPlanExit(dir, missingWrite);
643
+ assertExit(resOld, 0);
644
+ assertOut(resOld, 'WARN');
645
+ },
646
+ },
647
+
648
+ // 161: open/design 出口 CHANGE/REQUIREMENT/DESIGN 模板保真(设计语义 / AC-9)——标题
649
+ // (# CHANGE: / # REQUIREMENT: / # DESIGN:)+ 首部 + 段序(模板派生宽松匹配,编号前缀/括号
650
+ // 后缀/大小写兼容,防误拦)。缺任一:新 BLOCK;旧 WARN。当前 guard 只查 Why/用户故事/AC/
651
+ // 决策清单等单段存在 → 缺标题场景新 change 应 BLOCK 却放行 → 预期 RED。
652
+ {
653
+ name: '161 open/design 出口三文档模板保真:缺标题新 BLOCK / 旧 WARN',
654
+ run: (dir) => {
655
+ const addOpenMarker = () => {
656
+ fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
657
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
658
+ JSON.stringify({ node: 'open', skill: 'flow-comet-change', protocol: '0-change.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
659
+ };
660
+ const addDesignMarker = () => {
661
+ fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
662
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/design-flow-comet-design.json',
663
+ JSON.stringify({ node: 'design', skill: 'flow-comet-design', protocol: '2-design.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
664
+ };
665
+ // ① open 出口 新 change:REQUIREMENT 缺 `# REQUIREMENT:` 标题(段齐全)→ BLOCK
666
+ const stOpen = baseState('open');
667
+ stOpen.evidence.open = { summary: 'intake complete' };
668
+ stOpen.newChange = true;
669
+ stOpen.enteredNodes = ['open'];
670
+ writeState(dir, stOpen);
671
+ addOpenMarker();
672
+ writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# 变更文档\n\n## Why(为什么做)\n\n原因。\n\n## 范围(Scope)\n');
673
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# 需求文档\n\n## 用户故事\n\n- US-1 作为维护者……\n\n## 验收准则(AC)\n\n- Given X When Y Then Z\n');
674
+ const resOpen = runGuard(['exit', 'open'], dir);
675
+ assertExit(resOpen, 1);
676
+ assertOut(resOpen, 'BLOCKED');
677
+ assertOut(resOpen, 'REQUIREMENT');
678
+ // ② design 出口 新 change:DESIGN 缺 `# DESIGN:` 标题(段齐全)→ BLOCK
679
+ const stDesign = baseState('design');
680
+ stDesign.evidence.design = { summary: 'design done' };
681
+ stDesign.newChange = true;
682
+ stDesign.enteredNodes = ['design'];
683
+ writeState(dir, stDesign);
684
+ addDesignMarker();
685
+ writeFile(dir, 'flow-kit/templates/DESIGN.md', '# DESIGN 模板\n\n## 0. 技术栈选型\n## 1. 技术决策清单\n## 2. 数据流\n');
686
+ writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# 设计文档\n\n## 0. 技术栈选型\n\n- 选定:Node.js\n\n## 决策清单\n\n| # | 决策 | 选择 | 理由 |\n|---|---|---|---|\n| D1 | X | Y | Z |\n');
687
+ const resDesign = runGuard(['exit', 'design'], dir);
688
+ assertExit(resDesign, 1);
689
+ assertOut(resDesign, 'BLOCKED');
690
+ assertOut(resDesign, 'DESIGN');
691
+ // ③ 旧 change open 同构造(REQUIREMENT 缺标题)→ WARN 渐进不阻断
692
+ const stOld = baseState('open');
693
+ stOld.evidence.open = { summary: 'intake complete' };
694
+ writeState(dir, stOld);
695
+ addOpenMarker();
696
+ writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# 变更文档\n\n## Why(为什么做)\n\n原因。\n\n## 范围(Scope)\n');
697
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# 需求文档\n\n## 用户故事\n\n- US-1 作为维护者……\n\n## 验收准则(AC)\n\n- Given X When Y Then Z\n');
698
+ const resOld = runGuard(['exit', 'open'], dir);
699
+ assertExit(resOld, 0);
700
+ assertOut(resOld, 'WARN');
701
+ },
702
+ },
703
+
704
+ // 162: 技能加载前置门(设计语义 / AC-10)——新 change:handoff request 无本节点声明标记
705
+ // 应 BLOCK;record 无声明(payload 不含 completedChecks)应 BLOCK;旧 change → WARN 渐进。
706
+ // 当前 request 不查声明、record 靠 M5 自动补 → 不拦 → 预期 RED。
707
+ {
708
+ name: '162 技能加载前置门:request/record 无声明新 BLOCK / 旧 WARN',
709
+ run: (dir) => {
710
+ const env = { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) };
711
+ // ① handoff request 前置门:新 change、subagent-execute 节点无声明标记 → BLOCK
712
+ const stReq = baseState('subagent-execute');
713
+ stReq.newChange = true;
714
+ writeState(dir, stReq);
715
+ const resReq = runHandoff(['request', 'T01', 'delegate parallel task'], dir);
716
+ assertExit(resReq, 1);
717
+ assertOut(resReq, '先加载技能');
718
+ // ② record 前置门:新 change、plan 节点无声明标记、payload 不含 completedChecks → BLOCK
719
+ const stRec = baseState('plan');
720
+ stRec.newChange = true;
721
+ writeState(dir, stRec);
722
+ const resRec = runStateWithProtocol(dir, ['record', 'plan', '{"summary":"plan done"}']);
723
+ assertExit(resRec, 1);
724
+ assertOut(resRec, '先加载技能');
725
+ // ③ 旧 change:record 无声明 → WARN 渐进不阻断
726
+ const stOld = baseState('plan');
727
+ writeState(dir, stOld);
728
+ const resOld = runStateWithProtocol(dir, ['record', 'plan', '{"summary":"plan done"}']);
729
+ assertExit(resOld, 0);
730
+ assertOut(resOld, 'WARN');
731
+
732
+ // ===== M-02 request 时刻归属门禁(AC-2 不误伤面)=====
733
+ // 正确节点成功 / 串行错配 BLOCK / 未 entry WARN / done 与显式 write-files 旁路 /
734
+ // 协议无对应 enabled 节点跳过 / 协议不可读可见 WARN 后放行(不静默)。归属门禁位于
735
+ // 技能声明门之后——新 change 夹具必须放入本节点声明标记,否则先被技能门 BLOCK,
736
+ // 测不到归属门禁本身。
737
+ const writeMarker = (node) => {
738
+ fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
739
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/' + node + '-flow-comet-dev.json',
740
+ JSON.stringify({ node, skill: 'flow-comet-dev', protocol: '4-dev.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
741
+ };
742
+ const taskXml = (id, attrs, writeFiles) =>
743
+ '# TASK\n\n<task id="' + id + '" ' + attrs + '><action>实现 ' + id + '</action>'
744
+ + '<write_files>' + writeFiles + '</write_files><verify>node --check src/x.mjs</verify></task>\n';
745
+ const statePath = path.join(dir, '.flow-comet', 'flow-comet-state.json');
746
+ // ④ 正确节点(subagent-execute)+ pending 并行 → 成功落库(不误伤)
747
+ writeMarker('subagent-execute');
748
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskXml('P01', 'parallel="true" status="pending"', 'src/p01.mjs'));
749
+ const stOk = baseState('subagent-execute');
750
+ stOk.newChange = true;
751
+ stOk.enteredNodes = ['subagent-execute'];
752
+ writeState(dir, stOk);
753
+ const resOk = runHandoff(['request', 'P01', 'delegate'], dir, env);
754
+ assertExit(resOk, 0);
755
+ assertOut(resOk, 'HANDOFF REQUEST: P01');
756
+ const recOk = readScenarioState(dir).evidence?.['subagent-execute']?.handoffRequests?.P01;
757
+ if (!recOk) throw new Error('正确节点并行 pending 请求应成功落库,实际 ' + JSON.stringify(recOk));
758
+ // ⑤ 串行 pending 在 subagent-execute 请求(目标 execute 不匹配)→ BLOCK + 字节零改写
759
+ writeMarker('execute');
760
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskXml('S01', 'parallel="false" status="pending"', 'src/s01.mjs'));
761
+ const stSerial = baseState('subagent-execute');
762
+ stSerial.newChange = true;
763
+ stSerial.enteredNodes = ['subagent-execute'];
764
+ writeState(dir, stSerial);
765
+ const beforeSerial = fs.readFileSync(statePath, 'utf8');
766
+ const resSerial = runHandoff(['request', 'S01', 'serial slice'], dir, env);
767
+ assertExit(resSerial, 1);
768
+ assertOut(resSerial, 'BLOCKED: 任务 S01(串行 pending)应归属节点 execute');
769
+ assertOut(resSerial, 'entry execute');
770
+ if (fs.readFileSync(statePath, 'utf8') !== beforeSerial) {
771
+ throw new Error('串行错配 BLOCK 必须 state 字节零改写');
772
+ }
773
+ // ⑥ 正确节点但尚未 entry → 仅 WARN + 照常落库
774
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskXml('S02', 'parallel="false" status="pending"', 'src/s02.mjs'));
775
+ const stNotEntered = baseState('execute');
776
+ stNotEntered.newChange = true; // enteredNodes 缺 execute
777
+ writeState(dir, stNotEntered);
778
+ const resNotEntered = runHandoff(['request', 'S02', 'serial slice'], dir, env);
779
+ assertExit(resNotEntered, 0);
780
+ assertOut(resNotEntered, 'WARN: 任务 S02 的归属节点 execute 与原始 currentNode 一致');
781
+ assertOut(resNotEntered, '尚未 entry');
782
+ assertOut(resNotEntered, 'HANDOFF REQUEST: S02');
783
+ // ⑦ done 任务补录(非 pending)→ 归属门禁跳过,不误伤
784
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskXml('D01', 'parallel="true" status="done"', 'src/d01.mjs'));
785
+ const stDone = baseState('execute');
786
+ stDone.newChange = true;
787
+ stDone.enteredNodes = ['execute'];
788
+ writeState(dir, stDone);
789
+ const resDone = runHandoff(['request', 'D01', 'backfill'], dir, env);
790
+ assertExit(resDone, 0);
791
+ assertNotOut(resDone, 'BLOCKED');
792
+ assertOut(resDone, 'HANDOFF REQUEST: D01');
793
+ // ⑧ 显式 --write-files 且 TASK 无匹配任务 → 可见 WARN + 跳过归属门禁(不误伤)
794
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n<!-- 无匹配任务块 -->\n');
795
+ const stExplicit = baseState('execute');
796
+ stExplicit.newChange = true;
797
+ stExplicit.enteredNodes = ['execute'];
798
+ writeState(dir, stExplicit);
799
+ const resExplicit = runHandoff(['request', 'X01', 'explicit slice', '--write-files', 'src/x01.mjs'], dir, env);
800
+ assertExit(resExplicit, 0);
801
+ assertOut(resExplicit, '显式 --write-files 且 TASK.md 无匹配任务 X01');
802
+ assertOut(resExplicit, 'HANDOFF REQUEST: X01');
803
+ assertNotOut(resExplicit, 'BLOCKED');
804
+ // ⑨ 协议无对应 enabled 节点 → 跳过归属门禁(删除 subagent-execute 节点):驻留 execute
805
+ // 但任务为并行 pending——若实现不做协议感知会误判目标 subagent-execute ≠ execute 而 BLOCK
806
+ writeMarker('execute');
807
+ const proto = JSON.parse(fs.readFileSync(scenarioProtocolPath(dir), 'utf8'));
808
+ const noSubProto = { ...proto, nodes: proto.nodes.filter((n) => n.id !== 'subagent-execute') };
809
+ writeFile(dir, 'reference/protocol-nosub.json', JSON.stringify(noSubProto, null, 2) + '\n');
810
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskXml('P02', 'parallel="true" status="pending"', 'src/p02.mjs'));
811
+ const stNoSub = baseState('execute');
812
+ stNoSub.newChange = true;
813
+ stNoSub.enteredNodes = ['execute'];
814
+ writeState(dir, stNoSub);
815
+ const resNoSub = runHandoff(['request', 'P02', 'no-sub protocol'], dir,
816
+ { FLOW_COMET_PROTOCOL: path.join(dir, 'reference', 'protocol-nosub.json') });
817
+ assertExit(resNoSub, 0);
818
+ assertNotOut(resNoSub, 'BLOCKED');
819
+ assertNotOut(resNoSub, '本次未执行归属校验'); // 协议可读且无对应 enabled 节点 → 跳过校验,不产生归属 WARN
820
+ assertOut(resNoSub, 'HANDOFF REQUEST: P02');
821
+ // ⑩ 节点被 disabled → 同样跳过归属门禁
822
+ const disabledProto = { ...proto, nodes: proto.nodes.map((n) => (n.id === 'subagent-execute' ? { ...n, disabled: true } : n)) };
823
+ writeFile(dir, 'reference/protocol-disabled.json', JSON.stringify(disabledProto, null, 2) + '\n');
824
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskXml('P03', 'parallel="true" status="pending"', 'src/p03.mjs'));
825
+ const stDisabled = baseState('execute');
826
+ stDisabled.newChange = true;
827
+ stDisabled.enteredNodes = ['execute'];
828
+ writeState(dir, stDisabled);
829
+ const resDisabled = runHandoff(['request', 'P03', 'disabled protocol'], dir,
830
+ { FLOW_COMET_PROTOCOL: path.join(dir, 'reference', 'protocol-disabled.json') });
831
+ assertExit(resDisabled, 0);
832
+ assertNotOut(resDisabled, 'BLOCKED');
833
+ assertNotOut(resDisabled, '本次未执行归属校验'); // disabled 节点语义与缺节点一致 → 跳过校验且无归属 WARN
834
+ assertOut(resDisabled, 'HANDOFF REQUEST: P03');
835
+ // ⑪ pending 并行任务依赖未满足 → BLOCK 指引与 next 实际输出一致(next 按串行消化输出
836
+ // execute);依赖满足后按 next 输出进入委托节点,request 恢复成功——无 entry 死路。
837
+ writeIntakeArtifacts(dir);
838
+ const unmetDepsTask =
839
+ '<task id="S03" parallel="false" status="pending"><action>实现 S03</action><write_files>src/s03.mjs</write_files><verify>node --check src/s03.mjs</verify></task>\n' +
840
+ '<task id="P04" parallel="true" status="pending"><action>实现 P04</action><write_files>src/p04.mjs</write_files><verify>node --check src/p04.mjs</verify><depends_on>S03</depends_on></task>\n';
841
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + unmetDepsTask);
842
+ const stUnmet = baseState('execute');
843
+ stUnmet.newChange = true;
844
+ stUnmet.enteredNodes = ['execute'];
845
+ stUnmet.completedNodes = ['open', 'design', 'plan'];
846
+ stUnmet.evidence = { plan: { summary: 'plan done' } };
847
+ writeState(dir, stUnmet);
848
+ const unmetBytesBefore = fs.readFileSync(statePath, 'utf8');
849
+ const resUnmet = runHandoff(['request', 'P04', 'parallel slice with unmet deps'], dir, env);
850
+ assertExit(resUnmet, 1);
851
+ assertOut(resUnmet, 'BLOCKED: 任务 P04(并行 pending)当前不可委托:依赖未满足');
852
+ assertOut(resUnmet, '未完成: S03');
853
+ assertOut(resUnmet, 'workflow-state next');
854
+ assertOut(resUnmet, '若输出 execute 表示依赖未满足');
855
+ assertOut(resUnmet, '待任务变为可委托');
856
+ assertNotOut(resUnmet, 'entry subagent-execute');
857
+ if (fs.readFileSync(statePath, 'utf8') !== unmetBytesBefore) {
858
+ throw new Error('依赖未满足 BLOCK 必须 state 字节零改写');
859
+ }
860
+ if (readScenarioState(dir).evidence?.['subagent-execute']?.handoffRequests?.P04) {
861
+ throw new Error('依赖未满足 BLOCK 不得落 handoffRequests');
862
+ }
863
+ const resUnmetNext = runStateWithProtocol(dir, ['next']);
864
+ assertExit(resUnmetNext, 0);
865
+ if (!/^NODE: execute$/m.test(resUnmetNext.output)) {
866
+ throw new Error('依赖未满足时 next 应输出 execute:\n' + resUnmetNext.output);
867
+ }
868
+ // 依赖满足:串行任务消化完成后 next 输出 subagent-execute;按输出 entry 后 request 成功
869
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md',
870
+ '# TASK\n\n<task id="S03" parallel="false" status="done"><action>实现 S03</action><write_files>src/s03.mjs</write_files><verify>node --check src/s03.mjs</verify></task>\n'
871
+ + '<task id="P04" parallel="true" status="pending"><action>实现 P04</action><write_files>src/p04.mjs</write_files><verify>node --check src/p04.mjs</verify><depends_on>S03</depends_on></task>\n');
872
+ const afterSerial = readScenarioState(dir);
873
+ afterSerial.completedNodes = [...new Set([...(afterSerial.completedNodes || []), 'execute'])];
874
+ afterSerial.evidence = { ...(afterSerial.evidence || {}), execute: { summary: 'serial digest done' } };
875
+ writeState(dir, afterSerial);
876
+ const resDelegableNext = runStateWithProtocol(dir, ['next']);
877
+ assertExit(resDelegableNext, 0);
878
+ if (!/^NODE: subagent-execute$/m.test(resDelegableNext.output)) {
879
+ throw new Error('依赖满足后 next 应输出 subagent-execute:\n' + resDelegableNext.output);
880
+ }
881
+ if (readScenarioState(dir).currentNode !== 'subagent-execute') {
882
+ throw new Error('依赖满足后 next 应把工作归属推到 subagent-execute');
883
+ }
884
+ writeMarker('subagent-execute');
885
+ assertExit(runGuardWithProtocol(dir, ['entry', 'subagent-execute']), 0);
886
+ const resRecovered = runHandoff(['request', 'P04', 'now delegable'], dir, env);
887
+ assertExit(resRecovered, 0);
888
+ assertOut(resRecovered, 'HANDOFF REQUEST: P04');
889
+ // ⑫ 协议不可读(默认解析指向 runRoot 外的内置协议,受保护读取拒绝)→ 可见 WARN(原因 +
890
+ // 「本次未执行归属校验」)+ 放行语义不变。修复前此形态静默 skip(无 WARN、照常落库)=假绿。
891
+ writeMarker('execute');
892
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskXml('P05', 'parallel="true" status="pending"', 'src/p05.mjs'));
893
+ const stNoProtocol = baseState('execute');
894
+ stNoProtocol.newChange = true;
895
+ stNoProtocol.enteredNodes = ['execute'];
896
+ writeState(dir, stNoProtocol);
897
+ const resNoProtocol = runHandoff(['request', 'P05', 'no protocol'], dir, { FLOW_COMET_PROTOCOL: '' });
898
+ assertExit(resNoProtocol, 0);
899
+ assertOut(resNoProtocol, 'WARN:');
900
+ assertOut(resNoProtocol, '本次未执行归属校验');
901
+ assertOut(resNoProtocol, '协议路径不在当前项目根内');
902
+ assertOut(resNoProtocol, 'HANDOFF REQUEST: P05');
903
+ assertNotOut(resNoProtocol, 'BLOCKED');
904
+ if (!readScenarioState(dir).evidence?.['subagent-execute']?.handoffRequests?.P05) {
905
+ throw new Error('协议不可读应可见 WARN 后照常落库(放行语义不变),实际未落请求记录');
906
+ }
907
+ // ⑬ 协议文件缺失(显式指向 runRoot 内不存在的路径)→ 同类可见 WARN(原因=文件不存在)+ 放行
908
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskXml('P06', 'parallel="true" status="pending"', 'src/p06.mjs'));
909
+ const stProtocolMissing = baseState('execute');
910
+ stProtocolMissing.newChange = true;
911
+ stProtocolMissing.enteredNodes = ['execute'];
912
+ writeState(dir, stProtocolMissing);
913
+ const resProtocolMissing = runHandoff(['request', 'P06', 'missing protocol'], dir,
914
+ { FLOW_COMET_PROTOCOL: path.join(dir, 'reference', 'protocol-missing.json') });
915
+ assertExit(resProtocolMissing, 0);
916
+ assertOut(resProtocolMissing, 'WARN:');
917
+ assertOut(resProtocolMissing, '本次未执行归属校验');
918
+ assertOut(resProtocolMissing, '协议文件不存在');
919
+ assertOut(resProtocolMissing, 'HANDOFF REQUEST: P06');
920
+ assertNotOut(resProtocolMissing, 'BLOCKED');
921
+ // 旧 change 同形态 → 同样仅可见 WARN + 照常落库(协议不可读不区分新旧 change 新增硬 BLOCK)
922
+ const stProtocolMissingOld = JSON.parse(fs.readFileSync(statePath, 'utf8'));
923
+ delete stProtocolMissingOld.newChange;
924
+ writeState(dir, stProtocolMissingOld);
925
+ const resProtocolMissingOld = runHandoff(['request', 'P06', 'missing protocol legacy'], dir,
926
+ { FLOW_COMET_PROTOCOL: path.join(dir, 'reference', 'protocol-missing.json') });
927
+ assertExit(resProtocolMissingOld, 0);
928
+ assertOut(resProtocolMissingOld, '本次未执行归属校验');
929
+ assertOut(resProtocolMissingOld, 'HANDOFF REQUEST: P06');
930
+ assertNotOut(resProtocolMissingOld, 'BLOCKED');
931
+ // ⑭ 协议解析失败(非法 JSON 文件)→ 同类可见 WARN(原因=不是合法 JSON)+ 放行
932
+ writeFile(dir, 'reference/protocol-broken.json', '{ not-json\n');
933
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskXml('P07', 'parallel="true" status="pending"', 'src/p07.mjs'));
934
+ const stProtocolBroken = baseState('execute');
935
+ stProtocolBroken.newChange = true;
936
+ stProtocolBroken.enteredNodes = ['execute'];
937
+ writeState(dir, stProtocolBroken);
938
+ const resProtocolBroken = runHandoff(['request', 'P07', 'broken protocol'], dir,
939
+ { FLOW_COMET_PROTOCOL: path.join(dir, 'reference', 'protocol-broken.json') });
940
+ assertExit(resProtocolBroken, 0);
941
+ assertOut(resProtocolBroken, 'WARN:');
942
+ assertOut(resProtocolBroken, '本次未执行归属校验');
943
+ assertOut(resProtocolBroken, '不是合法 JSON');
944
+ assertOut(resProtocolBroken, 'HANDOFF REQUEST: P07');
945
+ assertNotOut(resProtocolBroken, 'BLOCKED');
946
+ // ⑮ state 协议绑定:init --protocol 指向自定义协议(无 execute / subagent-execute
947
+ // 节点)→ state.protocolPath 持久化;后续 request 按该协议判定,串行 pending 无对应
948
+ // enabled 委托节点 → 跳过归属校验。若协议来源未持久化,env 指向内置协议会把串行
949
+ // pending 误判为归属 execute → BLOCK(修复前 RED)。
950
+ const boundChange = 'bound-proto';
951
+ const boundProtocol = {
952
+ ...proto,
953
+ nodes: proto.nodes.filter((n) => n.id !== 'execute' && n.id !== 'subagent-execute'),
954
+ };
955
+ writeFile(dir, 'reference/protocol-bound.json', JSON.stringify(boundProtocol, null, 2) + '\n');
956
+ assertExit(runState(['init', boundChange, '--init-skip', '--protocol', 'reference/protocol-bound.json'], dir), 0);
957
+ writeFile(dir, '.specs/' + boundChange + '/TASK.md', taskXml('B01', 'parallel="false" status="pending"', 'src/b01.mjs'));
958
+ const resBound = runHandoff(['request', 'B01', 'bound protocol serial'], dir,
959
+ { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) });
960
+ assertExit(resBound, 0);
961
+ assertOut(resBound, 'HANDOFF REQUEST: B01');
962
+ assertNotOut(resBound, 'BLOCKED');
963
+ assertNotOut(resBound, '本次未执行归属校验'); // 协议可读且无对应 enabled 节点 → 跳过校验,不产生不可读 WARN
964
+ const boundState = readScenarioState(dir);
965
+ if (boundState.protocolPath !== 'reference/protocol-bound.json') {
966
+ throw new Error('init 应把解析后的协议路径持久化为项目根相对形态,实际: ' + JSON.stringify(boundState.protocolPath));
967
+ }
968
+ if (!boundState.evidence?.['subagent-execute']?.handoffRequests?.B01) {
969
+ throw new Error('state 绑定协议下的 request 应照常落库');
970
+ }
971
+ // ⑯ state.protocolPath 存在但不可读 → 不回退 env/默认(回退会按内置协议把串行 pending
972
+ // 误判为归属 execute → BLOCK);可见 WARN 说明来源 +「本次未执行归属校验」后放行。
973
+ const boundMissingState = readScenarioState(dir);
974
+ boundMissingState.protocolPath = 'reference/protocol-bound-missing.json';
975
+ writeState(dir, boundMissingState);
976
+ writeFile(dir, '.specs/' + boundChange + '/TASK.md', taskXml('B02', 'parallel="false" status="pending"', 'src/b02.mjs'));
977
+ const resBoundMissing = runHandoff(['request', 'B02', 'bound protocol unreadable'], dir,
978
+ { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) });
979
+ assertExit(resBoundMissing, 0);
980
+ assertOut(resBoundMissing, 'WARN:');
981
+ assertOut(resBoundMissing, '本次未执行归属校验');
982
+ assertOut(resBoundMissing, 'state.protocolPath');
983
+ assertOut(resBoundMissing, '协议文件不存在');
984
+ assertOut(resBoundMissing, 'HANDOFF REQUEST: B02');
985
+ assertNotOut(resBoundMissing, 'BLOCKED');
986
+ if (!readScenarioState(dir).evidence?.['subagent-execute']?.handoffRequests?.B02) {
987
+ throw new Error('state.protocolPath 不可读应可见 WARN 后照常落库');
988
+ }
989
+ // ⑰ 旧 state(无 protocolPath 字段)→ env/默认回退不回归:env 指向内置协议时,串行
990
+ // pending 在 open 节点发起仍按内置协议归属 execute → BLOCK(缺字段 = 渐进兼容路径)。
991
+ const legacyBoundState = readScenarioState(dir);
992
+ delete legacyBoundState.protocolPath;
993
+ legacyBoundState.currentNode = 'open';
994
+ writeState(dir, legacyBoundState);
995
+ writeFile(dir, '.specs/' + boundChange + '/TASK.md', taskXml('B03', 'parallel="false" status="pending"', 'src/b03.mjs'));
996
+ const resLegacyBound = runHandoff(['request', 'B03', 'legacy state no binding'], dir,
997
+ { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) });
998
+ assertExit(resLegacyBound, 1);
999
+ assertOut(resLegacyBound, 'BLOCKED: 任务 B03(串行 pending)应归属节点 execute');
1000
+ },
1001
+ },
1002
+
1003
+ // 163: next / guard entry 输出点名加载(设计语义 / AC-17)——`workflow-state next` 与
1004
+ // `workflow-guard entry` 输出应含 `LOAD SKILL: <skill>(用 Skill 工具,禁止跳过)`。
1005
+ // 当前 printNext / entry 无该行 → 预期 RED。
1006
+ {
1007
+ name: '163 next / entry 输出点名 LOAD SKILL:用 Skill 工具,禁止跳过',
1008
+ run: (dir) => {
1009
+ // ① next:open 节点 → 输出点名 flow-comet-open
1010
+ fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
1011
+ const st = baseState('open');
1012
+ st.evidence.open = { summary: 'intake complete' };
1013
+ writeState(dir, st);
1014
+ const resNext = runStateWithProtocol(dir, ['next']);
1015
+ assertExit(resNext, 0);
1016
+ assertOut(resNext, 'LOAD SKILL: flow-comet-open');
1017
+ assertOut(resNext, '禁止跳过');
1018
+ // ② guard entry:plan 节点 → 输出点名 flow-comet-plan
1019
+ const st2 = baseState('plan');
1020
+ writeState(dir, st2);
1021
+ const resEntry = runGuardWithProtocol(dir, ['entry', 'plan']);
1022
+ assertExit(resEntry, 0);
1023
+ assertOut(resEntry, 'LOAD SKILL: flow-comet-plan');
1024
+ assertOut(resEntry, '禁止跳过');
1025
+ },
1026
+ },
1027
+
1028
+ // 164: 技能加载措辞(设计语义 / AC-16)——主 SKILL(SKILL.md + 入口展开册)与节点 SKILL
1029
+ // 须含「Skill 工具」与「不得跳过/禁止跳过」。入口展开册随 `GUIDANCE.md` 改名同步为
1030
+ // `reference/entry-detail.md`(判据强度不变:仍是同两条存在级锚点句,只是文件名换了)。
1031
+ // 判据抽成纯函数(单一实现):真实判据与反向构造探针共用,逐份抽掉任一条锚点必红。
1032
+ {
1033
+ name: '164 技能加载措辞:主 SKILL 与节点 SKILL 含 Skill 工具 + 不得/禁止跳过',
1034
+ run: (dir) => {
1035
+ const files = [
1036
+ [path.join('flow-comet', 'SKILL.md'), path.join(SCRIPTS_DIR, '..', 'SKILL.md')],
1037
+ [path.join('flow-comet', 'reference', 'entry-detail.md'),
1038
+ path.join(SCRIPTS_DIR, '..', 'reference', 'entry-detail.md')],
1039
+ ...['flow-comet-open', 'flow-comet-design', 'flow-comet-plan', 'flow-comet-execute',
1040
+ 'flow-comet-subagent-execute', 'flow-comet-review', 'flow-comet-verify', 'flow-comet-archive']
1041
+ .map((s) => [path.join(s, 'SKILL.md'), path.join(SCRIPTS_DIR, '..', '..', s, 'SKILL.md')]),
1042
+ ];
1043
+ const missing = [];
1044
+ for (const [rel, f] of files) {
1045
+ const text = fs.readFileSync(f, 'utf8');
1046
+ missing.push(...skillLoadingWordingProblems(rel, text));
1047
+ // 反向构造(同一判据驱动):逐条锚点句抽掉 ⇒ 必报该条缺失——存在级锚点不得恒真空过。
1048
+ for (const [label, stripped] of [
1049
+ ['Skill 工具', text.split('Skill 工具').join('(反向构造:抽掉)')],
1050
+ ['不得跳过/禁止跳过', text.split('禁止跳过').join('(反向构造:抽掉)').split('不得跳过').join('(反向构造:抽掉)')],
1051
+ ]) {
1052
+ if (stripped === text) continue; // 该条本就不在场,缺失已由真实判据报告
1053
+ if (!skillLoadingWordingProblems(rel, stripped).some((p) => p.includes(label))) {
1054
+ missing.push(rel + ' 反向构造判别力缺失(抽掉「' + label + '」未被判缺失)');
1055
+ }
1056
+ }
1057
+ }
1058
+ if (missing.length > 0) {
1059
+ throw new Error('技能加载措辞缺失: ' + missing.join('; '));
1060
+ }
1061
+ },
1062
+ },
1063
+
1064
+ // 165: next 进行中节点保护扩展(承接既有保护场景)——已 entry 但未 record 的节点(enteredNodes 含 plan、
1065
+ // TASK.md 存在、无 evidence.plan)跑 next → 不得把 currentNode 推走(保持 plan,输出 NODE: plan)。
1066
+ // 当前保护只看 evidence(record 过)→ 会把 currentNode 推到 execute → 预期 RED。
1067
+ {
1068
+ name: '165 next 保护扩展:entered 未 record 节点不推走(保持 plan)',
1069
+ run: (dir) => {
1070
+ fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
1071
+ writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why(为什么做)\n\nx');
1072
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n\nx\n\n## 验收准则(AC)\n\n- Given x When y Then z');
1073
+ writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# DESIGN\n\n## 0. 技术栈选型\n\n- 选定:Node\n\n## 1. 技术决策清单\n\n| # | D | R |\n|---|---|---|\n| D1 | x | y |');
1074
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_SERIAL_PENDING);
1075
+ const st = {
1076
+ activeChange: CHANGE_ID,
1077
+ currentNode: 'plan',
1078
+ completedNodes: ['open', 'design'],
1079
+ enteredNodes: ['open', 'design', 'plan'],
1080
+ evidence: {
1081
+ open: { summary: 'intake complete' },
1082
+ design: { summary: 'design done' },
1083
+ },
1084
+ verifyFailures: 0,
1085
+ executionMode: 'subagent',
1086
+ directOverride: false,
1087
+ };
1088
+ writeState(dir, st);
1089
+ const res = runStateWithProtocol(dir, ['next']);
1090
+ assertExit(res, 0);
1091
+ assertOut(res, 'NODE: plan');
1092
+ const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
1093
+ if (st2.currentNode !== 'plan') {
1094
+ throw new Error('entered 未 record 的节点不应被推进,currentNode 应为 plan,实际: ' + st2.currentNode);
1095
+ }
1096
+ },
1097
+ },
1098
+
1099
+ // 166: 节点 SKILL 加载声明与协议一致(防回归锁)——每个节点 SKILL.md 必须含
1100
+ // requiredSkillCalls(非 advisory)对应的完整 skill-load 声明命令行与协议文件映射。
1101
+ {
1102
+ name: '166 节点 SKILL 声明命令与 workflow-protocol.json 一致',
1103
+ run: () => {
1104
+ const protocol = JSON.parse(fs.readFileSync(path.join(SCRIPTS_DIR, '..', 'reference', 'workflow-protocol.json'), 'utf8'));
1105
+ const promptBySkill = {
1106
+ 'flow-comet-change': '0-change.md',
1107
+ 'flow-comet-requirement': '1-requirement.md',
1108
+ 'flow-comet-design': '2-design.md',
1109
+ 'flow-comet-task': '3-task.md',
1110
+ 'flow-comet-dev': '4-dev.md',
1111
+ 'flow-comet-review': '6-review.md',
1112
+ 'flow-comet-test': '5-test.md',
1113
+ 'flow-comet-integration': '7-integration.md',
1114
+ };
1115
+ const advisory = new Set(['flow-comet-ui-design']);
1116
+ const problems = [];
1117
+ for (const node of protocol.nodes) {
1118
+ const impl = node.implementation && node.implementation.skill;
1119
+ if (!impl) continue;
1120
+ const text = fs.readFileSync(path.join(SCRIPTS_DIR, '..', '..', impl, 'SKILL.md'), 'utf8');
1121
+ for (const call of node.requiredSkillCalls || []) {
1122
+ if (advisory.has(call.skill)) continue;
1123
+ const promptFile = promptBySkill[call.skill];
1124
+ if (!promptFile) { problems.push(impl + ' 缺 ' + call.skill + ' 的 prompt 映射'); continue; }
1125
+ const line = 'skill-load ' + node.id + ' ' + call.skill + ' --prompt flow-kit/prompts/' + promptFile;
1126
+ if (!text.includes(line)) problems.push(impl + ' 缺声明命令: ' + line);
1127
+ }
1128
+ }
1129
+ if (problems.length > 0) throw new Error('节点 SKILL 声明命令与协议不一致: ' + problems.join('; '));
1130
+ },
1131
+ },
1132
+
1133
+ // 167: 两层加载模型措辞——阶段层禁止在节点 SKILL 内指示用 Skill 工具加载任何节点实现技能
1134
+ //(本节点技能已由入口路由经 Skill 工具加载);入口层禁止 Implementation/Required 混淆句式;
1135
+ // 全部 10 文件禁止无限定「record 会自动补写缺失的声明标记」表述(与新 change 技能加载前置门矛盾)。
1136
+ // 入口层的第二份随 `GUIDANCE.md` 改名同步为 `reference/entry-detail.md`(判据强度不变)。
1137
+ {
1138
+ name: '167 两层加载模型措辞:禁自加载句式/禁混淆句式/自动补分新旧',
1139
+ run: () => {
1140
+ const nodeDirs = ['flow-comet-open', 'flow-comet-design', 'flow-comet-plan', 'flow-comet-execute',
1141
+ 'flow-comet-subagent-execute', 'flow-comet-review', 'flow-comet-verify', 'flow-comet-archive'];
1142
+ const implPattern = /用\s*Skill\s*工具加载[^。\n]{0,60}flow-comet-(open|design|plan|execute|subagent-execute|review|verify|archive)/;
1143
+ const autoFill = 'record 会自动补写缺失的声明标记';
1144
+ const stageAnchor = '本节点技能已由入口路由经 Skill 工具加载';
1145
+ const entryAnchor = 'Skill 工具加载该节点的 Implementation 技能';
1146
+ const problems = [];
1147
+ for (const id of nodeDirs) {
1148
+ const text = fs.readFileSync(path.join(SCRIPTS_DIR, '..', '..', id, 'SKILL.md'), 'utf8');
1149
+ if (implPattern.test(text)) problems.push(id + ' 含「用 Skill 工具加载节点实现技能」句式');
1150
+ if (text.includes(autoFill)) problems.push(id + ' 含无限定自动补表述');
1151
+ if (!text.includes(stageAnchor)) problems.push(id + ' 缺阶段层锚点句');
1152
+ }
1153
+ const entryLevelFiles = [
1154
+ ['flow-comet/SKILL.md', path.join(SCRIPTS_DIR, '..', 'SKILL.md')],
1155
+ ['flow-comet/reference/entry-detail.md', path.join(SCRIPTS_DIR, '..', 'reference', 'entry-detail.md')],
1156
+ ];
1157
+ for (const [rel, file] of entryLevelFiles) {
1158
+ const text = fs.readFileSync(file, 'utf8');
1159
+ problems.push(...twoLayerEntryProblems(rel, text));
1160
+ // 反向构造(同一判据驱动):逐条锚点句抽掉 ⇒ 必报;还原混淆句式 / 无限定自动补表述 ⇒ 必报。
1161
+ for (const [label, stripped] of [
1162
+ ['入口层锚点句', text.split(entryAnchor).join('(反向构造:抽掉)')],
1163
+ ['前置门', text.split('前置门').join('(反向构造:抽掉)')],
1164
+ ]) {
1165
+ if (stripped === text) continue; // 该条本就不在场,缺失已由真实判据报告
1166
+ if (!twoLayerEntryProblems(rel, stripped).some((p) => p.includes(label))) {
1167
+ problems.push(rel + ' 反向构造判别力缺失(抽掉「' + label + '」未被判缺失)');
1168
+ }
1169
+ }
1170
+ const regressed = text + '\n见上方 Required Calls 表。' + autoFill + '。\n';
1171
+ const regressedProblems = twoLayerEntryProblems(rel, regressed);
1172
+ for (const label of ['Implementation/Required 混淆句式', '无限定自动补表述']) {
1173
+ if (!regressedProblems.some((p) => p.includes(label))) {
1174
+ problems.push(rel + ' 反向构造判别力缺失(还原「' + label + '」未被判违规)');
1175
+ }
1176
+ }
1177
+ }
1178
+ if (problems.length > 0) throw new Error('两层加载模型措辞不符: ' + problems.join('; '));
1179
+ },
1180
+ },
1181
+
1182
+ // 168: verify 出口 EPERM 降级——受限沙箱会话中管道式执行子进程被拒(EPERM)时,
1183
+ // 以继承 stdio 重试同一命令:①输出含 VERIFY-DEGRADED 行(降级捕获标记);②验证命令的
1184
+ // 副作用标记文件被真实写入(证明 inherit 重试真实执行——真实受限会话中管道阶段命令根本
1185
+ // 不启动,标记文件只能由重试写入);③最终按退出码判定通过(guard exit=0)。
1186
+ // 测试钩子 FLOW_COMET_VERIFY_FORCE_EPERM=1 使首次管道执行模拟 EPERM 拒绝(仅测试用途——
1187
+ // 生产触发条件是真实 spawn 层 EPERM),降级路径因此可确定性自动化断言。
1188
+ {
1189
+ name: '168 verify 出口 EPERM 降级:VERIFY-DEGRADED 行 + inherit 真实重试 + exit 0',
1190
+ run: (dir) => {
1191
+ const st = baseState('verify');
1192
+ st.evidence.verify = { summary: 'verified' };
1193
+ writeState(dir, st);
1194
+ // 验证命令写副作用标记文件(相对 cwd=runRoot)——文件存在即证明命令被真实执行
1195
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TEST.md', '# TEST\n\n## 验证命令\n\n```bash\nnode -e "require(\'fs\').writeFileSync(\'verify-marker.txt\',\'ok\')"\n```\n');
1196
+ writeFile(dir, '.specs/' + CHANGE_ID + '/UAT.md', '# UAT\n\n通过\n');
1197
+ const marker = path.join(dir, 'verify-marker.txt');
1198
+ if (fs.existsSync(marker)) fs.rmSync(marker);
1199
+ const res = runGuard(['exit', 'verify'], dir, { FLOW_COMET_VERIFY_FORCE_EPERM: '1' });
1200
+ assertOut(res, 'VERIFY-DEGRADED');
1201
+ if (!fs.existsSync(marker)) {
1202
+ throw new Error('EPERM 降级后标记文件未被写入——inherit 重试未真实执行\n实际输出:\n' + res.output);
1203
+ }
1204
+ if (fs.readFileSync(marker, 'utf8') !== 'ok') throw new Error('标记文件内容异常');
1205
+ assertExit(res, 0);
1206
+ },
1207
+ },
1208
+
1209
+ // 169: 非 EPERM 失败不降级——验证命令真实失败(非零退出、无 EPERM、无钩子)时行为与
1210
+ // 现状一致:VERIFY-FAIL 计数语义输出、不含 VERIFY-DEGRADED 行、guard exit≠0。
1211
+ // (锚定场景:防止降级逻辑扩大化吞掉真实测试失败——降级边界)
1212
+ {
1213
+ name: '169 非 EPERM 失败不降级:VERIFY-FAIL 照常且无 VERIFY-DEGRADED 行',
1214
+ run: (dir) => {
1215
+ const st = baseState('verify');
1216
+ st.evidence.verify = { summary: 'verified' };
1217
+ writeState(dir, st);
1218
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TEST.md', '# TEST\n\n## 验证命令\n\n```bash\nnode -e "process.exit(3)"\n```\n');
1219
+ writeFile(dir, '.specs/' + CHANGE_ID + '/UAT.md', '# UAT\n\n通过\n');
1220
+ const res = runGuard(['exit', 'verify'], dir);
1221
+ assertExit(res, 1);
1222
+ assertOut(res, 'VERIFY-FAIL');
1223
+ assertNotOut(res, 'VERIFY-DEGRADED');
1224
+ },
1225
+ },
1226
+
1227
+ // 170: 零提交旁路收紧——noCommit 结果若携带 tracked 提交:新 change BLOCKED / 旧 change
1228
+ // HANDOFF WARN;空提交(--allow-empty)正例通过。锚定 AC-1(防「空 write_files 声明」
1229
+ // 成为携带任意提交的逃逸口)。
1230
+ // ④ F-6 请求侧补 tracked 负例:write_files 路径虽被 .gitignore 命中、但该路径已 tracked
1231
+ //(index-aware check-ignore 退出 1)→ 不记 noCommit(tracked 提交仍走完整子集校验)。
1232
+ {
1233
+ name: '170 零提交旁路:携带 tracked 提交新 BLOCK / 旧 WARN / 空提交通过',
1234
+ run: (dir) => {
1235
+ execFileSync('git', ['init'], { cwd: dir, stdio: 'ignore' });
1236
+ const git = (...args) => execFileSync('git', args, { cwd: dir, stdio: 'ignore' });
1237
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'add', '-A');
1238
+ writeFile(dir, 'src/x.js', 'x');
1239
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'add', 'src/x.js');
1240
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '-m', 'tracked');
1241
+ const hashTracked = execFileSync('git', ['rev-parse', '--short', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
1242
+ const mkState = (isNew) => {
1243
+ const st = baseState('subagent-execute');
1244
+ if (isNew) st.newChange = true;
1245
+ st.evidence['subagent-execute'] = st.evidence['subagent-execute'] || {};
1246
+ st.evidence['subagent-execute'].handoffRequests = {
1247
+ T9: { description: 'zero-commit', noCommit: true },
1248
+ T10: { description: 'zero-commit legacy', noCommit: true },
1249
+ T11: { description: 'zero-commit empty', noCommit: true },
1250
+ };
1251
+ writeState(dir, st);
1252
+ };
1253
+ const payload = (id, hash) => JSON.stringify({ status: 'DONE', taskId: id, commitHash: hash,
1254
+ completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
1255
+ greenEvidence: { command: 'n', output: 'n' }, redEvidence: { command: 'r', output: 'r' } });
1256
+ // ① 新 change + 含 tracked 文件的提交 → BLOCKED
1257
+ mkState(true);
1258
+ const res1 = runHandoff(['result', 'T9', payload('T9', hashTracked)], dir);
1259
+ assertExit(res1, 1);
1260
+ assertOut(res1, '声明零提交但提交携带');
1261
+ // ② 旧 change 同构造 → WARN 不阻断
1262
+ mkState(false);
1263
+ const res2 = runHandoff(['result', 'T10', payload('T10', hashTracked)], dir);
1264
+ assertExit(res2, 0);
1265
+ assertOut(res2, 'HANDOFF WARN');
1266
+ // ③ 新 change + 空提交 → 通过
1267
+ mkState(true);
1268
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '--allow-empty', '-m', 'empty');
1269
+ const hashEmpty = execFileSync('git', ['rev-parse', '--short', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
1270
+ const res3 = runHandoff(['result', 'T11', payload('T11', hashEmpty)], dir);
1271
+ assertExit(res3, 0);
1272
+ assertOut(res3, '提交为空,校验通过');
1273
+ // ④ F-6 请求侧 tracked 负例:路径被 .gitignore 命中但已被 index 跟踪 → check-ignore 退出 1
1274
+ writeFile(dir, '.gitignore', '.specs/\n');
1275
+ writeFile(dir, '.specs/' + CHANGE_ID + '/tracked.md', 'tracked\n');
1276
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'add', '-f', '.specs/' + CHANGE_ID + '/tracked.md');
1277
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '-m', 'track ignored file');
1278
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
1279
+ + '<task id="T12" status="done"><action>边界任务</action>'
1280
+ + '<write_files>.specs/' + CHANGE_ID + '/tracked.md</write_files>'
1281
+ + '<verify>node --check src/x.js</verify></task>\n');
1282
+ writeState(dir, baseState('subagent-execute'));
1283
+ const resReqTracked = runHandoff(['request', 'T12', 'tracked path slice'], dir);
1284
+ assertExit(resReqTracked, 0);
1285
+ const stTracked = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
1286
+ const reqTracked = stTracked.evidence['subagent-execute'].handoffRequests.T12;
1287
+ if (!reqTracked || reqTracked.noCommit === true) {
1288
+ throw new Error('tracked 文件路径不应具备零提交资格,实际 ' + JSON.stringify(reqTracked));
1289
+ }
1290
+ // ④b m-13 result 重验:request 时路径不存在(记资格),随后路径被强制跟踪 →
1291
+ // result 重验失败撤销 noCommit,失败类别 = became-tracked,且留 at/reason 审计。
1292
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n'
1293
+ + '<task id="T15" status="done"><action>tracked-after-request 边界任务</action>'
1294
+ + '<write_files>.specs/' + CHANGE_ID + '/T15.md</write_files>'
1295
+ + '<verify>node --check src/x.js</verify></task>\n');
1296
+ writeState(dir, baseState('subagent-execute'));
1297
+ const resReqT15 = runHandoff(['request', 'T15', 'tracked-after-request slice'], dir);
1298
+ assertExit(resReqT15, 0);
1299
+ const stReqT15 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
1300
+ if (stReqT15.evidence['subagent-execute'].handoffRequests.T15.noCommit !== true) {
1301
+ throw new Error('request 时未跟踪且被忽略的路径应取得 noCommit 资格,实际 '
1302
+ + JSON.stringify(stReqT15.evidence['subagent-execute'].handoffRequests.T15));
1303
+ }
1304
+ writeFile(dir, '.specs/' + CHANGE_ID + '/T15.md', 'tracked after request\n');
1305
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'add', '-f', '.specs/' + CHANGE_ID + '/T15.md');
1306
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '-m', 'track after request');
1307
+ stReqT15.newChange = true;
1308
+ writeState(dir, stReqT15);
1309
+ const resRevokeTracked = runHandoff(['result', 'T15', payload('T15', '')], dir);
1310
+ assertExit(resRevokeTracked, 1);
1311
+ assertOut(resRevokeTracked, 'HANDOFF ERROR');
1312
+ assertOut(resRevokeTracked, 'revokeReason=became-tracked');
1313
+ const stRevokeTracked = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
1314
+ assertRevocationAudit(stRevokeTracked.evidence['subagent-execute'].handoffRequests.T15,
1315
+ 'became-tracked', '170④b 路径变 tracked 重验');
1316
+ if (stRevokeTracked.evidence['subagent-execute'].handoffResult?.T15) {
1317
+ throw new Error('tracked 重验失败不得落 result');
1318
+ }
1319
+ // ⑤ merge commit 负例(evil merge):merge 提交独有的越界文件不得绕过完整提交子集校验
1320
+ // → 新 change BLOCK 且列出越界文件(merge 与普通提交走同一 fail-closed 路径)
1321
+ const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
1322
+ git('checkout', '-q', '-b', 'feature-merge');
1323
+ writeFile(dir, 'src/feature-merge.js', 'feature\n');
1324
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'add', 'src/feature-merge.js');
1325
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '-m', 'feature branch');
1326
+ git('checkout', '-q', branch);
1327
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'merge', '--no-ff', '--no-commit', 'feature-merge');
1328
+ writeFile(dir, 'src/evil-merge.js', 'evil\n');
1329
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'add', 'src/evil-merge.js');
1330
+ git('-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '-m', 'evil merge');
1331
+ const mergeHash = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
1332
+ const stMerge = baseState('subagent-execute');
1333
+ stMerge.newChange = true;
1334
+ stMerge.evidence['subagent-execute'] = { handoffRequests: { T13: { description: 'merge boundary', writeFiles: ['src/x.js'] } } };
1335
+ writeState(dir, stMerge);
1336
+ const resMerge = runHandoff(['result', 'T13', payload('T13', mergeHash)], dir);
1337
+ assertExit(resMerge, 1);
1338
+ assertOut(resMerge, '超出 writeFiles 范围');
1339
+ assertOut(resMerge, 'src/evil-merge.js');
1340
+ // ⑥ invalid hash 负例:非法 commitHash 不得被静默当作合法提交——必须输出可见 HANDOFF ERROR
1341
+ //(记录不被拒绝是既有渐进语义;此处锚定「可见报错 + 不作为合法提交校验」的契约边界)
1342
+ const stInvalidHash = baseState('subagent-execute');
1343
+ stInvalidHash.newChange = true;
1344
+ stInvalidHash.evidence['subagent-execute'] = { handoffRequests: { T14: { description: 'invalid hash', writeFiles: ['src/x.js'] } } };
1345
+ writeState(dir, stInvalidHash);
1346
+ const resInvalidHash = runHandoff(['result', 'T14', payload('T14', 'not-a-commit-hash')], dir);
1347
+ assertExit(resInvalidHash, 0);
1348
+ assertOut(resInvalidHash, 'HANDOFF ERROR');
1349
+ assertOut(resInvalidHash, 'commitHash 格式非法');
1350
+ assertNotOut(resInvalidHash, '提交为空,校验通过');
1351
+ },
1352
+ },
1353
+
1354
+ // 171: 入口文档首部 Change ID 新 change 强制——标题/段序合规但缺 `- **Change ID**:`
1355
+ // 首部字段:新 change open 出口 BLOCKED(模板保真门的文案「首部缺字段: Change ID」);旧 change WARN 渐进。
1356
+ // (对齐 AC「标题·首部·段序」统一强制口径——此前仅 softWarning 与承诺不符。)
1357
+ {
1358
+ name: '171 入口首部 Change ID 新 BLOCK / 旧 WARN',
1359
+ run: (dir) => {
1360
+ const addOpenMarker = () => {
1361
+ fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
1362
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
1363
+ JSON.stringify({ node: 'open', skill: 'flow-comet-change', protocol: '0-change.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
1364
+ };
1365
+ const writeChange = (withId) => {
1366
+ const head = withId ? '- **Change ID**: ' + CHANGE_ID + '\n' : '';
1367
+ writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE: 标题\n\n' + head + '\n## Why(为什么做)\n\n原因。\n');
1368
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT: 标题\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## 用户故事\n\n- US-1\n\n## 验收准则(AC)\n\n- Given a When b Then c\n');
1369
+ };
1370
+ // ① 新 change 缺首部字段 → BLOCK
1371
+ const stNew = baseState('open');
1372
+ stNew.evidence.open = { summary: 'intake complete' };
1373
+ stNew.newChange = true;
1374
+ stNew.enteredNodes = ['open'];
1375
+ writeState(dir, stNew);
1376
+ addOpenMarker();
1377
+ writeChange(false);
1378
+ const resBad = runGuard(['exit', 'open'], dir);
1379
+ assertExit(resBad, 1);
1380
+ assertOut(resBad, 'BLOCKED');
1381
+ assertOut(resBad, '首部缺字段: Change ID');
1382
+ // ② 新 change 含首部字段 → 通过
1383
+ writeChange(true);
1384
+ const resGood = runGuard(['exit', 'open'], dir);
1385
+ assertExit(resGood, 0);
1386
+ assertOut(resGood, 'ALL CHECKS PASSED');
1387
+ // ③ 旧 change 缺首部字段 → WARN 渐进不阻断
1388
+ const stOld = baseState('open');
1389
+ stOld.evidence.open = { summary: 'intake complete' };
1390
+ writeState(dir, stOld);
1391
+ addOpenMarker();
1392
+ writeChange(false);
1393
+ const resOld = runGuard(['exit', 'open'], dir);
1394
+ assertExit(resOld, 0);
1395
+ assertOut(resOld, 'WARN');
1396
+ },
1397
+ },
1398
+ ];