flow-comet 1.6.5 → 1.8.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.flow-comet/skills/flow-comet/INSTALLED_VERSION +1 -1
- package/.flow-comet/skills/flow-comet/SKILL.md +32 -18
- package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +2 -2
- package/.flow-comet/skills/flow-comet/reference/decision-points.md +5 -5
- package/.flow-comet/skills/flow-comet/reference/dirty-worktree.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/entry-detail.md +30 -11
- package/.flow-comet/skills/flow-comet/reference/fix-loop.md +4 -4
- package/.flow-comet/skills/flow-comet/reference/init-detection.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/platform-facts.md +2 -2
- package/.flow-comet/skills/flow-comet/reference/post-archive-handoff.md +264 -0
- package/.flow-comet/skills/flow-comet/reference/recovery.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/replan.md +1 -1
- package/.flow-comet/skills/flow-comet/scripts/comet-check.mjs +1 -0
- package/.flow-comet/skills/flow-comet/scripts/comet-hook-guard.mjs +270 -30
- package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +26 -23
- package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +14 -94
- package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +122 -11
- package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +79 -40
- package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +11 -9
- package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +52 -10
- package/.flow-comet/skills/flow-comet/scripts/items/f.mjs +1 -1
- package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +128 -56
- package/.flow-comet/skills/flow-comet/scripts/items/k.mjs +357 -3
- package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +26 -1
- package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +6 -2
- package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +29 -21
- package/.flow-comet/skills/flow-comet/scripts/lib/ac-coverage.mjs +317 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/fix-loop-node.mjs +4 -15
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-artifact-skeleton.mjs +47 -5
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +357 -219
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +725 -309
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +182 -54
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +8 -6
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +224 -83
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +17 -28
- package/.flow-comet/skills/flow-comet/scripts/lib/lessons-hits.mjs +160 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/run-root.mjs +21 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/section-body.mjs +92 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +61 -33
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +663 -205
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +68 -9
- package/.flow-comet/skills/flow-comet/scripts/lib/state-determine.mjs +11 -4
- package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +92 -13
- package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +232 -11
- package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +140 -74
- package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +8 -4
- package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +84 -31
- package/.flow-comet/skills/flow-comet/scripts/lib/test-assertions.mjs +0 -3
- package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +248 -24
- package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +63 -3
- package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +181 -8
- package/.flow-comet/skills/flow-comet/scripts/lib/wave-projection.mjs +340 -0
- package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +132 -20
- package/.flow-comet/skills/flow-comet/scripts/route-node.mjs +12 -5
- package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +1564 -54
- package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1489 -38
- package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1466 -243
- package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +743 -24
- package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +220 -92
- package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +657 -21
- package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +41 -27
- package/.flow-comet/skills/flow-comet/scripts/scenarios/h.mjs +285 -9
- package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +7 -6
- package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +21 -15
- package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +8 -5
- package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +45 -36
- package/.flow-comet/skills/flow-comet/scripts/scenarios/m.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +2381 -85
- package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +135 -2
- package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +143 -16
- package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +339 -103
- package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +5 -2
- package/.flow-comet/skills/flow-comet-archive/SKILL.md +33 -11
- package/.flow-comet/skills/flow-comet-change/SKILL.md +1 -1
- package/.flow-comet/skills/flow-comet-design/SKILL.md +5 -3
- package/.flow-comet/skills/flow-comet-dev/SKILL.md +2 -2
- package/.flow-comet/skills/flow-comet-execute/SKILL.md +37 -13
- package/.flow-comet/skills/flow-comet-integration/SKILL.md +10 -4
- package/.flow-comet/skills/flow-comet-plan/GUIDANCE.md +1 -1
- package/.flow-comet/skills/flow-comet-plan/SKILL.md +13 -6
- package/.flow-comet/skills/flow-comet-review/SKILL.md +21 -12
- package/.flow-comet/skills/flow-comet-subagent-execute/GUIDANCE.md +1 -1
- package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +43 -18
- package/.flow-comet/skills/flow-comet-task/SKILL.md +4 -2
- package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +2 -2
- package/.flow-comet/skills/flow-comet-verify/SKILL.md +1 -1
- package/README.md +2 -2
- package/package.json +1 -1
- package/scripts/dsh-bridge.mjs +238 -21
|
@@ -1,13 +1,18 @@
|
|
|
1
1
|
// 节点门禁(守卫模块):entry 链 + 出口前置 / 文件纪律 / 节点结构 门禁。
|
|
2
2
|
//
|
|
3
|
-
//
|
|
4
|
-
//
|
|
5
|
-
// (未验证 ≠ 通过)。
|
|
3
|
+
// 判据只在本模块一处实现(入口零内联副本);门禁命中即 BLOCKED + 恢复指引(单轨,无分级旁路)。
|
|
4
|
+
// 门禁命中即显式报出原因并按 fail-closed 拒绝(未验证 ≠ 通过)。
|
|
6
5
|
|
|
7
6
|
import { promises as fs } from 'fs';
|
|
8
7
|
import path from 'path';
|
|
9
8
|
import { validateStateFields } from '../state-schema.mjs';
|
|
10
|
-
import {
|
|
9
|
+
import {
|
|
10
|
+
NODE_PROTOCOL_FILES,
|
|
11
|
+
nodeTemplateDeclaration,
|
|
12
|
+
templateKeyFromArtifactName,
|
|
13
|
+
templateKeyOf,
|
|
14
|
+
templatePointerPath,
|
|
15
|
+
} from '../protocol-utils.mjs';
|
|
11
16
|
import {
|
|
12
17
|
EXECUTE_FAMILY_NODE_IDS,
|
|
13
18
|
TASK_SET_SIGNATURE_ALGO,
|
|
@@ -29,17 +34,67 @@ import {
|
|
|
29
34
|
headingPattern,
|
|
30
35
|
} from './guard-artifact-skeleton.mjs';
|
|
31
36
|
import { frontendCriterion } from './guard-uidesign.mjs';
|
|
37
|
+
// 波次段解析与「波次 = 依赖层级的投影」判定(纯判定模块):plan 出口与 replan 重校段共用同一
|
|
38
|
+
// 判定、同一分级出口(waveReviewOutcome / parallelGapOutcome)——波次散文检测与波次投影判据取用
|
|
39
|
+
// 同一个 waveSectionBody(段体本身由 lib/section-body.mjs 单点切片)。
|
|
40
|
+
import {
|
|
41
|
+
parallelGapOutcome,
|
|
42
|
+
parallelGapReview,
|
|
43
|
+
waveProjectionReview,
|
|
44
|
+
waveReviewOutcome,
|
|
45
|
+
waveSectionBody,
|
|
46
|
+
} from './wave-projection.mjs';
|
|
32
47
|
import {
|
|
48
|
+
archiveDirNameNotice,
|
|
49
|
+
archivedChangeLocation,
|
|
50
|
+
declaredRequiredArtifacts,
|
|
33
51
|
evidenceFor,
|
|
34
|
-
findSkillLoadsDir,
|
|
35
52
|
hasEvidenceField,
|
|
36
53
|
hasNonEmptyHandoffResult,
|
|
37
|
-
isNewChange,
|
|
38
54
|
missingRequiredArtifacts,
|
|
39
55
|
missingRequiredSchemaEvidence,
|
|
40
56
|
nextNode,
|
|
57
|
+
recoveryActionText,
|
|
41
58
|
templateSectionPatterns,
|
|
59
|
+
unspecifiedPathsNotice,
|
|
42
60
|
} from './guard-routing.mjs';
|
|
61
|
+
// 结构化预检(exit --preflight)的子集由既有门禁与既有的产物路径判据组成:本节点声明工件的
|
|
62
|
+
// 存在性消费出口产物门禁的**同一条判据**(guard-routing 的 declaredRequiredArtifacts——枚举 +
|
|
63
|
+
// 路径解析 + 在场判定,预检不另写一份),SUMMARY 关键段来自证据/产物门禁族,骨架判据与 TASK 7
|
|
64
|
+
// 字段来自模板保真门禁族——预检自身不复制段形实现,也不新造一份节点→产物映射。
|
|
65
|
+
// 声明面两道门共用同一份派生(declare 命令 + 该声明哪些技能):出口覆盖门与缺证据恢复段的命令必须
|
|
66
|
+
// 同集合,否则「照抄报文」会在下一次 exit 上撞上另一套判据。
|
|
67
|
+
import {
|
|
68
|
+
declarationSkillNames,
|
|
69
|
+
evidenceRecoveryBlock,
|
|
70
|
+
nodeRecordCommand,
|
|
71
|
+
nodeSkillLoadCommands,
|
|
72
|
+
runAcCoverageGate,
|
|
73
|
+
runSummarySectionsGate,
|
|
74
|
+
} from './guard-evidence-gates.mjs';
|
|
75
|
+
// 写面元素提取与条目边界(剥注释 → 行切 → 分号容错切 → trim → 滤空)的唯一实现在 lib/lessons-hits.mjs:
|
|
76
|
+
// 伪并行启发式只是它的一个消费方(另两个是 handoff 的提交子集校验与 task-graph 的路径解析)。元素名
|
|
77
|
+
// 大小写无关(`<WRITE_FILES>` 与 `<write_files>` 是同一种元素)——与 7 字段门的在场判定同口径,本处
|
|
78
|
+
// 不另写标签正则(元素名少一个 /i 的副本会让这类任务静默掉出告警面)。
|
|
79
|
+
import { taskWriteFilesById, writeFilesEntries } from './lessons-hits.mjs';
|
|
80
|
+
import { evaluateArtifact, formatIssueParts, runTaskSevenFieldGate } from './guard-template-fidelity.mjs';
|
|
81
|
+
// 协调者禁令的常量落在中立模块(跨族共用的措辞不进任何一族):本模块只是取用方,状态命令族同理。
|
|
82
|
+
import { COORDINATOR_NOTICE } from './state-explain.mjs';
|
|
83
|
+
// 声明标记目录的路径规则(活动路径优先、归档兜底)归状态族的路径上下文模块,与 record 前置门同一份
|
|
84
|
+
// 实现——guard → state-* 是允许的单向边;规则若留在守卫族,状态 CLI 会为它加载整个守卫图。
|
|
85
|
+
import {
|
|
86
|
+
changeLocationFailureMessage,
|
|
87
|
+
findSkillLoadsDir,
|
|
88
|
+
resolveChangeDir,
|
|
89
|
+
} from './state-io.mjs';
|
|
90
|
+
// 声明标记的协议文件提取(protocols 数组 ∪ protocol 单值的 basename 归一)由状态族单源提供:
|
|
91
|
+
// skill-load 写入侧与出口覆盖判据读同一份实现——各写一份时「旧标记里存完整绝对路径」这条口径
|
|
92
|
+
// 会在一边生效、另一边判失配。
|
|
93
|
+
import { markerProtocolBasenames } from './state-skillmarkers.mjs';
|
|
94
|
+
// 段界(同级标题 / 围栏 / 分隔线 / 文末)与围栏行语法取 lib/section-body.mjs 的唯一实现:REVIEW
|
|
95
|
+
// 发现区、旧发现段与 LESSONS 模板样例段此前各写一份按行扫标题的实现,围栏代码块里的 `## ` 会把
|
|
96
|
+
// 段体截断(发现区的后果是「围栏之后的发现整段消失」)。
|
|
97
|
+
import { isFenceLine, scanHeadings, sectionBody } from './section-body.mjs';
|
|
43
98
|
|
|
44
99
|
// 节点 → 合法 exit 的前置条件(对齐 flow-kit 阶段门 + flowkit.*.v1 evidence)
|
|
45
100
|
const NODE_TRANSITION_GATES = {
|
|
@@ -53,30 +108,28 @@ const NODE_TRANSITION_GATES = {
|
|
|
53
108
|
archive: { evidence: ['archive-summary'] },
|
|
54
109
|
};
|
|
55
110
|
|
|
56
|
-
// 声明标记 protocol → basename 提取(exit 校验与节点协议映射表 basename 精确比对)。兼容新旧两种
|
|
57
|
-
// 格式:新格式(skill-load 写入)= 纯 basename(如 0-change.md),原样返回;旧格式 = 完整绝对路径
|
|
58
|
-
// (Windows 反斜杠 / POSIX 斜杠),提取最后一段后可比对。非字符串(null——skill-load 未传
|
|
59
|
-
// --protocol 的新格式缺省)→ null(协议集内无 null,fail-closed 由 includes 比对兜底)。
|
|
60
|
-
function markerProtocolBasename(value) {
|
|
61
|
-
if (typeof value !== 'string' || value === '') return null;
|
|
62
|
-
return String(value).replaceAll('\\', '/').split('/').pop() || null;
|
|
63
|
-
}
|
|
64
|
-
|
|
65
111
|
// REVIEW.md 发现区解析——发现的合法位置是模板位置 `### 2.2 …详细发现`(REVIEW 模板的结构子段);
|
|
66
|
-
// 旧形态 `## 发现` 段(历史 REVIEW
|
|
67
|
-
//
|
|
112
|
+
// 旧形态 `## 发现` 段(历史 REVIEW 的写法)继续按同一套条目口径解析,供迁移提示(位置不对即拦)。
|
|
113
|
+
// 发现项有两种合法书写形态:① 列表项("- **" 无序 / "1. **" 有序,两种列表形态同口径解析);
|
|
68
114
|
// ② 模板范例形态(flow-kit/templates/REVIEW.md 2.2 的书写样例 `### 🔴 R<x> · <名字>:<结论>` +
|
|
69
115
|
// 粗体字段行)——模板位置下以严重度 token 起头的 H3 同样是发现,标题行即条目自身的第一行(处置
|
|
70
116
|
// 标记按该行判定)。不以严重度 token 起头的 H3(如 `### Major`)仍是严重度分区。旧 `## 发现` 段
|
|
71
117
|
// 保持列表项口径(历史写法,避免把分区标题误判成发现)。"无"条目("- 无" / "无(...)")表示该
|
|
72
118
|
// 级别无发现,豁免。条目块包含其后的非空续行,直到空行 / 下一条目 / 下一个标题。严重度只取该条目
|
|
73
119
|
// 自身的标题/行首——所属 "### Major" 分区,或标题(加粗部分 / H3 严重度 token)内带级别信息;
|
|
74
|
-
// 条目正文引用他条的 [Major] 字样不改变本条严重度。返回
|
|
120
|
+
// 条目正文引用他条的 [Major] 字样不改变本条严重度。返回
|
|
121
|
+
// { title, scope, lines, isMajor, isMinor, ordinal }——isMinor 只认显式判为 Minor 的形态(### Minor
|
|
122
|
+
// 分区 / [Minor] 标签 / 🟢 前缀),未标严重度的条目不假装是 Minor(Minor 判定理由门禁据此不误判)。
|
|
75
123
|
const REVIEW_FINDING_ITEM_RE = /^\s*(?:[-*+]|\d+[.)])\s*\*\*(.+?)\*\*/;
|
|
76
124
|
const REVIEW_SEVERITY_TOKEN_RE = /^(?:🔴|🟡|🟢|\[\s*(?:critical|major|minor)\s*\])\s*/iu;
|
|
77
125
|
const REVIEW_DISPOSITION_RE = /\[已修\]|\[升级\]|\[转待办\]/;
|
|
78
126
|
const REVIEW_MAJOR_LABEL_RE = /\[\s*Major\s*\]/i;
|
|
127
|
+
const REVIEW_MINOR_LABEL_RE = /\[\s*Minor\s*\]/i;
|
|
79
128
|
const REVIEW_ADJUDICATION_RE = /用户裁决\s*[::]\s*接受延期/;
|
|
129
|
+
// Minor 判定理由的固定形态:条目块内以「判 Minor:」开头的一行(后接一句话理由)。只做结构级
|
|
130
|
+
// 判定(行首标签存在即视为已自证)——行首的列表记号 / 引用记号是 Markdown 行级噪音,不改变该行
|
|
131
|
+
// 的标签身份,故允许出现在标签之前。
|
|
132
|
+
const REVIEW_MINOR_JUSTIFICATION_RE = /^\s*(?:(?:[-*+]|\d+[.)])\s+|>\s*)*判\s*Minor\s*[::]/;
|
|
80
133
|
// 旧形态段的「空段」形态:占位词与「无」条目不构成内容(迁移提示只在旧段真有内容时给)。
|
|
81
134
|
const REVIEW_FINDINGS_PLACEHOLDER_RE =
|
|
82
135
|
/^(?:[-*+]\s*)?(?:\*\*)?(?:无|不适用|未涉及|无变更|N\/A|—|(无)|\(无\))(?:\*\*)?[。.;;,,]?$/iu;
|
|
@@ -101,29 +154,42 @@ async function reviewFindingScope() {
|
|
|
101
154
|
}
|
|
102
155
|
|
|
103
156
|
// H3 条目形态的严重度从标题前缀的严重度 token 派生(模板范例的 🔴/🟡/🟢;另接受文字标签形态的
|
|
104
|
-
// [Critical]/[Major]/[Minor]
|
|
157
|
+
// [Critical]/[Major]/[Minor])——延期裁决门禁对 H3 条目与列表项同口径。
|
|
105
158
|
function reviewSubheadingIsMajor(heading) {
|
|
106
159
|
const token = (String(heading).match(REVIEW_SEVERITY_TOKEN_RE) ?? [])[0] ?? '';
|
|
107
160
|
if (/🔴|🟡/u.test(token) || /critical|major/iu.test(token)) return true;
|
|
108
161
|
return REVIEW_MAJOR_LABEL_RE.test(heading);
|
|
109
162
|
}
|
|
110
163
|
|
|
164
|
+
// H3 条目的 Minor 形态(模板范例的 🟢 / 文字标签 [Minor])——与 reviewSubheadingIsMajor 同一派生面。
|
|
165
|
+
function reviewSubheadingIsMinor(heading) {
|
|
166
|
+
const token = (String(heading).match(REVIEW_SEVERITY_TOKEN_RE) ?? [])[0] ?? '';
|
|
167
|
+
if (/🟢/u.test(token) || /minor/iu.test(token)) return true;
|
|
168
|
+
return REVIEW_MINOR_LABEL_RE.test(heading);
|
|
169
|
+
}
|
|
170
|
+
|
|
111
171
|
function reviewFindingsItems(text, scope = { primary: null, siblings: [] }) {
|
|
112
172
|
const items = [];
|
|
113
173
|
let mode = 'none'; // 'none' | 'legacy'(旧 ## 发现)| 'primary'(模板位置 2.2)
|
|
114
174
|
let severity = '';
|
|
115
175
|
let current = null;
|
|
116
176
|
const pushCurrent = () => { if (current) { items.push(current); current = null; } };
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
177
|
+
// 段界(哪些标题行真的开 / 闭一段)由 lib/section-body.mjs 的围栏感知扫描给出:围栏代码块里的
|
|
178
|
+
// `## ` / `### ` 是条目正文里的 Markdown 示例,不是段界——旧实现把它们当结构标题,一段代码块
|
|
179
|
+
// 之后 `## ` 会重置发现区,其后的发现条目整段消失(处置标记门禁因此对它们形同虚设)。分区语义
|
|
180
|
+
// 仍在下面:模板位置下的严重度分区是作用域内的分区,兄弟结构子段才结束作用域。
|
|
181
|
+
const { lines, headings } = scanHeadings(text);
|
|
182
|
+
const headingAt = new Map(headings.map((heading) => [heading.index, heading]));
|
|
183
|
+
for (let index = 0; index < lines.length; index += 1) {
|
|
184
|
+
const line = lines[index];
|
|
185
|
+
const heading = headingAt.get(index);
|
|
186
|
+
if (heading !== undefined && heading.level === 2) {
|
|
120
187
|
pushCurrent();
|
|
121
188
|
severity = '';
|
|
122
|
-
mode = /^发现/.test(
|
|
189
|
+
mode = /^发现/.test(heading.text) ? 'legacy' : 'none';
|
|
123
190
|
continue;
|
|
124
191
|
}
|
|
125
|
-
|
|
126
|
-
if (h3) {
|
|
192
|
+
if (heading !== undefined && heading.level === 3) {
|
|
127
193
|
pushCurrent();
|
|
128
194
|
if (mode === 'primary') {
|
|
129
195
|
// 兄弟结构子段结束模板位置作用域;其余三级标题只是严重度分区
|
|
@@ -134,17 +200,18 @@ function reviewFindingsItems(text, scope = { primary: null, siblings: [] }) {
|
|
|
134
200
|
}
|
|
135
201
|
// 模板范例形态:严重度 token 起头的 H3 = 发现条目(标题行即条目自身第一行,处置标记
|
|
136
202
|
// 与列表项同口径按该行判定),续行是粗体字段 / 正文,直到空行或下一个标题。
|
|
137
|
-
const
|
|
138
|
-
if (REVIEW_SEVERITY_TOKEN_RE.test(
|
|
203
|
+
const headingText = heading.text;
|
|
204
|
+
if (REVIEW_SEVERITY_TOKEN_RE.test(headingText)) {
|
|
139
205
|
current = {
|
|
140
|
-
title:
|
|
206
|
+
title: headingText.replace(REVIEW_SEVERITY_TOKEN_RE, '').trim() || headingText,
|
|
141
207
|
scope: 'primary',
|
|
142
208
|
lines: [line],
|
|
143
|
-
isMajor: reviewSubheadingIsMajor(
|
|
209
|
+
isMajor: reviewSubheadingIsMajor(headingText),
|
|
210
|
+
isMinor: reviewSubheadingIsMinor(headingText),
|
|
144
211
|
};
|
|
145
212
|
continue;
|
|
146
213
|
}
|
|
147
|
-
severity =
|
|
214
|
+
severity = headingText;
|
|
148
215
|
continue;
|
|
149
216
|
}
|
|
150
217
|
if (mode === 'none' && scope.primary !== null && scope.primary.test(line)) {
|
|
@@ -152,7 +219,7 @@ function reviewFindingsItems(text, scope = { primary: null, siblings: [] }) {
|
|
|
152
219
|
severity = '';
|
|
153
220
|
continue;
|
|
154
221
|
}
|
|
155
|
-
severity =
|
|
222
|
+
severity = heading.text;
|
|
156
223
|
continue;
|
|
157
224
|
}
|
|
158
225
|
if (mode === 'none') continue;
|
|
@@ -165,6 +232,7 @@ function reviewFindingsItems(text, scope = { primary: null, siblings: [] }) {
|
|
|
165
232
|
scope: mode,
|
|
166
233
|
lines: [line],
|
|
167
234
|
isMajor: /^major\b/i.test(severity) || REVIEW_MAJOR_LABEL_RE.test(title),
|
|
235
|
+
isMinor: /^minor\b/i.test(severity) || REVIEW_MINOR_LABEL_RE.test(title),
|
|
168
236
|
};
|
|
169
237
|
continue;
|
|
170
238
|
}
|
|
@@ -181,11 +249,15 @@ function reviewFindingsItems(text, scope = { primary: null, siblings: [] }) {
|
|
|
181
249
|
// 旧形态 `## 发现` 段是否有实质内容(占位词 / 子标题 / 空行不计):写在旧段而模板位置无条目时
|
|
182
250
|
// 触发迁移提示——只在旧段真有内容时给,避免空段或只写「无」的旧 REVIEW 被误报。
|
|
183
251
|
function reviewLegacyFindingsHasContent(text) {
|
|
252
|
+
// 段界与发现区解析同一来源(scanHeadings):围栏代码块里的 `## ` 不结束旧段
|
|
253
|
+
const { lines, headings } = scanHeadings(text);
|
|
254
|
+
const legacyAt = new Map(headings.filter((heading) => heading.level === 2)
|
|
255
|
+
.map((heading) => [heading.index, /^发现/.test(heading.text)]));
|
|
184
256
|
let inLegacy = false;
|
|
185
|
-
for (
|
|
186
|
-
const
|
|
187
|
-
if (
|
|
188
|
-
inLegacy =
|
|
257
|
+
for (let index = 0; index < lines.length; index += 1) {
|
|
258
|
+
const line = lines[index];
|
|
259
|
+
if (legacyAt.has(index)) {
|
|
260
|
+
inLegacy = legacyAt.get(index);
|
|
189
261
|
continue;
|
|
190
262
|
}
|
|
191
263
|
if (!inLegacy) continue;
|
|
@@ -197,17 +269,24 @@ function reviewLegacyFindingsHasContent(text) {
|
|
|
197
269
|
return false;
|
|
198
270
|
}
|
|
199
271
|
|
|
272
|
+
// 发现条目本身(排除不是发现的条目):
|
|
273
|
+
// · "无" 条目("- 无" / "无(...)")表示该级别无发现;
|
|
274
|
+
// · 四要素字段行:REVIEW 发现条目的 Symptom/Source/Consequence/Remedy 是 brooks 审查输出的字段行
|
|
275
|
+
// (带 ** 加粗),不是与条目并列的发现——不排除会把字段行当成"缺处置的发现"。精确匹配完整
|
|
276
|
+
// 标签(允许尾冒号)——"Source maps expose paths" 这类以 Source 开头的真实发现标题不得被前缀
|
|
277
|
+
// 匹配误豁免。
|
|
278
|
+
// 处置标记 / 延期裁决 / Minor 判定理由三处门禁共用这一口径:同一豁免清单三处各写一份必然分叉。
|
|
279
|
+
function reviewRealFindings(items) {
|
|
280
|
+
return items
|
|
281
|
+
.filter((item) => !/^无/.test(item.title))
|
|
282
|
+
.filter((item) => !/^(?:Symptom|Source|Consequence|Remedy)\s*:?\s*$/i.test(item.title));
|
|
283
|
+
}
|
|
284
|
+
|
|
200
285
|
// 发现区条目处置标记存在性:返回缺处置状态标记([已修]/[升级]/[转待办])的条目标题列表——结构级
|
|
201
286
|
// 校验(不做语义判断:标记存在即视为已处置)。发现项(含 Minor;无序与有序条目同口径,均不得
|
|
202
287
|
// "记录后无声消失")的处置标记以该条目自身标题/行首为准——正文引用他条标记不参与判定。
|
|
203
288
|
function reviewFindingsMissingDisposition(text, scope = { primary: null, siblings: [] }) {
|
|
204
|
-
return reviewFindingsItems(text, scope)
|
|
205
|
-
.filter((item) => !/^无/.test(item.title)) // "无" 条目豁免
|
|
206
|
-
// 四要素字段行豁免:REVIEW 发现条目的 Symptom/Source/Consequence/Remedy 是 brooks 审查输出
|
|
207
|
-
// 格式的字段行(带 ** 加粗),不是发现条目本身——不豁免会误判为"发现项缺处置标记"(执行者按
|
|
208
|
-
// 4 要素格式书写时被误 BLOCKED)。精确匹配完整标签(允许尾冒号)——"Source maps expose paths"
|
|
209
|
-
// 这类以 Source 开头的真实发现标题不得被前缀匹配误豁免(其处置校验必须照常进行)
|
|
210
|
-
.filter((item) => !/^(?:Symptom|Source|Consequence|Remedy)\s*:?\s*$/i.test(item.title))
|
|
289
|
+
return reviewRealFindings(reviewFindingsItems(text, scope))
|
|
211
290
|
.filter((item) => !REVIEW_DISPOSITION_RE.test(item.lines[0]))
|
|
212
291
|
.map((item) => item.title);
|
|
213
292
|
}
|
|
@@ -223,20 +302,29 @@ function reviewAdjudicationPointsTo(record, item) {
|
|
|
223
302
|
return core.length >= 6 && record.includes(core);
|
|
224
303
|
}
|
|
225
304
|
|
|
226
|
-
// Major
|
|
227
|
-
//
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
305
|
+
// 条目自身的严重度标签(报文里点名用):Major / Minor 之外是"未标严重度"——延期门禁对任何严重度
|
|
306
|
+
// 生效,未标严重度同样要裁决记录,报文得让执行者看清是哪一类。
|
|
307
|
+
function reviewItemSeverityLabel(item) {
|
|
308
|
+
if (item.isMajor) return 'Major';
|
|
309
|
+
if (item.isMinor) return 'Minor';
|
|
310
|
+
return '未标严重度';
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
// 延期裁决门禁:发现区任何条目(**任何严重度**,含 Minor)处置为 [转待办] 时,必须同时存在用户裁决
|
|
314
|
+
// 记录——同段(条目自身段落)或其它段落(位置不限,须与条目以空行分隔)含「用户裁决:接受延期」且
|
|
315
|
+
// 指向该条目,并由 [升级] 承接(条目自身块或裁决记录含 [升级])。任一缺失 → 返回该条目(调用方
|
|
316
|
+
// BLOCK)。只认 [已修]/[升级] 的条目直接放行:它们的处置不是
|
|
317
|
+
// 延期,没有用户决策点。条目自身的处置标记([转待办])只认该条目标题/行首(无序与有序同口径),
|
|
318
|
+
// 正文续行引用他条标记不触发本门禁;[升级] 承接可出现在条目自身块或用户裁决记录中(承接非本条处置)。
|
|
319
|
+
// 历史语义:本门禁曾只覆盖 Major——Minor 的自行延期因此长期无门槛,成为延期积压的制度口子。
|
|
320
|
+
function reviewDeferredFindingProblems(text, scope = { primary: null, siblings: [] }) {
|
|
233
321
|
const textValue = String(text);
|
|
234
|
-
const items = reviewFindingsItems(textValue, scope);
|
|
322
|
+
const items = reviewRealFindings(reviewFindingsItems(textValue, scope));
|
|
235
323
|
const paragraphs = textValue.split(/\n\s*\n/).map((p) => p.trim()).filter(Boolean);
|
|
236
324
|
const problems = [];
|
|
237
325
|
for (const item of items) {
|
|
238
326
|
const ownLine = item.lines[0];
|
|
239
|
-
if (
|
|
327
|
+
if (!/\[转待办\]/.test(ownLine)) continue;
|
|
240
328
|
const block = item.lines.join('\n');
|
|
241
329
|
const escalatedInBlock = /\[升级\]/.test(block);
|
|
242
330
|
const blockTrimmed = block.trim();
|
|
@@ -246,11 +334,24 @@ function reviewDeferredMajorProblems(text, scope = { primary: null, siblings: []
|
|
|
246
334
|
if (paragraph === blockTrimmed) return false; // 跳过条目自身段落
|
|
247
335
|
return (escalatedInBlock || /\[升级\]/.test(paragraph)) && reviewAdjudicationPointsTo(paragraph, item);
|
|
248
336
|
});
|
|
249
|
-
if (!matched) problems.push(item.title);
|
|
337
|
+
if (!matched) problems.push({ title: item.title, severity: reviewItemSeverityLabel(item) });
|
|
250
338
|
}
|
|
251
339
|
return problems;
|
|
252
340
|
}
|
|
253
341
|
|
|
342
|
+
// Minor 判定理由门禁:**每条**判为 Minor 的发现都须在条目块内自证判据——一行以「判 Minor:」开头的
|
|
343
|
+
// 一句话理由,**与处置标记无关**([已修] / [升级] / [转待办] 一律要)。理由必须落在判定发生的那一刻:
|
|
344
|
+
// 只对延期条目查,等于允许"先宽判 Minor、要延期时再补票"——Minor 判定过宽正是这条门禁要挡的失效模式
|
|
345
|
+
// (举证责任在判 Minor 的一侧,拿不准时默认 Major)。结构级判定(行首标签存在即已自证),不做语义
|
|
346
|
+
// 判断:理由写得好不好不是脚本能判的,脚本只保证"判 Minor"这个动作留下可复核的依据。未标严重度的
|
|
347
|
+
// 条目不在本门禁内(它的缺口由处置标记门禁与延期裁决门禁负责)。
|
|
348
|
+
function reviewMinorJustificationProblems(text, scope = { primary: null, siblings: [] }) {
|
|
349
|
+
return reviewRealFindings(reviewFindingsItems(text, scope))
|
|
350
|
+
.filter((item) => item.isMinor)
|
|
351
|
+
.filter((item) => !item.lines.some((line) => REVIEW_MINOR_JUSTIFICATION_RE.test(line)))
|
|
352
|
+
.map((item) => ({ title: item.title, severity: reviewItemSeverityLabel(item) }));
|
|
353
|
+
}
|
|
354
|
+
|
|
254
355
|
// 节点 entry 链:受控归位 → 归档分支校验 → 委托前并行写冲突 → 委托前工件 commit 提示 →
|
|
255
356
|
// 清窗恢复产物提示 → 任务集签名记录 → 协调者禁令 → 进入标记落盘 → 点名节点实现技能。
|
|
256
357
|
export async function runEntryGates({ protocol, node, state, file }) {
|
|
@@ -276,8 +377,8 @@ export async function runEntryGates({ protocol, node, state, file }) {
|
|
|
276
377
|
}
|
|
277
378
|
if (fixBatchRollback) {
|
|
278
379
|
const sourceNode = state.currentNode;
|
|
279
|
-
// 轮次计数与阈值/授权判定全部走共享 helper:分支②不计数;第 4
|
|
280
|
-
// (此处尚未写盘,满足不写 currentNode
|
|
380
|
+
// 轮次计数与阈值/授权判定全部走共享 helper:分支②不计数;第 4 轮先 BLOCK
|
|
381
|
+
// (此处尚未写盘,满足不写 currentNode)。
|
|
281
382
|
const rollbackRound = applyFixRollbackRound({ state, sourceNode, decision: fixBatchDecision });
|
|
282
383
|
if (rollbackRound.blocked) {
|
|
283
384
|
console.error(rollbackRound.blockedMessage);
|
|
@@ -357,7 +458,8 @@ export async function runEntryGates({ protocol, node, state, file }) {
|
|
|
357
458
|
const entryExecutionMode = state.executionMode ?? 'subagent';
|
|
358
459
|
if (EXECUTE_FAMILY_NODE_IDS.has(node.id)) {
|
|
359
460
|
if (!(entryExecutionMode === 'direct' && node.id === 'execute')) {
|
|
360
|
-
|
|
461
|
+
// 与 next 的 COORDINATOR 行同源(COORDINATOR_NOTICE):两处输出逐字相同。
|
|
462
|
+
console.log('COORDINATOR: ' + COORDINATOR_NOTICE);
|
|
361
463
|
}
|
|
362
464
|
}
|
|
363
465
|
// enter 证据——entry 记录节点进入标记(enteredNodes),exit 检测未 entry(防跳过 entry 无痕)
|
|
@@ -382,11 +484,30 @@ export async function runEntryGates({ protocol, node, state, file }) {
|
|
|
382
484
|
}
|
|
383
485
|
|
|
384
486
|
// 出口前置:本节点 evidence 必须在场(缺失时给出补证据指引)。返回该 evidence。
|
|
385
|
-
|
|
487
|
+
// 异步是为把「缺了什么、下一步跑什么」交给**同一构造函数** evidenceRecoveryBlock(它要读技能加载
|
|
488
|
+
// 声明标记)——同一条缺证据的恢复路径只允许有一份编排,两处各拼一份必然分叉。
|
|
489
|
+
export async function requireNodeEvidence({ node, state }) {
|
|
386
490
|
const evidence = evidenceFor(state, node.id);
|
|
387
491
|
if (!evidence) {
|
|
388
492
|
console.error('BLOCKED: missing evidence for Node ' + node.id + '.');
|
|
389
|
-
|
|
493
|
+
// 恢复段给**可照抄的命令**,且与缺 Output Schema 字段那条**同一构造函数** evidenceRecoveryBlock:
|
|
494
|
+
// 散文式的「用 workflow-state.mjs record …」没有可复制的路径形态、也不带协议上下文,照抄的人得
|
|
495
|
+
// 自己从散文里反推命令、再自己补协议。同一件事拼两份的实证:这条路径曾只给 record,而 record 有
|
|
496
|
+
// 自己的技能加载声明门——照抄第一步就被拦下,第二步的命令还落在另一条报文里(两次往返)。
|
|
497
|
+
// 先点名缺的是这个节点的证据对象(lead),命令与步骤编排归构造函数;状态漂移的两条出路与禁令
|
|
498
|
+
// 照旧保留。
|
|
499
|
+
const recovery = await evidenceRecoveryBlock({
|
|
500
|
+
node,
|
|
501
|
+
state,
|
|
502
|
+
lead: '该节点已完成但缺证据记录(evidence.' + node.id + ' 不在场)',
|
|
503
|
+
});
|
|
504
|
+
// 状态漂移的那一句按目录在哪分两种说法(唯一分叉在 guard-routing 的 recoveryActionText):
|
|
505
|
+
// 目录已搬进归档时 advance / select 都走不通,只给可执行的那一步(移回活动位置)。
|
|
506
|
+
console.error([
|
|
507
|
+
...recovery,
|
|
508
|
+
' ' + recoveryActionText(state.activeChange,
|
|
509
|
+
'状态漂移 → workflow-state.mjs advance(强制推进)或 select(切换 change);禁止手改 state 机器字段'),
|
|
510
|
+
].join('\n'));
|
|
390
511
|
process.exit(1);
|
|
391
512
|
}
|
|
392
513
|
return evidence;
|
|
@@ -415,8 +536,14 @@ export async function runExitDriftGate({ protocol, node, state, evidence }) {
|
|
|
415
536
|
}
|
|
416
537
|
if (!tolerable) {
|
|
417
538
|
console.error('BLOCKED: currentNode is ' + String(state.currentNode) + ', cannot exit ' + node.id + '.');
|
|
418
|
-
|
|
419
|
-
|
|
539
|
+
// 恢复动作按目录在哪分两种说法(唯一分叉在 guard-routing 的 recoveryActionText):活动态给
|
|
540
|
+
// advance / select;目录已搬进归档时这两步都走不通,只给可执行的那一步。归档态下「提示」行不再
|
|
541
|
+
// 提 advance/select——那正是它上面一行已经不成立的东西。
|
|
542
|
+
const archivedHint = archivedChangeLocation(state.activeChange) !== null;
|
|
543
|
+
console.error('恢复: ' + recoveryActionText(state.activeChange,
|
|
544
|
+
'若节点状态漂移/卡死 → 用 workflow-state.mjs advance(强制推进,确认节点实际已完成后再用)或 select(切换 change);禁止手改 state 机器字段'));
|
|
545
|
+
console.error('提示: 若 currentNode 已漂移到文件推导位置且本节点证据/产物齐(执行者确认本节点实际已完成)→ 可用容错 exit ' + node.id + ' --apply 补齐欠账(漂移容忍路径'
|
|
546
|
+
+ (archivedHint ? '' : ',不再只有不可行的 advance/select 指引') + ');漂移但证据/产物不齐则不适用');
|
|
420
547
|
process.exit(1);
|
|
421
548
|
}
|
|
422
549
|
}
|
|
@@ -425,7 +552,7 @@ export async function runExitDriftGate({ protocol, node, state, evidence }) {
|
|
|
425
552
|
// done 但本批 execute 家族生命周期未闭合(本 change 最新家族出口签名 ≠ 当前任务集签名)时,直接
|
|
426
553
|
// exit 源节点收场会静默跳过 execute 家族生命周期与四类出口(缺陷形态)。排在 entry 证据门之前:
|
|
427
554
|
// 该越界路径给 Fix 恢复指引,避免通用 entry 提示覆盖更具体的归位路径。复用共享回退谓词判定:
|
|
428
|
-
//
|
|
555
|
+
// 命中即 BLOCKED 并给恢复指引(单轨,无渐进放行)。
|
|
429
556
|
export async function runFixBatchExitGate({ protocol, node, state }) {
|
|
430
557
|
if ((node.id !== 'review' && node.id !== 'verify') || !state.activeChange) return;
|
|
431
558
|
const fixBatchUnclosed = await resolveFixRollbackState({
|
|
@@ -436,27 +563,21 @@ export async function runFixBatchExitGate({ protocol, node, state }) {
|
|
|
436
563
|
currentNode: node.id,
|
|
437
564
|
history: state.history,
|
|
438
565
|
});
|
|
439
|
-
if (fixBatchUnclosed
|
|
566
|
+
if (fixBatchUnclosed) {
|
|
440
567
|
console.error('BLOCKED: 存在未归位/未跑出口的 Fix 批次——' + node.id + ' 驻留且 TASK.md 存在 pending 修复任务,或修复任务已 done 但本批 execute / subagent-execute 生命周期未闭合(最近一次 execute 家族 exit 后任务集仍有变更),不能直接 exit ' + node.id + ' 收场(会静默跳过 execute 家族生命周期与四类出口)');
|
|
441
568
|
console.error('恢复: 运行 workflow-state.mjs next 或 workflow-guard.mjs entry execute / entry subagent-execute 受控归位 execute 家族节点 → 在 execute 家族生命周期内完成修复任务 → record/exit 该节点 --apply 跑完四类出口并回源节点 ' + node.id + ' → 再 exit ' + node.id + ' --apply');
|
|
442
569
|
process.exit(1);
|
|
443
570
|
}
|
|
444
|
-
if (fixBatchUnclosed) {
|
|
445
|
-
console.error('FIX-BATCH WARN: 存在未归位/未跑出口的 Fix 批次——' + node.id + ' 驻留且 TASK.md 存在 pending 修复任务,或修复任务已 done 但本批 execute / subagent-execute 生命周期未闭合,直接 exit ' + node.id + ' 会跳过 execute 家族出口门禁(旧 change 渐进不阻断;建议 next/entry execute 家族节点归位跑完出口后回源节点 exit)');
|
|
446
|
-
}
|
|
447
571
|
}
|
|
448
572
|
|
|
449
|
-
// enter 证据检测——未 entry 直接 exit
|
|
573
|
+
// enter 证据检测——未 entry 直接 exit:一律 BLOCKED。
|
|
450
574
|
// 跳过 entry 会漏掉进入检查(协调者禁令 / 委托前工件 commit 提示 / PROGRESS 提示 / 签名记录)。
|
|
451
575
|
export function runEntryRecordGate({ node, state }) {
|
|
452
|
-
if (
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
}
|
|
458
|
-
} else if (Array.isArray(state.enteredNodes) && !state.enteredNodes.includes(node.id)) {
|
|
459
|
-
console.error('ENTER WARN: 节点 ' + node.id + ' 未执行 entry 直接 exit——entry 的进入检查(协调者禁令/C4 委托前检查/签名记录)被跳过,请先 entry 该节点再 exit(旧 change 渐进不阻断)');
|
|
576
|
+
if (!Array.isArray(state.enteredNodes) || !state.enteredNodes.includes(node.id)) {
|
|
577
|
+
console.error('BLOCKED: 节点 ' + node.id + ' 未执行 entry 直接 exit——先 entry(进入检查/协调者禁令/签名记录)');
|
|
578
|
+
console.error('恢复: 先运行 workflow-guard.mjs entry ' + node.id + ' 再重试 exit;'
|
|
579
|
+
+ recoveryActionText(state.activeChange, '状态漂移 → advance/select'));
|
|
580
|
+
process.exit(1);
|
|
460
581
|
}
|
|
461
582
|
}
|
|
462
583
|
|
|
@@ -515,11 +636,8 @@ export async function runContextAppendGate({ node, state }) {
|
|
|
515
636
|
if (content === null) return;
|
|
516
637
|
const m = content.match(/^## (术语|已锁决策|决策|术语表)[((][^\n]*(?:追加|update)[^\n]*$/im);
|
|
517
638
|
if (m) {
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
process.exit(1);
|
|
521
|
-
}
|
|
522
|
-
console.error('WARN: CONTEXT.md 检测到孤立追加段(术语/决策应插入既有结构段):' + m[0].replace(/^##\s*/, '').trim());
|
|
639
|
+
console.error('BLOCKED: CONTEXT.md 检测到孤立追加段(内容须插入既有结构段);恢复: 把内容移入术语表/已锁决策段');
|
|
640
|
+
process.exit(1);
|
|
523
641
|
}
|
|
524
642
|
const problems = await contextTemplateProblems(state, content);
|
|
525
643
|
if (problems === null) {
|
|
@@ -529,23 +647,19 @@ export async function runContextAppendGate({ node, state }) {
|
|
|
529
647
|
return;
|
|
530
648
|
}
|
|
531
649
|
if (problems.length === 0) return;
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
process.exit(1);
|
|
537
|
-
}
|
|
538
|
-
console.error('WARN: CONTEXT.md 有 ' + problems.length + ' 处与模板段形不符(旧 change 渐进不阻断): '
|
|
539
|
-
+ problems.join('、'));
|
|
650
|
+
console.error('BLOCKED: CONTEXT.md 有 ' + problems.length + ' 处与模板段形不符(项目上下文须按模板段形书写):');
|
|
651
|
+
for (const problem of problems) console.error(' - ' + problem);
|
|
652
|
+
console.error('恢复: 按 flow-kit/templates/CONTEXT.md 补齐段标题(未发现的写「未发现」;前端子段按条件段裁剪)后重试 exit open');
|
|
653
|
+
process.exit(1);
|
|
540
654
|
}
|
|
541
655
|
|
|
542
656
|
// LESSONS.md 结构检测(每条判据的作用面逐个交代):
|
|
543
|
-
// ① 旧形态 `## L-NNN`(条目写成二级标题)——open / verify / archive 三处出口都拦(AC-17
|
|
544
|
-
//
|
|
657
|
+
// ① 旧形态 `## L-NNN`(条目写成二级标题)——open / verify / archive 三处出口都拦(AC-17),
|
|
658
|
+
// BLOCKED 并逐行给「文件:行号 → 改法」;
|
|
545
659
|
// ② 条目区外条目(条目区锚点用段名归一,容忍模板标题的括号后缀,如 `## 条目区(夹具)`)与
|
|
546
660
|
// ③ 同段内编号递增——两条保持既有作用面(verify / archive),不随 ① 扩到 open;
|
|
547
|
-
// ④ `### L-NNN` 条目的字段键(C20)——键集合从 LESSONS
|
|
548
|
-
//
|
|
661
|
+
// ④ `### L-NNN` 条目的字段键(C20)——键集合从 LESSONS 模板「条目格式」段的书写样例派生;
|
|
662
|
+
// 缺任一键 BLOCKED(迁移形态 / 首发指向别的 change 的旧条目仍只告警);
|
|
549
663
|
// ⑤ archive 出口核对 evidence.lessonsNomination:扫描份数 = 该 change 内 SUMMARY 份数、提名编号在
|
|
550
664
|
// LESSONS 中真实存在、无提名时理由非空——归档提名留痕且可核对。
|
|
551
665
|
const LESSONS_LEGACY_ENTRY_RE = /^##\s+(L-\d+)\b/u;
|
|
@@ -568,22 +682,24 @@ function lessonsLegacyEntries(content) {
|
|
|
568
682
|
return hits;
|
|
569
683
|
}
|
|
570
684
|
|
|
571
|
-
// 该 change 的 SUMMARY 份数(C6
|
|
572
|
-
//
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
|
|
685
|
+
// 该 change 的 SUMMARY 份数(C6)。目录定位走**唯一**位置解析器 resolveChangeDir(活动目录优先 →
|
|
686
|
+
// 归档 <日期>-<change-id>;同名多份按日期——排除早于该 change createdAt 的候选、取最新、排不出就停
|
|
687
|
+
// 并列候选),本函数只保留「份数规则」:数解析到的目录下 *-SUMMARY.md。此前这里自带一份「活动优先 +
|
|
688
|
+
// 归档首个命中」的定位:同后缀的别的 change 归档目录会被算进来(份数对账拿别人的归档作证),
|
|
689
|
+
// readdir 顺序还会把本 change 的目录挤掉。
|
|
690
|
+
// 返回 { count, resolution }:count === null = 无从核对(目录缺失 / 多候选判不出),不当作 0 份——
|
|
691
|
+
// 报文按 resolution 的成因分开说(同一句话不得在这里再写一份)。
|
|
692
|
+
async function changeSummaryCount(state) {
|
|
693
|
+
const resolution = await resolveChangeDir({
|
|
694
|
+
root: runRoot,
|
|
695
|
+
changeName: state.activeChange,
|
|
696
|
+
createdAt: state.createdAt,
|
|
697
|
+
});
|
|
698
|
+
if (resolution.status !== 'active' && resolution.status !== 'archived') {
|
|
699
|
+
return { count: null, resolution };
|
|
583
700
|
}
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
return files.filter((name) => name.endsWith('-SUMMARY.md')).length;
|
|
701
|
+
const files = await fs.readdir(resolution.dir).catch(() => []);
|
|
702
|
+
return { count: files.filter((name) => name.endsWith('-SUMMARY.md')).length, resolution };
|
|
587
703
|
}
|
|
588
704
|
|
|
589
705
|
// LESSONS 里已登记的条目编号(旧形态与迁移后的新形态都算「编号存在」——形态由 ① 单独校验,
|
|
@@ -598,15 +714,20 @@ async function lessonsEntryNumbers() {
|
|
|
598
714
|
}
|
|
599
715
|
|
|
600
716
|
// 归档提名核对(结构级):evidence.lessonsNomination = { scanned, nominated[], reasonIfNone }。
|
|
717
|
+
// 返回 { problems, scanned }:scanned = 本 change 的 SUMMARY 份数(解析不出为 null),恢复命令据此
|
|
718
|
+
// 把份数填成可照抄的具体值——让执行者手填一个自己也没数过的数字,等于把「照抄即推进」变成猜谜。
|
|
601
719
|
async function lessonsNominationProblems(state) {
|
|
720
|
+
const { count: actual, resolution } = await changeSummaryCount(state);
|
|
602
721
|
const nomination = evidenceFor(state, 'archive')?.lessonsNomination;
|
|
603
722
|
if (!nomination || typeof nomination !== 'object' || Array.isArray(nomination)) {
|
|
604
|
-
return ['缺 evidence.lessonsNomination(应记录 { scanned, nominated[], reasonIfNone })'];
|
|
723
|
+
return { problems: ['缺 evidence.lessonsNomination(应记录 { scanned, nominated[], reasonIfNone })'], scanned: actual };
|
|
605
724
|
}
|
|
606
725
|
const problems = [];
|
|
607
|
-
const actual = await changeSummaryCount(state.activeChange);
|
|
608
726
|
if (actual === null) {
|
|
609
|
-
|
|
727
|
+
// 份数无从核对的两种成因分开说(多候选那一句与状态族同一措辞:BLOCKED 前缀在列表里多余,去掉)。
|
|
728
|
+
problems.push(resolution.status === 'ambiguous'
|
|
729
|
+
? changeLocationFailureMessage(state.activeChange, resolution).replace(/^BLOCKED: /u, '')
|
|
730
|
+
: '该 change 的工件目录缺失(.specs/<change>/ 与 .specs/archive/*-<change>/ 都不存在),无从核对扫描份数');
|
|
610
731
|
} else if (nomination.scanned !== actual) {
|
|
611
732
|
problems.push('扫描份数 ' + JSON.stringify(nomination.scanned ?? null)
|
|
612
733
|
+ ' ≠ 该 change 内 *-SUMMARY.md 份数 ' + actual);
|
|
@@ -628,60 +749,56 @@ async function lessonsNominationProblems(state) {
|
|
|
628
749
|
}
|
|
629
750
|
}
|
|
630
751
|
}
|
|
631
|
-
return problems;
|
|
752
|
+
return { problems, scanned: actual };
|
|
632
753
|
}
|
|
633
754
|
|
|
634
755
|
// ① 旧形态条目(`## L-NNN`):open / verify / archive 三处出口都拦(AC-17)——报文逐行给「文件:
|
|
635
|
-
// 行号 → 改法」,迁移口径 = 改级 + 移入条目区 +
|
|
756
|
+
// 行号 → 改法」,迁移口径 = 改级 + 移入条目区 + 按编号排序。命中即 BLOCKED。
|
|
636
757
|
function checkLessonsEntryForm({ content, node, state }) {
|
|
637
758
|
const legacyEntries = lessonsLegacyEntries(content);
|
|
638
759
|
if (legacyEntries.length === 0) return;
|
|
639
|
-
|
|
640
|
-
|
|
641
|
-
|
|
642
|
-
console.error(' - .specs/LESSONS.md:' + entry.line + ' → 改成 "### ' + entry.id + '"(并移入 ## 条目区,按编号升序)');
|
|
643
|
-
}
|
|
644
|
-
console.error('恢复: 逐行按上述改法迁移(改级 + 移入条目区 + 按编号排序)后重试 exit ' + node.id);
|
|
645
|
-
process.exit(1);
|
|
760
|
+
console.error('BLOCKED: LESSONS.md 有 ' + legacyEntries.length + ' 条旧形态条目(## L-NNN)——条目须写成三级标题并置于条目区:');
|
|
761
|
+
for (const entry of legacyEntries) {
|
|
762
|
+
console.error(' - .specs/LESSONS.md:' + entry.line + ' → 改成 "### ' + entry.id + '"(并移入 ## 条目区,按编号升序)');
|
|
646
763
|
}
|
|
647
|
-
console.error('
|
|
648
|
-
|
|
764
|
+
console.error('恢复: 逐行按上述改法迁移(改级 + 移入条目区 + 按编号排序)后重试 exit ' + node.id);
|
|
765
|
+
process.exit(1);
|
|
649
766
|
}
|
|
650
767
|
|
|
651
768
|
// ② 条目区外条目 + ③ 同段内编号递增:既有结构判据保持原作用面(verify / archive)——open 出口只
|
|
652
769
|
// 新增 ① 的旧形态迁移判据,不顺手把这两条扩张到 open(判据作用面按 AC 逐个交代)。
|
|
770
|
+
// 段界与标题识别都走 lib/section-body.mjs 的围栏感知扫描(scanHeadings):段标题与条目标题一次
|
|
771
|
+
// 扫描给出**行下标**,条目归属与「同段」比较都在同一套下标上做。旧实现各写一份——条目用字符
|
|
772
|
+
// 偏移的正则 matchAll、段用任意 `^##` 行匹配——围栏示例里的 `## ` 会把一段切成两段(乱序因此
|
|
773
|
+
// 被静默放过),围栏示例里的 `### L-NNN` 又会被当成真条目(误报)。
|
|
653
774
|
function checkLessonsZoneAndOrder({ content, state }) {
|
|
775
|
+
const { headings: scanned } = scanHeadings(content);
|
|
776
|
+
const zonePatterns = LESSONS_ENTRY_ZONE_NAMES.map((name) => headingPattern(name, 2));
|
|
654
777
|
// 条目区锚点(段名归一:条目区 / 活跃条目 / 已解决条目,容忍括号后缀)——取最早条目段
|
|
655
|
-
const
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
|
|
778
|
+
const zoneHeading = scanned.find((heading) => heading.level === 2
|
|
779
|
+
&& zonePatterns.some((pattern) => pattern.test(heading.line)));
|
|
780
|
+
const zoneIndex = zoneHeading === undefined ? -1 : zoneHeading.index;
|
|
781
|
+
const entryHeadings = scanned
|
|
782
|
+
.filter((heading) => heading.level === 3)
|
|
783
|
+
.map((heading) => ({ index: heading.index, number: (heading.text.match(/^L-(\d+)/u) ?? [])[1] }))
|
|
784
|
+
.filter((entry) => entry.number !== undefined);
|
|
785
|
+
const headings = entryHeadings;
|
|
662
786
|
if (zoneIndex !== -1) {
|
|
663
787
|
const outside = headings.some(h => h.index < zoneIndex);
|
|
664
788
|
if (outside) {
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
process.exit(1);
|
|
668
|
-
}
|
|
669
|
-
// 诊断信息附带 zoneIndex/条目位置——偶发 WARN 排查时可直接定位(文件时序/编码差异兜底)
|
|
670
|
-
console.error('WARN: LESSONS.md 有条目在条目区外(zoneIndex=' + zoneIndex + ', 条目数=' + headings.length + ', 区外条目: ' + headings.filter(h => h.index < zoneIndex).map(h => 'L-' + h[1]).join(',') + ')');
|
|
789
|
+
console.error('BLOCKED: LESSONS.md 有条目在条目区外(条目须插入条目区);恢复: 移入条目区');
|
|
790
|
+
process.exit(1);
|
|
671
791
|
}
|
|
672
792
|
}
|
|
673
|
-
const nums = headings.map(h => parseInt(h
|
|
674
|
-
//
|
|
675
|
-
|
|
793
|
+
const nums = headings.map(h => parseInt(h.number, 10));
|
|
794
|
+
// 分段检测:按围栏外的 ## 标题分段,仅同段内比较编号递增(多段 LESSONS 如「活跃条目/已解决条目」
|
|
795
|
+
// 编号体系可独立)——围栏示例里的 `## ` 不开新段。
|
|
796
|
+
const sectionStarts = scanned.filter((heading) => heading.level === 2).map((heading) => heading.index);
|
|
676
797
|
for (let i = 1; i < nums.length; i++) {
|
|
677
798
|
const sameSection = !sectionStarts.some(s => s > headings[i - 1].index && s < headings[i].index);
|
|
678
799
|
if (sameSection && nums[i] <= nums[i - 1]) {
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
process.exit(1);
|
|
682
|
-
}
|
|
683
|
-
console.error('WARN: LESSONS.md 条目编号乱序(L-' + String(nums[i]).padStart(3, '0') + ' 应按序插入条目区)');
|
|
684
|
-
break;
|
|
800
|
+
console.error('BLOCKED: LESSONS.md 条目编号乱序(L-' + String(nums[i]).padStart(3, '0') + ' 应按编号顺序插入条目区);恢复: 按 L-NNN 顺序插入');
|
|
801
|
+
process.exit(1);
|
|
685
802
|
}
|
|
686
803
|
}
|
|
687
804
|
}
|
|
@@ -698,16 +815,18 @@ async function lessonsEntryFieldKeys() {
|
|
|
698
815
|
// 字段键无从派生 → C20 静默退化为「未校验」。
|
|
699
816
|
let text;
|
|
700
817
|
try { text = await fs.readFile(path.join(runRoot, skeleton.file), 'utf8'); } catch { return null; }
|
|
818
|
+
// 段界由 lib/section-body.mjs 单点决定(围栏代码块里的 `## ` 不结束段体——旧实现先判标题再同步
|
|
819
|
+
// 围栏,示例里出现二级标题就会把字段样例截断)。本判据自己的语义是「只取围栏里的书写样例行」,
|
|
820
|
+
// 故只需围栏行判定(isFenceLine,与单源同一份语法)。
|
|
821
|
+
const body = sectionBody(text, formatSection.pattern, { level: 2, endOnSeparator: false });
|
|
822
|
+
if (body === null) return null;
|
|
701
823
|
const keys = [];
|
|
702
|
-
let inSection = false;
|
|
703
824
|
let inFence = false;
|
|
704
|
-
for (const line of
|
|
705
|
-
if (
|
|
706
|
-
|
|
825
|
+
for (const line of body.split('\n')) {
|
|
826
|
+
if (isFenceLine(line)) {
|
|
827
|
+
inFence = !inFence;
|
|
707
828
|
continue;
|
|
708
829
|
}
|
|
709
|
-
if (/^##\s+/u.test(line)) break;
|
|
710
|
-
if (/^\s*```/u.test(line)) { inFence = !inFence; continue; }
|
|
711
830
|
if (!inFence) continue;
|
|
712
831
|
const matched = line.match(LESSONS_FIELD_LINE_RE);
|
|
713
832
|
if (matched) keys.push(matched[1].trim());
|
|
@@ -722,7 +841,7 @@ function lessonsEntryBlocks(content) {
|
|
|
722
841
|
let current = null;
|
|
723
842
|
let inFence = false;
|
|
724
843
|
String(content).replace(/^\uFEFF/u, '').replace(/\r\n?/gu, '\n').split('\n').forEach((line, index) => {
|
|
725
|
-
if (
|
|
844
|
+
if (isFenceLine(line)) {
|
|
726
845
|
inFence = !inFence;
|
|
727
846
|
if (current) current.lines.push(line);
|
|
728
847
|
return;
|
|
@@ -742,8 +861,8 @@ function lessonsEntryBlocks(content) {
|
|
|
742
861
|
return blocks;
|
|
743
862
|
}
|
|
744
863
|
|
|
745
|
-
// 旧条目判定(结构级,不做语义判断):非模板标题形态(迁移冒号形态 /
|
|
746
|
-
//
|
|
864
|
+
// 旧条目判定(结构级,不做语义判断):非模板标题形态(迁移冒号形态 / 裸标题等历史写法——迁移期
|
|
865
|
+
// 保留原标题的条目同样算旧)或「首发」键指向别的 change。其余缺字段条目按「新条目」处置——
|
|
747
866
|
// 新条目只有标题与正文(无任何字段键)时同样落在 BLOCK 分支(M-5 的失效模式)。
|
|
748
867
|
function lessonsEntryIsOld(block, originKey, state) {
|
|
749
868
|
if (!LESSONS_TEMPLATE_HEADING_RE.test(block.heading)) return true;
|
|
@@ -758,7 +877,7 @@ function lessonsEntryIsOld(block, originKey, state) {
|
|
|
758
877
|
return false;
|
|
759
878
|
}
|
|
760
879
|
|
|
761
|
-
// ④ 字段键存在性(C20
|
|
880
|
+
// ④ 字段键存在性(C20):条目缺任一键 → BLOCKED;迁移形态 / 首发指向别的 change 的旧条目只告警。
|
|
762
881
|
function checkLessonsEntryFields({ content, node, state, keys }) {
|
|
763
882
|
const originKey = keys.find((key) => key.includes('首发')) ?? null;
|
|
764
883
|
const blocked = [];
|
|
@@ -783,30 +902,44 @@ function checkLessonsEntryFields({ content, node, state, keys }) {
|
|
|
783
902
|
if (blocked.length === 0) return;
|
|
784
903
|
const guide = '恢复: 按 flow-kit/templates/LESSONS.md「条目格式」段补全字段键(' + keys.join(' / ')
|
|
785
904
|
+ ';正文块不强制)后重试 exit ' + node.id;
|
|
786
|
-
|
|
787
|
-
console.error('LESSONS WARN: LESSONS.md 有 ' + blocked.length + ' 条条目缺字段键(旧 change 渐进不阻断): '
|
|
788
|
-
+ blocked.map(describe).join('、') + ';' + guide);
|
|
789
|
-
return;
|
|
790
|
-
}
|
|
791
|
-
console.error('BLOCKED: LESSONS.md 有 ' + blocked.length + ' 条新条目缺字段键(新 change 强制新条目按模板条目格式书写):');
|
|
905
|
+
console.error('BLOCKED: LESSONS.md 有 ' + blocked.length + ' 条条目缺字段键(条目须按模板条目格式书写):');
|
|
792
906
|
for (const entry of blocked) console.error(' - ' + describe(entry));
|
|
793
907
|
console.error(guide);
|
|
794
908
|
process.exit(1);
|
|
795
909
|
}
|
|
796
910
|
|
|
797
911
|
// ⑤ archive 出口的归档提名核对(对账 SUMMARY 份数 / 提名编号存在性 / 无提名理由)——归档提名
|
|
798
|
-
//
|
|
912
|
+
// 留痕且可核对;不成立即 BLOCKED。
|
|
799
913
|
async function checkLessonsNomination({ state }) {
|
|
800
|
-
|
|
914
|
+
// 归档目录名不合规(AC-6)先于「工件目录缺失」失败:真实归档路径下活动目录已整份搬进 archive,
|
|
915
|
+
// 名字不是 <YYYY-MM-DD>-<change-id> 时定位器解析不到它——这正是「份数无从核对」的一种成因,而
|
|
916
|
+
// 那句只说「两处都没有」,把盘上其实在场的目录报成缺失,还让执行者去补一件存在的东西。报文改用
|
|
917
|
+
// 唯一的 archiveDirNameNotice(期望格式 + 实际名字 + 可照抄的改名命令,与出口产物门 / 结构化预检
|
|
918
|
+
// 同一句措辞,不另写判据也不另写措辞)。
|
|
919
|
+
const archiveNameProblems = archiveDirNameNotice(state.activeChange, 'archive');
|
|
920
|
+
if (archiveNameProblems.length > 0) {
|
|
921
|
+
for (const line of archiveNameProblems) console.error(line);
|
|
922
|
+
process.exit(1);
|
|
923
|
+
}
|
|
924
|
+
const { problems, scanned } = await lessonsNominationProblems(state);
|
|
801
925
|
if (problems.length === 0) return;
|
|
802
|
-
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
|
|
926
|
+
console.error('BLOCKED: archive 出口的 evidence.lessonsNomination 不成立(' + problems.length + ' 项):');
|
|
927
|
+
for (const problem of problems) console.error(' - ' + problem);
|
|
928
|
+
if (typeof scanned !== 'number') {
|
|
929
|
+
// 份数无从核对(目录缺失 / 多候选)时不给命令:打印一个猜出来的份数只会让 record 落一份错证据。
|
|
930
|
+
console.error('恢复: 先按上面的问题把该 change 的工件目录放到可解析的位置,再重试 exit archive');
|
|
807
931
|
process.exit(1);
|
|
808
932
|
}
|
|
809
|
-
|
|
933
|
+
// 恢复命令走唯一的命令装配(state-explain 的 scriptCommand:平台化脚本路径 + 协议上下文):
|
|
934
|
+
// 裸脚本名的旧形态照抄是 command not found,等于没给命令。scanned 用本门已经算出的事实填好,
|
|
935
|
+
// 照抄即可推进(nominated 按本轮实际提名改,无提名保留 [] 并把 reasonIfNone 写成理由)。
|
|
936
|
+
console.error('恢复: 照抄下面的命令补齐 evidence.lessonsNomination 后重试 exit archive'
|
|
937
|
+
+ '(nominated 填本轮实际提名的编号,无提名保留 [] 并把 reasonIfNone 写成理由):');
|
|
938
|
+
console.error(' ' + nodeRecordCommand('archive', {
|
|
939
|
+
summary: '<归档摘要>',
|
|
940
|
+
lessonsNomination: { scanned, nominated: [], reasonIfNone: '<无提名时的理由>' },
|
|
941
|
+
}));
|
|
942
|
+
process.exit(1);
|
|
810
943
|
}
|
|
811
944
|
|
|
812
945
|
export async function runLessonsZoneGate({ node, state }) {
|
|
@@ -839,12 +972,8 @@ export async function runArchiveLogOrderGate({ node, state }) {
|
|
|
839
972
|
const dates = [...content.matchAll(/^- `?\[(\d{4}-\d{2}-\d{2})\]/gm)].map(m => m[1]);
|
|
840
973
|
for (let i = 1; i < dates.length; i++) {
|
|
841
974
|
if (dates[i] > dates[i - 1]) {
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
process.exit(1);
|
|
845
|
-
}
|
|
846
|
-
console.error('WARN: STATE.md 决策日志非倒序(新决策应插入顶部)');
|
|
847
|
-
break;
|
|
975
|
+
console.error('BLOCKED: STATE.md 决策日志非倒序(决策须顶部插入);恢复: 顶部插入新决策');
|
|
976
|
+
process.exit(1);
|
|
848
977
|
}
|
|
849
978
|
}
|
|
850
979
|
} catch {}
|
|
@@ -854,12 +983,8 @@ export async function runArchiveLogOrderGate({ node, state }) {
|
|
|
854
983
|
const dates = [...content.matchAll(/^\| (\d{4}-\d{2}-\d{2}) \|/gm)].map(m => m[1]);
|
|
855
984
|
for (let i = 1; i < dates.length; i++) {
|
|
856
985
|
if (dates[i] > dates[i - 1]) {
|
|
857
|
-
|
|
858
|
-
|
|
859
|
-
process.exit(1);
|
|
860
|
-
}
|
|
861
|
-
console.error('WARN: CHANGELOG.md 表格日期非倒序(新条目应插入表格顶部)');
|
|
862
|
-
break;
|
|
986
|
+
console.error('BLOCKED: CHANGELOG.md 表格日期非倒序(新条目须插入表格顶部);恢复: 表格顶部插入新条目');
|
|
987
|
+
process.exit(1);
|
|
863
988
|
}
|
|
864
989
|
}
|
|
865
990
|
// 归档收尾登记兜底(WARN 渐进,新旧一致)——CHANGELOG 未含本 change 标识(change-id)→ 提示
|
|
@@ -983,6 +1108,28 @@ export async function runDesignDecisionListGate({ node, state }) {
|
|
|
983
1108
|
} catch {}
|
|
984
1109
|
}
|
|
985
1110
|
|
|
1111
|
+
// 伪并行候选集(纯判定:无 console / 无 process.exit / 无写盘):标记为并行、尚未开始、且 write_files
|
|
1112
|
+
// 全部落在测试面的任务 id。这类任务很可能隐式依赖某个实现类并行任务的产出(测试 import 尚未存在的
|
|
1113
|
+
// 符号),多趟路由下委托后测试会失败;而「纯测试基础设施改动」也可能合法全测试面,故调用方只 WARN
|
|
1114
|
+
// 不阻断。判据与输出分离:本函数只回答「哪些任务看起来是伪并行」,分级与报文留在调用方。
|
|
1115
|
+
export function collectTestOnlyParallelIds({ taskContent = '', blocks = [] } = {}) {
|
|
1116
|
+
// 写面元素(键 = 任务 id)取 lib/lessons-hits.mjs 的唯一提取,条目边界取同一模块的 writeFilesEntries:
|
|
1117
|
+
// 同一份写面在这里与 7 字段门、task-graph 的路径解析被切成同一组条目(元素名大小写在三处同口径)。
|
|
1118
|
+
const writeFaces = taskWriteFilesById(taskContent);
|
|
1119
|
+
const ids = [];
|
|
1120
|
+
for (const block of blocks) {
|
|
1121
|
+
const attrs = taskOpeningAttrs(block);
|
|
1122
|
+
if (!attrs || !attrs.parallel || attrs.status !== 'pending') continue;
|
|
1123
|
+
const element = writeFaces.get(attrs.id);
|
|
1124
|
+
if (element === undefined) continue;
|
|
1125
|
+
const filePaths = writeFilesEntries(element);
|
|
1126
|
+
if (filePaths.length === 0) continue;
|
|
1127
|
+
const prodFiles = filePaths.filter(f => !/(?:^|[\/\\])(?:__tests__\/|test_|tests?\/)|\.(?:test|spec)\.(?:mjs|js|jsx|ts|tsx|cjs)$/.test(f));
|
|
1128
|
+
if (prodFiles.length === 0) ids.push(attrs.id || 'unknown');
|
|
1129
|
+
}
|
|
1130
|
+
return ids;
|
|
1131
|
+
}
|
|
1132
|
+
|
|
986
1133
|
// plan exit 校验 TASK 含 task 块和 verify 字段 + 依赖图/波次散文/伪并行/写写与读写冲突检测
|
|
987
1134
|
export async function runPlanExitGate({ node, state }) {
|
|
988
1135
|
if (node.id !== 'plan' || !state.activeChange) return;
|
|
@@ -1007,15 +1154,13 @@ export async function runPlanExitGate({ node, state }) {
|
|
|
1007
1154
|
}
|
|
1008
1155
|
// 波次散文一致性检测(WARN 渐进)——## 波次划分 的 Wave 行任务带 [P] 标记(并行语义)但 XML
|
|
1009
1156
|
// 任务无 parallel="true" → WARN(散文与机器路由依据不一致,以任务标记为准)。容错:无并行语义
|
|
1010
|
-
// 的 Wave
|
|
1011
|
-
//
|
|
1012
|
-
//
|
|
1013
|
-
|
|
1014
|
-
|
|
1015
|
-
const waveSection = content.match(/##\s*波次划分\s*\n([\s\S]*?)(?=\n##\s|\n---|(?![\s\S]))/);
|
|
1016
|
-
if (waveSection) {
|
|
1157
|
+
// 的 Wave 行不参与比对;解析不到波次段跳过(不误报)。段体由 wave-projection 的 waveSectionBody
|
|
1158
|
+
// 取用、段界(同级标题 / 围栏 / 分隔线 / 文末)由 lib/section-body.mjs 单点切片——本判据消费同一
|
|
1159
|
+
// 份段体,不另持第二份正则(两处各写一份段界,演进时必然静默分叉)。
|
|
1160
|
+
const waveBody = waveSectionBody(content);
|
|
1161
|
+
if (waveBody !== null) {
|
|
1017
1162
|
const proseParallelIds = [];
|
|
1018
|
-
for (const line of
|
|
1163
|
+
for (const line of waveBody.split('\n')) {
|
|
1019
1164
|
if (!/(Wave|\d+\s*波|parallel|并行)/i.test(line)) continue; // 无并行语义行跳过
|
|
1020
1165
|
for (const m of line.matchAll(/([A-Z][A-Z0-9-]*)\[P\]/g)) proseParallelIds.push(m[1]);
|
|
1021
1166
|
}
|
|
@@ -1026,11 +1171,8 @@ export async function runPlanExitGate({ node, state }) {
|
|
|
1026
1171
|
.filter(Boolean);
|
|
1027
1172
|
const missing = proseParallelIds.filter(id => !xmlParallelIds.includes(id));
|
|
1028
1173
|
if (missing.length > 0) {
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
process.exit(1);
|
|
1032
|
-
}
|
|
1033
|
-
console.error('WARN: 波次散文标记为并行([P])但任务无 parallel="true"——散文与任务标记不一致(以任务标记为准): ' + missing.join(', '));
|
|
1174
|
+
console.error('BLOCKED: 波次散文标记任务为并行([P])但任务无 parallel="true"(散文与任务标记须一致): ' + missing.join(', ') + ';恢复: 对齐散文或任务标记');
|
|
1175
|
+
process.exit(1);
|
|
1034
1176
|
}
|
|
1035
1177
|
}
|
|
1036
1178
|
}
|
|
@@ -1038,72 +1180,68 @@ export async function runPlanExitGate({ node, state }) {
|
|
|
1038
1180
|
// 废除——串行任务位置不再受限,串→并→串 / 并→串→并 / 多波混合均合法(多趟循环路由按依赖拓扑
|
|
1039
1181
|
// 分趟)。改为依赖图校验:① 全部任务建依赖图(deps 边)做 Kahn 拓扑排序判环——有环即规划结构性
|
|
1040
1182
|
// 死锁;② 全部引用的任务 id 必须存在(无环图下「每个 parallel 任务的全部传递依赖存在且非环」
|
|
1041
|
-
// ⟺
|
|
1042
|
-
//
|
|
1043
|
-
// 检测,维持不变)。
|
|
1183
|
+
// ⟺ 直接引用都存在)。违规即 BLOCKED(含「依赖环」/缺失依赖明细 + depends_on 调整恢复指引)。
|
|
1184
|
+
// 波次散文一致性检测保留不动(与形态约束正交的既有独立检测,维持不变)。
|
|
1044
1185
|
const depGraph = analyzeDependencyGraph(taskList);
|
|
1045
1186
|
if (depGraph.cyclic || depGraph.missing.length > 0) {
|
|
1046
1187
|
const detail = depGraph.cyclic
|
|
1047
1188
|
? '依赖环(拓扑排序无解,涉及任务: ' + depGraph.cycleIds.join(', ') + ')'
|
|
1048
1189
|
: '依赖不存在的任务: ' + depGraph.missing.map((m) => m.id + '→' + m.dep).join(', ');
|
|
1049
1190
|
const guide = ';恢复: 调整任务 depends_on——移除成环引用或改为真实存在的任务 id 后重试';
|
|
1050
|
-
|
|
1051
|
-
|
|
1052
|
-
process.exit(1);
|
|
1053
|
-
}
|
|
1054
|
-
console.error('WARN: TASK.md ' + detail + '——依赖图不可满足(旧 change 渐进不阻断)' + guide);
|
|
1055
|
-
}
|
|
1056
|
-
// 伪并行检测(真实载体验证暴露的设计盲区兜底):如果一个标记为并行的任务只写测试文件而无任何
|
|
1057
|
-
// 生产代码文件,它很可能隐式依赖某个实现类并行任务的产出(如测试 import 尚未存在的函数)。这种
|
|
1058
|
-
// "伪并行"在多趟路由下会导致委托后测试失败。启发式:并行任务的 write_files 全部匹配 tests/ 或
|
|
1059
|
-
// test_ 前缀 → 视为疑似伪并行。WARN 渐进不阻断——由执行者判断是否真独立(纯测试基础设施改动可
|
|
1060
|
-
// 合法全测试面)。
|
|
1061
|
-
const testOnlyParallelIds = [];
|
|
1062
|
-
for (const block of taskList) {
|
|
1063
|
-
const attrs = taskOpeningAttrs(block);
|
|
1064
|
-
if (!attrs || !attrs.parallel || attrs.status !== 'pending') continue;
|
|
1065
|
-
const wfMatch = block.match(/<write_files>([\s\S]*?)<\/write_files>/);
|
|
1066
|
-
if (!wfMatch) continue;
|
|
1067
|
-
// 分号容错:与 workflow-handoff.mjs 自动解析同源实现(分号容错双点内联,与 workflow-handoff.mjs
|
|
1068
|
-
// 同源互锚)——换行切分后逐段按 ';' 二次切分、trim、滤空与 HTML 注释行(路径含分号的极端形态
|
|
1069
|
-
// 不支持,须换行书写)
|
|
1070
|
-
const blockContent = wfMatch[1].replace(/<!--[\s\S]*?-->/g, '');
|
|
1071
|
-
const filePaths = blockContent.trim().split(/\s*\n\s*/).map(l => l.trim()).filter(Boolean)
|
|
1072
|
-
.flatMap(l => l.split(';')).map(l => l.trim()).filter(Boolean);
|
|
1073
|
-
if (filePaths.length === 0) continue;
|
|
1074
|
-
const prodFiles = filePaths.filter(f => !/(?:^|[\/\\])(?:__tests__\/|test_|tests?\/)|\.(?:test|spec)\.(?:mjs|js|jsx|ts|tsx|cjs)$/.test(f));
|
|
1075
|
-
if (prodFiles.length === 0) {
|
|
1076
|
-
testOnlyParallelIds.push(attrs.id || 'unknown');
|
|
1077
|
-
}
|
|
1191
|
+
console.error('BLOCKED: TASK.md ' + detail + '——依赖图不可满足(任务的依赖链必须存在且无环)' + guide);
|
|
1192
|
+
process.exit(1);
|
|
1078
1193
|
}
|
|
1194
|
+
// 波次投影判定(波次 = 依赖层级的投影):`## 波次划分` 声明的波次必须等于任务的依赖层级
|
|
1195
|
+
// (无依赖 = 第 1 波,其余 = 1 + 依赖中最晚波次),且任务集里每个非修复族任务都必须被某个
|
|
1196
|
+
// Wave 行声明过(未声明记入同一明细,取值「未声明」)。这是「图必须等于依赖」的判据——同波
|
|
1197
|
+
// 依赖、排在依赖之前、只需更早波次却排到更后面的保守排法、以及根本没写进波次段的任务都会被
|
|
1198
|
+
// 逐条点名(任务 / 依赖 / 当前波 / 应到波)。不一致即 BLOCKED(明细 + 恢复指引)。「判不了」按
|
|
1199
|
+
// 成因二分:载体缺席(无段 / 段名无从派生)只打印「未校验」放行——判据没有可判对象;工件内容
|
|
1200
|
+
// 不可判(段在场却没有一行 Wave 行能落到真实任务上)按同一先例判红(「该写的没写」不静默)。
|
|
1201
|
+
// 位置在依赖图判据之后:环与缺失依赖是更根本的规划错误,先报它们;replan 重校段(ADR-013
|
|
1202
|
+
// 不豁免)调用同一判定与同一报文构造,措辞与分级因此不会分叉。
|
|
1203
|
+
// 分级 → 输出单源:「哪一支打什么行、要不要拒绝」全在 waveReviewOutcome 一处——与 replan 重校段
|
|
1204
|
+
// 共用同一份,改分级只改一处。
|
|
1205
|
+
const waveReview = waveProjectionReview({ taskContent: content, blocks: taskList });
|
|
1206
|
+
const waveOutcome = waveReviewOutcome(waveReview, { blocking: true });
|
|
1207
|
+
for (const line of waveOutcome.lines) console.error(line);
|
|
1208
|
+
if (waveOutcome.block) process.exit(1);
|
|
1209
|
+
// 同波可并行却漏标 [P](波次判据之后的第二条波次面判据):同一波次内彼此无依赖路径、write_files
|
|
1210
|
+
// 不重叠的两个任务,只标一个 parallel="true" 不成立——单边标记既不表达「可并行」,机器路由又按
|
|
1211
|
+
// 串行跑(白丢一波并行度)。漏标即 BLOCKED(逐对点名 + 两条出路:都标 [P] / 补 depends_on 换波次)。
|
|
1212
|
+
// 判据本身(含「写面重叠」与「无依赖路径」两个前提)在 wave-projection 一处实现,本处只分级与
|
|
1213
|
+
// 打印;波次分组复用同一份解析结果(waveReview.waves),不重解析波次段。
|
|
1214
|
+
const gapOutcome = parallelGapOutcome(
|
|
1215
|
+
parallelGapReview({ taskContent: content, blocks: taskList, waves: waveReview.waves }),
|
|
1216
|
+
{ blocking: true },
|
|
1217
|
+
);
|
|
1218
|
+
for (const line of gapOutcome.lines) console.error(line);
|
|
1219
|
+
if (gapOutcome.block) process.exit(1);
|
|
1220
|
+
// 伪并行检测(真实载体验证暴露的设计盲区兜底)——判据(哪些并行任务只写测试产物)在
|
|
1221
|
+
// collectTestOnlyParallelIds 一处实现,本处只做分级(WARN 渐进不阻断)与打印:由执行者判断是否
|
|
1222
|
+
// 真独立(纯测试基础设施改动可合法全测试面)。
|
|
1223
|
+
const testOnlyParallelIds = collectTestOnlyParallelIds({ taskContent: content, blocks: taskList });
|
|
1079
1224
|
if (testOnlyParallelIds.length > 0) {
|
|
1080
1225
|
console.error('WARN: 伪并行检测——以下并行任务仅写测试文件而无生产代码文件: '
|
|
1081
1226
|
+ testOnlyParallelIds.join(', ')
|
|
1082
1227
|
+ '。测试通常依赖实现产出的符号,可能存在隐式依赖;建议添加 depends_on 声明或合并为垂直切片');
|
|
1083
1228
|
}
|
|
1084
|
-
// 并行文件依赖检测前移(触发面):write∩write
|
|
1085
|
-
//
|
|
1086
|
-
//
|
|
1087
|
-
//
|
|
1088
|
-
// 参与)。与委托前既有拦截并存(委托前为第二道写写锚,行为与消息保持既有语义不变)。
|
|
1229
|
+
// 并行文件依赖检测前移(触发面):write∩write 写写强判(BLOCKED)+ read∩write 读写弱判(仅无
|
|
1230
|
+
// 显式 depends_on 关联的并行对;WARN 提示级,不 BLOCK)+ 同文件跨任务且无依赖路径(未完成任务
|
|
1231
|
+
// 写入面重叠而两任务间无依赖路径——BLOCKED;串行拆分同样命中,修复任务族不参与)。与委托前
|
|
1232
|
+
// 既有拦截并存(委托前为第二道写写锚,行为与消息保持既有语义不变)。
|
|
1089
1233
|
const { writeConflicts, readWarnings, crossTaskConflicts } = await findParallelWriteConflicts(path.join(runRoot, '.specs', state.activeChange));
|
|
1090
1234
|
if (writeConflicts.length > 0) {
|
|
1091
1235
|
const detail = writeConflicts.map((c) => `${c.a}×${c.b}(${c.files.join(',')})`).join('; ');
|
|
1092
1236
|
const guide = ';恢复: 补显式 depends_on 或拆为串行任务后重试';
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
process.exit(1);
|
|
1096
|
-
}
|
|
1097
|
-
console.error('WARN: TASK.md 并行任务 write_files 重叠(写写冲突,建议补显式 depends_on 或拆为串行任务): ' + detail + guide);
|
|
1237
|
+
console.error('BLOCKED: TASK.md 并行任务 write_files 重叠(写写冲突,同波次并行会竞态覆盖): ' + detail + guide);
|
|
1238
|
+
process.exit(1);
|
|
1098
1239
|
}
|
|
1099
1240
|
if (crossTaskConflicts.length > 0) {
|
|
1100
1241
|
const detail = crossTaskConflicts.map((c) => `${c.a}×${c.b}(${c.files.join(',')})`).join('; ');
|
|
1101
1242
|
const guide = ';恢复: 补显式 depends_on 或合并为一个任务后重试';
|
|
1102
|
-
|
|
1103
|
-
|
|
1104
|
-
process.exit(1);
|
|
1105
|
-
}
|
|
1106
|
-
console.error('WARN: TASK.md 同文件跨任务且无依赖路径(建议补显式 depends_on 或合并为一个任务): ' + detail + guide);
|
|
1243
|
+
console.error('BLOCKED: TASK.md 同文件跨任务且无依赖路径: ' + detail + guide);
|
|
1244
|
+
process.exit(1);
|
|
1107
1245
|
}
|
|
1108
1246
|
if (readWarnings.length > 0) {
|
|
1109
1247
|
console.error('WARN: TASK.md 并行任务 read∩write 隐式依赖嫌疑(一方读取对方写路径,建议补显式 depends_on 声明): '
|
|
@@ -1132,7 +1270,7 @@ export async function runReviewExitGate({ node, state }) {
|
|
|
1132
1270
|
// 只警告不阻断(防旧 REVIEW 卡死),执行者补标记后可消除。
|
|
1133
1271
|
const reviewText = await fs.readFile(reviewFile, 'utf8');
|
|
1134
1272
|
// 发现位置(模板 2.2):发现写在旧 `## 发现` 而模板位置 `### 2.2 …详细发现` 下无条目——旧段不被
|
|
1135
|
-
//
|
|
1273
|
+
// 任何出口消费,等于「记录后静默丢弃」。命中即 BLOCKED + 逐条迁移指引。
|
|
1136
1274
|
// 模板缺席(primary=null)时不判位置:模板派生判据不臆造(C9),旧形态解析与处置校验照常。
|
|
1137
1275
|
const scope = await reviewFindingScope();
|
|
1138
1276
|
const findings = reviewFindingsItems(reviewText, scope);
|
|
@@ -1141,95 +1279,373 @@ export async function runReviewExitGate({ node, state }) {
|
|
|
1141
1279
|
&& reviewLegacyFindingsHasContent(reviewText);
|
|
1142
1280
|
if (misplacedFindings) {
|
|
1143
1281
|
const templateFile = (await buildSkeleton('REVIEW')).file ?? 'flow-kit/templates/REVIEW.md';
|
|
1144
|
-
|
|
1145
|
-
|
|
1146
|
-
|
|
1147
|
-
|
|
1148
|
-
process.exit(1);
|
|
1149
|
-
}
|
|
1150
|
-
console.error('REVIEW WARN: REVIEW.md 的发现写在模板外的段「## 发现」,模板位置 2.2 详细发现 无条目'
|
|
1151
|
-
+ '——迁移到 2.2 后本警告消除(旧 change 渐进不阻断;模板: ' + templateFile + ')');
|
|
1282
|
+
console.error('BLOCKED: REVIEW.md 的发现写在模板外的段「## 发现」,而模板位置(第二轮下的 2.2 详细发现)无条目——发现须写在模板位置');
|
|
1283
|
+
console.error('恢复: 把「## 发现」下的条目逐条移入「### 2.2 …详细发现」段内(模板: ' + templateFile
|
|
1284
|
+
+ '),删除旧段后重试 exit review');
|
|
1285
|
+
process.exit(1);
|
|
1152
1286
|
}
|
|
1153
1287
|
const missingDisposition = reviewFindingsMissingDisposition(reviewText, scope);
|
|
1154
1288
|
if (missingDisposition.length > 0) {
|
|
1155
|
-
|
|
1156
|
-
|
|
1157
|
-
|
|
1158
|
-
process.exit(1);
|
|
1159
|
-
}
|
|
1160
|
-
console.error('REVIEW WARN: REVIEW.md 发现区 ' + missingDisposition.length +
|
|
1161
|
-
' 项条目缺处置状态标记([已修]/[升级]/[转待办]): ' + missingDisposition.join('、') +
|
|
1162
|
-
'——未处置的发现(含 Minor)不应无声消失,补标记后本警告消除(渐进不阻断)');
|
|
1289
|
+
console.error('BLOCKED: REVIEW.md 发现区 ' + missingDisposition.length + ' 项条目缺处置状态标记([已修]/[升级]/[转待办])——每项发现须有处置: ' + missingDisposition.join('、'));
|
|
1290
|
+
console.error('恢复: 为发现区条目补处置标记后重试;未处置的发现(含 Minor)不应无声消失');
|
|
1291
|
+
process.exit(1);
|
|
1163
1292
|
}
|
|
1164
|
-
//
|
|
1165
|
-
// 条目标 [转待办]
|
|
1166
|
-
// 并由 [升级] 承接);缺失 →
|
|
1167
|
-
// Major
|
|
1168
|
-
|
|
1169
|
-
|
|
1170
|
-
|
|
1171
|
-
|
|
1172
|
-
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1293
|
+
// 延期裁决门禁:延期是用户决策点——reviewer 不得自行把任何严重度的发现标 [转待办]。结构校验:
|
|
1294
|
+
// 条目标 [转待办] 时须同时存在用户裁决记录(同段或其它段落含「用户裁决:接受延期」且指向该条目,
|
|
1295
|
+
// 并由 [升级] 承接);缺失 → BLOCKED。只以 [已修]/[升级] 处置的
|
|
1296
|
+
// 条目直接放行(不是延期,没有决策点)。Minor 并入同一门禁:此前只有 Major 受约束,Minor 可自行
|
|
1297
|
+
// 延期,延期因此长期无门槛积压。
|
|
1298
|
+
//
|
|
1299
|
+
// Minor 判定理由门禁:**每条**判为 Minor 的发现都须在条目块内自证判据——一行「判 Minor:<理由>」,
|
|
1300
|
+
// 与处置标记无关([已修]/[升级]/[转待办] 一律要:判据落在判定当时,而不是延期时补票)。结构级校验
|
|
1301
|
+
// (理由内容不做语义判断);缺失 → BLOCKED。报文把「改判 Major」
|
|
1302
|
+
// 作为默认出口——写不出理由通常说明这根本够不上 Minor。
|
|
1303
|
+
const deferredFindings = reviewDeferredFindingProblems(reviewText, scope);
|
|
1304
|
+
const minorUnjustified = reviewMinorJustificationProblems(reviewText, scope);
|
|
1305
|
+
if (deferredFindings.length > 0) {
|
|
1306
|
+
const named = deferredFindings.map((p) => p.title + '(' + p.severity + ')').join('、');
|
|
1307
|
+
const guide = ';恢复: 把该条目补 [升级] 交用户裁决;用户接受延期后,在与该条目以空行分隔的段落写'
|
|
1308
|
+
+ '「用户裁决:接受延期 —— 发现 <条目标识>:<理由>」,并由 [升级] 承接(条目内或该段落带 [升级])。'
|
|
1309
|
+
+ '示例: 「- **F1 · 标题**:[升级] [转待办]」+ 空行 +「用户裁决:接受延期 —— 发现 F1:下一 change 首修」';
|
|
1310
|
+
console.error('BLOCKED: REVIEW.md 发现区 ' + deferredFindings.length + ' 项条目为 [转待办] 但缺少用户裁决记录——任何严重度(含 Minor)的延期都不得由 reviewer 自行决定: ' + named + guide);
|
|
1178
1311
|
}
|
|
1312
|
+
if (minorUnjustified.length > 0) {
|
|
1313
|
+
const named = minorUnjustified.map((p) => p.title + '(' + p.severity + ')').join('、');
|
|
1314
|
+
const guide = ';恢复: 在该条目块内(与条目标题之间不留空行)补一行「判 Minor:<一句话理由>」,'
|
|
1315
|
+
+ '示例: 条目行「- **F2 · 标题**:[已修]」的下一行写「 判 Minor:仅影响日志措辞,不改变行为与接口」;'
|
|
1316
|
+
+ '若判断其实够不上 Minor,请改判 Major(拿不准时默认 Major)';
|
|
1317
|
+
console.error('BLOCKED: REVIEW.md 发现区 ' + minorUnjustified.length + ' 项条目被判为 Minor 但缺 `判 Minor:` 行'
|
|
1318
|
+
+ '——判为 Minor 须在判定当时自证判据,与处置标记([已修]/[升级]/[转待办])无关: ' + named + guide);
|
|
1319
|
+
}
|
|
1320
|
+
if (deferredFindings.length > 0 || minorUnjustified.length > 0) process.exit(1);
|
|
1321
|
+
// AC 覆盖汇总(只提示、不阻断):TEST.md 在场且其 1.1 测试矩阵漏了 AC → 一条汇总 WARN,退出码不变。
|
|
1322
|
+
// 同一判定的强制面在 verify 出口(BLOCKED),两处共用证据/产物门禁族的同一实现——
|
|
1323
|
+
// 本出口今天不要求 TEST.md,故只在判得了且真缺时报,不让「判不了」变成噪音。
|
|
1324
|
+
await runAcCoverageGate({ node, state });
|
|
1179
1325
|
} catch {}
|
|
1180
1326
|
}
|
|
1181
1327
|
|
|
1182
|
-
//
|
|
1183
|
-
//
|
|
1184
|
-
//
|
|
1185
|
-
//
|
|
1186
|
-
//
|
|
1187
|
-
//
|
|
1188
|
-
|
|
1189
|
-
|
|
1328
|
+
// 缺声明的恢复句(报文里唯一一处「怎么补」的编排):补**哪些**由上面的明细决定(逐项点名缺哪份
|
|
1329
|
+
// 协议文件、哪个必需技能),而命令本身必须**覆盖本节点的全部必需项**——命令形态与缺证据恢复段的
|
|
1330
|
+
// 第一步同源(nodeSkillLoadCommands):该节点全部协议文件的多个 --prompt、每个 guarded 必需技能
|
|
1331
|
+
// 各一条、模板全清单。只补缺项、占位技能名或漏 --templates 的旧形态,照抄后同一 exit 会再被覆盖门
|
|
1332
|
+
// 或模板门拦一次(「报文各给一半」的实证形态)。缺技能时只给缺的那几条(已声明的不重复刷),缺的
|
|
1333
|
+
// 只是协议文件时把完整命令全给(重跑同一标记 = 覆写,不新增)。
|
|
1334
|
+
async function missingDeclarationRecovery({ node, state, missingSkills }) {
|
|
1335
|
+
const derived = await nodeSkillLoadCommands({ node, state });
|
|
1336
|
+
const targeted = missingSkills.length > 0
|
|
1337
|
+
? derived.filter((entry) => missingSkills.includes(entry.skill))
|
|
1338
|
+
: derived;
|
|
1339
|
+
const commands = (targeted.length > 0 ? targeted : derived).map((entry) => entry.command);
|
|
1340
|
+
return '恢复: 照抄下面的命令补齐上述缺项后重试 exit ' + node.id
|
|
1341
|
+
+ '(每个必需技能各一条,每条都带该节点全部 --prompt 与模板全清单;同一 node-skill 重跑会覆写该标记;'
|
|
1342
|
+
+ '声明非物理证明,仅证明执行者声明已加载):\n'
|
|
1343
|
+
+ commands.map((command) => ' ' + command).join('\n');
|
|
1344
|
+
}
|
|
1345
|
+
|
|
1346
|
+
// 节点 exit 协议声明**覆盖**校验——扫描 .specs/<change-id>/.skill-loads/ 下该节点标记(<node>-*.json,
|
|
1347
|
+
// 执行者加载节点 skill 后经 skill-load 写入),要求覆盖本节点全部必需声明:
|
|
1348
|
+
// ① 节点该读的每份协议文件(NODE_PROTOCOL_FILES[node.id]——open / review 各两份)都必须被某个标记
|
|
1349
|
+
// 声明过:标记的 protocols 数组(多 --prompt)与 protocol 单值(收紧前的写入形态、record 自动补
|
|
1350
|
+
// 写的形态)都算,值一律按 basename 比对;
|
|
1351
|
+
// ② 协议声明的必需技能(enforcement='guarded' 且非 handoff scope)各自要有属于该技能的标记。
|
|
1352
|
+
// 缺任一 → BLOCKED 并**逐项点名**缺哪个协议文件、哪个必需技能。判定从「任一命中即通过」改为
|
|
1353
|
+
// 「全部覆盖」:旧口径把节点该读的清单当成允许
|
|
1354
|
+
// 集合,声明一份就能过——另一份协议文件、另一个必需技能从来没有判据。
|
|
1355
|
+
// 诚实边界:标记是执行者的自我声明——校验只确认「声明覆盖了必需项」,无法证明执行者真的阅读了协议
|
|
1356
|
+
// (声明非物理证明,仅保证声明可追溯)。**目录整体缺席 = 一项都没声明**(同一道判据的两半——
|
|
1357
|
+
// 「目录在但没覆盖」与「目录根本不在」不该有两种放行),逐项点名并 BLOCKED。删目录因此不是关掉
|
|
1358
|
+
// 覆盖判据的写法。节点已 exit 不重验(校验只在当前 exit 时执行);节点重新 exit(重入后再退)时
|
|
1359
|
+
// 按同一规则要求,无豁免。
|
|
1190
1360
|
export async function runSkillLoadMarkerGate({ node, state }) {
|
|
1191
|
-
if (!state.activeChange
|
|
1192
|
-
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
if (
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
|
|
1361
|
+
if (!state.activeChange) return;
|
|
1362
|
+
const requiredFiles = NODE_PROTOCOL_FILES[node.id] ?? [];
|
|
1363
|
+
const requiredSkills = await declarationSkillNames(node, state);
|
|
1364
|
+
// 零协议文件且零必需技能:本节点没有声明义务(自定义协议节点没有引擎映射,也没有 guarded 绑定)
|
|
1365
|
+
if (requiredFiles.length === 0 && requiredSkills.length === 0) return;
|
|
1366
|
+
// 标记目录活动/归档双路径解析(规范顺序「记录 → 搬目录 → exit」:搬目录在 exit 前、记录之后,
|
|
1367
|
+
// 移动后补记录仅作兼容 / 恢复路径——此时标记只在归档路径;单查活动路径会误报「机制未激活」静默放行)
|
|
1368
|
+
const foundDir = await findSkillLoadsDir(runRoot, state.activeChange);
|
|
1369
|
+
// 目录缺席按「一项都没声明」继续走下面那条判据(逐项点名 + BLOCKED)——把目录当成空的声明面,
|
|
1370
|
+
// 而不是「机制未激活」的放行口。
|
|
1371
|
+
// 声明面 = 「找到的目录」或「缺席的空声明面」:一处归一,下面的读目录 / 报文显示 / 缺项判定都只
|
|
1372
|
+
// 依赖这个形状(不再各自 `=== null` 判一遍,三处分支各自演进就是三份判据)。
|
|
1373
|
+
const surface = foundDir ?? { dir: null, display: '.specs/' + state.activeChange + '/.skill-loads/' };
|
|
1202
1374
|
const prefix = node.id + '-';
|
|
1203
|
-
const
|
|
1204
|
-
|
|
1205
|
-
.
|
|
1375
|
+
const names = surface.dir === null
|
|
1376
|
+
? []
|
|
1377
|
+
: (await fs.readdir(surface.dir).catch(() => []))
|
|
1378
|
+
.filter((f) => f.startsWith(prefix) && f.endsWith('.json'));
|
|
1379
|
+
const declaredFiles = new Set();
|
|
1380
|
+
const declaredSkills = new Set();
|
|
1206
1381
|
const malformed = [];
|
|
1207
|
-
|
|
1208
|
-
|
|
1382
|
+
for (const name of names) {
|
|
1383
|
+
let marker;
|
|
1209
1384
|
try {
|
|
1210
|
-
|
|
1211
|
-
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
|
|
1218
|
-
|
|
1219
|
-
|
|
1220
|
-
|
|
1221
|
-
|
|
1385
|
+
marker = JSON.parse(await fs.readFile(path.join(surface.dir, name), 'utf8'));
|
|
1386
|
+
} catch {
|
|
1387
|
+
malformed.push(name);
|
|
1388
|
+
continue;
|
|
1389
|
+
}
|
|
1390
|
+
// 非对象标记(null / 数组 / 标量)没有声明语义:与不可解析标记同样处置(不静默计入覆盖)
|
|
1391
|
+
if (!marker || typeof marker !== 'object' || Array.isArray(marker)) {
|
|
1392
|
+
malformed.push(name);
|
|
1393
|
+
continue;
|
|
1394
|
+
}
|
|
1395
|
+
for (const basename of markerProtocolBasenames(marker)) declaredFiles.add(basename);
|
|
1396
|
+
if (typeof marker.skill === 'string' && marker.skill !== '') declaredSkills.add(marker.skill);
|
|
1397
|
+
}
|
|
1398
|
+
const missingFiles = requiredFiles.filter((file) => !declaredFiles.has(file));
|
|
1399
|
+
const missingSkills = requiredSkills.filter((skill) => !declaredSkills.has(skill));
|
|
1400
|
+
if (missingFiles.length === 0 && missingSkills.length === 0) return;
|
|
1401
|
+
// 缺项明细(逐项点名):缺哪个协议文件、缺哪个必需技能(后者连标记文件名一起给,可直接对目录核对)
|
|
1402
|
+
const details = [];
|
|
1403
|
+
if (missingFiles.length > 0) details.push(' - 缺协议文件: ' + missingFiles.join('、'));
|
|
1404
|
+
if (missingSkills.length > 0) {
|
|
1405
|
+
details.push(' - 缺必需技能声明: ' + missingSkills.join('、')
|
|
1406
|
+
+ '(标记文件 ' + missingSkills.map((skill) => prefix + skill + '.json').join(' / ') + ')');
|
|
1407
|
+
}
|
|
1408
|
+
const recovery = (await missingDeclarationRecovery({ node, state, missingSkills }))
|
|
1409
|
+
+ (malformed.length > 0 ? ';不可解析标记: ' + malformed.join(', ') : '');
|
|
1410
|
+
const lead = '节点 ' + node.id + ' exit 缺协议声明标记——' + surface.display
|
|
1411
|
+
+ (surface.dir === null
|
|
1412
|
+
? '(活动与归档路径)不存在,即一项声明都没有'
|
|
1413
|
+
: ' 下的声明未覆盖本节点全部必需项');
|
|
1414
|
+
console.error('BLOCKED: ' + lead + '(声明须全部覆盖):');
|
|
1415
|
+
for (const line of details) console.error(line);
|
|
1416
|
+
console.error(recovery);
|
|
1417
|
+
process.exit(1);
|
|
1418
|
+
}
|
|
1419
|
+
|
|
1420
|
+
// ---------- 结构化预检(exit <node> --preflight)----------
|
|
1421
|
+
//
|
|
1422
|
+
// **结构性门禁子集**的唯一表达处:入口(workflow-guard)只调用 runStructuralPreflight,不另写「哪些
|
|
1423
|
+
// 门跑 / 哪些不跑」;每条判据复用既有门禁函数与既有路径判据,不在此复制实现。
|
|
1424
|
+
// 进 = 结构面(写得对不对):声明工件的存在性(协议 outputSchemas 的 file 类产物——缺件本身就是
|
|
1425
|
+
// 结论,**不是**进展判定)、SUMMARY 关键段(段在场 / 6 维实质 / 自检方法 / LESSONS 扫描回应)、
|
|
1426
|
+
// 模板保真骨架、TASK 7 字段(仅 plan 节点生效;execute 家族该门是 no-op)。
|
|
1427
|
+
// 存在性的时点分界(归档产出):判据只问「此刻该在场却不在场」的工件。归档动作自己的产出位置
|
|
1428
|
+
// (.specs/archive/)在归档前连上级目录都不存在,落在其中的声明产物属「归档执行后才会生成」——
|
|
1429
|
+
// 报成缺件并让人照着路径去创建,给的是归档前不可能执行的指令。它们走延后报告面,不阻断预检。
|
|
1430
|
+
// 不进 = 进展面(做到哪了):证据在场 / 转移前置 / 任务集签名 / Fix 批次越界 / 串行 pending /
|
|
1431
|
+
// 可委托并行 / 在飞委托 / verify 命令真实执行 / skill-load 声明 / UA 门控——它们在预检时点必然先
|
|
1432
|
+
// 命中,正是本模式要绕开的噪声;其余节点自有工件(REVIEW / TEST / UAT / TASK 段形)的骨架归各自
|
|
1433
|
+
// 出口的模板保真门禁,跨节点代为判定会把「子集」变成「超集」。
|
|
1434
|
+
// 同轮报告(顺序即反馈优先级):缺件与结构问题在**同一轮**里报出——先逐项列缺失工件(路径 + 模板
|
|
1435
|
+
// 指针),再列结构问题,互不因对方而跳过。
|
|
1436
|
+
// 只读:不写 state,也不写模板提示账本(.template-hints.json)⇒ 骨架报告停在两阶段报文的**首段
|
|
1437
|
+
// 形态**(模板路径 + 类别计数):**H2 缺段**只报数量(段名等节点收尾的完整 exit),结构子段与父段
|
|
1438
|
+
// 写法建议照常点名——它们本身就带定位信息,预检与收尾两种模式一致;判据本身来自 evaluateArtifact
|
|
1439
|
+
// (骨架 + 模板派生的同一实现),不在此另写段形判定。
|
|
1440
|
+
// 边界:预检通过 = **结构面**通过,不代表进展门禁会通过——推进仍由完整 exit / --apply 决定。
|
|
1441
|
+
|
|
1442
|
+
// 归档产出路径(「归档执行后才会生成」):`.specs/archive/` 是归档动作自己的产出位置——归档 =
|
|
1443
|
+
// 把 change 目录移入 `archive/<日期>-<change-id>/`。判据按**路径位置**而非节点身份:任何节点
|
|
1444
|
+
// 声明归档根下的产物,它的缺席都只能由归档动作解释,而不能是「该节点还没做完」。
|
|
1445
|
+
const ARCHIVE_ROOT_DIR = 'archive';
|
|
1446
|
+
function isArchiveProducedPath(pathBase, declaredPath) {
|
|
1447
|
+
if (pathBase !== 'specs-root') return false;
|
|
1448
|
+
return String(declaredPath).split('/')[0] === ARCHIVE_ROOT_DIR;
|
|
1449
|
+
}
|
|
1450
|
+
|
|
1451
|
+
// 声明工件的路径显示口径(与 explain 的产物行同源语义):specs-root 加 `.specs/` 前缀,
|
|
1452
|
+
// project / 缺省原样——缺件报文里的路径因此可直接对着项目根去创建,而不是抽象的 schema 名。
|
|
1453
|
+
// 通配段(`*`)在报文里换成占位说明:`*` 是**判据语法**(pathPatternExists 逐段按通配匹配),
|
|
1454
|
+
// 照原样印进「按上述路径创建」的指令里,读起来就是让人去建一个字面 `*` 目录——一条不可执行的
|
|
1455
|
+
// 指令。占位说明取哪个词由位置决定:归档目录名是「日期前缀 + change-id」(reference 的归档命名
|
|
1456
|
+
// 约定),这一段的通配就是那个日期,写 `<日期>`;其余通配不臆造语义,只声明这一段由运行期决定。
|
|
1457
|
+
function declaredArtifactDisplayPath(pathBase, declaredPath) {
|
|
1458
|
+
const pathText = String(declaredPath);
|
|
1459
|
+
const segments = pathText.split('/');
|
|
1460
|
+
const archiveChangeDirWildcard = pathBase === 'specs-root'
|
|
1461
|
+
&& segments[0] === ARCHIVE_ROOT_DIR
|
|
1462
|
+
&& (segments[1] ?? '').includes('*');
|
|
1463
|
+
return ((pathBase === 'specs-root' ? '.specs/' : '') + pathText)
|
|
1464
|
+
.replaceAll('*', archiveChangeDirWildcard ? '<日期>' : '<通配>');
|
|
1465
|
+
}
|
|
1466
|
+
|
|
1467
|
+
// 声明工件 → 模板指针:仅当该工件的模板键落在**本节点声明**的模板集合内才给模板路径(自定义节点
|
|
1468
|
+
// 未声明模板时不编造路径)。模板键派生与模板保真门禁**同一实现**(protocol-utils 的
|
|
1469
|
+
// templateKeyFromArtifactName)——本函数只保留「在声明集合里找回该键的名字 + 拼指针」,不再自持
|
|
1470
|
+
// 一份派生副本(两处副本漂移正是本 change 要收掉的东西)。键为 null(工件名里没有可派生的名字)
|
|
1471
|
+
// 时不给指针:降级为不打印模板路径,绝不拼一个空名字。
|
|
1472
|
+
function declaredArtifactTemplatePointer(declaration, declaredPath) {
|
|
1473
|
+
const key = templateKeyFromArtifactName(declaredPath);
|
|
1474
|
+
if (key === null) return null;
|
|
1475
|
+
const name = [...declaration.required, ...declaration.optional]
|
|
1476
|
+
.find((item) => templateKeyOf(item) === key);
|
|
1477
|
+
return name ? templatePointerPath(name) : null;
|
|
1478
|
+
}
|
|
1479
|
+
|
|
1480
|
+
// 本节点声明的 file 类产物是否在场:判据由 guard-routing 的 declaredRequiredArtifacts **一处产出**
|
|
1481
|
+
// (枚举 outputSchemas → artifacts + <change-id> 替换 + 在场判定),本函数不再自行遍历协议——
|
|
1482
|
+
// 只做预检侧的一处**显式过滤**、一处**显式分桶**与归档延后报告:
|
|
1483
|
+
// ① kind:只判 file 类产物(未声明 kind 按文件处置——路径判据本就是文件存在性)。其它 kind 的
|
|
1484
|
+
// 「在场」语义不是文件存在性,不在本判据里冒充(不静默扩面)。出口侧刻意不设这条过滤。
|
|
1485
|
+
// ② 未声明 paths(声明不完整):**仍然阻断**,但走独立的报告桶——报文给的是「修协议」这一条可
|
|
1486
|
+
// 执行的下一步,不是「按上述路径创建」那种做不到的指令(没有路径可建)。措辞与出口侧同一句
|
|
1487
|
+
// (unspecifiedPathsNotice),两侧因此不会再对同一份协议给出两种说法。
|
|
1488
|
+
// ③ 归档产出(见 isArchiveProducedPath):延后报告,归档执行前不可能在场。
|
|
1489
|
+
// 只读——不写 state、不写提示账本。返回三组(显示路径逐项给出 + 可推导时的模板指针):
|
|
1490
|
+
// missing = 此刻该在场却不在场(缺件,阻断);deferred = 归档产出(归档执行后才会生成,只报告);
|
|
1491
|
+
// incomplete = 声明不完整(required 但未声明 paths,阻断,报文指向协议)。
|
|
1492
|
+
async function missingDeclaredFileArtifacts({ protocol, node, state }) {
|
|
1493
|
+
if (!state.activeChange) return { missing: [], deferred: [], incomplete: [] };
|
|
1494
|
+
const declaration = nodeTemplateDeclaration(node);
|
|
1495
|
+
const missing = [];
|
|
1496
|
+
const deferred = [];
|
|
1497
|
+
const incomplete = [];
|
|
1498
|
+
for (const declared of await declaredRequiredArtifacts(protocol, node, state.activeChange)) {
|
|
1499
|
+
if (declared.kind !== undefined && declared.kind !== 'file') continue; // 差异①
|
|
1500
|
+
if (declared.unspecifiedPaths) { // 差异②
|
|
1501
|
+
incomplete.push(unspecifiedPathsNotice(declared.schemaId, declared.artifact.id));
|
|
1502
|
+
continue;
|
|
1503
|
+
}
|
|
1504
|
+
if (declared.present) continue;
|
|
1505
|
+
const displayPaths = declared.resolvedPaths
|
|
1506
|
+
.map((declaredPath) => declaredArtifactDisplayPath(declared.artifact.pathBase, declaredPath));
|
|
1507
|
+
const template = declared.resolvedPaths
|
|
1508
|
+
.map((declaredPath) => declaredArtifactTemplatePointer(declaration, declaredPath))
|
|
1509
|
+
.find(Boolean) ?? null;
|
|
1510
|
+
const item = { label: displayPaths[0].split('/').pop(), displayPaths, template };
|
|
1511
|
+
// 归档产出延后报告(见 isArchiveProducedPath,差异③):判据要求**全部**备选路径都落在归档根下
|
|
1512
|
+
// ——只要有一条此刻该在场的路径,它仍是真正的前置件,不因同组有归档路径而被放过。
|
|
1513
|
+
if (declared.resolvedPaths.every(
|
|
1514
|
+
(declaredPath) => isArchiveProducedPath(declared.artifact.pathBase, declaredPath),
|
|
1515
|
+
)) {
|
|
1516
|
+
deferred.push(item);
|
|
1517
|
+
continue;
|
|
1518
|
+
}
|
|
1519
|
+
missing.push(item);
|
|
1520
|
+
}
|
|
1521
|
+
return { missing, deferred, incomplete };
|
|
1522
|
+
}
|
|
1523
|
+
|
|
1524
|
+
// 声明不完整的报告面:**仍然阻断**(协议本身不完整,放行就等于把 fail-closed 换成静默通过),但
|
|
1525
|
+
// 报文指向协议要修——与出口侧同一句(措辞的唯一出处是 guard-routing 的 unspecifiedPathsNotice,
|
|
1526
|
+
// 两侧不各写一份)。恢复指引因此也不给「按上述路径创建」:没有路径可建。
|
|
1527
|
+
function reportIncompleteDeclarations(node, incomplete) {
|
|
1528
|
+
if (incomplete.length === 0) return;
|
|
1529
|
+
for (const notice of incomplete) console.error('BLOCKED: ' + notice);
|
|
1530
|
+
console.error('恢复: 上面列的是协议声明本身不完整(不是让你去创建某个文件)——给该项补一条 paths,'
|
|
1531
|
+
+ '或把 required 改成 false,再重试 exit ' + node.id + ' --preflight');
|
|
1532
|
+
}
|
|
1533
|
+
|
|
1534
|
+
// 存在性判据的报错编排(BLOCKED,不分新老 change——与出口的产物门禁同判级:工件是否存在是结构事实,
|
|
1535
|
+
// 不是「旧 change 的进展宽容」能改写的东西)。返回是否命中,收口退出由 runStructuralPreflight 负责
|
|
1536
|
+
// (先让同轮的结构门禁也能报完,缺件不被别的报错抢先吞掉顺序)。
|
|
1537
|
+
async function runDeclaredArtifactExistenceCheck({ protocol, node, state }) {
|
|
1538
|
+
// 归档目录名不合规(AC-6)先于在场判定失败:非日期名的归档目录既不是「在场」(产物门与声明门
|
|
1539
|
+
// 给不出两种答案),也不许报成「缺件」(那会让人去建一件其实存在的产物)。报文与出口产物门同一句
|
|
1540
|
+
// (判据与措辞都在 guard-routing 的 archiveDirNameNotice),预检因此不会给出另一个说法。
|
|
1541
|
+
const archiveNameProblems = archiveDirNameNotice(state.activeChange, node.id);
|
|
1542
|
+
if (archiveNameProblems.length > 0) {
|
|
1543
|
+
for (const line of archiveNameProblems) console.error(line);
|
|
1544
|
+
process.exit(1);
|
|
1545
|
+
}
|
|
1546
|
+
const { missing, deferred, incomplete } = await missingDeclaredFileArtifacts({ protocol, node, state });
|
|
1547
|
+
// 归档产出:只报「归档执行后才会生成」这一事实与它的落点,不报缺件、不给「去创建」的指令——
|
|
1548
|
+
// 归档前那条指令不可执行(连 .specs/archive/ 都还不存在),预检也不该把归档的输出当它的前提。
|
|
1549
|
+
for (const item of deferred) {
|
|
1550
|
+
console.error('归档执行后才会生成(预检不要求在场): ' + item.label + ' → ' + item.displayPaths.join(' | '));
|
|
1551
|
+
}
|
|
1552
|
+
if (missing.length === 0) {
|
|
1553
|
+
reportIncompleteDeclarations(node, incomplete);
|
|
1554
|
+
return incomplete.length > 0;
|
|
1555
|
+
}
|
|
1556
|
+
const items = missing.map((item) => item.label + ' → ' + item.displayPaths.join(' | ')
|
|
1557
|
+
+ (item.template ? '(模板: ' + item.template + ')' : ''));
|
|
1558
|
+
console.error('BLOCKED: 节点 ' + node.id + ' 的声明工件缺失 ' + missing.length + ' 项'
|
|
1559
|
+
+ '(本节点声明的 file 类产物不在场): ' + items.join('、'));
|
|
1560
|
+
console.error('恢复: 先按上述路径创建缺失工件(段形照模板),再重试 exit ' + node.id + ' --preflight'
|
|
1561
|
+
+ '——预检只读;缺件是结构性事实,工件不在场就没有可判的结构,也不会给出通过结论');
|
|
1562
|
+
reportIncompleteDeclarations(node, incomplete);
|
|
1563
|
+
return true;
|
|
1564
|
+
}
|
|
1565
|
+
|
|
1566
|
+
// 预检的骨架目标(只装**在场者**):① SUMMARY(execute 家族,与 runSummaryTemplateFidelityGate
|
|
1567
|
+
// 同一作用面:目录下全部 *-SUMMARY.md);② 入口三件(CHANGE / REQUIREMENT / DESIGN)——变更的结构
|
|
1568
|
+
// 输入,任何节点的预检都查在场者。这里的「在场才查」只决定**段形**目标:工件缺失不在这里报,
|
|
1569
|
+
// 由上面的声明工件存在性判据统一报(缺件是结构事实,不是本子集的静默跳过项);跨节点声明的入口
|
|
1570
|
+
// 三件不属于本节点的声明产物,其缺失由各自节点出口的产物门禁负责。DESIGN-lite 未登记骨架,其
|
|
1571
|
+
// 标题形态仍由 design 出口的既有判据负责。
|
|
1572
|
+
async function preflightSkeletonTargets({ node, state }) {
|
|
1573
|
+
const changeDir = path.join(runRoot, '.specs', state.activeChange ?? '');
|
|
1574
|
+
const targets = [];
|
|
1575
|
+
if (EXECUTE_FAMILY_NODE_IDS.has(node.id)) {
|
|
1576
|
+
const summaries = (await fs.readdir(changeDir).catch(() => [])).filter((file) => file.endsWith('-SUMMARY.md'));
|
|
1577
|
+
for (const file of summaries) targets.push({ key: 'SUMMARY', file });
|
|
1578
|
+
}
|
|
1579
|
+
for (const [key, file] of [['CHANGE', 'CHANGE.md'], ['REQUIREMENT', 'REQUIREMENT.md'], ['DESIGN', 'DESIGN.md']]) {
|
|
1580
|
+
if (await fileExists(path.join(changeDir, file))) targets.push({ key, file });
|
|
1581
|
+
}
|
|
1582
|
+
return targets;
|
|
1583
|
+
}
|
|
1584
|
+
|
|
1585
|
+
// 骨架子集:判据 = evaluateArtifact(与模板保真门禁同一实现);报告 = 首段形态(只读投影)。
|
|
1586
|
+
// 命中即 BLOCKED(含恢复指引)。
|
|
1587
|
+
async function runPreflightSkeletonChecks({ node, state }) {
|
|
1588
|
+
if (!state.activeChange) return;
|
|
1589
|
+
const changeDir = path.join(runRoot, '.specs', state.activeChange);
|
|
1590
|
+
const failures = [];
|
|
1591
|
+
const templatePaths = new Set();
|
|
1592
|
+
for (const target of await preflightSkeletonTargets({ node, state })) {
|
|
1593
|
+
let text;
|
|
1594
|
+
try {
|
|
1595
|
+
text = await fs.readFile(path.join(changeDir, target.file), 'utf8');
|
|
1222
1596
|
} catch {
|
|
1223
|
-
|
|
1597
|
+
continue; // 读失败与产物在场同属产物面,不在结构子集里重复报(未验证的可见性由产物门禁负责)
|
|
1598
|
+
}
|
|
1599
|
+
// SUMMARY 的首部四字段与模板保真门禁同口径(键集来自骨架、值非空才算填);入口三件只查骨架
|
|
1600
|
+
// 本身——「Change ID 必填」是入口文档门的硬要求,不是骨架派生判据,这里不扩张。
|
|
1601
|
+
const skeleton = await buildSkeleton(target.key);
|
|
1602
|
+
const evaluated = await evaluateArtifact(target.key, text, {
|
|
1603
|
+
requiredHeaderFields: target.key === 'SUMMARY' ? skeleton.headerFields : [],
|
|
1604
|
+
});
|
|
1605
|
+
if (!evaluated.derived) {
|
|
1606
|
+
// 模板缺席不静默通过:显式声明未校验(与模板权威门禁同一口径),不臆造段名兜底。
|
|
1607
|
+
console.error('未校验(模板缺失): ' + target.file + ' —— 模板或结构登记表不可读,段形校验跳过'
|
|
1608
|
+
+ '(修复: 按安装指引获取 flow-kit 模板后重试)');
|
|
1609
|
+
continue;
|
|
1224
1610
|
}
|
|
1611
|
+
// 首段形态 = 同一格式器在 escalate=false 下的输出:**H2 缺段**只报类别计数(预检不读提示账本,
|
|
1612
|
+
// 段名留到再犯),结构子段与父段写法建议照常点名;其余类别本身即定位信息。账本由报告函数写,
|
|
1613
|
+
// 格式器是纯函数——复用不会写盘,结构子段缺口的「该怎么写」建议因此在预检与收尾两种模式下一致。
|
|
1614
|
+
const parts = formatIssueParts(evaluated.issues, { escalate: false });
|
|
1615
|
+
if (parts.length === 0) continue;
|
|
1616
|
+
failures.push({ file: target.file, parts, template: evaluated.skeleton.file });
|
|
1617
|
+
if (evaluated.skeleton.file) templatePaths.add(evaluated.skeleton.file);
|
|
1225
1618
|
}
|
|
1226
|
-
if (
|
|
1227
|
-
|
|
1228
|
-
|
|
1229
|
-
|
|
1230
|
-
|
|
1619
|
+
if (failures.length === 0) return;
|
|
1620
|
+
const lines = failures.map((failure) => failure.file + ' 模板结构校验失败: '
|
|
1621
|
+
+ failure.parts.join('; ') + '(模板: ' + (failure.template ?? '(登记表未登记模板路径)') + ')');
|
|
1622
|
+
for (const line of lines) console.error('BLOCKED: ' + line);
|
|
1623
|
+
console.error('恢复: 对照 ' + [...templatePaths].join(' / ')
|
|
1624
|
+
+ ' 修正标题 / 首部字段 / 段序,并按模板补齐缺失的 H2 与结构型 H3 标题'
|
|
1625
|
+
+ '(条件段与无内容段正文可写 N/A;可选段按模板自述可整段删除)后重试 exit ' + node.id + ' --preflight'
|
|
1626
|
+
+ '(预检只读、不写提示账本,故 H2 缺段只报类别计数;结构子段与父段写法建议会点名到具体段。'
|
|
1627
|
+
+ '要知道被计数的那些段名,请等节点收尾的完整 exit(它维护提示账本),或直接按模板逐段对照)');
|
|
1628
|
+
process.exit(1);
|
|
1629
|
+
}
|
|
1630
|
+
|
|
1631
|
+
// 结构化预检子集(显式清单,单一表达处):workflow-guard 的 --preflight 分支只调用本函数。
|
|
1632
|
+
// 顺序即反馈优先级:先声明工件的存在性(缺件时没有可判的结构,且缺件最致命),再段(SUMMARY 关键段),
|
|
1633
|
+
// 再骨架(段形 / 结构子段),最后 TASK 字段。存在性命中不提前退出——它先把缺件报出来,同轮的结构
|
|
1634
|
+
// 门禁照常跑完,最后统一以非零退出收口(同轮报告;结构门禁自己命中时也会非零退出,两者不互相吞掉)。
|
|
1635
|
+
export async function runStructuralPreflight({ protocol, node, state }) {
|
|
1636
|
+
// 无活跃 change = 没有可判的结构面:声明工件 / 骨架 / 段 / TASK 字段全按 change 定位,子判据因此
|
|
1637
|
+
// 各自早退,预检会零判据跑完并打印 ALL CHECKS PASSED——「没看」被报成「看过且通过」,与同一 state
|
|
1638
|
+
// 的完整 exit(缺证据 BLOCKED)直接矛盾。只读不等于可以给结论:结论必须与「真的判过」等价,
|
|
1639
|
+
// 所以此处显式声明未校验并非零退出(不打印通过结论)。
|
|
1640
|
+
if (!state.activeChange) {
|
|
1641
|
+
console.error('PREFLIGHT: 未校验(无活跃 change,没有可判的结构面)——先 init / select');
|
|
1231
1642
|
process.exit(1);
|
|
1232
1643
|
}
|
|
1644
|
+
const missingArtifacts = await runDeclaredArtifactExistenceCheck({ protocol, node, state });
|
|
1645
|
+
await runSummarySectionsGate({ node, state });
|
|
1646
|
+
await runPreflightSkeletonChecks({ node, state });
|
|
1647
|
+
await runTaskSevenFieldGate({ node, state });
|
|
1648
|
+
if (missingArtifacts) process.exit(1);
|
|
1233
1649
|
}
|
|
1234
1650
|
|
|
1235
1651
|
// 受保护状态落盘(沿用 state-io 的受保护写入通道)
|