flow-comet 1.6.4 → 1.7.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.
Files changed (85) hide show
  1. package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
  2. package/.flow-comet/skills/flow-comet/SKILL.md +36 -6
  3. package/.flow-comet/skills/flow-comet/reference/artifact-template-overlay.md +154 -0
  4. package/.flow-comet/skills/flow-comet/reference/artifact-templates.json +387 -0
  5. package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +1 -1
  6. package/.flow-comet/skills/flow-comet/reference/entry-detail.md +29 -4
  7. package/.flow-comet/skills/flow-comet/reference/workflow-protocol.json +22 -0
  8. package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +26 -23
  9. package/.flow-comet/skills/flow-comet/scripts/evolve.mjs +174 -0
  10. package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +17 -95
  11. package/.flow-comet/skills/flow-comet/scripts/health.mjs +28 -4
  12. package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +136 -19
  13. package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +54 -18
  14. package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +6 -6
  15. package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +52 -10
  16. package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +25 -10
  17. package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +4 -2
  18. package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +21 -13
  19. package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +163 -0
  20. package/.flow-comet/skills/flow-comet/scripts/lib/ac-coverage.mjs +317 -0
  21. package/.flow-comet/skills/flow-comet/scripts/lib/guard-artifact-skeleton.mjs +448 -0
  22. package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +396 -27
  23. package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +1035 -172
  24. package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +129 -98
  25. package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +8 -6
  26. package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +797 -232
  27. package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +91 -22
  28. package/.flow-comet/skills/flow-comet/scripts/lib/lessons-hits.mjs +160 -0
  29. package/.flow-comet/skills/flow-comet/scripts/lib/run-root.mjs +21 -0
  30. package/.flow-comet/skills/flow-comet/scripts/lib/section-body.mjs +92 -0
  31. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +69 -13
  32. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +454 -135
  33. package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +66 -0
  34. package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +109 -13
  35. package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +55 -2
  36. package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +149 -34
  37. package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +79 -9
  38. package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +84 -31
  39. package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +78 -8
  40. package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +60 -3
  41. package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +167 -3
  42. package/.flow-comet/skills/flow-comet/scripts/lib/wave-projection.mjs +341 -0
  43. package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +287 -0
  44. package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +1454 -16
  45. package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1202 -8
  46. package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1205 -77
  47. package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +753 -5
  48. package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +52 -11
  49. package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +582 -3
  50. package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +9 -1
  51. package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +5 -0
  52. package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +22 -6
  53. package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +2 -0
  54. package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +18 -5
  55. package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +4100 -0
  56. package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +135 -0
  57. package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +6 -5
  58. package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +203 -4
  59. package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +312 -63
  60. package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +5 -2
  61. package/.flow-comet/skills/flow-comet-archive/SKILL.md +6 -2
  62. package/.flow-comet/skills/flow-comet-change/SKILL.md +6 -2
  63. package/.flow-comet/skills/flow-comet-design/GUIDANCE.md +13 -3
  64. package/.flow-comet/skills/flow-comet-design/SKILL.md +15 -8
  65. package/.flow-comet/skills/flow-comet-dev/SKILL.md +1 -1
  66. package/.flow-comet/skills/flow-comet-evolve/SKILL.md +1 -0
  67. package/.flow-comet/skills/flow-comet-execute/SKILL.md +42 -15
  68. package/.flow-comet/skills/flow-comet-health/SKILL.md +1 -1
  69. package/.flow-comet/skills/flow-comet-integration/SKILL.md +1 -1
  70. package/.flow-comet/skills/flow-comet-open/GUIDANCE.md +14 -4
  71. package/.flow-comet/skills/flow-comet-open/SKILL.md +11 -9
  72. package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +13 -3
  73. package/.flow-comet/skills/flow-comet-plan/SKILL.md +21 -10
  74. package/.flow-comet/skills/flow-comet-requirement/SKILL.md +1 -1
  75. package/.flow-comet/skills/flow-comet-review/SKILL.md +33 -18
  76. package/.flow-comet/skills/flow-comet-subagent-execute/GUIDANCE.md +13 -3
  77. package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +44 -16
  78. package/.flow-comet/skills/flow-comet-task/SKILL.md +3 -2
  79. package/.flow-comet/skills/flow-comet-test/SKILL.md +6 -2
  80. package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +2 -2
  81. package/.flow-comet/skills/flow-comet-verify/SKILL.md +12 -8
  82. package/README.md +3 -3
  83. package/package.json +1 -1
  84. package/scripts/dsh-bridge.mjs +2 -2
  85. package/scripts/lib/installer-flowkit.mjs +43 -3
@@ -11,24 +11,30 @@ 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
+ REPO_ROOT,
22
27
  SCRIPTS_DIR,
23
28
  TASK_DONE,
24
29
  TASK_DONE_TWO,
25
30
  TASK_P1,
26
31
  customProtocolWithSkillCall,
27
32
  handoffFor,
28
- isAuthoritativeSourceRepo,
33
+ makeTmp,
29
34
  summaryContent,
30
35
  writeCustomProtocol,
31
36
  writeIntakeArtifacts,
37
+ writeNodeDeclarationMarkers,
32
38
  } from '../lib/test-fixtures.mjs';
33
39
  import {
34
40
  assertOutMatches,
@@ -38,25 +44,711 @@ import {
38
44
  scenarioProtocolPath,
39
45
  } from '../lib/test-assertions.mjs';
40
46
  import {
47
+ PUBLIC_FACE_DOCS_DIR,
48
+ PUBLIC_FACE_SELF_CHECK_SKIP_NOTICE,
49
+ VISUAL_TONE_APPLICABLE,
50
+ authoritativeSourceAt,
41
51
  countSyncProblems,
52
+ publicFaceDocsAbsent,
53
+ writeDesignExitFixture,
42
54
  } from '../lib/text-anchor-checks.mjs';
43
55
 
56
+ // ---------- 公开面的机器状态字段名口径 + 命令锚(机检;判据与反向构造共用本实现) ----------
57
+ // 规则:公开说明面不直写机器状态字段名——引擎在状态文件里拥有的键要么改述为行为描述,要么放进
58
+ // **明确标注**的状态输出示例围栏块(白名单)。判据是「键名黑名单 + 示例块白名单」而非精确句锁:
59
+ // 改述措辞可以自由演化,键名不能重新走私进正文。routeNode 属公开输出契约名,不在黑名单内。
60
+ // 受检面不手抄:从 docs/authority-map.json(公开文档权威与姊妹文档的唯一声明处)取 authority/twin
61
+ // 两侧,再并上根目录文档与 docs/examples 的目录扫描——新增公开文档只要登记进映射、或按惯例落在
62
+ // 根目录,字段名扫描与命令锚两处判据同时覆盖,不会出现「加进一个清单、漏掉另一个」的静默窄化。
63
+ // 两类结构性排除(都不是行为描述面):① 变更日志——按时间的历史记录,条目引用当时发布的措辞与
64
+ // 当时的机器字段名;② 根目录的代理指令文件——本地工作说明,不面向用户、不随包分发。
65
+ const PUBLIC_FACE_AUTHORITY_MAP = 'docs/authority-map.json';
66
+ const PUBLIC_FACE_EXAMPLES_DIR = 'docs/examples';
67
+ const PUBLIC_FACE_HISTORY_DOCS = ['CHANGELOG.md', 'CHANGELOG-zh.md'];
68
+ const PUBLIC_FACE_AGENT_DOCS = ['AGENTS.md', 'CLAUDE.md'];
69
+ // 示例块白名单的标记词:围栏 info string,或围栏之上紧邻的最后一行非空正文(标题 / 说明)写明
70
+ // 这是状态输出示例——只有明说「这是示例数据」才放行,普通代码块不因此获得豁免。
71
+ const PUBLIC_FACE_EXAMPLE_MARKERS = ['状态输出示例', 'state output example', 'status output example'];
72
+ // 机器状态字段黑名单 = 引擎在状态文件里拥有、**绝不由人写**的键(state-schema 的机器自有字段)。
73
+ // 名单不按「今天文档里写了什么」取,而按「状态文件里真的有什么」取:这些键一旦被公开面当成用户
74
+ // 面契约直写,读者就会以为可以手改它们。新增机器字段时在这里登记,判据才跟着扩展。
75
+ // 驼峰键名在英文 / 中文散文里都不会自然出现,故任何位置命中都算直写(不必依赖反引号)。
76
+ const PUBLIC_FACE_STATE_FIELDS = [
77
+ 'currentNode', 'stateCurrentNode',
78
+ 'completedNodes', 'enteredNodes', 'directOverride', 'newChange',
79
+ // verifyFailures 用前缀匹配覆盖同族的 verifyFailuresByChange(见 fieldNameHitsOnLine)
80
+ 'verifyFailures',
81
+ ];
82
+ // evidence 另有散文形态(见 EVIDENCE_FIELD_FRAME_RE 与 fieldNameHitsOnLine 的放行规则)。
83
+ // 结构预检命令的公开面锚:三份文档 × 中英都必须在案。新增公开命令不得没有锚——否则删掉或漏写
84
+ // 其中任何一份,套件仍然全绿,公开面就真的丢了这条命令。这里只选主题名,路径仍从映射取——「哪份
85
+ // 文档承载命令说明」因此也只在映射里声明一次。
86
+ const PUBLIC_FACE_PREFLIGHT_TOPICS = ['behaviour', 'workflow', 'troubleshooting'];
87
+ const PREFLIGHT_FLAG = '--preflight';
88
+
89
+ function listMarkdownFiles(absDir, relDir) {
90
+ const out = [];
91
+ for (const entry of fs.readdirSync(absDir, { withFileTypes: true })) {
92
+ const rel = relDir + '/' + entry.name;
93
+ if (entry.isDirectory()) out.push(...listMarkdownFiles(path.join(absDir, entry.name), rel));
94
+ else if (entry.name.endsWith('.md')) out.push(rel);
95
+ }
96
+ return out;
97
+ }
98
+
99
+ // 形态判据(公开面能不能派生):先问「这份检出有没有公开文档面」,再谈派生——npm 包按 package.json
100
+ // 的 files 白名单只分发 .flow-comet/skills 与 rules,不含 docs/、CONTRIBUTING.md 与 .github/;安装
101
+ // 副本同理。这种形态下「受检面无法派生」不是缺文件事故,而是载体的**正常形态**,说成「仓库缺文件」
102
+ // 会把读者引到修复一个不存在的缺陷上。判据落点选**这三份公开面载体是否俱缺**,而不是权威映射文件
103
+ // 在不在:只看 docs/ 不够——分支 / 稀疏检出 / 误删把 docs/ 整份拿掉时,「本载体不含公开面」变成假话,
104
+ // 计数一致性 / 零代号 / 词表镜像会整块跳过;docs/ 在、映射缺 = 检出被裁坏,仍要在读取处显式失败
105
+ // (判据强度不降——跳过通道只对「整份公开面不存在」开放)。
106
+ // 形态判据与其跳过提示**从 lib 共用**(底部自检的公开面自检用同一对):同一种形态在两处各判一次,
107
+ // 两份实现迟早各说各话——一处把包形态说成「缺文件」、另一处说成「跳过」,正是本批修掉的误诊。
108
+ // 判据落点与措辞只在 lib/text-anchor-checks.mjs 维护(PUBLIC_FACE_DOCS_DIR / publicFaceDocsAbsent /
109
+ // PUBLIC_FACE_SELF_CHECK_SKIP_NOTICE)。
110
+
111
+ // 权威映射缺席或不可解析 = 受检面无从派生(不是「没有东西要查」):显式失败,不静默退化。
112
+ // root 可覆盖读取根(默认仓库根)——仅为可测性接缝:形态判据的探针要在夹具目录上验证「docs/ 在、
113
+ // 映射缺仍显式失败」,生产调用不传。
114
+ function readPublicFaceAuthorityMap(root = REPO_ROOT) {
115
+ const abs = path.join(root, ...PUBLIC_FACE_AUTHORITY_MAP.split('/'));
116
+ if (!fs.existsSync(abs)) {
117
+ throw new Error('受检面无法派生:' + PUBLIC_FACE_AUTHORITY_MAP
118
+ + ' 不在本检出(公开文档权威映射是受检面的唯一来源)');
119
+ }
120
+ const parsed = JSON.parse(fs.readFileSync(abs, 'utf8'));
121
+ if (!parsed || typeof parsed !== 'object' || !parsed.topics || typeof parsed.topics !== 'object') {
122
+ throw new Error('受检面无法派生:' + PUBLIC_FACE_AUTHORITY_MAP + ' 缺 topics 对象');
123
+ }
124
+ return parsed;
125
+ }
126
+
127
+ // 映射的每个主题 → [authority, twin](twin 为 null 的主题只登记权威侧)。
128
+ // 畸形或空主题一律抛错而不是跳过:跳过等于把该主题的文档静默移出受检面——字段名黑名单与命令锚
129
+ // 都不再落到它们身上,而套件依然全绿。主题写坏是可判定的失配,就该是一次显式失败。
130
+ function publicFaceTopicPairs(map) {
131
+ const pairs = new Map();
132
+ for (const [topic, spec] of Object.entries(map.topics)) {
133
+ if (!spec || typeof spec !== 'object' || Array.isArray(spec)) {
134
+ throw new Error('受检面无法派生:' + PUBLIC_FACE_AUTHORITY_MAP + ' 的主题 ' + topic + ' 不是对象');
135
+ }
136
+ const pair = [spec.authority, spec.twin].filter((rel) => typeof rel === 'string' && rel.trim() !== '');
137
+ if (pair.length === 0) {
138
+ throw new Error('受检面无法派生:' + PUBLIC_FACE_AUTHORITY_MAP + ' 的主题 ' + topic
139
+ + ' 未登记任何文档路径(authority 与 twin 都为空)');
140
+ }
141
+ pairs.set(topic, pair);
142
+ }
143
+ return pairs;
144
+ }
145
+
146
+ // 受检文档集合 = 映射两侧 ∪ 根目录文档,再减去上面两类排除面。根目录扫描是必要的:按 GitHub 惯例
147
+ // 放在根目录的公开文件里有整份未登记进映射的(CODE_OF_CONDUCT 及其双语版、SECURITY-zh.md),
148
+ // 只靠映射会静默漏掉它们。
149
+ function publicFaceDocPaths(map) {
150
+ const paths = new Set();
151
+ for (const pair of publicFaceTopicPairs(map).values()) for (const rel of pair) paths.add(rel);
152
+ for (const entry of fs.readdirSync(REPO_ROOT, { withFileTypes: true })) {
153
+ if (entry.isFile() && entry.name.endsWith('.md')) paths.add(entry.name);
154
+ }
155
+ for (const rel of [...PUBLIC_FACE_HISTORY_DOCS, ...PUBLIC_FACE_AGENT_DOCS]) paths.delete(rel);
156
+ return [...paths].sort();
157
+ }
158
+
159
+ // 命令锚所在的文档:按主题名从映射取(路径不在此手抄)。
160
+ // 主题名取不到即抛错:空集会把锚的受检文档集清空,于是命令锚被整段删掉也不红——「新增公开命令
161
+ // 不得无锚」这条判据要防的正是这种静默窄化,主题改名或写错必须显式失败。
162
+ function publicFacePreflightDocs(map) {
163
+ const pairs = publicFaceTopicPairs(map);
164
+ const docs = [];
165
+ for (const topic of PUBLIC_FACE_PREFLIGHT_TOPICS) {
166
+ const pair = pairs.get(topic);
167
+ if (!pair) {
168
+ throw new Error('受检面无法派生:' + PUBLIC_FACE_AUTHORITY_MAP + ' 未登记主题 ' + topic
169
+ + '(命令锚文档按主题名派生;主题改名时须同步本判据,不得让锚随主题一起消失)');
170
+ }
171
+ docs.push(...pair);
172
+ }
173
+ return docs;
174
+ }
175
+
176
+ // 受检快照 { texts, preflightDocs },文本按 Map 组织(rel → 文本或 null):判据只读这一份快照,
177
+ // 反向构造在副本上作业。
178
+ function readPublicFaceTexts() {
179
+ const map = readPublicFaceAuthorityMap();
180
+ const texts = new Map();
181
+ for (const rel of publicFaceDocPaths(map)) {
182
+ const abs = path.join(REPO_ROOT, ...rel.split('/'));
183
+ texts.set(rel, fs.existsSync(abs) ? fs.readFileSync(abs, 'utf8') : null);
184
+ }
185
+ const examplesRoot = path.join(REPO_ROOT, ...PUBLIC_FACE_EXAMPLES_DIR.split('/'));
186
+ if (!fs.existsSync(examplesRoot)) {
187
+ // 整面缺席显式报告:静默等于把「本检出没有示例面」当成「示例面已校验」。
188
+ texts.set(PUBLIC_FACE_EXAMPLES_DIR + '/**/*.md', null);
189
+ } else {
190
+ for (const rel of listMarkdownFiles(examplesRoot, PUBLIC_FACE_EXAMPLES_DIR)) {
191
+ texts.set(rel, fs.readFileSync(path.join(REPO_ROOT, ...rel.split('/')), 'utf8'));
192
+ }
193
+ }
194
+ return { texts, preflightDocs: publicFacePreflightDocs(map) };
195
+ }
196
+
197
+ function isStatusExampleMarker(line) {
198
+ const lowered = line.toLowerCase();
199
+ return PUBLIC_FACE_EXAMPLE_MARKERS.some((marker) => lowered.includes(marker.toLowerCase()));
200
+ }
201
+
202
+ // 报错要能直接照做:先点名键名与改述方向,再给出唯一的合法展示出口(标注为状态输出示例的
203
+ // 围栏块)——否则作者只知道「不能写」,不知道「要展示时该怎么写」。
204
+ function fieldNameViolation(where, fieldName) {
205
+ return where + ' 直写了机器状态字段名 ' + fieldName
206
+ + '(改述为行为描述;确需展示状态输出时,放进标注为「状态输出示例」的围栏块)';
207
+ }
208
+
209
+ // 「指名某个字段」的散文框:the `evidence` field / the evidence field / evidence 字段。**单数**才
210
+ // 构成指名——复数的 "the evidence fields" 是集合描述(公开面本就有这类句子:the output schemas,
211
+ // the gates, the commands, the evidence fields),不指名任何键。
212
+ const EVIDENCE_FIELD_FRAME_RE = /(?<![A-Za-z0-9_$])`?evidence`?\s+(?:field|字段)(?![A-Za-z0-9_$])/;
213
+
214
+ // 键名判据:驼峰键名任何位置命中都算直写(散文里不会自然出现,不必依赖反引号);evidence 是普通
215
+ // 英文名词与状态键同形,只在**被当成字段名写**时算违规:
216
+ // ① 独立成键名的反引号段 `evidence`;
217
+ // ② 指名它的散文框(EVIDENCE_FIELD_FRAME_RE,带不带反引号都命中);
218
+ // ③ 裸属性后缀 `.evidence`(单独写成字段路径)。
219
+ // 放行规则(两类都不是「行为描述面」,故不构成字段名直写):
220
+ // ① **代码位置引用**:state.evidence 这类带宿主标识符的属性访问说的是「去哪看」,不是把键名写成
221
+ // 文档契约——「裸 .evidence」与「X.evidence」由同一个连接式前后界区分,不另写键表;
222
+ // ② **围栏里的示例**:标注为状态输出示例的围栏块整块放行(既有白名单,双向探针在场景 105)。
223
+ // 未标注的围栏块不因「它是代码」而豁免:把状态输出贴进普通代码块同样是直写。
224
+ // 其余自然语言用法("the evidence recorded for the node"、`evidence: [{ id, required }]` 这类
225
+ // 协议字段说明)不命中任何一条。
226
+ function fieldNameHitsOnLine(where, line) {
227
+ const out = [];
228
+ for (const name of PUBLIC_FACE_STATE_FIELDS) {
229
+ // verifyFailures 用前缀匹配:verifyFailuresByChange 是同一族的键,漏掉它等于留后门。
230
+ const matcher = name === 'verifyFailures'
231
+ ? /(?<![A-Za-z0-9_$])verifyFailures[A-Za-z0-9_]*/g
232
+ : new RegExp('(?<![A-Za-z0-9_$])' + name + '(?![A-Za-z0-9_$])', 'g');
233
+ for (const hit of line.matchAll(matcher)) out.push(fieldNameViolation(where, hit[0]));
234
+ }
235
+ for (const span of line.matchAll(/`([^`]*)`/g)) {
236
+ if (span[1].trim() === 'evidence') out.push(fieldNameViolation(where, 'evidence'));
237
+ }
238
+ if (EVIDENCE_FIELD_FRAME_RE.test(line)) out.push(fieldNameViolation(where, 'evidence'));
239
+ if (/(?<![A-Za-z0-9_$])\.evidence(?![A-Za-z0-9_$])/.test(line)) {
240
+ out.push(fieldNameViolation(where, 'evidence'));
241
+ }
242
+ return out;
243
+ }
244
+
245
+ // 逐行扫描:未标注的围栏块同样是正文(把状态输出贴进普通代码块不等于获得白名单);标注为
246
+ // 状态输出示例的围栏块整块放行。行内反引号段里的 evidence 是被当作键名书写,散文里的不是。
247
+ function publicFaceFieldProblems(rel, text) {
248
+ const out = [];
249
+ const lines = text.split(/\r?\n/);
250
+ let fence = null;
251
+ let fenceIsExample = false;
252
+ let lastContentLine = '';
253
+ for (let i = 0; i < lines.length; i += 1) {
254
+ const line = lines[i];
255
+ const opening = /^\s{0,3}(`{3,}|~{3,})(.*)$/.exec(line);
256
+ if (fence === null && opening) {
257
+ fence = opening[1][0];
258
+ fenceIsExample = isStatusExampleMarker(opening[2]) || isStatusExampleMarker(lastContentLine);
259
+ continue;
260
+ }
261
+ if (fence !== null) {
262
+ if (new RegExp('^\\s{0,3}' + fence + '{3,}\\s*$').test(line)) {
263
+ fence = null;
264
+ fenceIsExample = false;
265
+ } else if (!fenceIsExample) {
266
+ out.push(...fieldNameHitsOnLine(rel + ':' + (i + 1), line));
267
+ }
268
+ continue;
269
+ }
270
+ if (line.trim() !== '') lastContentLine = line.trim();
271
+ out.push(...fieldNameHitsOnLine(rel + ':' + (i + 1), line));
272
+ }
273
+ return out;
274
+ }
275
+
276
+ function publicFaceMachineProblems({ texts, preflightDocs }) {
277
+ const out = [];
278
+ for (const [rel, text] of texts) {
279
+ if (typeof text !== 'string') out.push(rel + ' 缺失(公开面不在本检出)');
280
+ }
281
+ for (const [rel, text] of texts) {
282
+ if (typeof text === 'string') out.push(...publicFaceFieldProblems(rel, text));
283
+ }
284
+ for (const rel of preflightDocs) {
285
+ const text = texts.get(rel);
286
+ if (typeof text === 'string' && !text.includes(PREFLIGHT_FLAG)) {
287
+ out.push(rel + ' 缺「' + PREFLIGHT_FLAG + '」锚(结构预检命令须在三份公开面 × 中英在案)');
288
+ }
289
+ }
290
+ return out;
291
+ }
292
+
293
+ // ---------- 权威源设计形态锚(形态探测与上面同源:.flow-comet/ 技能树在场 = 权威源检出) ----------
294
+ // 设计形态 = 权威源册子里写出的命令形态(.claude/skills/flow-comet/scripts/…,相对路径),安装时由
295
+ // prepare-env 的 pathReplacements 按平台替换。锚的就是这个形态:安装副本按运行根推导同样是对的,但
296
+ // 那是另一种载体下的正确形态——两种形态混进一条判据,就谁也锁不住(谁都能满足它)。
297
+ const DESIGN_FORM_SCRIPTS_DIR = '.claude/skills/flow-comet/scripts';
298
+ // 「本锚只在权威源检出运行」的判据必须看**正在跑的是哪套脚本**,而不是「仓库里有没有 .flow-comet/」——
299
+ // 仓库里同时存在 .claude|.agents|.dsh 三份副本,跑副本套件时仓库根锚照样在场;只用根锚会把副本误判成权威源,
300
+ // 让安装副本按运行根打印的(对副本而言正确的)路径被判成违规。
301
+ const RUNS_FROM_AUTHORITATIVE_SCRIPTS = path.relative(REPO_ROOT, SCRIPTS_DIR).split(path.sep).join('/') === '.flow-comet/skills/flow-comet/scripts';
302
+
303
+ // 恢复段的形态锚(只在权威源检出运行)。场景 34 的恢复命令断言已改成行为判据(存在 + basename
304
+ // + 真执行),三种形态的路径都能满足——于是「权威源打印设计形态」失去锁:把 scriptCommand 改成恒打印
305
+ // 绝对安装根,行为判据全绿,而权威源册子里的命令会开始写本机路径。本锚只读打印出来的那段恢复报文
306
+ // (不拿 harness 的脚本路径替代),要求命令的脚本路径逐字等于设计形态。
307
+ // 锁的是「段内有一条 record 命令 + 路径是设计形态 + 步骤按执行顺序」,不锁「record 紧贴『恢复:』」
308
+ // 这种书写形态:措辞可以演化,能按顺序照抄走通才是判据——顺序反了,执行者从上往下第一步就撞门。
309
+ function assertDesignFormRecoveryPath(dir) {
310
+ // 触发一条走 scriptCommand 的恢复指引:subagent-execute 有 handoff 结果、缺 summary → 出口按
311
+ // Output Schema evidence 阻塞。夹具是全新临时目录 ⇒ 本节点还没有技能加载声明标记 ⇒ 走「先声明、
312
+ // 再 record」的两步形态(声明已在场时的收敛形态由场景 34 覆盖)。
313
+ const st = baseState('subagent-execute');
314
+ st.evidence['subagent-execute'] = { handoffResult: handoffFor(['P01']) };
315
+ writeState(dir, st);
316
+ writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n' + TASK_P1);
317
+ const res = runGuardWithProtocol(dir, ['exit', 'subagent-execute']);
318
+ assertExit(res, 1);
319
+ assertOut(res, 'BLOCKED: missing Output Schema evidence');
320
+ // 本段 = 输出里最后一条恢复段(该段之后引擎直接退出)。
321
+ const start = res.output.lastIndexOf('恢复:');
322
+ const block = start < 0 ? '' : res.output.slice(start);
323
+ if (block === '') {
324
+ throw new Error('缺 Output Schema evidence 的阻塞没给恢复段(设计形态锚无从判定):\n' + res.output);
325
+ }
326
+ // 两条命令(各自单独一行,行内只有命令本身):先声明技能加载,再 record。取法与照抄闭环同一处
327
+ // (printedCommandsOf)——恢复段的「哪一行是命令」只有一份判据,本锚不另写一条取行正则。
328
+ const skillLoadLine = printedCommandsOf(block, 'skill-load')[0];
329
+ const recordLine = printedCommandsOf(block, 'record')[0];
330
+ if (!skillLoadLine || !recordLine) {
331
+ throw new Error('恢复段应同时给出可照抄的 skill-load 与 record 命令'
332
+ + '(缺声明时照抄 record 会先被它自己的前置门拦下):\n' + block);
333
+ }
334
+ // 顺序 = 执行顺序,且步骤标注跟着各自的命令走(不是只在段首提一句)。
335
+ const skillAt = block.indexOf(skillLoadLine);
336
+ const recordAt = block.indexOf(recordLine);
337
+ if (!(skillAt >= 0 && recordAt > skillAt)) {
338
+ throw new Error('恢复段应按执行顺序排列:skill-load(声明技能加载)在前、record(补证据)在后——'
339
+ + '顺序反了执行者照抄会先撞前置门:\n' + block);
340
+ }
341
+ if (!block.slice(0, skillAt).includes('第一步')) {
342
+ throw new Error('恢复段未把技能加载声明标为第一步:\n' + block);
343
+ }
344
+ if (!block.slice(skillAt + skillLoadLine.length, recordAt).includes('第二步')) {
345
+ throw new Error('恢复段未把 record 标为第二步:\n' + block);
346
+ }
347
+ // 路径逐字等于设计形态(两条命令都经 scriptCommand,路径与引号只有这一处实现)。
348
+ const expected = DESIGN_FORM_SCRIPTS_DIR + '/workflow-state.mjs';
349
+ for (const [label, printed] of [['skill-load', skillLoadLine], ['record', recordLine]]) {
350
+ const printedPath = (printed.match(/^node "([^"]+)"/) || [])[1];
351
+ if (printedPath !== expected) {
352
+ throw new Error('权威源检出打印的恢复段 ' + label + ' 命令脚本路径应为设计形态 ' + expected
353
+ + '(相对路径)——实际: ' + JSON.stringify(printedPath)
354
+ + ';安装副本按运行根推导属另一种载体的正确形态,不在本锚范围(本锚只在权威源检出运行)');
355
+ }
356
+ }
357
+ }
358
+
359
+ // ---------- 恢复段给出的命令:解析 → 在夹具内逐字执行(照抄闭合) ----------
360
+ //
361
+ // 恢复段承诺的是「可照抄的命令」,判据就得**真的照抄**:从报文解析命令文本 → 按当前运行形态解析
362
+ // 脚本路径 → 用同一份参数跑一遍(只把 `node` 换成本进程的可执行文件——PATH 解析不是判据对象)。
363
+ // 这条链路的三个夹具(按安装布局复制技能树 / 打印命令切成 argv / 真实执行打印文本)与委托链路组
364
+ // 共用,单一来源在 lib/test-helpers.mjs;权威源打印的设计形态相对路径(.claude/skills/…)只在
365
+ // 复制进夹具的技能树里可解析,因此执行的是**打印文本**——拿 harness 的绝对脚本路径替代它,
366
+ //「这条命令能不能跑」就等于没判。本段只留声明恢复自己的夹具:重放根与逐条照抄执行。
367
+
368
+ // 照抄闭环自己的夹具根 + 协议副本:场景运行器给主夹具做的那两步,在闭环的独立根上再走一遍
369
+ // (协议文件必须在运行根内才会被守卫读取)。
370
+ function makeReplayRoot() {
371
+ const root = makeTmp();
372
+ fs.mkdirSync(path.dirname(scenarioProtocolPath(root)), { recursive: true });
373
+ fs.copyFileSync(BUILTIN_PROTOCOL_SOURCE, scenarioProtocolPath(root));
374
+ return root;
375
+ }
376
+
377
+ // 照抄执行段(两条闭环共用):按安装布局把本套件技能树复制进夹具(打印出来的设计形态相对路径才可
378
+ // 解析),并清掉环境里的协议注入——命令自带的协议上下文必须够用。返回逐条执行打印文本的函数,
379
+ // 非 0 即失败并回显命令。
380
+ function printedCommandReplay(root, label) {
381
+ installSkillTreeCopy(root, path.join('.claude', 'skills'));
382
+ const cleanEnv = { FLOW_COMET_RUN_ROOT: root, FLOW_COMET_PROTOCOL: '' };
383
+ return (command) => {
384
+ const res = runPrintedCommand(command, root, cleanEnv);
385
+ assertTrue(res.status === 0, label + ':照抄的命令跑不通\n 命令: ' + command
386
+ + '\n exit ' + res.status + '\n' + res.output);
387
+ return res;
388
+ };
389
+ }
390
+
391
+ // 恢复段 = 输出里最后一条「恢复:」起的整段(该段之后引擎直接退出)。
392
+ function lastRecoveryBlock(output) {
393
+ const text = String(output);
394
+ const start = text.lastIndexOf('恢复:');
395
+ return start < 0 ? '' : text.slice(start);
396
+ }
397
+
398
+ // 段内某一类命令的全部可照抄行:命令行自成一行(命令与说明分行——说明接在命令行尾时,整行丢给
399
+ // shell 会把说明当成参数)。判据只认「行首 = node + 引号脚本路径」这一形态,说明行因此不可能被读
400
+ // 成命令(同一个判据也用来证明恢复段里没有第二份命令文本)。
401
+ function printedCommandsOf(block, verb) {
402
+ const pattern = new RegExp('^\\s*(node "[^"]+" ' + verb + ' [^\\n]+)$', 'gm');
403
+ return [...block.matchAll(pattern)].map((match) => match[1]);
404
+ }
405
+
406
+ // 声明恢复的照抄闭合(open / review 同一条判据):删声明与证据 → exit 被拦 → **逐字照抄**报文给出的
407
+ // 每条命令(第一步的声明命令按序,再第二步的 record)→ 同一 exit 通过。缺陷形态:第一步只声明实现
408
+ // 技能 + 首份协议、且不带模板清单,照抄完同一 exit 仍被覆盖门点名(缺另一份协议文件与另一个必需
409
+ // 技能)——「报文各给一半」正是本断言要钉死的东西:照抄不了就是没修好。
410
+ function assertDeclarationRecoveryRoundTrip({ node, fixture, skills, prompts, templates }) {
411
+ const root = makeReplayRoot();
412
+ try {
413
+ fixture(root);
414
+ const blocked = runGuard(['exit', node], root);
415
+ assertExit(blocked, 1);
416
+ assertOut(blocked, 'BLOCKED: missing evidence for Node ' + node);
417
+ const block = lastRecoveryBlock(blocked.output);
418
+ const declared = printedCommandsOf(block, 'skill-load');
419
+ const recordCommand = printedCommandsOf(block, 'record')[0];
420
+ if (declared.length === 0 || !recordCommand) {
421
+ throw new Error(node + ':缺声明 + 缺证据的阻塞应同时给出 skill-load 与 record 命令:\n' + block);
422
+ }
423
+ // 照抄:声明命令按报文顺序执行,再 record。环境里不注入协议——命令自带的上下文必须够用。
424
+ const copyAndRun = printedCommandReplay(root, node);
425
+ for (const command of declared) copyAndRun(command);
426
+ copyAndRun(recordCommand);
427
+ // 核心:照抄完,同一个 exit 必须通过(不是「再去另一条报文里找第二步」)。
428
+ const recovered = runGuard(['exit', node], root);
429
+ assertExit(recovered, 0);
430
+ assertOut(recovered, 'ALL CHECKS PASSED');
431
+ assertDerivedDeclarationCommands({ node, block, declared, skills, prompts, templates });
432
+ assertDeclarationGateRecovery({ node, root, skills, prompts, templates, copyAndRun });
433
+ } finally {
434
+ cleanupTmpDir(root);
435
+ }
436
+ }
437
+
438
+ // 派生形态的判据:每个 guarded 必需技能各一条,且每条都带该节点**全部**协议文件与该节点的模板
439
+ // 全清单。照抄闭环已经会红掉「跑不通」的拼法;这一层把推导规则本身钉住——把两份协议分到两条命令、
440
+ // 或只给其一,都属于「凑够覆盖但命令不是同一个形态」,下游照抄同样会在模板面 / 协议面漏。
441
+ function assertDerivedDeclarationCommands({ node, block, declared, skills, prompts, templates }) {
442
+ if (declared.length !== skills.length) {
443
+ throw new Error(node + ':声明命令应每个 guarded 必需技能各一条(' + skills.length + ' 条),实际 '
444
+ + declared.length + ' 条:\n' + declared.join('\n'));
445
+ }
446
+ const templateFlag = '--templates ' + templates.join(',');
447
+ for (const skill of skills) {
448
+ const command = declared.find((line) => line.includes(' skill-load ' + node + ' ' + skill + ' '));
449
+ if (!command) {
450
+ throw new Error(node + ':恢复段缺技能 ' + skill + ' 的声明命令(该技能是 guarded 必需技能):\n' + block);
451
+ }
452
+ for (const prompt of prompts) {
453
+ if (!command.includes('--prompt ' + prompt)) {
454
+ throw new Error(node + ':' + skill + ' 的声明命令缺协议文件 ' + prompt
455
+ + '(一条命令要把该节点全部协议文件都带上,照抄才一次到位): ' + command);
456
+ }
457
+ }
458
+ if (!command.includes(templateFlag)) {
459
+ throw new Error(node + ':' + skill + ' 的声明命令缺模板全清单 ' + templateFlag
460
+ + '(漏模板清单,照抄后会被模板门拦下): ' + command);
461
+ }
462
+ }
463
+ }
464
+
465
+ // 覆盖门补齐命令的照抄闭合(同一缺陷的第二半:门只给缺项、技能名占位、且漏 --templates)。把声明
466
+ // 退回旧口径——只剩一个技能 + 一份协议(模板清单仍写全,否则第一步就撞 skill-load 自己的模板门,
467
+ // 测不到覆盖门)→ exit 被覆盖门拦下 → **照抄门给出的命令** → 同一 exit 通过。
468
+ function assertDeclarationGateRecovery({ node, root, skills, prompts, templates, copyAndRun }) {
469
+ const loadsDir = path.join(root, '.specs', CHANGE_ID, '.skill-loads');
470
+ const declaredSkill = skills[0];
471
+ for (const name of fs.readdirSync(loadsDir)) fs.rmSync(path.join(loadsDir, name));
472
+ assertExit(runState(['skill-load', node, declaredSkill, '--prompt', prompts[0],
473
+ '--templates', templates.join(',')], root), 0);
474
+ const blocked = runGuard(['exit', node], root);
475
+ assertExit(blocked, 1);
476
+ assertOut(blocked, '缺协议声明标记');
477
+ const block = lastRecoveryBlock(blocked.output);
478
+ const commands = printedCommandsOf(block, 'skill-load');
479
+ if (commands.length === 0) {
480
+ throw new Error(node + ':覆盖门的恢复段没给出可照抄的声明命令:\n' + block);
481
+ }
482
+ // 形态断言(照抄能过 ≠ 命令形态对):覆盖门的命令按**缺的必需技能子集**派生——已在场的技能不重
483
+ // 复刷,缺的每个技能各一条——且每条都把该节点**全部** --prompt 与模板全清单带全。只锁「照抄后
484
+ // 通过」会放过少一份 --prompt 的拼法:那份协议此刻由既有标记覆盖,缺口要等执行者删掉那条标记
485
+ // 才现形(报文当场就给不全)。少一条命令 / 多刷已声明的技能 / 少任一份 --prompt / 少模板清单,
486
+ // 本断言即红。
487
+ const expectedSkills = skills.filter((skill) => skill !== declaredSkill);
488
+ if (commands.length !== expectedSkills.length) {
489
+ throw new Error(node + ':覆盖门的声明命令应按缺的必需技能子集派生(缺 '
490
+ + expectedSkills.join('、') + ' = ' + expectedSkills.length + ' 条),实际 '
491
+ + commands.length + ' 条:\n' + block);
492
+ }
493
+ const templateFlag = '--templates ' + templates.join(',');
494
+ for (const skill of expectedSkills) {
495
+ const command = commands.find((line) => line.includes(' skill-load ' + node + ' ' + skill + ' '));
496
+ if (!command) {
497
+ throw new Error(node + ':覆盖门的恢复段缺技能 ' + skill + ' 的声明命令(它是缺的必需技能):\n' + block);
498
+ }
499
+ for (const prompt of prompts) {
500
+ if (!command.includes('--prompt ' + prompt)) {
501
+ throw new Error(node + ':' + skill + ' 的声明命令缺协议文件 ' + prompt
502
+ + '(覆盖门要求该节点全部协议文件都被声明,少给一份,照抄后同一 exit 仍会点名它): ' + command);
503
+ }
504
+ }
505
+ if (!command.includes(templateFlag)) {
506
+ throw new Error(node + ':' + skill + ' 的声明命令缺模板全清单 ' + templateFlag + ': ' + command);
507
+ }
508
+ }
509
+ for (const command of commands) copyAndRun(command);
510
+ const recovered = runGuard(['exit', node], root);
511
+ assertExit(recovered, 0);
512
+ assertOut(recovered, 'ALL CHECKS PASSED');
513
+ }
514
+
515
+ // 前端 design 的证据门照抄闭合(gated 绑定的那半):证据里只缺 required-skill:design.flow-comet-ui-design
516
+ // ——出口对该绑定**不再自动补写**,恢复必须同一段给全两件事:
517
+ // ① 真实 skill-load 声明(nodeSkillLoadCommands 的同一装配:每个 guarded 必需技能各一条,每条带
518
+ // 该节点全部 --prompt(含条件提示词 2a-ui-design.md)与模板全清单);
519
+ // ② 带该 required-skill 的 record——只补声明不补证据,同一个 exit 仍点名同一条。
520
+ // 旧形态(占位提示词、无 --templates、不提 record)照抄后必死循环;本断言逐层钉住这两件,再真的
521
+ // 照抄走一遍。
522
+ function assertFrontendDesignEvidenceRoundTrip() {
523
+ const root = makeReplayRoot();
524
+ try {
525
+ writeDesignExitFixture(root, {
526
+ newChange: true, visualTone: VISUAL_TONE_APPLICABLE, uiDesign: true, declareUiDesign: false,
527
+ });
528
+ const blocked = runGuard(['exit', 'design'], root);
529
+ assertExit(blocked, 1);
530
+ assertOut(blocked, 'BLOCKED: missing required Skill evidence: required-skill:design.flow-comet-ui-design');
531
+ // ① 占位提示词形态:--prompt 的值位置写「<flow-kit/prompts/ 协议文件>」,bash 下 < 是重定向——
532
+ // 照抄直接语法失败(值位置不接受占位符:路径要么给全,要么别给这个参数)。
533
+ assertNotOut(blocked, '--prompt <');
534
+ const block = lastRecoveryBlock(blocked.output);
535
+ const declared = printedCommandsOf(block, 'skill-load');
536
+ const recordCommand = printedCommandsOf(block, 'record')[0];
537
+ if (declared.length === 0 || !recordCommand) {
538
+ throw new Error('design:gated 绑定的缺口应同时给出 skill-load 与 record 命令'
539
+ + '(只给声明不给 record,照抄后同一 exit 仍点名同一条):\n' + block);
540
+ }
541
+ // ② record 载荷带上被点名的那条 required-skill——record 是覆盖写,只有把这条写回去才算补齐
542
+ if (!recordCommand.includes('required-skill:design.flow-comet-ui-design')) {
543
+ throw new Error('design:record 的恢复载荷没带上 required-skill:design.flow-comet-ui-design'
544
+ + '(自动补写对该绑定已失效,只补声明不补证据 = 死循环): ' + recordCommand);
545
+ }
546
+ // ③ 派生形态:每个 guarded 必需技能各一条,每条带全部协议文件(含条件提示词)与模板全清单
547
+ assertDerivedDeclarationCommands({
548
+ node: 'design',
549
+ block,
550
+ declared,
551
+ skills: ['flow-comet-design', 'flow-comet-ui-design'],
552
+ prompts: ['flow-kit/prompts/2-design.md', 'flow-kit/prompts/2a-ui-design.md'],
553
+ templates: ['DESIGN.md'],
554
+ });
555
+ // ④ 真的照抄:按报文顺序执行声明命令,再 record;环境里不注入协议(命令自带上下文必须够用)
556
+ const copyAndRun = printedCommandReplay(root, 'design');
557
+ for (const command of [...declared, recordCommand]) copyAndRun(command);
558
+ const recovered = runGuard(['exit', 'design'], root);
559
+ assertExit(recovered, 0);
560
+ assertOut(recovered, 'ALL CHECKS PASSED');
561
+ } finally {
562
+ cleanupTmpDir(root);
563
+ }
564
+ }
565
+
566
+ // 入口 --prompt 冲突报文的照抄闭合(同一缺陷的第三面):某个标记声明了节点协议面之外的路径 → 入口
567
+ // 拦下。旧报文写的是「重跑 skill-load <node> <skill> --prompt <上述协议文件>」——占位符落在 --prompt
568
+ // 的值位置(bash 下 `<` 是重定向,照抄直接语法失败),而且只补首份协议:换成真实路径也只补回一份,
569
+ // 下一次入口仍被同一判据点名另一份。故断言「报文里的命令逐字照抄后,同一条入口的冲突消失」。
570
+ function assertEntryConflictRecoveryRoundTrip() {
571
+ const root = makeReplayRoot();
572
+ try {
573
+ // currentNode = open:入口的归位判据满足;本格只让声明冲突这一道门说话。
574
+ writeState(root, baseState('open'));
575
+ writeFile(root, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
576
+ writeFile(root, 'flow-kit/prompts/1-requirement.md', '# 阶段 1 · REQUIREMENT\n\n## 角色\n\n你是 Requirer。\n');
577
+ // 声明里混进一份节点协议面之外的路径:入口按逐份核对拦下(第二份协议也被声明过,冲突只在这一份)。
578
+ writeFile(root, path.posix.join('.specs', CHANGE_ID, '.skill-loads', 'open-flow-comet-change.json'),
579
+ JSON.stringify({
580
+ node: 'open',
581
+ skill: 'flow-comet-change',
582
+ protocol: '0-change.md',
583
+ protocols: ['0-change.md', '9-other.md'],
584
+ templates: ['CHANGE', 'REQUIREMENT'],
585
+ at: '2026-11-01T00:00:00.000Z',
586
+ }, null, 2) + '\n');
587
+ const blocked = runGuard(['entry', 'open'], root);
588
+ assertExit(blocked, 1);
589
+ assertOut(blocked, '与节点协议文件不符');
590
+ // 占位符落在参数值位置 = 照抄不可执行;这是旧报文的形态,必须不再出现。
591
+ assertNotOut(blocked, '--prompt <');
592
+ const commands = [...blocked.output.matchAll(/^\s*(node "[^"]+" skill-load [^\n]+)$/gm)].map((match) => match[1]);
593
+ if (commands.length === 0) {
594
+ throw new Error('入口冲突报文必须给出可照抄的声明命令(占位词不算命令):\n' + blocked.output);
595
+ }
596
+ const command = commands.find((line) => line.includes(' skill-load open flow-comet-change ')) ?? commands[0];
597
+ for (const prompt of ['flow-kit/prompts/0-change.md', 'flow-kit/prompts/1-requirement.md']) {
598
+ if (!command.includes('--prompt ' + prompt)) {
599
+ throw new Error('入口冲突的重新声明命令缺协议文件 ' + prompt
600
+ + '(只补首份,下一次入口仍会点名另一份): ' + command);
601
+ }
602
+ }
603
+ const templateFlag = '--templates CHANGE.md,REQUIREMENT.md';
604
+ if (!command.includes(templateFlag)) {
605
+ throw new Error('入口冲突的重新声明命令缺模板全清单 ' + templateFlag
606
+ + '(漏 --templates 时照抄会先被 skill-load 自己的模板门拦下): ' + command);
607
+ }
608
+ const copyAndRun = printedCommandReplay(root, 'entry');
609
+ for (const line of commands) copyAndRun(line);
610
+ const recovered = runGuard(['entry', 'open'], root);
611
+ assertNotOut(recovered, '与节点协议文件不符');
612
+ assertOut(recovered, 'ENTRY OK: open');
613
+ } finally {
614
+ cleanupTmpDir(root);
615
+ }
616
+ }
617
+
618
+ // ---------- 声明命令的册子锚(入口册 + 展开册:open 的两条规范命令) ----------
619
+ //
620
+ // 两册给出 open 的**两条**规范声明命令——每个 guarded 必需技能各一条,每条都带该节点全部 --prompt
621
+ // 与模板全清单。只写其中一条时,照抄的人会在同一次 exit 上被覆盖门点名缺另一个技能(报文各给一半
622
+ // 的文档版)。锚取整行命令(可辨认、可 grep),不取裸词;两册都要有,只出现在一册不算。
623
+ const DECLARATION_BOOK_RELS = ['SKILL.md', path.join('reference', 'entry-detail.md')];
624
+ const DECLARATION_BOOK_COMMAND_ANCHORS = [
625
+ ['open 的第一个必需技能(change)',
626
+ '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'],
627
+ ['open 的第二个必需技能(requirement)',
628
+ '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'],
629
+ ];
630
+
631
+ function declarationBookProblems(skillRoot) {
632
+ const out = [];
633
+ for (const rel of DECLARATION_BOOK_RELS) {
634
+ let text;
635
+ try {
636
+ text = fs.readFileSync(path.join(skillRoot, rel), 'utf8');
637
+ } catch {
638
+ out.push(rel + ' 不在场(声明命令锚无法核对)');
639
+ continue;
640
+ }
641
+ for (const [label, command] of DECLARATION_BOOK_COMMAND_ANCHORS) {
642
+ if (!text.includes(command)) out.push(rel + ' 缺「' + label + '」的规范命令');
643
+ }
644
+ }
645
+ return out;
646
+ }
647
+
648
+ // ---------- 排障册的声明命令锚:与入口册同形 ----------
649
+ //
650
+ // 排障册「exit 缺协议声明标记」一条曾给出**手拼的半边命令**:占位符落在 --prompt 的值位置,且不带
651
+ // --templates——新 change 照抄即被 skill-load 自己的模板门拦下(「模板声明缺失」)。判据不在这里再抄
652
+ // 一份命令:排障册必须逐字含入口册的规范声明命令,两册(中英)都要有;抽掉即报。命令形态因此只有
653
+ // 一个来源,排障册不能自持一份「看起来像命令」的文本。
654
+ // 条数同样取入口册的判据面:该节点有几个 guarded 必需技能就给几条。只列第一条的排障册会让照抄的人
655
+ // 在同一次 exit 上被覆盖门点名缺另一个技能(报文各给一半的文档版)——所以锚是**全部**条目,不是首条。
656
+ const TROUBLESHOOTING_COMMAND_RELS = ['docs/TROUBLESHOOTING.md', 'docs/TROUBLESHOOTING-zh.md'];
657
+ const TROUBLESHOOTING_DECLARATION_ANCHORS = DECLARATION_BOOK_COMMAND_ANCHORS.map(([, command]) => command);
658
+
659
+ function troubleshootingDeclarationProblems(texts) {
660
+ const out = [];
661
+ for (const rel of TROUBLESHOOTING_COMMAND_RELS) {
662
+ const text = texts.get(rel);
663
+ if (typeof text !== 'string') {
664
+ out.push(rel + ' 不在场(声明命令锚无法核对)');
665
+ continue;
666
+ }
667
+ for (const anchor of TROUBLESHOOTING_DECLARATION_ANCHORS) {
668
+ if (!text.includes(anchor)) {
669
+ out.push(rel + ' 缺声明命令「' + anchor
670
+ + '」(排障册的声明命令必须与入口册同形同数:该节点每个 guarded 必需技能一条,'
671
+ + '每条带该节点全部 --prompt 与模板全清单)');
672
+ }
673
+ }
674
+ }
675
+ return out;
676
+ }
677
+
678
+ // ---------- 形态判据的判别力探针(同一实现驱动,在夹具目录上作业) ----------
679
+ // 三条边界都要有:① 真包形态 / 安装副本形态(有技能树、公开面载体**三者俱缺**)跳过且**可见**,
680
+ // 不判红;② docs/ 在场而权威映射缺失仍显式失败——跳过通道只对「整份公开面不存在」开放,不能顺手
681
+ // 把真事故一起吞掉;③ docs/ 不在、但 CONTRIBUTING.md 或 .github/ 在场必须判红——它们同样不进 npm
682
+ // tarball,任一在场就说明这是**被裁坏的仓库**,不是「本来不含公开面」的载体。
683
+ function assertPublicFaceShapeProbes(dir) {
684
+ // 真包形态 = docs/、CONTRIBUTING.md、.github/ 三者都不在本检出(npm tarball 三者都不带)
685
+ if (!publicFaceDocsAbsent(dir)) {
686
+ throw new Error('形态探针前提失效:夹具目录不应预先含 ' + PUBLIC_FACE_DOCS_DIR
687
+ + '/、CONTRIBUTING.md 或 .github/(三者俱缺才是「不含公开面」的包形态)');
688
+ }
689
+ for (const phrase of ['此形态不含公开面', '不是仓库缺文件', '未校验']) {
690
+ if (!PUBLIC_FACE_SELF_CHECK_SKIP_NOTICE.includes(phrase)) {
691
+ throw new Error('跳过提示缺「' + phrase + '」——跳过必须说明这是未校验、不是通过、也不是缺文件: '
692
+ + PUBLIC_FACE_SELF_CHECK_SKIP_NOTICE);
693
+ }
694
+ }
695
+ // docs/ 在场 ⇒ 不属「不含公开文档」形态,判据不得据此跳过(否则真检出会被整面跳过)
696
+ fs.mkdirSync(path.join(dir, ...PUBLIC_FACE_DOCS_DIR.split('/')), { recursive: true });
697
+ if (publicFaceDocsAbsent(dir)) {
698
+ throw new Error('形态判据把含 ' + PUBLIC_FACE_DOCS_DIR + '/ 的检出也判成不含公开文档(真检出会被整面跳过)');
699
+ }
700
+ // docs/ 不在、其余公开面载体在场 ⇒ 仍不属包形态:分支 / 稀疏检出 / 误删会把 docs/ 整份拿掉,那时
701
+ // 「本载体不含公开面」是假话——计数一致性 / 公开产物零代号 / 词表镜像会整块变成可见 SKIP 并 exit 0。
702
+ // 两份载体分开造根:CONTRIBUTING.md 与 .github/ 各自单独在场都足以证明本检出是仓库(两者都不进
703
+ // npm tarball;README 不作判据——npm 会强制包含它,用它判断等于把包形态误判成「有公开面」的仓库)。
704
+ for (const carrier of ['CONTRIBUTING.md', '.github/workflows/ci.yml']) {
705
+ const partial = path.join(dir, 'partial-face-' + carrier.split('/')[0].replace(/\./g, ''));
706
+ fs.mkdirSync(partial, { recursive: true });
707
+ writeFile(partial, carrier, '');
708
+ if (publicFaceDocsAbsent(partial)) {
709
+ throw new Error('docs/ 不在但 ' + carrier + ' 在场仍被判成「不含公开面」的包形态——'
710
+ + '该形态下计数一致性 / 公开产物零代号 / 词表镜像会整块变成 SKIP 并 exit 0');
711
+ }
712
+ }
713
+ // docs/ 在场、权威映射缺 = 检出被裁坏 → 仍是读取处的显式失败(判据强度不因跳过通道下降)
714
+ let threw = null;
715
+ try {
716
+ readPublicFaceAuthorityMap(dir);
717
+ } catch (e) {
718
+ threw = e;
719
+ }
720
+ if (!threw || !String(threw.message).includes('受检面无法派生')) {
721
+ throw new Error('docs/ 在场但权威映射缺失时应显式失败,实际: ' + (threw ? threw.message : '未抛错'));
722
+ }
723
+ // 补上映射 ⇒ 读取处正常返回(证明上一条的失败来自「缺映射」而不是「读不到」)
724
+ writeFile(dir, PUBLIC_FACE_AUTHORITY_MAP,
725
+ JSON.stringify({ topics: { workflow: { authority: PUBLIC_FACE_EXAMPLES_DIR + '/README.md' } } }, null, 2) + '\n');
726
+ const parsed = readPublicFaceAuthorityMap(dir);
727
+ if (!parsed.topics || !parsed.topics.workflow) {
728
+ throw new Error('权威映射在场时读取处应返回 topics(探针前提失效): ' + JSON.stringify(parsed));
729
+ }
730
+ }
731
+
44
732
  export const ENTRIES = [
45
733
 
46
734
  // ---------- 场景(completedChecks 真实性声明机制——skill-load/record/exit 校验 + 交叉自洽 + 旧兼容 + 场景数同步) ----------
47
735
 
48
736
  // 98: skill-load 写入声明标记(AC-1)——完整命令形态(--prompt flow-kit/prompts/<阶段>.md,
49
737
  // 归属校验通过)→ 标记 .specs/<change-id>/.skill-loads/<node>-<skill>.json 生成,
50
- // 内容含 node/skill/protocol/at(ISO 时间戳)+ 输出确认提示
738
+ // 内容含 node/skill/protocol/protocols/at(ISO 时间戳)+ 输出确认提示。
739
+ // 原位扩展(多 --prompt 记录):open 节点该读两份协议,一条命令可一次声明多份——标记里存
740
+ // protocols 数组(逐个 basename,按 --prompt 出现顺序),protocol 仍存首个 basename(旧读法兼容:
741
+ // 入口声明核对与既有读标记的消费方只读 protocol 单值)。
51
742
  {
52
743
  name: '98 skill-load 写入声明标记(AC-1)',
53
744
  run: (dir) => {
54
745
  // 场景内 flow-kit/prompts/ 提示文件(skill-load --prompt 指向——改名 --prompt 后归属校验仅查
55
746
  // 前缀不读内容;协议加载走 env reference 路径,文件无需为 JSON)
56
747
  writeFile(dir, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
748
+ writeFile(dir, 'flow-kit/prompts/1-requirement.md', '# 阶段 1 · REQUIREMENT\n\n## 角色\n\n你是 Requirer。\n');
57
749
  writeState(dir, baseState('open'));
58
750
  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']);
751
+ 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
752
  assertExit(res, 0);
61
753
  assertOut(res, 'SKILL-LOAD: open flow-comet-change → .skill-loads/open-flow-comet-change.json');
62
754
  const markerPath = path.join(dir, '.specs', CHANGE_ID, '.skill-loads', 'open-flow-comet-change.json');
@@ -67,10 +759,16 @@ export const ENTRIES = [
67
759
  }
68
760
  // 标记 protocol = --prompt 参数的 basename(与 guard exit 的 节点协议映射表比对同值,
69
761
  // 真实链路 skill-load → exit 一致;缺陷修复前写 resolveProtocol 解析后的完整绝对路径,
70
- // 与 节点协议映射表 basename 精确比对必然失败——机制实际不可用,已修复)
762
+ // 与 节点协议映射表 basename 精确比对必然失败——机制实际不可用,已修复)。
763
+ // 多 --prompt 时取首个(旧读法只认单值,保持逐字可读)。
71
764
  if (marker.protocol !== '0-change.md') {
72
765
  throw new Error('标记 protocol 应为 --prompt 参数的 basename 0-change.md: ' + JSON.stringify(marker));
73
766
  }
767
+ // 多 --prompt 全部被记录(缺陷修复前只取第一个,第二个声明被静默丢弃——覆盖判据因此永远
768
+ // 看不到它)。顺序 = 命令行出现顺序,供报文按序点名。
769
+ if (!Array.isArray(marker.protocols) || marker.protocols.join(',') !== '0-change.md,1-requirement.md') {
770
+ throw new Error('标记 protocols 应记录全部 --prompt 的 basename(0-change.md,1-requirement.md): ' + JSON.stringify(marker));
771
+ }
74
772
  if (typeof marker.at !== 'string' || Number.isNaN(Date.parse(marker.at))) {
75
773
  throw new Error('标记缺 ISO 时间戳 at: ' + JSON.stringify(marker));
76
774
  }
@@ -116,20 +814,38 @@ export const ENTRIES = [
116
814
  },
117
815
 
118
816
  // 100: record 校验 BLOCK(AC-3 反例)——completedChecks 含 required-skill:open.flow-comet-change
119
- // 条目但无对应声明标记 → BLOCKED + 指引先加载 skill 并运行 skill-load;evidence 不写入
817
+ // 条目但无对应声明标记 → BLOCKED + 可照抄的声明命令;evidence 不写入。
818
+ // 命令形态的判据是**照抄能跑通**:解析打印文本 → 在夹具里真执行 → 同一条 record 通过。旧形态是
819
+ // 裸脚本名 + 相对提示词 + 无协议上下文(`workflow-state.mjs skill-load …`),照抄在 shell 里
820
+ // command not found;字符串断言只能钉住那个坏形态本身,钉不出「这条命令能不能用」。
120
821
  {
121
822
  name: '100 record BLOCKED:completedChecks 缺声明标记(AC-3)',
122
823
  run: (dir) => {
123
824
  writeState(dir, baseState('open'));
124
825
  fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
125
- const res = runStateWithProtocol(dir, ['record', 'open', JSON.stringify({ summary: 'done', completedChecks: ['required-skill:open.flow-comet-change'] })]);
826
+ const payload = JSON.stringify({ summary: 'done', completedChecks: ['required-skill:open.flow-comet-change'] });
827
+ const res = runStateWithProtocol(dir, ['record', 'open', payload]);
126
828
  assertExit(res, 1);
127
829
  assertOut(res, 'BLOCKED');
128
830
  assertOut(res, '缺少对应声明标记');
129
- assertOut(res, 'workflow-state.mjs skill-load open flow-comet-change');
130
831
  // BLOCK 先于记录——校验失败后 evidence 不得写入
131
832
  const st = JSON.parse(fs.readFileSync(path.join(dir, '.flow-comet', 'flow-comet-state.json'), 'utf8'));
132
833
  if (st.evidence && st.evidence.open) throw new Error('BLOCKED 后不应写入 evidence: ' + JSON.stringify(st.evidence.open));
834
+ // 报文给出的声明命令必须可照抄(与守卫侧恢复段同一装配:脚本路径 + 全部 --prompt + 模板全清单
835
+ // + 协议上下文):解析 → 真跑 → 同一条 record 通过。
836
+ const command = (res.output.match(/^\s*(node "[^"]+" skill-load [^\n]+)$/m) || [])[1];
837
+ if (!command) {
838
+ throw new Error('缺声明标记的阻塞必须给出完整可执行命令(node "<脚本路径>" skill-load …):\n' + res.output);
839
+ }
840
+ // 协议上下文随命令走:本夹具的协议来自环境变量(不是内置默认),照抄时不带 --protocol 会
841
+ // 解析到另一份协议(状态命令族只认 CLI → env → 内置默认,没有第二来源)。
842
+ if (!command.includes('--protocol "reference/workflow-protocol.json"')) {
843
+ throw new Error('声明命令缺协议上下文(照抄会解析到内置默认协议,而不是本次运行的那份): ' + command);
844
+ }
845
+ printedCommandReplay(dir, '记录侧声明')(command);
846
+ const recorded = runStateWithProtocol(dir, ['record', 'open', payload]);
847
+ assertExit(recorded, 0);
848
+ assertOut(recorded, 'EVIDENCE: open');
133
849
  },
134
850
  },
135
851
 
@@ -139,7 +855,7 @@ export const ENTRIES = [
139
855
  run: (dir) => {
140
856
  writeState(dir, baseState('open'));
141
857
  fs.mkdirSync(path.join(dir, '.specs', CHANGE_ID), { recursive: true });
142
- const sl = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change']);
858
+ const sl = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--templates', 'CHANGE.md,REQUIREMENT.md']);
143
859
  assertExit(sl, 0);
144
860
  assertOut(sl, 'SKILL-LOAD: open flow-comet-change');
145
861
  const res = runStateWithProtocol(dir, ['record', 'open', JSON.stringify({ summary: 'done', completedChecks: ['required-skill:open.flow-comet-change'] })]);
@@ -163,62 +879,232 @@ export const ENTRIES = [
163
879
  },
164
880
  },
165
881
 
166
- // 102: exit 协议声明标记校验(AC-4)+ 真实链路集成——.skill-loads/ 已激活
167
- // (目录存在)但无本节点协议标记(<node>-*.json 且 protocol ∈ 该节点协议集,节点协议映射表
168
- // basename)→ BLOCKED;真实 skill-load --prompt 写入的标记(protocol = basename)→ exit 通过
169
- // (修复后真实链路一致——缺陷修复前 skill-load 写解析后完整路径,exit 必 BLOCKED);未传
170
- // --prompt(标记 protocol = null)→ BLOCKED;损坏标记(protocol 非协议集)→ BLOCKED
882
+ // 102: exit 协议声明标记校验(AC-4)+ 真实链路集成。判定从「任一命中即通过」改为「全部覆盖」:
883
+ // 节点该读的每个协议文件(NODE_PROTOCOL_FILES,open = 0-change / 1-requirement)都必须被某个标记
884
+ // 覆盖,协议声明的 requiredSkillCalls(enforcement=guarded)也各自要有标记。新 change 缺任一 →
885
+ // BLOCKED 并逐项点名缺哪个协议文件 / 哪个必需技能;旧 change → WARN 渐进(既有 change 不卡死)。
886
+ // 旧单值标记(只有 protocol、没有 protocols)照样计入覆盖——旧写入形态不被新规则判死。
887
+ // ⑧ 另补一格出口**链序**(见该格头注):同一个「缺声明」既表现为证据清单缺 required-skill、也
888
+ // 表现为标记没覆盖必需项,两段报文的先后是链序的直接读数。
171
889
  {
172
- name: '102 exit 协议标记校验:真实链路通过 / 无标记·null·损坏 BLOCKED(AC-4)',
890
+ name: '102 exit 协议标记校验:全部覆盖通过 / 少声明必红点名 / 旧 change 只 WARN / 旧单值标记可读 / 证据门先于覆盖门(AC-4)',
173
891
  run: (dir) => {
174
- const st = baseState('open');
175
- st.evidence.open = { summary: 'intake complete' };
176
- writeState(dir, st);
177
- writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why\n\n## 范围\n');
178
- writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\n\n## 验收准则(AC)\n');
892
+ const loadsDir = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
893
+ const markerFile = (skill) => path.join(loadsDir, 'open-' + skill + '.json');
894
+ const readMarker = (skill) => JSON.parse(fs.readFileSync(markerFile(skill), 'utf8'));
895
+ // 新 change 夹具(init 标记 = newChange:true)+ entry 已记录(否则先被 entry 记录门拦下,
896
+ // 测不到声明门本身)
897
+ const newChangeState = () => {
898
+ const st = baseState('open');
899
+ st.evidence.open = { summary: 'intake complete' };
900
+ st.newChange = true;
901
+ st.enteredNodes = ['open'];
902
+ return st;
903
+ };
904
+ writeState(dir, newChangeState());
905
+ // 新 change 下入口文档另有首部门(Change ID 必在场)——夹具让它在场,才能把断言收敛到声明门上
906
+ writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md',
907
+ '# CHANGE: 声明门夹具\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## Why\n\n夹具。\n\n## 范围\n');
908
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md',
909
+ '# 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
910
  // 场景内 flow-kit/prompts/ 提示文件(真实 skill-load --prompt 指向——归属校验仅查前缀不读内容)
180
911
  writeFile(dir, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
181
- const loadsDir = path.join(dir, '.specs', CHANGE_ID, '.skill-loads');
182
- fs.mkdirSync(loadsDir, { recursive: true });
183
- // ① 机制已激活(.skill-loads/ 存在)但无 open-* 标记(仅他节点标记)→ BLOCKED
912
+ writeFile(dir, 'flow-kit/prompts/1-requirement.md', '# 阶段 1 · REQUIREMENT\n\n## 角色\n\n你是 Requirer。\n');
913
+ // ① 机制已激活(.skill-loads/ 存在)但无 open-* 标记(仅他节点标记)→ BLOCKED,逐项点名
184
914
  writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/design-flow-comet-design.json',
185
915
  JSON.stringify({ node: 'design', skill: 'flow-comet-design', protocol: '2-design.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
186
- const resBlock = runGuard(['exit', 'open'], dir);
187
- assertExit(resBlock, 1);
188
- assertOut(resBlock, 'BLOCKED');
189
- assertOut(resBlock, 'exit 缺协议声明标记');
190
- // ② 真实链路:skill-load --prompt 写入标记(protocol = basename)→ exit 通过
191
- const markerPath = path.join(loadsDir, 'open-flow-comet-change.json');
192
- const sl = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--prompt', 'flow-kit/prompts/0-change.md']);
193
- assertExit(sl, 0);
194
- assertOut(sl, 'SKILL-LOAD: open flow-comet-change');
195
- const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
196
- if (marker.protocol !== '0-change.md') {
197
- throw new Error('skill-load 标记 protocol 应为 --prompt 参数的 basename 0-change.md: ' + JSON.stringify(marker));
916
+ const resNoMarker = runGuard(['exit', 'open'], dir);
917
+ assertExit(resNoMarker, 1);
918
+ assertOut(resNoMarker, 'BLOCKED');
919
+ assertOut(resNoMarker, 'exit 缺协议声明标记');
920
+ assertOut(resNoMarker, '缺协议文件: 0-change.md、1-requirement.md');
921
+ assertOut(resNoMarker, '缺必需技能声明: flow-comet-change、flow-comet-requirement');
922
+ // ② 少声明(新 change,真实链路)——只声明一个协议文件、只覆盖一个必需技能 → BLOCKED 并
923
+ // 逐项点名缺哪个协议文件、哪个必需技能。缺陷形态:门禁把「该读的协议清单」当允许集合、
924
+ // 任一命中即通过 → 这条会 exit 0(第二个声明被静默丢弃,覆盖缺口看不见)
925
+ assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--prompt', 'flow-kit/prompts/0-change.md', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
926
+ const resPartial = runGuard(['exit', 'open'], dir);
927
+ assertExit(resPartial, 1);
928
+ assertOut(resPartial, 'BLOCKED');
929
+ assertOut(resPartial, 'exit 缺协议声明标记');
930
+ assertOut(resPartial, '缺协议文件: 1-requirement.md');
931
+ assertOut(resPartial, '缺必需技能声明: flow-comet-requirement');
932
+ assertNotOut(resPartial, 'ALL CHECKS PASSED');
933
+ // ③ 全部声明(新 change,真实链路)→ exit 通过。一条命令多个 --prompt:两份协议都记进同一个
934
+ // 标记的 protocols 数组(protocol 保留首个 basename 供旧读法)
935
+ 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);
936
+ const multiMarker = readMarker('flow-comet-change');
937
+ if (multiMarker.protocol !== '0-change.md' || !Array.isArray(multiMarker.protocols)
938
+ || multiMarker.protocols.join(',') !== '0-change.md,1-requirement.md') {
939
+ throw new Error('多 --prompt 应全部记入 protocols 且 protocol 保留首个: ' + JSON.stringify(multiMarker));
198
940
  }
941
+ assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-requirement', '--prompt', 'flow-kit/prompts/1-requirement.md', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
199
942
  const resPass = runGuard(['exit', 'open'], dir);
200
943
  assertExit(resPass, 0);
201
944
  assertOut(resPass, 'ALL CHECKS PASSED');
202
945
  assertNotOut(resPass, 'BLOCKED');
203
- // ③ skill-load 未传 --prompt → 标记 protocol = null → exit BLOCKED(fail-closed:
204
- // 无协议声明不可通过——指引补 skill-load --prompt)
205
- const slNull = runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change']);
206
- assertExit(slNull, 0);
207
- const markerNull = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
208
- if (markerNull.protocol !== null) {
209
- throw new Error('skill-load 未传 --prompt 标记 protocol 应为 null: ' + JSON.stringify(markerNull));
946
+ assertNotOut(resPass, 'SKILL-LOAD WARN');
947
+ // ④ 旧单值标记仍可读——只有 protocol、没有 protocols 的两条标记(收紧前的写入形态)各覆盖
948
+ // 一份协议文件:覆盖判据照样把它们算进去 → exit 通过
949
+ fs.rmSync(loadsDir, { recursive: true, force: true });
950
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
951
+ 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');
952
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-requirement.json',
953
+ 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');
954
+ const resLegacy = runGuard(['exit', 'open'], dir);
955
+ assertExit(resLegacy, 0);
956
+ assertOut(resLegacy, 'ALL CHECKS PASSED');
957
+ assertNotOut(resLegacy, 'BLOCKED');
958
+ // ⑤ 旧 change(无 newChange):同样的「少声明」构造 → 只 WARN 不阻断(不收死既有 change),
959
+ // 报文与 ② 同样逐项点名
960
+ const legacyState = baseState('open');
961
+ legacyState.evidence.open = { summary: 'intake complete' };
962
+ writeState(dir, legacyState);
963
+ fs.rmSync(loadsDir, { recursive: true, force: true });
964
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-change.json',
965
+ JSON.stringify({ node: 'open', skill: 'flow-comet-change', protocol: '0-change.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
966
+ const resWarn = runGuard(['exit', 'open'], dir);
967
+ assertExit(resWarn, 0);
968
+ assertOut(resWarn, 'SKILL-LOAD WARN');
969
+ assertOut(resWarn, '缺协议文件: 1-requirement.md');
970
+ assertOut(resWarn, '缺必需技能声明: flow-comet-requirement');
971
+ assertOut(resWarn, 'ALL CHECKS PASSED');
972
+ // ⑥ 未传 --prompt(protocol = null / protocols 空)→ 两个必需技能都在场,但没有协议文件被
973
+ // 覆盖 → BLOCKED(fail-closed:声明了技能不等于读了两份协议)
974
+ writeState(dir, newChangeState());
975
+ fs.rmSync(loadsDir, { recursive: true, force: true });
976
+ assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-change', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
977
+ assertExit(runStateWithProtocol(dir, ['skill-load', 'open', 'flow-comet-requirement', '--templates', 'CHANGE.md,REQUIREMENT.md']), 0);
978
+ const markerNull = readMarker('flow-comet-change');
979
+ if (markerNull.protocol !== null || !Array.isArray(markerNull.protocols) || markerNull.protocols.length !== 0) {
980
+ throw new Error('未传 --prompt 时 protocol 应为 null、protocols 应为空数组: ' + JSON.stringify(markerNull));
210
981
  }
211
982
  const resNull = runGuard(['exit', 'open'], dir);
212
983
  assertExit(resNull, 1);
213
984
  assertOut(resNull, 'BLOCKED');
214
985
  assertOut(resNull, 'exit 缺协议声明标记');
215
- // ④ 损坏标记(protocol 非协议集 basename)→ BLOCKED(fail-closed)
986
+ assertOut(resNull, '缺协议文件: 0-change.md、1-requirement.md');
987
+ assertNotOut(resNull, '缺必需技能声明');
988
+ // ⑦ 损坏标记(protocol / protocols 均非协议集 basename)→ 该文件不算被覆盖 → BLOCKED
216
989
  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');
990
+ 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');
991
+ writeFile(dir, '.specs/' + CHANGE_ID + '/.skill-loads/open-flow-comet-requirement.json',
992
+ JSON.stringify({ node: 'open', skill: 'flow-comet-requirement', protocol: '1-requirement.md', at: '2026-08-01T00:00:00.000Z' }, null, 2) + '\n');
218
993
  const resCorrupt = runGuard(['exit', 'open'], dir);
219
994
  assertExit(resCorrupt, 1);
220
995
  assertOut(resCorrupt, 'BLOCKED');
221
996
  assertOut(resCorrupt, 'exit 缺协议声明标记');
997
+ assertOut(resCorrupt, '缺协议文件: 0-change.md');
998
+ assertNotOut(resCorrupt, '缺必需技能声明');
999
+ // ⑧ 出口链序:同一个「缺声明」既可能是证据清单缺 required-skill(证据门的报文给出该绑定的
1000
+ // 补齐命令),也可能是声明标记没覆盖必需项(覆盖门逐项点名缺哪个技能)。两者都说同一件事
1001
+ // 时,证据门必须先说话、覆盖门收口——颠倒顺序会让执行者只看到「缺协议声明标记」,看不到
1002
+ // 证据门指出的那条绑定。反向构造:把 workflow-guard 出口链上的两处调用对调(覆盖门排到
1003
+ // 证据族之前)→ 本格第一趟先报覆盖门 → 本格 RED。
1004
+ // 两段报文**不可能**同处一趟输出(任一命中即 process.exit),故按两趟真实顺序断言:第一趟
1005
+ // 只有证据门说话,补齐证据后第二趟才轮到覆盖门;「行序」取两趟输出拼接后的位置。
1006
+ // 夹具根独立(design 出口夹具与前七格的 open 夹具互不污染),协议副本按套件同一表达式预置。
1007
+ const chainRoot = makeTmp();
1008
+ try {
1009
+ fs.mkdirSync(path.dirname(scenarioProtocolPath(chainRoot)), { recursive: true });
1010
+ fs.copyFileSync(BUILTIN_PROTOCOL_SOURCE, scenarioProtocolPath(chainRoot));
1011
+ writeDesignExitFixture(chainRoot, {
1012
+ newChange: true, visualTone: VISUAL_TONE_APPLICABLE, uiDesign: true, declareUiDesign: false,
1013
+ });
1014
+ // 先写一条真实声明(design 技能 + 2-design.md):机制已激活,缺口收敛到 ui-design 这一条绑定
1015
+ assertExit(runState(['skill-load', 'design', 'flow-comet-design', '--prompt', 'flow-kit/prompts/2-design.md', '--templates', 'DESIGN.md'], chainRoot), 0);
1016
+ const bothMissing = runGuard(['exit', 'design'], chainRoot);
1017
+ assertExit(bothMissing, 1);
1018
+ assertOut(bothMissing, 'BLOCKED: missing required Skill evidence: required-skill:design.flow-comet-ui-design');
1019
+ assertNotOut(bothMissing, '缺协议声明标记');
1020
+ // 第二趟:证据补齐(同一夹具的 declareUiDesign),声明覆盖仍缺 → 覆盖门收口并点名该技能
1021
+ writeDesignExitFixture(chainRoot, {
1022
+ newChange: true, visualTone: VISUAL_TONE_APPLICABLE, uiDesign: true, declareUiDesign: true,
1023
+ });
1024
+ const markerMissing = runGuard(['exit', 'design'], chainRoot);
1025
+ assertExit(markerMissing, 1);
1026
+ assertOut(markerMissing, '缺协议声明标记');
1027
+ assertOut(markerMissing, '缺必需技能声明: flow-comet-ui-design');
1028
+ // 本格的核心断言:两段报文都在场,且「证据门」那段的行序早于「缺协议声明标记」那行——覆盖门
1029
+ // 的报文出现即证明链条已越过证据门(证据门命中会 process.exit,覆盖门就不会有输出)。
1030
+ const chainText = bothMissing.output + '\n' + markerMissing.output;
1031
+ const evidenceAt = chainText.indexOf('missing required Skill evidence');
1032
+ const markerAt = chainText.indexOf('缺协议声明标记');
1033
+ if (evidenceAt < 0 || markerAt < 0 || evidenceAt > markerAt) {
1034
+ throw new Error('链序:证据门报文应在「缺协议声明标记」之前(两段报文都必须在场): '
1035
+ + JSON.stringify({ evidenceAt, markerAt }));
1036
+ }
1037
+ } finally {
1038
+ cleanupTmpDir(chainRoot);
1039
+ }
1040
+ // ⑨ 恢复段命令的照抄闭合(本场景的核心扩展;不新增场景条目):open 与 review 各删声明与证据 →
1041
+ // exit 被拦 → **逐字照抄**报文给出的每条命令 → 同一 exit 通过。缺陷形态:恢复段第一步只声明
1042
+ // 实现技能 + 首份协议、且不带模板清单(声明覆盖门的补齐命令则只给缺项、同样漏模板),照抄完
1043
+ // 同一 exit 仍被覆盖门点名缺另一份协议文件与另一个必需技能——两处各给一半。
1044
+ assertDeclarationRecoveryRoundTrip({
1045
+ node: 'open',
1046
+ skills: ['flow-comet-change', 'flow-comet-requirement'],
1047
+ prompts: ['flow-kit/prompts/0-change.md', 'flow-kit/prompts/1-requirement.md'],
1048
+ templates: ['CHANGE.md', 'REQUIREMENT.md'],
1049
+ fixture: (root) => {
1050
+ const st = newChangeState();
1051
+ delete st.evidence.open; // 证据整体缺席:恢复段必须把「先声明」这一步一并给全
1052
+ writeState(root, st);
1053
+ writeFile(root, '.specs/' + CHANGE_ID + '/CHANGE.md',
1054
+ '# CHANGE: 声明门夹具\n\n- **Change ID**: ' + CHANGE_ID + '\n\n## Why\n\n夹具。\n\n## 范围\n');
1055
+ writeFile(root, '.specs/' + CHANGE_ID + '/REQUIREMENT.md',
1056
+ '# REQUIREMENT: 声明门夹具\n\n- **Change ID**: ' + CHANGE_ID
1057
+ + '\n\n## 用户故事\n\n- US-1\n\n## 验收准则(AC)\n\n- Given a When b Then c\n');
1058
+ writeFile(root, 'flow-kit/prompts/0-change.md', '# 阶段 0 · CHANGE\n\n## 角色\n\n你是 Changeer。\n');
1059
+ writeFile(root, 'flow-kit/prompts/1-requirement.md', '# 阶段 1 · REQUIREMENT\n\n## 角色\n\n你是 Requirer。\n');
1060
+ },
1061
+ });
1062
+ assertDeclarationRecoveryRoundTrip({
1063
+ node: 'review',
1064
+ skills: ['flow-comet-review', 'flow-comet-test'],
1065
+ prompts: ['flow-kit/prompts/6-review.md', 'flow-kit/prompts/5-test.md'],
1066
+ templates: ['REVIEW.md', 'TEST.md'],
1067
+ fixture: (root) => {
1068
+ const st = baseState('review');
1069
+ st.newChange = true;
1070
+ st.enteredNodes = ['review'];
1071
+ writeState(root, st);
1072
+ writeFile(root, '.specs/' + CHANGE_ID + '/REVIEW.md',
1073
+ '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题B**: 某处问题 **[已修]**\n'
1074
+ + ' - **Symptom**: 具体现象\n - **Source**: 某书某节\n'
1075
+ + ' - **Consequence**: 若不修会怎样\n - **Remedy**: 怎么改\n\n## 结论\n\n通过\n');
1076
+ writeFile(root, 'flow-kit/prompts/6-review.md', '# 阶段 6 · REVIEW\n\n## 角色\n\n你是 Reviewer。\n');
1077
+ writeFile(root, 'flow-kit/prompts/5-test.md', '# 阶段 5 · TEST\n\n## 角色\n\n你是 Tester。\n');
1078
+ },
1079
+ });
1080
+ // ⑩ 前端 design 的证据门照抄闭合(不新增场景条目):证据缺一条 gated 绑定(ui-design)时,
1081
+ // 恢复段必须给全「真实声明 + 带该 required-skill 的 record」两步,照抄后同一 exit 通过。
1082
+ assertFrontendDesignEvidenceRoundTrip();
1083
+ // ⑪ 入口 --prompt 冲突报文的照抄闭合(同一缺陷的第三面:报文与门禁判据不是同一份派生)。
1084
+ assertEntryConflictRecoveryRoundTrip();
1085
+ // ⑫ **标记目录整体被删**:旧口径把它读成「声明机制未激活」→ 跳过校验(对新 change 也印
1086
+ // 「旧 change 兼容」),于是 `rm -rf .skill-loads/` 就是关掉覆盖判据的写法。新 change
1087
+ // 下目录缺席 = 一项声明都没有:按缺声明 BLOCKED 并逐项点名(同一条判据的两半——
1088
+ // 「目录在但没覆盖」与「目录根本不在」不该有两种放行)。旧 change 的过渡规则不变
1089
+ // (渐进 WARN,且只有那一支才叫「旧 change 兼容」)。
1090
+ writeState(dir, newChangeState());
1091
+ fs.rmSync(loadsDir, { recursive: true, force: true });
1092
+ const resNoLoadsDir = runGuard(['exit', 'open'], dir);
1093
+ assertExit(resNoLoadsDir, 1);
1094
+ assertOut(resNoLoadsDir, 'BLOCKED');
1095
+ assertOut(resNoLoadsDir, 'exit 缺协议声明标记');
1096
+ assertOut(resNoLoadsDir, '缺协议文件: 0-change.md、1-requirement.md');
1097
+ assertOut(resNoLoadsDir, '缺必需技能声明: flow-comet-change、flow-comet-requirement');
1098
+ assertOut(resNoLoadsDir, '恢复: 照抄下面的命令补齐上述缺项');
1099
+ assertNotOut(resNoLoadsDir, '旧 change 兼容');
1100
+ assertNotOut(resNoLoadsDir, 'ALL CHECKS PASSED');
1101
+ // ⑫b 旧 change 同形态:仍按过渡规则渐进 WARN(不计入清单,但报文说清为什么跳过)
1102
+ writeState(dir, legacyState);
1103
+ const resNoLoadsDirOld = runGuard(['exit', 'open'], dir);
1104
+ assertExit(resNoLoadsDirOld, 0);
1105
+ assertOut(resNoLoadsDirOld, 'SKILL-LOAD WARN');
1106
+ assertOut(resNoLoadsDirOld, '旧 change 兼容');
1107
+ assertOut(resNoLoadsDirOld, 'ALL CHECKS PASSED');
222
1108
  },
223
1109
  },
224
1110
 
@@ -270,16 +1156,135 @@ export const ENTRIES = [
270
1156
  },
271
1157
  },
272
1158
 
273
- // 105: 计数一致性自检同步(AC-8 / AC-14)——组文件里的场景数或系统测试集项数变更时,
274
- // 受检文件须同步(场景数:ALL n SCENARIOS PASSED / n scenarios / n 场景 / n/n 变体;
275
- // 项数:n/n / n items / n 项 变体)。本场景读取权威源仓库的受检文件断言含当前计数变体——
276
- // 文档漏同步或条目缺失(幽灵条目)即 RED;与底部自检共用同一实现(countSyncProblems),
277
- // 两处判据不会漂移。安装副本无文档面,跳过。
1159
+ // 105: 计数一致性自检同步(AC-8 / AC-14)+ 公开面机器字段名黑名单 + 结构预检命令锚 + 权威源设计
1160
+ // 形态锚(in-place 扩展,不新增场景)——组文件里的场景数或系统测试集项数变更时,受检文件须同步
1161
+ // (场景数:ALL n SCENARIOS PASSED / n scenarios / n 场景 / n/n 变体;项数:n/n / n items / n 项
1162
+ // 变体)。本场景读取权威源仓库的受检文件断言含当前计数变体——文档漏同步或条目缺失(幽灵条目)即
1163
+ // RED;与底部自检共用同一实现(countSyncProblems),两处判据不会漂移。
1164
+ // 公开面口径:用户阅读面不得直写机器状态字段名(黑名单),被明确标注为状态输出示例的围栏块
1165
+ // 放行;机制 / 用法 / 排障三份文档 × 中英都必须出现 `--preflight`(新增公开命令不得无锚)。
1166
+ // 判别力由反向构造证明:注入键名、抽掉命令锚 ⇒ 必报;标注示例块放行、撤掉标注 ⇒ 再报。
1167
+ // 形态分派(只按载体形态判,不猜):安装副本(无 .flow-comet/ 技能树)与分发包(技能树在、docs/ +
1168
+ // CONTRIBUTING.md + .github/ 三者俱缺)都没有公开文档面——跳过且**可见**(SKIP = 未校验,不是通过);
1169
+ // 只有权威源检出才跑公开面判据与设计形态锚。形态边界由 assertPublicFaceShapeProbes 自己钉住。
278
1170
  {
279
- name: '105 计数一致性自检同步:受检文件含当前场景数与系统测试集项数变体(AC-8 / AC-14)',
280
- run: async () => {
281
- if (!isAuthoritativeSourceRepo()) return; // 安装副本无 flow-comet 文档
282
- const problems = await countSyncProblems();
1171
+ name: '105 计数一致性自检同步 + 公开面机器字段名黑名单 + --preflight 锚 + 声明命令册子锚 + 权威源设计形态锚(AC-8 / AC-14)',
1172
+ run: async (dir) => {
1173
+ // 声明命令的册子锚:不按载体形态分派(两册随技能包一起分发,装到哪都该给出同一组命令)——
1174
+ // 这也是「缺声明时报文给出的命令」与册子口径一致的那条机检(两边各给一半时必有一侧缺锚)。
1175
+ const bookProblems = declarationBookProblems(path.join(SCRIPTS_DIR, '..'));
1176
+ if (bookProblems.length > 0) throw new Error(bookProblems.join(';'));
1177
+ // 权威源判定走 lib 的同一份探针(authoritativeSourceAt:与真实检出同一技能树锚,可带受检根)——
1178
+ // 本场景不再自持一份前置判定,形态问题只有一处说了算。
1179
+ if (!authoritativeSourceAt()) {
1180
+ // 安装副本:无公开文档面,也无「权威源打印设计形态」这回事——跳过必须可见。
1181
+ console.log('SKIP: 公开面与设计形态判据(安装副本检出:本检出无 .flow-comet/skills/flow-comet/SKILL.md)'
1182
+ + '——本次未校验公开面键名黑名单 / 命令锚,也未校验恢复命令的脚本路径是否为权威源设计形态'
1183
+ + '(SKIP = 未校验,不是通过)');
1184
+ return;
1185
+ }
1186
+ // 形态判据自己的判别力(纯夹具,先于任何派生)
1187
+ assertPublicFaceShapeProbes(dir);
1188
+ // 设计形态锚:只读打印出来的恢复段,要求命令的脚本路径逐字为设计形态、步骤按执行顺序。仅在
1189
+ // **正在跑权威源脚本**时适用;
1190
+ // 跑安装副本套件时,副本按运行根推导出的路径才是那种载体的正确形态,不属于本锚范围——跳过必须可见。
1191
+ if (RUNS_FROM_AUTHORITATIVE_SCRIPTS) {
1192
+ assertDesignFormRecoveryPath(dir);
1193
+ } else {
1194
+ console.log('SKIP: 权威源设计形态锚(当前运行的是安装副本脚本:' + path.relative(REPO_ROOT, SCRIPTS_DIR)
1195
+ + ')——安装副本按运行根推导路径属另一种载体的正确形态,本锚只在权威源脚本下适用(SKIP = 未校验,不是通过)');
1196
+ }
1197
+ // 分发包形态(npm 包 / 安装副本):公开面载体三者俱缺(docs/ + CONTRIBUTING.md + .github/)⇒
1198
+ // 公开面无从派生,也就无从检查。跳过的就是**公开面这一整块**(含计数同步——它数的文件同样不随
1199
+ // 包分发);计数面在底部自检里另有一次独立执行,不会因这条跳过而整体失踪。判据本体在 lib
1200
+ // (publicFaceDocsAbsent):只按 docs/ 在不在分流,会把「docs/ 被裁掉、其余公开面还在」的检出
1201
+ // 一并放过——那正是整块判据静默失效的形态。
1202
+ if (publicFaceDocsAbsent(REPO_ROOT)) {
1203
+ console.log(PUBLIC_FACE_SELF_CHECK_SKIP_NOTICE);
1204
+ return;
1205
+ }
1206
+ const problems = [...await countSyncProblems()];
1207
+ const publicFace = readPublicFaceTexts();
1208
+ problems.push(...publicFaceMachineProblems(publicFace));
1209
+ // 反向构造(同一判据驱动):探针在快照副本上作业,真实断言与探针调用同一个函数。
1210
+ const mutated = (rel, mutate) => {
1211
+ const text = publicFace.texts.get(rel);
1212
+ if (typeof text !== 'string') return null; // 缺失已由真实判据报告,避免探针掩盖真实原因
1213
+ const next = mutate(text);
1214
+ return next === text ? null : { ...publicFace, texts: new Map(publicFace.texts).set(rel, next) };
1215
+ };
1216
+ // 排障册的声明命令锚:真实断言与反向构造走同一判据实现(逐条抽掉 ⇒ 必报——少任何一条,
1217
+ // 照抄的人都会在同一次 exit 上被覆盖门点名缺那一项)。
1218
+ problems.push(...troubleshootingDeclarationProblems(publicFace.texts));
1219
+ for (const anchor of TROUBLESHOOTING_DECLARATION_ANCHORS) {
1220
+ const stripped = mutated('docs/TROUBLESHOOTING.md',
1221
+ (text) => text.split(anchor).join('(反向构造:抽掉)'));
1222
+ if (stripped !== null && troubleshootingDeclarationProblems(stripped.texts).length === 0) {
1223
+ throw new Error('反向构造判别力缺失(排障册:抽掉声明命令锚未被判缺): ' + anchor);
1224
+ }
1225
+ }
1226
+ // 受检面来自派生(映射 + 根目录扫描):按 GitHub 惯例放在根目录的公开文件若被漏在受检面之外,
1227
+ // 就没有注入点——这里直接判红,不让探针静默跳过。探针必须是**只有根目录扫描能贡献**的文件:
1228
+ // 映射已登记的路径(SECURITY.md 就由 security 主题提供)在根目录扫描缺席时仍在面内,取它做
1229
+ // 探针等于空断言,所以在选型处就对这条前提本身设防。
1230
+ const ROOT_FACE_PROBE = 'CODE_OF_CONDUCT.md';
1231
+ const mappedFacePaths = new Set([...publicFaceTopicPairs(readPublicFaceAuthorityMap()).values()].flat());
1232
+ if (mappedFacePaths.has(ROOT_FACE_PROBE)) {
1233
+ throw new Error('根目录探针失去判别力(' + ROOT_FACE_PROBE + ' 已由权威映射提供,'
1234
+ + '根目录扫描缺席时它仍在受检面内)');
1235
+ }
1236
+ if (!publicFace.texts.has(ROOT_FACE_PROBE)) {
1237
+ throw new Error('受检面漏了根目录公开文档(' + ROOT_FACE_PROBE + ' 未纳入派生的受检面)');
1238
+ }
1239
+ const probes = [
1240
+ ['注入机器字段名(用法册)', mutated('docs/USAGE.md', (text) => text + '\n`currentNode`\n'), '直写了机器状态字段名'],
1241
+ ['注入 evidence 键名(机制册)', mutated('docs/MECHANISM.md', (text) => text + '\n`evidence`\n'), '直写了机器状态字段名 evidence'],
1242
+ // 散文形态(不带反引号):字段名不写反引号同样是把它当成用户面契约——这是黑名单原先的盲区
1243
+ ['注入 evidence 散文名(机制册,不带反引号)',
1244
+ mutated('docs/MECHANISM.md', (text) => text + '\nthe evidence field is written by record\n'),
1245
+ '直写了机器状态字段名 evidence'],
1246
+ ['注入 evidence 散文名(机制册,带反引号)',
1247
+ mutated('docs/MECHANISM.md', (text) => text + '\nthe `evidence` field is written by record\n'),
1248
+ '直写了机器状态字段名 evidence'],
1249
+ ['注入字段族键名(机制册)', mutated('docs/MECHANISM.md', (text) => text + '\n`verifyFailuresByChange`\n'), '直写了机器状态字段名 verifyFailuresByChange'],
1250
+ ['抽掉命令锚(排障册中文)', mutated('docs/TROUBLESHOOTING-zh.md', (text) => text.split('--preflight').join('')), '缺「--preflight」'],
1251
+ ['注入机器字段名(根目录公开文档)', mutated(ROOT_FACE_PROBE, (text) => text + '\n`currentNode`\n'), '直写了机器状态字段名'],
1252
+ ];
1253
+ for (const [label, texts, expected] of probes) {
1254
+ if (texts === null) continue;
1255
+ if (!publicFaceMachineProblems(texts).some((p) => p.includes(expected))) {
1256
+ throw new Error('反向构造判别力缺失(' + label + ' 未被判违规)');
1257
+ }
1258
+ }
1259
+ // 允许段白名单双向判别:同一段键名,标注为状态输出示例时放行,撤掉标注后必须报。
1260
+ const exampleBlock = (heading) => '\n' + heading + '\n\n```json\n{ "currentNode": "review" }\n```\n';
1261
+ const allowed = mutated('docs/MECHANISM.md', (text) => text + exampleBlock('### 状态输出示例'));
1262
+ if (allowed && publicFaceMachineProblems(allowed).some((p) => p.includes('docs/MECHANISM.md') && p.includes('直写了机器状态字段名'))) {
1263
+ throw new Error('允许段白名单失效(标注为状态输出示例的围栏块内键名被误判违规)');
1264
+ }
1265
+ const unmarked = mutated('docs/MECHANISM.md', (text) => text + exampleBlock('### 输出草稿'));
1266
+ if (unmarked && !publicFaceMachineProblems(unmarked).some((p) => p.includes('docs/MECHANISM.md') && p.includes('直写了机器状态字段名'))) {
1267
+ throw new Error('允许段白名单判别力缺失(未标注为状态输出示例的围栏块内键名未被判违规)');
1268
+ }
1269
+ // 黑名单扩容的判别力逐名验:加进数组不算数,每个名字都要真的命中——漏登记的键照样能走私进来。
1270
+ const WIDENED_KEYS = ['completedNodes', 'enteredNodes', 'directOverride', 'newChange'];
1271
+ const widened = mutated('docs/MECHANISM.md',
1272
+ (text) => text + '\n' + WIDENED_KEYS.map((name) => '`' + name + '`').join(' ') + '\n');
1273
+ for (const name of WIDENED_KEYS) {
1274
+ if (widened && !publicFaceMachineProblems(widened)
1275
+ .some((p) => p.includes('直写了机器状态字段名 ' + name))) {
1276
+ throw new Error('机器字段黑名单漏了 ' + name + '(注入后未被判违规)');
1277
+ }
1278
+ }
1279
+ // 放行规则的反向判别:黑名单扩容最容易砸到的既有句子——代码位置引用(state.evidence)与普通
1280
+ // 英文名词用法(the evidence recorded for the node)都必须放行,否则判据只能靠改文档来变绿。
1281
+ const released = mutated('docs/MECHANISM.md', (text) => text
1282
+ + '\n位置引用:恢复记录写在 state.evidence 下。\n'
1283
+ + '\nThe evidence recorded for the node is what the exit reads.\n');
1284
+ if (released && publicFaceMachineProblems(released)
1285
+ .some((p) => p.includes('docs/MECHANISM.md') && p.includes('直写了机器状态字段名'))) {
1286
+ throw new Error('放行规则失效(state.evidence 位置引用 / 普通英文 evidence 被误判为字段名直写)');
1287
+ }
283
1288
  if (problems.length > 0) {
284
1289
  throw new Error(problems.join('; '));
285
1290
  }
@@ -296,6 +1301,10 @@ export const ENTRIES = [
296
1301
  const st = baseState('review');
297
1302
  st.evidence.review = { summary: 'review done' };
298
1303
  writeState(dir, st);
1304
+ // ②④ 共用:本夹具下允许出现的 REVIEW WARN 类别由调用方逐条枚举,**枚举外的行一律算失败**——
1305
+ // 逐条 assertNotOut 只挡得住被点名的那一类,夹具上再冒出一类无关告警时不会红(判别力退化)。
1306
+ const reviewWarnsOutside = (res, allowed) => String(res.output || '').split(/\r?\n/)
1307
+ .filter((line) => line.includes('REVIEW WARN') && !allowed.some((marker) => line.includes(marker)));
299
1308
  // ① 发现区 Minor 条目无处置标记 → REVIEW WARN + 通过(渐进不阻断)
300
1309
  writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
301
1310
  '# 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');
@@ -303,12 +1312,16 @@ export const ENTRIES = [
303
1312
  assertExit(res, 0);
304
1313
  assertOut(res, 'REVIEW WARN');
305
1314
  assertOut(res, 'ALL CHECKS PASSED');
306
- // ② 同一条目带 [转待办] 处置标记 → 无 REVIEW WARN
1315
+ // ② 同一条目带 [转待办] 处置标记 → 不再报「缺处置状态标记」(该条已有处置去向;Minor 延期
1316
+ // 另受裁决/判据门槛约束,旧 change 只 WARN 不阻断)
307
1317
  writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
308
1318
  '# 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
1319
  const res2 = runGuard(['exit', 'review'], dir);
310
1320
  assertExit(res2, 0);
311
- assertNotOut(res2, 'REVIEW WARN');
1321
+ // [转待办] 另触发延期裁决与 Minor 判据两道门——这两类之外不得出现任何 REVIEW WARN
1322
+ // (含「缺处置状态标记」:该条已有处置去向,误报即本场景的回归)。
1323
+ const outside2 = reviewWarnsOutside(res2, ['缺少用户裁决记录', '缺 `判 Minor:` 行']);
1324
+ assertTrue(outside2.length === 0, '② 出现枚举外的 REVIEW WARN(未知告警类别):\n' + outside2.join('\n'));
312
1325
  assertOut(res2, 'ALL CHECKS PASSED');
313
1326
  // ③ 有序条目(1. **...**)与无序同口径——缺处置标记 → 旧 change 仍渐进 REVIEW WARN
314
1327
  // (修复前 .filter((item) => !item.ordered) 使有序条目静默通过 = RED)
@@ -318,12 +1331,14 @@ export const ENTRIES = [
318
1331
  assertExit(resOrdered, 0);
319
1332
  assertOut(resOrdered, 'REVIEW WARN');
320
1333
  assertNotOut(resOrdered, 'BLOCKED');
321
- // ④ 有序 Minor 带 [转待办] → 无该渐进告警(有序条目接入校验不误报已处置项)
1334
+ // ④ 有序 Minor 带 [转待办] → 无「缺处置状态标记」告警(有序条目接入校验不误报已处置项)
322
1335
  writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md',
323
1336
  '# REVIEW\n\n## 发现\n\n1. **m-3 · 有序小项**:某处小问题,已登记下一 change 跟踪处置 [转待办]\n\n## 结论\n\n通过\n');
324
1337
  const resOrderedOk = runGuard(['exit', 'review'], dir);
325
1338
  assertExit(resOrderedOk, 0);
326
- assertNotOut(resOrderedOk, 'REVIEW WARN');
1339
+ // 有序条目未标严重度 → 只允许延期待裁决一类告警(Minor 判据门对未标严重度的条目不适用)。
1340
+ const outsideOrdered = reviewWarnsOutside(resOrderedOk, ['缺少用户裁决记录']);
1341
+ assertTrue(outsideOrdered.length === 0, '④ 出现枚举外的 REVIEW WARN(未知告警类别):\n' + outsideOrdered.join('\n'));
327
1342
  assertOut(resOrderedOk, 'ALL CHECKS PASSED');
328
1343
  },
329
1344
  },
@@ -425,7 +1440,7 @@ export const ENTRIES = [
425
1440
 
426
1441
  // 110: execute 出口越权委托检测——TASK 有 parallel done 任务 + completedNodes
427
1442
  // 无 subagent-execute + 非 direct 模式 → WARN 渐进([P] 任务应由 subagent-execute 节点委托,
428
- // execute 阶段完成 [P] 是越权委托痕迹——上轮真实流程实证的越权委托);completedNodes 含
1443
+ // execute 阶段完成 [P] 是越权委托痕迹);completedNodes 含
429
1444
  // subagent-execute 或 direct 模式 → 无越权 WARN
430
1445
  {
431
1446
  name: '110 execute exit:parallel done 无 subagent-execute → WARN 越权委托',
@@ -485,7 +1500,7 @@ export const ENTRIES = [
485
1500
 
486
1501
  // 112: 节点顺序 BLOCK 消息含恢复指引——next 的「疑似未 exit」BLOCK 与
487
1502
  // exit 的「currentNode 不匹配」BLOCK 均提示恢复通道(advance 强制推进/select 切换/
488
- // exit --apply)——防 resume 自锁(上轮真实项目端到端验证观察:机器推导节点无脚本恢复通道)
1503
+ // exit --apply)——防 resume 自锁(机器推导出的节点没有脚本恢复通道)
489
1504
  {
490
1505
  name: '112 节点顺序 BLOCK 消息含恢复指引',
491
1506
  run: (dir) => {
@@ -554,6 +1569,7 @@ export const ENTRIES = [
554
1569
  stEof.evidence.plan = { summary: 'plan done' };
555
1570
  stEof.newChange = true;
556
1571
  writeState(dir, stEof);
1572
+ writeNodeDeclarationMarkers(dir, 'plan');
557
1573
  assertExit(runGuard(['entry', 'plan'], dir), 0);
558
1574
  const taskT01Eof = '<task id="T01"><action>a</action><write_files>f</write_files><verify>v</verify><done>d</done></task>\n';
559
1575
  const eofHead = '# TASK\n\n## 波次划分\n\nWave 1 (parallel): ';
@@ -749,6 +1765,7 @@ export const ENTRIES = [
749
1765
  st.enteredNodes = ['open', 'design', 'plan', 'execute'];
750
1766
  st.newChange = true;
751
1767
  writeState(dir, st);
1768
+ writeNodeDeclarationMarkers(dir, 'execute');
752
1769
  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
1770
  const res = runGuard(['exit', 'execute'], dir);
754
1771
  assertExit(res, 0);
@@ -778,8 +1795,8 @@ export const ENTRIES = [
778
1795
  },
779
1796
  },
780
1797
 
781
- // 123: M8——init 在无提交(空)仓库时输出提示且跳过分支创建(行为一致:
782
- // 修复前 WARN"无法创建分支"后仍 checkout -b 实际创建——声称与行为矛盾)
1798
+ // 123: init 在无提交(空)仓库时输出提示且跳过分支创建——提示与行为必须一致:
1799
+ // 警告之后仍 checkout -b 实际创建分支,就是声称与行为矛盾
783
1800
  {
784
1801
  name: '123 init 空仓库提示:无提交仓库的分支创建边界(M8)',
785
1802
  run: (dir) => {
@@ -818,15 +1835,18 @@ export const ENTRIES = [
818
1835
  },
819
1836
 
820
1837
  // 125: R1——新 change(newChange:true)review 处置标记缺失 → BLOCKED(旧 change WARN 保留);
821
- // 并内扩 Major 延期待裁决门禁三态+一反例:无用户裁决 BLOCK / 同段或文末裁决(由 [升级]
822
- // 承接)放行 / Minor [转待办] 不受影响 / 有裁决但缺 [升级] 承接仍 BLOCK。
1838
+ // 并内扩延期裁决门禁(覆盖任何严重度,含 Minor):无用户裁决 BLOCK / 同段或其它段落裁决(由
1839
+ // [升级] 承接)放行 / 有裁决但缺 [升级] 承接仍 BLOCK;Minor 另须在条目块内自证判据
1840
+ // 「判 Minor:<一句话理由>」——判据落在**判定当时**,与处置标记无关([已修]/[升级]/[转待办]
1841
+ // 一律要;缺则改判 Major,默认 Major)。
823
1842
  {
824
- name: '125 review exit BLOCKED:新 change 处置标记缺失 + Major 延期待裁决(R1)',
1843
+ name: '125 review exit BLOCKED:新 change 处置标记缺失 + 延期待裁决(R1)',
825
1844
  run: (dir) => {
826
1845
  const st = baseState('review');
827
1846
  st.evidence.review = { summary: 'reviewed' };
828
1847
  st.newChange = true;
829
1848
  writeState(dir, st);
1849
+ writeNodeDeclarationMarkers(dir, 'review');
830
1850
  assertExit(runGuard(['entry', 'review'], dir), 0);
831
1851
  writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## Critical\n\n无。\n\n## 发现\n\n- **问题A**: 某处存在一个需要记录的问题描述,但未给出任何处置结论\n\n## 结论\n\n通过\n');
832
1852
  const res = runGuard(['exit', 'review'], dir);
@@ -862,11 +1882,81 @@ export const ENTRIES = [
862
1882
  assertExit(resAdjudicated, 0);
863
1883
  assertOut(resAdjudicated, 'ALL CHECKS PASSED');
864
1884
  assertNotOut(resAdjudicated, '用户裁决');
865
- // 子断言:Minor [转待办] 不受影响 → 放行
866
- writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-1 · 小项**:某处小问题 [转待办]\n\n## 结论\n\n通过\n');
1885
+ // 子断言:Minor [转待办] 与 Major 同口径——无用户裁决记录 → BLOCKED(报文点名条目 + 给出
1886
+ // 裁决记录形态;修复前 Minor 可自行延期直接放行 = RED)
1887
+ 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
1888
  const resMinor = runGuard(['exit', 'review'], dir);
868
- assertExit(resMinor, 0);
869
- assertOut(resMinor, 'ALL CHECKS PASSED');
1889
+ assertExit(resMinor, 1);
1890
+ assertOut(resMinor, 'BLOCKED');
1891
+ assertOut(resMinor, 'm-1 · 小项');
1892
+ assertOut(resMinor, '用户裁决:接受延期');
1893
+ // 子断言:同一条目补上裁决记录(指向该条目 + [升级] 承接)→ 放行
1894
+ 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');
1895
+ const resMinorAdjudicated = runGuard(['exit', 'review'], dir);
1896
+ assertExit(resMinorAdjudicated, 0);
1897
+ assertOut(resMinorAdjudicated, 'ALL CHECKS PASSED');
1898
+ assertNotOut(resMinorAdjudicated, 'BLOCKED');
1899
+ // 子断言:Minor 条目缺判定理由「判 Minor:<理由>」→ BLOCKED(报文点名条目 + 给出形态);
1900
+ // 补上判据后放行(裁决记录仍在,缺的只是 Minor 判据本身)
1901
+ 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');
1902
+ const resMinorNoReason = runGuard(['exit', 'review'], dir);
1903
+ assertExit(resMinorNoReason, 1);
1904
+ assertOut(resMinorNoReason, 'BLOCKED');
1905
+ assertOut(resMinorNoReason, 'm-5 · 缺判据的小项');
1906
+ assertOut(resMinorNoReason, '判 Minor:');
1907
+ 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');
1908
+ const resMinorReasonOk = runGuard(['exit', 'review'], dir);
1909
+ assertExit(resMinorReasonOk, 0);
1910
+ assertOut(resMinorReasonOk, 'ALL CHECKS PASSED');
1911
+ // 子断言(R2 判定时门禁):判为 Minor 就要在**判定当时**自证判据,与处置标记无关——[已修]
1912
+ // 的 Minor 缺「判 Minor:」行 → BLOCKED(修复前只查 [转待办],[已修]/[升级] 的 Minor 直接
1913
+ // 放行 = RED);报文点名条目 + 严重度 + 缺行 + 正确形态 + 「改判 Major」兜底。
1914
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-9 · 已修但缺判据的小项**:某处小问题 [已修]\n\n## 结论\n\n通过\n');
1915
+ const resMinorFixed = runGuard(['exit', 'review'], dir);
1916
+ assertExit(resMinorFixed, 1);
1917
+ assertOut(resMinorFixed, 'BLOCKED');
1918
+ assertOut(resMinorFixed, 'm-9 · 已修但缺判据的小项');
1919
+ assertOut(resMinorFixed, '(Minor)');
1920
+ assertOut(resMinorFixed, '缺 `判 Minor:` 行');
1921
+ assertOut(resMinorFixed, '改判 Major');
1922
+ // 补上判据行 → 放行([已修] 不是「没有 Minor 判定」的理由)
1923
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-9 · 已修但缺判据的小项**:某处小问题 [已修]\n 判 Minor:仅影响日志措辞,不改变行为与接口\n\n## 结论\n\n通过\n');
1924
+ const resMinorFixedOk = runGuard(['exit', 'review'], dir);
1925
+ assertExit(resMinorFixedOk, 0);
1926
+ assertOut(resMinorFixedOk, 'ALL CHECKS PASSED');
1927
+ // [升级] 的 Minor 同形态:缺判据 → BLOCKED;补上 → 放行
1928
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-10 · 升级但缺判据的小项**:某处小问题 [升级]\n\n## 结论\n\n通过\n');
1929
+ const resMinorEscalated = runGuard(['exit', 'review'], dir);
1930
+ assertExit(resMinorEscalated, 1);
1931
+ assertOut(resMinorEscalated, 'BLOCKED');
1932
+ assertOut(resMinorEscalated, 'm-10 · 升级但缺判据的小项');
1933
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-10 · 升级但缺判据的小项**:某处小问题 [升级]\n 判 Minor:只涉及命名一致性\n\n## 结论\n\n通过\n');
1934
+ const resMinorEscalatedOk = runGuard(['exit', 'review'], dir);
1935
+ assertExit(resMinorEscalatedOk, 0);
1936
+ assertOut(resMinorEscalatedOk, 'ALL CHECKS PASSED');
1937
+ // 既有 [转待办] 不回归:R2 扩面不取代 R1——只补判据、无裁决 → 仍 BLOCKED(裁决门独立,
1938
+ // 判据门不再报);补裁决 + [升级] 承接后才放行(双重约束各自在场)。
1939
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-11 · 延期缺判据的小项**:某处小问题 [转待办]\n\n## 结论\n\n通过\n');
1940
+ const resMinorDeferredNoReason = runGuard(['exit', 'review'], dir);
1941
+ assertExit(resMinorDeferredNoReason, 1);
1942
+ assertOut(resMinorDeferredNoReason, '用户裁决');
1943
+ assertOut(resMinorDeferredNoReason, '判 Minor:');
1944
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-11 · 延期缺判据的小项**:某处小问题 [转待办]\n 判 Minor:仅影响内部日志\n\n## 结论\n\n通过\n');
1945
+ const resMinorDeferredReasonOnly = runGuard(['exit', 'review'], dir);
1946
+ assertExit(resMinorDeferredReasonOnly, 1);
1947
+ assertOut(resMinorDeferredReasonOnly, '用户裁决');
1948
+ assertNotOut(resMinorDeferredReasonOnly, '判 Minor:');
1949
+ 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');
1950
+ const resMinorDeferredOk = runGuard(['exit', 'review'], dir);
1951
+ assertExit(resMinorDeferredOk, 0);
1952
+ assertOut(resMinorDeferredOk, 'ALL CHECKS PASSED');
1953
+ // 子断言(R2 覆盖边界):Major 的任何处置都不受判据门影响——[已修] / [升级] 均不要求
1954
+ // 「判 Minor:」行([转待办] + 用户裁决的 Major 由上面的 F2 覆盖)
1955
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Major\n\n- **F11 · 已修的大项**:某处问题 [已修]\n- **F12 · 升级的大项**:另一处问题 [升级]\n\n## 结论\n\n通过\n');
1956
+ const resMajorDisposed = runGuard(['exit', 'review'], dir);
1957
+ assertExit(resMajorDisposed, 0);
1958
+ assertOut(resMajorDisposed, 'ALL CHECKS PASSED');
1959
+ assertNotOut(resMajorDisposed, '判 Minor:');
870
1960
  // 子断言:文末用户裁决 + 指向该条目 + [升级] 承接 → 放行
871
1961
  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
1962
  const resTail = runGuard(['exit', 'review'], dir);
@@ -884,13 +1974,19 @@ export const ENTRIES = [
884
1974
  assertOut(resNoEscalation, 'BLOCKED');
885
1975
  assertOut(resNoEscalation, 'Major');
886
1976
  assertOut(resNoEscalation, '用户裁决');
887
- // 子断言:Minor 条目正文引用 [Major] 标签字样(自身 [转待办])→ 放行——严重度/处置
888
- // 以条目自身标题/行首为准,不做整块标签扫描(修复前误判 Major 并触发延期门禁 = RED)
1977
+ // 子断言:条目正文引用 [Major] 标签字样(自身 [转待办])→ 严重度以条目自身标题/行首为准,
1978
+ // 正文标签不改变本条判定(报文按「未标严重度」点名,不因正文出现 [Major] 就升格为 Major);
1979
+ // 补上裁决记录后放行——延期门禁对任何严重度生效,处置由裁决记录承接
889
1980
  writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n- **m-2 · 引用 Major 的小项**:本条与 [Major] F1 项不同,是独立问题 [转待办]\n\n## 结论\n\n通过\n');
890
1981
  const resCited = runGuard(['exit', 'review'], dir);
891
- assertExit(resCited, 0);
892
- assertOut(resCited, 'ALL CHECKS PASSED');
893
- assertNotOut(resCited, 'BLOCKED');
1982
+ assertExit(resCited, 1);
1983
+ assertOut(resCited, '未标严重度');
1984
+ assertNotOut(resCited, '(Major)');
1985
+ 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');
1986
+ const resCitedOk = runGuard(['exit', 'review'], dir);
1987
+ assertExit(resCitedOk, 0);
1988
+ assertOut(resCitedOk, 'ALL CHECKS PASSED');
1989
+ assertNotOut(resCitedOk, 'BLOCKED');
894
1990
  // 子断言:Major 条目自身处置为 [已修],续行正文引用他条 [转待办] → 放行——
895
1991
  // 延期门禁只看该条目自身标题/行首的处置标记,不做整块扫描
896
1992
  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 +2017,7 @@ export const ENTRIES = [
921
2017
  '# REVIEW\n\n## 发现\n\n### Major\n\n'
922
2018
  + '- **F10 · 中段裁决的延期**:某处问题 [升级] [转待办]\n\n'
923
2019
  + '- 用户裁决:接受延期 —— 发现 F10(中段裁决的延期):下一 change 首修。\n\n'
924
- + '### Minor\n\n- **m-4 · 小项**:另一个独立问题 [已修]\n\n## 结论\n\n通过\n');
2020
+ + '### Minor\n\n- **m-4 · 小项**:另一个独立问题 [已修]\n 判 Minor:仅措辞问题\n\n## 结论\n\n通过\n');
925
2021
  const resMidParagraph = runGuard(['exit', 'review'], dir);
926
2022
  assertExit(resMidParagraph, 0);
927
2023
  assertOut(resMidParagraph, 'ALL CHECKS PASSED');
@@ -973,6 +2069,7 @@ export const ENTRIES = [
973
2069
  st.evidence.plan = { summary: 'planned' };
974
2070
  st.newChange = true;
975
2071
  writeState(dir, st);
2072
+ writeNodeDeclarationMarkers(dir, 'plan');
976
2073
  assertExit(runGuard(['entry', 'plan'], dir), 0);
977
2074
  const planTask = (text) => writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', text);
978
2075
  const taskT01 = '<task id="T01"><action>a</action><write_files>f</write_files><verify>v</verify><done>d</done></task>\n';
@@ -1044,7 +2141,10 @@ export const ENTRIES = [
1044
2141
  assertExit(resWrongNode, 1);
1045
2142
  assertOut(resWrongNode, 'BLOCKED: 任务 P-M02(并行 pending)应归属节点 subagent-execute');
1046
2143
  assertOut(resWrongNode, 'workflow-state next');
1047
- assertOut(resWrongNode, 'entry subagent-execute');
2144
+ // 同样改为断言顺序句本身——「先对当前节点 record + exit」+「未 exit 前不得 entry」。
2145
+ // 旧的裸 'entry subagent-execute' 会同时命中禁止句里的目标节点名,无法区分两种语义。
2146
+ assertOut(resWrongNode, '先对当前节点 execute record + exit');
2147
+ assertOut(resWrongNode, '不要在未 exit 前 entry 目标节点');
1048
2148
  assertOut(resWrongNode, '本次请求未写入 state');
1049
2149
  if (fs.readFileSync(reqStatePath, 'utf8') !== beforeReqBytes) {
1050
2150
  throw new Error('M-02 BLOCK 必须 state 字节零改写');
@@ -1150,10 +2250,11 @@ export const ENTRIES = [
1150
2250
  },
1151
2251
  },
1152
2252
 
1153
- // 131: R1 旧兼容——旧 change(无 newChange)处置标记缺失仍 WARN;并内扩 Major 延期待裁决
1154
- // 门禁旧 change 渐进面:无用户裁决 → WARN 不 BLOCK(不卡死旧 REVIEW);有裁决+[升级] → 放行。
2253
+ // 131: R1 旧兼容——旧 change(无 newChange)处置标记缺失仍 WARN;并内扩延期裁决门禁(含 Minor)
2254
+ // 的旧 change 渐进面:无用户裁决 / Minor 缺判据 → 只 WARN 不 BLOCK(不卡死旧 REVIEW);有裁决
2255
+ // +[升级] → 放行。Minor 判据门(R2)扩到 [已修]/[升级] 后旧 change 同一渐进口径。
1155
2256
  {
1156
- name: '131 review exit 兼容:旧 change 处置标记缺失仍 WARN + Major 延期渐进(R1 旧兼容)',
2257
+ name: '131 review exit 兼容:旧 change 处置标记缺失仍 WARN + 延期渐进(R1 旧兼容)',
1157
2258
  run: (dir) => {
1158
2259
  const st = baseState('review');
1159
2260
  st.evidence.review = { summary: 'reviewed' };
@@ -1183,6 +2284,31 @@ export const ENTRIES = [
1183
2284
  assertOut(resOrderedMajor, 'REVIEW WARN');
1184
2285
  assertOut(resOrderedMajor, '用户裁决');
1185
2286
  assertNotOut(resOrderedMajor, 'BLOCKED');
2287
+ // 子断言:Minor [转待办] 无用户裁决 → 旧 change 同样只 WARN 不 BLOCK(延期门禁覆盖任何
2288
+ // 严重度,旧 REVIEW 渐进提示、不卡死既有 change)
2289
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-6 · 旧 change 未裁决的小项**:某处小问题 [转待办]\n\n## 结论\n\n通过\n');
2290
+ const resMinorDeferred = runGuard(['exit', 'review'], dir);
2291
+ assertExit(resMinorDeferred, 0);
2292
+ assertOut(resMinorDeferred, 'REVIEW WARN');
2293
+ assertOut(resMinorDeferred, 'm-6 · 旧 change 未裁决的小项');
2294
+ assertOut(resMinorDeferred, '用户裁决');
2295
+ assertNotOut(resMinorDeferred, 'BLOCKED');
2296
+ // 子断言:Minor [转待办] + 裁决记录但缺「判 Minor:」判据 → 旧 change 只 WARN 不 BLOCK
2297
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-7 · 旧 change 缺判据的小项**:某处小问题 [升级] [转待办]\n\n- 用户裁决:接受延期 —— 发现 m-7:下一 change 首修。\n\n## 结论\n\n通过\n');
2298
+ const resMinorNoReason = runGuard(['exit', 'review'], dir);
2299
+ assertExit(resMinorNoReason, 0);
2300
+ assertOut(resMinorNoReason, 'REVIEW WARN');
2301
+ assertOut(resMinorNoReason, '判 Minor:');
2302
+ assertNotOut(resMinorNoReason, 'BLOCKED');
2303
+ // 子断言(R2 判定时门禁的旧 change 渐进面):[已修] 的 Minor 缺判据同样只 WARN 不 BLOCK
2304
+ // ——不卡死既有 REVIEW,与 [转待办] 形态同一渐进口径(新 change 见 125)
2305
+ writeFile(dir, '.specs/' + CHANGE_ID + '/REVIEW.md', '# REVIEW\n\n## 发现\n\n### Minor\n\n- **m-8 · 旧 change 已修缺判据的小项**:某处小问题 [已修]\n\n## 结论\n\n通过\n');
2306
+ const resMinorFixedNoReason = runGuard(['exit', 'review'], dir);
2307
+ assertExit(resMinorFixedNoReason, 0);
2308
+ assertOut(resMinorFixedNoReason, 'REVIEW WARN');
2309
+ assertOut(resMinorFixedNoReason, 'm-8 · 旧 change 已修缺判据的小项');
2310
+ assertOut(resMinorFixedNoReason, '判 Minor:');
2311
+ assertNotOut(resMinorFixedNoReason, 'BLOCKED');
1186
2312
  },
1187
2313
  },
1188
2314
 
@@ -1216,6 +2342,7 @@ export const ENTRIES = [
1216
2342
  st.evidence.execute = { summary: 'empty', emptyExitApproved: true };
1217
2343
  st.newChange = true;
1218
2344
  writeState(dir, st);
2345
+ writeNodeDeclarationMarkers(dir, 'execute');
1219
2346
  assertExit(runGuard(['entry', 'execute'], dir), 0);
1220
2347
  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
2348
  const res = runGuard(['exit', 'execute'], dir);
@@ -1355,6 +2482,7 @@ export const ENTRIES = [
1355
2482
  st.evidence.review = { summary: 'reviewed' }; // record 过但 exit 被拦截
1356
2483
  st.newChange = true;
1357
2484
  writeState(dir, st);
2485
+ writeNodeDeclarationMarkers(dir, 'review');
1358
2486
  // 前序产物(execute 产物门控需 *-SUMMARY.md)
1359
2487
  writeFile(dir, '.specs/' + CHANGE_ID + '/CHANGE.md', '# CHANGE\n\n## Why(为什么做)\nx');
1360
2488
  writeFile(dir, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', '# REQUIREMENT\n\n## 用户故事\nx\n\n## 验收准则(AC)\n- Given x When y Then z');