flow-comet 1.6.5 → 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 +17 -5
- package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/entry-detail.md +23 -4
- 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 +97 -3
- package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +38 -2
- package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +52 -10
- package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +16 -3
- package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +2 -0
- package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +4 -0
- package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +20 -11
- 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 +47 -5
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +297 -131
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +616 -151
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +96 -45
- 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 +204 -51
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +7 -9
- 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 +38 -20
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +439 -134
- 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 +92 -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 +94 -39
- package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +6 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +84 -31
- package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +57 -7
- 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 +158 -3
- package/.flow-comet/skills/flow-comet/scripts/lib/wave-projection.mjs +341 -0
- package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +92 -17
- package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +1439 -11
- package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1202 -8
- package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1204 -76
- package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +753 -5
- package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +32 -1
- package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +582 -3
- package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +5 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +5 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +16 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +2 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +5 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +2041 -66
- package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +135 -0
- package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +143 -16
- 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-execute/SKILL.md +30 -6
- package/.flow-comet/skills/flow-comet-plan/SKILL.md +10 -3
- package/.flow-comet/skills/flow-comet-review/SKILL.md +20 -11
- package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +33 -8
- package/.flow-comet/skills/flow-comet-task/SKILL.md +2 -1
- package/README.md +1 -1
- package/package.json +1 -1
- package/scripts/dsh-bridge.mjs +2 -2
|
@@ -0,0 +1,341 @@
|
|
|
1
|
+
// wave-projection.mjs — 波次段解析与「波次 = 依赖层级的投影」判定(纯判定:无 console、无
|
|
2
|
+
// process.exit、无写盘)。
|
|
3
|
+
//
|
|
4
|
+
// 语义:`## 波次划分` 段给每个任务声明它排在第几波;波次不是自由排版,而是依赖层级的投影——
|
|
5
|
+
// level(task) = 1 + max(level(dep))(无依赖 = 第 1 波,见 task-graph.mjs 的 taskWaveLevels)。
|
|
6
|
+
// 声明波次 ≠ 层级即不一致:同波依赖(依赖方与被依赖方写在同一波)、排在依赖之前、以及明明只需
|
|
7
|
+
// 更早波次却排到更后面的保守排法,都会在明细里被逐条点名为「当前波 → 应到波」。
|
|
8
|
+
// 分级不在这里判:本模块产出「判不了」的分类与载荷、明细与报文行;BLOCK / WARN 由调用方按
|
|
9
|
+
// isNewChange 给出 blocking。**分级 → 输出只有一处**(waveReviewOutcome):plan 出口门禁与 replan
|
|
10
|
+
// 重校段各自只派生 blocking(两处的 isNewChange 取法不同,由调用方传入)。调用方不得自写
|
|
11
|
+
// 「不可判 → 选级别 → 打印 → exit」的同构分支——同一分级有两份实现时,改一处只会在另一处静默落后
|
|
12
|
+
// (ADR-013 的前提正是「两处同判」:replan 不豁免)。
|
|
13
|
+
//
|
|
14
|
+
// 判定面覆盖两侧:① 已声明任务的波次必须等于依赖层级;② 任务集里存在、Wave 行一次都没提到的
|
|
15
|
+
// 任务同样不一致(明细取值 = 「未声明」)——只沿「已声明」一侧求差集,未写进 Wave 行的任务会整个
|
|
16
|
+
// 逃过判定(实测:段内只写 `Wave 1: T01` 而任务另有 T02/T03 时,出口 exit 0 且零输出)。修复族
|
|
17
|
+
// 任务不在声明的义务面内(回修有独立生命周期),族判定一律经 task-graph 的唯一谓词
|
|
18
|
+
// `fixTaskClassifier`——判据侧不自写前缀匹配。
|
|
19
|
+
//
|
|
20
|
+
// 解析面刻意宽(真实工件的写法差异一律容忍;误报比漏报更伤):Wave 行带 `(parallel)` /
|
|
21
|
+
// `(serial)` 标注、括号依赖注解 `(depends on …)` / `(T07 on T05; …)`、行尾 `#` 注释、
|
|
22
|
+
// 半角 / 全角冒号与逗号分号顿号、列表记号均可。只取「Wave N … 任务 id 列表」,注解里的 id 不算
|
|
23
|
+
// 本波成员;不是 TASK.md 任务 id 的一律不计入判定。
|
|
24
|
+
//
|
|
25
|
+
// 「判不了」按成因二分,形态与 ac-coverage.mjs **完全一致**(本仓结构判据只此一种形态):
|
|
26
|
+
// { unverified: { reason, notice } | null, unjudgeable: { reason, explanation, recovery } | null, ... }
|
|
27
|
+
// · 载体缺席(无 `## 波次划分` 段 / 段名无从派生)→ unverified 非空:调用方打印 notice
|
|
28
|
+
// (「未校验」)并放行——判据没有可判对象,不改退出码;
|
|
29
|
+
// · 工件内容不可判(段在场,但一行 Wave 行都解析不出可对应任务:正文只写 N/A、点的是不存在的
|
|
30
|
+
// 任务 id、行首强调记号让 Wave 行不成立)→ unjudgeable 非空:新 change BLOCKED / 旧 change
|
|
31
|
+
// WARN(WARN 行进入既有 WARN COUNT——「该写的没写」不再静默;恢复出路在载荷里)。
|
|
32
|
+
// 收敛到这一形态(而不是 { judgeable, reason })的理由:① 载荷跟着分类走——notice /
|
|
33
|
+
// explanation + recovery 直接可用于打印,调用方不必再按 reason 反查第二张表(同一组取值只许有一张
|
|
34
|
+
// 表:按 key 反查的第二张表与判定表必然分叉);② 「能否判定」由字段出现与否表达,reason 只留人读
|
|
35
|
+
// 成因,不再逼调用方从字符串取值反推分级;③ 新增的结构判据照抄这一组字段即可,不必再选一次。
|
|
36
|
+
// 形态不随落点变化:谁带着载荷,谁就是形态(换一个出口消费它,判定结论与字段不变)。
|
|
37
|
+
import {
|
|
38
|
+
analyzeDependencyGraph,
|
|
39
|
+
collectCrossTaskConflicts,
|
|
40
|
+
fixTaskClassifier,
|
|
41
|
+
taskWaveLevels,
|
|
42
|
+
} from './task-graph.mjs';
|
|
43
|
+
import { taskOpeningAttrs } from '../task-parsing.mjs';
|
|
44
|
+
// 段界单源(围栏 / 同级标题 / 分隔线 / 文末的判定只在这里一份)
|
|
45
|
+
import { sectionBody } from './section-body.mjs';
|
|
46
|
+
// 「这个任务有没有写面」的单一实现(元素提取 + 条目边界都在 lib/lessons-hits.mjs):本模块不自己
|
|
47
|
+
// 拿正则去块里找 <write_files>。同一件事写第二份表达式时,元素名大小写少一个 /i 就够——7 字段门
|
|
48
|
+
// 判字段在场、本模块判未知,任务因此从 [P] 判据的参与者里静默消失。
|
|
49
|
+
import { taskHasWriteFace } from './lessons-hits.mjs';
|
|
50
|
+
// 段名登记值与段标题谓词都取单源:骨架模块是「模板缺席时的段名基准」唯一登记处,也是「这一行是不是
|
|
51
|
+
// 登记的某段」的唯一判定(headingPredicate:级别 + 段名归一后相等),消费方只 import。
|
|
52
|
+
import { WAVE_SECTION_NAME, headingPredicate } from './guard-artifact-skeleton.mjs';
|
|
53
|
+
|
|
54
|
+
// 段界与 plan 出口既有的「波次散文一致性([P] vs parallel)」检测**同一实现**,而段界本身由
|
|
55
|
+
// lib/section-body.mjs 单点决定:围栏代码块里的 `## ` / `---` 是正文示例,不结束段体(段内贴一段
|
|
56
|
+
// Markdown 示例不会把其后声明的 Wave 行整段吞掉)。
|
|
57
|
+
// 段标题判定与 TASK 段形门、AC 覆盖**同一个谓词**(级别 + 归一后的标题正文相等):标题**正文本身**
|
|
58
|
+
// 以井号开头(`## ## 波次划分`)时,行正则会判缺席、段形门却认作在场——同一份工件的同一段在两处得到
|
|
59
|
+
// 相反答案时,一次排版就够关掉其中一处判据(未校验 ≠ 通过)。比较规则不在本模块另写一份。
|
|
60
|
+
const isWaveSectionHeading = headingPredicate(WAVE_SECTION_NAME, 2);
|
|
61
|
+
|
|
62
|
+
// 波次段正文(段标题之后、下一个二级标题 / 分隔线 / 文末之前的文本);无该段 → null。
|
|
63
|
+
export function waveSectionBody(taskContent) {
|
|
64
|
+
return sectionBody(taskContent, isWaveSectionHeading, { level: 2, endOnSeparator: true });
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
// Wave 行:`Wave N (parallel): T01[P], T02 (depends on T01) # 说明`。只认「Wave + 数字」开口
|
|
68
|
+
// (允许缩进与列表记号);行内其余注解由 parseWaveLine 剥离。
|
|
69
|
+
const WAVE_LINE_RE = /^\s*(?:[-*+]\s+)?Wave\s+(\d+)\b/iu;
|
|
70
|
+
// 行尾注释:`#` 之后的不是本波成员(括号内 `(见 #12)` 一类由后续括号剥离兜住)。
|
|
71
|
+
const WAVE_TRAILING_COMMENT_RE = /#[^\n]*/gu;
|
|
72
|
+
// 括号注解(半角 / 全角):`(parallel)` / `(serial)` / `(depends on T01, T02)` / `(T07 on T05; …)`。
|
|
73
|
+
// 注解里的任务 id 是「为什么排在这里」的说明,不是本波成员——先剥注解再取 id,否则依赖注解会把
|
|
74
|
+
// 被依赖方错算进本波(模板自身就写 `Wave 2 (parallel): T03[P], T04[P] (depends on T01)`)。
|
|
75
|
+
const WAVE_ANNOTATION_RE = /[((][^()()]*[))]/gu;
|
|
76
|
+
const WAVE_COLON_RE = /[::]/u;
|
|
77
|
+
// 任务 id 分隔符:半角逗号 / 分号 / 空白 + 中文顿号 / 全角逗号 / 全角分号。漏收全角逗号会让中文
|
|
78
|
+
// 写法的 `Wave 1:T01,T02` 只切出 `T01,T02` 这个假 id ⇒ 无可对应任务 ⇒ 整段降级成「未校验」
|
|
79
|
+
// 放行(半角写法同一计划却 BLOCK)——同一计划的两种标点写法必须得到同一判定。
|
|
80
|
+
const WAVE_TOKEN_SEPARATOR_RE = /[,\s;、,;]+/u;
|
|
81
|
+
// id token 上的标记(`[P]` 并行标记、Markdown 强调符)不是 id 的一部分:先整段剥掉方括号标
|
|
82
|
+
// 记(`T01[P]` → `T01`,只削括号会留下 `P` 拼成假 id),再剥残余的孤立记号。
|
|
83
|
+
const WAVE_TOKEN_BRACKETS_RE = /\[[^\]]*\]/gu;
|
|
84
|
+
const WAVE_TOKEN_MARKERS_RE = /[[\]`*]/gu;
|
|
85
|
+
|
|
86
|
+
// 单行 → { wave, tokens }(tokens 只做过标记剥离与切分,是否真是任务 id 由判定侧用任务集过滤);
|
|
87
|
+
// 不是 Wave 行 → null。
|
|
88
|
+
function parseWaveLine(line) {
|
|
89
|
+
const head = String(line).match(WAVE_LINE_RE);
|
|
90
|
+
if (head === null) return null;
|
|
91
|
+
let rest = String(line).slice(head[0].length)
|
|
92
|
+
.replace(WAVE_TRAILING_COMMENT_RE, '')
|
|
93
|
+
.replace(WAVE_ANNOTATION_RE, ' ')
|
|
94
|
+
.replace(WAVE_ANNOTATION_RE, ' '); // 括号嵌套(少见)再剥一层,不引入递归
|
|
95
|
+
const colon = rest.search(WAVE_COLON_RE);
|
|
96
|
+
if (colon >= 0) rest = rest.slice(colon + 1);
|
|
97
|
+
const tokens = rest
|
|
98
|
+
.split(WAVE_TOKEN_SEPARATOR_RE)
|
|
99
|
+
.map((token) => token.replace(WAVE_TOKEN_BRACKETS_RE, '').replace(WAVE_TOKEN_MARKERS_RE, '').trim())
|
|
100
|
+
.filter(Boolean);
|
|
101
|
+
return { wave: Number(head[1]), tokens };
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
// 波次段 → Map<任务 id, 声明波次>;无该段 → null(不可判)。同一 id 重复声明:首见为准
|
|
105
|
+
// (声明面本应唯一,重复时取确定性的那一个,不按书写顺序反复覆盖)。
|
|
106
|
+
function parseDeclaredWaves(taskContent) {
|
|
107
|
+
const body = waveSectionBody(taskContent);
|
|
108
|
+
if (body === null) return null;
|
|
109
|
+
const declared = new Map();
|
|
110
|
+
for (const line of body.split(/\r?\n/u)) {
|
|
111
|
+
const parsed = parseWaveLine(line);
|
|
112
|
+
if (parsed === null) continue;
|
|
113
|
+
for (const id of parsed.tokens) {
|
|
114
|
+
if (id === '' || declared.has(id)) continue;
|
|
115
|
+
declared.set(id, parsed.wave);
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
return declared;
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
// 「未声明」取值:Wave 行一次都没提到的真实任务(修复族例外)。明细形态与既有一致明细同形,
|
|
122
|
+
// 只有 declared 取值不同——渲染 / 分级 / 恢复指引因此仍走同一处构造,不会分叉。
|
|
123
|
+
const WAVE_UNDECLARED = '未声明';
|
|
124
|
+
|
|
125
|
+
// 「载体缺席」的 notice(由判定结果携带,调用方只打印):删段不是通过——判据跳过时执行者必须看见
|
|
126
|
+
// 「未校验」,而 plan 册要求该段在场(模板 H2 必填)。段在场却解析不出可对应任务**不属本支**(那是
|
|
127
|
+
// 「该写的没写」,见 WAVE_CONTENT_UNJUDGEABLE)。
|
|
128
|
+
const WAVE_UNCHECKED_NOTICE = '未校验(无波次段)——TASK.md 缺 ## 波次划分 段(或段名无从派生),波次 = 依赖层级 的投影判据跳过(未验证 ≠ 通过)';
|
|
129
|
+
|
|
130
|
+
// 「工件内容不可判」的成因载荷(与 ac-coverage 的 UNJUDGEABLE_CAUSES 同形:解释 + 恢复出路各占一半
|
|
131
|
+
// ——只有解释没有出路,人只能猜下一步)。reason 是机器可读短句,explanation / recovery 是人读文本,
|
|
132
|
+
// 判定结果自带这三样,调用方不再按 reason 反查第二张表。
|
|
133
|
+
const WAVE_CONTENT_UNJUDGEABLE = Object.freeze({
|
|
134
|
+
reason: 'no-resolvable-wave-line',
|
|
135
|
+
explanation: '## 波次划分 段在场,但段内没有一行 Wave 行能解析出可对应的任务 id'
|
|
136
|
+
+ '(正文只写 N/A / Wave 行点的是不存在的任务 id / 行首强调记号让 Wave 行不成立)',
|
|
137
|
+
recovery: '按模板把每一波写成可解析的 Wave 行(如 `Wave 1: T01, T02`,中文标点可用),'
|
|
138
|
+
+ '任务 id 必须逐字对应 TASK.md 里的任务;段正文写 N/A 不构成波次声明',
|
|
139
|
+
});
|
|
140
|
+
|
|
141
|
+
// 判定:返回 { unverified, unjudgeable, mismatches, waves }——「判不了」形态见文件头。
|
|
142
|
+
// · mismatches 逐条 { id, deps, declared, expected };
|
|
143
|
+
// · waves = Map<真实任务 id, 声明波次>(可判时非空;[P] 判据复用这份解析结果分组)。
|
|
144
|
+
// 可判条件 = 段在场且至少一条声明能落到 TASK.md 的真实任务上;到不落就说明正文不是可解析的波次
|
|
145
|
+
// 声明(N/A、点了不存在的 id、行首强调记号),此时不再猜「全部一致」。
|
|
146
|
+
// 已声明一侧要求能求出层级(环上任务无层级,其合法性由依赖图判据负责);未声明一侧同样要求层级
|
|
147
|
+
// (没有「应到波」就无法给出可照抄的明细)。明细按任务 id 升序(与书写顺序无关——报告稳定可对照)。
|
|
148
|
+
export function waveProjectionReview({ taskContent, blocks = [] } = {}) {
|
|
149
|
+
const declared = parseDeclaredWaves(taskContent);
|
|
150
|
+
if (declared === null) {
|
|
151
|
+
return { unverified: { reason: 'section-missing', notice: WAVE_UNCHECKED_NOTICE }, unjudgeable: null, mismatches: [], waves: null };
|
|
152
|
+
}
|
|
153
|
+
const graph = analyzeDependencyGraph(blocks);
|
|
154
|
+
const levels = taskWaveLevels(blocks);
|
|
155
|
+
const declaredTaskIds = [...declared.keys()].filter((id) => graph.ids.has(id));
|
|
156
|
+
if (declaredTaskIds.length === 0) {
|
|
157
|
+
return { unverified: null, unjudgeable: WAVE_CONTENT_UNJUDGEABLE, mismatches: [], waves: null };
|
|
158
|
+
}
|
|
159
|
+
// 修复族 = 「不要求排进波次」的那一族:族判定经 task-graph 的唯一谓词(前缀形态与「位于修复段内」
|
|
160
|
+
// 两条边界只在那里表达),本模块只取用结果,不自写前缀匹配。
|
|
161
|
+
const isFixTask = fixTaskClassifier(taskContent);
|
|
162
|
+
const fixIds = new Set(blocks
|
|
163
|
+
.filter((block) => isFixTask(block))
|
|
164
|
+
.map((block) => (taskOpeningAttrs(block) ?? {}).id)
|
|
165
|
+
.filter((id) => typeof id === 'string' && id !== ''));
|
|
166
|
+
const mismatches = [];
|
|
167
|
+
for (const id of declaredTaskIds) {
|
|
168
|
+
if (!levels.has(id)) continue; // 环上任务无层级:合法性由依赖图判据负责
|
|
169
|
+
const declaredWave = declared.get(id);
|
|
170
|
+
const level = levels.get(id);
|
|
171
|
+
if (declaredWave === level) continue;
|
|
172
|
+
mismatches.push({ id, deps: graph.depsById.get(id) ?? [], declared: declaredWave, expected: level });
|
|
173
|
+
}
|
|
174
|
+
// 未声明一侧:任务集减去 Wave 声明集(修复族排除在外)——写漏的任务同样是不一致,逐条点名。
|
|
175
|
+
for (const id of graph.ids) {
|
|
176
|
+
if (declared.has(id) || fixIds.has(id) || !levels.has(id)) continue;
|
|
177
|
+
mismatches.push({ id, deps: graph.depsById.get(id) ?? [], declared: WAVE_UNDECLARED, expected: levels.get(id) });
|
|
178
|
+
}
|
|
179
|
+
mismatches.sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
|
|
180
|
+
// 波次分组(真实任务 id → 声明波次)随判定结果一并返回:[P] 判据(parallelGapReview)用它分组,
|
|
181
|
+
// 不重解析同一段波次散文——同一段两次解析必然分叉。
|
|
182
|
+
const waves = new Map(declaredTaskIds.map((id) => [id, declared.get(id)]));
|
|
183
|
+
return { unverified: null, unjudgeable: null, mismatches, waves };
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
// 「工件内容不可判」的报文构造(plan 出口与 replan 重校共用同一份,只换分级前缀):首行点名哪一环
|
|
187
|
+
// 读不出来并给出分级,第二行给能照做的恢复出路——与 ac-coverage 的 acCoverageUnjudgeableLines 同形
|
|
188
|
+
// (同一件事两处措辞必然先漂移)。旧 change 用 WARN 前缀,因此该行进入既有 WARN COUNT(未校验不再
|
|
189
|
+
// 静默);新 change 用 BLOCKED 前缀并由调用方拒绝通过。载荷来自判定结果,本函数只做渲染。
|
|
190
|
+
function waveContentUnjudgeableLines(unjudgeable, level) {
|
|
191
|
+
const blocking = level === 'BLOCKED';
|
|
192
|
+
return [
|
|
193
|
+
(blocking ? 'BLOCKED: ' : 'WARN: ')
|
|
194
|
+
+ 'TASK.md 波次划分段内容不可判——' + unjudgeable.explanation
|
|
195
|
+
+ (blocking ? '' : '(旧 change 渐进不阻断)')
|
|
196
|
+
+ ':波次 = 依赖层级 的投影判据无法执行(未验证 ≠ 通过)',
|
|
197
|
+
'恢复: ' + unjudgeable.recovery,
|
|
198
|
+
];
|
|
199
|
+
}
|
|
200
|
+
|
|
201
|
+
// 报文构造(只由 waveReviewOutcome 调用,调用方不直接取用):BLOCKED / WARN 同一文本,只换分级前缀。
|
|
202
|
+
// 明细逐条点名「任务 / 依赖 / 当前波 / 应到波」(未声明的任务当前波记为「未声明」);恢复指引按明细
|
|
203
|
+
// 分流——已声明但波次不对:移到应到波,或把「为什么排在后面」的依赖写成显式 depends_on(作者有意
|
|
204
|
+
// 延后的合法排法靠后者表达);未声明:把它写进应到波的 Wave 行(没有「当前波」可挪,不套用前者)。
|
|
205
|
+
function waveProjectionReportLines(mismatches, level = 'BLOCKED') {
|
|
206
|
+
const blocking = level === 'BLOCKED';
|
|
207
|
+
const lines = [(blocking ? 'BLOCKED: ' : 'WARN: ')
|
|
208
|
+
+ 'TASK.md 波次划分与依赖层级不一致——波次 = 依赖层级的投影(无依赖 = 第 1 波,其余 = 1 + 依赖中最晚波次;同波任务必须彼此无依赖;'
|
|
209
|
+
+ '任务集里存在但 Wave 行一次都没提到的任务记为「未声明」)'
|
|
210
|
+
+ (blocking ? '' : '(旧 change 渐进不阻断)')
|
|
211
|
+
+ ':'];
|
|
212
|
+
for (const item of mismatches) {
|
|
213
|
+
lines.push(' - ' + item.id + '(依赖: ' + (item.deps.length > 0 ? item.deps.join(', ') : '无')
|
|
214
|
+
+ ')当前波 ' + item.declared + ' → 应到波 ' + item.expected);
|
|
215
|
+
}
|
|
216
|
+
lines.push('恢复: 按明细逐项修正——'
|
|
217
|
+
+ mismatches.map((item) => (item.declared === WAVE_UNDECLARED
|
|
218
|
+
? '把 ' + item.id + ' 写进第 ' + item.expected + ' 波的 Wave 行'
|
|
219
|
+
: '把 ' + item.id + ' 移到第 ' + item.expected
|
|
220
|
+
+ ' 波,或给它补 depends_on: <依赖> 把顺序声明出来(要保留当前波次,就把「它为何排在后面」的依赖写成显式 depends_on)')).join(';')
|
|
221
|
+
+ ';改完重试');
|
|
222
|
+
return lines;
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
// 分级 → 输出的**唯一出口**(plan 出口与 replan 重校各自只派生 blocking):返回 { lines, block }。
|
|
226
|
+
// · 载体缺席 → 打印 notice、不阻断(block=false;「未校验 ≠ 通过」由文本表达,不改退出码);
|
|
227
|
+
// · 内容不可判 → BLOCKED / WARN 两行(成因 + 恢复出路),block = blocking;
|
|
228
|
+
// · 判过且不一致 → 明细 + 恢复指引,block = blocking;
|
|
229
|
+
// · 判过且一致 → 零行、不阻断(不制造噪音)。
|
|
230
|
+
// 调用方一律「逐行 console.error → 按 block 拒绝」,不再自己选级别、也不再自己构造报文。
|
|
231
|
+
export function waveReviewOutcome(review, { blocking = false } = {}) {
|
|
232
|
+
const blocked = blocking === true;
|
|
233
|
+
const level = blocked ? 'BLOCKED' : 'WARN';
|
|
234
|
+
if (review.unverified !== null) return { lines: [review.unverified.notice], block: false };
|
|
235
|
+
if (review.unjudgeable !== null) {
|
|
236
|
+
return { lines: waveContentUnjudgeableLines(review.unjudgeable, level), block: blocked };
|
|
237
|
+
}
|
|
238
|
+
if (review.mismatches.length === 0) return { lines: [], block: false };
|
|
239
|
+
return { lines: waveProjectionReportLines(review.mismatches, level), block: blocked };
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
// ---------- 同波可并行却漏标 [P](plan 出口的第二条波次面判据) ----------
|
|
243
|
+
// 判据:同一波次内、彼此无依赖路径、且 write_files 不重叠的两个任务——**其中任一**没标
|
|
244
|
+
// parallel="true" 即「可并行却未标 [P]」。只标一个不成立:单边标记既不表达「可并行」,机器路由
|
|
245
|
+
// 又按串行跑(该并行度白丢)。作者的两条出路:两个都标 [P](真并行),或补一条 depends_on 把它们
|
|
246
|
+
// 排到不同波次(顺序显式)。修复族不参与(回修有独立生命周期)。
|
|
247
|
+
//
|
|
248
|
+
// 三条输入面的复用(本判据不另写第二份):
|
|
249
|
+
// · 波次分组 / 层级:分组取 waveProjectionReview 的 waves(同一次解析,见该函数),层级取
|
|
250
|
+
// task-graph 的 taskWaveLevels。**同层 ⇒ 彼此无依赖路径**(依赖边严格抬高层级:
|
|
251
|
+
// level(依赖方) ≥ level(被依赖方) + 1),故「同波 ∧ 同层」即「同一波次内且彼此无依赖路径」——
|
|
252
|
+
// 波次投影一致时两者本就等价,投影不一致(旧 change 只 WARN 才走到这里)时取交集使判据保守。
|
|
253
|
+
// · 写面重叠:**唯一入口是 task-graph 的 collectCrossTaskConflicts**。任务书写的是
|
|
254
|
+
// collectPathOverlaps(重叠判定的底层唯一实现),落地走它的上层入口——后者才带着「已归一路径」
|
|
255
|
+
// 的解析、glob 语义与参与者规则(未完成、非修复族),且这些都收在 task-graph 一处;为直接调底层
|
|
256
|
+
// 函数而导出 parsePaths / normalizeTaskPath,等于把私有契约放大成公共面。**等价关系**:该入口返回
|
|
257
|
+
// 「同波无关 ∧ 写面重叠」(参与者已按未完成 / 非修复族过滤),本判据要的是它的**补集**——同层任务
|
|
258
|
+
// 之间无依赖路径(层级不变量),故「不在其返回集合」⟺「写面不重叠」,不重叠才有资格叫「可并行」。
|
|
259
|
+
// 本判据不自己比较路径:第二份重叠判定(含路径归一与 glob)必然与第一份分叉。
|
|
260
|
+
// 补集判定同样不自己算键:task-graph 返回的 isOverlappingPair 就是「键集合上的成员判定」,任务对键
|
|
261
|
+
// 的形态(无序、NUL 分隔)只在那里表达一次。此处自建第二份键(换个分隔符或换个定序)时两端键不再
|
|
262
|
+
// 相等,补集会静默失效——写面重叠的一对被当成「本可并行」,而本判据照常报出来。
|
|
263
|
+
// · 修复族:族判定经 task-graph 的唯一谓词 fixTaskClassifier,判据侧不自写前缀匹配。
|
|
264
|
+
// 已 done 的任务不参与(规划面上的 [P] 只约束未开始的任务)。
|
|
265
|
+
// 写面未知的任务同样不参与:没有 <write_files>(或清单为空 / 只有注释)意味着「不能断言写面不重叠」,
|
|
266
|
+
// 而不是「写面不重叠」——把它当成后者,补集会把一对写面未知的任务报成「可并行却未标 [P]」,恢复句
|
|
267
|
+
// 还会让作者补 depends_on(真正缺的是字段)。参与者判据因此与 task-graph 的第三族同口径(该族只把
|
|
268
|
+
// 有写面的任务放进重叠比较),而「这份写面算不算有内容」取 lib/lessons-hits.mjs 的唯一判定
|
|
269
|
+
// (taskHasWriteFace)——本模块不再自持第二份元素提取(元素名大小写与注释剥离都在那里表达一次)。
|
|
270
|
+
|
|
271
|
+
// 判定:返回 { gaps },逐条 { a, b, wave, unmarked }(unmarked = 该对里没标 parallel 的任务 id)。
|
|
272
|
+
// 无波次段 / 内容不可判(waves 为 null)→ 空(波次侧已有判别不了,本判据没有分组可用)。
|
|
273
|
+
export function parallelGapReview({ taskContent = '', blocks = [], waves = null } = {}) {
|
|
274
|
+
if (!(waves instanceof Map) || waves.size === 0) return { gaps: [] };
|
|
275
|
+
const levels = taskWaveLevels(blocks);
|
|
276
|
+
const isFixTask = fixTaskClassifier(taskContent);
|
|
277
|
+
const candidates = [];
|
|
278
|
+
for (const block of blocks) {
|
|
279
|
+
const attrs = taskOpeningAttrs(block);
|
|
280
|
+
if (!attrs || typeof attrs.id !== 'string' || attrs.id === '') continue;
|
|
281
|
+
if (attrs.status === 'done' || isFixTask(block)) continue;
|
|
282
|
+
if (!taskHasWriteFace(block)) continue;
|
|
283
|
+
const wave = waves.get(attrs.id);
|
|
284
|
+
const level = levels.get(attrs.id);
|
|
285
|
+
if (wave === undefined || level === undefined) continue;
|
|
286
|
+
candidates.push({ id: attrs.id, wave, level, parallel: attrs.parallel === true });
|
|
287
|
+
}
|
|
288
|
+
if (candidates.length < 2) return { gaps: [] };
|
|
289
|
+
const { depsById } = analyzeDependencyGraph(blocks);
|
|
290
|
+
const { isOverlappingPair } = collectCrossTaskConflicts({
|
|
291
|
+
taskContent, allBlocks: blocks, depsById,
|
|
292
|
+
});
|
|
293
|
+
const gaps = [];
|
|
294
|
+
for (let i = 0; i < candidates.length; i += 1) {
|
|
295
|
+
for (let j = i + 1; j < candidates.length; j += 1) {
|
|
296
|
+
const left = candidates[i];
|
|
297
|
+
const right = candidates[j];
|
|
298
|
+
if (left.wave !== right.wave || left.level !== right.level) continue;
|
|
299
|
+
if (left.parallel && right.parallel) continue;
|
|
300
|
+
if (isOverlappingPair(left.id, right.id)) continue;
|
|
301
|
+
gaps.push({
|
|
302
|
+
a: left.id,
|
|
303
|
+
b: right.id,
|
|
304
|
+
wave: left.wave,
|
|
305
|
+
unmarked: [left, right].filter((task) => !task.parallel).map((task) => task.id),
|
|
306
|
+
});
|
|
307
|
+
}
|
|
308
|
+
}
|
|
309
|
+
return { gaps };
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
// 报文(plan 出口 BLOCKED / 旧 change WARN 同一文本,只换分级前缀):逐对点名哪两个任务同波、谁没标,
|
|
313
|
+
// 恢复句给两条出路(都标 [P],或补 depends_on 换波次)——只有一条出路时执行者会以为「标 [P] 是唯一
|
|
314
|
+
// 正确答案」,而真实计划里「这两个任务其实有先后」是同样常见的形态。
|
|
315
|
+
function parallelGapLines(gaps, level = 'BLOCKED') {
|
|
316
|
+
if (gaps.length === 0) return [];
|
|
317
|
+
const blocking = level === 'BLOCKED';
|
|
318
|
+
const sample = gaps[0];
|
|
319
|
+
const lines = [(blocking ? 'BLOCKED: ' : 'WARN: ')
|
|
320
|
+
+ 'TASK.md 同波任务可并行却未标 [P]——同一波次内彼此无依赖路径、且 write_files 不重叠的任务本可并行;'
|
|
321
|
+
+ '任务开标签的 parallel="true" 才是机器路由依据(Wave 行的 [P] 只是散文标记)'
|
|
322
|
+
+ (blocking ? '' : '(旧 change 渐进不阻断)')
|
|
323
|
+
+ ':'];
|
|
324
|
+
for (const gap of gaps) {
|
|
325
|
+
lines.push(' - ' + gap.a + ' × ' + gap.b + '(同在第 ' + gap.wave + ' 波;未标 parallel="true": '
|
|
326
|
+
+ gap.unmarked.join('、') + ')');
|
|
327
|
+
}
|
|
328
|
+
lines.push('恢复: 两条出路任选——① 给这一对都标 parallel="true"(Wave 行同步标 [P]),让它们真的同波并行;'
|
|
329
|
+
+ '② 补一条 depends_on(如给 ' + sample.b + ' 加 <depends_on>' + sample.a + '</depends_on>)'
|
|
330
|
+
+ '把它们排到不同波次,顺序因而显式;改完重试');
|
|
331
|
+
return lines;
|
|
332
|
+
}
|
|
333
|
+
|
|
334
|
+
// 分级 → 输出的唯一出口(与 waveReviewOutcome 同形:两个调用方各自只派生 blocking)。ADR-013 的
|
|
335
|
+
// 「replan 不豁免」同样适用于本判据:只在 plan 出口判,执行期重签就能把「本可并行却没标」的计划
|
|
336
|
+
// 换一份发出去——那正是两处同判要防的形态。
|
|
337
|
+
export function parallelGapOutcome(review, { blocking = false } = {}) {
|
|
338
|
+
const blocked = blocking === true;
|
|
339
|
+
if (review.gaps.length === 0) return { lines: [], block: false };
|
|
340
|
+
return { lines: parallelGapLines(review.gaps, blocked ? 'BLOCKED' : 'WARN'), block: blocked };
|
|
341
|
+
}
|
|
@@ -437,6 +437,24 @@ export function templateKeyOf(value) {
|
|
|
437
437
|
return normalizeTemplateName(value).toLowerCase();
|
|
438
438
|
}
|
|
439
439
|
|
|
440
|
+
// 声明工件名 → 模板键(单一实现):「节点声明的哪份工件对应哪份模板」只在此派生,两个消费面共用——
|
|
441
|
+
// 结构预检(缺件报文里的模板指针)与模板保真门禁(该工件用哪份骨架校验)。两处曾各持一份等价实现,
|
|
442
|
+
// 副本一旦漂移,预检与收尾就会对同一份工件给出两套口径——这正是本函数存在的理由。
|
|
443
|
+
// 口径(以模板保真门禁的既有实现为基准,它更新):
|
|
444
|
+
// ① 路径归一:`\` 与 `/` 同权(与 workflowRelativeSegments 对声明路径的口径一致),只取末段——
|
|
445
|
+
// 调用方传整条声明路径(`<change-id>/*-SUMMARY.md`)或裸文件名都可以;
|
|
446
|
+
// ② 通配:取末个 `*` 之后(通配只出现在文件名前缀:`*-SUMMARY.md` → `-SUMMARY.md`);
|
|
447
|
+
// ③ 去首部非字母数字(`-SUMMARY` → `SUMMARY`):通配残渣不是名字的一部分;
|
|
448
|
+
// ④ 空基名 → null(没有可派生的名字)——调用方据此「不给模板指针 / 不校验」,不臆造键;
|
|
449
|
+
// ⑤ 键归一(去尾 `.md` + 小写)由 templateKeyOf 承担,不在此另写一份。
|
|
450
|
+
// 只回答「键」,不回答「该节点是否允许这份模板」:声明集合比对(C11)与指针格式化留在调用方——
|
|
451
|
+
// 两侧对未知键的处置本就不同(预检不编造指针、模板保真门禁跳过未登记工件)。
|
|
452
|
+
export function templateKeyFromArtifactName(value) {
|
|
453
|
+
const base = String(value ?? '').replaceAll('\\', '/').split('/').pop();
|
|
454
|
+
const tail = base.split('*').pop().replace(/^[^A-Za-z0-9]+/u, '');
|
|
455
|
+
return tail === '' ? null : templateKeyOf(tail);
|
|
456
|
+
}
|
|
457
|
+
|
|
440
458
|
// 逗号分隔的模板清单(`--templates CHANGE.md,REQUIREMENT.md`;单模板可省略逗号)→ 去重保序数组。
|
|
441
459
|
export function parseTemplateList(value) {
|
|
442
460
|
const names = [];
|
|
@@ -520,23 +538,6 @@ export function templatePointerPath(name) {
|
|
|
520
538
|
return TEMPLATE_ROOT + '/' + normalizeTemplateName(name) + '.md';
|
|
521
539
|
}
|
|
522
540
|
|
|
523
|
-
// 重新声明的命令指引(skill-load 校验失败与 record 声明核对两处共用):两处本说的是同一件事
|
|
524
|
-
// 「怎么重新声明」——各拼一份必然分叉(命令形态改一次要改两地方)。零模板节点不拼 --templates
|
|
525
|
-
// (省略即空集,与 C11 的「可省略」一致);无 skill 名的场景用 <skill> 占位。
|
|
526
|
-
// --prompt 一并拼上:模板与提示词是同一次声明的两面,而 skill-load 重跑会**覆写**同一标记——
|
|
527
|
-
// 只补 --templates 的指引会把 protocol 写成 null,下一次 exit 反被判「缺协议声明标记」(恢复步骤
|
|
528
|
-
// 自己弄坏协议声明)。路径取该节点的首个内置协议文件,与入口的 READ PROMPT 同源;自定义节点没有
|
|
529
|
-
// 内置映射(协议自己也声明提示词路径)→ 不拼,不编造路径也不打占位符。
|
|
530
|
-
export function templateDeclareCommand(declaration, { nodeId, skillName } = {}) {
|
|
531
|
-
const skill = typeof skillName === 'string' && skillName !== '' ? skillName : '<skill>';
|
|
532
|
-
const flag = declaration.required.length > 0
|
|
533
|
-
? ' --templates ' + declaration.required.map((name) => name + '.md').join(',')
|
|
534
|
-
: '';
|
|
535
|
-
const promptFile = (NODE_PROTOCOL_FILES[nodeId] ?? [])[0];
|
|
536
|
-
const promptFlag = typeof promptFile === 'string' ? ' --prompt ' + promptPointerPath(promptFile) : '';
|
|
537
|
-
return 'workflow-state.mjs skill-load ' + nodeId + ' ' + skill + flag + promptFlag;
|
|
538
|
-
}
|
|
539
|
-
|
|
540
541
|
// 指针行(入口与 explain 共用:同一判据一份实现,两处输出措辞一致)。
|
|
541
542
|
// label:内置入口用 `READ TEMPLATE`,现问通道用 `TEMPLATE`;conditional=true 时追出条件模板行。
|
|
542
543
|
export function templatePointerLines(declaration, options = {}) {
|
|
@@ -609,3 +610,77 @@ export function promptDeclarationConflict({ node, declaredProtocol } = {}) {
|
|
|
609
610
|
const expected = [...nodeFiles, ...(NODE_CONDITIONAL_PROMPTS[node?.id] ?? [])];
|
|
610
611
|
return expected.includes(declared) ? null : { declared, expected };
|
|
611
612
|
}
|
|
613
|
+
|
|
614
|
+
// ---------- 声明命令:参数面的一处装配 ----------
|
|
615
|
+
//
|
|
616
|
+
// 一次 skill-load 声明要携带的东西只有三样:哪个节点的哪个技能、该节点该读的**每一份**协议文件
|
|
617
|
+
// (条件提示词在适用时并入)、以及该节点的模板全清单。这条装配此前散在几处各拼一份——重跑声明的
|
|
618
|
+
// 指引只带首份 --prompt、公开册把占位符写进 --prompt 的值位置(bash 下 `<` 是重定向)、门禁报文
|
|
619
|
+
// 干脆不带 --templates(照抄即撞模板门)。故参数面只在这里拼,调用方只提供事实(节点、技能)。
|
|
620
|
+
//
|
|
621
|
+
// 命令**文本**(脚本路径 / 引号 / 协议上下文)不在这里:那是运行面的事实(平台布局、本次解析到的
|
|
622
|
+
// 协议),由 lib/state-explain.mjs 的 declarationCommand 一处补齐——状态命令族与守卫族取同一份。
|
|
623
|
+
//
|
|
624
|
+
// 同步面与异步面的差别只有一处输入:条件提示词(design 的 2a-ui-design.md)是否适用。守卫的
|
|
625
|
+
// nodeSkillLoadCommands 判得了前端,按结论并入;状态命令族与册子拿不到该结论,改为「本次声明的
|
|
626
|
+
// 技能自己承载哪份条件提示词就并入哪份」(ui-design → 2a)——同步面不替一个异步判据下结论。
|
|
627
|
+
// 零模板节点不拼 --templates(省略即空集,与 C11 的「可省略」一致)。
|
|
628
|
+
function declarationPromptFiles({ nodeId, skill, frontend }) {
|
|
629
|
+
const files = [...(NODE_PROTOCOL_FILES[nodeId] ?? [])];
|
|
630
|
+
const own = SKILL_PROTOCOL_FILES[skill] ?? [];
|
|
631
|
+
for (const file of NODE_CONDITIONAL_PROMPTS[nodeId] ?? []) {
|
|
632
|
+
if (frontend || own.includes(file)) files.push(file);
|
|
633
|
+
}
|
|
634
|
+
return files.filter((file, index) => files.indexOf(file) === index);
|
|
635
|
+
}
|
|
636
|
+
|
|
637
|
+
// 一次声明的参数面(argv 形态,`skill-load` 起头):脚本路径与协议上下文由调用方追加——它们是
|
|
638
|
+
// 运行面的事实(平台路径 / 本次解析到的协议),不是声明内容。
|
|
639
|
+
export function skillLoadDeclarationArgs({ node, skill, frontend = false } = {}) {
|
|
640
|
+
const args = ['skill-load', node?.id, skill];
|
|
641
|
+
for (const file of declarationPromptFiles({ nodeId: node?.id, skill, frontend })) {
|
|
642
|
+
args.push('--prompt', promptPointerPath(file));
|
|
643
|
+
}
|
|
644
|
+
const declaration = nodeTemplateDeclaration(node);
|
|
645
|
+
if (declaration.required.length > 0) {
|
|
646
|
+
args.push('--templates', declaration.required.map((name) => name + '.md').join(','));
|
|
647
|
+
}
|
|
648
|
+
return args;
|
|
649
|
+
}
|
|
650
|
+
|
|
651
|
+
// 该节点要求声明的技能(guarded ∧ 非 handoff)——协议面的事实,唯一实现:守卫的异步适用性判据、
|
|
652
|
+
// 同步出口的覆盖门与回退取值全从这里取(第二个过滤条件在各处各写一遍,就是「两份判据各自演进」
|
|
653
|
+
// 的起点)。
|
|
654
|
+
export function guardedDeclarationSkills(node) {
|
|
655
|
+
return (node?.requiredSkillCalls ?? [])
|
|
656
|
+
.filter((binding) => binding
|
|
657
|
+
&& binding.enforcement === 'guarded'
|
|
658
|
+
&& binding.scope !== 'handoff'
|
|
659
|
+
&& typeof binding.skill === 'string'
|
|
660
|
+
&& binding.skill !== '')
|
|
661
|
+
.map((binding) => binding.skill);
|
|
662
|
+
}
|
|
663
|
+
|
|
664
|
+
// 没有可展开的必需技能时,声明该写哪个技能名(**不臆造**):优先节点实现技能(它是这个节点的实现
|
|
665
|
+
// 者),其次该节点 requiredSkillCalls 里非 handoff 的既有条目,两者皆无才留占位符。
|
|
666
|
+
// 占位符是最后的诚实选择——它落在位置实参位,在 bash 下 `<skill>` 是输入重定向、照抄即失败,
|
|
667
|
+
// 故只有当协议面确实没有可用的技能名时才出现,且报文会说明要按 entry 的 LOAD SKILL 行填。
|
|
668
|
+
export function declarationSkillFallback(node) {
|
|
669
|
+
const implementation = node?.implementation;
|
|
670
|
+
const implementationSkill = implementation && typeof implementation === 'object' ? implementation.skill : null;
|
|
671
|
+
if (typeof implementationSkill === 'string' && implementationSkill.trim() !== '') return implementationSkill.trim();
|
|
672
|
+
const mainScoped = (node?.requiredSkillCalls ?? [])
|
|
673
|
+
.find((binding) => binding && binding.scope !== 'handoff'
|
|
674
|
+
&& typeof binding.skill === 'string' && binding.skill !== '');
|
|
675
|
+
return mainScoped ? mainScoped.skill : '<skill>';
|
|
676
|
+
}
|
|
677
|
+
|
|
678
|
+
// 该节点本次该声明哪些技能(**同步面**的目标集):guarded 必需技能,但条件绑定(design 的 ui-design:
|
|
679
|
+
// 技能自身承载的协议文件就是该节点的条件提示词)不在此展开——它是否适用要读 CHANGE.md 判前端,
|
|
680
|
+
// 同步面不替它下结论,缺那一项时由判得了前端的出口指引补。一个都不剩时按 declarationSkillFallback 退。
|
|
681
|
+
export function declarationSkillTargets(node) {
|
|
682
|
+
const skills = guardedDeclarationSkills(node)
|
|
683
|
+
.filter((skill) => !(SKILL_PROTOCOL_FILES[skill] ?? [])
|
|
684
|
+
.some((file) => (NODE_CONDITIONAL_PROMPTS[node?.id] ?? []).includes(file)));
|
|
685
|
+
return skills.length > 0 ? skills : [declarationSkillFallback(node)];
|
|
686
|
+
}
|