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
|
@@ -5,10 +5,16 @@
|
|
|
5
5
|
import { execFileSync } from 'child_process';
|
|
6
6
|
import { promises as fs } from 'fs';
|
|
7
7
|
import path from 'path';
|
|
8
|
-
import {
|
|
8
|
+
import { fileURLToPath } from 'url';
|
|
9
|
+
import { route, hasSubagentNode, protocolTaskFilePath, resolveFixRollbackDecision, resolveFixRollbackState, applyFixRollbackRound, resolveFixReturnNode, isSingleSegmentChangeName, EXECUTE_FAMILY_NODE_IDS } from '../route-node.mjs';
|
|
9
10
|
import { taskOpeningAttrs, taskBlocks } from '../task-parsing.mjs';
|
|
10
|
-
import {
|
|
11
|
-
|
|
11
|
+
import {
|
|
12
|
+
NODE_PROTOCOL_FILES,
|
|
13
|
+
SKILL_PROTOCOL_FILES,
|
|
14
|
+
declarationSkillTargets,
|
|
15
|
+
inspectWorkflowPathSegments,
|
|
16
|
+
} from '../protocol-utils.mjs';
|
|
17
|
+
import { evidencePayloadProblems, looksLikeObjectLiteral, toPersistedProtocolPath, writeJsonAtomic } from '../state-schema.mjs';
|
|
12
18
|
import { nowTimestamp } from '../time-utils.mjs';
|
|
13
19
|
import { probeProject, classify, printDetection, validateContext, printGenerationGuide } from '../context-init.mjs';
|
|
14
20
|
import { fileExists, findActiveChange, readState, writeState, specsDir, runRootDir, hasExactSpecsEntry } from './state-io.mjs';
|
|
@@ -17,6 +23,18 @@ import { determineNode, normalAdvanceExempt } from './state-determine.mjs';
|
|
|
17
23
|
import { isInsideWorkTree, gitBranchName, branchExists, printBranchLine } from './state-branch.mjs';
|
|
18
24
|
import { printEvolveDueHint } from './state-evolve-hint.mjs';
|
|
19
25
|
import { reportIntelScanDrift } from './state-intelscan.mjs';
|
|
26
|
+
// 命令文本的唯一实现(平台化脚本根 + 整条路径加引号):运行期 PREFLIGHT 与 handoff result /
|
|
27
|
+
// guard 恢复指引 / explain 的 COMMAND 行同源(L-067:同一推导两处表达必然分叉)。声明命令与守卫族
|
|
28
|
+
// 同一装配(declarationCommands)+ 本族的运行上下文(commandContext)——不再各拼一份文本。
|
|
29
|
+
import { commandContext, declarationCommands, scriptCommand } from './state-explain.mjs';
|
|
30
|
+
// 协调者提示的单一来源:entry(门禁族)与 next / record(本模块)共用同一常量,各输出面逐字
|
|
31
|
+
// 一致。常量落在中立模块(state-explain)而不是门禁族——本模块只为一句措辞去依赖整个上游门禁面
|
|
32
|
+
// 是一条反向边——为此状态命令族不再 import 门禁族。
|
|
33
|
+
import { COORDINATOR_NOTICE } from './state-explain.mjs';
|
|
34
|
+
|
|
35
|
+
// 本模块位于 <技能包>/scripts/lib:脚本目录由自身位置推导一次(与 guard-evidence-gates 同形态)。
|
|
36
|
+
// 「自己在哪」是本模块可提供的事实,平台化与引号形态本身留在 state-explain。
|
|
37
|
+
const scriptsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
|
|
20
38
|
|
|
21
39
|
// --json-file 路径校验:解析后必须位于项目根内(拒绝相对/绝对形式的越界路径,
|
|
22
40
|
// 如 ../..、其他盘符——防读取任意文件内容进 evidence)。runRoot 内的绝对路径合法
|
|
@@ -70,12 +88,303 @@ function printNext(protocol, nodeId, executionMode = 'subagent') {
|
|
|
70
88
|
if (executionMode === 'direct' && nodeId === 'execute') {
|
|
71
89
|
console.log('EXECUTION-MODE: direct(主代理直接执行串行任务,必须加载 flow-comet-dev 完整协议;parallel 任务仍由 subagent-execute 委托)');
|
|
72
90
|
} else {
|
|
73
|
-
|
|
91
|
+
// 现行架构口径(ADR-014 / 并行委派四属性契约):委托按**平台的身份通道**判定,不是按
|
|
92
|
+
// 建树方式;独立 worktree 只是「① 写权限」的一种实现,共享工作区同样受支持(边界来自
|
|
93
|
+
// 互不重叠的任务写集、提交时点纪律与最小保护集)。文案取 guard-gates 的单一常量——
|
|
94
|
+
// entry 与 next 逐字相同;旧句「只能通过 Agent 工具 worktree isolation 委托子代理」不得
|
|
95
|
+
// 在任何一处复活。
|
|
96
|
+
console.log('COORDINATOR: ' + COORDINATOR_NOTICE);
|
|
74
97
|
console.log('EXECUTION-MODE: ' + (executionMode === 'direct' ? 'direct' : 'subagent'));
|
|
75
98
|
}
|
|
76
99
|
}
|
|
77
100
|
}
|
|
78
101
|
|
|
102
|
+
// ---------- 节点视图(单一实现):state 原值 / 产物推导 / 进行中保护 → 路由视图 ----------
|
|
103
|
+
// 「我现在该在哪个节点」只有这一份判定(同一事实两处实现必然分叉——LESSONS 的路由单一权威族)。
|
|
104
|
+
// 收敛前 next 内联一份、status 只报产物推导:同一 state 下两条命令报不同节点,执行者按任一输出
|
|
105
|
+
// 行动都可能撞上节点顺序门禁。收敛后三视图各归其位:
|
|
106
|
+
// derivedNode = 产物推导(既有键 currentNode 的语义,逐字不变);
|
|
107
|
+
// stateNode = state.currentNode 原值(既有键 stateCurrentNode 的语义,逐字不变);
|
|
108
|
+
// routeNode = 经「进行中保护」/「Fix 受控归位」后的路由视图(next 的 NODE 行的唯一来源)。
|
|
109
|
+
// 纯判定:只读 state 与产物,不写 state、不打印(展示由各命令渲染)。
|
|
110
|
+
// 消费方:status / next(本模块)与 workflow-handoff 的 result 提示(import 本函数,不复制第二份
|
|
111
|
+
// 判定——Fix 归位态若在 handoff 侧另取 state.currentNode,会指到被 Fix 批次门禁拦下的源节点)。
|
|
112
|
+
//
|
|
113
|
+
// routeNode 为 null 是**合法取值**:此态 next 会 BLOCKED 且不打印 NODE(节点顺序门禁 / Fix 归位第 4
|
|
114
|
+
// 轮无授权 / 单趟零进展),视图不得编一个节点出来——编出来的那个就是「status 叫人去一个 next 不会去
|
|
115
|
+
// 的地方」。
|
|
116
|
+
|
|
117
|
+
// ---------- 「此态 next 会 BLOCKED」的只读判定(status 用) ----------
|
|
118
|
+
// next 有三条**不打印 NODE**、直接 BLOCKED 的分支:① Fix 受控归位第 4 轮无授权;② 节点顺序门禁
|
|
119
|
+
// (「疑似未 exit」);③ 单趟零进展。只读视图若照常给节点,同一 state 下两条命令就是两个答案(执行者
|
|
120
|
+
// 按 status 动手必然撞 BLOCKED),故三个判定都在视图里求值、由 resolveNodeView 回报,next 消费同一
|
|
121
|
+
// 字段而不另判一份。
|
|
122
|
+
// BLOCKED 报文 → 单行原因(ROUTE: 行只放一句原因,完整报文与恢复指引仍由 next 打印)。
|
|
123
|
+
function blockedReason(message) {
|
|
124
|
+
return String(message ?? '').split('\n')[0].replace(/^BLOCKED:\s*/, '');
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
// 单趟零进展防呆(三重防呆决策之二·状态机侧):路由落在 execute/subagent-execute,但既无可委托的
|
|
128
|
+
// 并行任务(依赖已满足集合为空)又无串行 pending,且 TASK 尚未全 done——剩余 pending 全部是依赖
|
|
129
|
+
// 无法满足的孤儿并行任务(数据异常:depends_on 引用不存在的任务 id 或执行期出现依赖环)。命中即
|
|
130
|
+
// 返回 BLOCKED 报文(判定行 + 恢复指引行),否则 null。协议无 subagent-execute 节点时不适用
|
|
131
|
+
// (parallel 任务由 execute 直接消化,无孤儿语义)。依赖环的常规拦截点在 plan 出口(guard 前置),
|
|
132
|
+
// 此处兜底执行期数据异常(如手改 TASK 绕过签名校验的极端态)。
|
|
133
|
+
async function resolveZeroProgressBlock({ changeName, protocol, nodeId }) {
|
|
134
|
+
if (!EXECUTE_FAMILY_NODE_IDS.has(nodeId)) return null;
|
|
135
|
+
if (!hasSubagentNode(protocol)) return null;
|
|
136
|
+
try {
|
|
137
|
+
const zpBlocks = taskBlocks(await fs.readFile(protocolTaskFilePath(protocol, changeName, specsDir()), 'utf8'));
|
|
138
|
+
const zpAttrs = zpBlocks.map(taskOpeningAttrs).filter(Boolean);
|
|
139
|
+
const zpPending = zpAttrs.filter((a) => a.status === 'pending');
|
|
140
|
+
if (zpPending.length === 0) return null;
|
|
141
|
+
const zpDoneIds = new Set(zpAttrs.filter((a) => a.status === 'done' && a.id).map((a) => a.id));
|
|
142
|
+
const zpEligible = zpBlocks.filter((block) => {
|
|
143
|
+
const a = taskOpeningAttrs(block);
|
|
144
|
+
if (!a || !a.parallel || a.status !== 'pending') return false;
|
|
145
|
+
const depsMatch = block.match(/<depends_on>([\s\S]*?)<\/depends_on>/);
|
|
146
|
+
if (!depsMatch || !depsMatch[1].trim()) return true;
|
|
147
|
+
return depsMatch[1].trim().split(/[,\s]+/).filter(Boolean).every((d) => zpDoneIds.has(d));
|
|
148
|
+
});
|
|
149
|
+
const zpSerial = zpPending.filter((a) => !a.parallel);
|
|
150
|
+
if (zpEligible.length === 0 && zpSerial.length === 0) {
|
|
151
|
+
return [
|
|
152
|
+
'BLOCKED: 路由零进展——既无可委托的并行任务(依赖已满足集合为空)也无串行 pending,但 TASK 尚有 ' + zpPending.length + ' 个未完成任务',
|
|
153
|
+
'疑似孤儿并行任务依赖无法满足(检查 depends_on):' + zpPending.map((a) => a.id).join(', ') + '——修正 depends_on 为真实存在且无环的任务 id 后重试;执行期出现此异常请核对 TASK.md 是否被手改',
|
|
154
|
+
].join('\n');
|
|
155
|
+
}
|
|
156
|
+
} catch {}
|
|
157
|
+
return null;
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
// 节点顺序门禁(严格模式)→ BLOCKED 报文;判定与 next 的反例语义逐字不变(本函数自 next 内联判定
|
|
161
|
+
// 原样搬入,搬的是**同一份**判据与报文,不是第二份):
|
|
162
|
+
// state.currentNode 非 null、不在 completedNodes、且 evidence 无该节点记录 → 上一节点从未 exit 就
|
|
163
|
+
// 推进。状态漂移校正保留:已完成节点(currentNode ∈ completedNodes,或 evidence 已记录——节点已被
|
|
164
|
+
// record/exit 处理过)正常推进不受影响;本判定只拦「证据完全缺失的疑似跳阶段」。
|
|
165
|
+
// 豁免两条(独立判断,任一成立即放行):① 回退豁免(TASK.md 有 pending 回退修复任务 → execute 家族,
|
|
166
|
+
// 与 FIX-BATCH 决策同一谓词);② 正常推进豁免(exit --apply 推进后的下一节点,见 normalAdvanceExempt)
|
|
167
|
+
// ——真乱序(跳节点)仍严格 BLOCK。
|
|
168
|
+
// 归属:next 曾内联这一份,而 status 照常给节点——同一 state 下「status 叫人 exit 一个 next 根本不会
|
|
169
|
+
// 打印的节点」。搬进共享视图后 next 只消费 view.blocked,两份判定不再可能分叉。
|
|
170
|
+
async function resolveNodeOrderBlock({ changeName, protocol, completedArr, state }) {
|
|
171
|
+
if (!state.currentNode || completedArr.includes(state.currentNode)) return null;
|
|
172
|
+
const nodeEvidence = state.evidence && typeof state.evidence === 'object'
|
|
173
|
+
? state.evidence[state.currentNode]
|
|
174
|
+
: null;
|
|
175
|
+
if (nodeEvidence && typeof nodeEvidence === 'object' && !Array.isArray(nodeEvidence)) return null;
|
|
176
|
+
const rollbackExempt = await resolveFixRollbackState({
|
|
177
|
+
runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr, currentNode: state.currentNode,
|
|
178
|
+
history: state.history,
|
|
179
|
+
});
|
|
180
|
+
const advanceExempt = await normalAdvanceExempt(state, protocol, completedArr, state.currentNode, changeName);
|
|
181
|
+
if (rollbackExempt || advanceExempt) return null;
|
|
182
|
+
return [
|
|
183
|
+
'BLOCKED: 疑似未 exit 节点 ' + state.currentNode + ',先 workflow-guard.mjs exit ' + state.currentNode + ' --apply',
|
|
184
|
+
'恢复: 确认当前节点实际已完成 → 用 exit <节点> --apply 正常推进;节点状态漂移/卡死 → 用 workflow-state.mjs advance(强制推进)或 select(切换 change);禁止手改 state 机器字段',
|
|
185
|
+
].join('\n');
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
// 回程态判定(与 next 的 RETURN 分支同一谓词):resolveFixReturnNode 给出回程源节点、它就是
|
|
189
|
+
// state.currentNode,且产物推导确实把路由推到了它**之后**(跳过)⇒ next 保留源节点跑出口,路由视图
|
|
190
|
+
// 也只能是源节点。artifactNext 落在源节点之前(如 execute 产物缺失时回退)不是合法回程态——
|
|
191
|
+
// 回落既有门禁,不越界放宽。
|
|
192
|
+
async function resolveFixReturnTarget({ changeName, protocol, completedArr, state, derivedNode, currentNodeIdx, derivedIdx }) {
|
|
193
|
+
if (!state.activeChange) return null;
|
|
194
|
+
const sourceNode = await resolveFixReturnNode({
|
|
195
|
+
runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr,
|
|
196
|
+
});
|
|
197
|
+
if (sourceNode === null || sourceNode !== state.currentNode) return null;
|
|
198
|
+
if (derivedNode === state.currentNode) return null;
|
|
199
|
+
if (currentNodeIdx < 0 || derivedIdx <= currentNodeIdx) return null;
|
|
200
|
+
return sourceNode;
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
export async function resolveNodeView({ changeName, protocol, state }) {
|
|
204
|
+
const completedArr = Array.isArray(state.completedNodes) ? state.completedNodes : [];
|
|
205
|
+
const derivedNode = await determineNode(changeName, protocol, completedArr);
|
|
206
|
+
// 进行中节点保护:currentNode 未 exit(不在 completedNodes)且已 entry(enteredNodes 含该节点)
|
|
207
|
+
// 或已 record(evidence 记录过)→ 视为进行中(可能 exit 被内容级拦截后重跑),不校正推走——
|
|
208
|
+
// 否则被拦截节点的 exit 前置校验(currentNode 匹配)无法重跑,advance/select 均不恢复 → 死结
|
|
209
|
+
// (实测教训)。旧 state 无 enteredNodes 时回退 evidence 判定(既有语义不回归)。
|
|
210
|
+
const currentNodeEvidence = state.currentNode && state.evidence && typeof state.evidence === 'object'
|
|
211
|
+
? state.evidence[state.currentNode]
|
|
212
|
+
: null;
|
|
213
|
+
const currentNodeEntered = !!(
|
|
214
|
+
state.enteredNodes && Array.isArray(state.enteredNodes) && state.enteredNodes.includes(state.currentNode)
|
|
215
|
+
);
|
|
216
|
+
const routeIds = route(protocol).map((n) => n.id);
|
|
217
|
+
const currentNodeIdx = state.currentNode ? routeIds.indexOf(state.currentNode) : -1;
|
|
218
|
+
// 推导为 currentNode 的**路由后继**(与 guard 出口同源:把 currentNode 视为已完成再加入
|
|
219
|
+
// completedNodes 求 resolveNextNode)→ 该节点产物已齐待 exit、路由自然推进到 derivedNode
|
|
220
|
+
// (平行转换 plan→subagent-execute、趟间回流 subagent-execute→execute 均属此形态)→ 保护。
|
|
221
|
+
// 反过度修复锚(同族:产物全齐但无推进史形态):completedNodes 为空(无任何 exit 推进史,
|
|
222
|
+
// currentNode 仅是初始陈旧节点)时不做路由后继保护——产物推导继续生效推进到最终节点。
|
|
223
|
+
// 推导跳跃/跨节点或回退 → 产物权威校正(漂移,防过度修复)。静态直接后继兜底(串行推进原语义)。
|
|
224
|
+
const routingSuccessorOfCurrent = state.currentNode
|
|
225
|
+
? await determineNode(changeName, protocol, [...completedArr, state.currentNode])
|
|
226
|
+
: null;
|
|
227
|
+
// 「相等」还不是后继:等号只在两处推导同值时成立,派生的节点仍可能在 currentNode **之前**
|
|
228
|
+
// (currentNode 之后的节点产物缺失 → 派生回退;或 Fix 归位把任务推回 execute)——此时按等号
|
|
229
|
+
// 保护会把路由钉在 currentNode、吞掉产物权威校正(实测:verify 驻留 + REVIEW.md 缺失仍报
|
|
230
|
+
// verify)。故补协议 route 顺序条件:derived 的下标必须严格大于 currentNode 的下标。
|
|
231
|
+
// 两个例外都维持既有语义:① execute 家族之内——execute ⇄ subagent-execute 是同一个多趟
|
|
232
|
+
// **循环**,route 里的一前一后不是先后关系(趟间回边本就是文档化转换);波次收齐后只剩串行
|
|
233
|
+
// pending 时若按序号判「之前」,next 会把 currentNode 推回 execute,波次出口再也无法重跑
|
|
234
|
+
// (L-060 型死结)。② currentNode 不在协议 route 内(无先后可比)。
|
|
235
|
+
const derivedIdx = routeIds.indexOf(derivedNode);
|
|
236
|
+
const insideExecuteFamily = EXECUTE_FAMILY_NODE_IDS.has(derivedNode)
|
|
237
|
+
&& EXECUTE_FAMILY_NODE_IDS.has(state.currentNode);
|
|
238
|
+
const derivedIsAfterCurrent = currentNodeIdx < 0
|
|
239
|
+
|| insideExecuteFamily
|
|
240
|
+
|| (derivedIdx >= 0 && derivedIdx > currentNodeIdx);
|
|
241
|
+
const routingSuccessorProtects = !!(completedArr.length > 0
|
|
242
|
+
&& routingSuccessorOfCurrent !== null
|
|
243
|
+
&& routingSuccessorOfCurrent === derivedNode
|
|
244
|
+
&& derivedIsAfterCurrent);
|
|
245
|
+
const derivedIsDirectSuccessor = currentNodeIdx >= 0
|
|
246
|
+
&& currentNodeIdx + 1 < routeIds.length
|
|
247
|
+
&& routeIds[currentNodeIdx + 1] === derivedNode;
|
|
248
|
+
const derivedIsSuccessor = routingSuccessorProtects || derivedIsDirectSuccessor;
|
|
249
|
+
const inProgress = !!(
|
|
250
|
+
state.currentNode
|
|
251
|
+
&& !completedArr.includes(state.currentNode)
|
|
252
|
+
&& (currentNodeEntered
|
|
253
|
+
|| (currentNodeEvidence && typeof currentNodeEvidence === 'object' && !Array.isArray(currentNodeEvidence)))
|
|
254
|
+
&& derivedIsSuccessor
|
|
255
|
+
);
|
|
256
|
+
// Fix 受控归位(同一事实同一说法):next 的 FIX-BATCH 分支在共享视图之前返回并打印归位目标,
|
|
257
|
+
// status 只走共享视图 ⇒ 同一 state 下两条命令报不同节点,且 status 会叫人 exit 一个正在被
|
|
258
|
+
// Fix 批次门禁拦下的源节点(C1)。此处只读消费同一决策(纯读:不写盘、不计轮次),命中即把
|
|
259
|
+
// 归位目标作为路由视图——它是 next 的 NODE 行会打印的节点。
|
|
260
|
+
const fixRollback = await resolveFixRollbackDecision({
|
|
261
|
+
runRoot: runRootDir(),
|
|
262
|
+
changeName,
|
|
263
|
+
protocol,
|
|
264
|
+
completedNodes: completedArr,
|
|
265
|
+
currentNode: state.currentNode,
|
|
266
|
+
history: state.history,
|
|
267
|
+
});
|
|
268
|
+
const fixRollbackTarget = fixRollback === null ? null : fixRollback.target;
|
|
269
|
+
// 归位**只读预演**:next 在归位分支命中后会调 applyFixRollbackRound(唯一写点)计数,第 4 轮
|
|
270
|
+
// 无授权时在任何写盘之前 BLOCK——status 若照常给节点,给的就是 next 根本不会打印的那个答案。
|
|
271
|
+
// 预演在 state 的**副本**上跑同一 helper:阈值/授权/渐进放行的判据与 next 逐字同源(不是第二份
|
|
272
|
+
// 实现),而真 state 的字段(含 fixRoundsByChange)不可能被改动,也不写盘(字节零改写)。
|
|
273
|
+
const fixRollbackPreview = fixRollback === null
|
|
274
|
+
? null
|
|
275
|
+
: applyFixRollbackRound({
|
|
276
|
+
state: structuredClone(state),
|
|
277
|
+
sourceNode: state.currentNode,
|
|
278
|
+
decision: fixRollback,
|
|
279
|
+
});
|
|
280
|
+
// 三个 blocked 来源按 next 的分支顺序求值(同一先后,不是另一套优先级):
|
|
281
|
+
// ① Fix 受控归位第 4 轮无授权(next 的 FIX-BATCH 分支最先 BLOCK);
|
|
282
|
+
// ② 节点顺序门禁(next 的「疑似未 exit」);
|
|
283
|
+
// ③ 单趟零进展。
|
|
284
|
+
// 回程(fixReturnTarget)夹在 ② 之前:回程态下「源节点未出口」正是回程语义本身,顺序门禁不得推翻
|
|
285
|
+
// next 的回程分支(next 的回程分支先于顺序门禁返回);顺序门禁又先于零进展(零进展是路由落到
|
|
286
|
+
// execute 家族后的形态,执行者先要处理当前节点)。零进展成立时不再求回程——与 next 的既有先后一致
|
|
287
|
+
// (零进展态下回程分支不会被走到)。
|
|
288
|
+
const fixRoundBlockedMessage = fixRollbackPreview?.blocked ? fixRollbackPreview.blockedMessage : null;
|
|
289
|
+
const zeroProgressMessage = fixRoundBlockedMessage === null
|
|
290
|
+
? await resolveZeroProgressBlock({ changeName, protocol, nodeId: derivedNode })
|
|
291
|
+
: null;
|
|
292
|
+
const fixReturnTarget = fixRoundBlockedMessage === null && zeroProgressMessage === null
|
|
293
|
+
? await resolveFixReturnTarget({
|
|
294
|
+
changeName, protocol, completedArr, state, derivedNode, currentNodeIdx, derivedIdx,
|
|
295
|
+
})
|
|
296
|
+
: null;
|
|
297
|
+
const orderBlockedMessage = fixRoundBlockedMessage === null && fixReturnTarget === null
|
|
298
|
+
? await resolveNodeOrderBlock({ changeName, protocol, completedArr, state })
|
|
299
|
+
: null;
|
|
300
|
+
const blockedMessage = fixRoundBlockedMessage ?? orderBlockedMessage ?? zeroProgressMessage;
|
|
301
|
+
const blocked = blockedMessage === null
|
|
302
|
+
? null
|
|
303
|
+
: { message: blockedMessage, reason: blockedReason(blockedMessage) };
|
|
304
|
+
return {
|
|
305
|
+
derivedNode,
|
|
306
|
+
stateNode: state.currentNode ?? null,
|
|
307
|
+
// 优先级与 next 的分支顺序一致:BLOCKED(不打印节点)→ Fix 归位 → 回程 → 进行中保护 → 产物推导。
|
|
308
|
+
// Fix 归位优先于进行中保护:保护输出的是源节点,而归位态下源节点的动作(exit)会被拦下。
|
|
309
|
+
routeNode: blocked !== null
|
|
310
|
+
? null
|
|
311
|
+
: (fixRollbackTarget ?? fixReturnTarget ?? (inProgress ? state.currentNode : derivedNode)),
|
|
312
|
+
inProgress,
|
|
313
|
+
fixRollbackTarget,
|
|
314
|
+
fixReturnTarget,
|
|
315
|
+
blocked,
|
|
316
|
+
};
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
// 人读诊断(status):JSON 块之后的一行三视图对账——derived = 产物推导、state = state 原值、
|
|
320
|
+
// route = 路由视图(= next 的 NODE);尾部原因与 printWhyLine 的分支一一对应(同一停留原因在四个
|
|
321
|
+
// 输出面上说同一句话):Fix 归位态点名「先按 next 的 FIX-BATCH 归位」——此时源节点的 exit 会被 Fix
|
|
322
|
+
// 批次门禁拦下,指引不得指向它;回程态说明「产物在场且未出口、保留源节点跑出口」——否则两列并排
|
|
323
|
+
// 却不给原因,读起来就是「产物推导指向源节点」;进行中点名「先 exit 该节点」。
|
|
324
|
+
// 前缀严格为 `ROUTE: `。
|
|
325
|
+
// BLOCKED 态(route=null)与 next 的实际行为一致:next 此刻不打印 NODE 而是直接 BLOCKED,ROUTE: 行
|
|
326
|
+
// 因此明确写「next 将 BLOCKED:<原因>」并把人推回恢复指引,而不是编一个节点让人去跑。
|
|
327
|
+
function formatRouteLine(view) {
|
|
328
|
+
const head = 'derived=' + (view.derivedNode ?? 'null') + '(产物推导)'
|
|
329
|
+
+ ' state=' + (view.stateNode ?? 'null') + '(state 原值)';
|
|
330
|
+
if (view.blocked !== null) {
|
|
331
|
+
return head + ' route=null(路由视图);next 将 BLOCKED:' + view.blocked.reason + '(先按恢复指引处理)';
|
|
332
|
+
}
|
|
333
|
+
const tail = view.fixRollbackTarget
|
|
334
|
+
? ';Fix 批次:先按 next 的 FIX-BATCH 归位 ' + view.fixRollbackTarget + ' 并跑完其出口'
|
|
335
|
+
: (view.fixReturnTarget
|
|
336
|
+
? ';回程:产物在场且未出口——保留源节点 ' + view.routeNode + ' 跑出口'
|
|
337
|
+
: (view.inProgress
|
|
338
|
+
? ';进行中:' + view.stateNode + ' 已 entry 未 exit——先 exit ' + view.stateNode + ' 再推进'
|
|
339
|
+
: ''));
|
|
340
|
+
return head + ' route=' + (view.routeNode ?? 'null') + '(路由视图)' + tail;
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
// 人读诊断(next):为什么停在这个节点。四种停留原因在同一实现里各有一段文案:
|
|
344
|
+
// · Fix 受控归位——归位目标待跑出口(源节点此时 exit 会被 Fix 批次门禁拦下,指引不得指向 exit);
|
|
345
|
+
// · 回程——产物已在场把路由推后,但源节点未出口(保留源节点跑出口,不是「产物推导指向源节点」);
|
|
346
|
+
// · 进行中——已 entry 未 exit(保护生效),动作是 exit 本节点;
|
|
347
|
+
// · 其余——产物推导。
|
|
348
|
+
// 共享节点视图路径、Fix 归位分支与回程分支都经本函数:同源不只在 NODE 行,解释行也是同一段文案。
|
|
349
|
+
function printWhyLine(view) {
|
|
350
|
+
if (view.routeNode === null) return;
|
|
351
|
+
let reason;
|
|
352
|
+
if (view.fixRollbackTarget) {
|
|
353
|
+
reason = 'Fix 批次归位 ' + view.fixRollbackTarget
|
|
354
|
+
+ (view.stateNode ? '(源节点 ' + view.stateNode + ')' : '')
|
|
355
|
+
+ '——先跑 ' + view.fixRollbackTarget + ' 四类出口,再回源节点 exit';
|
|
356
|
+
} else if (view.fixReturnTarget) {
|
|
357
|
+
// 回程态:节点停在源节点不是产物推导的结果(产物已把它推后),解释必须说清「为什么保留源节点」——
|
|
358
|
+
// 否则 WHY: 行会把它读成「产物推导指向源节点(无进行中节点)」这类错因。
|
|
359
|
+
reason = '回程源节点 ' + view.routeNode + ':产物在场且未出口,保留源节点跑出口';
|
|
360
|
+
} else if (view.inProgress) {
|
|
361
|
+
reason = '停在 ' + view.routeNode + '——已 entry 未 exit(进行中保护),先 exit ' + view.routeNode + ' 再推进';
|
|
362
|
+
} else {
|
|
363
|
+
reason = '产物推导指向 ' + view.routeNode + '(无进行中节点)';
|
|
364
|
+
}
|
|
365
|
+
console.log('WHY: ' + reason);
|
|
366
|
+
}
|
|
367
|
+
|
|
368
|
+
// 结构预检提示的命令段(单一实现,两个运行期输出面共用:next 与 handoff result):--preflight 只跑
|
|
369
|
+
// 结构性门禁(不写 state、不写提示账本、不推进状态),它**不是**节点收尾的预演——完整 exit(不带
|
|
370
|
+
// --apply)才是全链预演。两句必须同行,否则同一个 PREFLIGHT 会被读成两条命令。节点由
|
|
371
|
+
// 调用方按**路由视图**传入(与 NODE 行同源),不得取 state 原值:Fix 归位态下源节点的 exit 会被
|
|
372
|
+
// Fix 批次门禁拦下。
|
|
373
|
+
export function structuralPreflightHint(nodeId) {
|
|
374
|
+
// 命令文本与 handoff result 的 PREFLIGHT 走同一实现(scriptCommand):平台化脚本根 + 整条
|
|
375
|
+
// 路径加引号——裸脚本名在 codex / dsh 单平台安装上照抄会落空(pathReplacements 只处理 .md)。
|
|
376
|
+
return '可运行 ' + scriptCommand({
|
|
377
|
+
scriptsDir, runRoot: runRootDir(), script: 'workflow-guard.mjs', args: ['exit', nodeId, '--preflight'],
|
|
378
|
+
}) + ' 做结构预检(只跑结构性门禁,不写 state、不推进状态);完整 exit(不带 --apply)是节点收尾的全链预演';
|
|
379
|
+
}
|
|
380
|
+
|
|
381
|
+
// 预检提示(next):只在 execute / subagent-execute 路由上打印——让每任务的模板结构反馈前移到
|
|
382
|
+
// 任务收尾,而不是攒到节点出口。贴什么命令、两句如何分工见 structuralPreflightHint(单一实现)。
|
|
383
|
+
function printPreflightLine(nodeId) {
|
|
384
|
+
if (!nodeId || !EXECUTE_FAMILY_NODE_IDS.has(nodeId)) return;
|
|
385
|
+
console.log('PREFLIGHT: ' + structuralPreflightHint(nodeId));
|
|
386
|
+
}
|
|
387
|
+
|
|
79
388
|
// init <change-id> [--branch-prefix <prefix>] [--init-context|--init-skip]
|
|
80
389
|
// protocolPath = 入口 resolveProtocol 解析出的协议路径(协议来源绑定的持久化取值)
|
|
81
390
|
export async function runInit(protocol, argv, protocolPath) {
|
|
@@ -160,7 +469,9 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
160
469
|
if (prevState?.activeChange === changeName || specsDirExists) {
|
|
161
470
|
console.error('WARN: change ' + changeName + ' 已存在——重跑 init 将重置节点状态(completedNodes/evidence 清空)。若需继续已有 change,请用 advance/select 而非重跑 init。');
|
|
162
471
|
}
|
|
163
|
-
// E1: branchMode 自动判定——git
|
|
472
|
+
// E1: branchMode 自动判定——git 仓库 → true;非 git 仓库 → false。git 命令一律以运行根为 cwd
|
|
473
|
+
//(state-branch 族统一取 runRootDir)——分支判定/创建与状态落点因此跟同一个根,不会一个走 cwd、
|
|
474
|
+
// 一个走变量根。
|
|
164
475
|
const branchMode = isInsideWorkTree();
|
|
165
476
|
const state = {
|
|
166
477
|
activeChange: changeName,
|
|
@@ -254,7 +565,10 @@ export async function runStatus(protocol) {
|
|
|
254
565
|
return;
|
|
255
566
|
}
|
|
256
567
|
const state = await readState();
|
|
257
|
-
|
|
568
|
+
// 节点视图(与 next 共用同一判定):currentNode 仍取产物推导(既有键语义逐字不变),
|
|
569
|
+
// routeNode 才是经「进行中保护」后的路由视图(= next 的 NODE 行)。
|
|
570
|
+
const nodeView = await resolveNodeView({ changeName, protocol, state });
|
|
571
|
+
const detectedNode = nodeView.derivedNode;
|
|
258
572
|
// 派生视图(ADR-013 决策 11;改为事件为准):被强制推进的节点以
|
|
259
573
|
// state.history 中本 change 的 advance-forced 事件为唯一判据——按 change 过滤(兼容旧事件
|
|
260
574
|
// 无 change 字段),取 e.node 集合后与 completedNodes 求交。旧「completedNodes 含而 evidence
|
|
@@ -286,6 +600,8 @@ export async function runStatus(protocol) {
|
|
|
286
600
|
change: changeName,
|
|
287
601
|
currentNode: detectedNode,
|
|
288
602
|
stateCurrentNode: state.currentNode,
|
|
603
|
+
// 增量字段:next 会打印的路由视图(进行中保护后的节点);不写 state、既有键语义不变
|
|
604
|
+
routeNode: nodeView.routeNode,
|
|
289
605
|
completedNodes: state.completedNodes,
|
|
290
606
|
forcedNodes,
|
|
291
607
|
executionMode: state.executionMode ?? 'subagent',
|
|
@@ -293,10 +609,14 @@ export async function runStatus(protocol) {
|
|
|
293
609
|
branchMode: isInsideWorkTree(),
|
|
294
610
|
enablePrReview: state.enablePrReview ?? false,
|
|
295
611
|
artifactRoot: '.specs/' + changeName,
|
|
296
|
-
|
|
612
|
+
// 与 routeNode 同一判定(One predicate):本键回答「协调者模式是否生效」,必须指向路由视图
|
|
613
|
+
// 那个节点——若另取产物推导,进行中态会在同一响应里给出两个「当前节点」口径(routeNode=
|
|
614
|
+
// execute 而 coordinatorMode=false)。既有键名/类型/位置不变,只换判定来源。
|
|
615
|
+
coordinatorMode: EXECUTE_FAMILY_NODE_IDS.has(nodeView.routeNode),
|
|
297
616
|
// 新旧 change 标记——newChange true = 新 change(严格模式);false/缺失 = 旧 change(渐进)
|
|
298
617
|
newChange: state.newChange === true
|
|
299
618
|
}, null, 2));
|
|
619
|
+
console.log('ROUTE: ' + formatRouteLine(nodeView));
|
|
300
620
|
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
301
621
|
await printEvolveDueHint(state);
|
|
302
622
|
return;
|
|
@@ -334,6 +654,14 @@ export async function runNext(protocol) {
|
|
|
334
654
|
await writeState(state);
|
|
335
655
|
console.log('FIX-BATCH: 归位 ' + fixRollbackDecision.target + '(源节点 ' + sourceNode + ')' + rollbackRound.auditSuffix);
|
|
336
656
|
printNext(protocol, fixRollbackDecision.target, state.executionMode ?? 'subagent');
|
|
657
|
+
// 解释行与共享视图同一实现(printWhyLine):status 的 routeNode 与这行点名的节点是同一事实。
|
|
658
|
+
printWhyLine({
|
|
659
|
+
routeNode: fixRollbackDecision.target,
|
|
660
|
+
stateNode: sourceNode,
|
|
661
|
+
inProgress: false,
|
|
662
|
+
fixRollbackTarget: fixRollbackDecision.target,
|
|
663
|
+
});
|
|
664
|
+
printPreflightLine(fixRollbackDecision.target);
|
|
337
665
|
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
338
666
|
return;
|
|
339
667
|
}
|
|
@@ -342,136 +670,47 @@ export async function runNext(protocol) {
|
|
|
342
670
|
// 源节点;仅当源节点未完成、任务全 done、firstIncompletePostExecNode === currentNode
|
|
343
671
|
// 且 resolveNextNode 确实会跳过该节点时显式放行(只读不改写 state)。artifactNext ===
|
|
344
672
|
// currentNode 的形态落回既有正常逻辑(normalAdvanceExempt 覆盖),不放宽豁免面。
|
|
673
|
+
// 本块只做「可能是回程态」的廉价前置筛选(源节点未完成 = 回程谓词的必要条件),真正的判定取共享
|
|
674
|
+
// 视图的 fixReturnTarget——回程分支的 NODE 与 status.routeNode 是同一个值,源节点未 entry /
|
|
675
|
+
// 无 evidence 的构造态里两者不再分叉(旧实现直接打印 state.currentNode,status 报产物后继)。
|
|
345
676
|
const fixReturnNode = state.activeChange
|
|
346
677
|
? await resolveFixReturnNode({ runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr })
|
|
347
678
|
: null;
|
|
348
679
|
if (fixReturnNode !== null && fixReturnNode === state.currentNode) {
|
|
349
|
-
const
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
// 产物缺失时回退到 execute)不是合法回程态,落回既有门禁,防止越界放宽(既有门禁反例锚)。
|
|
355
|
-
const skipsForward = artifactNext !== state.currentNode
|
|
356
|
-
&& currentIdx >= 0
|
|
357
|
-
&& artifactNextIdx > currentIdx;
|
|
358
|
-
if (skipsForward) {
|
|
359
|
-
console.log('RETURN: 回程源节点 ' + fixReturnNode + '(源节点产物在场且未出口;保留源节点跑出口)');
|
|
360
|
-
printNext(protocol, state.currentNode, state.executionMode ?? 'subagent');
|
|
680
|
+
const returnView = await resolveNodeView({ changeName, protocol, state });
|
|
681
|
+
if (returnView.fixReturnTarget !== null) {
|
|
682
|
+
console.log('RETURN: 回程源节点 ' + returnView.fixReturnTarget + '(源节点产物在场且未出口;保留源节点跑出口)');
|
|
683
|
+
printNext(protocol, returnView.routeNode, state.executionMode ?? 'subagent');
|
|
684
|
+
printWhyLine(returnView);
|
|
361
685
|
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
362
686
|
return;
|
|
363
687
|
}
|
|
364
688
|
}
|
|
365
|
-
//
|
|
366
|
-
//
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
//
|
|
370
|
-
//
|
|
371
|
-
//
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
const hasEvidence = !!(nodeEvidence && typeof nodeEvidence === 'object' && !Array.isArray(nodeEvidence));
|
|
377
|
-
if (!hasEvidence) {
|
|
378
|
-
// 回退豁免(显式分支已先行;此处按共享谓词保留门禁层语义,不再内联第二份判定)——
|
|
379
|
-
// review/verify 发现缺陷追加 pending 修复任务后回 execute 的修复任务标准回退路径放行
|
|
380
|
-
// (否则被严格模式误拦为"未 exit 跳阶段");豁免条件不满足时维持严格 BLOCK
|
|
381
|
-
const rollbackExempt = await resolveFixRollbackState({
|
|
382
|
-
runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr, currentNode: state.currentNode,
|
|
383
|
-
history: state.history,
|
|
384
|
-
});
|
|
385
|
-
// 正常推进豁免——exit --apply 推进 currentNode 到下一节点后按 SKILL 协议调 next
|
|
386
|
-
// (正常路径)不拦截;与回退豁免独立判断(详见 normalAdvanceExempt 注释)
|
|
387
|
-
const advanceExempt = await normalAdvanceExempt(state, protocol, completedArr, state.currentNode, changeName);
|
|
388
|
-
if (!rollbackExempt && !advanceExempt) {
|
|
389
|
-
console.error('BLOCKED: 疑似未 exit 节点 ' + state.currentNode + ',先 workflow-guard.mjs exit ' + state.currentNode + ' --apply');
|
|
390
|
-
console.error('恢复: 确认当前节点实际已完成 → 用 exit <节点> --apply 正常推进;节点状态漂移/卡死 → 用 workflow-state.mjs advance(强制推进)或 select(切换 change);禁止手改 state 机器字段');
|
|
391
|
-
process.exit(1);
|
|
392
|
-
}
|
|
393
|
-
}
|
|
394
|
-
}
|
|
395
|
-
const detectedNode = await determineNode(changeName, protocol, state.completedNodes);
|
|
396
|
-
// 单趟零进展防呆(三重防呆决策之二·状态机侧):路由落在 execute/subagent-execute,但既无可委托的并行任务
|
|
397
|
-
// (依赖已满足集合为空)又无串行 pending,且 TASK 未全 done——剩余 pending 全部是依赖无法满足的
|
|
398
|
-
// 孤儿并行任务(数据异常:depends_on 引用不存在的任务 id 或执行期出现依赖环)→ BLOCKED,
|
|
399
|
-
// 防止静默路由到无法推进的节点造成死循环/死等。协议无 subagent-execute 节点时不适用
|
|
400
|
-
// (parallel 任务由 execute 直接消化,无孤儿语义)。依赖环的常规拦截点在 plan 出口(guard 前置),
|
|
401
|
-
// 此处兜底执行期数据异常(如手改 TASK 绕过签名校验的极端态)。
|
|
402
|
-
if (EXECUTE_FAMILY_NODE_IDS.has(detectedNode)) {
|
|
403
|
-
if (hasSubagentNode(protocol)) {
|
|
404
|
-
try {
|
|
405
|
-
const zpBlocks = taskBlocks(await fs.readFile(protocolTaskFilePath(protocol, changeName, specsDir()), 'utf8'));
|
|
406
|
-
const zpAttrs = zpBlocks.map(taskOpeningAttrs).filter(Boolean);
|
|
407
|
-
const zpPending = zpAttrs.filter((a) => a.status === 'pending');
|
|
408
|
-
if (zpPending.length > 0) {
|
|
409
|
-
const zpDoneIds = new Set(zpAttrs.filter((a) => a.status === 'done' && a.id).map((a) => a.id));
|
|
410
|
-
const zpEligible = zpBlocks.filter((block) => {
|
|
411
|
-
const a = taskOpeningAttrs(block);
|
|
412
|
-
if (!a || !a.parallel || a.status !== 'pending') return false;
|
|
413
|
-
const depsMatch = block.match(/<depends_on>([\s\S]*?)<\/depends_on>/);
|
|
414
|
-
if (!depsMatch || !depsMatch[1].trim()) return true;
|
|
415
|
-
return depsMatch[1].trim().split(/[,\s]+/).filter(Boolean).every((d) => zpDoneIds.has(d));
|
|
416
|
-
});
|
|
417
|
-
const zpSerial = zpPending.filter((a) => !a.parallel);
|
|
418
|
-
if (zpEligible.length === 0 && zpSerial.length === 0) {
|
|
419
|
-
console.error('BLOCKED: 路由零进展——既无可委托的并行任务(依赖已满足集合为空)也无串行 pending,但 TASK 尚有 ' + zpPending.length + ' 个未完成任务');
|
|
420
|
-
console.error('疑似孤儿并行任务依赖无法满足(检查 depends_on):' + zpPending.map((a) => a.id).join(', ') + '——修正 depends_on 为真实存在且无环的任务 id 后重试;执行期出现此异常请核对 TASK.md 是否被手改');
|
|
421
|
-
process.exit(1);
|
|
422
|
-
}
|
|
423
|
-
}
|
|
424
|
-
} catch {}
|
|
425
|
-
}
|
|
689
|
+
// 节点视图(与 status 共用同一判定,见 resolveNodeView——节点顺序门禁也在其中,本命令不再内联
|
|
690
|
+
// 第二份):derivedNode 供零进展防呆与漂移校正使用,routeNode 才是输出节点(next 的 NODE 行)。
|
|
691
|
+
const nodeView = await resolveNodeView({ changeName, protocol, state });
|
|
692
|
+
const detectedNode = nodeView.derivedNode;
|
|
693
|
+
// 此态 next 不打印 NODE、直接 BLOCKED(节点顺序门禁 / 单趟零进展 / Fix 归位第 4 轮无授权):三个
|
|
694
|
+
// 判定与报文都在共享视图里(resolveNodeOrderBlock / resolveZeroProgressBlock / applyFixRollbackRound
|
|
695
|
+
// 的只读预演),本命令只消费而不另判一份——status 的「route=null + next 将 BLOCKED」来自同一字段,
|
|
696
|
+
// 两边答案因此一致。Fix 第 4 轮在 FIX-BATCH 分支已先行 BLOCK,此处的 blocked 只会是顺序门禁或零进展。
|
|
697
|
+
if (nodeView.blocked !== null) {
|
|
698
|
+
console.error(nodeView.blocked.message);
|
|
699
|
+
process.exit(1);
|
|
426
700
|
}
|
|
427
|
-
// 状态漂移自动校正——以文件产物为准(determineNode)校正 state.currentNode
|
|
428
|
-
//
|
|
429
|
-
//
|
|
430
|
-
|
|
431
|
-
const currentNodeEvidence = state.currentNode && state.evidence && typeof state.evidence === 'object'
|
|
432
|
-
? state.evidence[state.currentNode]
|
|
433
|
-
: null;
|
|
434
|
-
// 进行中节点保护扩展:保护从"已 record"扩展为"已 entry(enteredNodes 含该节点)且未 exit"。
|
|
435
|
-
// 已 entry 但未 record 的节点(如刚进入、产物已齐、premature next)同样视为进行中——
|
|
436
|
-
// 不校正推走(否则该节点 exit 前置 currentNode 校验无法重跑 → 死结)。旧 state 无
|
|
437
|
-
// enteredNodes 时回退到 evidence 判定(既有语义不回归)。
|
|
438
|
-
const currentNodeEntered = !!(
|
|
439
|
-
state.enteredNodes && Array.isArray(state.enteredNodes) && state.enteredNodes.includes(state.currentNode)
|
|
440
|
-
);
|
|
441
|
-
const routeIds = route(protocol).map((n) => n.id);
|
|
442
|
-
const currentNodeIdx = state.currentNode ? routeIds.indexOf(state.currentNode) : -1;
|
|
443
|
-
// 推导为 currentNode 的**路由后继**(与 guard 出口同源:把 currentNode 视为已完成再加入
|
|
444
|
-
// completedNodes 求 resolveNextNode)→ 该节点产物已齐待 exit、路由自然推进到 detectedNode
|
|
445
|
-
// (平行转换 plan→subagent-execute、趟间回流 subagent-execute→execute 均属此形态)→ 保护。
|
|
446
|
-
// 反过度修复锚(同族:产物全齐但无推进史形态):completedNodes 为空(无任何 exit 推进史,currentNode 仅是初始
|
|
447
|
-
// 陈旧节点)时不做路由后继保护——产物推导继续生效推进到最终节点(自定义协议产物全齐的
|
|
448
|
-
// 「部分完成但产物齐」形态仍路由到最后节点)。静态直接后继兜底(串行推进原语义)。
|
|
449
|
-
// 推导跳跃/跨节点或回退 → 产物权威校正(漂移,防过度修复)。
|
|
450
|
-
const routingSuccessorOfCurrent = state.currentNode
|
|
451
|
-
? await determineNode(changeName, protocol, [...completedArr, state.currentNode])
|
|
452
|
-
: null;
|
|
453
|
-
const routingSuccessorProtects = !!(completedArr.length > 0
|
|
454
|
-
&& routingSuccessorOfCurrent !== null
|
|
455
|
-
&& routingSuccessorOfCurrent === detectedNode);
|
|
456
|
-
const derivedIsDirectSuccessor = currentNodeIdx >= 0
|
|
457
|
-
&& currentNodeIdx + 1 < routeIds.length
|
|
458
|
-
&& routeIds[currentNodeIdx + 1] === detectedNode;
|
|
459
|
-
const derivedIsSuccessor = routingSuccessorProtects || derivedIsDirectSuccessor;
|
|
460
|
-
const inProgress = !!(
|
|
461
|
-
state.currentNode
|
|
462
|
-
&& !completedArr.includes(state.currentNode)
|
|
463
|
-
&& (currentNodeEntered
|
|
464
|
-
|| (currentNodeEvidence && typeof currentNodeEvidence === 'object' && !Array.isArray(currentNodeEvidence)))
|
|
465
|
-
&& derivedIsSuccessor
|
|
466
|
-
);
|
|
467
|
-
if (!inProgress && state.currentNode !== detectedNode) {
|
|
701
|
+
// 状态漂移自动校正——以文件产物为准(determineNode)校正 state.currentNode。进行中节点不校正
|
|
702
|
+
// (已 entry / 已 record 且未 exit、路由仍在其后继):判定统一在 resolveNodeView 内,本命令不再
|
|
703
|
+
// 内联第二份(与 status 共用;被拦截节点若被推走,其 exit 前置 currentNode 校验无法重跑 → 死结)。
|
|
704
|
+
if (!nodeView.inProgress && state.currentNode !== detectedNode) {
|
|
468
705
|
state.currentNode = detectedNode;
|
|
469
706
|
await writeState(state);
|
|
470
707
|
}
|
|
471
|
-
//
|
|
472
|
-
//
|
|
473
|
-
const printNode =
|
|
708
|
+
// 输出跟随路由视图:进行中时输出 state.currentNode(而非产物推导——否则 state 保持 review 但
|
|
709
|
+
// 输出 NODE: verify,执行者按输出 action 仍然死结);非进行中即产物推导节点。
|
|
710
|
+
const printNode = nodeView.routeNode;
|
|
474
711
|
printNext(protocol, printNode, state.executionMode ?? 'subagent');
|
|
712
|
+
printWhyLine(nodeView);
|
|
713
|
+
printPreflightLine(printNode);
|
|
475
714
|
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
476
715
|
return;
|
|
477
716
|
}
|
|
@@ -516,6 +755,9 @@ export async function runSelect(protocol, argv) {
|
|
|
516
755
|
export async function runRecord(protocol, argv) {
|
|
517
756
|
const nodeId = argv[3];
|
|
518
757
|
if (!nodeId) throw new Error('record requires a Node id.');
|
|
758
|
+
// 声明命令的运行上下文(脚本路径 / 运行根 / 包根 / 本次解析到的协议):本命令的两处恢复指引都要
|
|
759
|
+
// 打印可照抄的命令,一次取好往下传——各调用点各取一次就是同一事实的多处表达。
|
|
760
|
+
const declarationContext = commandContext({ argv });
|
|
519
761
|
const state = await readState();
|
|
520
762
|
state.evidence = state.evidence || {};
|
|
521
763
|
// 解析 JSON 参数并展开到 evidence 顶层(summary/completedChecks/output-schema evidence 等);
|
|
@@ -550,7 +792,6 @@ export async function runRecord(protocol, argv) {
|
|
|
550
792
|
// trim 后以 {/[ 开头 → 视作"形似对象字面量";若 JSON.parse 失败 → fail-closed。
|
|
551
793
|
try {
|
|
552
794
|
parsed = raw ? JSON.parse(raw) : {};
|
|
553
|
-
if (typeof parsed !== 'object' || Array.isArray(parsed)) parsed = { summary: String(parsed) };
|
|
554
795
|
} catch {
|
|
555
796
|
// 契约解析失败 fail-closed:payload 形似对象但 JSON.parse 失败 → 报错并
|
|
556
797
|
// process.exit(1),不写 evidence——防状态污染(旧语义把不可解析 raw 静默作
|
|
@@ -568,6 +809,45 @@ export async function runRecord(protocol, argv) {
|
|
|
568
809
|
}
|
|
569
810
|
parsed = { summary: raw || 'recorded' };
|
|
570
811
|
}
|
|
812
|
+
// 载荷本身必须是对象(入口判据,先于形状校验与任何写盘):JSON 可解析的非对象取值
|
|
813
|
+
// (null / 数组 / 字符串 / 数字)旧实现两条路都错——null 一路放行到读 parsed.completedChecks 时
|
|
814
|
+
// 抛 TypeError(报文是堆栈,既不说哪一步错了、也不说载荷该长什么样),数组/字符串/数字则被静默
|
|
815
|
+
// 改写成 { summary: String(...) }(替调用方编了一份它没说过的载荷,证据从此不可按字段消费)。
|
|
816
|
+
// 本判据只在本入口:形状表(state-schema.evidencePayloadProblems)判的是「对象各字段的类型」,
|
|
817
|
+
// 载荷不是对象时它按设计放行——两件事各守自己边界内的事实,不互相越界。
|
|
818
|
+
if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
|
819
|
+
const payloadTypeName = parsed === null ? 'null' : (Array.isArray(parsed) ? 'array' : typeof parsed);
|
|
820
|
+
console.error('ERROR: record 载荷必须是对象(当前是 ' + payloadTypeName + ')—— state 未改写');
|
|
821
|
+
console.error('恢复: ' + scriptCommand({
|
|
822
|
+
scriptsDir,
|
|
823
|
+
runRoot: runRootDir(),
|
|
824
|
+
script: 'workflow-state.mjs',
|
|
825
|
+
args: ['record', nodeId, `'{"summary":"<本节点完成摘要>"}'`],
|
|
826
|
+
}) + ' 用对象载荷重试;载荷里的引号被 shell 吞掉时改用 --json-file <path> 传入 JSON 文件'
|
|
827
|
+
+ '(cmd.exe 请把单引号换成双引号,并转义载荷里原有的双引号)');
|
|
828
|
+
process.exit(1);
|
|
829
|
+
}
|
|
830
|
+
// 载荷形状校验(写入前 fail-closed;判定单一来源 = state-schema.evidencePayloadProblems):
|
|
831
|
+
// 类型错误的载荷不得落库——否则下游出口门禁只会报「缺 evidence: <schema>」,出错的是 record、
|
|
832
|
+
// 报错的却是 exit,执行者得自己反推载荷该写什么形状。故在此拦下:点名字段路径与当前类型,
|
|
833
|
+
// 给出可照抄的正确形态;只判类型/非空,取值是否合法(扫描份数、提名编号是否登记)仍归出口门禁。
|
|
834
|
+
const shapeProblems = evidencePayloadProblems(parsed);
|
|
835
|
+
if (shapeProblems.length > 0) {
|
|
836
|
+
console.error('ERROR: record 载荷形状不合法(写入前拒绝,state 未改写):');
|
|
837
|
+
for (const problem of shapeProblems) {
|
|
838
|
+
console.error(' ' + problem.field + ': ' + problem.message);
|
|
839
|
+
}
|
|
840
|
+
console.error('恢复: ' + scriptCommand({
|
|
841
|
+
scriptsDir,
|
|
842
|
+
runRoot: runRootDir(),
|
|
843
|
+
script: 'workflow-state.mjs',
|
|
844
|
+
args: ['record', nodeId, `'{"summary":"<本节点完成摘要>"}'`],
|
|
845
|
+
}) + ' 用类型合法的载荷重试(summary 为非空字符串;completedChecks 为字符串数组;'
|
|
846
|
+
+ 'lessonsNomination 为 { scanned, nominated[], reasonIfNone },nominated 元素是条目编号字符串)'
|
|
847
|
+
+ ';载荷里的引号被 shell 吞掉时改用 --json-file <path> 传入 JSON 文件'
|
|
848
|
+
+ '(cmd.exe 请把单引号换成双引号,并转义载荷里原有的双引号)');
|
|
849
|
+
process.exit(1);
|
|
850
|
+
}
|
|
571
851
|
// completedChecks 真实性校验(skill-load 声明标记)——解析本次 record 写入的
|
|
572
852
|
// completedChecks 的 required-skill:<node>.<skill> 条目 → 对应声明标记必须存在,
|
|
573
853
|
// 缺失 → BLOCKED + 指引先加载 skill 并运行 skill-load;标记 at 必须 ≤ 本次记录时间
|
|
@@ -578,23 +858,34 @@ export async function runRecord(protocol, argv) {
|
|
|
578
858
|
// 传入 protocol + state——按 requiredSkillCalls scope 分类条目(handoff scope 豁免标记,
|
|
579
859
|
// 以共用证据库 handoffResult 为证据)
|
|
580
860
|
const markerChange = state.activeChange || await findActiveChange();
|
|
581
|
-
const markerCheck = await verifySkillLoadMarkers(parsed.completedChecks, markerChange, recordedAt, protocol, state);
|
|
861
|
+
const markerCheck = await verifySkillLoadMarkers(parsed.completedChecks, markerChange, recordedAt, protocol, state, declarationContext);
|
|
582
862
|
if (!markerCheck.ok) {
|
|
583
863
|
console.error('BLOCKED: ' + markerCheck.reason);
|
|
584
864
|
process.exit(1);
|
|
585
865
|
}
|
|
586
866
|
// 技能加载前置门(方案 A):节点完成记录必须先有本节点
|
|
587
867
|
// skill-load 声明标记——无论 payload 是否含 completedChecks 都校验(堵"先干活后补
|
|
588
|
-
// 声明"旁路):缺失 → 新 change BLOCK / 旧 change 渐进 WARN
|
|
589
|
-
//
|
|
590
|
-
// verifySkillLoadMarkers 的 scope 豁免一致)——本门按
|
|
591
|
-
//
|
|
592
|
-
//
|
|
868
|
+
// 声明"旁路):缺失 → 新 change BLOCK / 旧 change 渐进 WARN。指引先加载技能,再照抄派生出的
|
|
869
|
+
// 声明命令(该节点每个必需技能各一条,全部协议文件 + 模板全清单)后重试。handoff scope 技能
|
|
870
|
+
// (子代理加载)不要求协调者声明(与 verifySkillLoadMarkers 的 scope 豁免一致)——本门按
|
|
871
|
+
// <node>-*.json 存在性判定,与 guard exit 侧协议声明标记校验同构。仅对存在于当前协议的节点生效
|
|
872
|
+
// (协议外节点名的记录不适用前置门),无 active change 时无法定位标记而不重复报错(遗留兼容)。
|
|
593
873
|
const recordNodeDef = (protocol.nodes ?? []).find((n) => n.id === nodeId);
|
|
594
874
|
if (recordNodeDef && markerChange) {
|
|
595
875
|
const declaredForNode = await hasNodeSkillDeclaration(nodeId, markerChange);
|
|
596
876
|
if (!declaredForNode) {
|
|
597
|
-
|
|
877
|
+
// 声明命令由协议派生(该节点每个必需技能各一条,每条都带该节点全部协议文件、模板全清单与
|
|
878
|
+
// 协议上下文),与守卫侧恢复段同一装配:旧形态是手拼的 "skill-load <node> <skill>"——位置实参位
|
|
879
|
+
// 写占位符在 bash 里是重定向,照抄直接语法失败;换成真名也只声明了一个技能、不带模板清单,
|
|
880
|
+
// record 放行后 exit 还要再拦一次。
|
|
881
|
+
const loadGuide = '先加载技能(用 Skill 工具,禁止跳过),再照抄下面的命令声明本节点技能加载'
|
|
882
|
+
+ '(同一 node-skill 重跑会覆写该标记):\n '
|
|
883
|
+
+ declarationCommands({
|
|
884
|
+
node: recordNodeDef,
|
|
885
|
+
skills: declarationSkillTargets(recordNodeDef),
|
|
886
|
+
context: declarationContext,
|
|
887
|
+
}).map((entry) => entry.command).join('\n ')
|
|
888
|
+
+ '\n然后重试 record';
|
|
598
889
|
if (state.newChange === true) {
|
|
599
890
|
console.error('BLOCKED: 节点 ' + nodeId + ' 缺少技能加载声明标记(.skill-loads/' + nodeId + '-*.json)——' + loadGuide);
|
|
600
891
|
process.exit(1);
|
|
@@ -609,6 +900,7 @@ export async function runRecord(protocol, argv) {
|
|
|
609
900
|
nodeId,
|
|
610
901
|
changeName: markerChange,
|
|
611
902
|
newChange: state.newChange === true,
|
|
903
|
+
commandContext: declarationContext,
|
|
612
904
|
});
|
|
613
905
|
if (templateCheck.warn) console.error('WARN: ' + templateCheck.warn);
|
|
614
906
|
if (!templateCheck.ok) {
|
|
@@ -668,9 +960,22 @@ export async function runRecord(protocol, argv) {
|
|
|
668
960
|
};
|
|
669
961
|
await writeState(state);
|
|
670
962
|
console.log('EVIDENCE: ' + nodeId);
|
|
963
|
+
// 节点视图与 next / status 同源(L-067 族):record 也是「我现在该在哪个节点」的输出面。直接取
|
|
964
|
+
// 产物推导会让三面在**进行中保护**生效时分叉(record 报 review,而 next / status.routeNode 报
|
|
965
|
+
// execute)——故复用 resolveNodeView 的 routeNode:本命令不自持第二份判定,也不改变自己的写面
|
|
966
|
+
// (record 只写证据,不写 currentNode,视图是纯读)。
|
|
671
967
|
const changeName = state.activeChange || await findActiveChange();
|
|
672
|
-
const
|
|
673
|
-
|
|
968
|
+
const nodeView = changeName ? await resolveNodeView({ changeName, protocol, state }) : null;
|
|
969
|
+
// 边界态(next 会 BLOCKED、不打印 NODE):record 是同一事实的第四个输出面,尾巴不得再声称
|
|
970
|
+
// 「NEXT: done」——那是在说「没有下一节点了」,与 next 的 BLOCKED、status.routeNode=null 相反。
|
|
971
|
+
// 命中时改打与 ROUTE: 行同源的一句(原因 + 先按恢复指引处理),NODE / SKILL 一律不打(next 此刻
|
|
972
|
+
// 也不打)。blocked 来自共享视图在 state 副本上的只读预演:轮次与 currentNode 不动,本命令的写面
|
|
973
|
+
// 仍只有它自己的证据。
|
|
974
|
+
if (nodeView?.blocked) {
|
|
975
|
+
console.log('NEXT: blocked(' + nodeView.blocked.reason + ';先按恢复指引处理)');
|
|
976
|
+
return;
|
|
977
|
+
}
|
|
978
|
+
printNext(protocol, nodeView?.routeNode ?? null, state.executionMode ?? 'subagent');
|
|
674
979
|
return;
|
|
675
980
|
}
|
|
676
981
|
|