flow-comet 1.6.5 → 1.8.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
- package/.flow-comet/skills/flow-comet/SKILL.md +32 -18
- package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +2 -2
- package/.flow-comet/skills/flow-comet/reference/decision-points.md +5 -5
- package/.flow-comet/skills/flow-comet/reference/dirty-worktree.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/entry-detail.md +30 -11
- package/.flow-comet/skills/flow-comet/reference/fix-loop.md +4 -4
- package/.flow-comet/skills/flow-comet/reference/init-detection.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/platform-facts.md +2 -2
- package/.flow-comet/skills/flow-comet/reference/post-archive-handoff.md +264 -0
- package/.flow-comet/skills/flow-comet/reference/recovery.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/replan.md +1 -1
- package/.flow-comet/skills/flow-comet/scripts/comet-check.mjs +1 -0
- package/.flow-comet/skills/flow-comet/scripts/comet-hook-guard.mjs +270 -30
- package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +26 -23
- package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +14 -94
- package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +122 -11
- package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +79 -40
- package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +11 -9
- package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +52 -10
- package/.flow-comet/skills/flow-comet/scripts/items/f.mjs +1 -1
- package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +128 -56
- package/.flow-comet/skills/flow-comet/scripts/items/k.mjs +357 -3
- package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +26 -1
- package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +6 -2
- package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +29 -21
- package/.flow-comet/skills/flow-comet/scripts/lib/ac-coverage.mjs +317 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/fix-loop-node.mjs +4 -15
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-artifact-skeleton.mjs +47 -5
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +357 -219
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +725 -309
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +182 -54
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +8 -6
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +224 -83
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +17 -28
- package/.flow-comet/skills/flow-comet/scripts/lib/lessons-hits.mjs +160 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/run-root.mjs +21 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/section-body.mjs +92 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +61 -33
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +663 -205
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +68 -9
- package/.flow-comet/skills/flow-comet/scripts/lib/state-determine.mjs +11 -4
- package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +92 -13
- package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +232 -11
- package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +140 -74
- package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +8 -4
- package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +84 -31
- package/.flow-comet/skills/flow-comet/scripts/lib/test-assertions.mjs +0 -3
- package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +248 -24
- package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +63 -3
- package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +181 -8
- package/.flow-comet/skills/flow-comet/scripts/lib/wave-projection.mjs +340 -0
- package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +132 -20
- package/.flow-comet/skills/flow-comet/scripts/route-node.mjs +12 -5
- package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +1564 -54
- package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1489 -38
- package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1466 -243
- package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +743 -24
- package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +220 -92
- package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +657 -21
- package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +41 -27
- package/.flow-comet/skills/flow-comet/scripts/scenarios/h.mjs +285 -9
- package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +7 -6
- package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +21 -15
- package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +8 -5
- package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +45 -36
- package/.flow-comet/skills/flow-comet/scripts/scenarios/m.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +2381 -85
- package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +135 -2
- package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +143 -16
- package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +339 -103
- package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +5 -2
- package/.flow-comet/skills/flow-comet-archive/SKILL.md +33 -11
- package/.flow-comet/skills/flow-comet-change/SKILL.md +1 -1
- package/.flow-comet/skills/flow-comet-design/SKILL.md +5 -3
- package/.flow-comet/skills/flow-comet-dev/SKILL.md +2 -2
- package/.flow-comet/skills/flow-comet-execute/SKILL.md +37 -13
- package/.flow-comet/skills/flow-comet-integration/SKILL.md +10 -4
- package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +1 -1
- package/.flow-comet/skills/flow-comet-plan/SKILL.md +13 -6
- package/.flow-comet/skills/flow-comet-review/SKILL.md +21 -12
- package/.flow-comet/skills/flow-comet-subagent-execute/GUIDANCE.md +1 -1
- package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +43 -18
- package/.flow-comet/skills/flow-comet-task/SKILL.md +4 -2
- package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +2 -2
- package/.flow-comet/skills/flow-comet-verify/SKILL.md +1 -1
- package/README.md +2 -2
- package/package.json +1 -1
- package/scripts/dsh-bridge.mjs +238 -21
|
@@ -11,24 +11,34 @@ import {
|
|
|
11
11
|
assertOut,
|
|
12
12
|
assertTrue,
|
|
13
13
|
baseState,
|
|
14
|
+
cleanupTmpDir,
|
|
15
|
+
installSkillTreeCopy,
|
|
14
16
|
runGuard,
|
|
15
17
|
runHandoff,
|
|
18
|
+
runPrintedCommand,
|
|
16
19
|
runState,
|
|
17
20
|
writeFile,
|
|
18
21
|
writeState,
|
|
19
22
|
} from '../lib/test-helpers.mjs';
|
|
20
23
|
import {
|
|
24
|
+
BUILTIN_PROTOCOL_SOURCE,
|
|
21
25
|
CHANGE_ID,
|
|
26
|
+
customProtocolWithSkillCall,
|
|
27
|
+
handoffFor,
|
|
28
|
+
intakeChangeText,
|
|
29
|
+
intakeRequirementText,
|
|
30
|
+
makeTmp,
|
|
31
|
+
REPO_ROOT,
|
|
22
32
|
SCRIPTS_DIR,
|
|
33
|
+
strictSummary,
|
|
34
|
+
summaryContent,
|
|
23
35
|
TASK_DONE,
|
|
24
36
|
TASK_DONE_TWO,
|
|
25
37
|
TASK_P1,
|
|
26
|
-
|
|
27
|
-
handoffFor,
|
|
28
|
-
isAuthoritativeSourceRepo,
|
|
29
|
-
summaryContent,
|
|
38
|
+
writeAllNodeDeclarationMarkers,
|
|
30
39
|
writeCustomProtocol,
|
|
31
40
|
writeIntakeArtifacts,
|
|
41
|
+
writeNodeDeclarationMarkers,
|
|
32
42
|
} from '../lib/test-fixtures.mjs';
|
|
33
43
|
import {
|
|
34
44
|
assertOutMatches,
|
|
@@ -38,27 +48,714 @@ import {
|
|
|
38
48
|
scenarioProtocolPath,
|
|
39
49
|
} from '../lib/test-assertions.mjs';
|
|
40
50
|
import {
|
|
51
|
+
PUBLIC_FACE_DOCS_DIR,
|
|
52
|
+
PUBLIC_FACE_SELF_CHECK_SKIP_NOTICE,
|
|
53
|
+
VISUAL_TONE_APPLICABLE,
|
|
54
|
+
authoritativeSourceAt,
|
|
41
55
|
countSyncProblems,
|
|
56
|
+
publicFaceDocsAbsent,
|
|
57
|
+
writeDesignExitFixture,
|
|
42
58
|
} from '../lib/text-anchor-checks.mjs';
|
|
43
59
|
|
|
60
|
+
// ---------- 公开面的机器状态字段名口径 + 命令锚(机检;判据与反向构造共用本实现) ----------
|
|
61
|
+
// 规则:公开说明面不直写机器状态字段名——引擎在状态文件里拥有的键要么改述为行为描述,要么放进
|
|
62
|
+
// **明确标注**的状态输出示例围栏块(白名单)。判据是「键名黑名单 + 示例块白名单」而非精确句锁:
|
|
63
|
+
// 改述措辞可以自由演化,键名不能重新走私进正文。routeNode 属公开输出契约名,不在黑名单内。
|
|
64
|
+
// 受检面不手抄:从 docs/authority-map.json(公开文档权威与姊妹文档的唯一声明处)取 authority/twin
|
|
65
|
+
// 两侧,再并上根目录文档与 docs/examples 的目录扫描——新增公开文档只要登记进映射、或按惯例落在
|
|
66
|
+
// 根目录,字段名扫描与命令锚两处判据同时覆盖,不会出现「加进一个清单、漏掉另一个」的静默窄化。
|
|
67
|
+
// 两类结构性排除(都不是行为描述面):① 变更日志——按时间的历史记录,条目引用当时发布的措辞与
|
|
68
|
+
// 当时的机器字段名;② 根目录的代理指令文件——本地工作说明,不面向用户、不随包分发。
|
|
69
|
+
const PUBLIC_FACE_AUTHORITY_MAP = 'docs/authority-map.json';
|
|
70
|
+
const PUBLIC_FACE_EXAMPLES_DIR = 'docs/examples';
|
|
71
|
+
const PUBLIC_FACE_HISTORY_DOCS = ['CHANGELOG.md', 'CHANGELOG-zh.md'];
|
|
72
|
+
const PUBLIC_FACE_AGENT_DOCS = ['AGENTS.md', 'CLAUDE.md'];
|
|
73
|
+
// 示例块白名单的标记词:围栏 info string,或围栏之上紧邻的最后一行非空正文(标题 / 说明)写明
|
|
74
|
+
// 这是状态输出示例——只有明说「这是示例数据」才放行,普通代码块不因此获得豁免。
|
|
75
|
+
const PUBLIC_FACE_EXAMPLE_MARKERS = ['状态输出示例', 'state output example', 'status output example'];
|
|
76
|
+
// 机器状态字段黑名单 = 引擎在状态文件里拥有、**绝不由人写**的键(state-schema 的机器自有字段)。
|
|
77
|
+
// 名单不按「今天文档里写了什么」取,而按「状态文件里真的有什么」取:这些键一旦被公开面当成用户
|
|
78
|
+
// 面契约直写,读者就会以为可以手改它们。新增机器字段时在这里登记,判据才跟着扩展。
|
|
79
|
+
// 驼峰键名在英文 / 中文散文里都不会自然出现,故任何位置命中都算直写(不必依赖反引号)。
|
|
80
|
+
const PUBLIC_FACE_STATE_FIELDS = [
|
|
81
|
+
'currentNode', 'stateCurrentNode',
|
|
82
|
+
'completedNodes', 'enteredNodes', 'directOverride', 'newChange',
|
|
83
|
+
// verifyFailures 用前缀匹配覆盖同族的 verifyFailuresByChange(见 fieldNameHitsOnLine)
|
|
84
|
+
'verifyFailures',
|
|
85
|
+
];
|
|
86
|
+
// evidence 另有散文形态(见 EVIDENCE_FIELD_FRAME_RE 与 fieldNameHitsOnLine 的放行规则)。
|
|
87
|
+
// 结构预检命令的公开面锚:三份文档 × 中英都必须在案。新增公开命令不得没有锚——否则删掉或漏写
|
|
88
|
+
// 其中任何一份,套件仍然全绿,公开面就真的丢了这条命令。这里只选主题名,路径仍从映射取——「哪份
|
|
89
|
+
// 文档承载命令说明」因此也只在映射里声明一次。
|
|
90
|
+
const PUBLIC_FACE_PREFLIGHT_TOPICS = ['behaviour', 'workflow', 'troubleshooting'];
|
|
91
|
+
const PREFLIGHT_FLAG = '--preflight';
|
|
92
|
+
|
|
93
|
+
function listMarkdownFiles(absDir, relDir) {
|
|
94
|
+
const out = [];
|
|
95
|
+
for (const entry of fs.readdirSync(absDir, { withFileTypes: true })) {
|
|
96
|
+
const rel = relDir + '/' + entry.name;
|
|
97
|
+
if (entry.isDirectory()) out.push(...listMarkdownFiles(path.join(absDir, entry.name), rel));
|
|
98
|
+
else if (entry.name.endsWith('.md')) out.push(rel);
|
|
99
|
+
}
|
|
100
|
+
return out;
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
// 形态判据(公开面能不能派生):先问「这份检出有没有公开文档面」,再谈派生——npm 包按 package.json
|
|
104
|
+
// 的 files 白名单只分发 .flow-comet/skills 与 rules,不含 docs/、CONTRIBUTING.md 与 .github/;安装
|
|
105
|
+
// 副本同理。这种形态下「受检面无法派生」不是缺文件事故,而是载体的**正常形态**,说成「仓库缺文件」
|
|
106
|
+
// 会把读者引到修复一个不存在的缺陷上。判据落点选**这三份公开面载体是否俱缺**,而不是权威映射文件
|
|
107
|
+
// 在不在:只看 docs/ 不够——分支 / 稀疏检出 / 误删把 docs/ 整份拿掉时,「本载体不含公开面」变成假话,
|
|
108
|
+
// 计数一致性 / 零代号 / 词表镜像会整块跳过;docs/ 在、映射缺 = 检出被裁坏,仍要在读取处显式失败
|
|
109
|
+
// (判据强度不降——跳过通道只对「整份公开面不存在」开放)。
|
|
110
|
+
// 形态判据与其跳过提示**从 lib 共用**(底部自检的公开面自检用同一对):同一种形态在两处各判一次,
|
|
111
|
+
// 两份实现迟早各说各话——一处把包形态说成「缺文件」、另一处说成「跳过」,正是本批修掉的误诊。
|
|
112
|
+
// 判据落点与措辞只在 lib/text-anchor-checks.mjs 维护(PUBLIC_FACE_DOCS_DIR / publicFaceDocsAbsent /
|
|
113
|
+
// PUBLIC_FACE_SELF_CHECK_SKIP_NOTICE)。
|
|
114
|
+
|
|
115
|
+
// 权威映射缺席或不可解析 = 受检面无从派生(不是「没有东西要查」):显式失败,不静默退化。
|
|
116
|
+
// root 可覆盖读取根(默认仓库根)——仅为可测性接缝:形态判据的探针要在夹具目录上验证「docs/ 在、
|
|
117
|
+
// 映射缺仍显式失败」,生产调用不传。
|
|
118
|
+
function readPublicFaceAuthorityMap(root = REPO_ROOT) {
|
|
119
|
+
const abs = path.join(root, ...PUBLIC_FACE_AUTHORITY_MAP.split('/'));
|
|
120
|
+
if (!fs.existsSync(abs)) {
|
|
121
|
+
throw new Error('受检面无法派生:' + PUBLIC_FACE_AUTHORITY_MAP
|
|
122
|
+
+ ' 不在本检出(公开文档权威映射是受检面的唯一来源)');
|
|
123
|
+
}
|
|
124
|
+
const parsed = JSON.parse(fs.readFileSync(abs, 'utf8'));
|
|
125
|
+
if (!parsed || typeof parsed !== 'object' || !parsed.topics || typeof parsed.topics !== 'object') {
|
|
126
|
+
throw new Error('受检面无法派生:' + PUBLIC_FACE_AUTHORITY_MAP + ' 缺 topics 对象');
|
|
127
|
+
}
|
|
128
|
+
return parsed;
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
// 映射的每个主题 → [authority, twin](twin 为 null 的主题只登记权威侧)。
|
|
132
|
+
// 畸形或空主题一律抛错而不是跳过:跳过等于把该主题的文档静默移出受检面——字段名黑名单与命令锚
|
|
133
|
+
// 都不再落到它们身上,而套件依然全绿。主题写坏是可判定的失配,就该是一次显式失败。
|
|
134
|
+
function publicFaceTopicPairs(map) {
|
|
135
|
+
const pairs = new Map();
|
|
136
|
+
for (const [topic, spec] of Object.entries(map.topics)) {
|
|
137
|
+
if (!spec || typeof spec !== 'object' || Array.isArray(spec)) {
|
|
138
|
+
throw new Error('受检面无法派生:' + PUBLIC_FACE_AUTHORITY_MAP + ' 的主题 ' + topic + ' 不是对象');
|
|
139
|
+
}
|
|
140
|
+
const pair = [spec.authority, spec.twin].filter((rel) => typeof rel === 'string' && rel.trim() !== '');
|
|
141
|
+
if (pair.length === 0) {
|
|
142
|
+
throw new Error('受检面无法派生:' + PUBLIC_FACE_AUTHORITY_MAP + ' 的主题 ' + topic
|
|
143
|
+
+ ' 未登记任何文档路径(authority 与 twin 都为空)');
|
|
144
|
+
}
|
|
145
|
+
pairs.set(topic, pair);
|
|
146
|
+
}
|
|
147
|
+
return pairs;
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
// 受检文档集合 = 映射两侧 ∪ 根目录文档,再减去上面两类排除面。根目录扫描是必要的:按 GitHub 惯例
|
|
151
|
+
// 放在根目录的公开文件里有整份未登记进映射的(CODE_OF_CONDUCT 及其双语版、SECURITY-zh.md),
|
|
152
|
+
// 只靠映射会静默漏掉它们。
|
|
153
|
+
function publicFaceDocPaths(map) {
|
|
154
|
+
const paths = new Set();
|
|
155
|
+
for (const pair of publicFaceTopicPairs(map).values()) for (const rel of pair) paths.add(rel);
|
|
156
|
+
for (const entry of fs.readdirSync(REPO_ROOT, { withFileTypes: true })) {
|
|
157
|
+
if (entry.isFile() && entry.name.endsWith('.md')) paths.add(entry.name);
|
|
158
|
+
}
|
|
159
|
+
for (const rel of [...PUBLIC_FACE_HISTORY_DOCS, ...PUBLIC_FACE_AGENT_DOCS]) paths.delete(rel);
|
|
160
|
+
return [...paths].sort();
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
// 命令锚所在的文档:按主题名从映射取(路径不在此手抄)。
|
|
164
|
+
// 主题名取不到即抛错:空集会把锚的受检文档集清空,于是命令锚被整段删掉也不红——「新增公开命令
|
|
165
|
+
// 不得无锚」这条判据要防的正是这种静默窄化,主题改名或写错必须显式失败。
|
|
166
|
+
function publicFacePreflightDocs(map) {
|
|
167
|
+
const pairs = publicFaceTopicPairs(map);
|
|
168
|
+
const docs = [];
|
|
169
|
+
for (const topic of PUBLIC_FACE_PREFLIGHT_TOPICS) {
|
|
170
|
+
const pair = pairs.get(topic);
|
|
171
|
+
if (!pair) {
|
|
172
|
+
throw new Error('受检面无法派生:' + PUBLIC_FACE_AUTHORITY_MAP + ' 未登记主题 ' + topic
|
|
173
|
+
+ '(命令锚文档按主题名派生;主题改名时须同步本判据,不得让锚随主题一起消失)');
|
|
174
|
+
}
|
|
175
|
+
docs.push(...pair);
|
|
176
|
+
}
|
|
177
|
+
return docs;
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
// 受检快照 { texts, preflightDocs },文本按 Map 组织(rel → 文本或 null):判据只读这一份快照,
|
|
181
|
+
// 反向构造在副本上作业。
|
|
182
|
+
function readPublicFaceTexts() {
|
|
183
|
+
const map = readPublicFaceAuthorityMap();
|
|
184
|
+
const texts = new Map();
|
|
185
|
+
for (const rel of publicFaceDocPaths(map)) {
|
|
186
|
+
const abs = path.join(REPO_ROOT, ...rel.split('/'));
|
|
187
|
+
texts.set(rel, fs.existsSync(abs) ? fs.readFileSync(abs, 'utf8') : null);
|
|
188
|
+
}
|
|
189
|
+
const examplesRoot = path.join(REPO_ROOT, ...PUBLIC_FACE_EXAMPLES_DIR.split('/'));
|
|
190
|
+
if (!fs.existsSync(examplesRoot)) {
|
|
191
|
+
// 整面缺席显式报告:静默等于把「本检出没有示例面」当成「示例面已校验」。
|
|
192
|
+
texts.set(PUBLIC_FACE_EXAMPLES_DIR + '/**/*.md', null);
|
|
193
|
+
} else {
|
|
194
|
+
for (const rel of listMarkdownFiles(examplesRoot, PUBLIC_FACE_EXAMPLES_DIR)) {
|
|
195
|
+
texts.set(rel, fs.readFileSync(path.join(REPO_ROOT, ...rel.split('/')), 'utf8'));
|
|
196
|
+
}
|
|
197
|
+
}
|
|
198
|
+
return { texts, preflightDocs: publicFacePreflightDocs(map) };
|
|
199
|
+
}
|
|
200
|
+
|
|
201
|
+
function isStatusExampleMarker(line) {
|
|
202
|
+
const lowered = line.toLowerCase();
|
|
203
|
+
return PUBLIC_FACE_EXAMPLE_MARKERS.some((marker) => lowered.includes(marker.toLowerCase()));
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
// 报错要能直接照做:先点名键名与改述方向,再给出唯一的合法展示出口(标注为状态输出示例的
|
|
207
|
+
// 围栏块)——否则作者只知道「不能写」,不知道「要展示时该怎么写」。
|
|
208
|
+
function fieldNameViolation(where, fieldName) {
|
|
209
|
+
return where + ' 直写了机器状态字段名 ' + fieldName
|
|
210
|
+
+ '(改述为行为描述;确需展示状态输出时,放进标注为「状态输出示例」的围栏块)';
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
// 「指名某个字段」的散文框:the `evidence` field / the evidence field / evidence 字段。**单数**才
|
|
214
|
+
// 构成指名——复数的 "the evidence fields" 是集合描述(公开面本就有这类句子:the output schemas,
|
|
215
|
+
// the gates, the commands, the evidence fields),不指名任何键。
|
|
216
|
+
const EVIDENCE_FIELD_FRAME_RE = /(?<![A-Za-z0-9_$])`?evidence`?\s+(?:field|字段)(?![A-Za-z0-9_$])/;
|
|
217
|
+
|
|
218
|
+
// 键名判据:驼峰键名任何位置命中都算直写(散文里不会自然出现,不必依赖反引号);evidence 是普通
|
|
219
|
+
// 英文名词与状态键同形,只在**被当成字段名写**时算违规:
|
|
220
|
+
// ① 独立成键名的反引号段 `evidence`;
|
|
221
|
+
// ② 指名它的散文框(EVIDENCE_FIELD_FRAME_RE,带不带反引号都命中);
|
|
222
|
+
// ③ 裸属性后缀 `.evidence`(单独写成字段路径)。
|
|
223
|
+
// 放行规则(两类都不是「行为描述面」,故不构成字段名直写):
|
|
224
|
+
// ① **代码位置引用**:state.evidence 这类带宿主标识符的属性访问说的是「去哪看」,不是把键名写成
|
|
225
|
+
// 文档契约——「裸 .evidence」与「X.evidence」由同一个连接式前后界区分,不另写键表;
|
|
226
|
+
// ② **围栏里的示例**:标注为状态输出示例的围栏块整块放行(既有白名单,双向探针在场景 105)。
|
|
227
|
+
// 未标注的围栏块不因「它是代码」而豁免:把状态输出贴进普通代码块同样是直写。
|
|
228
|
+
// 其余自然语言用法("the evidence recorded for the node"、`evidence: [{ id, required }]` 这类
|
|
229
|
+
// 协议字段说明)不命中任何一条。
|
|
230
|
+
function fieldNameHitsOnLine(where, line) {
|
|
231
|
+
const out = [];
|
|
232
|
+
for (const name of PUBLIC_FACE_STATE_FIELDS) {
|
|
233
|
+
// verifyFailures 用前缀匹配:verifyFailuresByChange 是同一族的键,漏掉它等于留后门。
|
|
234
|
+
const matcher = name === 'verifyFailures'
|
|
235
|
+
? /(?<![A-Za-z0-9_$])verifyFailures[A-Za-z0-9_]*/g
|
|
236
|
+
: new RegExp('(?<![A-Za-z0-9_$])' + name + '(?![A-Za-z0-9_$])', 'g');
|
|
237
|
+
for (const hit of line.matchAll(matcher)) out.push(fieldNameViolation(where, hit[0]));
|
|
238
|
+
}
|
|
239
|
+
for (const span of line.matchAll(/`([^`]*)`/g)) {
|
|
240
|
+
if (span[1].trim() === 'evidence') out.push(fieldNameViolation(where, 'evidence'));
|
|
241
|
+
}
|
|
242
|
+
if (EVIDENCE_FIELD_FRAME_RE.test(line)) out.push(fieldNameViolation(where, 'evidence'));
|
|
243
|
+
if (/(?<![A-Za-z0-9_$])\.evidence(?![A-Za-z0-9_$])/.test(line)) {
|
|
244
|
+
out.push(fieldNameViolation(where, 'evidence'));
|
|
245
|
+
}
|
|
246
|
+
return out;
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
// 逐行扫描:未标注的围栏块同样是正文(把状态输出贴进普通代码块不等于获得白名单);标注为
|
|
250
|
+
// 状态输出示例的围栏块整块放行。行内反引号段里的 evidence 是被当作键名书写,散文里的不是。
|
|
251
|
+
function publicFaceFieldProblems(rel, text) {
|
|
252
|
+
const out = [];
|
|
253
|
+
const lines = text.split(/\r?\n/);
|
|
254
|
+
let fence = null;
|
|
255
|
+
let fenceIsExample = false;
|
|
256
|
+
let lastContentLine = '';
|
|
257
|
+
for (let i = 0; i < lines.length; i += 1) {
|
|
258
|
+
const line = lines[i];
|
|
259
|
+
const opening = /^\s{0,3}(`{3,}|~{3,})(.*)$/.exec(line);
|
|
260
|
+
if (fence === null && opening) {
|
|
261
|
+
fence = opening[1][0];
|
|
262
|
+
fenceIsExample = isStatusExampleMarker(opening[2]) || isStatusExampleMarker(lastContentLine);
|
|
263
|
+
continue;
|
|
264
|
+
}
|
|
265
|
+
if (fence !== null) {
|
|
266
|
+
if (new RegExp('^\\s{0,3}' + fence + '{3,}\\s*$').test(line)) {
|
|
267
|
+
fence = null;
|
|
268
|
+
fenceIsExample = false;
|
|
269
|
+
} else if (!fenceIsExample) {
|
|
270
|
+
out.push(...fieldNameHitsOnLine(rel + ':' + (i + 1), line));
|
|
271
|
+
}
|
|
272
|
+
continue;
|
|
273
|
+
}
|
|
274
|
+
if (line.trim() !== '') lastContentLine = line.trim();
|
|
275
|
+
out.push(...fieldNameHitsOnLine(rel + ':' + (i + 1), line));
|
|
276
|
+
}
|
|
277
|
+
return out;
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
function publicFaceMachineProblems({ texts, preflightDocs }) {
|
|
281
|
+
const out = [];
|
|
282
|
+
for (const [rel, text] of texts) {
|
|
283
|
+
if (typeof text !== 'string') out.push(rel + ' 缺失(公开面不在本检出)');
|
|
284
|
+
}
|
|
285
|
+
for (const [rel, text] of texts) {
|
|
286
|
+
if (typeof text === 'string') out.push(...publicFaceFieldProblems(rel, text));
|
|
287
|
+
}
|
|
288
|
+
for (const rel of preflightDocs) {
|
|
289
|
+
const text = texts.get(rel);
|
|
290
|
+
if (typeof text === 'string' && !text.includes(PREFLIGHT_FLAG)) {
|
|
291
|
+
out.push(rel + ' 缺「' + PREFLIGHT_FLAG + '」锚(结构预检命令须在三份公开面 × 中英在案)');
|
|
292
|
+
}
|
|
293
|
+
}
|
|
294
|
+
return out;
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
// ---------- 权威源设计形态锚(形态探测与上面同源:.flow-comet/ 技能树在场 = 权威源检出) ----------
|
|
298
|
+
// 设计形态 = 权威源册子里写出的命令形态(.claude/skills/flow-comet/scripts/…,相对路径),安装时由
|
|
299
|
+
// prepare-env 的 pathReplacements 按平台替换。锚的就是这个形态:安装副本按运行根推导同样是对的,但
|
|
300
|
+
// 那是另一种载体下的正确形态——两种形态混进一条判据,就谁也锁不住(谁都能满足它)。
|
|
301
|
+
const DESIGN_FORM_SCRIPTS_DIR = '.claude/skills/flow-comet/scripts';
|
|
302
|
+
// 「本锚只在权威源检出运行」的判据必须看**正在跑的是哪套脚本**,而不是「仓库里有没有 .flow-comet/」——
|
|
303
|
+
// 仓库里同时存在 .claude|.agents|.dsh 三份副本,跑副本套件时仓库根锚照样在场;只用根锚会把副本误判成权威源,
|
|
304
|
+
// 让安装副本按运行根打印的(对副本而言正确的)路径被判成违规。
|
|
305
|
+
const RUNS_FROM_AUTHORITATIVE_SCRIPTS = path.relative(REPO_ROOT, SCRIPTS_DIR).split(path.sep).join('/') === '.flow-comet/skills/flow-comet/scripts';
|
|
306
|
+
|
|
307
|
+
// 恢复段的形态锚(只在权威源检出运行)。场景 34 的恢复命令断言已改成行为判据(存在 + basename
|
|
308
|
+
// + 真执行),三种形态的路径都能满足——于是「权威源打印设计形态」失去锁:把 scriptCommand 改成恒打印
|
|
309
|
+
// 绝对安装根,行为判据全绿,而权威源册子里的命令会开始写本机路径。本锚只读打印出来的那段恢复报文
|
|
310
|
+
// (不拿 harness 的脚本路径替代),要求命令的脚本路径逐字等于设计形态。
|
|
311
|
+
// 锁的是「段内有一条 record 命令 + 路径是设计形态 + 步骤按执行顺序」,不锁「record 紧贴『恢复:』」
|
|
312
|
+
// 这种书写形态:措辞可以演化,能按顺序照抄走通才是判据——顺序反了,执行者从上往下第一步就撞门。
|
|
313
|
+
function assertDesignFormRecoveryPath(dir) {
|
|
314
|
+
// 触发一条走 scriptCommand 的恢复指引:subagent-execute 有 handoff 结果、缺 summary → 出口按
|
|
315
|
+
// Output Schema evidence 阻塞。夹具是全新临时目录 ⇒ 本节点还没有技能加载声明标记 ⇒ 走「先声明、
|
|
316
|
+
// 再 record」的两步形态(声明已在场时的收敛形态由场景 34 覆盖)。
|
|
317
|
+
const st = baseState('subagent-execute');
|
|
318
|
+
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['P01']) };
|
|
319
|
+
writeState(dir, st);
|
|
320
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
|
|
321
|
+
const res = runGuardWithProtocol(dir, ['exit', 'subagent-execute']);
|
|
322
|
+
assertExit(res, 1);
|
|
323
|
+
assertOut(res, 'BLOCKED: missing Output Schema evidence');
|
|
324
|
+
// 本段 = 输出里最后一条恢复段(该段之后引擎直接退出)。
|
|
325
|
+
const start = res.output.lastIndexOf('恢复:');
|
|
326
|
+
const block = start < 0 ? '' : res.output.slice(start);
|
|
327
|
+
if (block === '') {
|
|
328
|
+
throw new Error('缺 Output Schema evidence 的阻塞没给恢复段(设计形态锚无从判定):\n' + res.output);
|
|
329
|
+
}
|
|
330
|
+
// 两条命令(各自单独一行,行内只有命令本身):先声明技能加载,再 record。取法与照抄闭环同一处
|
|
331
|
+
// (printedCommandsOf)——恢复段的「哪一行是命令」只有一份判据,本锚不另写一条取行正则。
|
|
332
|
+
const skillLoadLine = printedCommandsOf(block, 'skill-load')[0];
|
|
333
|
+
const recordLine = printedCommandsOf(block, 'record')[0];
|
|
334
|
+
if (!skillLoadLine || !recordLine) {
|
|
335
|
+
throw new Error('恢复段应同时给出可照抄的 skill-load 与 record 命令'
|
|
336
|
+
+ '(缺声明时照抄 record 会先被它自己的前置门拦下):\n' + block);
|
|
337
|
+
}
|
|
338
|
+
// 顺序 = 执行顺序,且步骤标注跟着各自的命令走(不是只在段首提一句)。
|
|
339
|
+
const skillAt = block.indexOf(skillLoadLine);
|
|
340
|
+
const recordAt = block.indexOf(recordLine);
|
|
341
|
+
if (!(skillAt >= 0 && recordAt > skillAt)) {
|
|
342
|
+
throw new Error('恢复段应按执行顺序排列:skill-load(声明技能加载)在前、record(补证据)在后——'
|
|
343
|
+
+ '顺序反了执行者照抄会先撞前置门:\n' + block);
|
|
344
|
+
}
|
|
345
|
+
if (!block.slice(0, skillAt).includes('第一步')) {
|
|
346
|
+
throw new Error('恢复段未把技能加载声明标为第一步:\n' + block);
|
|
347
|
+
}
|
|
348
|
+
if (!block.slice(skillAt + skillLoadLine.length, recordAt).includes('第二步')) {
|
|
349
|
+
throw new Error('恢复段未把 record 标为第二步:\n' + block);
|
|
350
|
+
}
|
|
351
|
+
// 路径逐字等于设计形态(两条命令都经 scriptCommand,路径与引号只有这一处实现)。
|
|
352
|
+
const expected = DESIGN_FORM_SCRIPTS_DIR + '/workflow-state.mjs';
|
|
353
|
+
for (const [label, printed] of [['skill-load', skillLoadLine], ['record', recordLine]]) {
|
|
354
|
+
const printedPath = (printed.match(/^node "([^"]+)"/) || [])[1];
|
|
355
|
+
if (printedPath !== expected) {
|
|
356
|
+
throw new Error('权威源检出打印的恢复段 ' + label + ' 命令脚本路径应为设计形态 ' + expected
|
|
357
|
+
+ '(相对路径)——实际: ' + JSON.stringify(printedPath)
|
|
358
|
+
+ ';安装副本按运行根推导属另一种载体的正确形态,不在本锚范围(本锚只在权威源检出运行)');
|
|
359
|
+
}
|
|
360
|
+
}
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
// ---------- 恢复段给出的命令:解析 → 在夹具内逐字执行(照抄闭合) ----------
|
|
364
|
+
//
|
|
365
|
+
// 恢复段承诺的是「可照抄的命令」,判据就得**真的照抄**:从报文解析命令文本 → 按当前运行形态解析
|
|
366
|
+
// 脚本路径 → 用同一份参数跑一遍(只把 `node` 换成本进程的可执行文件——PATH 解析不是判据对象)。
|
|
367
|
+
// 这条链路的三个夹具(按安装布局复制技能树 / 打印命令切成 argv / 真实执行打印文本)与委托链路组
|
|
368
|
+
// 共用,单一来源在 lib/test-helpers.mjs;权威源打印的设计形态相对路径(.claude/skills/…)只在
|
|
369
|
+
// 复制进夹具的技能树里可解析,因此执行的是**打印文本**——拿 harness 的绝对脚本路径替代它,
|
|
370
|
+
//「这条命令能不能跑」就等于没判。本段只留声明恢复自己的夹具:重放根与逐条照抄执行。
|
|
371
|
+
|
|
372
|
+
// 照抄闭环自己的夹具根 + 协议副本:场景运行器给主夹具做的那两步,在闭环的独立根上再走一遍
|
|
373
|
+
// (协议文件必须在运行根内才会被守卫读取)。
|
|
374
|
+
function makeReplayRoot() {
|
|
375
|
+
const root = makeTmp();
|
|
376
|
+
fs.mkdirSync(path.dirname(scenarioProtocolPath(root)), { recursive: true });
|
|
377
|
+
fs.copyFileSync(BUILTIN_PROTOCOL_SOURCE, scenarioProtocolPath(root));
|
|
378
|
+
return root;
|
|
379
|
+
}
|
|
380
|
+
|
|
381
|
+
// 照抄执行段(两条闭环共用):按安装布局把本套件技能树复制进夹具(打印出来的设计形态相对路径才可
|
|
382
|
+
// 解析),并清掉环境里的协议注入——命令自带的协议上下文必须够用。返回逐条执行打印文本的函数,
|
|
383
|
+
// 非 0 即失败并回显命令。
|
|
384
|
+
function printedCommandReplay(root, label) {
|
|
385
|
+
installSkillTreeCopy(root, path.join('.claude', 'skills'));
|
|
386
|
+
const cleanEnv = { FLOW_COMET_RUN_ROOT: root, FLOW_COMET_PROTOCOL: '' };
|
|
387
|
+
return (command) => {
|
|
388
|
+
const res = runPrintedCommand(command, root, cleanEnv);
|
|
389
|
+
assertTrue(res.status === 0, label + ':照抄的命令跑不通\n 命令: ' + command
|
|
390
|
+
+ '\n exit ' + res.status + '\n' + res.output);
|
|
391
|
+
return res;
|
|
392
|
+
};
|
|
393
|
+
}
|
|
394
|
+
|
|
395
|
+
// 恢复段 = 输出里最后一条「恢复:」起的整段(该段之后引擎直接退出)。
|
|
396
|
+
function lastRecoveryBlock(output) {
|
|
397
|
+
const text = String(output);
|
|
398
|
+
const start = text.lastIndexOf('恢复:');
|
|
399
|
+
return start < 0 ? '' : text.slice(start);
|
|
400
|
+
}
|
|
401
|
+
|
|
402
|
+
// 段内某一类命令的全部可照抄行:命令行自成一行(命令与说明分行——说明接在命令行尾时,整行丢给
|
|
403
|
+
// shell 会把说明当成参数)。判据只认「行首 = node + 引号脚本路径」这一形态,说明行因此不可能被读
|
|
404
|
+
// 成命令(同一个判据也用来证明恢复段里没有第二份命令文本)。
|
|
405
|
+
function printedCommandsOf(block, verb) {
|
|
406
|
+
const pattern = new RegExp('^\\s*(node "[^"]+" ' + verb + ' [^\\n]+)$', 'gm');
|
|
407
|
+
return [...block.matchAll(pattern)].map((match) => match[1]);
|
|
408
|
+
}
|
|
409
|
+
|
|
410
|
+
// 声明恢复的照抄闭合(open / review 同一条判据):删声明与证据 → exit 被拦 → **逐字照抄**报文给出的
|
|
411
|
+
// 每条命令(第一步的声明命令按序,再第二步的 record)→ 同一 exit 通过。缺陷形态:第一步只声明实现
|
|
412
|
+
// 技能 + 首份协议、且不带模板清单,照抄完同一 exit 仍被覆盖门点名(缺另一份协议文件与另一个必需
|
|
413
|
+
// 技能)——「报文各给一半」正是本断言要钉死的东西:照抄不了就是没修好。
|
|
414
|
+
function assertDeclarationRecoveryRoundTrip({ node, fixture, skills, prompts, templates }) {
|
|
415
|
+
const root = makeReplayRoot();
|
|
416
|
+
try {
|
|
417
|
+
fixture(root);
|
|
418
|
+
const blocked = runGuard(['exit', node], root);
|
|
419
|
+
assertExit(blocked, 1);
|
|
420
|
+
assertOut(blocked, 'BLOCKED: missing evidence for Node ' + node);
|
|
421
|
+
const block = lastRecoveryBlock(blocked.output);
|
|
422
|
+
const declared = printedCommandsOf(block, 'skill-load');
|
|
423
|
+
const recordCommand = printedCommandsOf(block, 'record')[0];
|
|
424
|
+
if (declared.length === 0 || !recordCommand) {
|
|
425
|
+
throw new Error(node + ':缺声明 + 缺证据的阻塞应同时给出 skill-load 与 record 命令:\n' + block);
|
|
426
|
+
}
|
|
427
|
+
// 照抄:声明命令按报文顺序执行,再 record。环境里不注入协议——命令自带的上下文必须够用。
|
|
428
|
+
const copyAndRun = printedCommandReplay(root, node);
|
|
429
|
+
for (const command of declared) copyAndRun(command);
|
|
430
|
+
copyAndRun(recordCommand);
|
|
431
|
+
// 核心:照抄完,同一个 exit 必须通过(不是「再去另一条报文里找第二步」)。
|
|
432
|
+
const recovered = runGuard(['exit', node], root);
|
|
433
|
+
assertExit(recovered, 0);
|
|
434
|
+
assertOut(recovered, 'ALL CHECKS PASSED');
|
|
435
|
+
assertDerivedDeclarationCommands({ node, block, declared, skills, prompts, templates });
|
|
436
|
+
assertDeclarationGateRecovery({ node, root, skills, prompts, templates, copyAndRun });
|
|
437
|
+
} finally {
|
|
438
|
+
cleanupTmpDir(root);
|
|
439
|
+
}
|
|
440
|
+
}
|
|
441
|
+
|
|
442
|
+
// 派生形态的判据:每个 guarded 必需技能各一条,且每条都带该节点**全部**协议文件与该节点的模板
|
|
443
|
+
// 全清单。照抄闭环已经会红掉「跑不通」的拼法;这一层把推导规则本身钉住——把两份协议分到两条命令、
|
|
444
|
+
// 或只给其一,都属于「凑够覆盖但命令不是同一个形态」,下游照抄同样会在模板面 / 协议面漏。
|
|
445
|
+
function assertDerivedDeclarationCommands({ node, block, declared, skills, prompts, templates }) {
|
|
446
|
+
if (declared.length !== skills.length) {
|
|
447
|
+
throw new Error(node + ':声明命令应每个 guarded 必需技能各一条(' + skills.length + ' 条),实际 '
|
|
448
|
+
+ declared.length + ' 条:\n' + declared.join('\n'));
|
|
449
|
+
}
|
|
450
|
+
const templateFlag = '--templates ' + templates.join(',');
|
|
451
|
+
for (const skill of skills) {
|
|
452
|
+
const command = declared.find((line) => line.includes(' skill-load ' + node + ' ' + skill + ' '));
|
|
453
|
+
if (!command) {
|
|
454
|
+
throw new Error(node + ':恢复段缺技能 ' + skill + ' 的声明命令(该技能是 guarded 必需技能):\n' + block);
|
|
455
|
+
}
|
|
456
|
+
for (const prompt of prompts) {
|
|
457
|
+
if (!command.includes('--prompt ' + prompt)) {
|
|
458
|
+
throw new Error(node + ':' + skill + ' 的声明命令缺协议文件 ' + prompt
|
|
459
|
+
+ '(一条命令要把该节点全部协议文件都带上,照抄才一次到位): ' + command);
|
|
460
|
+
}
|
|
461
|
+
}
|
|
462
|
+
if (!command.includes(templateFlag)) {
|
|
463
|
+
throw new Error(node + ':' + skill + ' 的声明命令缺模板全清单 ' + templateFlag
|
|
464
|
+
+ '(漏模板清单,照抄后会被模板门拦下): ' + command);
|
|
465
|
+
}
|
|
466
|
+
}
|
|
467
|
+
}
|
|
468
|
+
|
|
469
|
+
// 覆盖门补齐命令的照抄闭合(同一缺陷的第二半:门只给缺项、技能名占位、且漏 --templates)。把声明
|
|
470
|
+
// 退回旧口径——只剩一个技能 + 一份协议(模板清单仍写全,否则第一步就撞 skill-load 自己的模板门,
|
|
471
|
+
// 测不到覆盖门)→ exit 被覆盖门拦下 → **照抄门给出的命令** → 同一 exit 通过。
|
|
472
|
+
function assertDeclarationGateRecovery({ node, root, skills, prompts, templates, copyAndRun }) {
|
|
473
|
+
const loadsDir = path.join(root, '.specs', CHANGE_ID, '.skill-loads');
|
|
474
|
+
const declaredSkill = skills[0];
|
|
475
|
+
for (const name of fs.readdirSync(loadsDir)) fs.rmSync(path.join(loadsDir, name));
|
|
476
|
+
assertExit(runState(['skill-load', node, declaredSkill, '--prompt', prompts[0],
|
|
477
|
+
'--templates', templates.join(',')], root), 0);
|
|
478
|
+
const blocked = runGuard(['exit', node], root);
|
|
479
|
+
assertExit(blocked, 1);
|
|
480
|
+
assertOut(blocked, '缺协议声明标记');
|
|
481
|
+
const block = lastRecoveryBlock(blocked.output);
|
|
482
|
+
const commands = printedCommandsOf(block, 'skill-load');
|
|
483
|
+
if (commands.length === 0) {
|
|
484
|
+
throw new Error(node + ':覆盖门的恢复段没给出可照抄的声明命令:\n' + block);
|
|
485
|
+
}
|
|
486
|
+
// 形态断言(照抄能过 ≠ 命令形态对):覆盖门的命令按**缺的必需技能子集**派生——已在场的技能不重
|
|
487
|
+
// 复刷,缺的每个技能各一条——且每条都把该节点**全部** --prompt 与模板全清单带全。只锁「照抄后
|
|
488
|
+
// 通过」会放过少一份 --prompt 的拼法:那份协议此刻由既有标记覆盖,缺口要等执行者删掉那条标记
|
|
489
|
+
// 才现形(报文当场就给不全)。少一条命令 / 多刷已声明的技能 / 少任一份 --prompt / 少模板清单,
|
|
490
|
+
// 本断言即红。
|
|
491
|
+
const expectedSkills = skills.filter((skill) => skill !== declaredSkill);
|
|
492
|
+
if (commands.length !== expectedSkills.length) {
|
|
493
|
+
throw new Error(node + ':覆盖门的声明命令应按缺的必需技能子集派生(缺 '
|
|
494
|
+
+ expectedSkills.join('、') + ' = ' + expectedSkills.length + ' 条),实际 '
|
|
495
|
+
+ commands.length + ' 条:\n' + block);
|
|
496
|
+
}
|
|
497
|
+
const templateFlag = '--templates ' + templates.join(',');
|
|
498
|
+
for (const skill of expectedSkills) {
|
|
499
|
+
const command = commands.find((line) => line.includes(' skill-load ' + node + ' ' + skill + ' '));
|
|
500
|
+
if (!command) {
|
|
501
|
+
throw new Error(node + ':覆盖门的恢复段缺技能 ' + skill + ' 的声明命令(它是缺的必需技能):\n' + block);
|
|
502
|
+
}
|
|
503
|
+
for (const prompt of prompts) {
|
|
504
|
+
if (!command.includes('--prompt ' + prompt)) {
|
|
505
|
+
throw new Error(node + ':' + skill + ' 的声明命令缺协议文件 ' + prompt
|
|
506
|
+
+ '(覆盖门要求该节点全部协议文件都被声明,少给一份,照抄后同一 exit 仍会点名它): ' + command);
|
|
507
|
+
}
|
|
508
|
+
}
|
|
509
|
+
if (!command.includes(templateFlag)) {
|
|
510
|
+
throw new Error(node + ':' + skill + ' 的声明命令缺模板全清单 ' + templateFlag + ': ' + command);
|
|
511
|
+
}
|
|
512
|
+
}
|
|
513
|
+
for (const command of commands) copyAndRun(command);
|
|
514
|
+
const recovered = runGuard(['exit', node], root);
|
|
515
|
+
assertExit(recovered, 0);
|
|
516
|
+
assertOut(recovered, 'ALL CHECKS PASSED');
|
|
517
|
+
}
|
|
518
|
+
|
|
519
|
+
// 前端 design 的证据门照抄闭合(gated 绑定的那半):证据里只缺 required-skill:design.flow-comet-ui-design
|
|
520
|
+
// ——出口对该绑定**不再自动补写**,恢复必须同一段给全两件事:
|
|
521
|
+
// ① 真实 skill-load 声明(nodeSkillLoadCommands 的同一装配:每个 guarded 必需技能各一条,每条带
|
|
522
|
+
// 该节点全部 --prompt(含条件提示词 2a-ui-design.md)与模板全清单);
|
|
523
|
+
// ② 带该 required-skill 的 record——只补声明不补证据,同一个 exit 仍点名同一条。
|
|
524
|
+
// 旧形态(占位提示词、无 --templates、不提 record)照抄后必死循环;本断言逐层钉住这两件,再真的
|
|
525
|
+
// 照抄走一遍。
|
|
526
|
+
function assertFrontendDesignEvidenceRoundTrip() {
|
|
527
|
+
const root = makeReplayRoot();
|
|
528
|
+
try {
|
|
529
|
+
writeDesignExitFixture(root, {
|
|
530
|
+
visualTone: VISUAL_TONE_APPLICABLE, uiDesign: true, declareUiDesign: false,
|
|
531
|
+
});
|
|
532
|
+
const blocked = runGuard(['exit', 'design'], root);
|
|
533
|
+
assertExit(blocked, 1);
|
|
534
|
+
assertOut(blocked, 'BLOCKED: missing required Skill evidence: required-skill:design.flow-comet-ui-design');
|
|
535
|
+
// ① 占位提示词形态:--prompt 的值位置写「<flow-kit/prompts/ 协议文件>」,bash 下 < 是重定向——
|
|
536
|
+
// 照抄直接语法失败(值位置不接受占位符:路径要么给全,要么别给这个参数)。
|
|
537
|
+
assertNotOut(blocked, '--prompt <');
|
|
538
|
+
const block = lastRecoveryBlock(blocked.output);
|
|
539
|
+
const declared = printedCommandsOf(block, 'skill-load');
|
|
540
|
+
const recordCommand = printedCommandsOf(block, 'record')[0];
|
|
541
|
+
if (declared.length === 0 || !recordCommand) {
|
|
542
|
+
throw new Error('design:gated 绑定的缺口应同时给出 skill-load 与 record 命令'
|
|
543
|
+
+ '(只给声明不给 record,照抄后同一 exit 仍点名同一条):\n' + block);
|
|
544
|
+
}
|
|
545
|
+
// ② record 载荷带上被点名的那条 required-skill——record 是覆盖写,只有把这条写回去才算补齐
|
|
546
|
+
if (!recordCommand.includes('required-skill:design.flow-comet-ui-design')) {
|
|
547
|
+
throw new Error('design:record 的恢复载荷没带上 required-skill:design.flow-comet-ui-design'
|
|
548
|
+
+ '(自动补写对该绑定已失效,只补声明不补证据 = 死循环): ' + recordCommand);
|
|
549
|
+
}
|
|
550
|
+
// ③ 派生形态:每个 guarded 必需技能各一条,每条带全部协议文件(含条件提示词)与模板全清单
|
|
551
|
+
assertDerivedDeclarationCommands({
|
|
552
|
+
node: 'design',
|
|
553
|
+
block,
|
|
554
|
+
declared,
|
|
555
|
+
skills: ['flow-comet-design', 'flow-comet-ui-design'],
|
|
556
|
+
prompts: ['flow-kit/prompts/2-design.md', 'flow-kit/prompts/2a-ui-design.md'],
|
|
557
|
+
templates: ['DESIGN.md'],
|
|
558
|
+
});
|
|
559
|
+
// ④ 真的照抄:按报文顺序执行声明命令,再 record;环境里不注入协议(命令自带上下文必须够用)
|
|
560
|
+
const copyAndRun = printedCommandReplay(root, 'design');
|
|
561
|
+
for (const command of [...declared, recordCommand]) copyAndRun(command);
|
|
562
|
+
const recovered = runGuard(['exit', 'design'], root);
|
|
563
|
+
assertExit(recovered, 0);
|
|
564
|
+
assertOut(recovered, 'ALL CHECKS PASSED');
|
|
565
|
+
} finally {
|
|
566
|
+
cleanupTmpDir(root);
|
|
567
|
+
}
|
|
568
|
+
}
|
|
569
|
+
|
|
570
|
+
// 入口 --prompt 冲突报文的照抄闭合(同一缺陷的第三面):某个标记声明了节点协议面之外的路径 → 入口
|
|
571
|
+
// 拦下。旧报文写的是「重跑 skill-load <node> <skill> --prompt <上述协议文件>」——占位符落在 --prompt
|
|
572
|
+
// 的值位置(bash 下 `<` 是重定向,照抄直接语法失败),而且只补首份协议:换成真实路径也只补回一份,
|
|
573
|
+
// 下一次入口仍被同一判据点名另一份。故断言「报文里的命令逐字照抄后,同一条入口的冲突消失」。
|
|
574
|
+
function assertEntryConflictRecoveryRoundTrip() {
|
|
575
|
+
const root = makeReplayRoot();
|
|
576
|
+
try {
|
|
577
|
+
// currentNode = open:入口的归位判据满足;本格只让声明冲突这一道门说话。
|
|
578
|
+
writeState(root, baseState('open'));
|
|
579
|
+
writeFile(root, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
|
|
580
|
+
writeFile(root, 'flow-kit/prompts/1-requirement.md', '# 阶段 1 · REQUIREMENT\n\n## 角色\n\n你是 Requirer。\n');
|
|
581
|
+
// 声明里混进一份节点协议面之外的路径:入口按逐份核对拦下(第二份协议也被声明过,冲突只在这一份)。
|
|
582
|
+
writeFile(root, path.posix.join('.specs', CHANGE_ID, '.skill-loads', 'open-flow-comet-change.json'),
|
|
583
|
+
JSON.stringify({
|
|
584
|
+
node: 'open',
|
|
585
|
+
skill: 'flow-comet-change',
|
|
586
|
+
protocol: '0-change.md',
|
|
587
|
+
protocols: ['0-change.md', '9-other.md'],
|
|
588
|
+
templates: ['CHANGE', 'REQUIREMENT'],
|
|
589
|
+
at: '2026-11-01T00:00:00.000Z',
|
|
590
|
+
}, null, 2) + '\n');
|
|
591
|
+
const blocked = runGuard(['entry', 'open'], root);
|
|
592
|
+
assertExit(blocked, 1);
|
|
593
|
+
assertOut(blocked, '与节点协议文件不符');
|
|
594
|
+
// 占位符落在参数值位置 = 照抄不可执行;这是旧报文的形态,必须不再出现。
|
|
595
|
+
assertNotOut(blocked, '--prompt <');
|
|
596
|
+
const commands = [...blocked.output.matchAll(/^\s*(node "[^"]+" skill-load [^\n]+)$/gm)].map((match) => match[1]);
|
|
597
|
+
if (commands.length === 0) {
|
|
598
|
+
throw new Error('入口冲突报文必须给出可照抄的声明命令(占位词不算命令):\n' + blocked.output);
|
|
599
|
+
}
|
|
600
|
+
const command = commands.find((line) => line.includes(' skill-load open flow-comet-change ')) ?? commands[0];
|
|
601
|
+
for (const prompt of ['flow-kit/prompts/0-change.md', 'flow-kit/prompts/1-requirement.md']) {
|
|
602
|
+
if (!command.includes('--prompt ' + prompt)) {
|
|
603
|
+
throw new Error('入口冲突的重新声明命令缺协议文件 ' + prompt
|
|
604
|
+
+ '(只补首份,下一次入口仍会点名另一份): ' + command);
|
|
605
|
+
}
|
|
606
|
+
}
|
|
607
|
+
const templateFlag = '--templates CHANGE.md,REQUIREMENT.md';
|
|
608
|
+
if (!command.includes(templateFlag)) {
|
|
609
|
+
throw new Error('入口冲突的重新声明命令缺模板全清单 ' + templateFlag
|
|
610
|
+
+ '(漏 --templates 时照抄会先被 skill-load 自己的模板门拦下): ' + command);
|
|
611
|
+
}
|
|
612
|
+
const copyAndRun = printedCommandReplay(root, 'entry');
|
|
613
|
+
for (const line of commands) copyAndRun(line);
|
|
614
|
+
const recovered = runGuard(['entry', 'open'], root);
|
|
615
|
+
assertNotOut(recovered, '与节点协议文件不符');
|
|
616
|
+
assertOut(recovered, 'ENTRY OK: open');
|
|
617
|
+
} finally {
|
|
618
|
+
cleanupTmpDir(root);
|
|
619
|
+
}
|
|
620
|
+
}
|
|
621
|
+
|
|
622
|
+
// ---------- 声明命令的册子锚(入口册 + 展开册:open 的两条规范命令) ----------
|
|
623
|
+
//
|
|
624
|
+
// 两册给出 open 的**两条**规范声明命令——每个 guarded 必需技能各一条,每条都带该节点全部 --prompt
|
|
625
|
+
// 与模板全清单。只写其中一条时,照抄的人会在同一次 exit 上被覆盖门点名缺另一个技能(报文各给一半
|
|
626
|
+
// 的文档版)。锚取整行命令(可辨认、可 grep),不取裸词;两册都要有,只出现在一册不算。
|
|
627
|
+
const DECLARATION_BOOK_RELS = ['SKILL.md', path.join('reference', 'entry-detail.md')];
|
|
628
|
+
const DECLARATION_BOOK_COMMAND_ANCHORS = [
|
|
629
|
+
['open 的第一个必需技能(change)',
|
|
630
|
+
'skill-load open flow-comet-change --prompt flow-kit/prompts/0-change.md --prompt flow-kit/prompts/1-requirement.md --templates CHANGE.md,REQUIREMENT.md'],
|
|
631
|
+
['open 的第二个必需技能(requirement)',
|
|
632
|
+
'skill-load open flow-comet-requirement --prompt flow-kit/prompts/0-change.md --prompt flow-kit/prompts/1-requirement.md --templates CHANGE.md,REQUIREMENT.md'],
|
|
633
|
+
];
|
|
634
|
+
|
|
635
|
+
function declarationBookProblems(skillRoot) {
|
|
636
|
+
const out = [];
|
|
637
|
+
for (const rel of DECLARATION_BOOK_RELS) {
|
|
638
|
+
let text;
|
|
639
|
+
try {
|
|
640
|
+
text = fs.readFileSync(path.join(skillRoot, rel), 'utf8');
|
|
641
|
+
} catch {
|
|
642
|
+
out.push(rel + ' 不在场(声明命令锚无法核对)');
|
|
643
|
+
continue;
|
|
644
|
+
}
|
|
645
|
+
for (const [label, command] of DECLARATION_BOOK_COMMAND_ANCHORS) {
|
|
646
|
+
if (!text.includes(command)) out.push(rel + ' 缺「' + label + '」的规范命令');
|
|
647
|
+
}
|
|
648
|
+
}
|
|
649
|
+
return out;
|
|
650
|
+
}
|
|
651
|
+
|
|
652
|
+
// ---------- 排障册的声明命令锚:与入口册同形 ----------
|
|
653
|
+
//
|
|
654
|
+
// 排障册「exit 缺协议声明标记」一条曾给出**手拼的半边命令**:占位符落在 --prompt 的值位置,且不带
|
|
655
|
+
// --templates——新 change 照抄即被 skill-load 自己的模板门拦下(「模板声明缺失」)。判据不在这里再抄
|
|
656
|
+
// 一份命令:排障册必须逐字含入口册的规范声明命令,两册(中英)都要有;抽掉即报。命令形态因此只有
|
|
657
|
+
// 一个来源,排障册不能自持一份「看起来像命令」的文本。
|
|
658
|
+
// 条数同样取入口册的判据面:该节点有几个 guarded 必需技能就给几条。只列第一条的排障册会让照抄的人
|
|
659
|
+
// 在同一次 exit 上被覆盖门点名缺另一个技能(报文各给一半的文档版)——所以锚是**全部**条目,不是首条。
|
|
660
|
+
const TROUBLESHOOTING_COMMAND_RELS = ['docs/TROUBLESHOOTING.md', 'docs/TROUBLESHOOTING-zh.md'];
|
|
661
|
+
const TROUBLESHOOTING_DECLARATION_ANCHORS = DECLARATION_BOOK_COMMAND_ANCHORS.map(([, command]) => command);
|
|
662
|
+
|
|
663
|
+
function troubleshootingDeclarationProblems(texts) {
|
|
664
|
+
const out = [];
|
|
665
|
+
for (const rel of TROUBLESHOOTING_COMMAND_RELS) {
|
|
666
|
+
const text = texts.get(rel);
|
|
667
|
+
if (typeof text !== 'string') {
|
|
668
|
+
out.push(rel + ' 不在场(声明命令锚无法核对)');
|
|
669
|
+
continue;
|
|
670
|
+
}
|
|
671
|
+
for (const anchor of TROUBLESHOOTING_DECLARATION_ANCHORS) {
|
|
672
|
+
if (!text.includes(anchor)) {
|
|
673
|
+
out.push(rel + ' 缺声明命令「' + anchor
|
|
674
|
+
+ '」(排障册的声明命令必须与入口册同形同数:该节点每个 guarded 必需技能一条,'
|
|
675
|
+
+ '每条带该节点全部 --prompt 与模板全清单)');
|
|
676
|
+
}
|
|
677
|
+
}
|
|
678
|
+
}
|
|
679
|
+
return out;
|
|
680
|
+
}
|
|
681
|
+
|
|
682
|
+
// ---------- 形态判据的判别力探针(同一实现驱动,在夹具目录上作业) ----------
|
|
683
|
+
// 三条边界都要有:① 真包形态 / 安装副本形态(有技能树、公开面载体**三者俱缺**)跳过且**可见**,
|
|
684
|
+
// 不判红;② docs/ 在场而权威映射缺失仍显式失败——跳过通道只对「整份公开面不存在」开放,不能顺手
|
|
685
|
+
// 把真事故一起吞掉;③ docs/ 不在、但 CONTRIBUTING.md 或 .github/ 在场必须判红——它们同样不进 npm
|
|
686
|
+
// tarball,任一在场就说明这是**被裁坏的仓库**,不是「本来不含公开面」的载体。
|
|
687
|
+
function assertPublicFaceShapeProbes(dir) {
|
|
688
|
+
// 真包形态 = docs/、CONTRIBUTING.md、.github/ 三者都不在本检出(npm tarball 三者都不带)
|
|
689
|
+
if (!publicFaceDocsAbsent(dir)) {
|
|
690
|
+
throw new Error('形态探针前提失效:夹具目录不应预先含 ' + PUBLIC_FACE_DOCS_DIR
|
|
691
|
+
+ '/、CONTRIBUTING.md 或 .github/(三者俱缺才是「不含公开面」的包形态)');
|
|
692
|
+
}
|
|
693
|
+
for (const phrase of ['此形态不含公开面', '不是仓库缺文件', '未校验']) {
|
|
694
|
+
if (!PUBLIC_FACE_SELF_CHECK_SKIP_NOTICE.includes(phrase)) {
|
|
695
|
+
throw new Error('跳过提示缺「' + phrase + '」——跳过必须说明这是未校验、不是通过、也不是缺文件: '
|
|
696
|
+
+ PUBLIC_FACE_SELF_CHECK_SKIP_NOTICE);
|
|
697
|
+
}
|
|
698
|
+
}
|
|
699
|
+
// docs/ 在场 ⇒ 不属「不含公开文档」形态,判据不得据此跳过(否则真检出会被整面跳过)
|
|
700
|
+
fs.mkdirSync(path.join(dir, ...PUBLIC_FACE_DOCS_DIR.split('/')), { recursive: true });
|
|
701
|
+
if (publicFaceDocsAbsent(dir)) {
|
|
702
|
+
throw new Error('形态判据把含 ' + PUBLIC_FACE_DOCS_DIR + '/ 的检出也判成不含公开文档(真检出会被整面跳过)');
|
|
703
|
+
}
|
|
704
|
+
// docs/ 不在、其余公开面载体在场 ⇒ 仍不属包形态:分支 / 稀疏检出 / 误删会把 docs/ 整份拿掉,那时
|
|
705
|
+
// 「本载体不含公开面」是假话——计数一致性 / 公开产物零代号 / 词表镜像会整块变成可见 SKIP 并 exit 0。
|
|
706
|
+
// 两份载体分开造根:CONTRIBUTING.md 与 .github/ 各自单独在场都足以证明本检出是仓库(两者都不进
|
|
707
|
+
// npm tarball;README 不作判据——npm 会强制包含它,用它判断等于把包形态误判成「有公开面」的仓库)。
|
|
708
|
+
for (const carrier of ['CONTRIBUTING.md', '.github/workflows/ci.yml']) {
|
|
709
|
+
const partial = path.join(dir, 'partial-face-' + carrier.split('/')[0].replace(/\./g, ''));
|
|
710
|
+
fs.mkdirSync(partial, { recursive: true });
|
|
711
|
+
writeFile(partial, carrier, '');
|
|
712
|
+
if (publicFaceDocsAbsent(partial)) {
|
|
713
|
+
throw new Error('docs/ 不在但 ' + carrier + ' 在场仍被判成「不含公开面」的包形态——'
|
|
714
|
+
+ '该形态下计数一致性 / 公开产物零代号 / 词表镜像会整块变成 SKIP 并 exit 0');
|
|
715
|
+
}
|
|
716
|
+
}
|
|
717
|
+
// docs/ 在场、权威映射缺 = 检出被裁坏 → 仍是读取处的显式失败(判据强度不因跳过通道下降)
|
|
718
|
+
let threw = null;
|
|
719
|
+
try {
|
|
720
|
+
readPublicFaceAuthorityMap(dir);
|
|
721
|
+
} catch (e) {
|
|
722
|
+
threw = e;
|
|
723
|
+
}
|
|
724
|
+
if (!threw || !String(threw.message).includes('受检面无法派生')) {
|
|
725
|
+
throw new Error('docs/ 在场但权威映射缺失时应显式失败,实际: ' + (threw ? threw.message : '未抛错'));
|
|
726
|
+
}
|
|
727
|
+
// 补上映射 ⇒ 读取处正常返回(证明上一条的失败来自「缺映射」而不是「读不到」)
|
|
728
|
+
writeFile(dir, PUBLIC_FACE_AUTHORITY_MAP,
|
|
729
|
+
JSON.stringify({ topics: { workflow: { authority: PUBLIC_FACE_EXAMPLES_DIR + '/README.md' } } }, null, 2) + '\n');
|
|
730
|
+
const parsed = readPublicFaceAuthorityMap(dir);
|
|
731
|
+
if (!parsed.topics || !parsed.topics.workflow) {
|
|
732
|
+
throw new Error('权威映射在场时读取处应返回 topics(探针前提失效): ' + JSON.stringify(parsed));
|
|
733
|
+
}
|
|
734
|
+
}
|
|
735
|
+
|
|
44
736
|
export const ENTRIES = [
|
|
45
737
|
|
|
46
738
|
// ---------- 场景(completedChecks 真实性声明机制——skill-load/record/exit 校验 + 交叉自洽 + 旧兼容 + 场景数同步) ----------
|
|
47
739
|
|
|
48
740
|
// 98: skill-load 写入声明标记(AC-1)——完整命令形态(--prompt flow-kit/prompts/<阶段>.md,
|
|
49
741
|
// 归属校验通过)→ 标记 .specs/<change-id>/.skill-loads/<node>-<skill>.json 生成,
|
|
50
|
-
// 内容含 node/skill/protocol/at(ISO 时间戳)+
|
|
742
|
+
// 内容含 node/skill/protocol/protocols/at(ISO 时间戳)+ 输出确认提示。
|
|
743
|
+
// 原位扩展(多 --prompt 记录):open 节点该读两份协议,一条命令可一次声明多份——标记里存
|
|
744
|
+
// protocols 数组(逐个 basename,按 --prompt 出现顺序),protocol 仍存首个 basename(旧读法兼容:
|
|
745
|
+
// 入口声明核对与既有读标记的消费方只读 protocol 单值)。
|
|
51
746
|
{
|
|
52
747
|
name: '98 skill-load 写入声明标记(AC-1)',
|
|
53
748
|
run: (dir) => {
|
|
54
749
|
// 场景内 flow-kit/prompts/ 提示文件(skill-load --prompt 指向——改名 --prompt 后归属校验仅查
|
|
55
750
|
// 前缀不读内容;协议加载走 env reference 路径,文件无需为 JSON)
|
|
56
751
|
writeFile(dir, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
|
|
752
|
+
writeFile(dir, 'flow-kit/prompts/1-requirement.md', '# 阶段 1 · REQUIREMENT\n\n## 角色\n\n你是 Requirer。\n');
|
|
57
753
|
writeState(dir, baseState('open'));
|
|
58
754
|
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', '--templates', 'CHANGE.md,REQUIREMENT.md']);
|
|
755
|
+
const res = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--prompt', 'flow-kit/prompts/0-change.md', '--prompt', 'flow-kit/prompts/1-requirement.md', '--templates', 'CHANGE.md,REQUIREMENT.md']);
|
|
60
756
|
assertExit(res, 0);
|
|
61
|
-
|
|
757
|
+
// 落点如实(报告写的是标记真正被放进哪个目录):活动目录下就是 .specs/<change-id>/.skill-loads/。
|
|
758
|
+
assertOut(res, 'SKILL-LOAD: open flow-comet-change → .specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json');
|
|
62
759
|
const markerPath = path.join(dir, '.specs', CHANGE_ID, '.skill-loads', 'open-flow-comet-change.json');
|
|
63
760
|
if (!fs.existsSync(markerPath)) throw new Error('标记文件未生成: ' + markerPath);
|
|
64
761
|
const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
|
|
@@ -67,13 +764,40 @@ export const ENTRIES = [
|
|
|
67
764
|
}
|
|
68
765
|
// 标记 protocol = --prompt 参数的 basename(与 guard exit 的 节点协议映射表比对同值,
|
|
69
766
|
// 真实链路 skill-load → exit 一致;缺陷修复前写 resolveProtocol 解析后的完整绝对路径,
|
|
70
|
-
// 与 节点协议映射表 basename
|
|
767
|
+
// 与 节点协议映射表 basename 精确比对必然失败——机制实际不可用,已修复)。
|
|
768
|
+
// 多 --prompt 时取首个(旧读法只认单值,保持逐字可读)。
|
|
71
769
|
if (marker.protocol !== '0-change.md') {
|
|
72
770
|
throw new Error('标记 protocol 应为 --prompt 参数的 basename 0-change.md: ' + JSON.stringify(marker));
|
|
73
771
|
}
|
|
772
|
+
// 多 --prompt 全部被记录(缺陷修复前只取第一个,第二个声明被静默丢弃——覆盖判据因此永远
|
|
773
|
+
// 看不到它)。顺序 = 命令行出现顺序,供报文按序点名。
|
|
774
|
+
if (!Array.isArray(marker.protocols) || marker.protocols.join(',') !== '0-change.md,1-requirement.md') {
|
|
775
|
+
throw new Error('标记 protocols 应记录全部 --prompt 的 basename(0-change.md,1-requirement.md): ' + JSON.stringify(marker));
|
|
776
|
+
}
|
|
74
777
|
if (typeof marker.at !== 'string' || Number.isNaN(Date.parse(marker.at))) {
|
|
75
778
|
throw new Error('标记缺 ISO 时间戳 at: ' + JSON.stringify(marker));
|
|
76
779
|
}
|
|
780
|
+
// ---------- 移动后落点(原位扩展 · running-moved 仍可声明) ----------
|
|
781
|
+
// 归档搬到一半的现场:目录已进 `.specs/archive/<日期>-<change-id>/`,执行者照抄 record / exit 报文
|
|
782
|
+
// 打印的 skill-load 命令。标记必须写进**解析到的目录**(归档),报告要说出真实落点;不得抛
|
|
783
|
+
// 「无活跃 change」(修复前身份绑在活动目录存在上,移动后即丢身份),也不得重建活动目录
|
|
784
|
+
// (位置是只读事实,不是命令的副作用)。
|
|
785
|
+
const archiveRoot = path.join(dir, '.specs', 'archive');
|
|
786
|
+
const archivedChange = path.join(archiveRoot, '2026-11-05-' + CHANGE_ID);
|
|
787
|
+
fs.mkdirSync(archiveRoot, { recursive: true });
|
|
788
|
+
fs.renameSync(path.join(dir, '.specs', CHANGE_ID), archivedChange);
|
|
789
|
+
const moved = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change',
|
|
790
|
+
'--prompt', 'flow-kit/prompts/0-change.md', '--templates', 'CHANGE.md,REQUIREMENT.md']);
|
|
791
|
+
assertExit(moved, 0);
|
|
792
|
+
assertOut(moved, 'SKILL-LOAD: open flow-comet-change → .specs/archive/2026-11-05-' + CHANGE_ID
|
|
793
|
+
+ '/.skill-loads/open-flow-comet-change.json');
|
|
794
|
+
const archivedMarker = path.join(archivedChange, '.skill-loads', 'open-flow-comet-change.json');
|
|
795
|
+
if (!fs.existsSync(archivedMarker)) {
|
|
796
|
+
throw new Error('移动后 skill-load 应把标记写进归档目录: ' + archivedMarker);
|
|
797
|
+
}
|
|
798
|
+
if (fs.existsSync(path.join(dir, '.specs', CHANGE_ID))) {
|
|
799
|
+
throw new Error('移动后 skill-load 重建了活动目录: .specs/' + CHANGE_ID + '/');
|
|
800
|
+
}
|
|
77
801
|
},
|
|
78
802
|
},
|
|
79
803
|
|
|
@@ -116,20 +840,38 @@ export const ENTRIES = [
|
|
|
116
840
|
},
|
|
117
841
|
|
|
118
842
|
// 100: record 校验 BLOCK(AC-3 反例)——completedChecks 含 required-skill:open.flow-comet-change
|
|
119
|
-
// 条目但无对应声明标记 → BLOCKED +
|
|
843
|
+
// 条目但无对应声明标记 → BLOCKED + 可照抄的声明命令;evidence 不写入。
|
|
844
|
+
// 命令形态的判据是**照抄能跑通**:解析打印文本 → 在夹具里真执行 → 同一条 record 通过。旧形态是
|
|
845
|
+
// 裸脚本名 + 相对提示词 + 无协议上下文(`workflow-state.mjs skill-load …`),照抄在 shell 里
|
|
846
|
+
// command not found;字符串断言只能钉住那个坏形态本身,钉不出「这条命令能不能用」。
|
|
120
847
|
{
|
|
121
848
|
name: '100 record BLOCKED:completedChecks 缺声明标记(AC-3)',
|
|
122
849
|
run: (dir) => {
|
|
123
850
|
writeState(dir, baseState('open'));
|
|
124
851
|
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
125
|
-
const
|
|
852
|
+
const payload = JSON.stringify({ summary: 'done', completedChecks: ['required-skill:open.flow-comet-change'] });
|
|
853
|
+
const res = runStateWithProtocol(dir, ['record', 'open', payload]);
|
|
126
854
|
assertExit(res, 1);
|
|
127
855
|
assertOut(res, 'BLOCKED');
|
|
128
856
|
assertOut(res, '缺少对应声明标记');
|
|
129
|
-
assertOut(res, 'workflow-state.mjs skill-load open flow-comet-change');
|
|
130
857
|
// BLOCK 先于记录——校验失败后 evidence 不得写入
|
|
131
858
|
const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
132
859
|
if (st.evidence && st.evidence.open) throw new Error('BLOCKED 后不应写入 evidence: ' + JSON.stringify(st.evidence.open));
|
|
860
|
+
// 报文给出的声明命令必须可照抄(与守卫侧恢复段同一装配:脚本路径 + 全部 --prompt + 模板全清单
|
|
861
|
+
// + 协议上下文):解析 → 真跑 → 同一条 record 通过。
|
|
862
|
+
const command = (res.output.match(/^\s*(node "[^"]+" skill-load [^\n]+)$/m) || [])[1];
|
|
863
|
+
if (!command) {
|
|
864
|
+
throw new Error('缺声明标记的阻塞必须给出完整可执行命令(node "<脚本路径>" skill-load …):\n' + res.output);
|
|
865
|
+
}
|
|
866
|
+
// 协议上下文随命令走:本夹具的协议来自环境变量(不是内置默认),照抄时不带 --protocol 会
|
|
867
|
+
// 解析到另一份协议(状态命令族只认 CLI → env → 内置默认,没有第二来源)。
|
|
868
|
+
if (!command.includes('--protocol "reference/workflow-protocol.json"')) {
|
|
869
|
+
throw new Error('声明命令缺协议上下文(照抄会解析到内置默认协议,而不是本次运行的那份): ' + command);
|
|
870
|
+
}
|
|
871
|
+
printedCommandReplay(dir, '记录侧声明')(command);
|
|
872
|
+
const recorded = runStateWithProtocol(dir, ['record', 'open', payload]);
|
|
873
|
+
assertExit(recorded, 0);
|
|
874
|
+
assertOut(recorded, 'EVIDENCE: open');
|
|
133
875
|
},
|
|
134
876
|
},
|
|
135
877
|
|
|
@@ -163,62 +905,233 @@ export const ENTRIES = [
|
|
|
163
905
|
},
|
|
164
906
|
},
|
|
165
907
|
|
|
166
|
-
// 102: exit 协议声明标记校验(AC-4)+
|
|
167
|
-
//
|
|
168
|
-
//
|
|
169
|
-
//
|
|
170
|
-
//
|
|
908
|
+
// 102: exit 协议声明标记校验(AC-4)+ 真实链路集成。判定从「任一命中即通过」改为「全部覆盖」:
|
|
909
|
+
// 节点该读的每个协议文件(NODE_PROTOCOL_FILES,open = 0-change / 1-requirement)都必须被某个标记
|
|
910
|
+
// 覆盖,协议声明的 requiredSkillCalls(enforcement=guarded)也各自要有标记。新 change 缺任一 →
|
|
911
|
+
// BLOCKED 并逐项点名缺哪个协议文件 / 哪个必需技能;旧 change → WARN 渐进(既有 change 不卡死)。
|
|
912
|
+
// 旧单值标记(只有 protocol、没有 protocols)照样计入覆盖——旧写入形态不被新规则判死。
|
|
913
|
+
// ⑧ 另补一格出口**链序**(见该格头注):同一个「缺声明」既表现为证据清单缺 required-skill、也
|
|
914
|
+
// 表现为标记没覆盖必需项,两段报文的先后是链序的直接读数。
|
|
171
915
|
{
|
|
172
|
-
name: '102 exit
|
|
916
|
+
name: '102 exit 协议标记校验:全部覆盖通过 / 少声明必红点名 / 旧 change 只 WARN / 旧单值标记可读 / 证据门先于覆盖门(AC-4)',
|
|
173
917
|
run: (dir) => {
|
|
174
|
-
const
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
918
|
+
const loadsDir = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
|
|
919
|
+
const markerFile = (skill) => path.join(loadsDir, 'open-' + skill + '.json');
|
|
920
|
+
const readMarker = (skill) => JSON.parse(fs.readFileSync(markerFile(skill), 'utf8'));
|
|
921
|
+
// 新 change 夹具(init 标记 = newChange:true)+ entry 已记录(否则先被 entry 记录门拦下,
|
|
922
|
+
// 测不到声明门本身)
|
|
923
|
+
const newChangeState = () => {
|
|
924
|
+
const st = baseState('open');
|
|
925
|
+
st.evidence.open = { summary: 'intake complete' };
|
|
926
|
+
st.enteredNodes = ['open'];
|
|
927
|
+
return st;
|
|
928
|
+
};
|
|
929
|
+
writeState(dir, newChangeState());
|
|
930
|
+
// 新 change 下入口文档另有首部门(Change ID 必在场)——夹具让它在场,才能把断言收敛到声明门上
|
|
931
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md',
|
|
932
|
+
'# CHANGE: 声明门夹具\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## Why\n\n夹具。\n\n## 范围\n');
|
|
933
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md',
|
|
934
|
+
'# REQUIREMENT: 声明门夹具\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## 用户故事\n\n- US-1\n\n## 验收准则(AC)\n\n- Given a When b Then c\n');
|
|
179
935
|
// 场景内 flow-kit/prompts/ 提示文件(真实 skill-load --prompt 指向——归属校验仅查前缀不读内容)
|
|
180
936
|
writeFile(dir, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
// ① 机制已激活(.skill-loads/ 存在)但无 open-* 标记(仅他节点标记)→ BLOCKED
|
|
937
|
+
writeFile(dir, 'flow-kit/prompts/1-requirement.md', '# 阶段 1 · REQUIREMENT\n\n## 角色\n\n你是 Requirer。\n');
|
|
938
|
+
// ① 机制已激活(.skill-loads/ 存在)但无 open-* 标记(仅他节点标记)→ BLOCKED,逐项点名
|
|
184
939
|
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/design-flow-comet-design.json',
|
|
185
940
|
JSON.stringify({ node: 'design', skill: 'flow-comet-design', protocol: '2-design.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
|
|
186
|
-
const
|
|
187
|
-
assertExit(
|
|
188
|
-
assertOut(
|
|
189
|
-
assertOut(
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
941
|
+
const resNoMarker = runGuard(['exit', 'open'], dir);
|
|
942
|
+
assertExit(resNoMarker, 1);
|
|
943
|
+
assertOut(resNoMarker, 'BLOCKED');
|
|
944
|
+
assertOut(resNoMarker, 'exit 缺协议声明标记');
|
|
945
|
+
assertOut(resNoMarker, '缺协议文件: 0-change.md、1-requirement.md');
|
|
946
|
+
assertOut(resNoMarker, '缺必需技能声明: flow-comet-change、flow-comet-requirement');
|
|
947
|
+
// ② 少声明(新 change,真实链路)——只声明一个协议文件、只覆盖一个必需技能 → BLOCKED 并
|
|
948
|
+
// 逐项点名缺哪个协议文件、哪个必需技能。缺陷形态:门禁把「该读的协议清单」当允许集合、
|
|
949
|
+
// 任一命中即通过 → 这条会 exit 0(第二个声明被静默丢弃,覆盖缺口看不见)
|
|
950
|
+
assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--prompt', 'flow-kit/prompts/0-change.md', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
|
|
951
|
+
const resPartial = runGuard(['exit', 'open'], dir);
|
|
952
|
+
assertExit(resPartial, 1);
|
|
953
|
+
assertOut(resPartial, 'BLOCKED');
|
|
954
|
+
assertOut(resPartial, 'exit 缺协议声明标记');
|
|
955
|
+
assertOut(resPartial, '缺协议文件: 1-requirement.md');
|
|
956
|
+
assertOut(resPartial, '缺必需技能声明: flow-comet-requirement');
|
|
957
|
+
assertNotOut(resPartial, 'ALL CHECKS PASSED');
|
|
958
|
+
// ③ 全部声明(新 change,真实链路)→ exit 通过。一条命令多个 --prompt:两份协议都记进同一个
|
|
959
|
+
// 标记的 protocols 数组(protocol 保留首个 basename 供旧读法)
|
|
960
|
+
assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--prompt', 'flow-kit/prompts/0-change.md', '--prompt', 'flow-kit/prompts/1-requirement.md', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
|
|
961
|
+
const multiMarker = readMarker('flow-comet-change');
|
|
962
|
+
if (multiMarker.protocol !== '0-change.md' || !Array.isArray(multiMarker.protocols)
|
|
963
|
+
|| multiMarker.protocols.join(',') !== '0-change.md,1-requirement.md') {
|
|
964
|
+
throw new Error('多 --prompt 应全部记入 protocols 且 protocol 保留首个: ' + JSON.stringify(multiMarker));
|
|
198
965
|
}
|
|
966
|
+
assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-requirement', '--prompt', 'flow-kit/prompts/1-requirement.md', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
|
|
199
967
|
const resPass = runGuard(['exit', 'open'], dir);
|
|
200
968
|
assertExit(resPass, 0);
|
|
201
969
|
assertOut(resPass, 'ALL CHECKS PASSED');
|
|
202
970
|
assertNotOut(resPass, 'BLOCKED');
|
|
203
|
-
|
|
204
|
-
//
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
971
|
+
assertNotOut(resPass, 'SKILL-LOAD WARN');
|
|
972
|
+
// ④ 旧单值标记仍可读——只有 protocol、没有 protocols 的两条标记(收紧前的写入形态)各覆盖
|
|
973
|
+
// 一份协议文件:覆盖判据照样把它们算进去 → exit 通过
|
|
974
|
+
fs.rmSync(loadsDir, { recursive: true, force: true });
|
|
975
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
|
|
976
|
+
JSON.stringify({ node: 'open', skill: 'flow-comet-change', protocol: '0-change.md', templates: ['CHANGE', 'REQUIREMENT'], at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
|
|
977
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-requirement.json',
|
|
978
|
+
JSON.stringify({ node: 'open', skill: 'flow-comet-requirement', protocol: '1-requirement.md', templates: ['CHANGE', 'REQUIREMENT'], at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
|
|
979
|
+
const resLegacy = runGuard(['exit', 'open'], dir);
|
|
980
|
+
assertExit(resLegacy, 0);
|
|
981
|
+
assertOut(resLegacy, 'ALL CHECKS PASSED');
|
|
982
|
+
assertNotOut(resLegacy, 'BLOCKED');
|
|
983
|
+
// ⑤ 旧状态带 newChange 字段(升级前的 init 产物):同样的「少声明」构造 → 同判 BLOCKED
|
|
984
|
+
// (字段只被忽略,不再有渐进放行),报文与 ② 同样逐项点名
|
|
985
|
+
const legacyState = baseState('open');
|
|
986
|
+
legacyState.evidence.open = { summary: 'intake complete' };
|
|
987
|
+
legacyState.enteredNodes = ['open'];
|
|
988
|
+
legacyState.newChange = true;
|
|
989
|
+
writeState(dir, legacyState);
|
|
990
|
+
fs.rmSync(loadsDir, { recursive: true, force: true });
|
|
991
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
|
|
992
|
+
JSON.stringify({ node: 'open', skill: 'flow-comet-change', protocol: '0-change.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
|
|
993
|
+
const resWarn = runGuard(['exit', 'open'], dir);
|
|
994
|
+
assertExit(resWarn, 1);
|
|
995
|
+
assertOut(resWarn, 'BLOCKED');
|
|
996
|
+
assertOut(resWarn, '缺协议文件: 1-requirement.md');
|
|
997
|
+
assertOut(resWarn, '缺必需技能声明: flow-comet-requirement');
|
|
998
|
+
assertNotOut(resWarn, 'SKILL-LOAD WARN');
|
|
999
|
+
// ⑥ 未传 --prompt(protocol = null / protocols 空)→ 两个必需技能都在场,但没有协议文件被
|
|
1000
|
+
// 覆盖 → BLOCKED(fail-closed:声明了技能不等于读了两份协议)
|
|
1001
|
+
writeState(dir, newChangeState());
|
|
1002
|
+
fs.rmSync(loadsDir, { recursive: true, force: true });
|
|
1003
|
+
assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
|
|
1004
|
+
assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-requirement', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
|
|
1005
|
+
const markerNull = readMarker('flow-comet-change');
|
|
1006
|
+
if (markerNull.protocol !== null || !Array.isArray(markerNull.protocols) || markerNull.protocols.length !== 0) {
|
|
1007
|
+
throw new Error('未传 --prompt 时 protocol 应为 null、protocols 应为空数组: ' + JSON.stringify(markerNull));
|
|
210
1008
|
}
|
|
211
1009
|
const resNull = runGuard(['exit', 'open'], dir);
|
|
212
1010
|
assertExit(resNull, 1);
|
|
213
1011
|
assertOut(resNull, 'BLOCKED');
|
|
214
1012
|
assertOut(resNull, 'exit 缺协议声明标记');
|
|
215
|
-
|
|
1013
|
+
assertOut(resNull, '缺协议文件: 0-change.md、1-requirement.md');
|
|
1014
|
+
assertNotOut(resNull, '缺必需技能声明');
|
|
1015
|
+
// ⑦ 损坏标记(protocol / protocols 均非协议集 basename)→ 该文件不算被覆盖 → BLOCKED
|
|
216
1016
|
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');
|
|
1017
|
+
JSON.stringify({ node: 'open', skill: 'flow-comet-change', protocol: '9-other.md', protocols: ['9-other.md'], at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
|
|
1018
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-requirement.json',
|
|
1019
|
+
JSON.stringify({ node: 'open', skill: 'flow-comet-requirement', protocol: '1-requirement.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
|
|
218
1020
|
const resCorrupt = runGuard(['exit', 'open'], dir);
|
|
219
1021
|
assertExit(resCorrupt, 1);
|
|
220
1022
|
assertOut(resCorrupt, 'BLOCKED');
|
|
221
1023
|
assertOut(resCorrupt, 'exit 缺协议声明标记');
|
|
1024
|
+
assertOut(resCorrupt, '缺协议文件: 0-change.md');
|
|
1025
|
+
assertNotOut(resCorrupt, '缺必需技能声明');
|
|
1026
|
+
// ⑧ 出口链序:同一个「缺声明」既可能是证据清单缺 required-skill(证据门的报文给出该绑定的
|
|
1027
|
+
// 补齐命令),也可能是声明标记没覆盖必需项(覆盖门逐项点名缺哪个技能)。两者都说同一件事
|
|
1028
|
+
// 时,证据门必须先说话、覆盖门收口——颠倒顺序会让执行者只看到「缺协议声明标记」,看不到
|
|
1029
|
+
// 证据门指出的那条绑定。反向构造:把 workflow-guard 出口链上的两处调用对调(覆盖门排到
|
|
1030
|
+
// 证据族之前)→ 本格第一趟先报覆盖门 → 本格 RED。
|
|
1031
|
+
// 两段报文**不可能**同处一趟输出(任一命中即 process.exit),故按两趟真实顺序断言:第一趟
|
|
1032
|
+
// 只有证据门说话,补齐证据后第二趟才轮到覆盖门;「行序」取两趟输出拼接后的位置。
|
|
1033
|
+
// 夹具根独立(design 出口夹具与前七格的 open 夹具互不污染),协议副本按套件同一表达式预置。
|
|
1034
|
+
const chainRoot = makeTmp();
|
|
1035
|
+
try {
|
|
1036
|
+
fs.mkdirSync(path.dirname(scenarioProtocolPath(chainRoot)), { recursive: true });
|
|
1037
|
+
fs.copyFileSync(BUILTIN_PROTOCOL_SOURCE, scenarioProtocolPath(chainRoot));
|
|
1038
|
+
writeDesignExitFixture(chainRoot, {
|
|
1039
|
+
visualTone: VISUAL_TONE_APPLICABLE, uiDesign: true, declareUiDesign: false,
|
|
1040
|
+
});
|
|
1041
|
+
// 先写一条真实声明(design 技能 + 2-design.md):机制已激活,缺口收敛到 ui-design 这一条绑定
|
|
1042
|
+
assertExit(runState(['skill-load', 'design', 'flow-comet-design', '--prompt', 'flow-kit/prompts/2-design.md', '--templates', 'DESIGN.md'], chainRoot), 0);
|
|
1043
|
+
const bothMissing = runGuard(['exit', 'design'], chainRoot);
|
|
1044
|
+
assertExit(bothMissing, 1);
|
|
1045
|
+
assertOut(bothMissing, 'BLOCKED: missing required Skill evidence: required-skill:design.flow-comet-ui-design');
|
|
1046
|
+
assertNotOut(bothMissing, '缺协议声明标记');
|
|
1047
|
+
// 第二趟:证据补齐(同一夹具的 declareUiDesign),声明覆盖仍缺 → 覆盖门收口并点名该技能
|
|
1048
|
+
writeDesignExitFixture(chainRoot, {
|
|
1049
|
+
visualTone: VISUAL_TONE_APPLICABLE, uiDesign: true, declareUiDesign: true,
|
|
1050
|
+
});
|
|
1051
|
+
const markerMissing = runGuard(['exit', 'design'], chainRoot);
|
|
1052
|
+
assertExit(markerMissing, 1);
|
|
1053
|
+
assertOut(markerMissing, '缺协议声明标记');
|
|
1054
|
+
assertOut(markerMissing, '缺必需技能声明: flow-comet-ui-design');
|
|
1055
|
+
// 本格的核心断言:两段报文都在场,且「证据门」那段的行序早于「缺协议声明标记」那行——覆盖门
|
|
1056
|
+
// 的报文出现即证明链条已越过证据门(证据门命中会 process.exit,覆盖门就不会有输出)。
|
|
1057
|
+
const chainText = bothMissing.output + '\n' + markerMissing.output;
|
|
1058
|
+
const evidenceAt = chainText.indexOf('missing required Skill evidence');
|
|
1059
|
+
const markerAt = chainText.indexOf('缺协议声明标记');
|
|
1060
|
+
if (evidenceAt < 0 || markerAt < 0 || evidenceAt > markerAt) {
|
|
1061
|
+
throw new Error('链序:证据门报文应在「缺协议声明标记」之前(两段报文都必须在场): '
|
|
1062
|
+
+ JSON.stringify({ evidenceAt, markerAt }));
|
|
1063
|
+
}
|
|
1064
|
+
} finally {
|
|
1065
|
+
cleanupTmpDir(chainRoot);
|
|
1066
|
+
}
|
|
1067
|
+
// ⑨ 恢复段命令的照抄闭合(本场景的核心扩展;不新增场景条目):open 与 review 各删声明与证据 →
|
|
1068
|
+
// exit 被拦 → **逐字照抄**报文给出的每条命令 → 同一 exit 通过。缺陷形态:恢复段第一步只声明
|
|
1069
|
+
// 实现技能 + 首份协议、且不带模板清单(声明覆盖门的补齐命令则只给缺项、同样漏模板),照抄完
|
|
1070
|
+
// 同一 exit 仍被覆盖门点名缺另一份协议文件与另一个必需技能——两处各给一半。
|
|
1071
|
+
assertDeclarationRecoveryRoundTrip({
|
|
1072
|
+
node: 'open',
|
|
1073
|
+
skills: ['flow-comet-change', 'flow-comet-requirement'],
|
|
1074
|
+
prompts: ['flow-kit/prompts/0-change.md', 'flow-kit/prompts/1-requirement.md'],
|
|
1075
|
+
templates: ['CHANGE.md', 'REQUIREMENT.md'],
|
|
1076
|
+
fixture: (root) => {
|
|
1077
|
+
const st = newChangeState();
|
|
1078
|
+
delete st.evidence.open; // 证据整体缺席:恢复段必须把「先声明」这一步一并给全
|
|
1079
|
+
writeState(root, st);
|
|
1080
|
+
writeFile(root, '.specs/' + CHANGE_ID + '/CHANGE.md',
|
|
1081
|
+
'# CHANGE: 声明门夹具\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## Why\n\n夹具。\n\n## 范围\n');
|
|
1082
|
+
writeFile(root, '.specs/' + CHANGE_ID + '/REQUIREMENT.md',
|
|
1083
|
+
'# REQUIREMENT: 声明门夹具\n\n- **Change ID**: ' + CHANGE_ID
|
|
1084
|
+
+ '\n\n## 用户故事\n\n- US-1\n\n## 验收准则(AC)\n\n- Given a When b Then c\n');
|
|
1085
|
+
writeFile(root, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
|
|
1086
|
+
writeFile(root, 'flow-kit/prompts/1-requirement.md', '# 阶段 1 · REQUIREMENT\n\n## 角色\n\n你是 Requirer。\n');
|
|
1087
|
+
},
|
|
1088
|
+
});
|
|
1089
|
+
assertDeclarationRecoveryRoundTrip({
|
|
1090
|
+
node: 'review',
|
|
1091
|
+
skills: ['flow-comet-review', 'flow-comet-test'],
|
|
1092
|
+
prompts: ['flow-kit/prompts/6-review.md', 'flow-kit/prompts/5-test.md'],
|
|
1093
|
+
templates: ['REVIEW.md', 'TEST.md'],
|
|
1094
|
+
fixture: (root) => {
|
|
1095
|
+
const st = baseState('review');
|
|
1096
|
+
st.enteredNodes = ['review'];
|
|
1097
|
+
writeState(root, st);
|
|
1098
|
+
writeFile(root, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
1099
|
+
'# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题B**: 某处问题 **[已修]**\n'
|
|
1100
|
+
+ ' - **Symptom**: 具体现象\n - **Source**: 某书某节\n'
|
|
1101
|
+
+ ' - **Consequence**: 若不修会怎样\n - **Remedy**: 怎么改\n\n## 结论\n\n通过\n');
|
|
1102
|
+
writeFile(root, 'flow-kit/prompts/6-review.md', '# 阶段 6 · REVIEW\n\n## 角色\n\n你是 Reviewer。\n');
|
|
1103
|
+
writeFile(root, 'flow-kit/prompts/5-test.md', '# 阶段 5 · TEST\n\n## 角色\n\n你是 Tester。\n');
|
|
1104
|
+
},
|
|
1105
|
+
});
|
|
1106
|
+
// ⑩ 前端 design 的证据门照抄闭合(不新增场景条目):证据缺一条 gated 绑定(ui-design)时,
|
|
1107
|
+
// 恢复段必须给全「真实声明 + 带该 required-skill 的 record」两步,照抄后同一 exit 通过。
|
|
1108
|
+
assertFrontendDesignEvidenceRoundTrip();
|
|
1109
|
+
// ⑪ 入口 --prompt 冲突报文的照抄闭合(同一缺陷的第三面:报文与门禁判据不是同一份派生)。
|
|
1110
|
+
assertEntryConflictRecoveryRoundTrip();
|
|
1111
|
+
// ⑫ **标记目录整体被删**:旧口径把它读成「声明机制未激活」→ 跳过校验(对新 change 也印
|
|
1112
|
+
// 「旧 change 兼容」),于是 `rm -rf .skill-loads/` 就是关掉覆盖判据的写法。新 change
|
|
1113
|
+
// 下目录缺席 = 一项声明都没有:按缺声明 BLOCKED 并逐项点名(同一条判据的两半——
|
|
1114
|
+
// 「目录在但没覆盖」与「目录根本不在」不该有两种放行)。旧 change 的过渡规则不变
|
|
1115
|
+
// (渐进 WARN,且只有那一支才叫「旧 change 兼容」)。
|
|
1116
|
+
writeState(dir, newChangeState());
|
|
1117
|
+
fs.rmSync(loadsDir, { recursive: true, force: true });
|
|
1118
|
+
const resNoLoadsDir = runGuard(['exit', 'open'], dir);
|
|
1119
|
+
assertExit(resNoLoadsDir, 1);
|
|
1120
|
+
assertOut(resNoLoadsDir, 'BLOCKED');
|
|
1121
|
+
assertOut(resNoLoadsDir, 'exit 缺协议声明标记');
|
|
1122
|
+
assertOut(resNoLoadsDir, '缺协议文件: 0-change.md、1-requirement.md');
|
|
1123
|
+
assertOut(resNoLoadsDir, '缺必需技能声明: flow-comet-change、flow-comet-requirement');
|
|
1124
|
+
assertOut(resNoLoadsDir, '恢复: 照抄下面的命令补齐上述缺项');
|
|
1125
|
+
assertNotOut(resNoLoadsDir, '旧 change 兼容');
|
|
1126
|
+
assertNotOut(resNoLoadsDir, 'ALL CHECKS PASSED');
|
|
1127
|
+
// ⑫b 同一形态(无任何新旧标记字段)→ 同判 BLOCKED(单轨:目录缺席 = 一项都没声明)
|
|
1128
|
+
writeState(dir, legacyState);
|
|
1129
|
+
const resNoLoadsDirOld = runGuard(['exit', 'open'], dir);
|
|
1130
|
+
assertExit(resNoLoadsDirOld, 1);
|
|
1131
|
+
assertOut(resNoLoadsDirOld, 'BLOCKED');
|
|
1132
|
+
assertOut(resNoLoadsDirOld, '缺协议文件: 0-change.md、1-requirement.md');
|
|
1133
|
+
assertNotOut(resNoLoadsDirOld, '旧 change 兼容');
|
|
1134
|
+
assertNotOut(resNoLoadsDirOld, 'ALL CHECKS PASSED');
|
|
222
1135
|
},
|
|
223
1136
|
},
|
|
224
1137
|
|
|
@@ -238,48 +1151,171 @@ export const ENTRIES = [
|
|
|
238
1151
|
},
|
|
239
1152
|
},
|
|
240
1153
|
|
|
241
|
-
// 104: 旧 evidence
|
|
242
|
-
// 无 completedChecks
|
|
243
|
-
//
|
|
1154
|
+
// 104: 旧 evidence 格式兼容(AC-6)——声明齐备时,旧格式记录(completedChecks 无
|
|
1155
|
+
// required-skill 条目 / 无 completedChecks)照常通过,exit 也照常通过。声明缺席不再因
|
|
1156
|
+
// 「旧 change」放行(单轨;负例见 120)。
|
|
244
1157
|
{
|
|
245
|
-
name: '104 旧 evidence
|
|
1158
|
+
name: '104 旧 evidence 格式兼容:声明齐备时旧格式记录照常通过(AC-6)',
|
|
246
1159
|
run: (dir) => {
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
1160
|
+
const st = baseState('open');
|
|
1161
|
+
st.enteredNodes = ['open'];
|
|
1162
|
+
writeState(dir, st);
|
|
1163
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', intakeChangeText());
|
|
1164
|
+
writeFile(dir, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
|
|
1165
|
+
writeFile(dir, 'flow-kit/prompts/1-requirement.md', '# 阶段 1 · REQUIREMENT\n\n## 角色\n\n你是 Requirer。\n');
|
|
1166
|
+
// 声明齐备(手动 skill-load 是唯一路径;模板清单按节点映射给全)
|
|
1167
|
+
assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change',
|
|
1168
|
+
'--prompt', 'flow-kit/prompts/0-change.md', '--prompt', 'flow-kit/prompts/1-requirement.md',
|
|
1169
|
+
'--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
|
|
1170
|
+
assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-requirement',
|
|
1171
|
+
'--prompt', 'flow-kit/prompts/1-requirement.md', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
|
|
1172
|
+
// ① 旧格式 record:completedChecks 无 required-skill 条目 → 照常通过
|
|
250
1173
|
const resA = runStateWithProtocol(dir, ['record', 'open', JSON.stringify({ summary: 'legacy', completedChecks: ['unit-tests'] })]);
|
|
251
1174
|
assertExit(resA, 0);
|
|
252
1175
|
assertOut(resA, 'EVIDENCE: open');
|
|
253
|
-
// ② 无 completedChecks 的纯 summary 记录 →
|
|
1176
|
+
// ② 无 completedChecks 的纯 summary 记录 → 照常通过
|
|
254
1177
|
const resB = runStateWithProtocol(dir, ['record', 'open', JSON.stringify({ summary: 'plain' })]);
|
|
255
1178
|
assertExit(resB, 0);
|
|
256
|
-
// ③ exit open
|
|
257
|
-
|
|
258
|
-
|
|
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');
|
|
1179
|
+
// ③ exit open:声明齐备 → 通过且无兼容告警
|
|
1180
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', intakeChangeText());
|
|
1181
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', intakeRequirementText());
|
|
262
1182
|
const resC = runGuard(['exit', 'open'], dir);
|
|
263
1183
|
assertExit(resC, 0);
|
|
264
1184
|
assertOut(resC, 'ALL CHECKS PASSED');
|
|
265
1185
|
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
1186
|
},
|
|
271
1187
|
},
|
|
272
1188
|
|
|
273
|
-
// 105: 计数一致性自检同步(AC-8 / AC-14
|
|
274
|
-
//
|
|
275
|
-
//
|
|
276
|
-
//
|
|
277
|
-
//
|
|
1189
|
+
// 105: 计数一致性自检同步(AC-8 / AC-14)+ 公开面机器字段名黑名单 + 结构预检命令锚 + 权威源设计
|
|
1190
|
+
// 形态锚(in-place 扩展,不新增场景)——组文件里的场景数或系统测试集项数变更时,受检文件须同步
|
|
1191
|
+
// (场景数:ALL n SCENARIOS PASSED / n scenarios / n 场景 / n/n 变体;项数:n/n / n items / n 项
|
|
1192
|
+
// 变体)。本场景读取权威源仓库的受检文件断言含当前计数变体——文档漏同步或条目缺失(幽灵条目)即
|
|
1193
|
+
// RED;与底部自检共用同一实现(countSyncProblems),两处判据不会漂移。
|
|
1194
|
+
// 公开面口径:用户阅读面不得直写机器状态字段名(黑名单),被明确标注为状态输出示例的围栏块
|
|
1195
|
+
// 放行;机制 / 用法 / 排障三份文档 × 中英都必须出现 `--preflight`(新增公开命令不得无锚)。
|
|
1196
|
+
// 判别力由反向构造证明:注入键名、抽掉命令锚 ⇒ 必报;标注示例块放行、撤掉标注 ⇒ 再报。
|
|
1197
|
+
// 形态分派(只按载体形态判,不猜):安装副本(无 .flow-comet/ 技能树)与分发包(技能树在、docs/ +
|
|
1198
|
+
// CONTRIBUTING.md + .github/ 三者俱缺)都没有公开文档面——跳过且**可见**(SKIP = 未校验,不是通过);
|
|
1199
|
+
// 只有权威源检出才跑公开面判据与设计形态锚。形态边界由 assertPublicFaceShapeProbes 自己钉住。
|
|
278
1200
|
{
|
|
279
|
-
name: '105
|
|
280
|
-
run: async () => {
|
|
281
|
-
|
|
282
|
-
|
|
1201
|
+
name: '105 计数一致性自检同步 + 公开面机器字段名黑名单 + --preflight 锚 + 声明命令册子锚 + 权威源设计形态锚(AC-8 / AC-14)',
|
|
1202
|
+
run: async (dir) => {
|
|
1203
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', strictSummary('P01'));
|
|
1204
|
+
// 声明命令的册子锚:不按载体形态分派(两册随技能包一起分发,装到哪都该给出同一组命令)——
|
|
1205
|
+
// 这也是「缺声明时报文给出的命令」与册子口径一致的那条机检(两边各给一半时必有一侧缺锚)。
|
|
1206
|
+
const bookProblems = declarationBookProblems(path.join(SCRIPTS_DIR, '..'));
|
|
1207
|
+
if (bookProblems.length > 0) throw new Error(bookProblems.join(';'));
|
|
1208
|
+
// 权威源判定走 lib 的同一份探针(authoritativeSourceAt:与真实检出同一技能树锚,可带受检根)——
|
|
1209
|
+
// 本场景不再自持一份前置判定,形态问题只有一处说了算。
|
|
1210
|
+
if (!authoritativeSourceAt()) {
|
|
1211
|
+
// 安装副本:无公开文档面,也无「权威源打印设计形态」这回事——跳过必须可见。
|
|
1212
|
+
console.log('SKIP: 公开面与设计形态判据(安装副本检出:本检出无 .flow-comet/skills/flow-comet/SKILL.md)'
|
|
1213
|
+
+ '——本次未校验公开面键名黑名单 / 命令锚,也未校验恢复命令的脚本路径是否为权威源设计形态'
|
|
1214
|
+
+ '(SKIP = 未校验,不是通过)');
|
|
1215
|
+
return;
|
|
1216
|
+
}
|
|
1217
|
+
// 形态判据自己的判别力(纯夹具,先于任何派生)
|
|
1218
|
+
assertPublicFaceShapeProbes(dir);
|
|
1219
|
+
// 设计形态锚:只读打印出来的恢复段,要求命令的脚本路径逐字为设计形态、步骤按执行顺序。仅在
|
|
1220
|
+
// **正在跑权威源脚本**时适用;
|
|
1221
|
+
// 跑安装副本套件时,副本按运行根推导出的路径才是那种载体的正确形态,不属于本锚范围——跳过必须可见。
|
|
1222
|
+
if (RUNS_FROM_AUTHORITATIVE_SCRIPTS) {
|
|
1223
|
+
assertDesignFormRecoveryPath(dir);
|
|
1224
|
+
} else {
|
|
1225
|
+
console.log('SKIP: 权威源设计形态锚(当前运行的是安装副本脚本:' + path.relative(REPO_ROOT, SCRIPTS_DIR)
|
|
1226
|
+
+ ')——安装副本按运行根推导路径属另一种载体的正确形态,本锚只在权威源脚本下适用(SKIP = 未校验,不是通过)');
|
|
1227
|
+
}
|
|
1228
|
+
// 分发包形态(npm 包 / 安装副本):公开面载体三者俱缺(docs/ + CONTRIBUTING.md + .github/)⇒
|
|
1229
|
+
// 公开面无从派生,也就无从检查。跳过的就是**公开面这一整块**(含计数同步——它数的文件同样不随
|
|
1230
|
+
// 包分发);计数面在底部自检里另有一次独立执行,不会因这条跳过而整体失踪。判据本体在 lib
|
|
1231
|
+
// (publicFaceDocsAbsent):只按 docs/ 在不在分流,会把「docs/ 被裁掉、其余公开面还在」的检出
|
|
1232
|
+
// 一并放过——那正是整块判据静默失效的形态。
|
|
1233
|
+
if (publicFaceDocsAbsent(REPO_ROOT)) {
|
|
1234
|
+
console.log(PUBLIC_FACE_SELF_CHECK_SKIP_NOTICE);
|
|
1235
|
+
return;
|
|
1236
|
+
}
|
|
1237
|
+
const problems = [...await countSyncProblems()];
|
|
1238
|
+
const publicFace = readPublicFaceTexts();
|
|
1239
|
+
problems.push(...publicFaceMachineProblems(publicFace));
|
|
1240
|
+
// 反向构造(同一判据驱动):探针在快照副本上作业,真实断言与探针调用同一个函数。
|
|
1241
|
+
const mutated = (rel, mutate) => {
|
|
1242
|
+
const text = publicFace.texts.get(rel);
|
|
1243
|
+
if (typeof text !== 'string') return null; // 缺失已由真实判据报告,避免探针掩盖真实原因
|
|
1244
|
+
const next = mutate(text);
|
|
1245
|
+
return next === text ? null : { ...publicFace, texts: new Map(publicFace.texts).set(rel, next) };
|
|
1246
|
+
};
|
|
1247
|
+
// 排障册的声明命令锚:真实断言与反向构造走同一判据实现(逐条抽掉 ⇒ 必报——少任何一条,
|
|
1248
|
+
// 照抄的人都会在同一次 exit 上被覆盖门点名缺那一项)。
|
|
1249
|
+
problems.push(...troubleshootingDeclarationProblems(publicFace.texts));
|
|
1250
|
+
for (const anchor of TROUBLESHOOTING_DECLARATION_ANCHORS) {
|
|
1251
|
+
const stripped = mutated('docs/TROUBLESHOOTING.md',
|
|
1252
|
+
(text) => text.split(anchor).join('(反向构造:抽掉)'));
|
|
1253
|
+
if (stripped !== null && troubleshootingDeclarationProblems(stripped.texts).length === 0) {
|
|
1254
|
+
throw new Error('反向构造判别力缺失(排障册:抽掉声明命令锚未被判缺): ' + anchor);
|
|
1255
|
+
}
|
|
1256
|
+
}
|
|
1257
|
+
// 受检面来自派生(映射 + 根目录扫描):按 GitHub 惯例放在根目录的公开文件若被漏在受检面之外,
|
|
1258
|
+
// 就没有注入点——这里直接判红,不让探针静默跳过。探针必须是**只有根目录扫描能贡献**的文件:
|
|
1259
|
+
// 映射已登记的路径(SECURITY.md 就由 security 主题提供)在根目录扫描缺席时仍在面内,取它做
|
|
1260
|
+
// 探针等于空断言,所以在选型处就对这条前提本身设防。
|
|
1261
|
+
const ROOT_FACE_PROBE = 'CODE_OF_CONDUCT.md';
|
|
1262
|
+
const mappedFacePaths = new Set([...publicFaceTopicPairs(readPublicFaceAuthorityMap()).values()].flat());
|
|
1263
|
+
if (mappedFacePaths.has(ROOT_FACE_PROBE)) {
|
|
1264
|
+
throw new Error('根目录探针失去判别力(' + ROOT_FACE_PROBE + ' 已由权威映射提供,'
|
|
1265
|
+
+ '根目录扫描缺席时它仍在受检面内)');
|
|
1266
|
+
}
|
|
1267
|
+
if (!publicFace.texts.has(ROOT_FACE_PROBE)) {
|
|
1268
|
+
throw new Error('受检面漏了根目录公开文档(' + ROOT_FACE_PROBE + ' 未纳入派生的受检面)');
|
|
1269
|
+
}
|
|
1270
|
+
const probes = [
|
|
1271
|
+
['注入机器字段名(用法册)', mutated('docs/USAGE.md', (text) => text + '\n`currentNode`\n'), '直写了机器状态字段名'],
|
|
1272
|
+
['注入 evidence 键名(机制册)', mutated('docs/MECHANISM.md', (text) => text + '\n`evidence`\n'), '直写了机器状态字段名 evidence'],
|
|
1273
|
+
// 散文形态(不带反引号):字段名不写反引号同样是把它当成用户面契约——这是黑名单原先的盲区
|
|
1274
|
+
['注入 evidence 散文名(机制册,不带反引号)',
|
|
1275
|
+
mutated('docs/MECHANISM.md', (text) => text + '\nthe evidence field is written by record\n'),
|
|
1276
|
+
'直写了机器状态字段名 evidence'],
|
|
1277
|
+
['注入 evidence 散文名(机制册,带反引号)',
|
|
1278
|
+
mutated('docs/MECHANISM.md', (text) => text + '\nthe `evidence` field is written by record\n'),
|
|
1279
|
+
'直写了机器状态字段名 evidence'],
|
|
1280
|
+
['注入字段族键名(机制册)', mutated('docs/MECHANISM.md', (text) => text + '\n`verifyFailuresByChange`\n'), '直写了机器状态字段名 verifyFailuresByChange'],
|
|
1281
|
+
['抽掉命令锚(排障册中文)', mutated('docs/TROUBLESHOOTING-zh.md', (text) => text.split('--preflight').join('')), '缺「--preflight」'],
|
|
1282
|
+
['注入机器字段名(根目录公开文档)', mutated(ROOT_FACE_PROBE, (text) => text + '\n`currentNode`\n'), '直写了机器状态字段名'],
|
|
1283
|
+
];
|
|
1284
|
+
for (const [label, texts, expected] of probes) {
|
|
1285
|
+
if (texts === null) continue;
|
|
1286
|
+
if (!publicFaceMachineProblems(texts).some((p) => p.includes(expected))) {
|
|
1287
|
+
throw new Error('反向构造判别力缺失(' + label + ' 未被判违规)');
|
|
1288
|
+
}
|
|
1289
|
+
}
|
|
1290
|
+
// 允许段白名单双向判别:同一段键名,标注为状态输出示例时放行,撤掉标注后必须报。
|
|
1291
|
+
const exampleBlock = (heading) => '\n' + heading + '\n\n```json\n{ "currentNode": "review" }\n```\n';
|
|
1292
|
+
const allowed = mutated('docs/MECHANISM.md', (text) => text + exampleBlock('### 状态输出示例'));
|
|
1293
|
+
if (allowed && publicFaceMachineProblems(allowed).some((p) => p.includes('docs/MECHANISM.md') && p.includes('直写了机器状态字段名'))) {
|
|
1294
|
+
throw new Error('允许段白名单失效(标注为状态输出示例的围栏块内键名被误判违规)');
|
|
1295
|
+
}
|
|
1296
|
+
const unmarked = mutated('docs/MECHANISM.md', (text) => text + exampleBlock('### 输出草稿'));
|
|
1297
|
+
if (unmarked && !publicFaceMachineProblems(unmarked).some((p) => p.includes('docs/MECHANISM.md') && p.includes('直写了机器状态字段名'))) {
|
|
1298
|
+
throw new Error('允许段白名单判别力缺失(未标注为状态输出示例的围栏块内键名未被判违规)');
|
|
1299
|
+
}
|
|
1300
|
+
// 黑名单扩容的判别力逐名验:加进数组不算数,每个名字都要真的命中——漏登记的键照样能走私进来。
|
|
1301
|
+
const WIDENED_KEYS = ['completedNodes', 'enteredNodes', 'directOverride', 'newChange'];
|
|
1302
|
+
const widened = mutated('docs/MECHANISM.md',
|
|
1303
|
+
(text) => text + '\n' + WIDENED_KEYS.map((name) => '`' + name + '`').join(' ') + '\n');
|
|
1304
|
+
for (const name of WIDENED_KEYS) {
|
|
1305
|
+
if (widened && !publicFaceMachineProblems(widened)
|
|
1306
|
+
.some((p) => p.includes('直写了机器状态字段名 ' + name))) {
|
|
1307
|
+
throw new Error('机器字段黑名单漏了 ' + name + '(注入后未被判违规)');
|
|
1308
|
+
}
|
|
1309
|
+
}
|
|
1310
|
+
// 放行规则的反向判别:黑名单扩容最容易砸到的既有句子——代码位置引用(state.evidence)与普通
|
|
1311
|
+
// 英文名词用法(the evidence recorded for the node)都必须放行,否则判据只能靠改文档来变绿。
|
|
1312
|
+
const released = mutated('docs/MECHANISM.md', (text) => text
|
|
1313
|
+
+ '\n位置引用:恢复记录写在 state.evidence 下。\n'
|
|
1314
|
+
+ '\nThe evidence recorded for the node is what the exit reads.\n');
|
|
1315
|
+
if (released && publicFaceMachineProblems(released)
|
|
1316
|
+
.some((p) => p.includes('docs/MECHANISM.md') && p.includes('直写了机器状态字段名'))) {
|
|
1317
|
+
throw new Error('放行规则失效(state.evidence 位置引用 / 普通英文 evidence 被误判为字段名直写)');
|
|
1318
|
+
}
|
|
283
1319
|
if (problems.length > 0) {
|
|
284
1320
|
throw new Error(problems.join('; '));
|
|
285
1321
|
}
|
|
@@ -287,44 +1323,57 @@ export const ENTRIES = [
|
|
|
287
1323
|
},
|
|
288
1324
|
|
|
289
1325
|
// 106: exit review——REVIEW.md 发现区条目处置状态结构级校验(L3-1:问题处理原则)——
|
|
290
|
-
// 发现项(含 Minor)无处置状态标记([已修]/[升级]/[转待办])→
|
|
291
|
-
//
|
|
292
|
-
// (发现不得"记录后无声消失"——每条须有处置去向)
|
|
1326
|
+
// 发现项(含 Minor)无处置状态标记([已修]/[升级]/[转待办])→ BLOCKED(单一等级);
|
|
1327
|
+
// 全部带标记且有裁决/判据 → 通过(发现不得"记录后无声消失"——每条须有处置去向)
|
|
293
1328
|
{
|
|
294
|
-
name: '106 exit review
|
|
1329
|
+
name: '106 exit review BLOCKED:发现区条目缺处置状态标记(L3-1)',
|
|
295
1330
|
run: (dir) => {
|
|
296
1331
|
const st = baseState('review');
|
|
297
1332
|
st.evidence.review = { summary: 'review done' };
|
|
298
1333
|
writeState(dir, st);
|
|
299
|
-
|
|
1334
|
+
writeNodeDeclarationMarkers(dir, 'review');
|
|
1335
|
+
// ②④ 共用:本夹具下允许出现的 REVIEW WARN 类别由调用方逐条枚举,**枚举外的行一律算失败**——
|
|
1336
|
+
// 逐条 assertNotOut 只挡得住被点名的那一类,夹具上再冒出一类无关告警时不会红(判别力退化)。
|
|
1337
|
+
const reviewWarnsOutside = (res, allowed) => String(res.output || '').split(/\r?\n/)
|
|
1338
|
+
.filter((line) => line.includes('REVIEW WARN') && !allowed.some((marker) => line.includes(marker)));
|
|
1339
|
+
// ① 发现区 Minor 条目无处置标记 → BLOCKED(点名缺处置状态标记)
|
|
300
1340
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
301
1341
|
'# 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
1342
|
const res = runGuard(['exit', 'review'], dir);
|
|
303
|
-
assertExit(res,
|
|
304
|
-
assertOut(res, '
|
|
305
|
-
assertOut(res, '
|
|
306
|
-
// ② 同一条目带 [转待办]
|
|
1343
|
+
assertExit(res, 1);
|
|
1344
|
+
assertOut(res, 'BLOCKED');
|
|
1345
|
+
assertOut(res, '处置状态标记');
|
|
1346
|
+
// ② 同一条目带 [转待办] → 处置门通过,但延期须有用户裁决 → BLOCKED(不报「缺处置状态标记」)
|
|
307
1347
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
308
1348
|
'# 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
1349
|
const res2 = runGuard(['exit', 'review'], dir);
|
|
310
|
-
assertExit(res2,
|
|
311
|
-
|
|
312
|
-
|
|
1350
|
+
assertExit(res2, 1);
|
|
1351
|
+
assertOut(res2, '缺少用户裁决记录');
|
|
1352
|
+
assertNotOut(res2, '缺处置状态标记');
|
|
1353
|
+
assertNotOut(res2, '处置状态标记');
|
|
313
1354
|
// ③ 有序条目(1. **...**)与无序同口径——缺处置标记 → 旧 change 仍渐进 REVIEW WARN
|
|
314
1355
|
// (修复前 .filter((item) => !item.ordered) 使有序条目静默通过 = RED)
|
|
315
1356
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
316
1357
|
'# REVIEW\n\n## 发现\n\n1. **m-2 · 有序未处置**:某处问题,未给出任何处置结论,描述足够长以避免内容不足\n\n## 结论\n\n通过\n');
|
|
317
1358
|
const resOrdered = runGuard(['exit', 'review'], dir);
|
|
318
|
-
assertExit(resOrdered,
|
|
319
|
-
assertOut(resOrdered, '
|
|
320
|
-
|
|
321
|
-
// ④ 有序 Minor 带 [转待办] →
|
|
1359
|
+
assertExit(resOrdered, 1);
|
|
1360
|
+
assertOut(resOrdered, 'BLOCKED');
|
|
1361
|
+
assertOut(resOrdered, '处置状态标记');
|
|
1362
|
+
// ④ 有序 Minor 带 [转待办] → 无「缺处置状态标记」告警(有序条目接入校验不误报已处置项)
|
|
322
1363
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
323
1364
|
'# REVIEW\n\n## 发现\n\n1. **m-3 · 有序小项**:某处小问题,已登记下一 change 跟踪处置 [转待办]\n\n## 结论\n\n通过\n');
|
|
324
1365
|
const resOrderedOk = runGuard(['exit', 'review'], dir);
|
|
325
|
-
assertExit(resOrderedOk,
|
|
326
|
-
|
|
327
|
-
|
|
1366
|
+
assertExit(resOrderedOk, 1);
|
|
1367
|
+
assertOut(resOrderedOk, '缺少用户裁决记录');
|
|
1368
|
+
assertNotOut(resOrderedOk, '处置状态标记');
|
|
1369
|
+
// ⑤ 处置齐备的正例:Minor 带 [已修] 且条目内自证「判 Minor:」→ 通过
|
|
1370
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
|
|
1371
|
+
'# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-4 · 已修小项**:某处小问题 [已修]\n 判 Minor:仅影响日志措辞,不改变行为与接口\n\n## 结论\n\n通过\n');
|
|
1372
|
+
const resAllDisposed = runGuard(['exit', 'review'], dir);
|
|
1373
|
+
assertExit(resAllDisposed, 0);
|
|
1374
|
+
assertOut(resAllDisposed, 'ALL CHECKS PASSED');
|
|
1375
|
+
assertTrue(reviewWarnsOutside(resAllDisposed, []).length === 0,
|
|
1376
|
+
'⑤ 处置齐备时不应出现任何 REVIEW WARN:\n' + reviewWarnsOutside(resAllDisposed, []).join('\n'));
|
|
328
1377
|
},
|
|
329
1378
|
},
|
|
330
1379
|
|
|
@@ -395,10 +1444,11 @@ export const ENTRIES = [
|
|
|
395
1444
|
},
|
|
396
1445
|
|
|
397
1446
|
// 109: execute 出口校验——TASK done 任务 ↔ <id>-SUMMARY.md 存在——
|
|
398
|
-
// 缺任一 done 任务的 SUMMARY →
|
|
1447
|
+
// 缺任一 done 任务的 SUMMARY → BLOCKED(单一等级);齐全 → 通过
|
|
399
1448
|
{
|
|
400
|
-
name: '109 execute exit:done 任务缺 SUMMARY →
|
|
1449
|
+
name: '109 execute exit:done 任务缺 SUMMARY → BLOCKED',
|
|
401
1450
|
run: (dir) => {
|
|
1451
|
+
writeNodeDeclarationMarkers(dir, 'execute');
|
|
402
1452
|
const st = baseState('execute');
|
|
403
1453
|
st.evidence.execute = { summary: 'execute done' };
|
|
404
1454
|
st.executionMode = 'direct'; // direct:串行任务主代理直写,不要求 handoff(聚焦产物完整性校验)
|
|
@@ -407,15 +1457,14 @@ export const ENTRIES = [
|
|
|
407
1457
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' +
|
|
408
1458
|
'<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
1459
|
'<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 缺)→
|
|
411
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/T02-SUMMARY.md',
|
|
1460
|
+
// ① 只有 T02-SUMMARY.md(T01 缺)→ BLOCKED 点名 T01-SUMMARY.md
|
|
1461
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T02-SUMMARY.md', strictSummary('T01'));
|
|
412
1462
|
const res = runGuard(['exit', 'execute'], dir);
|
|
413
|
-
assertExit(res,
|
|
414
|
-
assertOut(res, '
|
|
1463
|
+
assertExit(res, 1);
|
|
1464
|
+
assertOut(res, 'BLOCKED');
|
|
415
1465
|
assertOut(res, 'T01-SUMMARY.md');
|
|
416
|
-
assertOut(res, 'ALL CHECKS PASSED');
|
|
417
1466
|
// ② 补 T01-SUMMARY.md → 无缺产物 WARN(既有 SKILL-LOAD 兼容 WARN 与本文无关)
|
|
418
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
|
|
1467
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
|
|
419
1468
|
const res2 = runGuard(['exit', 'execute'], dir);
|
|
420
1469
|
assertExit(res2, 0);
|
|
421
1470
|
assertNotOut(res2, '缺少 T01-SUMMARY.md');
|
|
@@ -424,26 +1473,26 @@ export const ENTRIES = [
|
|
|
424
1473
|
},
|
|
425
1474
|
|
|
426
1475
|
// 110: execute 出口越权委托检测——TASK 有 parallel done 任务 + completedNodes
|
|
427
|
-
// 无 subagent-execute + 非 direct 模式 →
|
|
428
|
-
// execute 阶段完成 [P]
|
|
429
|
-
// subagent-execute 或 direct 模式 → 无越权 WARN
|
|
1476
|
+
// 无 subagent-execute + 非 direct 模式 → BLOCKED([P] 任务应由 subagent-execute 节点委托,
|
|
1477
|
+
// execute 阶段完成 [P] 是越权委托);completedNodes 含 subagent-execute → 放行
|
|
430
1478
|
{
|
|
431
|
-
name: '110 execute exit:parallel done 无 subagent-execute →
|
|
1479
|
+
name: '110 execute exit:parallel done 无 subagent-execute → BLOCKED 越权委托',
|
|
432
1480
|
run: (dir) => {
|
|
433
1481
|
const st = baseState('execute');
|
|
434
1482
|
st.evidence.execute = { summary: 'execute done' };
|
|
435
1483
|
st.completedNodes = ['open', 'design', 'plan', 'execute']; // subagent-execute 未 exit
|
|
436
1484
|
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['P01']) }; // 已委托(共用证据库)
|
|
437
1485
|
writeState(dir, st);
|
|
1486
|
+
writeNodeDeclarationMarkers(dir, 'execute');
|
|
438
1487
|
// TASK:parallel done P01 + 产物 SUMMARY(满足 task-summaries 出口门禁 + KI-8)
|
|
439
1488
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
|
|
440
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md',
|
|
441
|
-
// ① completedNodes 无 subagent-execute + 非 direct →
|
|
1489
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', strictSummary('T01'));
|
|
1490
|
+
// ① completedNodes 无 subagent-execute + 非 direct → BLOCKED(越权委托)
|
|
442
1491
|
const res = runGuard(['exit', 'execute'], dir);
|
|
443
|
-
assertExit(res,
|
|
1492
|
+
assertExit(res, 1);
|
|
1493
|
+
assertOut(res, 'BLOCKED');
|
|
444
1494
|
assertOut(res, '越权委托');
|
|
445
1495
|
assertOut(res, 'subagent-execute');
|
|
446
|
-
assertOut(res, 'ALL CHECKS PASSED');
|
|
447
1496
|
// ② completedNodes 含 subagent-execute → 无越权 WARN
|
|
448
1497
|
st.completedNodes = ['open', 'design', 'plan', 'execute', 'subagent-execute'];
|
|
449
1498
|
writeState(dir, st);
|
|
@@ -455,23 +1504,25 @@ export const ENTRIES = [
|
|
|
455
1504
|
},
|
|
456
1505
|
|
|
457
1506
|
// 111: verify 出口越权委托兜底检测——同 KI-10 判定(TASK parallel done +
|
|
458
|
-
// completedNodes 无 subagent-execute + 非 direct),verify 时仍未 exit →
|
|
459
|
-
// (execute 出口未拦截的兜底提示)
|
|
1507
|
+
// completedNodes 无 subagent-execute + 非 direct),verify 时仍未 exit → BLOCKED 兜底
|
|
460
1508
|
{
|
|
461
|
-
name: '111 verify exit:parallel done 无 subagent-execute →
|
|
1509
|
+
name: '111 verify exit:parallel done 无 subagent-execute → BLOCKED 越权委托兜底',
|
|
462
1510
|
run: (dir) => {
|
|
1511
|
+
writeNodeDeclarationMarkers(dir, 'verify');
|
|
1512
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', intakeRequirementText());
|
|
463
1513
|
const st = baseState('verify');
|
|
464
1514
|
st.evidence.verify = { summary: 'verified' };
|
|
465
1515
|
st.completedNodes = ['open', 'design', 'plan', 'execute', 'review']; // 无 subagent-execute
|
|
466
1516
|
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['P01']) };
|
|
467
1517
|
writeState(dir, st);
|
|
468
1518
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
|
|
469
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md',
|
|
1519
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', strictSummary('T01'));
|
|
470
1520
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TEST.md', '# TEST\n\n## 验证命令\n\n```bash\nnode -e "1"\n```\n');
|
|
471
1521
|
writeFile(dir, '.specs/' + CHANGE_ID + '/UAT.md', '# UAT\n\n通过\n');
|
|
472
|
-
// ① completedNodes 无 subagent-execute →
|
|
1522
|
+
// ① completedNodes 无 subagent-execute → BLOCKED 兜底
|
|
473
1523
|
const res = runGuard(['exit', 'verify'], dir);
|
|
474
|
-
assertExit(res,
|
|
1524
|
+
assertExit(res, 1);
|
|
1525
|
+
assertOut(res, 'BLOCKED');
|
|
475
1526
|
assertOut(res, '越权委托');
|
|
476
1527
|
assertOut(res, 'subagent-execute');
|
|
477
1528
|
// ② completedNodes 含 subagent-execute → 无越权 WARN
|
|
@@ -485,7 +1536,7 @@ export const ENTRIES = [
|
|
|
485
1536
|
|
|
486
1537
|
// 112: 节点顺序 BLOCK 消息含恢复指引——next 的「疑似未 exit」BLOCK 与
|
|
487
1538
|
// exit 的「currentNode 不匹配」BLOCK 均提示恢复通道(advance 强制推进/select 切换/
|
|
488
|
-
// exit --apply)——防 resume
|
|
1539
|
+
// exit --apply)——防 resume 自锁(机器推导出的节点没有脚本恢复通道)
|
|
489
1540
|
{
|
|
490
1541
|
name: '112 节点顺序 BLOCK 消息含恢复指引',
|
|
491
1542
|
run: (dir) => {
|
|
@@ -524,8 +1575,9 @@ export const ENTRIES = [
|
|
|
524
1575
|
// ③④ 追加同判据的段尾分支回归锚(波次段即文末,新 change 形态 ⇒ 必 BLOCK):段尾判定若
|
|
525
1576
|
// 不成立,该检查会被整段静默跳过——下一条 [P] 行漏扫的同族形态见上一场景。
|
|
526
1577
|
{
|
|
527
|
-
name: '113 plan exit:波次散文与并行标记不一致 →
|
|
1578
|
+
name: '113 plan exit:波次散文与并行标记不一致 → BLOCK(含段即文末形态)',
|
|
528
1579
|
run: (dir) => {
|
|
1580
|
+
writeNodeDeclarationMarkers(dir, 'plan');
|
|
529
1581
|
const st = baseState('plan');
|
|
530
1582
|
st.evidence.plan = { summary: 'plan done' };
|
|
531
1583
|
writeState(dir, st);
|
|
@@ -533,12 +1585,12 @@ export const ENTRIES = [
|
|
|
533
1585
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n## 波次划分\n\nWave 1 (parallel): T01[P], T02[P]\n\n## 任务清单\n\n'
|
|
534
1586
|
+ '<task id="T01" parallel="true" status="pending"><action>a</action><write_files>f1</write_files><verify>v</verify></task>\n'
|
|
535
1587
|
+ '<task id="T02" status="pending"><action>b</action><write_files>f2</write_files><verify>v</verify></task>\n');
|
|
536
|
-
// ① 散文 T02[P] 但 XML 无 parallel →
|
|
1588
|
+
// ① 散文 T02[P] 但 XML 无 parallel → BLOCKED
|
|
537
1589
|
const res = runGuard(['exit', 'plan'], dir);
|
|
538
|
-
assertExit(res,
|
|
1590
|
+
assertExit(res, 1);
|
|
1591
|
+
assertOut(res, 'BLOCKED');
|
|
539
1592
|
assertOut(res, '波次散文');
|
|
540
1593
|
assertOut(res, 'T02');
|
|
541
|
-
assertOut(res, 'ALL CHECKS PASSED');
|
|
542
1594
|
// ② XML 补 T02 parallel → 无波次 WARN
|
|
543
1595
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n## 波次划分\n\nWave 1 (parallel): T01[P], T02[P]\n\n## 任务清单\n\n'
|
|
544
1596
|
+ '<task id="T01" parallel="true" status="pending"><action>a</action><write_files>f1</write_files><verify>v</verify></task>\n'
|
|
@@ -552,8 +1604,8 @@ export const ENTRIES = [
|
|
|
552
1604
|
// 语义行 ⇒ 放行(该对照因此在任一态都可观测到)。
|
|
553
1605
|
const stEof = baseState('plan');
|
|
554
1606
|
stEof.evidence.plan = { summary: 'plan done' };
|
|
555
|
-
stEof.newChange = true;
|
|
556
1607
|
writeState(dir, stEof);
|
|
1608
|
+
writeNodeDeclarationMarkers(dir, 'plan');
|
|
557
1609
|
assertExit(runGuard(['entry', 'plan'], dir), 0);
|
|
558
1610
|
const taskT01Eof = '<task id="T01"><action>a</action><write_files>f</write_files><verify>v</verify><done>d</done></task>\n';
|
|
559
1611
|
const eofHead = '# TASK\n\n## 波次划分\n\nWave 1 (parallel): ';
|
|
@@ -605,22 +1657,36 @@ export const ENTRIES = [
|
|
|
605
1657
|
},
|
|
606
1658
|
},
|
|
607
1659
|
|
|
608
|
-
// 115:
|
|
1660
|
+
// 115: entry 证据化——本节点未 entry 直接 exit → BLOCKED(单一等级,无渐进放行)
|
|
609
1661
|
{
|
|
610
|
-
name: '115 execute exit
|
|
1662
|
+
name: '115 execute exit BLOCKED:本节点未 entry 直接 exit(M1)',
|
|
611
1663
|
run: (dir) => {
|
|
612
1664
|
const st = baseState('execute');
|
|
613
1665
|
st.evidence.execute = { summary: 'executed' };
|
|
614
|
-
st.enteredNodes = ['open', 'design', 'plan']; // 前序节点 enter
|
|
1666
|
+
st.enteredNodes = ['open', 'design', 'plan']; // 前序节点 enter 过;execute 未 entry
|
|
615
1667
|
writeState(dir, st);
|
|
616
1668
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
617
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
|
|
1669
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
|
|
618
1670
|
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
619
1671
|
st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
620
1672
|
writeState(dir, st2);
|
|
621
1673
|
const res = runGuard(['exit', 'execute'], dir);
|
|
622
|
-
assertExit(res,
|
|
623
|
-
assertOut(res, '
|
|
1674
|
+
assertExit(res, 1);
|
|
1675
|
+
assertOut(res, '未执行 entry 直接 exit');
|
|
1676
|
+
// 恢复指引按**目录在哪**分两种说法(in-place 扩展):活动目录在场时,状态漂移的两条既有
|
|
1677
|
+
// 出路(advance / select)是可行的那一步;目录已搬进归档时这两步都走不通——select 要求活动
|
|
1678
|
+
// 目录在场,advance 的产物推导也读活动路径——只给可执行的那一步(把目录移回活动位置)。
|
|
1679
|
+
assertOut(res, '状态漂移 → advance/select');
|
|
1680
|
+
fs.mkdirSync(path.join(dir, '.specs', 'archive'), { recursive: true });
|
|
1681
|
+
fs.renameSync(path.join(dir, '.specs', CHANGE_ID),
|
|
1682
|
+
path.join(dir, '.specs', 'archive', '2026-11-05-' + CHANGE_ID));
|
|
1683
|
+
const resMoved = runGuard(['exit', 'execute'], dir);
|
|
1684
|
+
assertExit(resMoved, 1);
|
|
1685
|
+
assertOut(resMoved, '未执行 entry 直接 exit');
|
|
1686
|
+
assertOut(resMoved, '已移到归档位置(.specs/archive/2026-11-05-' + CHANGE_ID + ')');
|
|
1687
|
+
assertOut(resMoved, '移回活动位置 .specs/' + CHANGE_ID + '/');
|
|
1688
|
+
assertNotOut(resMoved, 'advance');
|
|
1689
|
+
assertNotOut(resMoved, 'select');
|
|
624
1690
|
},
|
|
625
1691
|
},
|
|
626
1692
|
|
|
@@ -632,9 +1698,10 @@ export const ENTRIES = [
|
|
|
632
1698
|
st.evidence.execute = { summary: 'executed' };
|
|
633
1699
|
st.enteredNodes = ['open', 'design', 'plan'];
|
|
634
1700
|
writeState(dir, st);
|
|
1701
|
+
writeNodeDeclarationMarkers(dir, 'execute');
|
|
635
1702
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
636
1703
|
assertExit(runGuard(['entry', 'execute'], dir), 0); // entry 记录 enter 标记
|
|
637
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
|
|
1704
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
|
|
638
1705
|
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
639
1706
|
st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
640
1707
|
writeState(dir, st2);
|
|
@@ -653,10 +1720,9 @@ export const ENTRIES = [
|
|
|
653
1720
|
st.evidence.execute = { summary: 'executed' };
|
|
654
1721
|
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'T02']) };
|
|
655
1722
|
st.enteredNodes = ['open', 'design', 'plan', 'execute'];
|
|
656
|
-
st.newChange = true;
|
|
657
1723
|
writeState(dir, st);
|
|
658
1724
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE_TWO);
|
|
659
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
|
|
1725
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
|
|
660
1726
|
const res = runGuard(['exit', 'execute'], dir); // T02 缺 SUMMARY
|
|
661
1727
|
assertExit(res, 1);
|
|
662
1728
|
assertOut(res, 'SUMMARY');
|
|
@@ -671,13 +1737,12 @@ export const ENTRIES = [
|
|
|
671
1737
|
const st = baseState('subagent-execute');
|
|
672
1738
|
st.evidence.execute = { summary: 'executed' };
|
|
673
1739
|
st.enteredNodes = ['open', 'design', 'plan', 'subagent-execute'];
|
|
674
|
-
st.newChange = true;
|
|
675
1740
|
const handoff = handoffFor(['T01']);
|
|
676
1741
|
delete handoff.T01.result.redEvidence;
|
|
677
1742
|
st.evidence['subagent-execute'] = { summary: 'delegated', handoffRequest: { T01: { taskId: 'T01' } }, handoffResult: handoff };
|
|
678
1743
|
writeState(dir, st);
|
|
679
1744
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
680
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
|
|
1745
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
|
|
681
1746
|
const res = runGuard(['exit', 'subagent-execute'], dir);
|
|
682
1747
|
assertExit(res, 1);
|
|
683
1748
|
assertOut(res, 'redEvidence');
|
|
@@ -688,6 +1753,7 @@ export const ENTRIES = [
|
|
|
688
1753
|
{
|
|
689
1754
|
name: '119 handoff result 提交对象不可校验 → 协调者确认提示(M4)',
|
|
690
1755
|
run: (dir) => {
|
|
1756
|
+
writeNodeDeclarationMarkers(dir, 'subagent-execute');
|
|
691
1757
|
writeState(dir, baseState('subagent-execute'));
|
|
692
1758
|
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
|
|
693
1759
|
execFileSync('git', ['init', '-q'], { cwd: dir });
|
|
@@ -700,6 +1766,7 @@ export const ENTRIES = [
|
|
|
700
1766
|
completedChecks: ['required-skill:subagent-execute.flow-comet-dev'],
|
|
701
1767
|
riskSignals: ['none'],
|
|
702
1768
|
});
|
|
1769
|
+
assertExit(runHandoff(['request', 'T01', 'delegate', '--write-files', 'src/t1.mjs'], dir, { FLOW_COMET_PROTOCOL: scenarioProtocolPath(dir) }), 0);
|
|
703
1770
|
const res = runHandoff(['result', 'T01', payload], dir);
|
|
704
1771
|
assertExit(res, 0);
|
|
705
1772
|
assertOut(res, 'HANDOFF ERROR');
|
|
@@ -707,35 +1774,49 @@ export const ENTRIES = [
|
|
|
707
1774
|
},
|
|
708
1775
|
},
|
|
709
1776
|
|
|
710
|
-
// 120:
|
|
1777
|
+
// 120: 缺声明一律 BLOCKED(record 自动补写已整体删除)——照抄报文命令手动声明后同一 record 通过。
|
|
1778
|
+
// 反向构造:引擎若仍自动补写,第一趟就不会 BLOCKED(本格 RED);标记若仍由 record 代记,
|
|
1779
|
+
// ② 的「零标记」断言会命中 auto 标记文件。
|
|
711
1780
|
{
|
|
712
|
-
name: '120 record
|
|
1781
|
+
name: '120 record 缺声明一律 BLOCKED:手动 skill-load 后同一 record 通过(自动补写已删除)',
|
|
713
1782
|
run: (dir) => {
|
|
714
1783
|
const st = baseState('open');
|
|
715
1784
|
st.enteredNodes = ['open'];
|
|
716
1785
|
writeState(dir, st);
|
|
717
1786
|
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why(为什么做)\nx');
|
|
718
1787
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\nx\n\n## 验收准则(AC)\n- Given x When y Then z');
|
|
719
|
-
|
|
720
|
-
|
|
1788
|
+
writeFile(dir, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
|
|
1789
|
+
writeFile(dir, 'flow-kit/prompts/1-requirement.md', '# 阶段 1 · REQUIREMENT\n\n## 角色\n\n你是 Requirer。\n');
|
|
721
1790
|
const loads = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
|
|
722
|
-
|
|
723
|
-
const
|
|
724
|
-
|
|
725
|
-
|
|
1791
|
+
// ① 无声明 → BLOCKED(唯一等级:旧 change 的渐进分支已随字段退役),报文给可照抄的声明命令
|
|
1792
|
+
const blocked = runStateWithProtocol(dir, ['record', 'open', '{"summary":"done"}']);
|
|
1793
|
+
assertExit(blocked, 1);
|
|
1794
|
+
assertOut(blocked, 'BLOCKED: 节点 open 缺少技能加载声明标记');
|
|
1795
|
+
assertOut(blocked, 'skill-load open flow-comet-change');
|
|
1796
|
+
assertOut(blocked, 'skill-load open flow-comet-requirement');
|
|
1797
|
+
// ② 缺声明时不得代记任何标记(自动补写已删除;任何 .skill-loads 文件都是回退)
|
|
1798
|
+
if (fs.existsSync(loads)) {
|
|
1799
|
+
const written = fs.readdirSync(loads);
|
|
1800
|
+
if (written.length > 0) {
|
|
1801
|
+
throw new Error('record 在缺声明时自动补写了标记(自动补写应已删除): ' + written.join(', '));
|
|
1802
|
+
}
|
|
726
1803
|
}
|
|
727
|
-
//
|
|
728
|
-
|
|
729
|
-
|
|
1804
|
+
// ③ 手动声明(真实 skill-load,协议文件与模板清单照报文形态给全)→ 同一 record 通过
|
|
1805
|
+
assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change',
|
|
1806
|
+
'--prompt', 'flow-kit/prompts/0-change.md', '--prompt', 'flow-kit/prompts/1-requirement.md',
|
|
1807
|
+
'--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
|
|
1808
|
+
assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-requirement',
|
|
1809
|
+
'--prompt', 'flow-kit/prompts/1-requirement.md', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
|
|
1810
|
+
const passed = runStateWithProtocol(dir, ['record', 'open', '{"summary":"done"}']);
|
|
1811
|
+
assertExit(passed, 0);
|
|
1812
|
+
assertOut(passed, 'EVIDENCE: open');
|
|
1813
|
+
// ④ 标记如实记录执行者声明的协议文件,且不带 auto(引擎代记的形态不再产生)
|
|
1814
|
+
const changeMeta = JSON.parse(fs.readFileSync(path.join(loads, 'open-flow-comet-change.json'), 'utf8'));
|
|
730
1815
|
if (changeMeta.protocol !== '0-change.md') {
|
|
731
|
-
throw new Error('
|
|
1816
|
+
throw new Error('手动声明标记的 protocol 应为 0-change.md: ' + JSON.stringify(changeMeta.protocol));
|
|
732
1817
|
}
|
|
733
|
-
if (
|
|
734
|
-
throw new Error('
|
|
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));
|
|
1818
|
+
if (changeMeta.auto === true) {
|
|
1819
|
+
throw new Error('手动声明标记不应带 auto(自动补写已删除): ' + JSON.stringify(changeMeta));
|
|
739
1820
|
}
|
|
740
1821
|
},
|
|
741
1822
|
},
|
|
@@ -747,8 +1828,8 @@ export const ENTRIES = [
|
|
|
747
1828
|
const st = baseState('execute');
|
|
748
1829
|
st.evidence.execute = { summary: 'empty exit', emptyExitApproved: true };
|
|
749
1830
|
st.enteredNodes = ['open', 'design', 'plan', 'execute'];
|
|
750
|
-
st.newChange = true;
|
|
751
1831
|
writeState(dir, st);
|
|
1832
|
+
writeNodeDeclarationMarkers(dir, 'execute');
|
|
752
1833
|
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
1834
|
const res = runGuard(['exit', 'execute'], dir);
|
|
754
1835
|
assertExit(res, 0);
|
|
@@ -763,23 +1844,28 @@ export const ENTRIES = [
|
|
|
763
1844
|
|
|
764
1845
|
// 122: M7——旧 change(enter 机制未激活)done 缺 SUMMARY 仍 WARN 渐进,不升级(兼容正例)
|
|
765
1846
|
// 构造:两个 done 任务(T01/T02),仅 T01-SUMMARY 存在(满足产物通配符,隔离 KI-8 语义)
|
|
1847
|
+
// 122: 同一「done 任务缺 SUMMARY」构造在**无任何新旧标记字段**的状态下同样 BLOCKED
|
|
1848
|
+
// (单轨:不再有「旧 change 渐进放行」这一侧)
|
|
766
1849
|
{
|
|
767
|
-
name: '122 execute exit
|
|
1850
|
+
name: '122 execute exit:done 缺 SUMMARY 一律 BLOCKED(无字段状态同判)',
|
|
768
1851
|
run: (dir) => {
|
|
769
1852
|
const st = baseState('execute');
|
|
1853
|
+
st.enteredNodes = ['execute'];
|
|
770
1854
|
st.evidence.execute = { summary: 'executed' };
|
|
771
1855
|
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'T02']) };
|
|
772
|
-
writeState(dir, st);
|
|
1856
|
+
writeState(dir, st);
|
|
1857
|
+
writeNodeDeclarationMarkers(dir, 'execute');
|
|
773
1858
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE_TWO);
|
|
774
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
|
|
775
|
-
const res = runGuard(['exit', 'execute'], dir); // T02 缺 SUMMARY
|
|
776
|
-
assertExit(res,
|
|
777
|
-
assertOut(res, '
|
|
1859
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
|
|
1860
|
+
const res = runGuard(['exit', 'execute'], dir); // T02 缺 SUMMARY
|
|
1861
|
+
assertExit(res, 1);
|
|
1862
|
+
assertOut(res, 'BLOCKED');
|
|
1863
|
+
assertOut(res, 'SUMMARY');
|
|
778
1864
|
},
|
|
779
1865
|
},
|
|
780
1866
|
|
|
781
|
-
// 123:
|
|
782
|
-
//
|
|
1867
|
+
// 123: init 在无提交(空)仓库时输出提示且跳过分支创建——提示与行为必须一致:
|
|
1868
|
+
// 警告之后仍 checkout -b 实际创建分支,就是声称与行为矛盾
|
|
783
1869
|
{
|
|
784
1870
|
name: '123 init 空仓库提示:无提交仓库的分支创建边界(M8)',
|
|
785
1871
|
run: (dir) => {
|
|
@@ -799,34 +1885,38 @@ export const ENTRIES = [
|
|
|
799
1885
|
},
|
|
800
1886
|
},
|
|
801
1887
|
|
|
802
|
-
// 124:
|
|
1888
|
+
// 124: handoff 缺 redEvidence 一律 BLOCKED(无字段状态同判,不再有渐进 WARN 这一侧)
|
|
803
1889
|
{
|
|
804
|
-
name: '124 subagent-execute exit
|
|
1890
|
+
name: '124 subagent-execute exit:handoff 缺 redEvidence 一律 BLOCKED',
|
|
805
1891
|
run: (dir) => {
|
|
806
1892
|
const st = baseState('subagent-execute');
|
|
1893
|
+
st.enteredNodes = ['subagent-execute'];
|
|
807
1894
|
st.evidence.execute = { summary: 'executed' };
|
|
808
1895
|
const handoff = handoffFor(['T01']);
|
|
809
1896
|
delete handoff.T01.result.redEvidence;
|
|
810
1897
|
st.evidence['subagent-execute'] = { summary: 'delegated', handoffRequest: { T01: { taskId: 'T01' } }, handoffResult: handoff };
|
|
811
|
-
writeState(dir, st);
|
|
1898
|
+
writeState(dir, st);
|
|
1899
|
+
writeNodeDeclarationMarkers(dir, 'subagent-execute');
|
|
812
1900
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
813
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
|
|
1901
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
|
|
814
1902
|
const res = runGuard(['exit', 'subagent-execute'], dir);
|
|
815
|
-
assertExit(res,
|
|
816
|
-
assertOut(res, '
|
|
1903
|
+
assertExit(res, 1);
|
|
1904
|
+
assertOut(res, 'redEvidence');
|
|
817
1905
|
},
|
|
818
1906
|
},
|
|
819
1907
|
|
|
820
1908
|
// 125: R1——新 change(newChange:true)review 处置标记缺失 → BLOCKED(旧 change WARN 保留);
|
|
821
|
-
//
|
|
822
|
-
//
|
|
1909
|
+
// 并内扩延期裁决门禁(覆盖任何严重度,含 Minor):无用户裁决 BLOCK / 同段或其它段落裁决(由
|
|
1910
|
+
// [升级] 承接)放行 / 有裁决但缺 [升级] 承接仍 BLOCK;Minor 另须在条目块内自证判据
|
|
1911
|
+
// 「判 Minor:<一句话理由>」——判据落在**判定当时**,与处置标记无关([已修]/[升级]/[转待办]
|
|
1912
|
+
// 一律要;缺则改判 Major,默认 Major)。
|
|
823
1913
|
{
|
|
824
|
-
name: '125 review exit BLOCKED:新 change 处置标记缺失 +
|
|
1914
|
+
name: '125 review exit BLOCKED:新 change 处置标记缺失 + 延期待裁决(R1)',
|
|
825
1915
|
run: (dir) => {
|
|
826
1916
|
const st = baseState('review');
|
|
827
1917
|
st.evidence.review = { summary: 'reviewed' };
|
|
828
|
-
st.newChange = true;
|
|
829
1918
|
writeState(dir, st);
|
|
1919
|
+
writeNodeDeclarationMarkers(dir, 'review');
|
|
830
1920
|
assertExit(runGuard(['entry', 'review'], dir), 0);
|
|
831
1921
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题A**: 某处存在一个需要记录的问题描述,但未给出任何处置结论\n\n## 结论\n\n通过\n');
|
|
832
1922
|
const res = runGuard(['exit', 'review'], dir);
|
|
@@ -862,11 +1952,81 @@ export const ENTRIES = [
|
|
|
862
1952
|
assertExit(resAdjudicated, 0);
|
|
863
1953
|
assertOut(resAdjudicated, 'ALL CHECKS PASSED');
|
|
864
1954
|
assertNotOut(resAdjudicated, '用户裁决');
|
|
865
|
-
// 子断言:Minor [转待办]
|
|
866
|
-
|
|
1955
|
+
// 子断言:Minor [转待办] 与 Major 同口径——无用户裁决记录 → BLOCKED(报文点名条目 + 给出
|
|
1956
|
+
// 裁决记录形态;修复前 Minor 可自行延期直接放行 = RED)
|
|
1957
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-1 · 小项**:某处小问题 [转待办]\n 判 Minor:仅影响日志措辞,不改变行为与接口\n\n## 结论\n\n通过\n');
|
|
867
1958
|
const resMinor = runGuard(['exit', 'review'], dir);
|
|
868
|
-
assertExit(resMinor,
|
|
869
|
-
assertOut(resMinor, '
|
|
1959
|
+
assertExit(resMinor, 1);
|
|
1960
|
+
assertOut(resMinor, 'BLOCKED');
|
|
1961
|
+
assertOut(resMinor, 'm-1 · 小项');
|
|
1962
|
+
assertOut(resMinor, '用户裁决:接受延期');
|
|
1963
|
+
// 子断言:同一条目补上裁决记录(指向该条目 + [升级] 承接)→ 放行
|
|
1964
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-1 · 小项**:某处小问题 [升级] [转待办]\n 判 Minor:仅影响日志措辞,不改变行为与接口\n\n- 用户裁决:接受延期 —— 发现 m-1:下一 change 首修。\n\n## 结论\n\n通过\n');
|
|
1965
|
+
const resMinorAdjudicated = runGuard(['exit', 'review'], dir);
|
|
1966
|
+
assertExit(resMinorAdjudicated, 0);
|
|
1967
|
+
assertOut(resMinorAdjudicated, 'ALL CHECKS PASSED');
|
|
1968
|
+
assertNotOut(resMinorAdjudicated, 'BLOCKED');
|
|
1969
|
+
// 子断言:Minor 条目缺判定理由「判 Minor:<理由>」→ BLOCKED(报文点名条目 + 给出形态);
|
|
1970
|
+
// 补上判据后放行(裁决记录仍在,缺的只是 Minor 判据本身)
|
|
1971
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-5 · 缺判据的小项**:某处小问题 [升级] [转待办]\n\n- 用户裁决:接受延期 —— 发现 m-5:下一 change 首修。\n\n## 结论\n\n通过\n');
|
|
1972
|
+
const resMinorNoReason = runGuard(['exit', 'review'], dir);
|
|
1973
|
+
assertExit(resMinorNoReason, 1);
|
|
1974
|
+
assertOut(resMinorNoReason, 'BLOCKED');
|
|
1975
|
+
assertOut(resMinorNoReason, 'm-5 · 缺判据的小项');
|
|
1976
|
+
assertOut(resMinorNoReason, '判 Minor:');
|
|
1977
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-5 · 缺判据的小项**:某处小问题 [升级] [转待办]\n 判 Minor:只影响内部诊断输出\n\n- 用户裁决:接受延期 —— 发现 m-5:下一 change 首修。\n\n## 结论\n\n通过\n');
|
|
1978
|
+
const resMinorReasonOk = runGuard(['exit', 'review'], dir);
|
|
1979
|
+
assertExit(resMinorReasonOk, 0);
|
|
1980
|
+
assertOut(resMinorReasonOk, 'ALL CHECKS PASSED');
|
|
1981
|
+
// 子断言(R2 判定时门禁):判为 Minor 就要在**判定当时**自证判据,与处置标记无关——[已修]
|
|
1982
|
+
// 的 Minor 缺「判 Minor:」行 → BLOCKED(修复前只查 [转待办],[已修]/[升级] 的 Minor 直接
|
|
1983
|
+
// 放行 = RED);报文点名条目 + 严重度 + 缺行 + 正确形态 + 「改判 Major」兜底。
|
|
1984
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-9 · 已修但缺判据的小项**:某处小问题 [已修]\n\n## 结论\n\n通过\n');
|
|
1985
|
+
const resMinorFixed = runGuard(['exit', 'review'], dir);
|
|
1986
|
+
assertExit(resMinorFixed, 1);
|
|
1987
|
+
assertOut(resMinorFixed, 'BLOCKED');
|
|
1988
|
+
assertOut(resMinorFixed, 'm-9 · 已修但缺判据的小项');
|
|
1989
|
+
assertOut(resMinorFixed, '(Minor)');
|
|
1990
|
+
assertOut(resMinorFixed, '缺 `判 Minor:` 行');
|
|
1991
|
+
assertOut(resMinorFixed, '改判 Major');
|
|
1992
|
+
// 补上判据行 → 放行([已修] 不是「没有 Minor 判定」的理由)
|
|
1993
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-9 · 已修但缺判据的小项**:某处小问题 [已修]\n 判 Minor:仅影响日志措辞,不改变行为与接口\n\n## 结论\n\n通过\n');
|
|
1994
|
+
const resMinorFixedOk = runGuard(['exit', 'review'], dir);
|
|
1995
|
+
assertExit(resMinorFixedOk, 0);
|
|
1996
|
+
assertOut(resMinorFixedOk, 'ALL CHECKS PASSED');
|
|
1997
|
+
// [升级] 的 Minor 同形态:缺判据 → BLOCKED;补上 → 放行
|
|
1998
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-10 · 升级但缺判据的小项**:某处小问题 [升级]\n\n## 结论\n\n通过\n');
|
|
1999
|
+
const resMinorEscalated = runGuard(['exit', 'review'], dir);
|
|
2000
|
+
assertExit(resMinorEscalated, 1);
|
|
2001
|
+
assertOut(resMinorEscalated, 'BLOCKED');
|
|
2002
|
+
assertOut(resMinorEscalated, 'm-10 · 升级但缺判据的小项');
|
|
2003
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-10 · 升级但缺判据的小项**:某处小问题 [升级]\n 判 Minor:只涉及命名一致性\n\n## 结论\n\n通过\n');
|
|
2004
|
+
const resMinorEscalatedOk = runGuard(['exit', 'review'], dir);
|
|
2005
|
+
assertExit(resMinorEscalatedOk, 0);
|
|
2006
|
+
assertOut(resMinorEscalatedOk, 'ALL CHECKS PASSED');
|
|
2007
|
+
// 既有 [转待办] 不回归:R2 扩面不取代 R1——只补判据、无裁决 → 仍 BLOCKED(裁决门独立,
|
|
2008
|
+
// 判据门不再报);补裁决 + [升级] 承接后才放行(双重约束各自在场)。
|
|
2009
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-11 · 延期缺判据的小项**:某处小问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
2010
|
+
const resMinorDeferredNoReason = runGuard(['exit', 'review'], dir);
|
|
2011
|
+
assertExit(resMinorDeferredNoReason, 1);
|
|
2012
|
+
assertOut(resMinorDeferredNoReason, '用户裁决');
|
|
2013
|
+
assertOut(resMinorDeferredNoReason, '判 Minor:');
|
|
2014
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-11 · 延期缺判据的小项**:某处小问题 [转待办]\n 判 Minor:仅影响内部日志\n\n## 结论\n\n通过\n');
|
|
2015
|
+
const resMinorDeferredReasonOnly = runGuard(['exit', 'review'], dir);
|
|
2016
|
+
assertExit(resMinorDeferredReasonOnly, 1);
|
|
2017
|
+
assertOut(resMinorDeferredReasonOnly, '用户裁决');
|
|
2018
|
+
assertNotOut(resMinorDeferredReasonOnly, '判 Minor:');
|
|
2019
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-11 · 延期缺判据的小项**:某处小问题 [升级] [转待办]\n 判 Minor:仅影响内部日志\n\n- 用户裁决:接受延期 —— 发现 m-11:下一 change 首修。\n\n## 结论\n\n通过\n');
|
|
2020
|
+
const resMinorDeferredOk = runGuard(['exit', 'review'], dir);
|
|
2021
|
+
assertExit(resMinorDeferredOk, 0);
|
|
2022
|
+
assertOut(resMinorDeferredOk, 'ALL CHECKS PASSED');
|
|
2023
|
+
// 子断言(R2 覆盖边界):Major 的任何处置都不受判据门影响——[已修] / [升级] 均不要求
|
|
2024
|
+
// 「判 Minor:」行([转待办] + 用户裁决的 Major 由上面的 F2 覆盖)
|
|
2025
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F11 · 已修的大项**:某处问题 [已修]\n- **F12 · 升级的大项**:另一处问题 [升级]\n\n## 结论\n\n通过\n');
|
|
2026
|
+
const resMajorDisposed = runGuard(['exit', 'review'], dir);
|
|
2027
|
+
assertExit(resMajorDisposed, 0);
|
|
2028
|
+
assertOut(resMajorDisposed, 'ALL CHECKS PASSED');
|
|
2029
|
+
assertNotOut(resMajorDisposed, '判 Minor:');
|
|
870
2030
|
// 子断言:文末用户裁决 + 指向该条目 + [升级] 承接 → 放行
|
|
871
2031
|
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
2032
|
const resTail = runGuard(['exit', 'review'], dir);
|
|
@@ -884,13 +2044,19 @@ export const ENTRIES = [
|
|
|
884
2044
|
assertOut(resNoEscalation, 'BLOCKED');
|
|
885
2045
|
assertOut(resNoEscalation, 'Major');
|
|
886
2046
|
assertOut(resNoEscalation, '用户裁决');
|
|
887
|
-
//
|
|
888
|
-
//
|
|
2047
|
+
// 子断言:条目正文引用 [Major] 标签字样(自身 [转待办])→ 严重度以条目自身标题/行首为准,
|
|
2048
|
+
// 正文标签不改变本条判定(报文按「未标严重度」点名,不因正文出现 [Major] 就升格为 Major);
|
|
2049
|
+
// 补上裁决记录后放行——延期门禁对任何严重度生效,处置由裁决记录承接
|
|
889
2050
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n- **m-2 · 引用 Major 的小项**:本条与 [Major] F1 项不同,是独立问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
890
2051
|
const resCited = runGuard(['exit', 'review'], dir);
|
|
891
|
-
assertExit(resCited,
|
|
892
|
-
assertOut(resCited, '
|
|
893
|
-
assertNotOut(resCited, '
|
|
2052
|
+
assertExit(resCited, 1);
|
|
2053
|
+
assertOut(resCited, '未标严重度');
|
|
2054
|
+
assertNotOut(resCited, '(Major)');
|
|
2055
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n- **m-2 · 引用 Major 的小项**:本条与 [Major] F1 项不同,是独立问题 [升级] [转待办]\n\n- 用户裁决:接受延期 —— 发现 m-2:下一 change 首修。\n\n## 结论\n\n通过\n');
|
|
2056
|
+
const resCitedOk = runGuard(['exit', 'review'], dir);
|
|
2057
|
+
assertExit(resCitedOk, 0);
|
|
2058
|
+
assertOut(resCitedOk, 'ALL CHECKS PASSED');
|
|
2059
|
+
assertNotOut(resCitedOk, 'BLOCKED');
|
|
894
2060
|
// 子断言:Major 条目自身处置为 [已修],续行正文引用他条 [转待办] → 放行——
|
|
895
2061
|
// 延期门禁只看该条目自身标题/行首的处置标记,不做整块扫描
|
|
896
2062
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **[Major] F9 · 已修项引用他条**:某处问题 [已修]\n (续行仅引用他条的处置去向 [转待办],非本条处置)\n\n## 结论\n\n通过\n');
|
|
@@ -921,7 +2087,7 @@ export const ENTRIES = [
|
|
|
921
2087
|
'# REVIEW\n\n## 发现\n\n### Major\n\n'
|
|
922
2088
|
+ '- **F10 · 中段裁决的延期**:某处问题 [升级] [转待办]\n\n'
|
|
923
2089
|
+ '- 用户裁决:接受延期 —— 发现 F10(中段裁决的延期):下一 change 首修。\n\n'
|
|
924
|
-
+ '### Minor\n\n- **m-4 · 小项**:另一个独立问题 [已修]\n\n## 结论\n\n通过\n');
|
|
2090
|
+
+ '### Minor\n\n- **m-4 · 小项**:另一个独立问题 [已修]\n 判 Minor:仅措辞问题\n\n## 结论\n\n通过\n');
|
|
925
2091
|
const resMidParagraph = runGuard(['exit', 'review'], dir);
|
|
926
2092
|
assertExit(resMidParagraph, 0);
|
|
927
2093
|
assertOut(resMidParagraph, 'ALL CHECKS PASSED');
|
|
@@ -942,7 +2108,6 @@ export const ENTRIES = [
|
|
|
942
2108
|
const st = baseState('execute');
|
|
943
2109
|
st.evidence.execute = { summary: 'executed' };
|
|
944
2110
|
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
945
|
-
st.newChange = true;
|
|
946
2111
|
writeState(dir, st);
|
|
947
2112
|
assertExit(runGuard(['entry', 'execute'], dir), 0);
|
|
948
2113
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
@@ -971,8 +2136,8 @@ export const ENTRIES = [
|
|
|
971
2136
|
run: (dir) => {
|
|
972
2137
|
const st = baseState('plan');
|
|
973
2138
|
st.evidence.plan = { summary: 'planned' };
|
|
974
|
-
st.newChange = true;
|
|
975
2139
|
writeState(dir, st);
|
|
2140
|
+
writeNodeDeclarationMarkers(dir, 'plan');
|
|
976
2141
|
assertExit(runGuard(['entry', 'plan'], dir), 0);
|
|
977
2142
|
const planTask = (text) => writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', text);
|
|
978
2143
|
const taskT01 = '<task id="T01"><action>a</action><write_files>f</write_files><verify>v</verify><done>d</done></task>\n';
|
|
@@ -1011,11 +2176,11 @@ export const ENTRIES = [
|
|
|
1011
2176
|
run: (dir) => {
|
|
1012
2177
|
const st = baseState('execute');
|
|
1013
2178
|
st.evidence.execute = { summary: 'executed' };
|
|
1014
|
-
st.newChange = true;
|
|
1015
2179
|
writeState(dir, st);
|
|
2180
|
+
writeNodeDeclarationMarkers(dir, 'execute');
|
|
1016
2181
|
assertExit(runGuard(['entry', 'execute'], dir), 0);
|
|
1017
2182
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
|
|
1018
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md',
|
|
2183
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/P01-SUMMARY.md', strictSummary('T01')); // 满足 M2
|
|
1019
2184
|
const st2 = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
1020
2185
|
st2.evidence['subagent-execute'] = { handoffResult: handoffFor(['P01']) }; // 满足越俎代庖,触发 KI-10 越权委托
|
|
1021
2186
|
writeState(dir, st2);
|
|
@@ -1036,7 +2201,6 @@ export const ENTRIES = [
|
|
|
1036
2201
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + pendingParallelTask);
|
|
1037
2202
|
// ① 新 change 错误节点 pending 并行 request → BLOCK + state 字节零改写 + 不落请求记录 + 恢复指引
|
|
1038
2203
|
const reqState = baseState('execute');
|
|
1039
|
-
reqState.newChange = true;
|
|
1040
2204
|
reqState.enteredNodes = ['execute'];
|
|
1041
2205
|
writeState(dir, reqState);
|
|
1042
2206
|
const beforeReqBytes = fs.readFileSync(reqStatePath, 'utf8');
|
|
@@ -1044,7 +2208,10 @@ export const ENTRIES = [
|
|
|
1044
2208
|
assertExit(resWrongNode, 1);
|
|
1045
2209
|
assertOut(resWrongNode, 'BLOCKED: 任务 P-M02(并行 pending)应归属节点 subagent-execute');
|
|
1046
2210
|
assertOut(resWrongNode, 'workflow-state next');
|
|
1047
|
-
|
|
2211
|
+
// 同样改为断言顺序句本身——「先对当前节点 record + exit」+「未 exit 前不得 entry」。
|
|
2212
|
+
// 旧的裸 'entry subagent-execute' 会同时命中禁止句里的目标节点名,无法区分两种语义。
|
|
2213
|
+
assertOut(resWrongNode, '先对当前节点 execute record + exit');
|
|
2214
|
+
assertOut(resWrongNode, '不要在未 exit 前 entry 目标节点');
|
|
1048
2215
|
assertOut(resWrongNode, '本次请求未写入 state');
|
|
1049
2216
|
if (fs.readFileSync(reqStatePath, 'utf8') !== beforeReqBytes) {
|
|
1050
2217
|
throw new Error('M-02 BLOCK 必须 state 字节零改写');
|
|
@@ -1054,16 +2221,15 @@ export const ENTRIES = [
|
|
|
1054
2221
|
if (reqsAfterBlock['P-M02']) {
|
|
1055
2222
|
throw new Error('M-02 BLOCK 不得落 handoffRequests: ' + JSON.stringify(reqsAfterBlock));
|
|
1056
2223
|
}
|
|
1057
|
-
// ②
|
|
2224
|
+
// ② 同一构造(无任何新旧标记字段)→ 同判 BLOCKED(单轨:归属门禁不再有渐进侧)
|
|
1058
2225
|
writeState(dir, { ...baseState('execute'), enteredNodes: ['execute'] });
|
|
1059
2226
|
const resOldChange = runHandoff(['request', 'P-M02', 'parallel fix slice'], dir, reqEnv);
|
|
1060
|
-
assertExit(resOldChange,
|
|
1061
|
-
assertOut(resOldChange, '
|
|
1062
|
-
assertOut(resOldChange, '
|
|
1063
|
-
assertOut(resOldChange, 'HANDOFF REQUEST: P-M02');
|
|
2227
|
+
assertExit(resOldChange, 1);
|
|
2228
|
+
assertOut(resOldChange, 'BLOCKED: 任务 P-M02(并行 pending)应归属节点 subagent-execute');
|
|
2229
|
+
assertOut(resOldChange, '本次请求未写入 state');
|
|
1064
2230
|
const stOldChange = readScenarioState(dir);
|
|
1065
|
-
if (
|
|
1066
|
-
throw new Error('
|
|
2231
|
+
if (stOldChange.evidence?.['subagent-execute']?.handoffRequests?.['P-M02']) {
|
|
2232
|
+
throw new Error('归属门禁 BLOCK 不得落 handoffRequests,实际 ' + JSON.stringify(stOldChange.evidence));
|
|
1067
2233
|
}
|
|
1068
2234
|
// ③ pending 并行任务依赖未满足 → 当前不可委托。恢复指引必须以 next 实际输出为准:
|
|
1069
2235
|
// next 对依赖未满足的并行任务按串行消化输出 execute——指引不得再固定指向
|
|
@@ -1074,7 +2240,6 @@ export const ENTRIES = [
|
|
|
1074
2240
|
'<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
2241
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + unmetDepsTask);
|
|
1076
2242
|
const unmetState = baseState('execute');
|
|
1077
|
-
unmetState.newChange = true;
|
|
1078
2243
|
unmetState.enteredNodes = ['execute'];
|
|
1079
2244
|
unmetState.completedNodes = ['open', 'design', 'plan'];
|
|
1080
2245
|
unmetState.evidence = { plan: { summary: 'plan done' } };
|
|
@@ -1108,103 +2273,163 @@ export const ENTRIES = [
|
|
|
1108
2273
|
if (readScenarioState(dir).currentNode !== 'execute') {
|
|
1109
2274
|
throw new Error('依赖未满足时 next 应把工作归属留在 execute: ' + JSON.stringify(readScenarioState(dir).currentNode));
|
|
1110
2275
|
}
|
|
1111
|
-
//
|
|
2276
|
+
// 同一形态(无任何新旧标记字段)→ 同判 BLOCKED(单轨:无渐进放行侧)
|
|
1112
2277
|
const oldUnmetState = { ...unmetState };
|
|
1113
|
-
delete oldUnmetState.newChange;
|
|
1114
2278
|
writeState(dir, oldUnmetState);
|
|
1115
2279
|
const resUnmetOld = runHandoff(['request', 'P-M03', 'old change unmet deps'], dir, reqEnv);
|
|
1116
|
-
assertExit(resUnmetOld,
|
|
1117
|
-
assertOut(resUnmetOld, '
|
|
1118
|
-
|
|
1119
|
-
assertOut(resUnmetOld, 'HANDOFF REQUEST: P-M03');
|
|
2280
|
+
assertExit(resUnmetOld, 1);
|
|
2281
|
+
assertOut(resUnmetOld, 'BLOCKED: 任务 P-M03(并行 pending)当前不可委托:依赖未满足');
|
|
2282
|
+
assertNotOut(resUnmetOld, 'HANDOFF REQUEST');
|
|
1120
2283
|
},
|
|
1121
2284
|
},
|
|
1122
2285
|
|
|
1123
|
-
// 129: R2
|
|
2286
|
+
// 129: R2——未 entry 直接 exit → BLOCKED
|
|
1124
2287
|
{
|
|
1125
|
-
name: '129 execute exit BLOCKED
|
|
2288
|
+
name: '129 execute exit BLOCKED:未 entry 直接 exit(R2)',
|
|
1126
2289
|
run: (dir) => {
|
|
1127
2290
|
const st = baseState('execute');
|
|
1128
2291
|
st.evidence.execute = { summary: 'executed' };
|
|
1129
2292
|
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
1130
|
-
st.
|
|
2293
|
+
st.enteredNodes = []; // 显式构造未 entry 形态
|
|
1131
2294
|
writeState(dir, st);
|
|
1132
2295
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
1133
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
|
|
2296
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
|
|
1134
2297
|
const res = runGuard(['exit', 'execute'], dir);
|
|
1135
2298
|
assertExit(res, 1);
|
|
1136
2299
|
assertOut(res, 'entry');
|
|
1137
2300
|
},
|
|
1138
2301
|
},
|
|
1139
2302
|
|
|
1140
|
-
// 130: R6
|
|
2303
|
+
// 130: R6 退役——init 不写 newChange;旧状态带 true / null 与无字段逐字一致(AC-1 / AC-2)。
|
|
2304
|
+
// 三态对照是唯一判据:同一构造写三份 state、跑同一序列,退出码与首行必须相同——「带字段
|
|
2305
|
+
// BLOCK、无字段 WARN」的分级若残留,无字段那一份会 exit 0(本格 RED)。
|
|
1141
2306
|
{
|
|
1142
|
-
name: '130 init
|
|
2307
|
+
name: '130 init 不写 newChange;旧值 true/null 与无字段逐字一致(R6 退役)',
|
|
1143
2308
|
run: (dir) => {
|
|
1144
2309
|
execFileSync('git', ['init', '-q'], { cwd: dir, stdio: 'ignore' });
|
|
1145
2310
|
execFileSync('git', ['-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '--allow-empty', '-m', 'init'], { cwd: dir, stdio: 'ignore' });
|
|
1146
2311
|
const res = runStateWithProtocol(dir, ['init', CHANGE_ID]);
|
|
1147
2312
|
assertExit(res, 0);
|
|
1148
|
-
const
|
|
1149
|
-
if (
|
|
2313
|
+
const initialized = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
|
|
2314
|
+
if ('newChange' in initialized) {
|
|
2315
|
+
throw new Error('init 不应写入 newChange 字段(字段已退役): ' + JSON.stringify(initialized.newChange));
|
|
2316
|
+
}
|
|
2317
|
+
// 三态对照:同一夹具分别写 true / null / 无字段,跑同一序列(缺声明 record → status → exit open)
|
|
2318
|
+
const signature = (r) => r.status + '|' + r.output.split('\n')[0];
|
|
2319
|
+
const sequence = (field) => {
|
|
2320
|
+
const st = { ...initialized, enteredNodes: ['open'] };
|
|
2321
|
+
if (field !== undefined) st.newChange = field;
|
|
2322
|
+
writeState(dir, st);
|
|
2323
|
+
const record = runStateWithProtocol(dir, ['record', 'open', '{"summary":"x"}']);
|
|
2324
|
+
const status = runStateWithProtocol(dir, ['status']);
|
|
2325
|
+
const exit = runGuardWithProtocol(dir, ['exit', 'open']);
|
|
2326
|
+
return {
|
|
2327
|
+
record: signature(record),
|
|
2328
|
+
exit: signature(exit),
|
|
2329
|
+
statusCode: status.status,
|
|
2330
|
+
statusJson: status.output.split('\nROUTE:')[0].trim(),
|
|
2331
|
+
};
|
|
2332
|
+
};
|
|
2333
|
+
const withTrue = sequence(true);
|
|
2334
|
+
const withNull = sequence(null);
|
|
2335
|
+
const without = sequence(undefined);
|
|
2336
|
+
for (const [label, got] of [['true', withTrue], ['null', withNull]]) {
|
|
2337
|
+
if (got.record !== without.record) {
|
|
2338
|
+
throw new Error('newChange=' + label + ' 的 record 行为与无字段不一致: ' + got.record + ' ≠ ' + without.record);
|
|
2339
|
+
}
|
|
2340
|
+
if (got.exit !== without.exit) {
|
|
2341
|
+
throw new Error('newChange=' + label + ' 的 exit 行为与无字段不一致: ' + got.exit + ' ≠ ' + without.exit);
|
|
2342
|
+
}
|
|
2343
|
+
if (got.statusJson !== without.statusJson) {
|
|
2344
|
+
throw new Error('newChange=' + label + ' 的 status 输出与无字段不一致');
|
|
2345
|
+
}
|
|
2346
|
+
}
|
|
2347
|
+
// 单一行为 = 缺声明 BLOCKED:三态都拦(不是「只有某一态被拦」)
|
|
2348
|
+
if (!without.record.startsWith('1|')) throw new Error('缺声明 record 应 BLOCKED(exit 1),实际: ' + without.record);
|
|
2349
|
+
if (!without.exit.startsWith('1|')) throw new Error('缺声明 exit 应 BLOCKED(exit 1),实际: ' + without.exit);
|
|
2350
|
+
// 旧值被容忍:status 不报 schema 错误,且 JSON 不再输出该键
|
|
2351
|
+
if (without.statusCode !== 0) throw new Error('旧状态带 newChange 时 status 不应报错,实际 exit ' + without.statusCode);
|
|
2352
|
+
if (without.statusJson.includes('newChange')) {
|
|
2353
|
+
throw new Error('status JSON 不应再输出 newChange 键: ' + without.statusJson.slice(0, 200));
|
|
2354
|
+
}
|
|
1150
2355
|
},
|
|
1151
2356
|
},
|
|
1152
2357
|
|
|
1153
|
-
// 131:
|
|
1154
|
-
//
|
|
2358
|
+
// 131: 处置标记缺失与延期裁决门禁(含 Minor)在**无任何新旧标记字段**的状态下同样 BLOCKED
|
|
2359
|
+
// (单轨:不再有「旧 REVIEW 只 WARN」这一侧);有裁决 +[升级] 的条目照常放行。
|
|
1155
2360
|
{
|
|
1156
|
-
name: '131 review exit
|
|
2361
|
+
name: '131 review exit:处置标记缺失/延期待裁决一律 BLOCKED(无字段状态同判)',
|
|
1157
2362
|
run: (dir) => {
|
|
1158
2363
|
const st = baseState('review');
|
|
2364
|
+
st.enteredNodes = ['review'];
|
|
1159
2365
|
st.evidence.review = { summary: 'reviewed' };
|
|
1160
|
-
writeState(dir, st);
|
|
2366
|
+
writeState(dir, st);
|
|
2367
|
+
writeNodeDeclarationMarkers(dir, 'review');
|
|
1161
2368
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题A**: 某处存在一个需要记录的问题描述,但未给出任何处置结论\n\n## 结论\n\n通过\n');
|
|
1162
2369
|
const res = runGuard(['exit', 'review'], dir);
|
|
1163
|
-
assertExit(res,
|
|
1164
|
-
assertOut(res, '
|
|
1165
|
-
// 子断言:Major [转待办] 无用户裁决 →
|
|
2370
|
+
assertExit(res, 1);
|
|
2371
|
+
assertOut(res, '处置状态标记');
|
|
2372
|
+
// 子断言:Major [转待办] 无用户裁决 → BLOCKED(延期是用户决策点,reviewer 不得自行决定)
|
|
1166
2373
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F1 · 未裁决的延期**:某处问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
1167
2374
|
const resMajor = runGuard(['exit', 'review'], dir);
|
|
1168
|
-
assertExit(resMajor,
|
|
1169
|
-
assertOut(resMajor, '
|
|
2375
|
+
assertExit(resMajor, 1);
|
|
2376
|
+
assertOut(resMajor, 'BLOCKED');
|
|
1170
2377
|
assertOut(resMajor, 'Major');
|
|
1171
2378
|
assertOut(resMajor, '用户裁决');
|
|
1172
|
-
assertNotOut(resMajor, 'BLOCKED');
|
|
1173
2379
|
// 子断言:有同段用户裁决 + [升级] 承接 → 无该渐进告警
|
|
1174
2380
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F2 · 已裁决的延期**:某处问题 [升级] [转待办](用户裁决:接受延期)\n\n## 结论\n\n通过\n');
|
|
1175
2381
|
const resOk = runGuard(['exit', 'review'], dir);
|
|
1176
2382
|
assertExit(resOk, 0);
|
|
1177
2383
|
assertNotOut(resOk, '用户裁决');
|
|
1178
2384
|
assertOut(resOk, 'ALL CHECKS PASSED');
|
|
1179
|
-
// 子断言:有序 Major [转待办] 无用户裁决 →
|
|
2385
|
+
// 子断言:有序 Major [转待办] 无用户裁决 → 同判 BLOCKED(有序同口径)
|
|
1180
2386
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n1. **F3 · 有序未裁决的延期**:某处问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
1181
2387
|
const resOrderedMajor = runGuard(['exit', 'review'], dir);
|
|
1182
|
-
assertExit(resOrderedMajor,
|
|
1183
|
-
assertOut(resOrderedMajor, '
|
|
2388
|
+
assertExit(resOrderedMajor, 1);
|
|
2389
|
+
assertOut(resOrderedMajor, 'BLOCKED');
|
|
1184
2390
|
assertOut(resOrderedMajor, '用户裁决');
|
|
1185
|
-
|
|
2391
|
+
// 子断言:Minor [转待办] 无用户裁决 → BLOCKED(延期门禁覆盖任何严重度)
|
|
2392
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-6 · 未裁决的小项**:某处小问题 [转待办]\n\n## 结论\n\n通过\n');
|
|
2393
|
+
const resMinorDeferred = runGuard(['exit', 'review'], dir);
|
|
2394
|
+
assertExit(resMinorDeferred, 1);
|
|
2395
|
+
assertOut(resMinorDeferred, 'BLOCKED');
|
|
2396
|
+
assertOut(resMinorDeferred, 'm-6 · 未裁决的小项');
|
|
2397
|
+
assertOut(resMinorDeferred, '用户裁决');
|
|
2398
|
+
// 子断言:Minor [转待办] + 裁决记录但缺「判 Minor:」判据 → BLOCKED
|
|
2399
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-7 · 缺判据的小项**:某处小问题 [升级] [转待办]\n\n- 用户裁决:接受延期 —— 发现 m-7:下一 change 首修。\n\n## 结论\n\n通过\n');
|
|
2400
|
+
const resMinorNoReason = runGuard(['exit', 'review'], dir);
|
|
2401
|
+
assertExit(resMinorNoReason, 1);
|
|
2402
|
+
assertOut(resMinorNoReason, 'BLOCKED');
|
|
2403
|
+
assertOut(resMinorNoReason, '判 Minor:');
|
|
2404
|
+
// 子断言:[已修] 的 Minor 缺判据同样 BLOCKED(判据落在判定当时,与处置标记无关)
|
|
2405
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-8 · 已修缺判据的小项**:某处小问题 [已修]\n\n## 结论\n\n通过\n');
|
|
2406
|
+
const resMinorFixedNoReason = runGuard(['exit', 'review'], dir);
|
|
2407
|
+
assertExit(resMinorFixedNoReason, 1);
|
|
2408
|
+
assertOut(resMinorFixedNoReason, 'BLOCKED');
|
|
2409
|
+
assertOut(resMinorFixedNoReason, 'm-8 · 已修缺判据的小项');
|
|
2410
|
+
assertOut(resMinorFixedNoReason, '判 Minor:');
|
|
1186
2411
|
},
|
|
1187
2412
|
},
|
|
1188
2413
|
|
|
1189
|
-
// 132: R3
|
|
2414
|
+
// 132: R3 退役——auto 标记提示随自动补写删除;残留 auto 标记不产生提示,也不替本节点
|
|
2415
|
+
// 其它必需项作证(覆盖门照常逐项点名 BLOCKED)
|
|
1190
2416
|
{
|
|
1191
|
-
name: '132
|
|
2417
|
+
name: '132 auto 声明标记不再提示且不替其它必需项作证(R3 退役)',
|
|
1192
2418
|
run: (dir) => {
|
|
1193
|
-
// 技能加载前置门对齐:record 无声明标记在新 change 下 BLOCK——本场景测 exit 的
|
|
1194
|
-
// auto 标记提示,改用旧 change(无 newChange)构造,保留 record 通过 + exit auto 提示
|
|
1195
|
-
// 的测试意图(新 change 无声明记录由前置门场景覆盖)。
|
|
1196
2419
|
const st = baseState('open');
|
|
2420
|
+
st.evidence.open = { summary: 'intake' };
|
|
1197
2421
|
writeState(dir, st);
|
|
1198
|
-
|
|
1199
|
-
|
|
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');
|
|
2422
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', intakeChangeText());
|
|
2423
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', intakeRequirementText());
|
|
1202
2424
|
fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID, '.skill-loads'), { recursive: true });
|
|
1203
2425
|
writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
|
|
1204
2426
|
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
2427
|
const res = runGuard(['exit', 'open'], dir);
|
|
1206
|
-
assertExit(res,
|
|
1207
|
-
assertOut(res, '
|
|
2428
|
+
assertExit(res, 1);
|
|
2429
|
+
assertOut(res, 'BLOCKED');
|
|
2430
|
+
assertOut(res, '缺必需技能声明: flow-comet-requirement');
|
|
2431
|
+
assertNotOut(res, 'SKILL-LOAD HINT');
|
|
2432
|
+
assertNotOut(res, '自动补写');
|
|
1208
2433
|
},
|
|
1209
2434
|
},
|
|
1210
2435
|
|
|
@@ -1214,8 +2439,8 @@ export const ENTRIES = [
|
|
|
1214
2439
|
run: (dir) => {
|
|
1215
2440
|
const st = baseState('execute');
|
|
1216
2441
|
st.evidence.execute = { summary: 'empty', emptyExitApproved: true };
|
|
1217
|
-
st.newChange = true;
|
|
1218
2442
|
writeState(dir, st);
|
|
2443
|
+
writeNodeDeclarationMarkers(dir, 'execute');
|
|
1219
2444
|
assertExit(runGuard(['entry', 'execute'], dir), 0);
|
|
1220
2445
|
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
2446
|
const res = runGuard(['exit', 'execute'], dir);
|
|
@@ -1231,28 +2456,25 @@ export const ENTRIES = [
|
|
|
1231
2456
|
const st = baseState('execute');
|
|
1232
2457
|
st.evidence.execute = { summary: 'executed' };
|
|
1233
2458
|
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01', 'T02']) };
|
|
1234
|
-
st.newChange = true;
|
|
1235
2459
|
writeState(dir, st);
|
|
1236
2460
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE_TWO);
|
|
1237
|
-
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md',
|
|
2461
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', strictSummary('T01'));
|
|
1238
2462
|
const res = runGuard(['exit', 'execute'], dir); // T02 缺 SUMMARY
|
|
1239
2463
|
assertExit(res, 1);
|
|
1240
2464
|
assertOut(res, '恢复:');
|
|
1241
2465
|
},
|
|
1242
2466
|
},
|
|
1243
2467
|
|
|
1244
|
-
// 135:
|
|
1245
|
-
//
|
|
1246
|
-
// 旧 change 同构造 → BROOKS-LINT WARN 渐进(兼容保留,L2457)
|
|
2468
|
+
// 135: 自检方法段含 brooks-review 声明但缺 `## 自检方法` 段标题(旧格式形态) → BLOCKED;
|
|
2469
|
+
// 旧状态带 newChange 字段同构造 → 同判(字段只被忽略)
|
|
1247
2470
|
{
|
|
1248
|
-
name: '135 execute exit BLOCKED
|
|
2471
|
+
name: '135 execute exit BLOCKED:自检方法段缺标题(旧格式分支)',
|
|
1249
2472
|
run: (dir) => {
|
|
1250
2473
|
// ① 新 change(newChange:true):T01-SUMMARY 含 brooks-review 声明(6 维自查+方法行)但缺
|
|
1251
2474
|
// `## 自检方法` 段标题(旧格式) → BLOCKED(自检方法段强制;恢复:补 ## 自检方法 段标题)
|
|
1252
2475
|
const st = baseState('execute');
|
|
1253
2476
|
st.evidence.execute = { summary: 'executed' };
|
|
1254
2477
|
st.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
1255
|
-
st.newChange = true;
|
|
1256
2478
|
writeState(dir, st);
|
|
1257
2479
|
assertExit(runGuard(['entry', 'execute'], dir), 0); // R2: 新 change 须先 entry
|
|
1258
2480
|
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_DONE);
|
|
@@ -1260,15 +2482,16 @@ export const ENTRIES = [
|
|
|
1260
2482
|
const res = runGuard(['exit', 'execute'], dir);
|
|
1261
2483
|
assertExit(res, 1);
|
|
1262
2484
|
assertOut(res, '自检方法');
|
|
1263
|
-
// ②
|
|
2485
|
+
// ② 旧状态带 newChange 字段 + 同构造 → 同判 BLOCKED(字段只被忽略,不再有 WARN 侧)
|
|
1264
2486
|
const stOld = baseState('execute');
|
|
1265
2487
|
stOld.evidence.execute = { summary: 'executed' };
|
|
1266
2488
|
stOld.evidence['subagent-execute'] = { handoffResult: handoffFor(['T01']) };
|
|
2489
|
+
stOld.newChange = true;
|
|
1267
2490
|
writeState(dir, stOld);
|
|
1268
2491
|
writeFile(dir, '.specs/' + CHANGE_ID + '/T01-SUMMARY.md', summaryContent({ method: 'brooks-review' }));
|
|
1269
2492
|
const resOld = runGuard(['exit', 'execute'], dir);
|
|
1270
|
-
assertExit(resOld,
|
|
1271
|
-
assertOut(resOld, '
|
|
2493
|
+
assertExit(resOld, 1);
|
|
2494
|
+
assertOut(resOld, '自检方法');
|
|
1272
2495
|
},
|
|
1273
2496
|
},
|
|
1274
2497
|
|
|
@@ -1353,8 +2576,8 @@ export const ENTRIES = [
|
|
|
1353
2576
|
const st = baseState('review');
|
|
1354
2577
|
st.completedNodes = ['open', 'design', 'plan', 'execute', 'subagent-execute'];
|
|
1355
2578
|
st.evidence.review = { summary: 'reviewed' }; // record 过但 exit 被拦截
|
|
1356
|
-
st.newChange = true;
|
|
1357
2579
|
writeState(dir, st);
|
|
2580
|
+
writeNodeDeclarationMarkers(dir, 'review');
|
|
1358
2581
|
// 前序产物(execute 产物门控需 *-SUMMARY.md)
|
|
1359
2582
|
writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why(为什么做)\nx');
|
|
1360
2583
|
writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\nx\n\n## 验收准则(AC)\n- Given x When y Then z');
|