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.
- package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
- package/.flow-comet/skills/flow-comet/SKILL.md +36 -6
- package/.flow-comet/skills/flow-comet/reference/artifact-template-overlay.md +154 -0
- package/.flow-comet/skills/flow-comet/reference/artifact-templates.json +387 -0
- package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/entry-detail.md +29 -4
- package/.flow-comet/skills/flow-comet/reference/workflow-protocol.json +22 -0
- package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +26 -23
- package/.flow-comet/skills/flow-comet/scripts/evolve.mjs +174 -0
- package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +17 -95
- package/.flow-comet/skills/flow-comet/scripts/health.mjs +28 -4
- package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +136 -19
- package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +54 -18
- package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +6 -6
- package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +52 -10
- package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +25 -10
- package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +4 -2
- package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +21 -13
- package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +163 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/ac-coverage.mjs +317 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-artifact-skeleton.mjs +448 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +396 -27
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +1035 -172
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +129 -98
- 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 +797 -232
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +91 -22
- 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 +69 -13
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +454 -135
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +66 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +109 -13
- package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +55 -2
- package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +149 -34
- package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +79 -9
- package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +84 -31
- package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +78 -8
- package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +60 -3
- package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +167 -3
- package/.flow-comet/skills/flow-comet/scripts/lib/wave-projection.mjs +341 -0
- package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +287 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +1454 -16
- package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1202 -8
- package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1205 -77
- package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +753 -5
- package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +52 -11
- package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +582 -3
- package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +9 -1
- package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +5 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +22 -6
- package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +2 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +18 -5
- package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +4100 -0
- package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +135 -0
- package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +6 -5
- package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +203 -4
- package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +312 -63
- package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +5 -2
- package/.flow-comet/skills/flow-comet-archive/SKILL.md +6 -2
- package/.flow-comet/skills/flow-comet-change/SKILL.md +6 -2
- package/.flow-comet/skills/flow-comet-design/GUIDANCE.md +13 -3
- package/.flow-comet/skills/flow-comet-design/SKILL.md +15 -8
- package/.flow-comet/skills/flow-comet-dev/SKILL.md +1 -1
- package/.flow-comet/skills/flow-comet-evolve/SKILL.md +1 -0
- package/.flow-comet/skills/flow-comet-execute/SKILL.md +42 -15
- package/.flow-comet/skills/flow-comet-health/SKILL.md +1 -1
- package/.flow-comet/skills/flow-comet-integration/SKILL.md +1 -1
- package/.flow-comet/skills/flow-comet-open/GUIDANCE.md +14 -4
- package/.flow-comet/skills/flow-comet-open/SKILL.md +11 -9
- package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +13 -3
- package/.flow-comet/skills/flow-comet-plan/SKILL.md +21 -10
- package/.flow-comet/skills/flow-comet-requirement/SKILL.md +1 -1
- package/.flow-comet/skills/flow-comet-review/SKILL.md +33 -18
- package/.flow-comet/skills/flow-comet-subagent-execute/GUIDANCE.md +13 -3
- package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +44 -16
- package/.flow-comet/skills/flow-comet-task/SKILL.md +3 -2
- package/.flow-comet/skills/flow-comet-test/SKILL.md +6 -2
- package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +2 -2
- package/.flow-comet/skills/flow-comet-verify/SKILL.md +12 -8
- package/README.md +3 -3
- package/package.json +1 -1
- package/scripts/dsh-bridge.mjs +2 -2
- package/scripts/lib/installer-flowkit.mjs +43 -3
|
@@ -3,18 +3,23 @@
|
|
|
3
3
|
// 组界:场景序列按组文件规模上限连续分区——本文件先承载 D 组场景、后承载 E 组头部两项(154 · 155);
|
|
4
4
|
// 分区只搬文件,场景名/内容与其在入口 `SCENARIOS` 里的拼接顺序均不变。
|
|
5
5
|
|
|
6
|
+
import { spawnSync } from 'child_process';
|
|
6
7
|
import fs from 'fs';
|
|
7
8
|
import path from 'path';
|
|
9
|
+
import { pathToFileURL } from 'url';
|
|
8
10
|
import {
|
|
9
11
|
assertExit,
|
|
10
12
|
assertNotOut,
|
|
11
13
|
assertOut,
|
|
14
|
+
assertTrue,
|
|
12
15
|
baseState,
|
|
16
|
+
runGuard,
|
|
13
17
|
runHandoff,
|
|
14
18
|
writeFile,
|
|
15
19
|
writeState,
|
|
16
20
|
} from '../lib/test-helpers.mjs';
|
|
17
21
|
import {
|
|
22
|
+
CHANGE_ID,
|
|
18
23
|
PREPARE_ENV,
|
|
19
24
|
SCRIPTS_DIR,
|
|
20
25
|
TASK_DEP_CYCLE,
|
|
@@ -23,17 +28,155 @@ import {
|
|
|
23
28
|
TASK_MIXED_SPS,
|
|
24
29
|
TASK_VALID_ALL_PARALLEL,
|
|
25
30
|
dropNamedImport,
|
|
31
|
+
engineCodeText,
|
|
26
32
|
engineConsumersOf,
|
|
27
33
|
engineDefinitionHits,
|
|
28
34
|
engineDefinitionModule,
|
|
29
35
|
engineScriptTexts,
|
|
36
|
+
makeTmp,
|
|
30
37
|
renderMultiWaveTasks,
|
|
31
38
|
runPlanExit,
|
|
32
39
|
runPrepareEnv,
|
|
40
|
+
writeNodeDeclarationMarkers,
|
|
33
41
|
} from '../lib/test-fixtures.mjs';
|
|
34
|
-
import {
|
|
42
|
+
import {
|
|
43
|
+
REPLAN_STALE_SIGNATURE,
|
|
44
|
+
assertStateBytesUnchanged,
|
|
45
|
+
readStateBytes,
|
|
46
|
+
replanBackupFiles,
|
|
47
|
+
replanExecuteState,
|
|
48
|
+
runStateWithProtocol,
|
|
49
|
+
} from '../lib/test-assertions.mjs';
|
|
35
50
|
import { singleSourceImportProblems } from '../lib/text-anchor-checks.mjs';
|
|
36
51
|
|
|
52
|
+
// ---------- 波次投影族夹具(plan 出口:波次 = 依赖层级的投影) ----------
|
|
53
|
+
// 匿名化同形夹具(中性任务 id / 中性路径),与真实计划同形不同内容:真实计划只作一次性验收载体,
|
|
54
|
+
// 不进套件夹具、也不随包分发。任务块的 parallel="true" 与散文的 [P] 标记保持一致——否则先被既有的
|
|
55
|
+
// 「波次散文一致性」判据拦下,测不到波次投影本身。
|
|
56
|
+
// options.parallel=false 时**不写开标签属性**(「未标 parallel」的真实形态——写 parallel="false"
|
|
57
|
+
// 也是同一个判定结果,但夹具要表达的是「没声明」);options.write 覆盖写面路径(构造「写面重叠」对)。
|
|
58
|
+
const waveTask = (id, deps = '', { parallel = true, write } = {}) => {
|
|
59
|
+
const writePath = write ?? 'src/' + id.toLowerCase() + '.mjs';
|
|
60
|
+
return '<task id="' + id + '"' + (parallel ? ' parallel="true"' : '') + ' status="pending"><action>实现 ' + id
|
|
61
|
+
+ '</action><write_files>' + writePath + '</write_files><verify>node --check ' + writePath
|
|
62
|
+
+ '</verify><depends_on>' + deps + '</depends_on></task>\n';
|
|
63
|
+
};
|
|
64
|
+
|
|
65
|
+
// 波次段 + 任务清单的最小 TASK.md。Wave 行的注解形态刻意取真实工件的写法((parallel) 标注、
|
|
66
|
+
// 括号依赖注解、行尾 # 注释、[P] 标记)——解析面必须容忍它们,且不把注解里的 id 算成本波成员。
|
|
67
|
+
const waveMarkdown = (waveLines, tasks) => '# TASK\n\n## 波次划分\n\n```\n' + waveLines
|
|
68
|
+
+ '\n```\n\n## 任务清单\n\n' + tasks;
|
|
69
|
+
|
|
70
|
+
// 写 TASK.md → entry plan(走完整入口记录)→ exit plan;返回 exit 结果。
|
|
71
|
+
const runPlanWithTask = (dir, markdown) => {
|
|
72
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', markdown);
|
|
73
|
+
assertExit(runGuard(['entry', 'plan'], dir), 0);
|
|
74
|
+
// 新 change 的声明标记(真实流程里由协调者 / record 写;夹具直接写 state 时补同一份事实)
|
|
75
|
+
writeNodeDeclarationMarkers(dir, 'plan');
|
|
76
|
+
return runGuard(['exit', 'plan'], dir);
|
|
77
|
+
};
|
|
78
|
+
|
|
79
|
+
// 同一判据的三种形态(单变量构造:只有波次声明 / 依赖变化):
|
|
80
|
+
// ① 诚实——同波任务彼此无依赖,每波 = 依赖层级(无依赖第 1 波,其余 = 1 + 依赖中最晚波次);
|
|
81
|
+
// ② 同波依赖——T02 依赖 T01 却与它同写第 2 波(被依赖的 T01 层级为 1,无法与依赖方同波);
|
|
82
|
+
// ③ 排得保守——T02 无依赖(层级为 1)却排到第 3 波(排得比依赖允许的更靠后,浪费并行效率)。
|
|
83
|
+
const honestWavePlan = () => waveMarkdown(
|
|
84
|
+
'Wave 1 (parallel): T01[P], T02[P]\nWave 2 (parallel): T03[P] (depends on T01, T02)\nWave 3: T04 (depends on T03) # 收尾',
|
|
85
|
+
waveTask('T01') + waveTask('T02') + waveTask('T03', 'T01,T02') + waveTask('T04', 'T03'));
|
|
86
|
+
const sameWavePlan = () => waveMarkdown(
|
|
87
|
+
'Wave 2 (parallel): T01[P], T02 (T02 on T01)',
|
|
88
|
+
waveTask('T01') + waveTask('T02', 'T01'));
|
|
89
|
+
const conservativeWavePlan = () => waveMarkdown(
|
|
90
|
+
'Wave 1: T01\nWave 3: T02 # 无依赖却排到第三波',
|
|
91
|
+
waveTask('T01') + waveTask('T02'));
|
|
92
|
+
// 修正后:T01 回到第 1 波、T02 排到第 2 波并显式依赖 T01(恢复指引的两条出路都落到这份夹具上)。
|
|
93
|
+
const fixedWavePlan = () => waveMarkdown(
|
|
94
|
+
'Wave 1 (parallel): T01[P]\nWave 2: T02 (depends on T01)',
|
|
95
|
+
waveTask('T01') + waveTask('T02', 'T01'));
|
|
96
|
+
|
|
97
|
+
// 未声明任务:Wave 行只写 T01,而任务集里还有 T02(依赖 T01)与 T03(依赖 T02)——这是「真任务集
|
|
98
|
+
// 减去 Wave 声明集」的差集,此前完全不进判定(判据只沿「已声明」一侧求差),于是 exit 0 且零输出。
|
|
99
|
+
const undeclaredWavePlan = () => waveMarkdown(
|
|
100
|
+
'Wave 1 (parallel): T01[P]',
|
|
101
|
+
waveTask('T01') + waveTask('T02', 'T01') + waveTask('T03', 'T02'));
|
|
102
|
+
|
|
103
|
+
// 修复族任务不在波次声明的义务面内:带修复族前缀 id 的任务、以及位于「Fix 任务」段内的任务
|
|
104
|
+
// (R01),两者都不写进 Wave 行,判据仍须放行——族判定一律经 task-graph 的唯一谓词,判据侧
|
|
105
|
+
// 不自写前缀匹配。
|
|
106
|
+
const fixFamilyWavePlan = () => waveMarkdown(
|
|
107
|
+
'Wave 1 (parallel): T01[P]\nWave 2: T02 (depends on T01)',
|
|
108
|
+
waveTask('T01') + waveTask('T02', 'T01')
|
|
109
|
+
+ '<task id="T-FIX-01" status="pending"><action>回修前缀形态</action>'
|
|
110
|
+
+ '<write_files>src/fix1.mjs</write_files><verify>node --check src/fix1.mjs</verify>'
|
|
111
|
+
+ '<depends_on></depends_on></task>\n'
|
|
112
|
+
+ '\n## Fix 任务(来自 REVIEW / INTEGRATION)\n\n'
|
|
113
|
+
+ '<task id="R01" status="pending"><action>回修段内形态</action>'
|
|
114
|
+
+ '<write_files>src/fix2.mjs</write_files><verify>node --check src/fix2.mjs</verify>'
|
|
115
|
+
+ '<depends_on></depends_on></task>\n');
|
|
116
|
+
|
|
117
|
+
// 全角与半角是同一份错误计划的两种写法(唯一变量 = 标点):同一明细、同一分级。漏收全角逗号时,
|
|
118
|
+
// 中文写法解析不出任务 id ⇒ 降级成「未校验」放行(实测 Wave 1:T01,T02 → exit 0 + ALL CHECKS PASSED)。
|
|
119
|
+
const fullWidthSameWavePlan = () => waveMarkdown(
|
|
120
|
+
'Wave 2(parallel):T01[P],T02 (T02 on T01)',
|
|
121
|
+
waveTask('T01') + waveTask('T02', 'T01'));
|
|
122
|
+
|
|
123
|
+
// 波次段正文(段在场、正文不可判):段标题在场而判据拿不到任何可对应任务的 Wave 行——三种真实
|
|
124
|
+
// 糊弄形态是同一成因的三个入口(纯 N/A 声明 / 点到不存在的任务 id / 行首带 Markdown 强调记号)。
|
|
125
|
+
const waveBodyPlan = (body, tasks) => '# TASK\n\n## 波次划分\n\n' + body + '\n\n## 任务清单\n\n' + tasks;
|
|
126
|
+
const naWavePlan = () => waveBodyPlan('N/A(本计划不使用波次划分)', waveTask('T01') + waveTask('T02', 'T01'));
|
|
127
|
+
const phantomWavePlan = () => waveBodyPlan('```\nWave 1: T99\n```', waveTask('T01'));
|
|
128
|
+
const boldWavePlan = () => waveBodyPlan('```\n**Wave 1**: T01\n```', waveTask('T01'));
|
|
129
|
+
|
|
130
|
+
// 同波可并行却漏标 [P](波次判据之后的第二条波次面判据):Wave 1 里的 T01 与 T02 彼此无依赖、
|
|
131
|
+
// write_files 不重叠(本可并行),而只有 T01 标了 parallel="true"。单变量 = T02 的 parallel 标记
|
|
132
|
+
// (markAll)——判据该报的正是「本可并行却谁都没说」这一形态。「写面不重叠」的判定入口是
|
|
133
|
+
// task-graph 的 collectCrossTaskConflicts(其返回集合的补集,见 wave-projection 的判据注释)。
|
|
134
|
+
const parallelGapPlan = ({ markAll = false } = {}) => waveMarkdown(
|
|
135
|
+
'Wave 1 (parallel): T01[P], T02',
|
|
136
|
+
waveTask('T01') + waveTask('T02', '', { parallel: markAll }));
|
|
137
|
+
// 第二条出路:补一条 depends_on 把两者排到不同波次(T02 进第 2 波,标记仍是串行)。
|
|
138
|
+
const parallelGapDependPlan = () => waveMarkdown(
|
|
139
|
+
'Wave 1 (parallel): T01[P]\nWave 2: T02 (depends on T01)',
|
|
140
|
+
waveTask('T01') + waveTask('T02', 'T01', { parallel: false }));
|
|
141
|
+
// 修复族不参与:同波四只修复任务(两只族前缀 + 两只修复段内)都没标 parallel、写面互不重叠——
|
|
142
|
+
// 族判定经 task-graph 的唯一谓词,判据不得在这里另立一套边界。
|
|
143
|
+
const fixPairWavePlan = () => waveMarkdown(
|
|
144
|
+
'Wave 1: T-FIX-01, T-FIX-02, R01, R02',
|
|
145
|
+
waveTask('T-FIX-01', '', { parallel: false }) + waveTask('T-FIX-02', '', { parallel: false })
|
|
146
|
+
+ '\n## Fix 任务(来自 REVIEW / INTEGRATION)\n\n'
|
|
147
|
+
+ waveTask('R01', '', { parallel: false }) + waveTask('R02', '', { parallel: false }));
|
|
148
|
+
// 写面重叠的一对不是「可并行」:同波同层、都没标 parallel,但写同一个文件——写冲突族另有判据,
|
|
149
|
+
// 本判据不得在同一对上加一条「可并行」的错话(重叠判定退化为「一律不重叠」时这里会多一条报文)。
|
|
150
|
+
const overlapPairWavePlan = () => waveMarkdown(
|
|
151
|
+
'Wave 1: T01, T02',
|
|
152
|
+
waveTask('T01', '', { parallel: false, write: 'src/shared.mjs' })
|
|
153
|
+
+ waveTask('T02', '', { parallel: false, write: 'src/shared.mjs' }));
|
|
154
|
+
|
|
155
|
+
// 报告明细行(同一报文构造的逐条投影):只取报文里的「 - 」行,用于比较两种标点写法的判定是否一致。
|
|
156
|
+
const waveDetailLines = (res) => res.output.split(/\r?\n/u).filter((line) => line.startsWith(' - ')).sort();
|
|
157
|
+
|
|
158
|
+
// 波次报文段(plan 出口与 replan 重校的逐字对账用):明细标题行 → 恢复行。两处共用同一构造函数,
|
|
159
|
+
// 任一处自建报文(或分级规则只改一处)即在此判红。
|
|
160
|
+
const waveReportLines = (res) => {
|
|
161
|
+
const lines = res.output.split(/\r?\n/u);
|
|
162
|
+
const start = lines.findIndex((line) => line.includes('波次划分与依赖层级不一致'));
|
|
163
|
+
const end = lines.findIndex((line) => line.startsWith('恢复: 按明细逐项修正'));
|
|
164
|
+
return start < 0 || end < start ? [] : lines.slice(start, end + 1);
|
|
165
|
+
};
|
|
166
|
+
const waveGapReportLines = (res) => {
|
|
167
|
+
const lines = res.output.split(/\r?\n/u);
|
|
168
|
+
const start = lines.findIndex((line) => line.includes('同波任务可并行却未标 [P]'));
|
|
169
|
+
const end = lines.findIndex((line) => line.startsWith('恢复: 两条出路任选'));
|
|
170
|
+
return start < 0 || end < start ? [] : lines.slice(start, end + 1);
|
|
171
|
+
};
|
|
172
|
+
const waveUnjudgeableLines = (res) => {
|
|
173
|
+
const lines = res.output.split(/\r?\n/u);
|
|
174
|
+
const start = lines.findIndex((line) => line.includes('波次划分段内容不可判'));
|
|
175
|
+
if (start < 0) return [];
|
|
176
|
+
const next = lines[start + 1] ?? '';
|
|
177
|
+
return next.startsWith('恢复: ') ? [lines[start], next] : [lines[start]];
|
|
178
|
+
};
|
|
179
|
+
|
|
37
180
|
export const ENTRIES = [
|
|
38
181
|
|
|
39
182
|
// ---------- 场景(prepare-env 平台选择链——T01 实现:显式单平台/逗号多选/all/both 移除/痕迹探测/幂等) ----------
|
|
@@ -204,8 +347,8 @@ export const ENTRIES = [
|
|
|
204
347
|
// 145(多趟语义重写):新 change + 依赖环(P01↔P02 互为 depends_on)→ exit plan 应 BLOCKED,
|
|
205
348
|
// 输出含「依赖环」(拓扑排序判环)与「depends_on」恢复指引。旧引擎无波次校验静默放行 = 预期 RED。
|
|
206
349
|
{
|
|
207
|
-
name: '145 plan exit BLOCKED:新 change 依赖环(P01↔P02
|
|
208
|
-
run: (dir) => {
|
|
350
|
+
name: '145 plan exit BLOCKED:新 change 依赖环(P01↔P02 互为依赖)+ 波次投影三形态(同波依赖 / 排得保守 / 修正后通过)+ 同波漏标 [P] + replan 同源拒绝重签(含执行期删段被 TASK 段形门拦、旧 change 只 WARN)',
|
|
351
|
+
run: async (dir) => {
|
|
209
352
|
const st = baseState('plan');
|
|
210
353
|
st.evidence.plan = { summary: 'plan done' };
|
|
211
354
|
st.newChange = true;
|
|
@@ -215,6 +358,542 @@ export const ENTRIES = [
|
|
|
215
358
|
assertOut(res, 'BLOCKED');
|
|
216
359
|
assertOut(res, '依赖环');
|
|
217
360
|
assertOut(res, 'depends_on');
|
|
361
|
+
// ===== 波次投影(波次 = 依赖层级的投影)三形态:既有 plan 出口族原位扩展,不新增顶层场景 =====
|
|
362
|
+
// ② 同波依赖(Wave 2: T01[P], T02 且 T02 依赖 T01)⇒ 新 change BLOCK,明细逐条点名
|
|
363
|
+
// (被依赖的 T01 层级为 1,无法与依赖它的 T02 同波)。
|
|
364
|
+
const sameWaveBlocked = runPlanWithTask(dir, sameWavePlan());
|
|
365
|
+
assertExit(sameWaveBlocked, 1);
|
|
366
|
+
assertOut(sameWaveBlocked, '波次划分与依赖层级不一致');
|
|
367
|
+
assertOut(sameWaveBlocked, 'T01');
|
|
368
|
+
assertOut(sameWaveBlocked, '当前波 2');
|
|
369
|
+
assertOut(sameWaveBlocked, '应到波 1');
|
|
370
|
+
// 恢复指引的两条出路都必须可照抄(移到应到波 / 补 depends_on)
|
|
371
|
+
assertOut(sameWaveBlocked, '移到第 1 波');
|
|
372
|
+
assertOut(sameWaveBlocked, 'depends_on');
|
|
373
|
+
assertNotOut(sameWaveBlocked, '未校验(无波次段)');
|
|
374
|
+
// ③ 排得保守(T02 无依赖、只需第 1 波却排到第 3 波)⇒ 同样 BLOCK 且点名 T02——
|
|
375
|
+
// 只判「依赖不得倒挂」会放过这种浪费(作者要的是「不浪费效率」,两者都要判)。
|
|
376
|
+
const conservativeBlocked = runPlanWithTask(dir, conservativeWavePlan());
|
|
377
|
+
assertExit(conservativeBlocked, 1);
|
|
378
|
+
assertOut(conservativeBlocked, '波次划分与依赖层级不一致');
|
|
379
|
+
assertOut(conservativeBlocked, 'T02');
|
|
380
|
+
assertOut(conservativeBlocked, '当前波 3');
|
|
381
|
+
assertOut(conservativeBlocked, '应到波 1');
|
|
382
|
+
// ④ 修正后通过(T01 回第 1 波、T02 排第 2 波并显式依赖 T01):判据在场(不是跳过)且沉默。
|
|
383
|
+
const waveFixed = runPlanWithTask(dir, fixedWavePlan());
|
|
384
|
+
assertExit(waveFixed, 0);
|
|
385
|
+
assertOut(waveFixed, 'ALL CHECKS PASSED');
|
|
386
|
+
assertNotOut(waveFixed, '波次划分与依赖层级不一致');
|
|
387
|
+
assertNotOut(waveFixed, '未校验(无波次段)');
|
|
388
|
+
// ⑤ 未声明任务(Wave 行只写 T01,任务另有 T02←T01、T03←T02):新 change 必须 BLOCK,并在
|
|
389
|
+
// 明细里点名「哪些任务没有被波次覆盖」——取值形态沿用同一报文:当前波 = 未声明。
|
|
390
|
+
const undeclaredBlocked = runPlanWithTask(dir, undeclaredWavePlan());
|
|
391
|
+
assertExit(undeclaredBlocked, 1);
|
|
392
|
+
assertOut(undeclaredBlocked, '波次划分与依赖层级不一致');
|
|
393
|
+
assertOut(undeclaredBlocked, 'T02(依赖: T01)当前波 未声明 → 应到波 2');
|
|
394
|
+
assertOut(undeclaredBlocked, 'T03(依赖: T02)当前波 未声明 → 应到波 3');
|
|
395
|
+
assertOut(undeclaredBlocked, '写进第 2 波的 Wave 行');
|
|
396
|
+
// 已声明的 T01 不得被算成未声明(判据不是把所有任务一网打尽)
|
|
397
|
+
assertNotOut(undeclaredBlocked, 'T01(依赖: 无)当前波 未声明');
|
|
398
|
+
// ⑥ 修复族任务不被要求覆盖:族前缀形态的任务与修复段内的 R01 都不写进 Wave 行,判据照常
|
|
399
|
+
// 放行——族排除经 task-graph 的唯一谓词,判据侧没有第二套前缀匹配。
|
|
400
|
+
const fixFamilyPassed = runPlanWithTask(dir, fixFamilyWavePlan());
|
|
401
|
+
assertExit(fixFamilyPassed, 0);
|
|
402
|
+
assertOut(fixFamilyPassed, 'ALL CHECKS PASSED');
|
|
403
|
+
assertNotOut(fixFamilyPassed, '未声明');
|
|
404
|
+
assertNotOut(fixFamilyPassed, '波次划分与依赖层级不一致');
|
|
405
|
+
// ⑦ 全角 / 半角是同一份错误计划(唯一变量 = 标点):都 BLOCK 且明细逐条一致。半角侧复用 ② 的
|
|
406
|
+
// 结果,全角侧此前降级成「未校验」放行(分隔符漏收全角逗号)——这一格专锚该退化。
|
|
407
|
+
const fullWidthBlocked = runPlanWithTask(dir, fullWidthSameWavePlan());
|
|
408
|
+
assertExit(fullWidthBlocked, 1);
|
|
409
|
+
assertOut(fullWidthBlocked, '波次划分与依赖层级不一致');
|
|
410
|
+
assertNotOut(fullWidthBlocked, '未校验(无波次段)');
|
|
411
|
+
const halfDetails = waveDetailLines(sameWaveBlocked);
|
|
412
|
+
const fullDetails = waveDetailLines(fullWidthBlocked);
|
|
413
|
+
assertTrue(halfDetails.length > 0, '半角写法的波次明细为空(判据未生效): ' + sameWaveBlocked.output);
|
|
414
|
+
assertTrue(halfDetails.join('\n') === fullDetails.join('\n'),
|
|
415
|
+
'全角与半角的波次明细不一致(同一计划应同一判定): 半角=' + JSON.stringify(halfDetails)
|
|
416
|
+
+ ' 全角=' + JSON.stringify(fullDetails));
|
|
417
|
+
// ⑧ 段在场而内容不可判(N/A 声明 / 指向不存在的任务 id / 行首强调记号):新 change BLOCKED——
|
|
418
|
+
// 「判不了」不再等价于放行(未验证 ≠ 通过),且报文与「载体缺席」那一支明确不同。
|
|
419
|
+
const unjudgeablePlanResults = [];
|
|
420
|
+
for (const [label, plan] of [
|
|
421
|
+
['N/A 声明', naWavePlan()],
|
|
422
|
+
['指向不存在的任务 id', phantomWavePlan()],
|
|
423
|
+
['行首强调记号', boldWavePlan()],
|
|
424
|
+
]) {
|
|
425
|
+
const unjudgeable = runPlanWithTask(dir, plan);
|
|
426
|
+
unjudgeablePlanResults.push(unjudgeable);
|
|
427
|
+
try {
|
|
428
|
+
assertExit(unjudgeable, 1);
|
|
429
|
+
assertOut(unjudgeable, '波次划分段内容不可判');
|
|
430
|
+
// 恢复指引必须指出「N/A 不构成声明」这条真实可照抄的出路(不是只出现「恢复」二字的空句)
|
|
431
|
+
assertOut(unjudgeable, '段正文写 N/A 不构成波次声明');
|
|
432
|
+
assertNotOut(unjudgeable, '未校验(无波次段)');
|
|
433
|
+
assertNotOut(unjudgeable, '波次划分与依赖层级不一致');
|
|
434
|
+
} catch (error) {
|
|
435
|
+
throw new Error(label + ':' + error.message);
|
|
436
|
+
}
|
|
437
|
+
}
|
|
438
|
+
// ⑨ 同波可并行却漏标 [P](波次判据之后的第二条波次面判据):同一波次内彼此无依赖路径、
|
|
439
|
+
// write_files 不重叠的两个任务本可并行——只标一个 parallel="true" 不成立(单边标记既不
|
|
440
|
+
// 表达「可并行」,机器路由也只按串行跑、白丢一波并行度)。新 change BLOCKED 且逐对点名
|
|
441
|
+
// 「哪个任务没标」,并给两条可照抄的出路。
|
|
442
|
+
const gapBlocked = runPlanWithTask(dir, parallelGapPlan());
|
|
443
|
+
assertExit(gapBlocked, 1);
|
|
444
|
+
assertOut(gapBlocked, '同波任务可并行却未标 [P]');
|
|
445
|
+
assertOut(gapBlocked, 'T01 × T02');
|
|
446
|
+
assertOut(gapBlocked, '未标 parallel="true": T02');
|
|
447
|
+
// 两条出路都必须在报文里:① 两个都标 [P];② 补一条 depends_on 把它们排到不同波次
|
|
448
|
+
assertOut(gapBlocked, '都标 parallel="true"');
|
|
449
|
+
assertOut(gapBlocked, 'depends_on');
|
|
450
|
+
assertOut(gapBlocked, '不同波次');
|
|
451
|
+
// 出路①(唯一变量 = T02 的 parallel 标记)→ 判据沉默(不是「同波即报」)
|
|
452
|
+
const gapAllMarked = runPlanWithTask(dir, parallelGapPlan({ markAll: true }));
|
|
453
|
+
assertExit(gapAllMarked, 0);
|
|
454
|
+
assertNotOut(gapAllMarked, '可并行却未标 [P]');
|
|
455
|
+
// 出路②(补 depends_on 把 T02 排到第 2 波、标记仍是串行)→ 同样通过:两条出路都真能解掉判定
|
|
456
|
+
const gapDependFixed = runPlanWithTask(dir, parallelGapDependPlan());
|
|
457
|
+
assertExit(gapDependFixed, 0);
|
|
458
|
+
assertNotOut(gapDependFixed, '可并行却未标 [P]');
|
|
459
|
+
// 修复族不参与:同波四只修复任务(族前缀两只 + 修复段内两只)都没标 parallel、写面互不重叠,
|
|
460
|
+
// 判据不得报——族边界仍只在 task-graph 的唯一谓词里表达。
|
|
461
|
+
const gapFixFamily = runPlanWithTask(dir, fixPairWavePlan());
|
|
462
|
+
assertExit(gapFixFamily, 0);
|
|
463
|
+
assertNotOut(gapFixFamily, '可并行却未标 [P]');
|
|
464
|
+
// ===== replan 同源(AC-3 · ADR-013 不豁免):重校段调用同一判定、同一报文 =====
|
|
465
|
+
// 相位夹具 = execute 已 entry、前序完成、taskHash 过期(避开幂等空操作)。
|
|
466
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', sameWavePlan());
|
|
467
|
+
writeState(dir, replanExecuteState({ taskHash: REPLAN_STALE_SIGNATURE }));
|
|
468
|
+
const replanBytes = readStateBytes(dir);
|
|
469
|
+
const replanBlocked = runStateWithProtocol(dir, ['replan', '计划缺陷重校', '--authorized-by', 'user-approval']);
|
|
470
|
+
assertExit(replanBlocked, 1);
|
|
471
|
+
// 与 plan 出口同一判据同一措辞(同一个报文构造函数)
|
|
472
|
+
assertOut(replanBlocked, '波次划分与依赖层级不一致');
|
|
473
|
+
assertOut(replanBlocked, 'T01');
|
|
474
|
+
assertOut(replanBlocked, '当前波 2');
|
|
475
|
+
assertOut(replanBlocked, '应到波 1');
|
|
476
|
+
// ⑩ 分级 → 输出单源:两处只派生 blocking,报文段逐字相同(各写一份同构分支时,改分级只改
|
|
477
|
+
// 一处就会在另一处静默落后——反向构造:把分级规则只改一处,本节两处对账必红)。
|
|
478
|
+
const planWaveReport = waveReportLines(sameWaveBlocked);
|
|
479
|
+
const replanWaveReport = waveReportLines(replanBlocked);
|
|
480
|
+
assertTrue(planWaveReport.length > 0,
|
|
481
|
+
'plan 出口的波次报文段未取到(恢复行缺失?): ' + sameWaveBlocked.output);
|
|
482
|
+
assertTrue(planWaveReport.join('\n') === replanWaveReport.join('\n'),
|
|
483
|
+
'plan 出口与 replan 重校的波次报文不逐字相同:\nplan=' + JSON.stringify(planWaveReport)
|
|
484
|
+
+ '\nreplan=' + JSON.stringify(replanWaveReport));
|
|
485
|
+
// 拒绝重签:状态零改写,且重签前备份尚未产生(重校全部先于写盘)
|
|
486
|
+
assertStateBytesUnchanged(dir, replanBytes, 'replan 波次投影 BLOCK');
|
|
487
|
+
if (replanBackupFiles(dir).length !== 0) {
|
|
488
|
+
throw new Error('replan 波次投影 BLOCK 路径不得产生重签前备份,实际 ' + replanBackupFiles(dir).length + ' 份');
|
|
489
|
+
}
|
|
490
|
+
// ⑪ 同波漏标 [P] 同样不豁免(ADR-013):执行期重签不得把「本可并行却没标」的计划换一份发
|
|
491
|
+
// 出去;两处分级与措辞同源(同一构造),故报文段逐字相同。
|
|
492
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', parallelGapPlan());
|
|
493
|
+
const replanGap = runStateWithProtocol(dir, ['replan', '同波漏标的计划重校', '--authorized-by', 'user-approval']);
|
|
494
|
+
assertExit(replanGap, 1);
|
|
495
|
+
assertOut(replanGap, '同波任务可并行却未标 [P]');
|
|
496
|
+
assertOut(replanGap, 'T01 × T02');
|
|
497
|
+
const planGapReport = waveGapReportLines(gapBlocked);
|
|
498
|
+
const replanGapReport = waveGapReportLines(replanGap);
|
|
499
|
+
assertTrue(planGapReport.length > 0, 'plan 出口的同波漏标报文未取到: ' + gapBlocked.output);
|
|
500
|
+
assertTrue(planGapReport.join('\n') === replanGapReport.join('\n'),
|
|
501
|
+
'同波漏标两支的措辞不逐字相同:\nplan=' + JSON.stringify(planGapReport)
|
|
502
|
+
+ '\nreplan=' + JSON.stringify(replanGapReport));
|
|
503
|
+
assertStateBytesUnchanged(dir, replanBytes, 'replan 同波漏标 BLOCK');
|
|
504
|
+
// 未声明任务同样不豁免(ADR-013:改散文绕不过判据):重校段必须点名未被波次覆盖的任务。
|
|
505
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', undeclaredWavePlan());
|
|
506
|
+
const replanUndeclared = runStateWithProtocol(dir, ['replan', '未声明任务的计划重校', '--authorized-by', 'user-approval']);
|
|
507
|
+
assertExit(replanUndeclared, 1);
|
|
508
|
+
assertOut(replanUndeclared, '波次划分与依赖层级不一致');
|
|
509
|
+
assertOut(replanUndeclared, 'T02(依赖: T01)当前波 未声明 → 应到波 2');
|
|
510
|
+
assertStateBytesUnchanged(dir, replanBytes, 'replan 未声明任务 BLOCK');
|
|
511
|
+
// ⑪ 内容不可判那一支同样两处逐字相同(同一构造函数的第二条分级路径,只换分级前缀)
|
|
512
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', naWavePlan());
|
|
513
|
+
const replanUnjudgeable = runStateWithProtocol(dir, ['replan', '内容不可判的计划重校', '--authorized-by', 'user-approval']);
|
|
514
|
+
assertExit(replanUnjudgeable, 1);
|
|
515
|
+
assertOut(replanUnjudgeable, '波次划分段内容不可判');
|
|
516
|
+
const planUnjudgeableReport = waveUnjudgeableLines(unjudgeablePlanResults[0]);
|
|
517
|
+
const replanUnjudgeableReport = waveUnjudgeableLines(replanUnjudgeable);
|
|
518
|
+
assertTrue(planUnjudgeableReport.length > 0, 'plan 出口的内容不可判报文未取到: ' + unjudgeablePlanResults[0].output);
|
|
519
|
+
assertTrue(planUnjudgeableReport.join('\n') === replanUnjudgeableReport.join('\n'),
|
|
520
|
+
'内容不可判两支的措辞不逐字相同:\nplan=' + JSON.stringify(planUnjudgeableReport)
|
|
521
|
+
+ '\nreplan=' + JSON.stringify(replanUnjudgeableReport));
|
|
522
|
+
assertStateBytesUnchanged(dir, replanBytes, 'replan 内容不可判 BLOCK');
|
|
523
|
+
// 改到一致后重签成功(判据不阻断合规计划)
|
|
524
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', fixedWavePlan());
|
|
525
|
+
const replanFixed = runStateWithProtocol(dir, ['replan', '按波次投影修正后重校', '--authorized-by', 'user-approval']);
|
|
526
|
+
assertExit(replanFixed, 0);
|
|
527
|
+
assertOut(replanFixed, 'REPLAN: execute');
|
|
528
|
+
// ⑪b 前置同源(P2b):执行期**删掉承载段**(## 波次划分)再改任务集 —— 重校段不得走「未校验」
|
|
529
|
+
// 放行口。TASK.md 的段形由模板权威裁定,plan 出口已经用同一份骨架门拦过缺段,重校段不豁免:
|
|
530
|
+
// 新 change BLOCKED,state 字节零改写、零新增备份(判据全部先于备份与写盘)。
|
|
531
|
+
// 模板在场才判段形:模板缺席是「未校验(模板缺失)」的另一支边界(与 plan 出口同一口径),
|
|
532
|
+
// 故本块显式写出 TASK 模板,让「删段」成为唯一的变量。
|
|
533
|
+
writeFile(dir, 'flow-kit/templates/TASK.md',
|
|
534
|
+
'# TASK: <change 标题>\n\n## 波次划分\n\n## 任务清单\n');
|
|
535
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', '# TASK\n\n## 任务清单\n\n' + waveTask('T01'));
|
|
536
|
+
const noWaveSectionBytes = readStateBytes(dir);
|
|
537
|
+
const backupsBeforeNoWave = replanBackupFiles(dir).length;
|
|
538
|
+
const replanNoWaveSection = runStateWithProtocol(dir, ['replan', '删段 + 改任务集的重校', '--authorized-by', 'user-approval']);
|
|
539
|
+
assertExit(replanNoWaveSection, 1);
|
|
540
|
+
assertOut(replanNoWaveSection, 'BLOCKED: TASK.md 模板结构校验失败');
|
|
541
|
+
assertOut(replanNoWaveSection, '波次划分');
|
|
542
|
+
assertOut(replanNoWaveSection, '(模板: flow-kit/templates/TASK.md)');
|
|
543
|
+
assertOut(replanNoWaveSection, '重试 replan');
|
|
544
|
+
assertNotOut(replanNoWaveSection, 'REPLAN:');
|
|
545
|
+
assertStateBytesUnchanged(dir, noWaveSectionBytes, 'replan 承载段缺席 BLOCK');
|
|
546
|
+
assertTrue(replanBackupFiles(dir).length === backupsBeforeNoWave,
|
|
547
|
+
'承载段缺席 BLOCK 不得新增重签前备份: ' + JSON.stringify(replanBackupFiles(dir)));
|
|
548
|
+
// 分级二分(旧 change):同一份删段任务集只 WARN 不阻断——判据在场(不是「旧 change 就跳过」),
|
|
549
|
+
// 只是照常重签并产生备份。与上面那格共用同一夹具,唯一变量 = 有无 newChange 标记。
|
|
550
|
+
const oldNoWaveState = replanExecuteState({ taskHash: REPLAN_STALE_SIGNATURE });
|
|
551
|
+
delete oldNoWaveState.newChange;
|
|
552
|
+
writeState(dir, oldNoWaveState);
|
|
553
|
+
const backupsBeforeOldWarn = replanBackupFiles(dir).length;
|
|
554
|
+
const replanNoWaveOld = runStateWithProtocol(dir, ['replan', '删段 + 改任务集的重校(旧 change)', '--authorized-by', 'user-approval']);
|
|
555
|
+
assertExit(replanNoWaveOld, 0);
|
|
556
|
+
assertOut(replanNoWaveOld, 'TEMPLATE-STRUCTURE WARN: TASK.md 模板结构校验失败');
|
|
557
|
+
assertOut(replanNoWaveOld, '波次划分');
|
|
558
|
+
assertOut(replanNoWaveOld, '(旧 change 渐进,不阻断;新 change 将强制)');
|
|
559
|
+
assertNotOut(replanNoWaveOld, 'BLOCKED:');
|
|
560
|
+
assertOut(replanNoWaveOld, 'REPLAN: execute');
|
|
561
|
+
assertTrue(replanBackupFiles(dir).length === backupsBeforeOldWarn + 1,
|
|
562
|
+
'旧 change 的段形 WARN 不应阻断重签(应新增 1 份备份): ' + JSON.stringify(replanBackupFiles(dir)));
|
|
563
|
+
// 两处措辞同源(plan 出口 / 重校段):同一份 TASK.md(模板在场、承载段缺席)必须给出**逐字相同**
|
|
564
|
+
// 的失败行——骨架取模板权威、片段取 guard-template-fidelity 的同一格式器、两阶段口径不变
|
|
565
|
+
// (escalate=false:首次只给类别计数)。现场适配只落在恢复行:replan 在那里点名缺的段(重校段
|
|
566
|
+
// 没有提示账本可「再犯升级」)、并把重试目标换成本命令。
|
|
567
|
+
// 反向构造:任一处自建段名清单或自拼措辞,这两行就不再相等。
|
|
568
|
+
const taskStructureLine = (res) => (res.output.match(/TASK\.md 模板结构校验失败[^\n]*/u) ?? [''])[0];
|
|
569
|
+
assertTrue(taskStructureLine(replanNoWaveSection).includes('缺段 1 项'),
|
|
570
|
+
'replan 的 TASK 段形失败行应报类别计数(与 plan 出口同一两阶段口径):\n' + replanNoWaveSection.output);
|
|
571
|
+
const planNoWaveState = baseState('plan');
|
|
572
|
+
planNoWaveState.evidence.plan = { summary: 'plan done' };
|
|
573
|
+
planNoWaveState.newChange = true;
|
|
574
|
+
writeState(dir, planNoWaveState);
|
|
575
|
+
const planNoWaveSection = runPlanWithTask(dir, '# TASK\n\n## 任务清单\n\n' + waveTask('T01'));
|
|
576
|
+
assertExit(planNoWaveSection, 1);
|
|
577
|
+
assertTrue(taskStructureLine(planNoWaveSection) === taskStructureLine(replanNoWaveSection),
|
|
578
|
+
'plan 出口与 replan 的 TASK 段形失败行不逐字相同:\nplan='
|
|
579
|
+
+ JSON.stringify(taskStructureLine(planNoWaveSection)) + '\nreplan='
|
|
580
|
+
+ JSON.stringify(taskStructureLine(replanNoWaveSection)));
|
|
581
|
+
assertOut(planNoWaveSection, '(模板: flow-kit/templates/TASK.md)');
|
|
582
|
+
// 反向构造(唯一变量 = 承载段是否在场):补回 ## 波次划分 后同一通道照常重签
|
|
583
|
+
writeFile(dir, '.specs/' + CHANGE_ID + '/TASK.md', honestWavePlan());
|
|
584
|
+
writeState(dir, replanExecuteState({ taskHash: REPLAN_STALE_SIGNATURE }));
|
|
585
|
+
const replanWithWaveSection = runStateWithProtocol(dir, ['replan', '补回承载段后的重校', '--authorized-by', 'user-approval']);
|
|
586
|
+
assertExit(replanWithWaveSection, 0);
|
|
587
|
+
assertOut(replanWithWaveSection, 'REPLAN: execute');
|
|
588
|
+
fs.rmSync(path.join(dir, 'flow-kit', 'templates', 'TASK.md'), { force: true });
|
|
589
|
+
|
|
590
|
+
// ===== ⑫ 「判不了」形态统一 + 分级→输出单源(两条判据共用一处契约)=====
|
|
591
|
+
// ① 源码契约锁:两条结构判据的「判不了」载荷键同形(载体缺席 { reason, notice } / 内容不可判
|
|
592
|
+
// { reason, explanation, recovery }),旧的「judgeable + reason 混装」形态在判据与两个调用方
|
|
593
|
+
// 身上零残留——形态只在源码里表达,靠注释互指同源不算同步机制。
|
|
594
|
+
const judgeTexts = engineScriptTexts();
|
|
595
|
+
const judgeCode = (rel) => engineCodeText(judgeTexts.get(rel) ?? '');
|
|
596
|
+
for (const rel of ['lib/wave-projection.mjs', 'lib/ac-coverage.mjs']) {
|
|
597
|
+
const code = judgeCode(rel);
|
|
598
|
+
const missingKeys = ['unverified:', 'unjudgeable:', 'notice', 'explanation', 'recovery']
|
|
599
|
+
.filter((token) => !code.includes(token));
|
|
600
|
+
assertTrue(missingKeys.length === 0,
|
|
601
|
+
rel + ' 缺「判不了」载荷键(形态应与另一条判据同形): ' + missingKeys.join('、'));
|
|
602
|
+
}
|
|
603
|
+
for (const rel of ['lib/wave-projection.mjs', 'lib/ac-coverage.mjs', 'lib/guard-gates.mjs', 'lib/state-commands-recovery.mjs']) {
|
|
604
|
+
assertTrue(!/\bjudgeable\b/u.test(judgeCode(rel)),
|
|
605
|
+
rel + ' 仍在使用旧形态字段 judgeable(「判不了」只许一种形态)');
|
|
606
|
+
}
|
|
607
|
+
// ② 分级 → 输出单源:两个波次调用方只派生 blocking 并经 waveReviewOutcome 分派,不再各自
|
|
608
|
+
// 构造波次报文(两处各写一份同构分支,改分级只改一处就会在另一处静默落后)。
|
|
609
|
+
for (const rel of ['lib/guard-gates.mjs', 'lib/state-commands-recovery.mjs']) {
|
|
610
|
+
const code = judgeCode(rel);
|
|
611
|
+
for (const entry of ['waveReviewOutcome', 'parallelGapOutcome']) {
|
|
612
|
+
assertTrue(code.includes(entry), rel + ' 未经由 ' + entry + ' 分派(分级→输出应单源)');
|
|
613
|
+
}
|
|
614
|
+
for (const retired of ['waveProjectionReportLines', 'waveContentUnjudgeableLine', 'WAVE_UNCHECKED_NOTICE']) {
|
|
615
|
+
assertTrue(!code.includes(retired),
|
|
616
|
+
rel + ' 仍直接消费报文构造函数 ' + retired + '(应统一经 waveReviewOutcome)');
|
|
617
|
+
}
|
|
618
|
+
}
|
|
619
|
+
// ③ 运行期形态对账:两条判据各自产出一条「内容不可判」结果,字段与载荷键必须完全同形
|
|
620
|
+
// (波次侧 = 段在场而读不出声明;AC 侧 = `REQUIREMENT.md` 缺席——「删掉承载文件」按内容
|
|
621
|
+
// 不可判处置,删除因此不是跳过口,两侧这一支吃的是同一份工件;载荷键由 ① 的源码契约锁住)。
|
|
622
|
+
const waveModule = await import(pathToFileURL(path.join(SCRIPTS_DIR, 'lib', 'wave-projection.mjs')).href);
|
|
623
|
+
const acModule = await import(pathToFileURL(path.join(SCRIPTS_DIR, 'lib', 'ac-coverage.mjs')).href);
|
|
624
|
+
const judgeShape = (outcome) => JSON.stringify({
|
|
625
|
+
fields: ['unverified', 'unjudgeable'].filter((field) => field in outcome),
|
|
626
|
+
unverified: outcome.unverified === null ? null : Object.keys(outcome.unverified).sort(),
|
|
627
|
+
unjudgeable: outcome.unjudgeable === null ? null : Object.keys(outcome.unjudgeable).sort(),
|
|
628
|
+
});
|
|
629
|
+
const waveCarrier = waveModule.waveProjectionReview({ taskContent: '# TASK\n\n## 任务清单\n\n' + waveTask('T01') });
|
|
630
|
+
const waveContent = waveModule.waveProjectionReview({ taskContent: naWavePlan() });
|
|
631
|
+
const acContent = await acModule.acCoverageReview(path.join(dir, '.specs', CHANGE_ID));
|
|
632
|
+
assertTrue(judgeShape(waveContent) === judgeShape(acContent),
|
|
633
|
+
'波次判据与 AC 覆盖的「内容不可判」形态不一致: 波次=' + judgeShape(waveContent) + ' AC=' + judgeShape(acContent));
|
|
634
|
+
assertTrue(waveContent.unverified === null && waveContent.unjudgeable !== null,
|
|
635
|
+
'内容不可判应只填 unjudgeable(另一支必须为空): ' + judgeShape(waveContent));
|
|
636
|
+
assertTrue(JSON.stringify(Object.keys(waveContent.unjudgeable).sort())
|
|
637
|
+
=== JSON.stringify(['explanation', 'reason', 'recovery']),
|
|
638
|
+
'内容不可判的载荷键应与 AC 覆盖同形(reason / explanation / recovery): '
|
|
639
|
+
+ JSON.stringify(Object.keys(waveContent.unjudgeable)));
|
|
640
|
+
// ④ 「未校验」那一支的载荷键按 AC 侧判——断言的是键集合本身,不是形状说明。这一支的成因只有
|
|
641
|
+
// 「模板缺席」,而模板根在进程启动时就绑定到运行上下文(`FLOW_COMET_RUN_ROOT` / cwd):
|
|
642
|
+
// 本套件进程的根里模板是在场的,所以进程内造不出「模板缺席」。夹具给一份**没有
|
|
643
|
+
// `flow-kit/templates`** 的项目根,子进程以它为运行上下文叫同一个判定,把载荷原样交回来
|
|
644
|
+
// (子进程而不是 chdir:运行上下文是模块加载时算出来的常量,改不动也改不干净)。
|
|
645
|
+
// 载体文件仍在场——AC 侧的「未校验」要求先过「载体在不在」这一关,缺文件是内容不可判。
|
|
646
|
+
const noTemplateRoot = makeTmp();
|
|
647
|
+
writeFile(noTemplateRoot, '.specs/' + CHANGE_ID + '/REQUIREMENT.md',
|
|
648
|
+
'# REQUIREMENT\n\n## 验收准则(AC)\n\n- AC-1 模板缺席时仍在场上的载体\n');
|
|
649
|
+
const acCarrierRun = spawnSync(process.execPath, [
|
|
650
|
+
'--input-type=module', '--eval',
|
|
651
|
+
'const m = await import(' + JSON.stringify(
|
|
652
|
+
pathToFileURL(path.join(SCRIPTS_DIR, 'lib', 'ac-coverage.mjs')).href) + ');'
|
|
653
|
+
+ 'process.stdout.write(JSON.stringify(await m.acCoverageReview(process.argv[1])));',
|
|
654
|
+
'--', path.join(noTemplateRoot, '.specs', CHANGE_ID),
|
|
655
|
+
], { cwd: noTemplateRoot, env: { ...process.env, FLOW_COMET_RUN_ROOT: noTemplateRoot }, encoding: 'utf8' });
|
|
656
|
+
assertTrue(acCarrierRun.status === 0,
|
|
657
|
+
'「无模板的项目根」夹具子进程异常: '
|
|
658
|
+
+ String(acCarrierRun.stdout ?? '') + String(acCarrierRun.stderr ?? ''));
|
|
659
|
+
const acCarrier = JSON.parse(String(acCarrierRun.stdout));
|
|
660
|
+
const acCarrierKeys = acCarrier.unverified === null
|
|
661
|
+
? 'null'
|
|
662
|
+
: JSON.stringify(Object.keys(acCarrier.unverified).sort());
|
|
663
|
+
assertTrue(acCarrierKeys === JSON.stringify(['notice', 'reason']),
|
|
664
|
+
'AC 覆盖「模板缺席」的载荷键应为 { notice, reason }: ' + acCarrierKeys);
|
|
665
|
+
// 两侧同形:波次侧由「段缺席」进「未校验」,AC 侧由「模板缺席」进同一支——载荷键任一侧漂移,
|
|
666
|
+
// verify 出口读 notice 的两个入口就只剩一个能读(只钉一侧等于只守一半)。
|
|
667
|
+
assertTrue(judgeShape(waveCarrier) === judgeShape(acCarrier),
|
|
668
|
+
'波次判据与 AC 覆盖的「未校验」形态不一致: 波次=' + judgeShape(waveCarrier) + ' AC=' + judgeShape(acCarrier));
|
|
669
|
+
|
|
670
|
+
// ===== ⑬ 段体切片的围栏语义(五处消费共用 lib/section-body.mjs 的同一实现)=====
|
|
671
|
+
// 段体里的围栏代码块是正文示例:围栏内的 `## ` 不结束段体。修复前波次段的段界是一条「遇 `## `
|
|
672
|
+
// 即收」的惰性正则——段内贴一段 Markdown 示例后,示例之后声明的 Wave 行整段消失,判据把
|
|
673
|
+
// 「声明了」读成「没声明」(段在场而内容不可判 ⇒ 新 change BLOCKED,且永远补不上)。
|
|
674
|
+
const waveSectionWith = (body) => '# TASK\n\n## 波次划分\n\n' + body
|
|
675
|
+
+ '\n\n## 任务清单\n\n' + waveTask('T01');
|
|
676
|
+
// 本块独立于前面的 replan 段:重校成功重签后 currentNode 已在 execute,先归位到 plan 再跑出口
|
|
677
|
+
// (否则 exit plan 直接报节点漂移,测不到段体判据)。
|
|
678
|
+
const planWithSection = (markdown) => {
|
|
679
|
+
const planState = baseState('plan');
|
|
680
|
+
planState.evidence.plan = { summary: 'plan done' };
|
|
681
|
+
planState.newChange = true;
|
|
682
|
+
writeState(dir, planState);
|
|
683
|
+
return runPlanWithTask(dir, markdown);
|
|
684
|
+
};
|
|
685
|
+
// ① 围栏内的二级标题不结束段体:Wave 行在围栏之后,判据仍读到它
|
|
686
|
+
const fencedWave = planWithSection(waveSectionWith('```md\n## 代码块里的示例段标题\n```\n\nWave 1: T01'));
|
|
687
|
+
assertExit(fencedWave, 0);
|
|
688
|
+
assertOut(fencedWave, 'ALL CHECKS PASSED');
|
|
689
|
+
assertNotOut(fencedWave, '波次划分段内容不可判');
|
|
690
|
+
assertNotOut(fencedWave, '未校验(无波次段)'); // 判据真在场:不是靠「跳过」变绿
|
|
691
|
+
// ② 围栏外的同级标题照常结束段体:Wave 行落在段外 ⇒ 段在场而无可判声明
|
|
692
|
+
const closedByHeading = planWithSection(
|
|
693
|
+
waveSectionWith('```md\n示例\n```\n\n## 代码块外的段标题\n\nWave 1: T01'));
|
|
694
|
+
assertExit(closedByHeading, 1);
|
|
695
|
+
assertOut(closedByHeading, '波次划分段内容不可判');
|
|
696
|
+
// ③ 分隔线语义保持:围栏外的 `---` 同样结束段体
|
|
697
|
+
const closedByRule = planWithSection(waveSectionWith('---\n\nWave 1: T01'));
|
|
698
|
+
assertExit(closedByRule, 1);
|
|
699
|
+
assertOut(closedByRule, '波次划分段内容不可判');
|
|
700
|
+
// ④ 修复段的段界同源:修复段里的围栏代码块(块内含 `## `)不结束修复段,段内任务仍判为修复族
|
|
701
|
+
// (族判定经 task-graph 的唯一谓词——段定位不再由各消费方各写一份行扫描)。
|
|
702
|
+
const fixModule = await import(pathToFileURL(path.join(SCRIPTS_DIR, 'lib', 'task-graph.mjs')).href);
|
|
703
|
+
const fixBlock = '<task id="R02" status="pending"><action>回修段内形态</action>'
|
|
704
|
+
+ '<write_files>src/r02.mjs</write_files><verify>node --check src/r02.mjs</verify>'
|
|
705
|
+
+ '<depends_on></depends_on></task>';
|
|
706
|
+
const fixSectionWith = (body) => '# TASK\n\n## 任务清单\n\n' + waveTask('T01')
|
|
707
|
+
+ '\n## Fix 任务(来自 REVIEW / INTEGRATION)\n\n' + body;
|
|
708
|
+
const inFixFenced = fixModule.fixTaskClassifier(
|
|
709
|
+
fixSectionWith('```md\n## 代码块里的示例段标题\n```\n\n' + fixBlock), 'Fix 任务');
|
|
710
|
+
assertTrue(inFixFenced(fixBlock) === true,
|
|
711
|
+
'修复段里的围栏代码块截断了段体:围栏之后的修复任务不再被判为修复族(段界只应由围栏外的标题决定)');
|
|
712
|
+
// ⑤ 围栏外的同级标题照常结束修复段:任务落到段外 ⇒ 不属修复族
|
|
713
|
+
const inFixAfterHeading = fixModule.fixTaskClassifier(
|
|
714
|
+
'# TASK\n\n## Fix 任务\n\n```md\n示例\n```\n\n## 任务清单\n\n' + fixBlock, 'Fix 任务');
|
|
715
|
+
assertTrue(inFixAfterHeading(fixBlock) === false,
|
|
716
|
+
'围栏外的同级标题应结束修复段:其后段落里的任务不属修复族');
|
|
717
|
+
// ⑥ 分隔线语义保持:修复段不以 `---` 结束(既有语义)
|
|
718
|
+
const inFixAfterRule = fixModule.fixTaskClassifier(
|
|
719
|
+
'# TASK\n\n## Fix 任务\n\n---\n\n' + fixBlock, 'Fix 任务');
|
|
720
|
+
assertTrue(inFixAfterRule(fixBlock) === true, '`---` 不应结束修复段(既有语义)');
|
|
721
|
+
|
|
722
|
+
// ===== ⑭ 段标题的写法不是判定变量(波次段与 TASK 段形门同一口径)=====
|
|
723
|
+
// 波次段的段名曾是行首精确正则,而 TASK 段形门走标题归一:同一份计划换个标题写法,判据就退化成
|
|
724
|
+
// 「未校验(无波次段)」放行——一次排版即可绕过「未验证 ≠ 通过」。合法写法因此必须给出同一判定与
|
|
725
|
+
// 同一明细;围栏代码块里的示例标题是正文,不得被读成段。
|
|
726
|
+
// `## ## 波次划分` 这一格钉住「两处归一必须真的同源」的接缝:它的标题**正文本身**以井号开头——
|
|
727
|
+
// 段形门先剥前导井号再归一(认作在场),波次门若拿原始行做正则就会判缺席并跳过,于是同一份工件的
|
|
728
|
+
// 同一段在两处得到相反答案,新 change 仍 exit 0。判定必须过同一 normalizeHeading 再比。
|
|
729
|
+
writeFile(dir, 'flow-kit/templates/TASK.md',
|
|
730
|
+
'# TASK: <change 标题>\n\n## 波次划分\n\n## 任务清单\n');
|
|
731
|
+
const headingFormPlan = (heading) => '# TASK\n\n' + heading
|
|
732
|
+
+ '\n\nWave 2 (parallel): T01[P], T02 (T02 on T01)\n\n## 任务清单\n\n'
|
|
733
|
+
+ waveTask('T01') + waveTask('T02', 'T01');
|
|
734
|
+
const waveHeadingForms = [
|
|
735
|
+
'## 波次划分',
|
|
736
|
+
'## 波次划分(依赖层级)',
|
|
737
|
+
'## 3. 波次划分',
|
|
738
|
+
'## 波次划分 ##',
|
|
739
|
+
'## ## 波次划分',
|
|
740
|
+
];
|
|
741
|
+
const headingFormResults = waveHeadingForms.map((heading) => planWithSection(headingFormPlan(heading)));
|
|
742
|
+
const headingFormReports = headingFormResults.map((res) => waveReportLines(res));
|
|
743
|
+
for (const [index, heading] of waveHeadingForms.entries()) {
|
|
744
|
+
assertExit(headingFormResults[index], 1);
|
|
745
|
+
assertNotOut(headingFormResults[index], '未校验(无波次段)');
|
|
746
|
+
assertTrue(headingFormReports[index].length > 0,
|
|
747
|
+
'段标题写法「' + heading + '」下波次判据没有给出明细(判据被排版关掉,配套的段形门也认这组写法): '
|
|
748
|
+
+ headingFormResults[index].output);
|
|
749
|
+
}
|
|
750
|
+
for (const [index, report] of headingFormReports.entries()) {
|
|
751
|
+
assertTrue(report.join('\n') === headingFormReports[0].join('\n'),
|
|
752
|
+
'段标题写法改变了波次判定(' + waveHeadingForms[index] + ')——写法是排版,不是判定变量:\n'
|
|
753
|
+
+ JSON.stringify(report) + '\n基准=' + JSON.stringify(headingFormReports[0]));
|
|
754
|
+
}
|
|
755
|
+
fs.rmSync(path.join(dir, 'flow-kit', 'templates', 'TASK.md'), { force: true });
|
|
756
|
+
// 围栏代码块里的示例标题是正文:唯一一处「波次划分」落在围栏里时,判据没有可判对象(打印未校验、
|
|
757
|
+
// 不据此阻断),但不得被读成「段在场而内容不可判」——那是另一支判定,会把只有示例的工件判错。
|
|
758
|
+
const fencedHeadingOnly = planWithSection('# TASK\n\n```md\n## 波次划分\n\nWave 2: T01, T02\n```\n\n'
|
|
759
|
+
+ '## 任务清单\n\n' + waveTask('T01') + waveTask('T02', 'T01'));
|
|
760
|
+
assertExit(fencedHeadingOnly, 0);
|
|
761
|
+
assertOut(fencedHeadingOnly, '未校验(无波次段)');
|
|
762
|
+
assertNotOut(fencedHeadingOnly, '波次划分段内容不可判');
|
|
763
|
+
|
|
764
|
+
// ===== ⑮ 闭合 ATX 标题(`## 标题 ##`)不改变「段是否在场」(AC 覆盖与 1.1 矩阵同口径)=====
|
|
765
|
+
// 闭合 ATX 是合法 Markdown;段名判据若只认开放写法,合法工件会被读成「段缺席」——AC 覆盖因此报
|
|
766
|
+
// 「判据无法执行」并拦下新 change。围栏代码块里的示例标题仍是正文,不得被读成段。
|
|
767
|
+
const atxRoot = makeTmp();
|
|
768
|
+
writeFile(atxRoot, 'flow-kit/templates/REQUIREMENT.md',
|
|
769
|
+
'# REQUIREMENT 模板\n\n## 用户故事\n## 验收准则(AC)\n');
|
|
770
|
+
writeFile(atxRoot, 'flow-kit/templates/TEST.md', '# TEST 模板\n\n## 第 1 轮 · 功能测试\n');
|
|
771
|
+
const runCoverageIn = (root) => {
|
|
772
|
+
const changeDir = path.join(root, '.specs', CHANGE_ID);
|
|
773
|
+
const proc = spawnSync(process.execPath, [
|
|
774
|
+
'--input-type=module', '--eval',
|
|
775
|
+
'const m = await import(' + JSON.stringify(
|
|
776
|
+
pathToFileURL(path.join(SCRIPTS_DIR, 'lib', 'ac-coverage.mjs')).href) + ');'
|
|
777
|
+
+ 'process.stdout.write(JSON.stringify(await m.acCoverageReview(process.argv[1])));',
|
|
778
|
+
'--', changeDir,
|
|
779
|
+
], { cwd: root, env: { ...process.env, FLOW_COMET_RUN_ROOT: root }, encoding: 'utf8' });
|
|
780
|
+
assertTrue(proc.status === 0, 'AC 覆盖夹具子进程异常: '
|
|
781
|
+
+ String(proc.stdout ?? '') + String(proc.stderr ?? ''));
|
|
782
|
+
return JSON.parse(String(proc.stdout));
|
|
783
|
+
};
|
|
784
|
+
writeFile(atxRoot, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', [
|
|
785
|
+
'# REQUIREMENT: 闭合 ATX 夹具',
|
|
786
|
+
'',
|
|
787
|
+
'## 验收准则(AC) ##',
|
|
788
|
+
'',
|
|
789
|
+
'### AC-1 · 夹具准则',
|
|
790
|
+
'',
|
|
791
|
+
'- **Given** 夹具前置',
|
|
792
|
+
'',
|
|
793
|
+
'### AC-2 · 夹具准则',
|
|
794
|
+
'',
|
|
795
|
+
'- **Given** 夹具前置',
|
|
796
|
+
'',
|
|
797
|
+
].join('\n'));
|
|
798
|
+
writeFile(atxRoot, '.specs/' + CHANGE_ID + '/TEST.md', [
|
|
799
|
+
'# TEST: 闭合 ATX 夹具',
|
|
800
|
+
'',
|
|
801
|
+
'## 第 1 轮 · 功能测试 ##',
|
|
802
|
+
'',
|
|
803
|
+
'### 1.1 测试矩阵(AC → 用例) ##',
|
|
804
|
+
'',
|
|
805
|
+
'| AC | 类型 | 用例文件 / UAT | 状态 |',
|
|
806
|
+
'|---|---|---|---|',
|
|
807
|
+
'| AC-1 | unit | guard-self-test.mjs | ✅ |',
|
|
808
|
+
'| AC-2 | unit | guard-self-test.mjs | ✅ |',
|
|
809
|
+
'',
|
|
810
|
+
].join('\n'));
|
|
811
|
+
const closedAtxCoverage = runCoverageIn(atxRoot);
|
|
812
|
+
assertTrue(closedAtxCoverage.unverified === null && closedAtxCoverage.unjudgeable === null,
|
|
813
|
+
'闭合 ATX 标题被读成「段缺席」(判据无法执行): ' + JSON.stringify(closedAtxCoverage));
|
|
814
|
+
assertTrue(closedAtxCoverage.missing.length === 0,
|
|
815
|
+
'闭合 ATX 写法的 1.1 矩阵未被读成覆盖(缺: ' + JSON.stringify(closedAtxCoverage.missing) + ')');
|
|
816
|
+
// 围栏里的示例标题仍是正文:只有示例、没有真段时判「承载段不在」,而不是「段在场」。
|
|
817
|
+
writeFile(atxRoot, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', [
|
|
818
|
+
'# REQUIREMENT: 围栏示例夹具',
|
|
819
|
+
'',
|
|
820
|
+
'```md',
|
|
821
|
+
'## 验收准则(AC)',
|
|
822
|
+
'',
|
|
823
|
+
'### AC-1 · 示例',
|
|
824
|
+
'```',
|
|
825
|
+
'',
|
|
826
|
+
].join('\n'));
|
|
827
|
+
const fencedSectionCoverage = runCoverageIn(atxRoot);
|
|
828
|
+
assertTrue(fencedSectionCoverage.unjudgeable !== null
|
|
829
|
+
&& fencedSectionCoverage.unjudgeable.reason === 'REQUIREMENT 无验收准则段',
|
|
830
|
+
'围栏代码块里的示例标题被读成了段(示例是正文,不是段): ' + JSON.stringify(fencedSectionCoverage));
|
|
831
|
+
// ⑯ 标题**正文本身**以井号开头(`## ## 验收准则(AC)`):段形门先剥前导井号再归一(认在场),
|
|
832
|
+
// 段定位若拿原始行做正则,第二个井号被读成段名的一部分 → 判「无验收准则段」——同一份工件的
|
|
833
|
+
// 同一段在两处得到相反答案(假红,恢复句还指向「补段」)。两侧过同一套归一后,这一形态必须与
|
|
834
|
+
// 普通写法给出同一判定:编号正常取到、矩阵照常对上。1.1 矩阵是三级标题,同一形态照此推到三级。
|
|
835
|
+
writeFile(atxRoot, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', [
|
|
836
|
+
'# REQUIREMENT: 井号开头夹具',
|
|
837
|
+
'',
|
|
838
|
+
'## ## 验收准则(AC)',
|
|
839
|
+
'',
|
|
840
|
+
'### AC-1 · 夹具准则',
|
|
841
|
+
'',
|
|
842
|
+
'- **Given** 夹具前置',
|
|
843
|
+
'',
|
|
844
|
+
'### AC-2 · 夹具准则',
|
|
845
|
+
'',
|
|
846
|
+
'- **Given** 夹具前置',
|
|
847
|
+
'',
|
|
848
|
+
].join('\n'));
|
|
849
|
+
writeFile(atxRoot, '.specs/' + CHANGE_ID + '/TEST.md', [
|
|
850
|
+
'# TEST: 井号开头夹具',
|
|
851
|
+
'',
|
|
852
|
+
'## ## 第 1 轮 · 功能测试',
|
|
853
|
+
'',
|
|
854
|
+
'### ## 1.1 测试矩阵(AC → 用例)',
|
|
855
|
+
'',
|
|
856
|
+
'| AC | 类型 | 用例文件 / UAT | 状态 |',
|
|
857
|
+
'|---|---|---|---|',
|
|
858
|
+
'| AC-1 | unit | guard-self-test.mjs | ✅ |',
|
|
859
|
+
'| AC-2 | unit | guard-self-test.mjs | ✅ |',
|
|
860
|
+
'',
|
|
861
|
+
].join('\n'));
|
|
862
|
+
const hashedHeadingCoverage = runCoverageIn(atxRoot);
|
|
863
|
+
assertTrue(hashedHeadingCoverage.unverified === null && hashedHeadingCoverage.unjudgeable === null,
|
|
864
|
+
'标题正文以井号开头被读成「段缺席」(段形门认在场,判据走同一套归一后不应分叉): '
|
|
865
|
+
+ JSON.stringify(hashedHeadingCoverage));
|
|
866
|
+
assertTrue(hashedHeadingCoverage.missing.length === 0,
|
|
867
|
+
'井号开头写法的 1.1 矩阵未被读成覆盖(缺: ' + JSON.stringify(hashedHeadingCoverage.missing) + ')');
|
|
868
|
+
// ⑰ 段名仍以模板为准:TEST 模板声明的承载段是「第 1 轮 · 功能测试」,工件标题换成模板没写过的
|
|
869
|
+
// 「第 1 轮:功能测试」时不得被回退名清单悄悄接住——回退只在**模板段名不含关键词**时生效,
|
|
870
|
+
// 否则「模板说缺段、判据说在场」会把判定放宽(假绿)。段形门对这一份工件同样报缺段。
|
|
871
|
+
writeFile(atxRoot, '.specs/' + CHANGE_ID + '/REQUIREMENT.md', [
|
|
872
|
+
'# REQUIREMENT: 段名漂移夹具',
|
|
873
|
+
'',
|
|
874
|
+
'## 验收准则(AC)',
|
|
875
|
+
'',
|
|
876
|
+
'### AC-1 · 夹具准则',
|
|
877
|
+
'',
|
|
878
|
+
'- **Given** 夹具前置',
|
|
879
|
+
'',
|
|
880
|
+
].join('\n'));
|
|
881
|
+
writeFile(atxRoot, '.specs/' + CHANGE_ID + '/TEST.md', [
|
|
882
|
+
'# TEST: 段名漂移夹具',
|
|
883
|
+
'',
|
|
884
|
+
'## 第 1 轮:功能测试',
|
|
885
|
+
'',
|
|
886
|
+
'### 1.1 测试矩阵(AC → 用例)',
|
|
887
|
+
'',
|
|
888
|
+
'| AC | 类型 | 用例文件 / UAT | 状态 |',
|
|
889
|
+
'|---|---|---|---|',
|
|
890
|
+
'| AC-1 | unit | guard-self-test.mjs | ✅ |',
|
|
891
|
+
'',
|
|
892
|
+
].join('\n'));
|
|
893
|
+
const driftedRound = runCoverageIn(atxRoot);
|
|
894
|
+
assertTrue(driftedRound.unjudgeable !== null
|
|
895
|
+
&& driftedRound.unjudgeable.reason === 'TEST.md 无第 1 轮段',
|
|
896
|
+
'模板没声明的段标题被回退名清单接住(段名不再由模板派生,判定被放宽): ' + JSON.stringify(driftedRound));
|
|
218
897
|
},
|
|
219
898
|
},
|
|
220
899
|
|
|
@@ -265,7 +944,7 @@ export const ENTRIES = [
|
|
|
265
944
|
|
|
266
945
|
// 149(混排合法锚):新 change + 多波混合(≥2 个并行块被串行分隔)→ 放行
|
|
267
946
|
{
|
|
268
|
-
name: '149 plan exit
|
|
947
|
+
name: '149 plan exit 通过:混排合法锚——多波混合(两并行块被串行分隔)+ 波次投影诚实计划通过 / 无波次段显式未校验',
|
|
269
948
|
run: (dir) => {
|
|
270
949
|
const st = baseState('plan');
|
|
271
950
|
st.evidence.plan = { summary: 'plan done' };
|
|
@@ -274,6 +953,16 @@ export const ENTRIES = [
|
|
|
274
953
|
const res = runPlanExit(dir, renderMultiWaveTasks());
|
|
275
954
|
assertExit(res, 0);
|
|
276
955
|
assertOut(res, 'ALL CHECKS PASSED');
|
|
956
|
+
// ⑥ 无波次段:判据不可判 ⇒ 显式「未校验」且其余判据照常(不是静默通过)——本夹具的
|
|
957
|
+
// TASK.md 就没有波次段,故这一行必须出现,且出口仍然通过。
|
|
958
|
+
assertOut(res, '未校验(无波次段)');
|
|
959
|
+
// ① 诚实计划(同波任务彼此无依赖、每波 = 依赖层级)⇒ 判据在场但不产生任何输出
|
|
960
|
+
// (「未校验」缺席证明它真的判过,而不是又跳过了)。
|
|
961
|
+
const honestPlan = runPlanWithTask(dir, honestWavePlan());
|
|
962
|
+
assertExit(honestPlan, 0);
|
|
963
|
+
assertOut(honestPlan, 'ALL CHECKS PASSED');
|
|
964
|
+
assertNotOut(honestPlan, '未校验(无波次段)');
|
|
965
|
+
assertNotOut(honestPlan, '波次划分与依赖层级不一致');
|
|
277
966
|
},
|
|
278
967
|
},
|
|
279
968
|
|
|
@@ -294,7 +983,7 @@ export const ENTRIES = [
|
|
|
294
983
|
// 151(渐进语义适配):旧 change(无 newChange)+ 依赖环 → 不 BLOCK(渐进 WARN——断言锁「不阻断」,
|
|
295
984
|
// 检测须真实发生:输出 WARN 且含「依赖环」明细)。混排本身已合法化,渐进路径改由依赖图违规承载。
|
|
296
985
|
{
|
|
297
|
-
name: '151 plan exit 兼容:旧 change 依赖环不 BLOCK(渐进 WARN
|
|
986
|
+
name: '151 plan exit 兼容:旧 change 依赖环不 BLOCK(渐进 WARN)+ 波次投影旧 change 只 WARN',
|
|
298
987
|
run: (dir) => {
|
|
299
988
|
const st = baseState('plan');
|
|
300
989
|
st.evidence.plan = { summary: 'plan done' };
|
|
@@ -305,6 +994,65 @@ export const ENTRIES = [
|
|
|
305
994
|
assertNotOut(res, 'BLOCKED');
|
|
306
995
|
assertOut(res, 'WARN');
|
|
307
996
|
assertOut(res, '依赖环');
|
|
997
|
+
// ⑤ 旧 change 走同一输入(② 的同波依赖夹具):判据同源、明细同一措辞,但只 WARN 不阻断——
|
|
998
|
+
// 退出码不因该判据改变(既有归档流程不被阻断),明细仍点名任务与应到波。
|
|
999
|
+
const oldWaveWarn = runPlanWithTask(dir, sameWavePlan());
|
|
1000
|
+
assertExit(oldWaveWarn, 0);
|
|
1001
|
+
assertNotOut(oldWaveWarn, 'BLOCKED');
|
|
1002
|
+
assertOut(oldWaveWarn, '波次划分与依赖层级不一致');
|
|
1003
|
+
assertOut(oldWaveWarn, 'T01');
|
|
1004
|
+
assertOut(oldWaveWarn, '应到波 1');
|
|
1005
|
+
// ⑥ 旧 change + 未声明任务:同一明细、同一措辞(当前波 = 未声明),但只 WARN——退出码不因该
|
|
1006
|
+
// 判据改变,明细仍点名未被波次覆盖的任务与应到波。
|
|
1007
|
+
const oldUndeclared = runPlanWithTask(dir, undeclaredWavePlan());
|
|
1008
|
+
assertExit(oldUndeclared, 0);
|
|
1009
|
+
assertNotOut(oldUndeclared, 'BLOCKED');
|
|
1010
|
+
assertOut(oldUndeclared, '未声明');
|
|
1011
|
+
assertOut(oldUndeclared, 'T02(依赖: T01)当前波 未声明 → 应到波 2');
|
|
1012
|
+
assertOut(oldUndeclared, '应到波 3');
|
|
1013
|
+
// ⑦ 旧 change + 段在场而内容不可判(N/A 正文):WARN 不阻断,且进入既有 WARN COUNT——
|
|
1014
|
+
// 「未校验」不再静默(此前这一类只打印未校验、不进 WARN 汇总,等于零反馈)。
|
|
1015
|
+
const oldUnjudgeable = runPlanWithTask(dir, naWavePlan());
|
|
1016
|
+
assertExit(oldUnjudgeable, 0);
|
|
1017
|
+
assertNotOut(oldUnjudgeable, 'BLOCKED');
|
|
1018
|
+
assertOut(oldUnjudgeable, '波次划分段内容不可判');
|
|
1019
|
+
// 计数用例别力:同一任务集、唯一变量 = 波次段是否在场——载体缺席只「未校验」(不计 WARN),
|
|
1020
|
+
// 内容不可判那一支必须使 WARN COUNT 恰好比它多 1(「未校验不再静默」的证据是计数差,不是
|
|
1021
|
+
// 「输出里有 WARN 字样」)。
|
|
1022
|
+
const noSectionSameTasks = runPlanWithTask(dir, '# TASK\n\n## 任务清单\n\n'
|
|
1023
|
+
+ waveTask('T01') + waveTask('T02', 'T01'));
|
|
1024
|
+
assertExit(noSectionSameTasks, 0);
|
|
1025
|
+
assertOut(noSectionSameTasks, '未校验(无波次段)');
|
|
1026
|
+
const warnCountOf = (res) => {
|
|
1027
|
+
const match = /WARN COUNT: (\d+)/u.exec(res.output);
|
|
1028
|
+
return match === null ? 0 : Number(match[1]);
|
|
1029
|
+
};
|
|
1030
|
+
assertTrue(warnCountOf(oldUnjudgeable) === warnCountOf(noSectionSameTasks) + 1,
|
|
1031
|
+
'段在场而内容不可判未计入 WARN COUNT(未校验仍静默): N/A=' + warnCountOf(oldUnjudgeable)
|
|
1032
|
+
+ ' 无段=' + warnCountOf(noSectionSameTasks));
|
|
1033
|
+
// ⑧ 旧 change + 同波可并行却漏标 [P]:同一输入只 WARN 不阻断,且该行进入既有 WARN COUNT——
|
|
1034
|
+
// 计数差分(判别力):唯一变量(T02 的 parallel 标记)补上后该 WARN 消失,计数恰少 1。
|
|
1035
|
+
const oldGap = runPlanWithTask(dir, parallelGapPlan());
|
|
1036
|
+
assertExit(oldGap, 0);
|
|
1037
|
+
assertNotOut(oldGap, 'BLOCKED');
|
|
1038
|
+
assertOut(oldGap, '同波任务可并行却未标 [P]');
|
|
1039
|
+
assertOut(oldGap, 'T01 × T02');
|
|
1040
|
+
const oldGapFixed = runPlanWithTask(dir, parallelGapPlan({ markAll: true }));
|
|
1041
|
+
assertExit(oldGapFixed, 0);
|
|
1042
|
+
assertNotOut(oldGapFixed, '可并行却未标 [P]');
|
|
1043
|
+
assertTrue(warnCountOf(oldGap) === warnCountOf(oldGapFixed) + 1,
|
|
1044
|
+
'同波漏标 [P] 的 WARN 未计入 WARN COUNT: 漏标=' + warnCountOf(oldGap)
|
|
1045
|
+
+ ' 全标=' + warnCountOf(oldGapFixed));
|
|
1046
|
+
// ⑨ 补集等价:本判据的「写面不重叠」= task-graph 的 collectCrossTaskConflicts(写面重叠的唯一
|
|
1047
|
+
// 入口,其实现就是 collectPathOverlaps + 已归一路径 + glob)返回集合的**补集**。夹具构造反面:
|
|
1048
|
+
// 同波同层、都没标 parallel,但写同一个文件 → 写冲突族照常报,本判据必须沉默(否则同一对上
|
|
1049
|
+
// 两条报文自相矛盾)。反向构造:抽掉该入口(M4)→ 这里同时冒出「可并行却未标 [P]」→ 判红。
|
|
1050
|
+
const oldOverlap = runPlanWithTask(dir, overlapPairWavePlan());
|
|
1051
|
+
assertExit(oldOverlap, 0);
|
|
1052
|
+
assertOut(oldOverlap, '同文件跨任务且无依赖路径');
|
|
1053
|
+
assertTrue(!oldOverlap.output.includes('可并行却未标 [P]'),
|
|
1054
|
+
'补集等价被破坏:写面重叠(collectCrossTaskConflicts 判为冲突)的一对不得被要求标 [P]('
|
|
1055
|
+
+ oldOverlap.output + ')');
|
|
308
1056
|
},
|
|
309
1057
|
},
|
|
310
1058
|
|