flow-comet 1.6.3 → 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.
- package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
- package/.flow-comet/skills/flow-comet/scripts/comet-hook-guard.mjs +11 -13
- package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/evolve.mjs +6 -6
- package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +67 -18878
- package/.flow-comet/skills/flow-comet/scripts/health.mjs +1 -1
- package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +1030 -0
- package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +830 -0
- package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +781 -0
- package/.flow-comet/skills/flow-comet/scripts/items/d.mjs +99 -0
- package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +185 -0
- package/.flow-comet/skills/flow-comet/scripts/items/f.mjs +90 -0
- package/.flow-comet/skills/flow-comet/scripts/items/g.mjs +59 -0
- package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +815 -0
- package/.flow-comet/skills/flow-comet/scripts/items/i.mjs +77 -0
- package/.flow-comet/skills/flow-comet/scripts/items/j.mjs +75 -0
- package/.flow-comet/skills/flow-comet/scripts/items/k.mjs +1427 -0
- package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +275 -0
- package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +614 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/count-derivation.mjs +97 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/fix-loop-node.mjs +196 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +553 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +837 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +404 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +404 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +302 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +133 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/reentry-node.mjs +237 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/replan-node.mjs +209 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-branch.mjs +49 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-bridgecheck.mjs +201 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +141 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +700 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +578 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-determine.mjs +52 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-evolve-hint.mjs +55 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +106 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-intelscan.mjs +58 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +147 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +189 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +1441 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +471 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/test-assertions.mjs +509 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +1228 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +237 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +2484 -0
- package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/route-node.mjs +72 -1123
- package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +966 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1233 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1382 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +483 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +1388 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +1466 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +1364 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/h.mjs +1287 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +1436 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +1384 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +1338 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +1484 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/m.mjs +971 -0
- package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +1 -1
- package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +58 -7559
- package/.flow-comet/skills/flow-comet/scripts/time-utils.mjs +4 -4
- package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +151 -2476
- package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +5 -5
- package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +27 -2190
- package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +1 -1
- package/README.md +52 -69
- package/package.json +3 -2
- package/scripts/dsh-bridge.mjs +2 -2
- package/scripts/lib/installer-cleanup.mjs +152 -0
- package/scripts/lib/installer-flowkit.mjs +119 -0
- package/scripts/lib/installer-hooks.mjs +363 -0
- package/scripts/lib/installer-loader.mjs +220 -0
- package/scripts/lib/installer-migrate.mjs +236 -0
- package/scripts/lib/installer-platforms.mjs +314 -0
- package/scripts/prepare-env.mjs +21 -1313
|
@@ -0,0 +1,1233 @@
|
|
|
1
|
+
// 场景组 b — 委托链路 · 签名与机制交互 · hook 写白名单 · 初始化与状态兼容
|
|
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 {
|
|
9
|
+
assertExit,
|
|
10
|
+
assertNotOut,
|
|
11
|
+
assertOut,
|
|
12
|
+
baseState,
|
|
13
|
+
runGuard,
|
|
14
|
+
runHandoff,
|
|
15
|
+
runHook,
|
|
16
|
+
runState,
|
|
17
|
+
writeFile,
|
|
18
|
+
writeState,
|
|
19
|
+
} from '../lib/test-helpers.mjs';
|
|
20
|
+
import {
|
|
21
|
+
CHANGE_ID,
|
|
22
|
+
TASK_DONE,
|
|
23
|
+
TASK_P1,
|
|
24
|
+
TASK_P2_PENDING,
|
|
25
|
+
TASK_T03_PENDING,
|
|
26
|
+
TASK_TFIX,
|
|
27
|
+
composeState,
|
|
28
|
+
customProtocol,
|
|
29
|
+
handoffFor,
|
|
30
|
+
summaryContent,
|
|
31
|
+
writeCustomProtocol,
|
|
32
|
+
} from '../lib/test-fixtures.mjs';
|
|
33
|
+
import {
|
|
34
|
+
runGuardWithProtocol,
|
|
35
|
+
runStateWithProtocol,
|
|
36
|
+
} from '../lib/test-assertions.mjs';
|
|
37
|
+
|
|
38
|
+
export const ENTRIES = [
|
|
39
|
+
|
|
40
|
+
// ---------- 场景(handoff completedChecks 严格校验,handoff-guarded 落实) ----------
|
|
41
|
+
|
|
42
|
+
// 34: subagent-execute exit 通过——handoff result 的 completedChecks 含 required-skill 条目 → exit 0
|
|
43
|
+
{
|
|
44
|
+
name: '34 subagent-execute exit 通过:handoff 含 completedChecks',
|
|
45
|
+
run: (dir) => {
|
|
46
|
+
const st = baseState('subagent-execute');
|
|
47
|
+
st.evidence['subagent-execute'] = {
|
|
48
|
+
summary: 'delegated and collected',
|
|
49
|
+
handoffResult: handoffFor(['P01']),
|
|
50
|
+
};
|
|
51
|
+
writeState(dir, st);
|
|
52
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
|
|
53
|
+
const res = runGuard(['exit', 'subagent-execute'], dir);
|
|
54
|
+
assertExit(res, 0);
|
|
55
|
+
assertOut(res, 'ALL CHECKS PASSED');
|
|
56
|
+
},
|
|
57
|
+
},
|
|
58
|
+
|
|
59
|
+
// 35: subagent-execute exit BLOCKED——handoff result 缺 completedChecks(严格模式,无旧 change 豁免)
|
|
60
|
+
// → exit 1:旧格式/缺 completedChecks 的 handoff 在 subagent-execute 重入时被硬性拦截
|
|
61
|
+
{
|
|
62
|
+
name: '35 subagent-execute exit BLOCKED:handoff 缺 completedChecks',
|
|
63
|
+
run: (dir) => {
|
|
64
|
+
const st = baseState('subagent-execute');
|
|
65
|
+
const hr = handoffFor(['P01']);
|
|
66
|
+
delete hr['P01'].result.completedChecks;
|
|
67
|
+
st.evidence['subagent-execute'] = { summary: 'delegated and collected', handoffResult: hr };
|
|
68
|
+
writeState(dir, st);
|
|
69
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
|
|
70
|
+
const res = runGuard(['exit', 'subagent-execute'], dir);
|
|
71
|
+
assertExit(res, 1);
|
|
72
|
+
assertOut(res, 'BLOCKED');
|
|
73
|
+
assertOut(res, 'completedChecks');
|
|
74
|
+
},
|
|
75
|
+
},
|
|
76
|
+
|
|
77
|
+
// ---------- 场景(next 节点顺序校验,严格模式) ----------
|
|
78
|
+
|
|
79
|
+
// 36: next BLOCKED——currentNode=open 未 exit(completedNodes 空 + evidence 无 open 记录)
|
|
80
|
+
// → 上一节点未 exit 就推进 → 严格拦截,输出恢复指令(先 exit open --apply)
|
|
81
|
+
{
|
|
82
|
+
name: '36 next BLOCKED:currentNode=open 未 exit(completedNodes 空)',
|
|
83
|
+
run: (dir) => {
|
|
84
|
+
writeState(dir, baseState('open'));
|
|
85
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
86
|
+
const res = runStateWithProtocol(dir, ['next']);
|
|
87
|
+
assertExit(res, 1);
|
|
88
|
+
assertOut(res, '疑似未 exit 节点 open');
|
|
89
|
+
assertOut(res, 'workflow-guard.mjs exit open --apply');
|
|
90
|
+
},
|
|
91
|
+
},
|
|
92
|
+
|
|
93
|
+
// 37: next 正常——open 已 exit(completedNodes 含 open)+ 当前节点 evidence 已记录 → 正常推进
|
|
94
|
+
// (状态漂移校正保留:已完成节点正常推进不受严格校验影响)
|
|
95
|
+
{
|
|
96
|
+
name: '37 next 正常:open 已 exit 后正常推进',
|
|
97
|
+
run: (dir) => {
|
|
98
|
+
const st = baseState('design');
|
|
99
|
+
st.completedNodes = ['open'];
|
|
100
|
+
st.evidence.design = { summary: 'design in progress' };
|
|
101
|
+
writeState(dir, st);
|
|
102
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n');
|
|
103
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n');
|
|
104
|
+
const res = runStateWithProtocol(dir, ['next']);
|
|
105
|
+
assertExit(res, 0);
|
|
106
|
+
assertOut(res, 'NODE: design');
|
|
107
|
+
assertNotOut(res, 'BLOCKED');
|
|
108
|
+
},
|
|
109
|
+
},
|
|
110
|
+
|
|
111
|
+
// ---------- 场景(redEvidence 时间顺序校验) ----------
|
|
112
|
+
|
|
113
|
+
// 38: handoff result 时间顺序通过——先记录 redEvidence(TDD RED),再补 greenEvidence(GREEN)
|
|
114
|
+
// → 两次均通过;且 evidence 中 redEvidence/greenEvidence 附带 recordedAt 时间戳
|
|
115
|
+
// (重录保留 red 首次记录时间,green 为补录时间——时序可审计)
|
|
116
|
+
{
|
|
117
|
+
name: '38 handoff red 先于 green 通过(redEvidence/greenEvidence 附带 recordedAt)',
|
|
118
|
+
run: (dir) => {
|
|
119
|
+
writeState(dir, baseState('subagent-execute'));
|
|
120
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
121
|
+
const redOnly = '{"redEvidence":{"command":"node --check src/p1.mjs"}}';
|
|
122
|
+
const res1 = runHandoff(['result', 'P01', redOnly], dir);
|
|
123
|
+
assertExit(res1, 0);
|
|
124
|
+
assertOut(res1, 'HANDOFF RESULT: P01');
|
|
125
|
+
const both = '{"redEvidence":{"command":"node --check src/p1.mjs"},"greenEvidence":{"command":"node --check src/p1.mjs"}}';
|
|
126
|
+
const res2 = runHandoff(['result', 'P01', both], dir);
|
|
127
|
+
assertExit(res2, 0);
|
|
128
|
+
assertOut(res2, 'HANDOFF RESULT: P01');
|
|
129
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
130
|
+
const rec = st.evidence['subagent-execute'].handoffResult['P01'].result;
|
|
131
|
+
if (!rec.redEvidence.recordedAt || typeof rec.redEvidence.recordedAt !== 'string') {
|
|
132
|
+
throw new Error('redEvidence 未附带 recordedAt: ' + JSON.stringify(rec.redEvidence));
|
|
133
|
+
}
|
|
134
|
+
if (!rec.greenEvidence.recordedAt || typeof rec.greenEvidence.recordedAt !== 'string') {
|
|
135
|
+
throw new Error('greenEvidence 未附带 recordedAt: ' + JSON.stringify(rec.greenEvidence));
|
|
136
|
+
}
|
|
137
|
+
},
|
|
138
|
+
},
|
|
139
|
+
|
|
140
|
+
// 39: handoff result BLOCKED——已记录 greenEvidence(无 redEvidence)后同批补录 redEvidence
|
|
141
|
+
// → redEvidence 事后补录(TDD 要求 RED 先于 GREEN),exit 1
|
|
142
|
+
{
|
|
143
|
+
name: '39 handoff BLOCKED:greenEvidence 后同批补录 redEvidence',
|
|
144
|
+
run: (dir) => {
|
|
145
|
+
writeState(dir, baseState('subagent-execute'));
|
|
146
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
147
|
+
const greenOnly = '{"greenEvidence":{"command":"node --check src/p1.mjs"}}';
|
|
148
|
+
const res1 = runHandoff(['result', 'P01', greenOnly], dir);
|
|
149
|
+
assertExit(res1, 0);
|
|
150
|
+
const backfill = '{"greenEvidence":{"command":"node --check src/p1.mjs"},"redEvidence":{"command":"node --check src/p1.mjs"}}';
|
|
151
|
+
const res2 = runHandoff(['result', 'P01', backfill], dir);
|
|
152
|
+
assertExit(res2, 1);
|
|
153
|
+
assertOut(res2, 'redEvidence 事后补录');
|
|
154
|
+
},
|
|
155
|
+
},
|
|
156
|
+
|
|
157
|
+
// ---------- 场景(C3 签名行尾规范化 + 回退豁免) ----------
|
|
158
|
+
|
|
159
|
+
// 40: execute exit 通过——TASK.md 从 LF 行尾改写为 CRLF(bash heredoc → python os.linesep
|
|
160
|
+
// 跨工具编辑),任务集逻辑未变 → 签名一致(行尾规范化),不误报"任务集被修改"
|
|
161
|
+
{
|
|
162
|
+
name: '40 execute exit 通过:TASK LF→CRLF 行尾变化签名一致',
|
|
163
|
+
run: (dir) => {
|
|
164
|
+
const st = baseState('execute');
|
|
165
|
+
st.evidence.execute = { summary: 'executed' };
|
|
166
|
+
writeState(dir, st);
|
|
167
|
+
// LF 版本任务集(enter 时记录签名)
|
|
168
|
+
const taskLF = '# TASK\n\n' + TASK_DONE + TASK_P1;
|
|
169
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskLF);
|
|
170
|
+
assertExit(runGuard(['entry', 'execute'], dir), 0);
|
|
171
|
+
// 同一任务集改写为 CRLF 行尾(仅行尾差异,逻辑内容不变)
|
|
172
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskLF.replace(/\n/g, '\r\n'));
|
|
173
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
174
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', summaryContent()); // M2: 新 change 强制 done 任务须有 SUMMARY
|
|
175
|
+
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
176
|
+
st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'P01']) };
|
|
177
|
+
writeState(dir, st2);
|
|
178
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
179
|
+
assertExit(res, 0);
|
|
180
|
+
assertOut(res, 'ALL CHECKS PASSED');
|
|
181
|
+
},
|
|
182
|
+
},
|
|
183
|
+
|
|
184
|
+
// 41: execute exit BLOCKED——TASK.md 任务内容实际变化(改 action 文本)→ 签名不同 → 严格拦截
|
|
185
|
+
{
|
|
186
|
+
name: '41 execute exit BLOCKED:任务内容变化签名不同',
|
|
187
|
+
run: (dir) => {
|
|
188
|
+
const st = baseState('execute');
|
|
189
|
+
st.evidence.execute = { summary: 'executed' };
|
|
190
|
+
writeState(dir, st);
|
|
191
|
+
const taskLF = '# TASK\n\n' + TASK_DONE + TASK_P1;
|
|
192
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskLF);
|
|
193
|
+
assertExit(runGuard(['entry', 'execute'], dir), 0);
|
|
194
|
+
// 逻辑内容变化(T01 action 文本被改),行尾保持 LF 不变
|
|
195
|
+
const changed = taskLF.replace('实现 T01', '实现 T01 并补充单元测试');
|
|
196
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', changed);
|
|
197
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
198
|
+
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
199
|
+
st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'P01']) };
|
|
200
|
+
writeState(dir, st2);
|
|
201
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
202
|
+
assertExit(res, 1);
|
|
203
|
+
assertOut(res, 'TASK.md 任务集被修改');
|
|
204
|
+
},
|
|
205
|
+
},
|
|
206
|
+
|
|
207
|
+
// 42: next 回退豁免通过——verify 未 exit(completedNodes 无 verify + evidence 无 verify 记录)
|
|
208
|
+
// 但 TASK.md 存在 pending 修复任务且 determineNode 推导为 execute → 允许标准回退路径
|
|
209
|
+
// (verify 发现缺陷 → 回 execute),不 BLOCK,输出 NODE: execute
|
|
210
|
+
{
|
|
211
|
+
name: '42 next 回退豁免:verify 未 exit + pending 修复任务 → 允许回 execute',
|
|
212
|
+
run: (dir) => {
|
|
213
|
+
const st = baseState('verify');
|
|
214
|
+
st.completedNodes = ['open', 'design', 'plan', 'execute', 'subagent-execute', 'review'];
|
|
215
|
+
writeState(dir, st);
|
|
216
|
+
// 前置产物(preExec 门控:open/design/plan 的 CHANGE/REQUIREMENT/DESIGN/TASK)
|
|
217
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n');
|
|
218
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n');
|
|
219
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# DESIGN\n\n## 0. 技术栈\n');
|
|
220
|
+
// 既有 done 任务 + verify 阶段追加的 pending 修复任务
|
|
221
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE + TASK_P1 + TASK_TFIX);
|
|
222
|
+
const res = runStateWithProtocol(dir, ['next']);
|
|
223
|
+
assertExit(res, 0);
|
|
224
|
+
assertOut(res, 'NODE: execute');
|
|
225
|
+
assertNotOut(res, 'BLOCKED');
|
|
226
|
+
},
|
|
227
|
+
},
|
|
228
|
+
|
|
229
|
+
// 43: next 维持严格 BLOCK——verify 未 exit(evidence 无 verify 记录)且 TASK.md 无 pending
|
|
230
|
+
// 任务(非修复回退)→ 豁免不成立 → 维持 严格拦截,输出恢复指令
|
|
231
|
+
{
|
|
232
|
+
name: '43 next 维持 BLOCK:无 pending 任务(非修复任务回退)',
|
|
233
|
+
run: (dir) => {
|
|
234
|
+
const st = baseState('verify');
|
|
235
|
+
st.completedNodes = ['open', 'design', 'plan', 'execute', 'subagent-execute', 'review'];
|
|
236
|
+
writeState(dir, st);
|
|
237
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n');
|
|
238
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n');
|
|
239
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# DESIGN\n\n## 0. 技术栈\n');
|
|
240
|
+
// 全部 done(无 pending)——正常推进场景不豁免
|
|
241
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE + TASK_P1);
|
|
242
|
+
const res = runStateWithProtocol(dir, ['next']);
|
|
243
|
+
assertExit(res, 1);
|
|
244
|
+
assertOut(res, '疑似未 exit 节点 verify');
|
|
245
|
+
assertOut(res, 'workflow-guard.mjs exit verify --apply');
|
|
246
|
+
},
|
|
247
|
+
},
|
|
248
|
+
|
|
249
|
+
// ---------- 场景(C3 签名标记类属性剥离——completed_at 误报修复) ----------
|
|
250
|
+
|
|
251
|
+
// 44: execute exit 通过——enter 后子代理在 task 开标签追加 completed_at 标记属性
|
|
252
|
+
// (标记 task done 的时序属性,纯状态标记不影响任务集逻辑)→ 签名不受标记属性影响,不误报 BLOCK
|
|
253
|
+
{
|
|
254
|
+
name: '44 execute exit 通过:追加 completed_at 标记属性签名一致',
|
|
255
|
+
run: (dir) => {
|
|
256
|
+
const st = baseState('execute');
|
|
257
|
+
st.evidence.execute = { summary: 'executed' };
|
|
258
|
+
writeState(dir, st);
|
|
259
|
+
const taskLF = '# TASK\n\n' + TASK_DONE + TASK_P1;
|
|
260
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskLF);
|
|
261
|
+
assertExit(runGuard(['entry', 'execute'], dir), 0);
|
|
262
|
+
// 子代理标记 task done:T01 开标签追加 completed_at 属性(其余逻辑内容不变)
|
|
263
|
+
const marked = taskLF.replace('id="T01"', 'id="T01" completed_at="2026-08-07"');
|
|
264
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', marked);
|
|
265
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
266
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', summaryContent()); // M2: 新 change 强制 done 任务须有 SUMMARY
|
|
267
|
+
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
268
|
+
st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'P01']) };
|
|
269
|
+
writeState(dir, st2);
|
|
270
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
271
|
+
assertExit(res, 0);
|
|
272
|
+
assertOut(res, 'ALL CHECKS PASSED');
|
|
273
|
+
},
|
|
274
|
+
},
|
|
275
|
+
|
|
276
|
+
// 45: execute exit BLOCKED——追加 completed_at 标记属性 + 任务内容(action)实际变化
|
|
277
|
+
// → 标记属性剥离不越界:内容仍签名敏感 → 严格拦截"任务集被修改"
|
|
278
|
+
{
|
|
279
|
+
name: '45 execute exit BLOCKED:completed_at 标记属性 + action 变化签名不同',
|
|
280
|
+
run: (dir) => {
|
|
281
|
+
const st = baseState('execute');
|
|
282
|
+
st.evidence.execute = { summary: 'executed' };
|
|
283
|
+
writeState(dir, st);
|
|
284
|
+
const taskLF = '# TASK\n\n' + TASK_DONE + TASK_P1;
|
|
285
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', taskLF);
|
|
286
|
+
assertExit(runGuard(['entry', 'execute'], dir), 0);
|
|
287
|
+
// 内容实际变化(T01 action 文本被改)+ 同时追加 completed_at 标记属性
|
|
288
|
+
const changed = taskLF
|
|
289
|
+
.replace('id="T01"', 'id="T01" completed_at="2026-08-07"')
|
|
290
|
+
.replace('实现 T01', '实现 T01(改)');
|
|
291
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', changed);
|
|
292
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
293
|
+
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
294
|
+
st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'P01']) };
|
|
295
|
+
writeState(dir, st2);
|
|
296
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
297
|
+
assertExit(res, 1);
|
|
298
|
+
assertOut(res, 'TASK.md 任务集被修改');
|
|
299
|
+
},
|
|
300
|
+
},
|
|
301
|
+
|
|
302
|
+
// ---------- 场景(next 正常推进豁免——exit 推进后的正常 next 不再被误拦) ----------
|
|
303
|
+
|
|
304
|
+
// 46: next 正常推进豁免通过——open exit --apply 已把 currentNode 推进到 design(completedNodes=['open']、
|
|
305
|
+
// design 尚未开始故 evidence 无 design 记录),随后按 SKILL 协议调 next(正常路径)→ 不 BLOCK,
|
|
306
|
+
// 输出 NODE: design( 误拦回归:修复前此状态被 BLOCK 为"疑似未 exit 节点 design";
|
|
307
|
+
// open 的 evidence 证明该 exit 真实发生过,满足 normalAdvanceExempt)
|
|
308
|
+
{
|
|
309
|
+
name: '46 next 正常:open exit 推进后 currentNode=design 无 evidence(修复任务回退豁免)',
|
|
310
|
+
run: (dir) => {
|
|
311
|
+
const st = baseState('design');
|
|
312
|
+
st.completedNodes = ['open'];
|
|
313
|
+
st.evidence.open = { summary: 'open done' };
|
|
314
|
+
writeState(dir, st);
|
|
315
|
+
// open exit 已通过的产物(design 尚未开始,无 DESIGN.md)
|
|
316
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n');
|
|
317
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n');
|
|
318
|
+
const res = runStateWithProtocol(dir, ['next']);
|
|
319
|
+
assertExit(res, 0);
|
|
320
|
+
assertOut(res, 'NODE: design');
|
|
321
|
+
assertNotOut(res, 'BLOCKED');
|
|
322
|
+
},
|
|
323
|
+
},
|
|
324
|
+
|
|
325
|
+
// 47: next 维持严格 BLOCK——真乱序跳节点:currentNode=review 但 completedNodes 仅 ['open']
|
|
326
|
+
// (open 已 exit 且有 evidence)→ review 不是 open 的路由直接后继(open 的后继是 design)
|
|
327
|
+
// → 豁免不成立(回退豁免也不成立:TASK.md 无 pending)→ 严格拦截核心价值
|
|
328
|
+
// 保持(跳节点仍严格拦截),输出恢复指令
|
|
329
|
+
{
|
|
330
|
+
name: '47 next BLOCKED:跳节点乱序(completedNodes 仅 open,currentNode=review)',
|
|
331
|
+
run: (dir) => {
|
|
332
|
+
const st = baseState('review');
|
|
333
|
+
st.completedNodes = ['open'];
|
|
334
|
+
st.evidence.open = { summary: 'open done' };
|
|
335
|
+
writeState(dir, st);
|
|
336
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n');
|
|
337
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n');
|
|
338
|
+
const res = runStateWithProtocol(dir, ['next']);
|
|
339
|
+
assertExit(res, 1);
|
|
340
|
+
assertOut(res, '疑似未 exit 节点 review');
|
|
341
|
+
assertOut(res, 'workflow-guard.mjs exit review --apply');
|
|
342
|
+
},
|
|
343
|
+
},
|
|
344
|
+
|
|
345
|
+
// ---------- 场景(机制交互组合——两个机制同时作用,防单机制测试盲区) ----------
|
|
346
|
+
|
|
347
|
+
// 48: 组合盲区 A(对照组 A 撞出)——record 覆盖语义 × 越俎代庖检测:先经 workflow-handoff
|
|
348
|
+
// result 正确记录 T01 的 Return Contract(含 completedChecks),随后 record subagent-execute
|
|
349
|
+
// '{"handoffResult":{}}'(浅合并整体替换 handoffResult 键)把已记录的 handoff 覆盖丢失 →
|
|
350
|
+
// exit execute 的越俎代庖检测(统一委托下 done 任务必须有 handoff)BLOCK——
|
|
351
|
+
// 组合语义:record 的"整体覆盖"不是无害操作,会连带破坏委托证明链(T01 合法 done 变越俎代庖)
|
|
352
|
+
{
|
|
353
|
+
name: '48 execute exit BLOCKED:record 覆盖 handoff(越俎代庖)',
|
|
354
|
+
run: (dir) => {
|
|
355
|
+
const st = baseState('execute');
|
|
356
|
+
st.evidence.execute = { summary: 'executed' };
|
|
357
|
+
writeState(dir, st);
|
|
358
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
359
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
360
|
+
// ① workflow-handoff result 正确记录 T01 的 Return Contract(含 completedChecks)
|
|
361
|
+
const res = runHandoff(['result', 'T01', JSON.stringify({
|
|
362
|
+
commitHash: 'abcd1234',
|
|
363
|
+
completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
|
|
364
|
+
greenEvidence: { command: 'node --check src/t1.mjs' },
|
|
365
|
+
redEvidence: { command: 'node --check src/t1.mjs' },
|
|
366
|
+
})], dir);
|
|
367
|
+
assertExit(res, 0);
|
|
368
|
+
assertOut(res, 'HANDOFF RESULT: T01');
|
|
369
|
+
// ② record subagent-execute '{"handoffResult":{}}' 整体覆盖 evidence['subagent-execute']
|
|
370
|
+
//(浅合并替换 handoffResult 键)→ 已记录的 T01 handoff 丢失(对照组 A 踩坑路径)
|
|
371
|
+
assertExit(runStateWithProtocol(dir, ['record', 'subagent-execute', '{"handoffResult":{}}']), 0);
|
|
372
|
+
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
373
|
+
const hr = st2.evidence['subagent-execute'] && st2.evidence['subagent-execute'].handoffResult;
|
|
374
|
+
if (!hr || hr['T01']) {
|
|
375
|
+
throw new Error('record 未整体覆盖 handoffResult(T01 应被覆盖丢失): ' + JSON.stringify(st2.evidence['subagent-execute']));
|
|
376
|
+
}
|
|
377
|
+
// ③ exit execute:T01 done 但 handoff 已被覆盖丢失 → 越俎代庖 BLOCK
|
|
378
|
+
const res2 = runGuard(['exit', 'execute'], dir);
|
|
379
|
+
assertExit(res2, 1);
|
|
380
|
+
assertOut(res2, '越俎代庖');
|
|
381
|
+
},
|
|
382
|
+
},
|
|
383
|
+
|
|
384
|
+
// 49(多趟语义翻转):路由 × 节点推进——subagent-execute 已 completed(第一波 parallel 全 done +
|
|
385
|
+
// exit,completedNodes 含该节点)后,第二波 parallel 任务(P02,depends 已满足)出现时:
|
|
386
|
+
// next 重新路由回 subagent-execute(多趟循环路由——委托进入谓词每趟重新求值,单趟限制已移除);
|
|
387
|
+
// entry subagent-execute 仍放行(completedNodes 含该节点允许重入——每趟完整 entry 检查不绕过)
|
|
388
|
+
{
|
|
389
|
+
name: '49 next 二次路由回 subagent-execute + entry 重入(多趟语义)',
|
|
390
|
+
run: (dir) => {
|
|
391
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n');
|
|
392
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n');
|
|
393
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# DESIGN\n\n## 0. 技术栈\n');
|
|
394
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1 + TASK_P2_PENDING + TASK_T03_PENDING);
|
|
395
|
+
const st = baseState('subagent-execute');
|
|
396
|
+
st.completedNodes = ['open', 'design', 'plan', 'execute', 'subagent-execute'];
|
|
397
|
+
st.evidence['subagent-execute'] = { summary: 'wave1 delegated and collected' };
|
|
398
|
+
writeState(dir, st);
|
|
399
|
+
// ① next:第二波 eligible 并行存在 → 多趟路由回该节点(旧单趟「不回流」行为已移除)
|
|
400
|
+
const res = runStateWithProtocol(dir, ['next']);
|
|
401
|
+
assertExit(res, 0);
|
|
402
|
+
assertOut(res, 'NODE: subagent-execute');
|
|
403
|
+
// ② entry subagent-execute:completedNodes 含该节点仍可重入(每趟完整 entry 检查)
|
|
404
|
+
const res2 = runGuard(['entry', 'subagent-execute'], dir);
|
|
405
|
+
assertExit(res2, 0);
|
|
406
|
+
assertOut(res2, 'ENTRY OK');
|
|
407
|
+
},
|
|
408
|
+
},
|
|
409
|
+
|
|
410
|
+
// ---------- 校验补充场景(协议 schema nodes 校验 / 豁免 summary 严格化 / hook 声明模式 fail-closed) ----------
|
|
411
|
+
|
|
412
|
+
// 50: validateProtocolSchema 拒绝空 node(自定义协议 nodes 含空对象 → 加载报错 fail-closed)
|
|
413
|
+
{
|
|
414
|
+
name: '50 自定义协议空 node:schema 校验拒绝(审查补充)',
|
|
415
|
+
run: (dir) => {
|
|
416
|
+
const badProtocol = customProtocol();
|
|
417
|
+
badProtocol.nodes.push({});
|
|
418
|
+
writeFile(dir, 'bad-protocol.json', JSON.stringify(badProtocol, null, 2) + '\n');
|
|
419
|
+
const res = runState(['status', '--protocol', path.join(dir, 'bad-protocol.json')], dir);
|
|
420
|
+
assertExit(res, 1);
|
|
421
|
+
assertOut(res, 'workflow protocol node must have a non-empty string id');
|
|
422
|
+
},
|
|
423
|
+
},
|
|
424
|
+
|
|
425
|
+
// 51: normalAdvanceExempt 空对象 evidence 不豁免(completedNodes 最后节点 evidence 是 {} → next BLOCK)
|
|
426
|
+
{
|
|
427
|
+
name: '51 next BLOCKED:豁免节点 evidence 为空对象(审查补充)',
|
|
428
|
+
run: (dir) => {
|
|
429
|
+
const custom = writeCustomProtocol(dir);
|
|
430
|
+
writeState(dir, composeState({
|
|
431
|
+
currentNode: 'tdd',
|
|
432
|
+
completedNodes: ['brainstorm'],
|
|
433
|
+
evidence: { brainstorm: {} },
|
|
434
|
+
}));
|
|
435
|
+
writeFile(dir, '.specs/compose-demo/notes.md', '# notes\n');
|
|
436
|
+
const res = runState(['next', '--protocol', custom], dir);
|
|
437
|
+
assertExit(res, 1);
|
|
438
|
+
assertOut(res, 'BLOCKED');
|
|
439
|
+
},
|
|
440
|
+
},
|
|
441
|
+
|
|
442
|
+
// 52: 协议声明 writeWhitelist 未列出节点 → hook BLOCK(fail-closed)
|
|
443
|
+
{
|
|
444
|
+
name: '52 hook BLOCKED:writeWhitelist 未声明节点(审查补充)',
|
|
445
|
+
run: (dir) => {
|
|
446
|
+
const custom = customProtocol();
|
|
447
|
+
custom.writeWhitelist = { brainstorm: ['.specs/'] };
|
|
448
|
+
writeFile(dir, 'partial-protocol.json', JSON.stringify(custom, null, 2) + '\n');
|
|
449
|
+
writeState(dir, composeState({ status: 'running', currentNode: 'tdd' }));
|
|
450
|
+
const res = runHook(['before_tool'], dir,
|
|
451
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, '.specs', 'compose-demo', 'notes.md') } },
|
|
452
|
+
{ FLOW_COMET_PROTOCOL: path.join(dir, 'partial-protocol.json') });
|
|
453
|
+
assertExit(res, 2);
|
|
454
|
+
assertOut(res, '未在协议 writeWhitelist 中声明');
|
|
455
|
+
},
|
|
456
|
+
},
|
|
457
|
+
|
|
458
|
+
// ---------- 场景(分支前缀可配置,适配仓库规范) ----------
|
|
459
|
+
|
|
460
|
+
// 53: init --branch-prefix feat/ → 分支创建为 feat/<id>(适配仓库规范如 feat/)
|
|
461
|
+
{
|
|
462
|
+
name: '53 init --branch-prefix feat/ 创建 feat/<id> 分支',
|
|
463
|
+
run: (dir) => {
|
|
464
|
+
execFileSync('git', ['init', '-q'], { cwd: dir, stdio: 'ignore' });
|
|
465
|
+
execFileSync('git', ['-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '--allow-empty', '-m', 'init'], { cwd: dir, stdio: 'ignore' });
|
|
466
|
+
const res = runStateWithProtocol(dir, ['init', 'prefix-test', '--branch-prefix', 'feat/']);
|
|
467
|
+
assertExit(res, 0);
|
|
468
|
+
assertOut(res, 'BRANCH: feat/prefix-test');
|
|
469
|
+
const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: dir, encoding: 'utf8' }).trim();
|
|
470
|
+
if (branch !== 'feat/prefix-test') {
|
|
471
|
+
throw new Error('期望分支 feat/prefix-test,实际 ' + branch);
|
|
472
|
+
}
|
|
473
|
+
},
|
|
474
|
+
},
|
|
475
|
+
|
|
476
|
+
// 54: 一致性校验用 state.branchPrefix(status 显示 ok)
|
|
477
|
+
{
|
|
478
|
+
name: '54 status 一致性:branchPrefix=feat/ 分支 feat/<id> → ok',
|
|
479
|
+
run: (dir) => {
|
|
480
|
+
execFileSync('git', ['init', '-q'], { cwd: dir, stdio: 'ignore' });
|
|
481
|
+
execFileSync('git', ['-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '--allow-empty', '-m', 'init'], { cwd: dir, stdio: 'ignore' });
|
|
482
|
+
execFileSync('git', ['checkout', '-b', 'feat/pref-state'], { cwd: dir, stdio: 'ignore' });
|
|
483
|
+
const st = baseState('open');
|
|
484
|
+
st.activeChange = 'pref-state';
|
|
485
|
+
st.branchPrefix = 'feat/';
|
|
486
|
+
writeState(dir, st);
|
|
487
|
+
writeFile(dir, '.specs/pref-state/CHANGE.md', '# CHANGE\n## Why\nx\n');
|
|
488
|
+
writeFile(dir, '.specs/pref-state/REQUIREMENT.md', '# REQUIREMENT\n## 用户故事\nx\n## 验收准则(AC)\nx\n');
|
|
489
|
+
const res = runStateWithProtocol(dir, ['status']);
|
|
490
|
+
assertExit(res, 0);
|
|
491
|
+
assertOut(res, '一致性: ok');
|
|
492
|
+
},
|
|
493
|
+
},
|
|
494
|
+
|
|
495
|
+
// ---------- 场景(init 写 status + hook 判定对齐) ----------
|
|
496
|
+
|
|
497
|
+
// 55: init 生成的 state 必须含 status:'running'(当前缺——hook 判定不一致的根源)
|
|
498
|
+
{
|
|
499
|
+
name: '55 init state 含 status: running',
|
|
500
|
+
run: (dir) => {
|
|
501
|
+
const res = runStateWithProtocol(dir, ['init', 'tf15-st']);
|
|
502
|
+
assertExit(res, 0);
|
|
503
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
504
|
+
if (st.status !== 'running') {
|
|
505
|
+
throw new Error('init state 缺 status: running,实际: ' + JSON.stringify(st.status));
|
|
506
|
+
}
|
|
507
|
+
},
|
|
508
|
+
},
|
|
509
|
+
|
|
510
|
+
// 56: init 后(open 阶段)越权写源码 → hook BLOCK(当前因 status undefined 放行——三层防线缺口)
|
|
511
|
+
{
|
|
512
|
+
name: '56 hook BLOCKED:init 后越权写源码',
|
|
513
|
+
run: (dir) => {
|
|
514
|
+
const initRes = runStateWithProtocol(dir, ['init', 'tf15-hk']);
|
|
515
|
+
assertExit(initRes, 0);
|
|
516
|
+
const res = runHook(['before_tool'], dir,
|
|
517
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, 'src', 'evil.py') } });
|
|
518
|
+
assertExit(res, 2);
|
|
519
|
+
},
|
|
520
|
+
},
|
|
521
|
+
|
|
522
|
+
// 57: status:'completed'(归档后状态)→ hook 放行(当前 exit 1 拦截全部写入)
|
|
523
|
+
{
|
|
524
|
+
name: '57 hook 放行:status completed 归档后状态',
|
|
525
|
+
run: (dir) => {
|
|
526
|
+
writeState(dir, composeState({ status: 'completed', activeChange: null, currentNode: null }));
|
|
527
|
+
const res = runHook(['before_tool'], dir,
|
|
528
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, 'anything.md') } });
|
|
529
|
+
assertExit(res, 0);
|
|
530
|
+
},
|
|
531
|
+
},
|
|
532
|
+
|
|
533
|
+
// ---------- 场景(init 创建 .specs/<id>/ 目录,findActiveChange 立即可识别) ----------
|
|
534
|
+
|
|
535
|
+
// 58: init 后 next 识别 active change(当前因 .specs/<id>/ 目录未建报 No active change)
|
|
536
|
+
{
|
|
537
|
+
name: '58 init 后 next 识别 active change',
|
|
538
|
+
run: (dir) => {
|
|
539
|
+
const initRes = runStateWithProtocol(dir, ['init', 'tf16-dir']);
|
|
540
|
+
assertExit(initRes, 0);
|
|
541
|
+
const res = runStateWithProtocol(dir, ['next']);
|
|
542
|
+
assertExit(res, 1);
|
|
543
|
+
assertOut(res, '疑似未 exit 节点 open');
|
|
544
|
+
assertNotOut(res, 'No active change');
|
|
545
|
+
},
|
|
546
|
+
},
|
|
547
|
+
|
|
548
|
+
// ---------- 场景(归档完成态不兜底识别残留目录) ----------
|
|
549
|
+
|
|
550
|
+
// 59: state 为归档完成态(completed + activeChange null)→ .specs/ 顶层残留目录(含 TASK.md)不被兜底识别
|
|
551
|
+
{
|
|
552
|
+
name: '59 归档后残留目录不误判为 active',
|
|
553
|
+
run: (dir) => {
|
|
554
|
+
writeState(dir, composeState({ status: 'completed', activeChange: null, currentNode: null }));
|
|
555
|
+
writeFile(dir, '.specs/stale/CHANGE.md', '# CHANGE\n## Why\nx\n');
|
|
556
|
+
writeFile(dir, '.specs/stale/TASK.md', '# TASK\n');
|
|
557
|
+
const res = runStateWithProtocol(dir, ['status']);
|
|
558
|
+
assertExit(res, 0);
|
|
559
|
+
assertOut(res, 'no-change');
|
|
560
|
+
assertNotOut(res, 'stale');
|
|
561
|
+
},
|
|
562
|
+
},
|
|
563
|
+
|
|
564
|
+
// ---------- 场景(init currentNode 按协议首节点) ----------
|
|
565
|
+
|
|
566
|
+
// 60: 自定义协议 init → currentNode = 协议首节点 brainstorm(当前硬编码 open——)
|
|
567
|
+
{
|
|
568
|
+
name: '60 init currentNode 按协议首节点',
|
|
569
|
+
run: (dir) => {
|
|
570
|
+
const custom = writeCustomProtocol(dir);
|
|
571
|
+
const initRes = runState(['init', 'tf18-cp'], dir, { FLOW_COMET_PROTOCOL: custom });
|
|
572
|
+
assertExit(initRes, 0);
|
|
573
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
574
|
+
if (st.currentNode !== 'brainstorm') {
|
|
575
|
+
throw new Error('init currentNode 应为协议首节点 brainstorm,实际: ' + JSON.stringify(st.currentNode));
|
|
576
|
+
}
|
|
577
|
+
},
|
|
578
|
+
},
|
|
579
|
+
|
|
580
|
+
// ---------- 补齐场景(兼容分支固化) ----------
|
|
581
|
+
|
|
582
|
+
// 61: 旧 state(无 status 字段但有 activeChange)→ hook 按 running 处理(fail-closed 向后兼容,行为固化)
|
|
583
|
+
{
|
|
584
|
+
name: '61 hook fail-closed:旧 state 无 status 有 activeChange 按 running(既有修复固化)',
|
|
585
|
+
run: (dir) => {
|
|
586
|
+
const st = baseState('open');
|
|
587
|
+
delete st.status;
|
|
588
|
+
st.activeChange = 'legacy-change';
|
|
589
|
+
writeState(dir, st);
|
|
590
|
+
const res = runHook(['before_tool'], dir,
|
|
591
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, 'src', 'evil.py') } });
|
|
592
|
+
assertExit(res, 2);
|
|
593
|
+
},
|
|
594
|
+
},
|
|
595
|
+
|
|
596
|
+
// 62: init 后(open 阶段)合法写 .specs/ 工件 → hook 放行( 正确 RED:
|
|
597
|
+
// 修复前 init 无 status → hook「not running」throw exit 1 拦截合法写入——open 阶段无法产出工件)
|
|
598
|
+
{
|
|
599
|
+
name: '62 hook 放行:init 后写 .specs/ 工件',
|
|
600
|
+
run: (dir) => {
|
|
601
|
+
const initRes = runStateWithProtocol(dir, ['init', 'tf15-ok']);
|
|
602
|
+
assertExit(initRes, 0);
|
|
603
|
+
const res = runHook(['before_tool'], dir,
|
|
604
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, '.specs', 'tf15-ok', 'CHANGE.md') } });
|
|
605
|
+
assertExit(res, 0);
|
|
606
|
+
assertOut(res, 'NODE: open');
|
|
607
|
+
},
|
|
608
|
+
},
|
|
609
|
+
|
|
610
|
+
// 63: 新 change 与旧归档同名(state 缺失时走扫描兜底)→ 应识别为 active( 扩展边界:
|
|
611
|
+
// archivedIds 剥日期前缀匹配不得误伤同名新 change)
|
|
612
|
+
{
|
|
613
|
+
name: '63 同名新 change 不被归档检查误跳过',
|
|
614
|
+
run: (dir) => {
|
|
615
|
+
writeFile(dir, '.specs/sci-notation/CHANGE.md', '# CHANGE\n## Why\nx\n');
|
|
616
|
+
writeFile(dir, '.specs/sci-notation/TASK.md', '# TASK\n');
|
|
617
|
+
writeFile(dir, '.specs/archive/2026-08-08-sci-notation/CHANGE.md', '# CHANGE\n## Why\nx\n');
|
|
618
|
+
const res = runStateWithProtocol(dir, ['status']);
|
|
619
|
+
assertExit(res, 0);
|
|
620
|
+
assertOut(res, '"change": "sci-notation"');
|
|
621
|
+
},
|
|
622
|
+
},
|
|
623
|
+
|
|
624
|
+
// ---------- 边界补充场景 ----------
|
|
625
|
+
|
|
626
|
+
// 64: record 命令的 --protocol 参数不得污染 payload(:payload 解析前剥离)
|
|
627
|
+
{
|
|
628
|
+
name: '64 record --protocol 不污染 payload',
|
|
629
|
+
run: (dir) => {
|
|
630
|
+
const custom = writeCustomProtocol(dir);
|
|
631
|
+
const initRes = runStateWithProtocol(dir, ['init', 'tf14-rec']);
|
|
632
|
+
assertExit(initRes, 0);
|
|
633
|
+
const res = runState(['record', 'open', '{"summary":"x","completedChecks":["a"]}', '--protocol', custom], dir);
|
|
634
|
+
assertExit(res, 0);
|
|
635
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
636
|
+
const ev = st.evidence.open || {};
|
|
637
|
+
if (ev.summary !== 'x') {
|
|
638
|
+
throw new Error('summary 被污染,应为 "x",实际: ' + JSON.stringify(ev.summary));
|
|
639
|
+
}
|
|
640
|
+
if (ev.completedChecks === undefined) {
|
|
641
|
+
throw new Error('completedChecks 丢失(payload 未解析为对象): ' + JSON.stringify(ev));
|
|
642
|
+
}
|
|
643
|
+
},
|
|
644
|
+
},
|
|
645
|
+
|
|
646
|
+
// 65: 自定义协议未声明 writeWhitelist 时,非内置节点写源码 → BLOCK( 方案 B:
|
|
647
|
+
// 协调者默认 .specs/——当前 fail-open 放行)
|
|
648
|
+
{
|
|
649
|
+
name: '65 自定义节点未声明白名单写源码 BLOCK',
|
|
650
|
+
run: (dir) => {
|
|
651
|
+
const custom = writeCustomProtocol(dir);
|
|
652
|
+
writeState(dir, composeState({ status: 'running' }));
|
|
653
|
+
const res = runHook(['before_tool'], dir,
|
|
654
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, 'src', 'evil.py') } },
|
|
655
|
+
{ FLOW_COMET_PROTOCOL: custom });
|
|
656
|
+
assertExit(res, 2);
|
|
657
|
+
},
|
|
658
|
+
},
|
|
659
|
+
|
|
660
|
+
// 66: 自定义协议未声明白名单时,写 .specs/ 工件 → 放行( 协调者默认的正面)
|
|
661
|
+
{
|
|
662
|
+
name: '66 自定义节点未声明白名单写工件放行',
|
|
663
|
+
run: (dir) => {
|
|
664
|
+
const custom = writeCustomProtocol(dir);
|
|
665
|
+
writeState(dir, composeState({ status: 'running' }));
|
|
666
|
+
const res = runHook(['before_tool'], dir,
|
|
667
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, '.specs', 'compose-demo', 'notes.md') } },
|
|
668
|
+
{ FLOW_COMET_PROTOCOL: custom });
|
|
669
|
+
assertExit(res, 0);
|
|
670
|
+
assertOut(res, 'NODE: brainstorm');
|
|
671
|
+
},
|
|
672
|
+
},
|
|
673
|
+
|
|
674
|
+
// 67: 旧格式 state(无 status 字段 + 无 activeChange + 无 currentNode——归档批次的升级场景)
|
|
675
|
+
// → hook 放行(:无 activeChange 与无 state 文件同语义——当前被「not running」拦截)
|
|
676
|
+
{
|
|
677
|
+
name: '67 旧 state 无 status 无 activeChange hook 放行',
|
|
678
|
+
run: (dir) => {
|
|
679
|
+
const st = baseState('open');
|
|
680
|
+
delete st.status;
|
|
681
|
+
st.activeChange = null;
|
|
682
|
+
st.currentNode = null;
|
|
683
|
+
writeState(dir, st);
|
|
684
|
+
const res = runHook(['before_tool'], dir,
|
|
685
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, 'src', 'evil.py') } });
|
|
686
|
+
assertExit(res, 0);
|
|
687
|
+
},
|
|
688
|
+
},
|
|
689
|
+
|
|
690
|
+
// 68: writeWhitelist 路径支持 <change-id> 占位符(:协议复用自动适配——
|
|
691
|
+
// 与 artifacts paths 同机制——当前字面匹配失败 BLOCK)
|
|
692
|
+
{
|
|
693
|
+
name: '68 writeWhitelist change-id 占位符',
|
|
694
|
+
run: (dir) => {
|
|
695
|
+
const custom = customProtocol();
|
|
696
|
+
custom.writeWhitelist = { brainstorm: ['.specs/<change-id>/'] };
|
|
697
|
+
writeFile(dir, 'ph-protocol.json', JSON.stringify(custom, null, 2) + '\n');
|
|
698
|
+
writeState(dir, composeState({ status: 'running' }));
|
|
699
|
+
// 写 .specs/compose-demo/(占位符替换为 activeChange=compose-demo)→ 放行
|
|
700
|
+
const r1 = runHook(['before_tool'], dir,
|
|
701
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, '.specs', 'compose-demo', 'notes.md') } },
|
|
702
|
+
{ FLOW_COMET_PROTOCOL: path.join(dir, 'ph-protocol.json') });
|
|
703
|
+
assertExit(r1, 0);
|
|
704
|
+
// 写 .specs/other/(不在白名单)→ BLOCK
|
|
705
|
+
const r2 = runHook(['before_tool'], dir,
|
|
706
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, '.specs', 'other', 'x.md') } },
|
|
707
|
+
{ FLOW_COMET_PROTOCOL: path.join(dir, 'ph-protocol.json') });
|
|
708
|
+
assertExit(r2, 2);
|
|
709
|
+
},
|
|
710
|
+
},
|
|
711
|
+
|
|
712
|
+
// 69: 自定义协议 init 输出 NODE: 协议首节点(:printNext 硬编码 open——输出与 state 不一致)
|
|
713
|
+
{
|
|
714
|
+
name: '69 init 输出 NODE 协议首节点',
|
|
715
|
+
run: (dir) => {
|
|
716
|
+
const custom = writeCustomProtocol(dir);
|
|
717
|
+
const res = runState(['init', 'tf17-out'], dir, { FLOW_COMET_PROTOCOL: custom });
|
|
718
|
+
assertExit(res, 0);
|
|
719
|
+
assertOut(res, 'NODE: brainstorm');
|
|
720
|
+
assertNotOut(res, 'NODE: open');
|
|
721
|
+
},
|
|
722
|
+
},
|
|
723
|
+
|
|
724
|
+
// 70: state completed + activeChange 非空(残留值)→ status 应 no-change(:
|
|
725
|
+
// completed 检查优先于 activeChange 分支——当前 activeChange 分支先命中误判)
|
|
726
|
+
{
|
|
727
|
+
name: '70 completed state 残留 activeChange 不误判',
|
|
728
|
+
run: (dir) => {
|
|
729
|
+
const st = composeState({ status: 'completed', currentNode: null });
|
|
730
|
+
st.activeChange = 'stale-id';
|
|
731
|
+
writeState(dir, st);
|
|
732
|
+
writeFile(dir, '.specs/stale-id/CHANGE.md', '# CHANGE\n## Why\nx\n');
|
|
733
|
+
writeFile(dir, '.specs/stale-id/TASK.md', '# TASK\n');
|
|
734
|
+
const res = runStateWithProtocol(dir, ['status']);
|
|
735
|
+
assertExit(res, 0);
|
|
736
|
+
assertOut(res, 'no-change');
|
|
737
|
+
},
|
|
738
|
+
},
|
|
739
|
+
|
|
740
|
+
// 71: 自定义协议未声明 state.statePath(最小 schema)→ hook 不崩溃,写 .specs/ 放行
|
|
741
|
+
// (:statePath 缺省回退 .flow-comet/flow-comet-state.json——与 workflow-state 硬编码一致;
|
|
742
|
+
// 当前空值解析崩溃 exit 1 全量拦截)
|
|
743
|
+
{
|
|
744
|
+
name: '71 无 statePath 协议 hook 不崩溃',
|
|
745
|
+
run: (dir) => {
|
|
746
|
+
const custom = customProtocol();
|
|
747
|
+
delete custom.state;
|
|
748
|
+
writeFile(dir, 'nostate-protocol.json', JSON.stringify(custom, null, 2) + '\n');
|
|
749
|
+
writeState(dir, composeState({ status: 'running' }));
|
|
750
|
+
const res = runHook(['before_tool'], dir,
|
|
751
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, '.specs', 'compose-demo', 'notes.md') } },
|
|
752
|
+
{ FLOW_COMET_PROTOCOL: path.join(dir, 'nostate-protocol.json') });
|
|
753
|
+
assertExit(res, 0);
|
|
754
|
+
},
|
|
755
|
+
},
|
|
756
|
+
|
|
757
|
+
// 72: state 文件带 UTF-8 BOM(外部写入如会话 Write)→ status 正常输出(:
|
|
758
|
+
// 读端 JSON.parse 应容忍 BOM——当前崩)
|
|
759
|
+
{
|
|
760
|
+
name: '72 state 带 BOM 正常读取',
|
|
761
|
+
run: (dir) => {
|
|
762
|
+
const st = composeState({ status: 'running' });
|
|
763
|
+
const raw = '' + JSON.stringify(st, null, 2) + '\n';
|
|
764
|
+
fs.mkdirSync(path.join(dir, '.flow-comet'), { recursive: true });
|
|
765
|
+
fs.writeFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), raw, 'utf8');
|
|
766
|
+
writeFile(dir, '.specs/compose-demo/CHANGE.md', '# CHANGE\n## Why\nx\n');
|
|
767
|
+
const res = runStateWithProtocol(dir, ['status']);
|
|
768
|
+
assertExit(res, 0);
|
|
769
|
+
assertOut(res, '"status": "running"');
|
|
770
|
+
},
|
|
771
|
+
},
|
|
772
|
+
|
|
773
|
+
// 73: hook 读带 BOM 的 state → 判定正常(——hook readStateJson 的 BOM 容忍)
|
|
774
|
+
{
|
|
775
|
+
name: '73 hook 读带 BOM state 正常',
|
|
776
|
+
run: (dir) => {
|
|
777
|
+
const st = baseState('open');
|
|
778
|
+
st.status = 'running';
|
|
779
|
+
const raw = '' + JSON.stringify(st, null, 2) + '\n';
|
|
780
|
+
fs.mkdirSync(path.join(dir, '.flow-comet'), { recursive: true });
|
|
781
|
+
fs.writeFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), raw, 'utf8');
|
|
782
|
+
const res = runHook(['before_tool'], dir,
|
|
783
|
+
{ tool_name: 'Write', tool_input: { file_path: path.join(dir, '.specs', 'compose-demo', 'CHANGE.md') } });
|
|
784
|
+
assertExit(res, 0);
|
|
785
|
+
assertOut(res, 'NODE: open');
|
|
786
|
+
},
|
|
787
|
+
},
|
|
788
|
+
|
|
789
|
+
// ---------- 场景(builtin 降级须含缓存尝试证据) ----------
|
|
790
|
+
|
|
791
|
+
// 74: builtin-quickcheck 声明 + 不可用原因但无缓存尝试证据 → BROOKS-LINT WARN
|
|
792
|
+
// (:防「未尝试 Read 插件缓存协议文件」的偷懒降级——修复前不校验 = RED)
|
|
793
|
+
{
|
|
794
|
+
name: '74 builtin 无缓存尝试证据 → WARN',
|
|
795
|
+
run: (dir) => {
|
|
796
|
+
const st = baseState('execute');
|
|
797
|
+
st.evidence.execute = { summary: 'executed' };
|
|
798
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
799
|
+
writeState(dir, st);
|
|
800
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
801
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent({
|
|
802
|
+
method: '## 自检方法\n\nbuiltin-quickcheck — brooks-lint 不可用(Skill 仅返回占位,插件执行体未加载),按协议降级内置 R1~R6 快查',
|
|
803
|
+
}));
|
|
804
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
805
|
+
assertExit(res, 0);
|
|
806
|
+
assertOut(res, 'BROOKS-LINT WARN');
|
|
807
|
+
},
|
|
808
|
+
},
|
|
809
|
+
|
|
810
|
+
// 75: cache-brooks 声明(两级降级路径第 2 级——读缓存手动执行成功)→ 放行
|
|
811
|
+
// ( 补:guard method 正则须识别 cache-brooks——修复前正则不匹配 → 全文无 brooks-review/builtin → BLOCKED = RED)
|
|
812
|
+
{
|
|
813
|
+
name: '75 cache-brooks 声明 → 放行',
|
|
814
|
+
run: (dir) => {
|
|
815
|
+
const st = baseState('execute');
|
|
816
|
+
st.evidence.execute = { summary: 'executed' };
|
|
817
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
818
|
+
writeState(dir, st);
|
|
819
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
820
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent({
|
|
821
|
+
method: '## 自检方法\n\ncache-brooks — 已 Read 插件缓存协议文件手动执行完整审查(4-element + file:line + 书引用),结果见「6 维自查」',
|
|
822
|
+
sixDim: '## 6 维自查\n\n- 功能: 通过(cache-brooks 审查已跑)\n- 性能: 无影响\n- 安全: 无影响\n- 兼容: 通过\n- 可观测: 通过\n- 可维护: 通过',
|
|
823
|
+
}));
|
|
824
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
825
|
+
assertExit(res, 0);
|
|
826
|
+
assertNotOut(res, 'BLOCKED');
|
|
827
|
+
assertNotOut(res, 'BROOKS-LINT WARN');
|
|
828
|
+
},
|
|
829
|
+
},
|
|
830
|
+
|
|
831
|
+
// 76: builtin-quickcheck 声明 + 不可用原因 + 含缓存尝试证据(已 Read 插件缓存协议文件)→ 无 WARN 放行
|
|
832
|
+
// ( 正面:两级降级路径的第 2 级被正确执行后的合法态)
|
|
833
|
+
{
|
|
834
|
+
name: '76 builtin 含缓存尝试证据 → 无 WARN',
|
|
835
|
+
run: (dir) => {
|
|
836
|
+
const st = baseState('execute');
|
|
837
|
+
st.evidence.execute = { summary: 'executed' };
|
|
838
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
839
|
+
writeState(dir, st);
|
|
840
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
841
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent({
|
|
842
|
+
method: '## 自检方法\n\nbuiltin-quickcheck — 已尝试 Skill 加载(仅占位)并已 Read 插件缓存协议文件(~/.claude/plugins/cache/brooks-lint-marketplace/...)手动执行,仍不可行,brooks-lint 不可用,按协议降级内置 R1~R6 快查',
|
|
843
|
+
}));
|
|
844
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
845
|
+
assertExit(res, 0);
|
|
846
|
+
assertNotOut(res, 'BROOKS-LINT WARN');
|
|
847
|
+
},
|
|
848
|
+
},
|
|
849
|
+
|
|
850
|
+
// 77: guard 读带 BOM 的 state → 正常(——guard readStateJson 的 BOM 容忍)
|
|
851
|
+
{
|
|
852
|
+
name: '77 guard 读带 BOM state 正常',
|
|
853
|
+
run: (dir) => {
|
|
854
|
+
const st = baseState('open');
|
|
855
|
+
st.status = 'running';
|
|
856
|
+
const raw = '' + JSON.stringify(st, null, 2) + '\n';
|
|
857
|
+
fs.mkdirSync(path.join(dir, '.flow-comet'), { recursive: true });
|
|
858
|
+
fs.writeFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), raw, 'utf8');
|
|
859
|
+
writeFile(dir, '.specs/compose-demo/CHANGE.md', '# CHANGE\n## Why\nx\n');
|
|
860
|
+
const res = runGuardWithProtocol(dir, ['entry', 'open']);
|
|
861
|
+
assertExit(res, 0);
|
|
862
|
+
},
|
|
863
|
+
},
|
|
864
|
+
|
|
865
|
+
// ---------- 场景(worktree 委托链路,验证问题实录) ----------
|
|
866
|
+
|
|
867
|
+
// 78: 路由诊断——「未找到可委托并行块」诊断的在场/静默边界。期望随 multipass-exit-hardening
|
|
868
|
+
// ROUTE WARN 前置条件语义更新(ROUTE WARN 增加存在任一 status=pending 的前置条件):① 夹具存在可解析 pending
|
|
869
|
+
// 任务(串行 pending + 并行全 done)且无可委托并行块 → ROUTE WARN 保持在场(检测失败纠偏可见
|
|
870
|
+
// ——信息量保留);② 旧模板无 status 属性形态(无可解析 pending)→ 按新前置条件静默
|
|
871
|
+
// (原「旧模板也告警」行为被设计性取代)。
|
|
872
|
+
// nextNode 只看 completedNodes——路由触发场景 = exit plan(completed 后 nextNode=execute → 路由检查)
|
|
873
|
+
{
|
|
874
|
+
name: '78 路由诊断:有 pending 无可委托并行 WARN 在场 / 无可解析 pending 静默',
|
|
875
|
+
run: (dir) => {
|
|
876
|
+
const st = baseState('plan');
|
|
877
|
+
st.completedNodes = ['open', 'design'];
|
|
878
|
+
st.evidence.plan = { summary: 'executed' };
|
|
879
|
+
writeState(dir, st);
|
|
880
|
+
// 上游工件(open=CHANGE+REQUIREMENT、design=DESIGN-lite、plan=TASK)
|
|
881
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n## Why\nx\n');
|
|
882
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n## 用户故事\nx\n## 验收准则(AC)\nx\n');
|
|
883
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN-lite.md', '# DESIGN-lite\n## 决策清单\n- d1: x\n');
|
|
884
|
+
// ① 可解析 pending 在场且剩余全串行(并行已 done、串行 pending、无缺 status 畸形块)
|
|
885
|
+
// → M4 静默(P→S 收尾转换无噪音——① 语义随扩展翻转)
|
|
886
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
|
|
887
|
+
'<task id="P01" parallel="true" status="done">\n <action>do</action>\n <verify>echo ok</verify>\n</task>\n' +
|
|
888
|
+
'<task id="T01" parallel="false" status="pending">\n <action>do serial</action>\n <verify>echo ok</verify>\n</task>\n');
|
|
889
|
+
const res = runGuardWithProtocol(dir, ['exit', 'plan', '--apply']);
|
|
890
|
+
assertExit(res, 0);
|
|
891
|
+
assertNotOut(res, 'ROUTE WARN');
|
|
892
|
+
// ② 旧模板无 status 属性(无可解析 pending)→ 前置条件跳过诊断 → 静默
|
|
893
|
+
//(① 的 --apply 已把 currentNode 推进到 execute——先复位 state 再独立跑第二半)
|
|
894
|
+
writeState(dir, st);
|
|
895
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n<task id="T02" parallel="true">\n <action>do legacy</action>\n <verify>echo ok</verify>\n</task>\n');
|
|
896
|
+
const resLegacy = runGuardWithProtocol(dir, ['exit', 'plan', '--apply']);
|
|
897
|
+
assertExit(resLegacy, 0);
|
|
898
|
+
assertNotOut(resLegacy, 'ROUTE WARN');
|
|
899
|
+
},
|
|
900
|
+
},
|
|
901
|
+
|
|
902
|
+
// 79: C4 catch 可见化——非 git 仓库 → entry execute 输出 C4-CHECK SKIP
|
|
903
|
+
// (检测失败也要可见——修复前 catch 静默 = RED)
|
|
904
|
+
{
|
|
905
|
+
name: '79 C4 catch 非 git 仓库输出 SKIP',
|
|
906
|
+
run: (dir) => {
|
|
907
|
+
const st = baseState('execute');
|
|
908
|
+
writeState(dir, st);
|
|
909
|
+
const res = runGuardWithProtocol(dir, ['entry', 'execute']);
|
|
910
|
+
assertExit(res, 0);
|
|
911
|
+
assertOut(res, 'C4-CHECK SKIP');
|
|
912
|
+
},
|
|
913
|
+
},
|
|
914
|
+
|
|
915
|
+
// 80: handoff result commitHash 存在性校验——不存在 → HANDOFF ERROR(固化:校验已存在(W2-D),经确认)
|
|
916
|
+
{
|
|
917
|
+
name: '80 handoff result 无效 commitHash → ERROR(batch-H 固化)',
|
|
918
|
+
run: (dir) => {
|
|
919
|
+
writeState(dir, baseState('subagent-execute'));
|
|
920
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
921
|
+
execFileSync('git', ['init', '-q'], { cwd: dir });
|
|
922
|
+
execFileSync('git', ['-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-q', '--allow-empty', '-m', 'init'], { cwd: dir });
|
|
923
|
+
const payload = JSON.stringify({
|
|
924
|
+
status: 'DONE',
|
|
925
|
+
commitHash: 'deadbeef00000000000000000000000000000000',
|
|
926
|
+
redEvidence: { command: 'echo red', output: 'red' },
|
|
927
|
+
greenEvidence: { command: 'echo green', output: 'green' },
|
|
928
|
+
completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
|
|
929
|
+
riskSignals: ['none'],
|
|
930
|
+
});
|
|
931
|
+
const res = runHandoff(['result', 'T01', payload], dir);
|
|
932
|
+
assertExit(res, 0);
|
|
933
|
+
assertOut(res, 'HANDOFF ERROR: commitHash 无效或 git show 失败');
|
|
934
|
+
},
|
|
935
|
+
},
|
|
936
|
+
|
|
937
|
+
// 81: entry/exit WARN COUNT 汇总行——构造 BROOKS-LINT WARN → exit 输出 WARN COUNT
|
|
938
|
+
// ( F:可观测性——修复前无汇总行 = RED)
|
|
939
|
+
{
|
|
940
|
+
name: '81 exit 输出 WARN COUNT 汇总',
|
|
941
|
+
run: (dir) => {
|
|
942
|
+
const st = baseState('execute');
|
|
943
|
+
st.evidence.execute = { summary: 'executed' };
|
|
944
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
945
|
+
writeState(dir, st);
|
|
946
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
947
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent({
|
|
948
|
+
method: '## 自检方法\n\nbuiltin-quickcheck — brooks-lint 不可用(Skill 仅返回占位,插件执行体未加载),按协议降级内置 R1~R6 快查',
|
|
949
|
+
}));
|
|
950
|
+
const res = runGuardWithProtocol(dir, ['exit', 'execute']);
|
|
951
|
+
assertExit(res, 0);
|
|
952
|
+
assertOut(res, 'BROOKS-LINT WARN');
|
|
953
|
+
assertOut(res, 'WARN COUNT:');
|
|
954
|
+
},
|
|
955
|
+
},
|
|
956
|
+
|
|
957
|
+
// 82: 空退出行为固化——全 parallel 任务 exit execute → task-summaries BLOCKED(现状保护,H1 文档一致化的行为锚点)
|
|
958
|
+
{
|
|
959
|
+
name: '82 全 parallel exit execute BLOCKED 产物(batch-H 固化)',
|
|
960
|
+
run: (dir) => {
|
|
961
|
+
const st = baseState('execute');
|
|
962
|
+
st.evidence.execute = { summary: 'executed' };
|
|
963
|
+
writeState(dir, st);
|
|
964
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n<task id="T01" parallel="true" status="pending">\n <action>do</action>\n</task>\n<task id="T02" parallel="true" status="pending">\n <action>do2</action>\n</task>\n');
|
|
965
|
+
const res = runGuardWithProtocol(dir, ['exit', 'execute']);
|
|
966
|
+
assertExit(res, 1);
|
|
967
|
+
assertOut(res, 'missing Output Schema artifacts');
|
|
968
|
+
},
|
|
969
|
+
},
|
|
970
|
+
|
|
971
|
+
// 83~91: 自动初始化检测(auto-init-detection)——脚本确定性探测/判决/提示 + agent 生成协作
|
|
972
|
+
// 生成职责:--init-context 时 CONTEXT 缺失 → INIT-GENERATE 指引(不生成、
|
|
973
|
+
// 不写 last_intel_scan),由 agent 全量阅读生成;生成后重跑 → 脚本校验 7 段 → 通过写 last_intel_scan。
|
|
974
|
+
// 83: CONTEXT 缺失 + 有代码上下文 → init 输出 INIT-NEEDED 且不自动生成(基础探测)
|
|
975
|
+
{
|
|
976
|
+
name: '83 CONTEXT 缺失 + 有代码 → init 输出 INIT-NEEDED 不生成',
|
|
977
|
+
run: (dir) => {
|
|
978
|
+
writeFile(dir, 'package.json', '{"name":"x"}');
|
|
979
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID]);
|
|
980
|
+
assertExit(res, 0);
|
|
981
|
+
assertOut(res, 'INIT-NEEDED');
|
|
982
|
+
if (fs.existsSync(path.join(dir, '.specs', 'CONTEXT.md'))) throw new Error('CONTEXT 不应被自动生成');
|
|
983
|
+
},
|
|
984
|
+
},
|
|
985
|
+
|
|
986
|
+
// 84: --init-skip → state.ai_context_doc='none',下次 init 不再提示(拒绝路径)
|
|
987
|
+
{
|
|
988
|
+
name: '84 --init-skip 记 none 且下次 init 静默',
|
|
989
|
+
run: (dir) => {
|
|
990
|
+
writeFile(dir, 'package.json', '{"name":"x"}');
|
|
991
|
+
runStateWithProtocol(dir, ['init', CHANGE_ID, '--init-skip']);
|
|
992
|
+
const st1 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
993
|
+
if (st1.ai_context_doc !== 'none') throw new Error('ai_context_doc 应为 none');
|
|
994
|
+
const res2 = runStateWithProtocol(dir, ['init', CHANGE_ID + '-2']);
|
|
995
|
+
if (res2.output.includes('INIT-NEEDED') || res2.output.includes('INIT-HINT')) throw new Error('下次 init 不应再提示');
|
|
996
|
+
},
|
|
997
|
+
},
|
|
998
|
+
|
|
999
|
+
// 85: CONTEXT 新鲜(last_intel_scan ≤90 天)→ init 零初始化输出(新鲜路径)
|
|
1000
|
+
{
|
|
1001
|
+
name: '85 CONTEXT 新鲜 → init 零初始化输出',
|
|
1002
|
+
run: (dir) => {
|
|
1003
|
+
writeState(dir, { ...baseState('open'), last_intel_scan: new Date(Date.now() - 10 * 864e5).toISOString() });
|
|
1004
|
+
writeFile(dir, '.specs/CONTEXT.md', '# CONTEXT\n## 项目概要\nx\n');
|
|
1005
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID]);
|
|
1006
|
+
assertExit(res, 0);
|
|
1007
|
+
if (res.output.includes('INIT-NEEDED') || res.output.includes('INIT-HINT')) throw new Error('不应有初始化提示');
|
|
1008
|
+
},
|
|
1009
|
+
},
|
|
1010
|
+
|
|
1011
|
+
// 86: 有 CONTEXT 无扫描记录(旧项目迁移)→ INIT-HINT 文案不得含 null
|
|
1012
|
+
{
|
|
1013
|
+
name: '86 有 CONTEXT 无扫描记录 → INIT-HINT 文案无 null',
|
|
1014
|
+
run: (dir) => {
|
|
1015
|
+
writeFile(dir, '.specs/CONTEXT.md', '# CONTEXT\n## 项目概要\nx\n');
|
|
1016
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID]);
|
|
1017
|
+
assertExit(res, 0);
|
|
1018
|
+
assertOut(res, 'INIT-HINT');
|
|
1019
|
+
if (res.output.includes('null')) throw new Error('INIT-HINT 不应含 "null"(无扫描记录时用友好文案)');
|
|
1020
|
+
},
|
|
1021
|
+
},
|
|
1022
|
+
|
|
1023
|
+
// 87: CONTEXT 缺失 + --init-context → INIT-GENERATE 指引且不生成、不写 last_intel_scan(生成协作第一步)
|
|
1024
|
+
{
|
|
1025
|
+
name: '87 --init-context 无 CONTEXT → INIT-GENERATE 指引不生成',
|
|
1026
|
+
run: (dir) => {
|
|
1027
|
+
writeFile(dir, 'package.json', '{"name":"x"}');
|
|
1028
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID, '--init-context']);
|
|
1029
|
+
assertExit(res, 0);
|
|
1030
|
+
assertOut(res, 'INIT-GENERATE');
|
|
1031
|
+
if (fs.existsSync(path.join(dir, '.specs', 'CONTEXT.md'))) throw new Error('CONTEXT 不应由脚本生成(生成职责在 agent)');
|
|
1032
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1033
|
+
if (st.last_intel_scan) throw new Error('校验通过前不应写 last_intel_scan');
|
|
1034
|
+
},
|
|
1035
|
+
},
|
|
1036
|
+
|
|
1037
|
+
// 88: CONTEXT 缺失 + 既有 AI 文档 + --init-context → INIT-GENERATE 指引含源文档列表
|
|
1038
|
+
{
|
|
1039
|
+
name: '88 --init-context 指引含源文档列表',
|
|
1040
|
+
run: (dir) => {
|
|
1041
|
+
writeFile(dir, 'CLAUDE.md', '# CLAUDE\n项目约定:使用 kebab-case 命名。\n');
|
|
1042
|
+
writeFile(dir, 'package.json', '{"name":"x"}');
|
|
1043
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID, '--init-context']);
|
|
1044
|
+
assertExit(res, 0);
|
|
1045
|
+
assertOut(res, 'INIT-GENERATE');
|
|
1046
|
+
assertOut(res, 'CLAUDE.md');
|
|
1047
|
+
},
|
|
1048
|
+
},
|
|
1049
|
+
|
|
1050
|
+
// 89: CONTEXT 缺失 + 代码信号 + --init-context → INIT-GENERATE 指引含代码信号
|
|
1051
|
+
{
|
|
1052
|
+
name: '89 --init-context 指引含代码信号',
|
|
1053
|
+
run: (dir) => {
|
|
1054
|
+
writeFile(dir, 'requirements.txt', 'pytest\n');
|
|
1055
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID, '--init-context']);
|
|
1056
|
+
assertExit(res, 0);
|
|
1057
|
+
assertOut(res, 'INIT-GENERATE');
|
|
1058
|
+
assertOut(res, '代码信号');
|
|
1059
|
+
},
|
|
1060
|
+
},
|
|
1061
|
+
|
|
1062
|
+
// 90: CONTEXT 已存在且 7 段 + 模板格式完整 + --init-context → INIT-DONE + last_intel_scan 写入(生成协作第二步)
|
|
1063
|
+
{
|
|
1064
|
+
name: '90 CONTEXT 7 段+格式完整 --init-context → INIT-DONE + state 写入',
|
|
1065
|
+
run: (dir) => {
|
|
1066
|
+
writeFile(dir, '.specs/CONTEXT.md', '# CONTEXT\n## 项目概要\nx\n## 技术栈\nx\n## 域语言\n| 术语 | 定义 |\n|---|---|\n| 例 | 定义 |\n## 已锁决策\n- [2026-08-01] 决策一\n## 默认偏好\nx\n## 既有抽象索引\nx\n## intel-scan 元数据\n- **last_intel_scan**: x\n- **scanner**: x\n- **下次重扫建议**: x\n');
|
|
1067
|
+
writeFile(dir, 'package.json', '{"name":"x"}');
|
|
1068
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID, '--init-context']);
|
|
1069
|
+
assertExit(res, 0);
|
|
1070
|
+
assertOut(res, 'INIT-DONE');
|
|
1071
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1072
|
+
if (!st.last_intel_scan) throw new Error('校验通过后应写 last_intel_scan');
|
|
1073
|
+
},
|
|
1074
|
+
},
|
|
1075
|
+
|
|
1076
|
+
// 91: CONTEXT 存在但缺段 + --init-context → INIT-VALIDATE-FAILED 重写指引 + 不写 last_intel_scan。
|
|
1077
|
+
// ② 段名判定须为**精确标题**匹配(非全文 includes):段名变体(`## 技术栈补充`)与正文文本提及
|
|
1078
|
+
// 都不得算作段存在——旧 includes 判据下二者会假通过(校验放行 + 写 last_intel_scan)。
|
|
1079
|
+
// ③ 标题解析须先排除围栏代码块:代码示例里的 `## 段名` 不是段(否则缺段仍能假通过并写扫描时间)。
|
|
1080
|
+
{
|
|
1081
|
+
name: '91 CONTEXT 缺段 --init-context → 重写指引不写 state(含围栏代码块段名不假通过)',
|
|
1082
|
+
run: (dir) => {
|
|
1083
|
+
writeFile(dir, '.specs/CONTEXT.md', '# CONTEXT\n## 项目概要\nx\n');
|
|
1084
|
+
writeFile(dir, 'package.json', '{"name":"x"}');
|
|
1085
|
+
let res = runStateWithProtocol(dir, ['init', CHANGE_ID, '--init-context']);
|
|
1086
|
+
assertExit(res, 0);
|
|
1087
|
+
assertOut(res, 'INIT-VALIDATE-FAILED');
|
|
1088
|
+
assertOut(res, '重写');
|
|
1089
|
+
let st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1090
|
+
if (st.last_intel_scan) throw new Error('校验失败不应写 last_intel_scan');
|
|
1091
|
+
// ② 段名变体(含正文提及)不满足必填段
|
|
1092
|
+
writeFile(dir, '.specs/CONTEXT.md', '# CONTEXT\n## 项目概要\nx\n## 技术栈补充\nx\n## 域语言说明\n| 术语 | 定义 |\n|---|---|\n| 例 | 定义 |\n## 已锁决策说明\n- [2026-08-01] 决策一\n## 默认偏好补充\nx\n## 既有抽象索引附录\nx\n## intel-scan 元数据附录\n- **last_intel_scan**: x\n- **scanner**: x\n- **下次重扫建议**: x\n正文提及 域语言 与 默认偏好 与 既有抽象索引(文本非标题)。\n');
|
|
1093
|
+
res = runStateWithProtocol(dir, ['init', CHANGE_ID + '-2', '--init-context']);
|
|
1094
|
+
assertExit(res, 0);
|
|
1095
|
+
assertOut(res, 'INIT-VALIDATE-FAILED');
|
|
1096
|
+
st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1097
|
+
if (st.last_intel_scan) throw new Error('段名变体不应通过校验(不应写 last_intel_scan)');
|
|
1098
|
+
// ③ 围栏代码块内的 `## 段名` 不计入标题集合:缺 `## 默认偏好`,但三种围栏形态——
|
|
1099
|
+
// 带语言标注的反引号围栏、缩进 2 空格的波浪线围栏、波浪线围栏——内都出现该段名。
|
|
1100
|
+
// 标题正则若不跟踪围栏边界,就会把这些示例行当成段存在 → 假通过并写扫描时间(RED)。
|
|
1101
|
+
writeFile(dir, '.specs/CONTEXT.md', [
|
|
1102
|
+
'# CONTEXT',
|
|
1103
|
+
'## 项目概要', 'x',
|
|
1104
|
+
'## 技术栈', 'x',
|
|
1105
|
+
'## 域语言', '| 术语 | 定义 |', '|---|---|', '| 例 | 定义 |',
|
|
1106
|
+
'## 已锁决策', '- [2026-08-01] 决策一',
|
|
1107
|
+
'## 既有抽象索引', 'x',
|
|
1108
|
+
'## intel-scan 元数据', '- **last_intel_scan**: x', '- **scanner**: x', '- **下次重扫建议**: x',
|
|
1109
|
+
'示例(以下均为代码示例,不是段):',
|
|
1110
|
+
'```markdown', '## 默认偏好', '- 反引号围栏内的示例', '```',
|
|
1111
|
+
' ~~~', '## 默认偏好', ' ~~~',
|
|
1112
|
+
'~~~text', '## 默认偏好', '~~~',
|
|
1113
|
+
'',
|
|
1114
|
+
].join('\n'));
|
|
1115
|
+
res = runStateWithProtocol(dir, ['init', CHANGE_ID + '-3', '--init-context']);
|
|
1116
|
+
assertExit(res, 0);
|
|
1117
|
+
assertOut(res, 'INIT-VALIDATE-FAILED');
|
|
1118
|
+
st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1119
|
+
if (st.last_intel_scan) throw new Error('围栏内的段名不应通过校验(不应写 last_intel_scan)');
|
|
1120
|
+
},
|
|
1121
|
+
},
|
|
1122
|
+
|
|
1123
|
+
// 92: CONTEXT 7 段齐全但模板格式不满足(已锁决策无日期前缀)→ 格式校验失败重写指引 + 不写 state
|
|
1124
|
+
{
|
|
1125
|
+
name: '92 CONTEXT 格式不满足模板 → 重写指引不写 state',
|
|
1126
|
+
run: (dir) => {
|
|
1127
|
+
// 7 段齐全但已锁决策条目缺 [YYYY-MM-DD] 日期前缀(模板格式)
|
|
1128
|
+
writeFile(dir, '.specs/CONTEXT.md', '# CONTEXT\n## 项目概要\nx\n## 技术栈\nx\n## 域语言\n| 术语 | 定义 |\n|---|---|\n| 例 | 定义 |\n## 已锁决策\n- 决策缺日期前缀\n## 默认偏好\nx\n## 既有抽象索引\nx\n## intel-scan 元数据\n- **last_intel_scan**: x\n- **scanner**: x\n- **下次重扫建议**: x\n');
|
|
1129
|
+
writeFile(dir, 'package.json', '{"name":"x"}');
|
|
1130
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID, '--init-context']);
|
|
1131
|
+
assertExit(res, 0);
|
|
1132
|
+
assertOut(res, 'INIT-VALIDATE-FAILED');
|
|
1133
|
+
assertOut(res, '日期');
|
|
1134
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1135
|
+
if (st.last_intel_scan) throw new Error('格式校验失败不应写 last_intel_scan');
|
|
1136
|
+
},
|
|
1137
|
+
},
|
|
1138
|
+
|
|
1139
|
+
// 93: 新项目骨架 CONTEXT(已锁决策仅占位)→ 占位放行 INIT-DONE(DF-5:占位不是裸条目)
|
|
1140
|
+
{
|
|
1141
|
+
name: '93 新项目占位 CONTEXT → 校验通过 INIT-DONE',
|
|
1142
|
+
run: (dir) => {
|
|
1143
|
+
writeFile(dir, '.specs/CONTEXT.md', '# CONTEXT\n## 项目概要\n新项目骨架\n## 技术栈\nx\n## 域语言\n| 术语 | 定义 |\n|---|---|\n| (待沉淀) | 随 change 逐步补充 |\n## 已锁决策\n- (待沉淀——后续 change 按时间倒序追加)\n## 默认偏好\n- 待补充\n## 既有抽象索引\nx\n## intel-scan 元数据\n- **last_intel_scan**: x\n- **scanner**: x\n- **下次重扫建议**: x\n');
|
|
1144
|
+
writeFile(dir, 'package.json', '{"name":"x"}');
|
|
1145
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID, '--init-context']);
|
|
1146
|
+
assertExit(res, 0);
|
|
1147
|
+
assertOut(res, 'INIT-DONE');
|
|
1148
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1149
|
+
if (!st.last_intel_scan) throw new Error('占位 CONTEXT 校验通过应写 last_intel_scan');
|
|
1150
|
+
},
|
|
1151
|
+
},
|
|
1152
|
+
|
|
1153
|
+
// 94: CONTEXT 已满足模板但无扫描记录 + init 无参数 → 提示"记录扫描时间"(C 文案优化——
|
|
1154
|
+
// agent 生成后未重跑的悬空态,误导性"扫描时间未知/刷新"文案不出现)
|
|
1155
|
+
{
|
|
1156
|
+
name: '94 CONTEXT 就绪无扫描记录 → 提示记录扫描时间',
|
|
1157
|
+
run: (dir) => {
|
|
1158
|
+
writeFile(dir, '.specs/CONTEXT.md', '# CONTEXT\n## 项目概要\nx\n## 技术栈\nx\n## 域语言\n| 术语 | 定义 |\n|---|---|\n| 例 | 定义 |\n## 已锁决策\n- [2026-08-01] 决策一\n## 默认偏好\nx\n## 既有抽象索引\nx\n## intel-scan 元数据\n- **last_intel_scan**: x\n- **scanner**: x\n- **下次重扫建议**: x\n');
|
|
1159
|
+
writeFile(dir, 'package.json', '{"name":"x"}');
|
|
1160
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID]);
|
|
1161
|
+
assertExit(res, 0);
|
|
1162
|
+
assertOut(res, '记录扫描时间');
|
|
1163
|
+
if (res.output.includes('刷新')) throw new Error('CONTEXT 已就绪不应提示"刷新"(应提示记录扫描时间)');
|
|
1164
|
+
},
|
|
1165
|
+
},
|
|
1166
|
+
|
|
1167
|
+
// 95: init 同 id 重跑(.specs/<id>/ 已存在)→ WARN 防护输出且不阻断(F)
|
|
1168
|
+
{
|
|
1169
|
+
name: '95 init 同 id 重跑 → WARN 防护不阻断',
|
|
1170
|
+
run: (dir) => {
|
|
1171
|
+
writeFile(dir, 'package.json', '{"name":"x"}');
|
|
1172
|
+
runStateWithProtocol(dir, ['init', CHANGE_ID]);
|
|
1173
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID]);
|
|
1174
|
+
assertExit(res, 0);
|
|
1175
|
+
assertOut(res, 'WARN: change ' + CHANGE_ID + ' 已存在');
|
|
1176
|
+
assertOut(res, '重置节点状态');
|
|
1177
|
+
},
|
|
1178
|
+
},
|
|
1179
|
+
|
|
1180
|
+
// 96~97: 端到端验证实证的校验误报修复
|
|
1181
|
+
// 96: 自检方法段内后续行声明方法(子代理把方法名写在列表后续行)→ 放行无 WARN
|
|
1182
|
+
// (修复前 guard 正则只匹配段后第一行 → 全文有 cache-brooks 声明 → 误报 BROOKS-LINT WARN = RED)
|
|
1183
|
+
{
|
|
1184
|
+
name: '96 自检方法段后续行声明 → 放行',
|
|
1185
|
+
run: (dir) => {
|
|
1186
|
+
const st = baseState('execute');
|
|
1187
|
+
st.evidence.execute = { summary: 'executed' };
|
|
1188
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
1189
|
+
writeState(dir, st);
|
|
1190
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
1191
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent({
|
|
1192
|
+
method: '## 自检方法\n\n- flow-comet-dev Skill 加载成功\n- 自检:第 1 级 brooks-review 返回占位 → 第 2 级 Read 插件缓存协议文件手动执行(selfReview: cache-brooks)',
|
|
1193
|
+
sixDim: '## 6 维自查\n\n- 功能: 通过(cache-brooks 审查已跑)\n- 性能: 无影响\n- 安全: 无影响\n- 兼容: 通过\n- 可观测: 通过\n- 可维护: 通过',
|
|
1194
|
+
}));
|
|
1195
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
1196
|
+
assertExit(res, 0);
|
|
1197
|
+
assertNotOut(res, 'BROOKS-LINT WARN');
|
|
1198
|
+
},
|
|
1199
|
+
},
|
|
1200
|
+
|
|
1201
|
+
// 97: handoff changedFiles 含任务专属 SUMMARY(.specs/<change-id>/<task-id>-SUMMARY.md,
|
|
1202
|
+
// 精确豁免路径)→ 不报越界 WARN;其他 *-SUMMARY.md(非本任务路径)仍判越界
|
|
1203
|
+
// (修复前 W2-D 以 endsWith('-SUMMARY.md') 全量豁免 + 前缀匹配 = RED;真实 commitHash 供 git show 校验)
|
|
1204
|
+
{
|
|
1205
|
+
name: '97 handoff 含 SUMMARY 文件 → 无越界 WARN',
|
|
1206
|
+
run: (dir) => {
|
|
1207
|
+
const g = (args) => spawnSync('git', args, { cwd: dir, encoding: 'utf8' });
|
|
1208
|
+
g(['init', '-q']);
|
|
1209
|
+
g(['config', 'user.email', 't@t']);
|
|
1210
|
+
g(['config', 'user.name', 't']);
|
|
1211
|
+
writeFile(dir, 'test_stats.py', 'def f():\n pass\n');
|
|
1212
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', '# T01-SUMMARY\n## 做了什么\nx\n');
|
|
1213
|
+
// 只提交指定文件(场景运行器预置的 reference/ 协议文件不入提交集)
|
|
1214
|
+
g(['add', 'test_stats.py', '.specs/' + CHANGE_ID + '/T01-SUMMARY.md']);
|
|
1215
|
+
g(['commit', '-qm', 'init']);
|
|
1216
|
+
const hash = g(['rev-parse', 'HEAD']).stdout.trim();
|
|
1217
|
+
const st = baseState('subagent-execute');
|
|
1218
|
+
st.evidence['subagent-execute'] = {
|
|
1219
|
+
handoffRequests: { T01: { writeFiles: ['test_stats.py'] } },
|
|
1220
|
+
handoffResult: {},
|
|
1221
|
+
};
|
|
1222
|
+
writeState(dir, st);
|
|
1223
|
+
const res = runHandoff(['result', 'T01', JSON.stringify({
|
|
1224
|
+
status: 'DONE', taskId: 'T01', commitHash: hash,
|
|
1225
|
+
changedFiles: ['test_stats.py', '.specs/' + CHANGE_ID + '/T01-SUMMARY.md'],
|
|
1226
|
+
completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
|
|
1227
|
+
greenEvidence: { command: 'node --check test_stats.py', output: 'ok' },
|
|
1228
|
+
})], dir);
|
|
1229
|
+
assertExit(res, 0);
|
|
1230
|
+
if (res.output.includes('超出 writeFiles 范围')) throw new Error('任务专属 SUMMARY 不应报越界 WARN');
|
|
1231
|
+
},
|
|
1232
|
+
},
|
|
1233
|
+
];
|