flow-comet 1.6.2 → 1.6.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
- package/.flow-comet/skills/flow-comet/SKILL.md +64 -46
- package/.flow-comet/skills/flow-comet/reference/KNOWN-ISSUES-template.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +32 -0
- package/.flow-comet/skills/flow-comet/reference/dirty-worktree.md +1 -1
- package/.flow-comet/skills/flow-comet/{GUIDANCE.md → reference/entry-detail.md} +18 -28
- package/.flow-comet/skills/flow-comet/reference/fix-loop.md +57 -0
- package/.flow-comet/skills/flow-comet/reference/platform-facts.md +58 -0
- package/.flow-comet/skills/flow-comet/reference/replan.md +23 -0
- package/.flow-comet/skills/flow-comet/scripts/comet-check.mjs +5 -4
- package/.flow-comet/skills/flow-comet/scripts/comet-hook-guard.mjs +266 -25
- 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 -16325
- 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 +73 -1077
- 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 +14 -1
- package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +58 -6692
- package/.flow-comet/skills/flow-comet/scripts/time-utils.mjs +4 -4
- package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +151 -2428
- package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +116 -9
- package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +29 -2086
- package/.flow-comet/skills/flow-comet-archive/SKILL.md +10 -19
- package/.flow-comet/skills/flow-comet-change/SKILL.md +2 -3
- package/.flow-comet/skills/flow-comet-compose/SKILL.md +1 -1
- package/.flow-comet/skills/flow-comet-design/SKILL.md +6 -6
- package/.flow-comet/skills/flow-comet-execute/SKILL.md +58 -16
- package/.flow-comet/skills/flow-comet-integration/SKILL.md +8 -5
- package/.flow-comet/skills/flow-comet-open/SKILL.md +5 -1
- package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +1 -1
- package/.flow-comet/skills/flow-comet-plan/SKILL.md +8 -8
- package/.flow-comet/skills/flow-comet-review/SKILL.md +9 -12
- package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +59 -16
- package/.flow-comet/skills/flow-comet-task/SKILL.md +3 -2
- package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +3 -3
- package/.flow-comet/skills/flow-comet-verify/SKILL.md +8 -17
- package/README.md +53 -70
- package/package.json +3 -2
- package/scripts/dsh-bridge.mjs +59 -26
- 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 +36 -1164
- package/.flow-comet/skills/flow-comet/reference/TEST-MATRIX.md +0 -116
- package/.flow-comet/skills/flow-comet/reference/composition-report.md +0 -65
- package/.flow-comet/skills/flow-comet/reference/dsh-platform.md +0 -184
- package/.flow-comet/skills/flow-comet/reference/resolved-skills.json +0 -661
- package/.flow-comet/skills/flow-comet/reference/skill-review.md +0 -13
- package/.flow-comet/skills/flow-comet/reference/subagents/script-author.md +0 -7
- package/.flow-comet/skills/flow-comet/reference/worktree-notes.md +0 -70
|
@@ -0,0 +1,1382 @@
|
|
|
1
|
+
// 场景组 c — 声明机制 · 产物推导 · 模板保真 · 技能加载前置门 · 零提交边界
|
|
2
|
+
// 元素形态:`{ name, run }`;计数由 `lib/count-derivation.mjs` 从本目录聚合,不手抄数字。
|
|
3
|
+
// 组界按场景名前缀与文件内既有分段划,与入口 `SCENARIOS` 的拼接顺序一致。
|
|
4
|
+
|
|
5
|
+
import fs from 'fs';
|
|
6
|
+
import path from 'path';
|
|
7
|
+
import { execFileSync } from 'child_process';
|
|
8
|
+
import {
|
|
9
|
+
assertExit,
|
|
10
|
+
assertNotOut,
|
|
11
|
+
assertOut,
|
|
12
|
+
assertTrue,
|
|
13
|
+
baseState,
|
|
14
|
+
runGuard,
|
|
15
|
+
runHandoff,
|
|
16
|
+
runState,
|
|
17
|
+
writeFile,
|
|
18
|
+
writeState,
|
|
19
|
+
} from '../lib/test-helpers.mjs';
|
|
20
|
+
import {
|
|
21
|
+
CHANGE_ID,
|
|
22
|
+
SCRIPTS_DIR,
|
|
23
|
+
TASK_DONE,
|
|
24
|
+
TASK_DONE_TWO,
|
|
25
|
+
TASK_P1,
|
|
26
|
+
customProtocolWithSkillCall,
|
|
27
|
+
handoffFor,
|
|
28
|
+
isAuthoritativeSourceRepo,
|
|
29
|
+
summaryContent,
|
|
30
|
+
writeCustomProtocol,
|
|
31
|
+
writeIntakeArtifacts,
|
|
32
|
+
} from '../lib/test-fixtures.mjs';
|
|
33
|
+
import {
|
|
34
|
+
assertOutMatches,
|
|
35
|
+
readScenarioState,
|
|
36
|
+
runGuardWithProtocol,
|
|
37
|
+
runStateWithProtocol,
|
|
38
|
+
scenarioProtocolPath,
|
|
39
|
+
} from '../lib/test-assertions.mjs';
|
|
40
|
+
import {
|
|
41
|
+
countSyncProblems,
|
|
42
|
+
} from '../lib/text-anchor-checks.mjs';
|
|
43
|
+
|
|
44
|
+
export const ENTRIES = [
|
|
45
|
+
|
|
46
|
+
// ---------- 场景(completedChecks 真实性声明机制——skill-load/record/exit 校验 + 交叉自洽 + 旧兼容 + 场景数同步) ----------
|
|
47
|
+
|
|
48
|
+
// 98: skill-load 写入声明标记(AC-1)——完整命令形态(--prompt flow-kit/prompts/<阶段>.md,
|
|
49
|
+
// 归属校验通过)→ 标记 .specs/<change-id>/.skill-loads/<node>-<skill>.json 生成,
|
|
50
|
+
// 内容含 node/skill/protocol/at(ISO 时间戳)+ 输出确认提示
|
|
51
|
+
{
|
|
52
|
+
name: '98 skill-load 写入声明标记(AC-1)',
|
|
53
|
+
run: (dir) => {
|
|
54
|
+
// 场景内 flow-kit/prompts/ 提示文件(skill-load --prompt 指向——改名 --prompt 后归属校验仅查
|
|
55
|
+
// 前缀不读内容;协议加载走 env reference 路径,文件无需为 JSON)
|
|
56
|
+
writeFile(dir, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
|
|
57
|
+
writeState(dir, baseState('open'));
|
|
58
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
59
|
+
const res = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--prompt', 'flow-kit/prompts/0-change.md']);
|
|
60
|
+
assertExit(res, 0);
|
|
61
|
+
assertOut(res, 'SKILL-LOAD: open flow-comet-change → .skill-loads/open-flow-comet-change.json');
|
|
62
|
+
const markerPath = path.join(dir, '.specs', CHANGE_ID, '.skill-loads', 'open-flow-comet-change.json');
|
|
63
|
+
if (!fs.existsSync(markerPath)) throw new Error('标记文件未生成: ' + markerPath);
|
|
64
|
+
const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
|
|
65
|
+
if (marker.node !== 'open' || marker.skill !== 'flow-comet-change') {
|
|
66
|
+
throw new Error('标记 node/skill 字段不符: ' + JSON.stringify(marker));
|
|
67
|
+
}
|
|
68
|
+
// 标记 protocol = --prompt 参数的 basename(与 guard exit 的 节点协议映射表比对同值,
|
|
69
|
+
// 真实链路 skill-load → exit 一致;缺陷修复前写 resolveProtocol 解析后的完整绝对路径,
|
|
70
|
+
// 与 节点协议映射表 basename 精确比对必然失败——机制实际不可用,已修复)
|
|
71
|
+
if (marker.protocol !== '0-change.md') {
|
|
72
|
+
throw new Error('标记 protocol 应为 --prompt 参数的 basename 0-change.md: ' + JSON.stringify(marker));
|
|
73
|
+
}
|
|
74
|
+
if (typeof marker.at !== 'string' || Number.isNaN(Date.parse(marker.at))) {
|
|
75
|
+
throw new Error('标记缺 ISO 时间戳 at: ' + JSON.stringify(marker));
|
|
76
|
+
}
|
|
77
|
+
},
|
|
78
|
+
},
|
|
79
|
+
|
|
80
|
+
// 99: skill-load 非法参数拒绝(AC-2)——缺 node/skill / node 非法 / skill 名非法字符 /
|
|
81
|
+
// --prompt 不在 flow-kit/prompts/ 下 → 报错 exit 非 0,不写任何标记(.skill-loads/ 无文件)
|
|
82
|
+
{
|
|
83
|
+
name: '99 skill-load 非法参数拒绝不写标记(AC-2)',
|
|
84
|
+
run: (dir) => {
|
|
85
|
+
writeState(dir, baseState('open'));
|
|
86
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
87
|
+
// a) 缺参数(无 node/skill)
|
|
88
|
+
const rA = runStateWithProtocol(dir, ['skill-load']);
|
|
89
|
+
assertExit(rA, 1);
|
|
90
|
+
assertOut(rA, 'skill-load requires <node> <skill>');
|
|
91
|
+
// b) node 非法(非内置节点)
|
|
92
|
+
const rB = runStateWithProtocol(dir, ['skill-load', 'bogus', 'flow-comet-change']);
|
|
93
|
+
assertExit(rB, 1);
|
|
94
|
+
assertOut(rB, 'skill-load node 非法');
|
|
95
|
+
// c) skill 名含非法字符
|
|
96
|
+
const rC = runStateWithProtocol(dir, ['skill-load', 'open', 'bad/name']);
|
|
97
|
+
assertExit(rC, 1);
|
|
98
|
+
assertOut(rC, 'skill-load skill 名非法');
|
|
99
|
+
// d) --prompt 不在 flow-kit/prompts/ 下(指向场景内 reference 副本——文件存在可加载,
|
|
100
|
+
// 归属校验拒绝;若归属校验被跳过则此处会成功写标记,断言即失效)
|
|
101
|
+
const rD = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--prompt', 'reference/workflow-protocol.json']);
|
|
102
|
+
assertExit(rD, 1);
|
|
103
|
+
assertOut(rD, 'skill-load --prompt 路径必须位于 flow-kit/prompts/ 下');
|
|
104
|
+
// e) 自定义协议下未知节点同样拒绝(node 校验从内置清单改为当前协议节点集合
|
|
105
|
+
// 动态读取——协议外节点名依然非法,fail-closed 行为不变)
|
|
106
|
+
const custom = writeCustomProtocol(dir);
|
|
107
|
+
const rE = runState(['skill-load', 'bogus', 'flow-comet-change'], dir, { FLOW_COMET_PROTOCOL: custom });
|
|
108
|
+
assertExit(rE, 1);
|
|
109
|
+
assertOut(rE, 'skill-load node 非法');
|
|
110
|
+
// 全部拒绝后 .skill-loads/ 不产生任何标记文件
|
|
111
|
+
const loadsDir = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
|
|
112
|
+
if (fs.existsSync(loadsDir) && fs.readdirSync(loadsDir).length > 0) {
|
|
113
|
+
throw new Error('非法参数不应写入标记: ' + fs.readdirSync(loadsDir).join(', '));
|
|
114
|
+
}
|
|
115
|
+
},
|
|
116
|
+
},
|
|
117
|
+
|
|
118
|
+
// 100: record 校验 BLOCK(AC-3 反例)——completedChecks 含 required-skill:open.flow-comet-change
|
|
119
|
+
// 条目但无对应声明标记 → BLOCKED + 指引先加载 skill 并运行 skill-load;evidence 不写入
|
|
120
|
+
{
|
|
121
|
+
name: '100 record BLOCKED:completedChecks 缺声明标记(AC-3)',
|
|
122
|
+
run: (dir) => {
|
|
123
|
+
writeState(dir, baseState('open'));
|
|
124
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
125
|
+
const res = runStateWithProtocol(dir, ['record', 'open', JSON.stringify({ summary: 'done', completedChecks: ['required-skill:open.flow-comet-change'] })]);
|
|
126
|
+
assertExit(res, 1);
|
|
127
|
+
assertOut(res, 'BLOCKED');
|
|
128
|
+
assertOut(res, '缺少对应声明标记');
|
|
129
|
+
assertOut(res, 'workflow-state.mjs skill-load open flow-comet-change');
|
|
130
|
+
// BLOCK 先于记录——校验失败后 evidence 不得写入
|
|
131
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
132
|
+
if (st.evidence && st.evidence.open) throw new Error('BLOCKED 后不应写入 evidence: ' + JSON.stringify(st.evidence.open));
|
|
133
|
+
},
|
|
134
|
+
},
|
|
135
|
+
|
|
136
|
+
// 101: record 校验通过(AC-3 正例)——先 skill-load 写入标记,record 带同条 completedChecks → 正常记录
|
|
137
|
+
{
|
|
138
|
+
name: '101 record 通过:先 skill-load 声明标记(AC-3 正例)',
|
|
139
|
+
run: (dir) => {
|
|
140
|
+
writeState(dir, baseState('open'));
|
|
141
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
142
|
+
const sl = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change']);
|
|
143
|
+
assertExit(sl, 0);
|
|
144
|
+
assertOut(sl, 'SKILL-LOAD: open flow-comet-change');
|
|
145
|
+
const res = runStateWithProtocol(dir, ['record', 'open', JSON.stringify({ summary: 'done', completedChecks: ['required-skill:open.flow-comet-change'] })]);
|
|
146
|
+
assertExit(res, 0);
|
|
147
|
+
assertOut(res, 'EVIDENCE: open');
|
|
148
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
149
|
+
if (!st.evidence.open || st.evidence.open.summary !== 'done') {
|
|
150
|
+
throw new Error('record 未写入 evidence: ' + JSON.stringify(st.evidence));
|
|
151
|
+
}
|
|
152
|
+
// 自定义协议节点(compose 兼容)——node 校验按当前协议节点集合动态读取
|
|
153
|
+
// (内置 + 自定义),自定义节点(brainstorm)可 skill-load 声明 + record 声明校验端到端通过
|
|
154
|
+
// (修复前 BUILTIN_NODES 硬编码只含内置 8 节点 → skill-load 拒绝 brainstorm = RED)
|
|
155
|
+
writeFile(dir, 'custom-protocol.json', JSON.stringify(customProtocolWithSkillCall(), null, 2) + '\n');
|
|
156
|
+
const customEnv = { FLOW_COMET_PROTOCOL: path.join(dir, 'custom-protocol.json') };
|
|
157
|
+
const slCustom = runState(['skill-load', 'brainstorm', 'flow-comet-brainstorm'], dir, customEnv);
|
|
158
|
+
assertExit(slCustom, 0);
|
|
159
|
+
assertOut(slCustom, 'SKILL-LOAD: brainstorm flow-comet-brainstorm');
|
|
160
|
+
const resCustom = runState(['record', 'brainstorm', JSON.stringify({ summary: 'brainstorm done', completedChecks: ['required-skill:brainstorm.flow-comet-brainstorm'] })], dir, customEnv);
|
|
161
|
+
assertExit(resCustom, 0);
|
|
162
|
+
assertOut(resCustom, 'EVIDENCE: brainstorm');
|
|
163
|
+
},
|
|
164
|
+
},
|
|
165
|
+
|
|
166
|
+
// 102: exit 协议声明标记校验(AC-4)+ 真实链路集成——.skill-loads/ 已激活
|
|
167
|
+
// (目录存在)但无本节点协议标记(<node>-*.json 且 protocol ∈ 该节点协议集,节点协议映射表
|
|
168
|
+
// basename)→ BLOCKED;真实 skill-load --prompt 写入的标记(protocol = basename)→ exit 通过
|
|
169
|
+
// (修复后真实链路一致——缺陷修复前 skill-load 写解析后完整路径,exit 必 BLOCKED);未传
|
|
170
|
+
// --prompt(标记 protocol = null)→ BLOCKED;损坏标记(protocol 非协议集)→ BLOCKED
|
|
171
|
+
{
|
|
172
|
+
name: '102 exit 协议标记校验:真实链路通过 / 无标记·null·损坏 BLOCKED(AC-4)',
|
|
173
|
+
run: (dir) => {
|
|
174
|
+
const st = baseState('open');
|
|
175
|
+
st.evidence.open = { summary: 'intake complete' };
|
|
176
|
+
writeState(dir, st);
|
|
177
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n\n## 范围\n');
|
|
178
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n\n## 验收准则(AC)\n');
|
|
179
|
+
// 场景内 flow-kit/prompts/ 提示文件(真实 skill-load --prompt 指向——归属校验仅查前缀不读内容)
|
|
180
|
+
writeFile(dir, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
|
|
181
|
+
const loadsDir = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
|
|
182
|
+
fs.mkdirSync(loadsDir, { recursive: true });
|
|
183
|
+
// ① 机制已激活(.skill-loads/ 存在)但无 open-* 标记(仅他节点标记)→ BLOCKED
|
|
184
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/design-flow-comet-design.json',
|
|
185
|
+
JSON.stringify({ node: 'design', skill: 'flow-comet-design', protocol: '2-design.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
|
|
186
|
+
const resBlock = runGuard(['exit', 'open'], dir);
|
|
187
|
+
assertExit(resBlock, 1);
|
|
188
|
+
assertOut(resBlock, 'BLOCKED');
|
|
189
|
+
assertOut(resBlock, 'exit 缺协议声明标记');
|
|
190
|
+
// ② 真实链路:skill-load --prompt 写入标记(protocol = basename)→ exit 通过
|
|
191
|
+
const markerPath = path.join(loadsDir, 'open-flow-comet-change.json');
|
|
192
|
+
const sl = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--prompt', 'flow-kit/prompts/0-change.md']);
|
|
193
|
+
assertExit(sl, 0);
|
|
194
|
+
assertOut(sl, 'SKILL-LOAD: open flow-comet-change');
|
|
195
|
+
const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
|
|
196
|
+
if (marker.protocol !== '0-change.md') {
|
|
197
|
+
throw new Error('skill-load 标记 protocol 应为 --prompt 参数的 basename 0-change.md: ' + JSON.stringify(marker));
|
|
198
|
+
}
|
|
199
|
+
const resPass = runGuard(['exit', 'open'], dir);
|
|
200
|
+
assertExit(resPass, 0);
|
|
201
|
+
assertOut(resPass, 'ALL CHECKS PASSED');
|
|
202
|
+
assertNotOut(resPass, 'BLOCKED');
|
|
203
|
+
// ③ skill-load 未传 --prompt → 标记 protocol = null → exit BLOCKED(fail-closed:
|
|
204
|
+
// 无协议声明不可通过——指引补 skill-load --prompt)
|
|
205
|
+
const slNull = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change']);
|
|
206
|
+
assertExit(slNull, 0);
|
|
207
|
+
const markerNull = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
|
|
208
|
+
if (markerNull.protocol !== null) {
|
|
209
|
+
throw new Error('skill-load 未传 --prompt 标记 protocol 应为 null: ' + JSON.stringify(markerNull));
|
|
210
|
+
}
|
|
211
|
+
const resNull = runGuard(['exit', 'open'], dir);
|
|
212
|
+
assertExit(resNull, 1);
|
|
213
|
+
assertOut(resNull, 'BLOCKED');
|
|
214
|
+
assertOut(resNull, 'exit 缺协议声明标记');
|
|
215
|
+
// ④ 损坏标记(protocol 非协议集 basename)→ BLOCKED(fail-closed)
|
|
216
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
|
|
217
|
+
JSON.stringify({ node: 'open', skill: 'flow-comet-change', protocol: '9-other.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
|
|
218
|
+
const resCorrupt = runGuard(['exit', 'open'], dir);
|
|
219
|
+
assertExit(resCorrupt, 1);
|
|
220
|
+
assertOut(resCorrupt, 'BLOCKED');
|
|
221
|
+
assertOut(resCorrupt, 'exit 缺协议声明标记');
|
|
222
|
+
},
|
|
223
|
+
},
|
|
224
|
+
|
|
225
|
+
// 103: 交叉自洽(AC-5)——标记存在但 at 晚于 record 时间(手工构造未来时间戳)→ BLOCKED
|
|
226
|
+
// (标记必须先于记录声明——时间序可审计)
|
|
227
|
+
{
|
|
228
|
+
name: '103 record BLOCKED:标记 at 晚于记录时间(AC-5 交叉自洽)',
|
|
229
|
+
run: (dir) => {
|
|
230
|
+
writeState(dir, baseState('open'));
|
|
231
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
232
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
|
|
233
|
+
JSON.stringify({ node: 'open', skill: 'flow-comet-change', protocol: '0-change.md', at: '2999-12-31T00:00:00.000Z' }, null, 2) + '\n');
|
|
234
|
+
const res = runStateWithProtocol(dir, ['record', 'open', JSON.stringify({ summary: 'done', completedChecks: ['required-skill:open.flow-comet-change'] })]);
|
|
235
|
+
assertExit(res, 1);
|
|
236
|
+
assertOut(res, 'BLOCKED');
|
|
237
|
+
assertOut(res, '标记必须先于记录声明');
|
|
238
|
+
},
|
|
239
|
+
},
|
|
240
|
+
|
|
241
|
+
// 104: 旧 evidence/旧 change 兼容(AC-6)——旧格式记录(completedChecks 无 required-skill 条目 /
|
|
242
|
+
// 无 completedChecks)无标记照常通过;exit 在 .skill-loads/ 未激活(目录不存在)时
|
|
243
|
+
// SKILL-LOAD WARN 照常通过(声明机制未激活不追溯)
|
|
244
|
+
{
|
|
245
|
+
name: '104 旧 evidence/旧 change 兼容:无标记照常通过(AC-6)',
|
|
246
|
+
run: (dir) => {
|
|
247
|
+
writeState(dir, baseState('open'));
|
|
248
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
249
|
+
// ① 旧格式 record:completedChecks 无 required-skill 条目 → 无标记也通过
|
|
250
|
+
const resA = runStateWithProtocol(dir, ['record', 'open', JSON.stringify({ summary: 'legacy', completedChecks: ['unit-tests'] })]);
|
|
251
|
+
assertExit(resA, 0);
|
|
252
|
+
assertOut(resA, 'EVIDENCE: open');
|
|
253
|
+
// ② 无 completedChecks 的纯 summary 记录 → 通过
|
|
254
|
+
const resB = runStateWithProtocol(dir, ['record', 'open', JSON.stringify({ summary: 'plain' })]);
|
|
255
|
+
assertExit(resB, 0);
|
|
256
|
+
// ③ exit open:M5 后 record 已自动补声明标记 → 无 SKILL-LOAD WARN,正常通过
|
|
257
|
+
const st = baseState('open');
|
|
258
|
+
st.evidence.open = { summary: 'intake complete' };
|
|
259
|
+
writeState(dir, st);
|
|
260
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n\n## 范围\n');
|
|
261
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n\n## 验收准则(AC)\n');
|
|
262
|
+
const resC = runGuard(['exit', 'open'], dir);
|
|
263
|
+
assertExit(resC, 0);
|
|
264
|
+
assertOut(resC, 'ALL CHECKS PASSED');
|
|
265
|
+
assertNotOut(resC, 'SKILL-LOAD WARN');
|
|
266
|
+
// M5: record 已自动补 requiredSkillCalls 声明标记
|
|
267
|
+
if (!fs.existsSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads', 'open-flow-comet-change.json'))) {
|
|
268
|
+
throw new Error('record 自动声明标记缺失: open-flow-comet-change.json');
|
|
269
|
+
}
|
|
270
|
+
},
|
|
271
|
+
},
|
|
272
|
+
|
|
273
|
+
// 105: 计数一致性自检同步(AC-8 / AC-14)——组文件里的场景数或系统测试集项数变更时,
|
|
274
|
+
// 受检文件须同步(场景数:ALL n SCENARIOS PASSED / n scenarios / n 场景 / n/n 变体;
|
|
275
|
+
// 项数:n/n / n items / n 项 变体)。本场景读取权威源仓库的受检文件断言含当前计数变体——
|
|
276
|
+
// 文档漏同步或条目缺失(幽灵条目)即 RED;与底部自检共用同一实现(countSyncProblems),
|
|
277
|
+
// 两处判据不会漂移。安装副本无文档面,跳过。
|
|
278
|
+
{
|
|
279
|
+
name: '105 计数一致性自检同步:受检文件含当前场景数与系统测试集项数变体(AC-8 / AC-14)',
|
|
280
|
+
run: async () => {
|
|
281
|
+
if (!isAuthoritativeSourceRepo()) return; // 安装副本无 flow-comet 文档
|
|
282
|
+
const problems = await countSyncProblems();
|
|
283
|
+
if (problems.length > 0) {
|
|
284
|
+
throw new Error(problems.join('; '));
|
|
285
|
+
}
|
|
286
|
+
},
|
|
287
|
+
},
|
|
288
|
+
|
|
289
|
+
// 106: exit review——REVIEW.md 发现区条目处置状态结构级校验(L3-1:问题处理原则)——
|
|
290
|
+
// 发现项(含 Minor)无处置状态标记([已修]/[升级]/[转待办])→ REVIEW WARN 渐进不 BLOCK
|
|
291
|
+
// (防旧 REVIEW 卡死——旧 REVIEW 未按新格式写标记只警告不阻断);全部带标记 → 无 WARN
|
|
292
|
+
// (发现不得"记录后无声消失"——每条须有处置去向)
|
|
293
|
+
{
|
|
294
|
+
name: '106 exit review WARN:发现区条目缺处置状态标记(L3-1)',
|
|
295
|
+
run: (dir) => {
|
|
296
|
+
const st = baseState('review');
|
|
297
|
+
st.evidence.review = { summary: 'review done' };
|
|
298
|
+
writeState(dir, st);
|
|
299
|
+
// ① 发现区 Minor 条目无处置标记 → REVIEW WARN + 通过(渐进不阻断)
|
|
300
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
301
|
+
'# REVIEW\n\n## 发现\n\n### Critical\n\n无\n\n### Major\n\n无\n\n### Minor\n\n- **m-1 · 示例发现**:描述(未处置)\n\n## 结论\n\n通过\n');
|
|
302
|
+
const res = runGuard(['exit', 'review'], dir);
|
|
303
|
+
assertExit(res, 0);
|
|
304
|
+
assertOut(res, 'REVIEW WARN');
|
|
305
|
+
assertOut(res, 'ALL CHECKS PASSED');
|
|
306
|
+
// ② 同一条目带 [转待办] 处置标记 → 无 REVIEW WARN
|
|
307
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
308
|
+
'# REVIEW\n\n## 发现\n\n### Critical\n\n无\n\n### Major\n\n无\n\n### Minor\n\n- **m-1 · 示例发现**:描述 [转待办]\n\n## 结论\n\n通过\n');
|
|
309
|
+
const res2 = runGuard(['exit', 'review'], dir);
|
|
310
|
+
assertExit(res2, 0);
|
|
311
|
+
assertNotOut(res2, 'REVIEW WARN');
|
|
312
|
+
assertOut(res2, 'ALL CHECKS PASSED');
|
|
313
|
+
// ③ 有序条目(1. **...**)与无序同口径——缺处置标记 → 旧 change 仍渐进 REVIEW WARN
|
|
314
|
+
// (修复前 .filter((item) => !item.ordered) 使有序条目静默通过 = RED)
|
|
315
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
316
|
+
'# REVIEW\n\n## 发现\n\n1. **m-2 · 有序未处置**:某处问题,未给出任何处置结论,描述足够长以避免内容不足\n\n## 结论\n\n通过\n');
|
|
317
|
+
const resOrdered = runGuard(['exit', 'review'], dir);
|
|
318
|
+
assertExit(resOrdered, 0);
|
|
319
|
+
assertOut(resOrdered, 'REVIEW WARN');
|
|
320
|
+
assertNotOut(resOrdered, 'BLOCKED');
|
|
321
|
+
// ④ 有序 Minor 带 [转待办] → 无该渐进告警(有序条目接入校验不误报已处置项)
|
|
322
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
323
|
+
'# REVIEW\n\n## 发现\n\n1. **m-3 · 有序小项**:某处小问题,已登记下一 change 跟踪处置 [转待办]\n\n## 结论\n\n通过\n');
|
|
324
|
+
const resOrderedOk = runGuard(['exit', 'review'], dir);
|
|
325
|
+
assertExit(resOrderedOk, 0);
|
|
326
|
+
assertNotOut(resOrderedOk, 'REVIEW WARN');
|
|
327
|
+
assertOut(resOrderedOk, 'ALL CHECKS PASSED');
|
|
328
|
+
},
|
|
329
|
+
},
|
|
330
|
+
|
|
331
|
+
// 107: determineNode 产物推导 pathBase 感知——compose 自定义协议 outputSchemas 含
|
|
332
|
+
// pathBase='project' 工件(项目根 README.md)时,status/next 按项目根产物正确推进。
|
|
333
|
+
// 修复前 buildNodeCompletionFlags 丢弃 pathBase、nodeFlagsComplete 一律按 .specs/ 解析
|
|
334
|
+
// → 项目根工件永不命中 → 节点判定不完成 → next 钉回(卡死)。
|
|
335
|
+
{
|
|
336
|
+
name: '107 产物推导 pathBase 感知:project 根工件正确推进',
|
|
337
|
+
run: (dir) => {
|
|
338
|
+
// 自定义协议:brief(project 根 README.md)→ doccheck(specs-root report.md)
|
|
339
|
+
const custom = path.join(dir, 'pb-protocol.json');
|
|
340
|
+
writeFile(dir, 'pb-protocol.json', JSON.stringify({
|
|
341
|
+
schemaVersion: 1,
|
|
342
|
+
kind: 'workflow-kernel',
|
|
343
|
+
name: 'pathbase-test',
|
|
344
|
+
goal: 'pathBase 场景:pathBase=project 工件正确推进。',
|
|
345
|
+
nodes: [
|
|
346
|
+
{ id: 'brief', label: 'Brief', kind: 'control', responsibility: '产出项目根 README.md。', outputSchemas: ['pathbase.brief.v1'], requiredSkillCalls: [], augmentations: [], disabled: false },
|
|
347
|
+
{ id: 'doccheck', label: 'Doc Check', kind: 'control', responsibility: '产出 specs-root report.md。', outputSchemas: ['pathbase.doccheck.v1'], requiredSkillCalls: [], augmentations: [], disabled: false },
|
|
348
|
+
],
|
|
349
|
+
outputSchemas: [
|
|
350
|
+
{ id: 'pathbase.brief.v1', artifacts: [{ id: 'readme', paths: ['README.md'], pathBase: 'project' }] },
|
|
351
|
+
{ id: 'pathbase.doccheck.v1', artifacts: [{ id: 'report', paths: ['report.md'] }] },
|
|
352
|
+
],
|
|
353
|
+
}, null, 2));
|
|
354
|
+
// init(自定义协议经 --protocol CLI)+ 项目根产物 README.md
|
|
355
|
+
assertExit(runState(['init', CHANGE_ID, '--protocol', custom, '--init-skip'], dir), 0);
|
|
356
|
+
writeFile(dir, 'README.md', '# project readme\n');
|
|
357
|
+
// brief 完成(README.md 在项目根存在)→ determineNode 推导下一节点 doccheck
|
|
358
|
+
// (验证点:产物推导尊重 pathBase——修复前 README.md 按 .specs/ 解析永不命中 → currentNode 仍 brief)
|
|
359
|
+
// (注:next 的顺序门禁会 BLOCK 未 exit 节点——那是节点顺序语义,非本场景目标)
|
|
360
|
+
const st = runState(['status', '--protocol', custom], dir);
|
|
361
|
+
assertExit(st, 0);
|
|
362
|
+
assertOut(st, '"currentNode": "doccheck"');
|
|
363
|
+
},
|
|
364
|
+
},
|
|
365
|
+
|
|
366
|
+
// 108: 产物推导 fail-fast(B 方案)——协议声明 classic/native pathBase 时状态机推导
|
|
367
|
+
// 暂不支持(guard 侧全量感知、state 侧兜底不一致的已知边界),显式报错提示改用
|
|
368
|
+
// specs-root/project + 完整路径——不静默兜底(防卡死/误判)。
|
|
369
|
+
{
|
|
370
|
+
name: '108 产物推导 fail-fast:classic/native pathBase 显式报错(B 方案)',
|
|
371
|
+
run: (dir) => {
|
|
372
|
+
// 自定义协议:proposal 节点声明 classic-openspec-root 工件
|
|
373
|
+
const custom = path.join(dir, 'classic-protocol.json');
|
|
374
|
+
writeFile(dir, 'classic-protocol.json', JSON.stringify({
|
|
375
|
+
schemaVersion: 1,
|
|
376
|
+
kind: 'workflow-kernel',
|
|
377
|
+
name: 'classic-test',
|
|
378
|
+
goal: 'fail-fast 场景:classic pathBase 显式报错。',
|
|
379
|
+
nodes: [
|
|
380
|
+
{ id: 'proposal', label: 'Proposal', kind: 'control', responsibility: '产出 openspec 产物。', outputSchemas: ['classic.proposal.v1'], requiredSkillCalls: [], augmentations: [], disabled: false },
|
|
381
|
+
],
|
|
382
|
+
outputSchemas: [
|
|
383
|
+
{ id: 'classic.proposal.v1', artifacts: [{ id: 'proposal', paths: ['changes/xxx.md'], pathBase: 'classic-openspec-root' }] },
|
|
384
|
+
],
|
|
385
|
+
}, null, 2));
|
|
386
|
+
assertExit(runState(['init', CHANGE_ID, '--protocol', custom, '--init-skip'], dir), 0);
|
|
387
|
+
// status:classic/native pathBase → fail-fast 显式报错(不静默兜底)。
|
|
388
|
+
// 措辞订正:guard 侧同样拒绝这三类 pathBase,故消息不再说「由 guard 校验支持」
|
|
389
|
+
// (旧措辞会让人以为只有状态机推导缺支持)——断言随之锁新措辞。
|
|
390
|
+
const st = runState(['status', '--protocol', custom], dir);
|
|
391
|
+
assertExit(st, 1);
|
|
392
|
+
assertOut(st, '已不受 guard 与状态机支持');
|
|
393
|
+
assertOut(st, 'specs-root');
|
|
394
|
+
},
|
|
395
|
+
},
|
|
396
|
+
|
|
397
|
+
// 109: execute 出口校验——TASK done 任务 ↔ <id>-SUMMARY.md 存在——
|
|
398
|
+
// 缺任一 done 任务的 SUMMARY → WARN 渐进不 BLOCK(防旧 change 卡死);齐全 → 无 WARN
|
|
399
|
+
{
|
|
400
|
+
name: '109 execute exit:done 任务缺 SUMMARY → WARN 渐进',
|
|
401
|
+
run: (dir) => {
|
|
402
|
+
const st = baseState('execute');
|
|
403
|
+
st.evidence.execute = { summary: 'execute done' };
|
|
404
|
+
st.executionMode = 'direct'; // direct:串行任务主代理直写,不要求 handoff(聚焦产物完整性校验)
|
|
405
|
+
writeState(dir, st);
|
|
406
|
+
// TASK:两个 done 任务(T01/T02)
|
|
407
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
|
|
408
|
+
'<task id="T01" status="done"><action>实现 T01</action><write_files>src/t1.mjs</write_files><verify>node --check src/t1.mjs</verify></task>\n' +
|
|
409
|
+
'<task id="T02" status="done"><action>实现 T02</action><write_files>src/t2.mjs</write_files><verify>node --check src/t2.mjs</verify></task>\n');
|
|
410
|
+
// ① 只有 T02-SUMMARY.md(T01 缺)→ WARN 点名 T01-SUMMARY.md + 通过(渐进)
|
|
411
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T02-SUMMARY.md', summaryContent());
|
|
412
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
413
|
+
assertExit(res, 0);
|
|
414
|
+
assertOut(res, 'WARN');
|
|
415
|
+
assertOut(res, 'T01-SUMMARY.md');
|
|
416
|
+
assertOut(res, 'ALL CHECKS PASSED');
|
|
417
|
+
// ② 补 T01-SUMMARY.md → 无缺产物 WARN(既有 SKILL-LOAD 兼容 WARN 与本文无关)
|
|
418
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
419
|
+
const res2 = runGuard(['exit', 'execute'], dir);
|
|
420
|
+
assertExit(res2, 0);
|
|
421
|
+
assertNotOut(res2, '缺少 T01-SUMMARY.md');
|
|
422
|
+
assertOut(res2, 'ALL CHECKS PASSED');
|
|
423
|
+
},
|
|
424
|
+
},
|
|
425
|
+
|
|
426
|
+
// 110: execute 出口越权委托检测——TASK 有 parallel done 任务 + completedNodes
|
|
427
|
+
// 无 subagent-execute + 非 direct 模式 → WARN 渐进([P] 任务应由 subagent-execute 节点委托,
|
|
428
|
+
// execute 阶段完成 [P] 是越权委托痕迹——上轮真实流程实证的越权委托);completedNodes 含
|
|
429
|
+
// subagent-execute 或 direct 模式 → 无越权 WARN
|
|
430
|
+
{
|
|
431
|
+
name: '110 execute exit:parallel done 无 subagent-execute → WARN 越权委托',
|
|
432
|
+
run: (dir) => {
|
|
433
|
+
const st = baseState('execute');
|
|
434
|
+
st.evidence.execute = { summary: 'execute done' };
|
|
435
|
+
st.completedNodes = ['open', 'design', 'plan', 'execute']; // subagent-execute 未 exit
|
|
436
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['P01']) }; // 已委托(共用证据库)
|
|
437
|
+
writeState(dir, st);
|
|
438
|
+
// TASK:parallel done P01 + 产物 SUMMARY(满足 task-summaries 出口门禁 + KI-8)
|
|
439
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
|
|
440
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', summaryContent());
|
|
441
|
+
// ① completedNodes 无 subagent-execute + 非 direct → WARN(越权委托)
|
|
442
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
443
|
+
assertExit(res, 0);
|
|
444
|
+
assertOut(res, '越权委托');
|
|
445
|
+
assertOut(res, 'subagent-execute');
|
|
446
|
+
assertOut(res, 'ALL CHECKS PASSED');
|
|
447
|
+
// ② completedNodes 含 subagent-execute → 无越权 WARN
|
|
448
|
+
st.completedNodes = ['open', 'design', 'plan', 'execute', 'subagent-execute'];
|
|
449
|
+
writeState(dir, st);
|
|
450
|
+
const res2 = runGuard(['exit', 'execute'], dir);
|
|
451
|
+
assertExit(res2, 0);
|
|
452
|
+
assertNotOut(res2, '越权委托');
|
|
453
|
+
assertOut(res2, 'ALL CHECKS PASSED');
|
|
454
|
+
},
|
|
455
|
+
},
|
|
456
|
+
|
|
457
|
+
// 111: verify 出口越权委托兜底检测——同 KI-10 判定(TASK parallel done +
|
|
458
|
+
// completedNodes 无 subagent-execute + 非 direct),verify 时仍未 exit → WARN 兜底
|
|
459
|
+
// (execute 出口未拦截的兜底提示)
|
|
460
|
+
{
|
|
461
|
+
name: '111 verify exit:parallel done 无 subagent-execute → WARN 越权委托兜底',
|
|
462
|
+
run: (dir) => {
|
|
463
|
+
const st = baseState('verify');
|
|
464
|
+
st.evidence.verify = { summary: 'verified' };
|
|
465
|
+
st.completedNodes = ['open', 'design', 'plan', 'execute', 'review']; // 无 subagent-execute
|
|
466
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['P01']) };
|
|
467
|
+
writeState(dir, st);
|
|
468
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
|
|
469
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', summaryContent());
|
|
470
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TEST.md', '# TEST\n\n## 验证命令\n\n```bash\nnode -e "1"\n```\n');
|
|
471
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/UAT.md', '# UAT\n\n通过\n');
|
|
472
|
+
// ① completedNodes 无 subagent-execute → WARN 兜底
|
|
473
|
+
const res = runGuard(['exit', 'verify'], dir);
|
|
474
|
+
assertExit(res, 0);
|
|
475
|
+
assertOut(res, '越权委托');
|
|
476
|
+
assertOut(res, 'subagent-execute');
|
|
477
|
+
// ② completedNodes 含 subagent-execute → 无越权 WARN
|
|
478
|
+
st.completedNodes = ['open', 'design', 'plan', 'execute', 'subagent-execute', 'review'];
|
|
479
|
+
writeState(dir, st);
|
|
480
|
+
const res2 = runGuard(['exit', 'verify'], dir);
|
|
481
|
+
assertExit(res2, 0);
|
|
482
|
+
assertNotOut(res2, '越权委托');
|
|
483
|
+
},
|
|
484
|
+
},
|
|
485
|
+
|
|
486
|
+
// 112: 节点顺序 BLOCK 消息含恢复指引——next 的「疑似未 exit」BLOCK 与
|
|
487
|
+
// exit 的「currentNode 不匹配」BLOCK 均提示恢复通道(advance 强制推进/select 切换/
|
|
488
|
+
// exit --apply)——防 resume 自锁(上轮真实项目端到端验证观察:机器推导节点无脚本恢复通道)
|
|
489
|
+
{
|
|
490
|
+
name: '112 节点顺序 BLOCK 消息含恢复指引',
|
|
491
|
+
run: (dir) => {
|
|
492
|
+
// ① next:currentNode=execute 但未 exit(无 evidence 记录)→ BLOCK 消息含 advance/select 指引
|
|
493
|
+
const st1 = baseState('execute'); // evidence 空——无豁免,触发"疑似未 exit"BLOCK
|
|
494
|
+
writeState(dir, st1);
|
|
495
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true }); // findActiveChange 要求目录存在
|
|
496
|
+
const nx = runStateWithProtocol(dir, ['next']);
|
|
497
|
+
assertExit(nx, 1);
|
|
498
|
+
assertOut(nx, 'BLOCKED');
|
|
499
|
+
assertOut(nx, 'advance');
|
|
500
|
+
assertOut(nx, 'select');
|
|
501
|
+
// ② exit:currentNode=design 但 exit open → BLOCK 消息含 advance 指引
|
|
502
|
+
const st2 = baseState('design');
|
|
503
|
+
st2.evidence.design = { summary: 'design done' };
|
|
504
|
+
writeState(dir, st2);
|
|
505
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n\n## 范围\n');
|
|
506
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## AC\n');
|
|
507
|
+
const ex = runGuard(['exit', 'open'], dir);
|
|
508
|
+
assertExit(ex, 1);
|
|
509
|
+
assertOut(ex, 'BLOCKED');
|
|
510
|
+
assertOut(ex, 'advance');
|
|
511
|
+
// ③ exit 无 evidence → BLOCK 消息含 record 补证据指引(KI-3 补全)
|
|
512
|
+
const st3 = baseState('design');
|
|
513
|
+
writeState(dir, st3);
|
|
514
|
+
const ex3 = runGuard(['exit', 'open'], dir);
|
|
515
|
+
assertExit(ex3, 1);
|
|
516
|
+
assertOut(ex3, 'missing evidence');
|
|
517
|
+
assertOut(ex3, 'record');
|
|
518
|
+
},
|
|
519
|
+
},
|
|
520
|
+
|
|
521
|
+
// 113: plan 出口波次散文一致性检测——TASK 的 ## 波次划分 Wave 行任务带 [P]
|
|
522
|
+
// 标记(并行语义)但 XML 任务无 parallel="true" → WARN(散文与机器路由依据不一致,
|
|
523
|
+
// 以任务标记为准);XML 补齐 parallel → 无 WARN。容错:无并行语义的 Wave 行不参与比对。
|
|
524
|
+
// ③④ 追加同判据的段尾分支回归锚(波次段即文末,新 change 形态 ⇒ 必 BLOCK):段尾判定若
|
|
525
|
+
// 不成立,该检查会被整段静默跳过——下一条 [P] 行漏扫的同族形态见上一场景。
|
|
526
|
+
{
|
|
527
|
+
name: '113 plan exit:波次散文与并行标记不一致 → WARN(旧 change)/ BLOCK(新 change,含段即文末形态)',
|
|
528
|
+
run: (dir) => {
|
|
529
|
+
const st = baseState('plan');
|
|
530
|
+
st.evidence.plan = { summary: 'plan done' };
|
|
531
|
+
writeState(dir, st);
|
|
532
|
+
// TASK:波次散文 Wave 1 (parallel): T01[P], T02[P];XML 仅 T01 parallel(T02 不一致)
|
|
533
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n## 波次划分\n\nWave 1 (parallel): T01[P], T02[P]\n\n## 任务清单\n\n'
|
|
534
|
+
+ '<task id="T01" parallel="true" status="pending"><action>a</action><write_files>f1</write_files><verify>v</verify></task>\n'
|
|
535
|
+
+ '<task id="T02" status="pending"><action>b</action><write_files>f2</write_files><verify>v</verify></task>\n');
|
|
536
|
+
// ① 散文 T02[P] 但 XML 无 parallel → WARN
|
|
537
|
+
const res = runGuard(['exit', 'plan'], dir);
|
|
538
|
+
assertExit(res, 0);
|
|
539
|
+
assertOut(res, '波次散文');
|
|
540
|
+
assertOut(res, 'T02');
|
|
541
|
+
assertOut(res, 'ALL CHECKS PASSED');
|
|
542
|
+
// ② XML 补 T02 parallel → 无波次 WARN
|
|
543
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n## 波次划分\n\nWave 1 (parallel): T01[P], T02[P]\n\n## 任务清单\n\n'
|
|
544
|
+
+ '<task id="T01" parallel="true" status="pending"><action>a</action><write_files>f1</write_files><verify>v</verify></task>\n'
|
|
545
|
+
+ '<task id="T02" parallel="true" status="pending"><action>b</action><write_files>f2</write_files><verify>v</verify></task>\n');
|
|
546
|
+
const res2 = runGuard(['exit', 'plan'], dir);
|
|
547
|
+
assertExit(res2, 0);
|
|
548
|
+
assertNotOut(res2, '波次散文');
|
|
549
|
+
assertOut(res2, 'ALL CHECKS PASSED');
|
|
550
|
+
// ③ 段即文末形态(新 change):段提取的段尾判定第三个分支——波次段**即文末**(其后再无段
|
|
551
|
+
// 标题、亦无分隔线)。先跑「抽掉必报」对照:同 ④ 夹具仅去掉散文行的 [P] 标记 ⇒ 无并行
|
|
552
|
+
// 语义行 ⇒ 放行(该对照因此在任一态都可观测到)。
|
|
553
|
+
const stEof = baseState('plan');
|
|
554
|
+
stEof.evidence.plan = { summary: 'plan done' };
|
|
555
|
+
stEof.newChange = true;
|
|
556
|
+
writeState(dir, stEof);
|
|
557
|
+
assertExit(runGuard(['entry', 'plan'], dir), 0);
|
|
558
|
+
const taskT01Eof = '<task id="T01"><action>a</action><write_files>f</write_files><verify>v</verify><done>d</done></task>\n';
|
|
559
|
+
const eofHead = '# TASK\n\n## 波次划分\n\nWave 1 (parallel): ';
|
|
560
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', eofHead + 'T01\n\n' + taskT01Eof);
|
|
561
|
+
const resEofControl = runGuard(['exit', 'plan'], dir);
|
|
562
|
+
assertExit(resEofControl, 0);
|
|
563
|
+
assertNotOut(resEofControl, 'BLOCKED');
|
|
564
|
+
// ④ 同 ③ 夹具补回 [P] 标记(唯一变量)→ 段尾判定须成立、该检查不得被整段静默跳过 ⇒ BLOCK。
|
|
565
|
+
// 夹具形态自证(判别力前提):波次段之后不得再出现段标题 / 分隔线——否则该夹具退化为
|
|
566
|
+
// 「段后有下一段标题」形态,段尾第三分支失去覆盖而断言在两种写法下都成立(假绿)。
|
|
567
|
+
const eofFixture = eofHead + 'T01[P]\n\n' + taskT01Eof;
|
|
568
|
+
assertTrue(!/\n##\s|\n---/.test(eofFixture.slice(eofFixture.indexOf('## 波次划分'))),
|
|
569
|
+
'夹具形态前提不成立:波次段须为文末(其后不得再出现段标题或分隔线),否则段尾分支无覆盖');
|
|
570
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', eofFixture);
|
|
571
|
+
const resEof = runGuard(['exit', 'plan'], dir);
|
|
572
|
+
assertExit(resEof, 1);
|
|
573
|
+
assertOutMatches(resEof, /波次散文标记任务为并行(\[P\])但任务无 parallel="true"/, '波次段即文末时检查被整段跳过');
|
|
574
|
+
},
|
|
575
|
+
},
|
|
576
|
+
|
|
577
|
+
// 114: init 未知参数(以 -- 开头,如 --help)→ 报错而非当作 change 名执行
|
|
578
|
+
// (此前 --help 会被当作 change id 使用:自动开 change、建分支、写状态——误用有破坏性)
|
|
579
|
+
{
|
|
580
|
+
name: '114 init 未知参数(以 -- 开头)报错而非当作 change 名',
|
|
581
|
+
run: (dir) => {
|
|
582
|
+
execFileSync('git', ['init', '-q'], { cwd: dir, stdio: 'ignore' });
|
|
583
|
+
execFileSync('git', ['-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '--allow-empty', '-m', 'init'], { cwd: dir, stdio: 'ignore' });
|
|
584
|
+
const branchBefore = execFileSync('git', ['branch', '--show-current'], { cwd: dir, encoding: 'utf8' }).trim();
|
|
585
|
+
const res = runStateWithProtocol(dir, ['init', '--help']);
|
|
586
|
+
assertExit(res, 1);
|
|
587
|
+
assertOut(res, 'not a change name');
|
|
588
|
+
assertOut(res, 'Usage: workflow-state.mjs init');
|
|
589
|
+
assertNotOut(res, 'BRANCH:');
|
|
590
|
+
const branchAfter = execFileSync('git', ['branch', '--show-current'], { cwd: dir, encoding: 'utf8' }).trim();
|
|
591
|
+
if (branchAfter !== branchBefore) throw new Error('init --help 不应切换或创建分支');
|
|
592
|
+
if (fs.existsSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'))) {
|
|
593
|
+
throw new Error('init --help 不应写状态文件(此前被当作 change 名执行的副作用)');
|
|
594
|
+
}
|
|
595
|
+
if (fs.existsSync(path.join(dir, '.specs', '--help'))) {
|
|
596
|
+
throw new Error('init --help 不应创建 .specs/--help 工件目录');
|
|
597
|
+
}
|
|
598
|
+
// ② 带前导空白的 flag-like 参数(如 " --help")经 trim 后同样应被拒绝
|
|
599
|
+
const res2 = runStateWithProtocol(dir, ['init', ' --help']);
|
|
600
|
+
assertExit(res2, 1);
|
|
601
|
+
assertOut(res2, 'not a change name');
|
|
602
|
+
if (fs.existsSync(path.join(dir, '.specs', ' --help'))) {
|
|
603
|
+
throw new Error('init " --help" 不应创建工件目录(trim 后应被拒绝)');
|
|
604
|
+
}
|
|
605
|
+
},
|
|
606
|
+
},
|
|
607
|
+
|
|
608
|
+
// 115: M1 entry 证据化——新 change(enter 机制激活)未 entry 直接 exit → ENTER WARN(渐进不阻断)
|
|
609
|
+
{
|
|
610
|
+
name: '115 execute exit ENTER WARN:enter 机制激活但本节点未 entry(M1)',
|
|
611
|
+
run: (dir) => {
|
|
612
|
+
const st = baseState('execute');
|
|
613
|
+
st.evidence.execute = { summary: 'executed' };
|
|
614
|
+
st.enteredNodes = ['open', 'design', 'plan']; // 前序节点 enter 过(机制激活);execute 未 entry
|
|
615
|
+
writeState(dir, st);
|
|
616
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
617
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
618
|
+
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
619
|
+
st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
620
|
+
writeState(dir, st2);
|
|
621
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
622
|
+
assertExit(res, 0);
|
|
623
|
+
assertOut(res, 'ENTER WARN');
|
|
624
|
+
},
|
|
625
|
+
},
|
|
626
|
+
|
|
627
|
+
// 116: M1 正例——entry 后 exit 无 enter 证据警告
|
|
628
|
+
{
|
|
629
|
+
name: '116 execute exit 通过:entry 后无 enter 证据警告(M1 正例)',
|
|
630
|
+
run: (dir) => {
|
|
631
|
+
const st = baseState('execute');
|
|
632
|
+
st.evidence.execute = { summary: 'executed' };
|
|
633
|
+
st.enteredNodes = ['open', 'design', 'plan'];
|
|
634
|
+
writeState(dir, st);
|
|
635
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
636
|
+
assertExit(runGuard(['entry', 'execute'], dir), 0); // entry 记录 enter 标记
|
|
637
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
638
|
+
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
639
|
+
st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
640
|
+
writeState(dir, st2);
|
|
641
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
642
|
+
assertExit(res, 0);
|
|
643
|
+
assertNotOut(res, 'ENTER WARN');
|
|
644
|
+
},
|
|
645
|
+
},
|
|
646
|
+
|
|
647
|
+
// 117: M2——新 change(enter 机制激活)done 任务缺 SUMMARY → BLOCKED(旧 change WARN 渐进保留)
|
|
648
|
+
// 构造:两个 done 任务(T01/T02),仅 T01-SUMMARY 存在(满足产物通配符,隔离 KI-8 语义)
|
|
649
|
+
{
|
|
650
|
+
name: '117 execute exit BLOCKED:新 change done 任务缺 SUMMARY(M2)',
|
|
651
|
+
run: (dir) => {
|
|
652
|
+
const st = baseState('execute');
|
|
653
|
+
st.evidence.execute = { summary: 'executed' };
|
|
654
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'T02']) };
|
|
655
|
+
st.enteredNodes = ['open', 'design', 'plan', 'execute'];
|
|
656
|
+
st.newChange = true;
|
|
657
|
+
writeState(dir, st);
|
|
658
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE_TWO);
|
|
659
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
660
|
+
const res = runGuard(['exit', 'execute'], dir); // T02 缺 SUMMARY
|
|
661
|
+
assertExit(res, 1);
|
|
662
|
+
assertOut(res, 'SUMMARY');
|
|
663
|
+
},
|
|
664
|
+
},
|
|
665
|
+
|
|
666
|
+
// 118: M3——新 change(enter 机制激活)handoff 缺 redEvidence → BLOCKED(旧 change WARN 保留)
|
|
667
|
+
// 构造:handoffRequest + handoffResult 齐(满足 Output Schema evidence),仅缺 redEvidence(隔离 M3 语义)
|
|
668
|
+
{
|
|
669
|
+
name: '118 subagent-execute exit BLOCKED:新 change handoff 缺 redEvidence(M3)',
|
|
670
|
+
run: (dir) => {
|
|
671
|
+
const st = baseState('subagent-execute');
|
|
672
|
+
st.evidence.execute = { summary: 'executed' };
|
|
673
|
+
st.enteredNodes = ['open', 'design', 'plan', 'subagent-execute'];
|
|
674
|
+
st.newChange = true;
|
|
675
|
+
const handoff = handoffFor(['T01']);
|
|
676
|
+
delete handoff.T01.result.redEvidence;
|
|
677
|
+
st.evidence['subagent-execute'] = { summary: 'delegated', handoffRequest: { T01: { taskId: 'T01' } }, handoffResult: handoff };
|
|
678
|
+
writeState(dir, st);
|
|
679
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
680
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
681
|
+
const res = runGuard(['exit', 'subagent-execute'], dir);
|
|
682
|
+
assertExit(res, 1);
|
|
683
|
+
assertOut(res, 'redEvidence');
|
|
684
|
+
},
|
|
685
|
+
},
|
|
686
|
+
|
|
687
|
+
// 119: M4——handoff 提交对象不可校验 → HANDOFF ERROR 且含协调者确认提示
|
|
688
|
+
{
|
|
689
|
+
name: '119 handoff result 提交对象不可校验 → 协调者确认提示(M4)',
|
|
690
|
+
run: (dir) => {
|
|
691
|
+
writeState(dir, baseState('subagent-execute'));
|
|
692
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
693
|
+
execFileSync('git', ['init', '-q'], { cwd: dir });
|
|
694
|
+
execFileSync('git', ['-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-q', '--allow-empty', '-m', 'init'], { cwd: dir });
|
|
695
|
+
const payload = JSON.stringify({
|
|
696
|
+
status: 'DONE',
|
|
697
|
+
commitHash: 'deadbeef00000000000000000000000000000000',
|
|
698
|
+
redEvidence: { command: 'echo red', output: 'red' },
|
|
699
|
+
greenEvidence: { command: 'echo green', output: 'green' },
|
|
700
|
+
completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
|
|
701
|
+
riskSignals: ['none'],
|
|
702
|
+
});
|
|
703
|
+
const res = runHandoff(['result', 'T01', payload], dir);
|
|
704
|
+
assertExit(res, 0);
|
|
705
|
+
assertOut(res, 'HANDOFF ERROR');
|
|
706
|
+
assertOut(res, '确认'); // 协调者确认提示
|
|
707
|
+
},
|
|
708
|
+
},
|
|
709
|
+
|
|
710
|
+
// 120: M5——record 自动补写 skill-load 声明标记(open 节点 requiredSkillCalls)
|
|
711
|
+
{
|
|
712
|
+
name: '120 record 自动补写 skill-load 声明标记(M5)',
|
|
713
|
+
run: (dir) => {
|
|
714
|
+
const st = baseState('open');
|
|
715
|
+
st.enteredNodes = ['open'];
|
|
716
|
+
writeState(dir, st);
|
|
717
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why(为什么做)\nx');
|
|
718
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\nx\n\n## 验收准则(AC)\n- Given x When y Then z');
|
|
719
|
+
const res = runStateWithProtocol(dir, ['record', 'open', '{"summary":"done"}']);
|
|
720
|
+
assertExit(res, 0);
|
|
721
|
+
const loads = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
|
|
722
|
+
const changeMarker = path.join(loads, 'open-flow-comet-change.json');
|
|
723
|
+
const requirementMarker = path.join(loads, 'open-flow-comet-requirement.json');
|
|
724
|
+
if (!fs.existsSync(changeMarker)) {
|
|
725
|
+
throw new Error('record 自动声明标记缺失: open-flow-comet-change.json');
|
|
726
|
+
}
|
|
727
|
+
// 子断言:自动补标记的 protocol 字段按 skill 归属协议文件(修复前所有 skill 都写节点
|
|
728
|
+
// 首文件 0-change.md——requirement 标记的协议归属语义错误,此处应 RED)
|
|
729
|
+
const changeMeta = JSON.parse(fs.readFileSync(changeMarker, 'utf8'));
|
|
730
|
+
if (changeMeta.protocol !== '0-change.md') {
|
|
731
|
+
throw new Error('change 自动标记 protocol 应为 0-change.md: ' + JSON.stringify(changeMeta.protocol));
|
|
732
|
+
}
|
|
733
|
+
if (!fs.existsSync(requirementMarker)) {
|
|
734
|
+
throw new Error('record 自动声明标记缺失: open-flow-comet-requirement.json');
|
|
735
|
+
}
|
|
736
|
+
const requirementMeta = JSON.parse(fs.readFileSync(requirementMarker, 'utf8'));
|
|
737
|
+
if (requirementMeta.protocol !== '1-requirement.md') {
|
|
738
|
+
throw new Error('requirement 自动标记 protocol 应为 1-requirement.md(修复前误写 0-change.md): ' + JSON.stringify(requirementMeta.protocol));
|
|
739
|
+
}
|
|
740
|
+
},
|
|
741
|
+
},
|
|
742
|
+
|
|
743
|
+
// 121: M6——execute 显式空退出豁免(全 parallel 无串行任务,evidence 声明后通过)
|
|
744
|
+
{
|
|
745
|
+
name: '121 execute exit 通过:显式空退出豁免(M6)',
|
|
746
|
+
run: (dir) => {
|
|
747
|
+
const st = baseState('execute');
|
|
748
|
+
st.evidence.execute = { summary: 'empty exit', emptyExitApproved: true };
|
|
749
|
+
st.enteredNodes = ['open', 'design', 'plan', 'execute'];
|
|
750
|
+
st.newChange = true;
|
|
751
|
+
writeState(dir, st);
|
|
752
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n<task id="T01" parallel="true" status="pending" depends_on="">\n <name>p</name>\n <write_files>a</write_files>\n <action>p</action>\n <verify>t</verify>\n <done>d</done>\n</task>');
|
|
753
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
754
|
+
assertExit(res, 0);
|
|
755
|
+
// 子断言:豁免不适用于存在未完成串行任务——防规划错误被豁免掩盖
|
|
756
|
+
// (修复前 emptyExitApproved 会跳过串行 pending 阻断,此处应 RED)
|
|
757
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n<task id="T02" status="pending"><action>串行任务</action><write_files>f</write_files><verify>v</verify></task>\n');
|
|
758
|
+
const resSerial = runGuard(['exit', 'execute'], dir);
|
|
759
|
+
assertExit(resSerial, 1);
|
|
760
|
+
assertOut(resSerial, '串行 pending');
|
|
761
|
+
},
|
|
762
|
+
},
|
|
763
|
+
|
|
764
|
+
// 122: M7——旧 change(enter 机制未激活)done 缺 SUMMARY 仍 WARN 渐进,不升级(兼容正例)
|
|
765
|
+
// 构造:两个 done 任务(T01/T02),仅 T01-SUMMARY 存在(满足产物通配符,隔离 KI-8 语义)
|
|
766
|
+
{
|
|
767
|
+
name: '122 execute exit 兼容:旧 change done 缺 SUMMARY 仍 WARN 渐进(M7)',
|
|
768
|
+
run: (dir) => {
|
|
769
|
+
const st = baseState('execute');
|
|
770
|
+
st.evidence.execute = { summary: 'executed' };
|
|
771
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'T02']) };
|
|
772
|
+
writeState(dir, st); // 无 enteredNodes(旧 change)
|
|
773
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE_TWO);
|
|
774
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
775
|
+
const res = runGuard(['exit', 'execute'], dir); // T02 缺 SUMMARY → 旧 change 仍 WARN 渐进
|
|
776
|
+
assertExit(res, 0);
|
|
777
|
+
assertOut(res, 'WARN');
|
|
778
|
+
},
|
|
779
|
+
},
|
|
780
|
+
|
|
781
|
+
// 123: M8——init 在无提交(空)仓库时输出提示且跳过分支创建(行为一致:
|
|
782
|
+
// 修复前 WARN"无法创建分支"后仍 checkout -b 实际创建——声称与行为矛盾)
|
|
783
|
+
{
|
|
784
|
+
name: '123 init 空仓库提示:无提交仓库的分支创建边界(M8)',
|
|
785
|
+
run: (dir) => {
|
|
786
|
+
execFileSync('git', ['init', '-q'], { cwd: dir, stdio: 'ignore' });
|
|
787
|
+
const res = runStateWithProtocol(dir, ['init', 'empty-repo']);
|
|
788
|
+
assertExit(res, 0);
|
|
789
|
+
assertOut(res, 'EMPTY-REPO');
|
|
790
|
+
// 子断言 ①:警告后不得实际创建分支(unborn HEAD 下 rev-parse 失败 → currentBranch=null
|
|
791
|
+
// → checkout -b 被跳过——分支列表应保持为空)
|
|
792
|
+
const branches = execFileSync('git', ['branch', '--list'], { cwd: dir, encoding: 'utf8' });
|
|
793
|
+
if (branches.includes('change/empty-repo')) {
|
|
794
|
+
throw new Error('空仓库警告后仍创建了 change/empty-repo 分支: ' + branches);
|
|
795
|
+
}
|
|
796
|
+
// 子断言 ②:BRANCH 输出不得声称分支已创建(修复前输出 'BRANCH: change/empty-repo'
|
|
797
|
+
// 但分支实际未创建——声称与行为矛盾,此处应 RED)
|
|
798
|
+
assertNotOut(res, 'BRANCH: change/empty-repo');
|
|
799
|
+
},
|
|
800
|
+
},
|
|
801
|
+
|
|
802
|
+
// 124: M3 旧兼容——旧 change(enter 机制未激活)handoff 缺 redEvidence 仍 WARN 渐进(不升级)
|
|
803
|
+
{
|
|
804
|
+
name: '124 subagent-execute exit 兼容:旧 change handoff 缺 redEvidence 仍 WARN(M3 旧兼容)',
|
|
805
|
+
run: (dir) => {
|
|
806
|
+
const st = baseState('subagent-execute');
|
|
807
|
+
st.evidence.execute = { summary: 'executed' };
|
|
808
|
+
const handoff = handoffFor(['T01']);
|
|
809
|
+
delete handoff.T01.result.redEvidence;
|
|
810
|
+
st.evidence['subagent-execute'] = { summary: 'delegated', handoffRequest: { T01: { taskId: 'T01' } }, handoffResult: handoff };
|
|
811
|
+
writeState(dir, st); // 无 enteredNodes(旧 change)
|
|
812
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
813
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
814
|
+
const res = runGuard(['exit', 'subagent-execute'], dir);
|
|
815
|
+
assertExit(res, 0);
|
|
816
|
+
assertOut(res, 'HANDOFF WARN');
|
|
817
|
+
},
|
|
818
|
+
},
|
|
819
|
+
|
|
820
|
+
// 125: R1——新 change(newChange:true)review 处置标记缺失 → BLOCKED(旧 change WARN 保留);
|
|
821
|
+
// 并内扩 Major 延期待裁决门禁三态+一反例:无用户裁决 BLOCK / 同段或文末裁决(由 [升级]
|
|
822
|
+
// 承接)放行 / Minor [转待办] 不受影响 / 有裁决但缺 [升级] 承接仍 BLOCK。
|
|
823
|
+
{
|
|
824
|
+
name: '125 review exit BLOCKED:新 change 处置标记缺失 + Major 延期待裁决(R1)',
|
|
825
|
+
run: (dir) => {
|
|
826
|
+
const st = baseState('review');
|
|
827
|
+
st.evidence.review = { summary: 'reviewed' };
|
|
828
|
+
st.newChange = true;
|
|
829
|
+
writeState(dir, st);
|
|
830
|
+
assertExit(runGuard(['entry', 'review'], dir), 0);
|
|
831
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题A**: 某处存在一个需要记录的问题描述,但未给出任何处置结论\n\n## 结论\n\n通过\n');
|
|
832
|
+
const res = runGuard(['exit', 'review'], dir);
|
|
833
|
+
assertExit(res, 1);
|
|
834
|
+
assertOut(res, '处置状态标记');
|
|
835
|
+
// 子断言:四要素字段行(Symptom/Source/Consequence/Remedy)不误判为发现条目——
|
|
836
|
+
// 执行者按 brooks 输出格式书写(带处置标记的条目)应正常通过
|
|
837
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题B**: 某处问题 **[已修]**\n - **Symptom**: 具体现象\n - **Source**: 某书某节\n - **Consequence**: 若不修会怎样\n - **Remedy**: 怎么改\n\n## 结论\n\n通过\n');
|
|
838
|
+
const resOk = runGuard(['exit', 'review'], dir);
|
|
839
|
+
assertExit(resOk, 0);
|
|
840
|
+
assertOut(resOk, 'ALL CHECKS PASSED');
|
|
841
|
+
// 子断言:字段豁免必须精确匹配完整标签(允许尾冒号)——"Source maps expose paths"
|
|
842
|
+
// 这类以 Source 开头的真实发现标题不得被误豁免(修复前前缀匹配会跳过其处置校验)
|
|
843
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **Source maps expose paths**: 某处泄露文件路径,未给出任何处置结论\n\n## 结论\n\n通过\n');
|
|
844
|
+
const resSource = runGuard(['exit', 'review'], dir);
|
|
845
|
+
assertExit(resSource, 1);
|
|
846
|
+
assertOut(resSource, '处置状态标记');
|
|
847
|
+
// 负例对照:完整标签行(Symptom:/Source:)仍豁免(字段行不是发现条目)
|
|
848
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题C**: 某处问题 **[已修]**\n - **Symptom**: 现象\n - **Source**: 某书\n\n## 结论\n\n通过\n');
|
|
849
|
+
const resOk2 = runGuard(['exit', 'review'], dir);
|
|
850
|
+
assertExit(resOk2, 0);
|
|
851
|
+
assertOut(resOk2, 'ALL CHECKS PASSED');
|
|
852
|
+
// 子断言:Major [转待办] 属用户决策点——无用户裁决记录 → BLOCKED(修复前放行 = RED)
|
|
853
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F1 · 未裁决的延期**:某处问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
854
|
+
const resMajor = runGuard(['exit', 'review'], dir);
|
|
855
|
+
assertExit(resMajor, 1);
|
|
856
|
+
assertOut(resMajor, 'BLOCKED');
|
|
857
|
+
assertOut(resMajor, 'Major');
|
|
858
|
+
assertOut(resMajor, '用户裁决');
|
|
859
|
+
// 子断言:同段用户裁决 + [升级] 承接 → 放行
|
|
860
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F2 · 已裁决的延期**:某处问题 [升级] [转待办](用户裁决:接受延期,下一 change 首修)\n\n## 结论\n\n通过\n');
|
|
861
|
+
const resAdjudicated = runGuard(['exit', 'review'], dir);
|
|
862
|
+
assertExit(resAdjudicated, 0);
|
|
863
|
+
assertOut(resAdjudicated, 'ALL CHECKS PASSED');
|
|
864
|
+
assertNotOut(resAdjudicated, '用户裁决');
|
|
865
|
+
// 子断言:Minor [转待办] 不受影响 → 放行
|
|
866
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-1 · 小项**:某处小问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
867
|
+
const resMinor = runGuard(['exit', 'review'], dir);
|
|
868
|
+
assertExit(resMinor, 0);
|
|
869
|
+
assertOut(resMinor, 'ALL CHECKS PASSED');
|
|
870
|
+
// 子断言:文末用户裁决 + 指向该条目 + [升级] 承接 → 放行
|
|
871
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F3 · 文末裁决的延期**:某处问题 [升级] [转待办]\n\n## 用户裁决\n\n- 用户裁决:接受延期 —— 发现 F3(文末裁决的延期):下一 change 首修。\n\n## 结论\n\n通过\n');
|
|
872
|
+
const resTail = runGuard(['exit', 'review'], dir);
|
|
873
|
+
assertExit(resTail, 0);
|
|
874
|
+
assertOut(resTail, 'ALL CHECKS PASSED');
|
|
875
|
+
// 子断言:尾部裁决段落引用条目整行(引用块)时不得被误判为条目自身段落 → 放行
|
|
876
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F5 · 引用条目行的尾部裁决**:某处问题 [升级] [转待办]\n\n## 用户裁决\n\n> - **F5 · 引用条目行的尾部裁决**:某处问题 [升级] [转待办]\n> 用户裁决:接受延期 —— 发现 F5:下一 change 首修。\n\n## 结论\n\n通过\n');
|
|
877
|
+
const resQuotedTail = runGuard(['exit', 'review'], dir);
|
|
878
|
+
assertExit(resQuotedTail, 0);
|
|
879
|
+
assertOut(resQuotedTail, 'ALL CHECKS PASSED');
|
|
880
|
+
// 子断言:有用户裁决但缺 [升级] 承接 → 仍 BLOCKED(不因裁决在文末就跳过承接校验)
|
|
881
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F4 · 无升级承接**:某处问题 [转待办]\n\n## 用户裁决\n\n- 用户裁决:接受延期 —— 发现 F4(无升级承接):下一 change 首修。\n\n## 结论\n\n通过\n');
|
|
882
|
+
const resNoEscalation = runGuard(['exit', 'review'], dir);
|
|
883
|
+
assertExit(resNoEscalation, 1);
|
|
884
|
+
assertOut(resNoEscalation, 'BLOCKED');
|
|
885
|
+
assertOut(resNoEscalation, 'Major');
|
|
886
|
+
assertOut(resNoEscalation, '用户裁决');
|
|
887
|
+
// 子断言:Minor 条目正文引用 [Major] 标签字样(自身 [转待办])→ 放行——严重度/处置
|
|
888
|
+
// 以条目自身标题/行首为准,不做整块标签扫描(修复前误判 Major 并触发延期门禁 = RED)
|
|
889
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n- **m-2 · 引用 Major 的小项**:本条与 [Major] F1 项不同,是独立问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
890
|
+
const resCited = runGuard(['exit', 'review'], dir);
|
|
891
|
+
assertExit(resCited, 0);
|
|
892
|
+
assertOut(resCited, 'ALL CHECKS PASSED');
|
|
893
|
+
assertNotOut(resCited, 'BLOCKED');
|
|
894
|
+
// 子断言:Major 条目自身处置为 [已修],续行正文引用他条 [转待办] → 放行——
|
|
895
|
+
// 延期门禁只看该条目自身标题/行首的处置标记,不做整块扫描
|
|
896
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **[Major] F9 · 已修项引用他条**:某处问题 [已修]\n (续行仅引用他条的处置去向 [转待办],非本条处置)\n\n## 结论\n\n通过\n');
|
|
897
|
+
const resQuotedDisposition = runGuard(['exit', 'review'], dir);
|
|
898
|
+
assertExit(resQuotedDisposition, 0);
|
|
899
|
+
assertOut(resQuotedDisposition, 'ALL CHECKS PASSED');
|
|
900
|
+
assertNotOut(resQuotedDisposition, 'BLOCKED');
|
|
901
|
+
// 子断言:有序 Major 标签条目缺任何处置标记 → BLOCKED(修复前有序条目被跳过 = RED)
|
|
902
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n1. **[Major] F6 · 有序无处置**:某处问题,未给出任何处置结论,描述足够长以避免内容不足\n\n## 结论\n\n通过\n');
|
|
903
|
+
const resOrderedMissing = runGuard(['exit', 'review'], dir);
|
|
904
|
+
assertExit(resOrderedMissing, 1);
|
|
905
|
+
assertOut(resOrderedMissing, '处置状态标记');
|
|
906
|
+
// 子断言:有序 Major [转待办] 无用户裁决 → BLOCKED(Major 延期门禁对有序条目同口径)
|
|
907
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n1. **F7 · 有序未裁决的延期**:某处问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
908
|
+
const resOrderedDeferred = runGuard(['exit', 'review'], dir);
|
|
909
|
+
assertExit(resOrderedDeferred, 1);
|
|
910
|
+
assertOut(resOrderedDeferred, 'Major');
|
|
911
|
+
assertOut(resOrderedDeferred, '用户裁决');
|
|
912
|
+
// 子断言:有序 Major [升级] [转待办] + 同段用户裁决([升级] 承接)→ 放行
|
|
913
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n1. **F8 · 有序已裁决的延期**:某处问题 [升级] [转待办](用户裁决:接受延期,下一 change 首修)\n\n## 结论\n\n通过\n');
|
|
914
|
+
const resOrderedAdjudicated = runGuard(['exit', 'review'], dir);
|
|
915
|
+
assertExit(resOrderedAdjudicated, 0);
|
|
916
|
+
assertOut(resOrderedAdjudicated, 'ALL CHECKS PASSED');
|
|
917
|
+
assertNotOut(resOrderedAdjudicated, '用户裁决');
|
|
918
|
+
// 子断言:中间位置的独立裁决段落(不与条目同段、也不在文末)——指向该条目且含
|
|
919
|
+
// [升级] 承接 → 放行。实现按独立段落匹配,位置不限;文档须写明这一合法形态。
|
|
920
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
921
|
+
'# REVIEW\n\n## 发现\n\n### Major\n\n'
|
|
922
|
+
+ '- **F10 · 中段裁决的延期**:某处问题 [升级] [转待办]\n\n'
|
|
923
|
+
+ '- 用户裁决:接受延期 —— 发现 F10(中段裁决的延期):下一 change 首修。\n\n'
|
|
924
|
+
+ '### Minor\n\n- **m-4 · 小项**:另一个独立问题 [已修]\n\n## 结论\n\n通过\n');
|
|
925
|
+
const resMidParagraph = runGuard(['exit', 'review'], dir);
|
|
926
|
+
assertExit(resMidParagraph, 0);
|
|
927
|
+
assertOut(resMidParagraph, 'ALL CHECKS PASSED');
|
|
928
|
+
// 子断言:文档口径与实现对齐——review SKILL 须写明「单独段落(指向条目 + [升级] 承接)」
|
|
929
|
+
// 也是合法裁决位置,避免文档只写「同段或文末」而收窄实现语义(文档未同步 = RED)。
|
|
930
|
+
const reviewSkillText = fs.readFileSync(
|
|
931
|
+
path.join(SCRIPTS_DIR, '..', '..', 'flow-comet-review', 'SKILL.md'), 'utf8');
|
|
932
|
+
if (!reviewSkillText.includes('单独段落') || !reviewSkillText.includes('指向') || !reviewSkillText.includes('[升级]')) {
|
|
933
|
+
throw new Error('flow-comet-review/SKILL.md 未写明「单独段落(指向条目 + [升级] 承接)」合法');
|
|
934
|
+
}
|
|
935
|
+
},
|
|
936
|
+
},
|
|
937
|
+
|
|
938
|
+
// 126: R1——新 change builtin 缓存证据缺失 → BLOCKED
|
|
939
|
+
{
|
|
940
|
+
name: '126 execute exit BLOCKED:新 change builtin 缓存证据缺失(R1)',
|
|
941
|
+
run: (dir) => {
|
|
942
|
+
const st = baseState('execute');
|
|
943
|
+
st.evidence.execute = { summary: 'executed' };
|
|
944
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
945
|
+
st.newChange = true;
|
|
946
|
+
writeState(dir, st);
|
|
947
|
+
assertExit(runGuard(['entry', 'execute'], dir), 0);
|
|
948
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
949
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent({
|
|
950
|
+
method: '## 自检方法\n\nbrooks-lint 不可用,builtin-quickcheck',
|
|
951
|
+
sixDim: '## 6 维自查\n\n- 功能: 通过\n- 性能: 无影响\n- 安全: 无影响\n- 兼容: 通过\n- 可观测: 通过\n- 可维护: 通过',
|
|
952
|
+
}));
|
|
953
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
954
|
+
assertExit(res, 1);
|
|
955
|
+
assertOut(res, '缓存');
|
|
956
|
+
// 子断言:拦截消息须含关键词引导(声明级校验的执行者体验——真机回归实证:语义完整但
|
|
957
|
+
// 缺关键词被拦,消息应指明所需关键词,防执行者无从下手)
|
|
958
|
+
assertOut(res, '须含关键词');
|
|
959
|
+
},
|
|
960
|
+
},
|
|
961
|
+
|
|
962
|
+
// 127: R1——新 change 波次散文不一致 → BLOCKED。波次段提取的「段尾」判定在此留一格判别夹具 +
|
|
963
|
+
// 一格单变量对照:① 段后紧跟下一段标题、段内无大写 Z(阳性对照,检查本身在场,两态同判);
|
|
964
|
+
// ② 段内**早于** [P] 行出现大写 Z(机检标记字面量形态)但散文行无 [P] 标记(「抽掉必报」对照:
|
|
965
|
+
// 去掉 [P] 这一个变量 ⇒ 无并行语义行 ⇒ 放行,两态同判);③ 同 ② 的夹具补回 [P] 标记 ⇒ 段体
|
|
966
|
+
// 若在段内首个大写 Z 处提前收尾,该 [P] 行整行漏扫 ⇒ 本应 BLOCK 却静默放过(③ 即该形态的
|
|
967
|
+
// 常驻回归锚)。段即文末的第二形态见下一场景(同判据、另一段尾分支,独立成景以便单轮同时可见)。
|
|
968
|
+
// 两格夹具各自带「形态前提」断言(Z 早于 [P] 行)——形态漂移会让锚静默退化成假绿。
|
|
969
|
+
{
|
|
970
|
+
name: '127 plan exit BLOCKED:新 change 波次散文不一致(R1;段内大写 Z 早于 [P] 行形态)',
|
|
971
|
+
run: (dir) => {
|
|
972
|
+
const st = baseState('plan');
|
|
973
|
+
st.evidence.plan = { summary: 'planned' };
|
|
974
|
+
st.newChange = true;
|
|
975
|
+
writeState(dir, st);
|
|
976
|
+
assertExit(runGuard(['entry', 'plan'], dir), 0);
|
|
977
|
+
const planTask = (text) => writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', text);
|
|
978
|
+
const taskT01 = '<task id="T01"><action>a</action><write_files>f</write_files><verify>v</verify><done>d</done></task>\n';
|
|
979
|
+
// 判别句式锚(非裸子串):拦因句 + 判据分支,抽掉该句即红
|
|
980
|
+
const waveBlocked = /波次散文标记任务为并行(\[P\])但任务无 parallel="true"/;
|
|
981
|
+
// 大写 Z 说明行:段内早于 [P] 行,且自身不含并行语义词(避免截断态/完整态的行筛选差异)
|
|
982
|
+
const waveZNote = '- 机检标记形态说明(ZERO-LOGIC-CHANGE-OK)';
|
|
983
|
+
// ① 段后有下一段标题、段内无 Z → BLOCK(阳性对照:两态同判)
|
|
984
|
+
planTask('# TASK\n\n## 波次划分\n\nWave 1 (parallel): T01[P]\n\n## 任务清单\n\n' + taskT01);
|
|
985
|
+
const res = runGuard(['exit', 'plan'], dir);
|
|
986
|
+
assertExit(res, 1);
|
|
987
|
+
assertOutMatches(res, waveBlocked, '波次散文不一致');
|
|
988
|
+
// 段内大写 Z 说明行 + 散文行共用夹具(散文行的 [P] 标记为唯一变量):② 不带 [P](抽掉必报
|
|
989
|
+
// 对照)、③ 带 [P](判别夹具)。形态自证:大写 Z 必须**早于** [P] 行——若 Z 排在 [P] 行之后,
|
|
990
|
+
// 段体截断点落在该行之后、该行仍会被扫描,本族断言在两种写法下都成立(假绿 ⇒ 零判别力)。
|
|
991
|
+
const zWaveFixture = (marker) => '# TASK\n\n## 波次划分\n\n' + waveZNote + '\n\nWave 1 (parallel): T01' + marker + '\n\n## 任务清单\n\n' + taskT01;
|
|
992
|
+
assertTrue(zWaveFixture('[P]').indexOf(waveZNote) < zWaveFixture('[P]').indexOf('T01[P]'),
|
|
993
|
+
'夹具形态前提不成立:大写 Z 说明行须早于 [P] 行,否则段尾截断不影响该行扫描(锚零判别力)');
|
|
994
|
+
// ② 抽掉必报自证(单变量对照):段内大写 Z 说明行在场、散文行无 [P] 标记 → 放行
|
|
995
|
+
planTask(zWaveFixture(''));
|
|
996
|
+
const resNoMarker = runGuard(['exit', 'plan'], dir);
|
|
997
|
+
assertExit(resNoMarker, 0);
|
|
998
|
+
assertNotOut(resNoMarker, 'BLOCKED');
|
|
999
|
+
assertOut(resNoMarker, 'ALL CHECKS PASSED');
|
|
1000
|
+
// ③ 同一夹具补回散文行的 [P] 标记(唯一变量)→ 段内大写 Z 之后的 [P] 行不得漏扫 ⇒ BLOCK
|
|
1001
|
+
planTask(zWaveFixture('[P]'));
|
|
1002
|
+
const resZ = runGuard(['exit', 'plan'], dir);
|
|
1003
|
+
assertExit(resZ, 1);
|
|
1004
|
+
assertOutMatches(resZ, waveBlocked, '段内大写 Z 之后的 [P] 行漏扫');
|
|
1005
|
+
},
|
|
1006
|
+
},
|
|
1007
|
+
|
|
1008
|
+
// 128: R1——新 change 越权委托(KI-10)→ BLOCKED
|
|
1009
|
+
{
|
|
1010
|
+
name: '128 execute exit BLOCKED:新 change 越权委托(R1)',
|
|
1011
|
+
run: (dir) => {
|
|
1012
|
+
const st = baseState('execute');
|
|
1013
|
+
st.evidence.execute = { summary: 'executed' };
|
|
1014
|
+
st.newChange = true;
|
|
1015
|
+
writeState(dir, st);
|
|
1016
|
+
assertExit(runGuard(['entry', 'execute'], dir), 0);
|
|
1017
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
|
|
1018
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', summaryContent()); // 满足 M2
|
|
1019
|
+
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1020
|
+
st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['P01']) }; // 满足越俎代庖,触发 KI-10 越权委托
|
|
1021
|
+
writeState(dir, st2);
|
|
1022
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
1023
|
+
assertExit(res, 1);
|
|
1024
|
+
assertOut(res, '越权');
|
|
1025
|
+
|
|
1026
|
+
// ===== M-02 request 时刻归属门禁(AC-1/AC-2/AC-3 的 L1 面)=====
|
|
1027
|
+
// 夹具前提:新 change 驻留 execute + 本节点技能声明标记在场(否则先被技能声明门 BLOCK,
|
|
1028
|
+
// 测不到归属门禁本身);协议副本由运行器放入 <dir>/reference/ 并显式指向(env 优先级)。
|
|
1029
|
+
const reqEnv = { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) };
|
|
1030
|
+
const reqStatePath = path.join(dir, '.flow-comet', 'flow-comet-state.json');
|
|
1031
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
|
|
1032
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/execute-flow-comet-dev.json',
|
|
1033
|
+
JSON.stringify({ node: 'execute', skill: 'flow-comet-dev', protocol: '4-dev.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
|
|
1034
|
+
const pendingParallelTask =
|
|
1035
|
+
'<task id="P-M02" parallel="true" status="pending"><action>实现 P-M02</action><write_files>src/p-m02.mjs</write_files><verify>node --check src/p-m02.mjs</verify></task>\n';
|
|
1036
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + pendingParallelTask);
|
|
1037
|
+
// ① 新 change 错误节点 pending 并行 request → BLOCK + state 字节零改写 + 不落请求记录 + 恢复指引
|
|
1038
|
+
const reqState = baseState('execute');
|
|
1039
|
+
reqState.newChange = true;
|
|
1040
|
+
reqState.enteredNodes = ['execute'];
|
|
1041
|
+
writeState(dir, reqState);
|
|
1042
|
+
const beforeReqBytes = fs.readFileSync(reqStatePath, 'utf8');
|
|
1043
|
+
const resWrongNode = runHandoff(['request', 'P-M02', 'parallel fix slice'], dir, reqEnv);
|
|
1044
|
+
assertExit(resWrongNode, 1);
|
|
1045
|
+
assertOut(resWrongNode, 'BLOCKED: 任务 P-M02(并行 pending)应归属节点 subagent-execute');
|
|
1046
|
+
assertOut(resWrongNode, 'workflow-state next');
|
|
1047
|
+
assertOut(resWrongNode, 'entry subagent-execute');
|
|
1048
|
+
assertOut(resWrongNode, '本次请求未写入 state');
|
|
1049
|
+
if (fs.readFileSync(reqStatePath, 'utf8') !== beforeReqBytes) {
|
|
1050
|
+
throw new Error('M-02 BLOCK 必须 state 字节零改写');
|
|
1051
|
+
}
|
|
1052
|
+
const stAfterBlock = readScenarioState(dir);
|
|
1053
|
+
const reqsAfterBlock = stAfterBlock.evidence?.['subagent-execute']?.handoffRequests ?? {};
|
|
1054
|
+
if (reqsAfterBlock['P-M02']) {
|
|
1055
|
+
throw new Error('M-02 BLOCK 不得落 handoffRequests: ' + JSON.stringify(reqsAfterBlock));
|
|
1056
|
+
}
|
|
1057
|
+
// ② 旧 change 同构造 → 可见 WARN + 照常落库(AC-3 渐进兼容)
|
|
1058
|
+
writeState(dir, { ...baseState('execute'), enteredNodes: ['execute'] });
|
|
1059
|
+
const resOldChange = runHandoff(['request', 'P-M02', 'parallel fix slice'], dir, reqEnv);
|
|
1060
|
+
assertExit(resOldChange, 0);
|
|
1061
|
+
assertOut(resOldChange, 'WARN: 任务 P-M02(并行 pending)应归属节点 subagent-execute');
|
|
1062
|
+
assertOut(resOldChange, '旧 change 渐进不阻断');
|
|
1063
|
+
assertOut(resOldChange, 'HANDOFF REQUEST: P-M02');
|
|
1064
|
+
const stOldChange = readScenarioState(dir);
|
|
1065
|
+
if (!stOldChange.evidence?.['subagent-execute']?.handoffRequests?.['P-M02']) {
|
|
1066
|
+
throw new Error('旧 change 错误节点请求应照常落库(AC-3),实际 ' + JSON.stringify(stOldChange.evidence));
|
|
1067
|
+
}
|
|
1068
|
+
// ③ pending 并行任务依赖未满足 → 当前不可委托。恢复指引必须以 next 实际输出为准:
|
|
1069
|
+
// next 对依赖未满足的并行任务按串行消化输出 execute——指引不得再固定指向
|
|
1070
|
+
// entry subagent-execute(否则按指引进入会被 currentNode 门禁拦成死路)。
|
|
1071
|
+
writeIntakeArtifacts(dir);
|
|
1072
|
+
const unmetDepsTask =
|
|
1073
|
+
'<task id="S-M01" parallel="false" status="pending"><action>实现 S-M01</action><write_files>src/s-m01.mjs</write_files><verify>node --check src/s-m01.mjs</verify></task>\n' +
|
|
1074
|
+
'<task id="P-M03" parallel="true" status="pending"><action>实现 P-M03</action><write_files>src/p-m03.mjs</write_files><verify>node --check src/p-m03.mjs</verify><depends_on>S-M01</depends_on></task>\n';
|
|
1075
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + unmetDepsTask);
|
|
1076
|
+
const unmetState = baseState('execute');
|
|
1077
|
+
unmetState.newChange = true;
|
|
1078
|
+
unmetState.enteredNodes = ['execute'];
|
|
1079
|
+
unmetState.completedNodes = ['open', 'design', 'plan'];
|
|
1080
|
+
unmetState.evidence = { plan: { summary: 'plan done' } };
|
|
1081
|
+
writeState(dir, unmetState);
|
|
1082
|
+
const unmetBytesBefore = fs.readFileSync(reqStatePath, 'utf8');
|
|
1083
|
+
const resUnmet = runHandoff(['request', 'P-M03', 'parallel slice with unmet deps'], dir, reqEnv);
|
|
1084
|
+
assertExit(resUnmet, 1);
|
|
1085
|
+
assertOut(resUnmet, 'BLOCKED: 任务 P-M03(并行 pending)当前不可委托:依赖未满足');
|
|
1086
|
+
assertOut(resUnmet, '未完成: S-M01');
|
|
1087
|
+
assertOut(resUnmet, '原始 currentNode=execute');
|
|
1088
|
+
assertOut(resUnmet, 'workflow-state next');
|
|
1089
|
+
assertOut(resUnmet, '按输出的 NODE 进入');
|
|
1090
|
+
assertOut(resUnmet, '若输出 execute 表示依赖未满足');
|
|
1091
|
+
assertOut(resUnmet, '待任务变为可委托');
|
|
1092
|
+
// 不得固定指引 next 不会输出的节点(进入即死路的反锚)
|
|
1093
|
+
assertNotOut(resUnmet, 'entry subagent-execute');
|
|
1094
|
+
assertNotOut(resUnmet, 'HANDOFF REQUEST');
|
|
1095
|
+
if (fs.readFileSync(reqStatePath, 'utf8') !== unmetBytesBefore) {
|
|
1096
|
+
throw new Error('依赖未满足 BLOCK 必须 state 字节零改写');
|
|
1097
|
+
}
|
|
1098
|
+
const stUnmet = readScenarioState(dir);
|
|
1099
|
+
if (stUnmet.evidence?.['subagent-execute']?.handoffRequests?.['P-M03']) {
|
|
1100
|
+
throw new Error('依赖未满足 BLOCK 不得落 handoffRequests: ' + JSON.stringify(stUnmet.evidence));
|
|
1101
|
+
}
|
|
1102
|
+
// 同构真实链路:next 对当前 TASK 实际输出 execute(依赖未满足/串行消化),与指引条件分支一致
|
|
1103
|
+
const resUnmetNext = runStateWithProtocol(dir, ['next']);
|
|
1104
|
+
assertExit(resUnmetNext, 0);
|
|
1105
|
+
if (!/^NODE: execute$/m.test(resUnmetNext.output)) {
|
|
1106
|
+
throw new Error('依赖未满足时 next 应输出 execute(指引一致性锚):\n' + resUnmetNext.output);
|
|
1107
|
+
}
|
|
1108
|
+
if (readScenarioState(dir).currentNode !== 'execute') {
|
|
1109
|
+
throw new Error('依赖未满足时 next 应把工作归属留在 execute: ' + JSON.stringify(readScenarioState(dir).currentNode));
|
|
1110
|
+
}
|
|
1111
|
+
// 旧 change 同形态 → 可见 WARN + 照常落库(渐进兼容,不因依赖未满足而卡死)
|
|
1112
|
+
const oldUnmetState = { ...unmetState };
|
|
1113
|
+
delete oldUnmetState.newChange;
|
|
1114
|
+
writeState(dir, oldUnmetState);
|
|
1115
|
+
const resUnmetOld = runHandoff(['request', 'P-M03', 'old change unmet deps'], dir, reqEnv);
|
|
1116
|
+
assertExit(resUnmetOld, 0);
|
|
1117
|
+
assertOut(resUnmetOld, 'WARN: 任务 P-M03(并行 pending)当前不可委托:依赖未满足');
|
|
1118
|
+
assertOut(resUnmetOld, '旧 change 渐进不阻断');
|
|
1119
|
+
assertOut(resUnmetOld, 'HANDOFF REQUEST: P-M03');
|
|
1120
|
+
},
|
|
1121
|
+
},
|
|
1122
|
+
|
|
1123
|
+
// 129: R2——新 change 未 entry 直接 exit → BLOCKED(旧 change ENTER WARN 保留)
|
|
1124
|
+
{
|
|
1125
|
+
name: '129 execute exit BLOCKED:新 change 未 entry 直接 exit(R2)',
|
|
1126
|
+
run: (dir) => {
|
|
1127
|
+
const st = baseState('execute');
|
|
1128
|
+
st.evidence.execute = { summary: 'executed' };
|
|
1129
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
1130
|
+
st.newChange = true;
|
|
1131
|
+
writeState(dir, st);
|
|
1132
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
1133
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
1134
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
1135
|
+
assertExit(res, 1);
|
|
1136
|
+
assertOut(res, 'entry');
|
|
1137
|
+
},
|
|
1138
|
+
},
|
|
1139
|
+
|
|
1140
|
+
// 130: R6——init 写 newChange: true
|
|
1141
|
+
{
|
|
1142
|
+
name: '130 init 写入 newChange 标记(R6)',
|
|
1143
|
+
run: (dir) => {
|
|
1144
|
+
execFileSync('git', ['init', '-q'], { cwd: dir, stdio: 'ignore' });
|
|
1145
|
+
execFileSync('git', ['-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '--allow-empty', '-m', 'init'], { cwd: dir, stdio: 'ignore' });
|
|
1146
|
+
const res = runStateWithProtocol(dir, ['init', CHANGE_ID]);
|
|
1147
|
+
assertExit(res, 0);
|
|
1148
|
+
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1149
|
+
if (st.newChange !== true) throw new Error('init 未写入 newChange: true');
|
|
1150
|
+
},
|
|
1151
|
+
},
|
|
1152
|
+
|
|
1153
|
+
// 131: R1 旧兼容——旧 change(无 newChange)处置标记缺失仍 WARN;并内扩 Major 延期待裁决
|
|
1154
|
+
// 门禁旧 change 渐进面:无用户裁决 → WARN 不 BLOCK(不卡死旧 REVIEW);有裁决+[升级] → 放行。
|
|
1155
|
+
{
|
|
1156
|
+
name: '131 review exit 兼容:旧 change 处置标记缺失仍 WARN + Major 延期渐进(R1 旧兼容)',
|
|
1157
|
+
run: (dir) => {
|
|
1158
|
+
const st = baseState('review');
|
|
1159
|
+
st.evidence.review = { summary: 'reviewed' };
|
|
1160
|
+
writeState(dir, st); // 无 newChange(旧 change)
|
|
1161
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题A**: 某处存在一个需要记录的问题描述,但未给出任何处置结论\n\n## 结论\n\n通过\n');
|
|
1162
|
+
const res = runGuard(['exit', 'review'], dir);
|
|
1163
|
+
assertExit(res, 0);
|
|
1164
|
+
assertOut(res, 'WARN');
|
|
1165
|
+
// 子断言:Major [转待办] 无用户裁决 → 旧 change 渐进 WARN 且不 BLOCK(不卡死旧 REVIEW)
|
|
1166
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F1 · 未裁决的延期**:某处问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
1167
|
+
const resMajor = runGuard(['exit', 'review'], dir);
|
|
1168
|
+
assertExit(resMajor, 0);
|
|
1169
|
+
assertOut(resMajor, 'REVIEW WARN');
|
|
1170
|
+
assertOut(resMajor, 'Major');
|
|
1171
|
+
assertOut(resMajor, '用户裁决');
|
|
1172
|
+
assertNotOut(resMajor, 'BLOCKED');
|
|
1173
|
+
// 子断言:有同段用户裁决 + [升级] 承接 → 无该渐进告警
|
|
1174
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F2 · 已裁决的延期**:某处问题 [升级] [转待办](用户裁决:接受延期)\n\n## 结论\n\n通过\n');
|
|
1175
|
+
const resOk = runGuard(['exit', 'review'], dir);
|
|
1176
|
+
assertExit(resOk, 0);
|
|
1177
|
+
assertNotOut(resOk, '用户裁决');
|
|
1178
|
+
assertOut(resOk, 'ALL CHECKS PASSED');
|
|
1179
|
+
// 子断言:有序 Major [转待办] 无用户裁决 → 旧 change 渐进 WARN 不 BLOCK(有序同口径)
|
|
1180
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n1. **F3 · 有序未裁决的延期**:某处问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
1181
|
+
const resOrderedMajor = runGuard(['exit', 'review'], dir);
|
|
1182
|
+
assertExit(resOrderedMajor, 0);
|
|
1183
|
+
assertOut(resOrderedMajor, 'REVIEW WARN');
|
|
1184
|
+
assertOut(resOrderedMajor, '用户裁决');
|
|
1185
|
+
assertNotOut(resOrderedMajor, 'BLOCKED');
|
|
1186
|
+
},
|
|
1187
|
+
},
|
|
1188
|
+
|
|
1189
|
+
// 132: R3——exit 校验对 auto 声明标记输出 WARN 提示
|
|
1190
|
+
{
|
|
1191
|
+
name: '132 exit 对 auto 声明标记输出提示(R3)',
|
|
1192
|
+
run: (dir) => {
|
|
1193
|
+
// 技能加载前置门对齐:record 无声明标记在新 change 下 BLOCK——本场景测 exit 的
|
|
1194
|
+
// auto 标记提示,改用旧 change(无 newChange)构造,保留 record 通过 + exit auto 提示
|
|
1195
|
+
// 的测试意图(新 change 无声明记录由前置门场景覆盖)。
|
|
1196
|
+
const st = baseState('open');
|
|
1197
|
+
writeState(dir, st);
|
|
1198
|
+
assertExit(runGuard(['entry', 'open'], dir), 0);
|
|
1199
|
+
assertExit(runStateWithProtocol(dir, ['record', 'open', '{"summary":"intake"}']), 0);
|
|
1200
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why(为什么做)\nx');
|
|
1201
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\nx\n\n## 验收准则(AC)\n- Given x When y Then z');
|
|
1202
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
|
|
1203
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
|
|
1204
|
+
JSON.stringify({ node: 'open', skill: 'flow-comet-change', protocol: '0-change.md', at: '2026-08-01T00:00:00.000Z', auto: true }, null, 2) + '\n');
|
|
1205
|
+
const res = runGuard(['exit', 'open'], dir);
|
|
1206
|
+
assertExit(res, 0);
|
|
1207
|
+
assertOut(res, 'auto');
|
|
1208
|
+
},
|
|
1209
|
+
},
|
|
1210
|
+
|
|
1211
|
+
// 133: R4——空退出豁免 exit 输出审计提示
|
|
1212
|
+
{
|
|
1213
|
+
name: '133 execute exit 空退出豁免输出审计提示(R4)',
|
|
1214
|
+
run: (dir) => {
|
|
1215
|
+
const st = baseState('execute');
|
|
1216
|
+
st.evidence.execute = { summary: 'empty', emptyExitApproved: true };
|
|
1217
|
+
st.newChange = true;
|
|
1218
|
+
writeState(dir, st);
|
|
1219
|
+
assertExit(runGuard(['entry', 'execute'], dir), 0);
|
|
1220
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n<task id="P01" parallel="true" status="pending"><action>p</action><write_files>a</write_files><verify>t</verify><done>d</done></task>\n');
|
|
1221
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
1222
|
+
assertExit(res, 0);
|
|
1223
|
+
assertOut(res, 'EMPTY-EXIT');
|
|
1224
|
+
},
|
|
1225
|
+
},
|
|
1226
|
+
|
|
1227
|
+
// 134: G16——M2 BLOCKED 消息含恢复指引
|
|
1228
|
+
{
|
|
1229
|
+
name: '134 execute exit BLOCKED 消息含恢复指引(G16)',
|
|
1230
|
+
run: (dir) => {
|
|
1231
|
+
const st = baseState('execute');
|
|
1232
|
+
st.evidence.execute = { summary: 'executed' };
|
|
1233
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'T02']) };
|
|
1234
|
+
st.newChange = true;
|
|
1235
|
+
writeState(dir, st);
|
|
1236
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE_TWO);
|
|
1237
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent());
|
|
1238
|
+
const res = runGuard(['exit', 'execute'], dir); // T02 缺 SUMMARY
|
|
1239
|
+
assertExit(res, 1);
|
|
1240
|
+
assertOut(res, '恢复:');
|
|
1241
|
+
},
|
|
1242
|
+
},
|
|
1243
|
+
|
|
1244
|
+
// 135: R1 旧格式兼容分支——自检方法段含 brooks-review 声明但缺 `## 自检方法` 段标题(旧格式形态):
|
|
1245
|
+
// 新 change 全文声明方法但缺段标题 → BLOCKED(强制自检方法段,transition 规则 L2454-2455);
|
|
1246
|
+
// 旧 change 同构造 → BROOKS-LINT WARN 渐进(兼容保留,L2457)
|
|
1247
|
+
{
|
|
1248
|
+
name: '135 execute exit BLOCKED:新 change 自检方法段缺标题(R1 旧格式兼容分支)',
|
|
1249
|
+
run: (dir) => {
|
|
1250
|
+
// ① 新 change(newChange:true):T01-SUMMARY 含 brooks-review 声明(6 维自查+方法行)但缺
|
|
1251
|
+
// `## 自检方法` 段标题(旧格式) → BLOCKED(自检方法段强制;恢复:补 ## 自检方法 段标题)
|
|
1252
|
+
const st = baseState('execute');
|
|
1253
|
+
st.evidence.execute = { summary: 'executed' };
|
|
1254
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
1255
|
+
st.newChange = true;
|
|
1256
|
+
writeState(dir, st);
|
|
1257
|
+
assertExit(runGuard(['entry', 'execute'], dir), 0); // R2: 新 change 须先 entry
|
|
1258
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
1259
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent({ method: 'brooks-review' }));
|
|
1260
|
+
const res = runGuard(['exit', 'execute'], dir);
|
|
1261
|
+
assertExit(res, 1);
|
|
1262
|
+
assertOut(res, '自检方法');
|
|
1263
|
+
// ② 旧 change(无 newChange)同构造 → BROOKS-LINT WARN 渐进(兼容保留,不阻断)
|
|
1264
|
+
const stOld = baseState('execute');
|
|
1265
|
+
stOld.evidence.execute = { summary: 'executed' };
|
|
1266
|
+
stOld.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
1267
|
+
writeState(dir, stOld);
|
|
1268
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent({ method: 'brooks-review' }));
|
|
1269
|
+
const resOld = runGuard(['exit', 'execute'], dir);
|
|
1270
|
+
assertExit(resOld, 0);
|
|
1271
|
+
assertOut(resOld, 'BROOKS-LINT WARN');
|
|
1272
|
+
},
|
|
1273
|
+
},
|
|
1274
|
+
|
|
1275
|
+
// 136: verifyFailures 按 change 隔离——切换 change 后计数独立(串扰修复:全局计数会让
|
|
1276
|
+
// change B 继承 change A 的失败次数,误触发"超限需用户决策");旧顶层字段
|
|
1277
|
+
// (verifyFailures)迁移并入当前 change 计数(旧 state 兼容)
|
|
1278
|
+
{
|
|
1279
|
+
name: '136 verifyFailures 按 change 隔离:切换计数独立 + 旧字段迁移',
|
|
1280
|
+
run: (dir) => {
|
|
1281
|
+
// ① 旧字段迁移:旧 state(顶层 verifyFailures=2)→ verify-fail 并入当前 change(2+1=3)不超限
|
|
1282
|
+
const st = baseState('verify');
|
|
1283
|
+
st.verifyFailures = 2;
|
|
1284
|
+
writeState(dir, st);
|
|
1285
|
+
// 场景内 ch/ch2 目录(select 要求 change 目录存在)
|
|
1286
|
+
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
1287
|
+
const r1 = runStateWithProtocol(dir, ['verify-fail']);
|
|
1288
|
+
assertExit(r1, 0);
|
|
1289
|
+
assertOut(r1, 'VERIFY-FAIL: 3/3');
|
|
1290
|
+
const stAfter = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1291
|
+
if (!stAfter.verifyFailuresByChange || stAfter.verifyFailuresByChange['ch'] !== 3) {
|
|
1292
|
+
throw new Error('旧字段未迁移并入 change 计数: ' + JSON.stringify(stAfter.verifyFailuresByChange));
|
|
1293
|
+
}
|
|
1294
|
+
if (stAfter.verifyFailures !== undefined) {
|
|
1295
|
+
throw new Error('旧顶层字段应已清除: ' + JSON.stringify(stAfter.verifyFailures));
|
|
1296
|
+
}
|
|
1297
|
+
// ② 同 change 第 4 次 → BLOCK(3 >= 3)
|
|
1298
|
+
const r2 = runStateWithProtocol(dir, ['verify-fail']);
|
|
1299
|
+
assertExit(r2, 1);
|
|
1300
|
+
assertOut(r2, '超限');
|
|
1301
|
+
// ③ 切换 change:select ch2 → 计数独立(若实现仍用全局计数 3,此处会误 BLOCK = RED)
|
|
1302
|
+
writeFile(dir, '.specs/ch2/CHANGE.md', '# CHANGE\n## Why\nx\n');
|
|
1303
|
+
const r3 = runStateWithProtocol(dir, ['select', 'ch2']);
|
|
1304
|
+
assertExit(r3, 0);
|
|
1305
|
+
const r4 = runStateWithProtocol(dir, ['verify-fail']);
|
|
1306
|
+
assertExit(r4, 0);
|
|
1307
|
+
assertOut(r4, 'VERIFY-FAIL: 1/3');
|
|
1308
|
+
// ④ ch2 独立计数:连续 3 次后第 4 次 BLOCK
|
|
1309
|
+
assertExit(runStateWithProtocol(dir, ['verify-fail']), 0);
|
|
1310
|
+
assertExit(runStateWithProtocol(dir, ['verify-fail']), 0);
|
|
1311
|
+
const r7 = runStateWithProtocol(dir, ['verify-fail']);
|
|
1312
|
+
assertExit(r7, 1);
|
|
1313
|
+
assertOut(r7, '超限');
|
|
1314
|
+
// ⑤ 切回 ch:原计数保留(3 → 仍超限,不串扰不回零)
|
|
1315
|
+
const r8 = runStateWithProtocol(dir, ['select', 'ch']);
|
|
1316
|
+
assertExit(r8, 0);
|
|
1317
|
+
const r9 = runStateWithProtocol(dir, ['verify-fail']);
|
|
1318
|
+
assertExit(r9, 1);
|
|
1319
|
+
assertOut(r9, '超限');
|
|
1320
|
+
// ⑥ 计数隔离扩展(AC-5):verify 失败计数与 Fix 归位轮次各自独立——verify-fail 只动
|
|
1321
|
+
// verifyFailuresByChange,绝不触碰 fixRoundsByChange(旧实现只读 verify 计数已通过;
|
|
1322
|
+
// 若未来把二者混用 / 共用容器,本条按 change 逐项断言变红)。
|
|
1323
|
+
const stIsolated = readScenarioState(dir);
|
|
1324
|
+
stIsolated.fixRoundsByChange = { ch: 2, ch2: 1 };
|
|
1325
|
+
writeState(dir, stIsolated);
|
|
1326
|
+
writeFile(dir, '.specs/ch3/CHANGE.md', '# CHANGE\n## Why\nx\n');
|
|
1327
|
+
assertExit(runStateWithProtocol(dir, ['select', 'ch3']), 0);
|
|
1328
|
+
const stCh3Before = readScenarioState(dir);
|
|
1329
|
+
stCh3Before.fixRoundsByChange = { ch: 2, ch2: 1, ch3: 5 };
|
|
1330
|
+
writeState(dir, stCh3Before);
|
|
1331
|
+
const r10 = runStateWithProtocol(dir, ['verify-fail']);
|
|
1332
|
+
assertExit(r10, 0);
|
|
1333
|
+
assertOut(r10, 'VERIFY-FAIL: 1/3');
|
|
1334
|
+
const stCh3After = readScenarioState(dir);
|
|
1335
|
+
if (stCh3After.verifyFailuresByChange?.ch3 !== 1) {
|
|
1336
|
+
throw new Error('verify-fail 应按 change 递增 verify 计数,实际 '
|
|
1337
|
+
+ JSON.stringify(stCh3After.verifyFailuresByChange));
|
|
1338
|
+
}
|
|
1339
|
+
if (JSON.stringify(stCh3After.fixRoundsByChange) !== JSON.stringify({ ch: 2, ch2: 1, ch3: 5 })) {
|
|
1340
|
+
throw new Error('verify 失败计数与 Fix 轮次计数不得串扰(fixRoundsByChange 被改写): '
|
|
1341
|
+
+ JSON.stringify(stCh3After.fixRoundsByChange));
|
|
1342
|
+
}
|
|
1343
|
+
},
|
|
1344
|
+
},
|
|
1345
|
+
|
|
1346
|
+
// 137: next 漂移校正不得推走"已记录证据但未 exit"的进行中节点——exit 被拦截(如
|
|
1347
|
+
// 内容级 BLOCKED)后执行者跑 next,校正把 currentNode 推到下一节点,被拦截节点无法
|
|
1348
|
+
// 重跑(exit 前置 currentNode 校验拦截),advance/select 均不恢复 → 死结(实测教训)。
|
|
1349
|
+
// 修复:evidence 存在且节点未 exit → 视为进行中,next 不校正(currentNode 保持原节点)
|
|
1350
|
+
{
|
|
1351
|
+
name: '137 next 不推走进行中节点:exit 被拦截后重跑路径保留',
|
|
1352
|
+
run: (dir) => {
|
|
1353
|
+
const st = baseState('review');
|
|
1354
|
+
st.completedNodes = ['open', 'design', 'plan', 'execute', 'subagent-execute'];
|
|
1355
|
+
st.evidence.review = { summary: 'reviewed' }; // record 过但 exit 被拦截
|
|
1356
|
+
st.newChange = true;
|
|
1357
|
+
writeState(dir, st);
|
|
1358
|
+
// 前序产物(execute 产物门控需 *-SUMMARY.md)
|
|
1359
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why(为什么做)\nx');
|
|
1360
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\nx\n\n## 验收准则(AC)\n- Given x When y Then z');
|
|
1361
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/DESIGN.md', '# DESIGN\n\n## 0. 技术栈\npython\n\n## 决策清单\n- d1: x\n');
|
|
1362
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n<task id="T01" status="done"><action>x</action><write_files>f</write_files><verify>v</verify></task>\n');
|
|
1363
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', '# T01-SUMMARY\n## verify 输出\nx\n## 6 维自查\nx\n## 越界检查\nx\n');
|
|
1364
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题A**: 某处问题 **[已修]**\n\n## 结论\n\n通过\n');
|
|
1365
|
+
// ① next:进行中节点(evidence 存在且未 exit)不被漂移校正推走(修复前校正到 verify = RED)
|
|
1366
|
+
const r1 = runStateWithProtocol(dir, ['next']);
|
|
1367
|
+
assertExit(r1, 0);
|
|
1368
|
+
assertOut(r1, 'NODE: review');
|
|
1369
|
+
assertNotOut(r1, 'NODE: verify');
|
|
1370
|
+
// ② exit review 重跑路径保留:缺处置标记 → BLOCKED(新 change),补标记后通过
|
|
1371
|
+
assertExit(runGuardWithProtocol(dir, ['entry', 'review']), 0); // 新 change 强制先 entry
|
|
1372
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题B**: 某处问题无处置标记\n\n## 结论\n\n通过\n');
|
|
1373
|
+
const rBlock = runGuardWithProtocol(dir, ['exit', 'review']);
|
|
1374
|
+
assertExit(rBlock, 1);
|
|
1375
|
+
assertOut(rBlock, '处置状态标记');
|
|
1376
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题B**: 某处问题 **[已修]**\n\n## 结论\n\n通过\n');
|
|
1377
|
+
const rPass = runGuardWithProtocol(dir, ['exit', 'review', '--apply']);
|
|
1378
|
+
assertExit(rPass, 0);
|
|
1379
|
+
assertOut(rPass, 'ALL CHECKS PASSED');
|
|
1380
|
+
},
|
|
1381
|
+
},
|
|
1382
|
+
];
|