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
|
@@ -5,18 +5,35 @@
|
|
|
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
|
-
|
|
12
|
-
|
|
11
|
+
import {
|
|
12
|
+
NODE_PROTOCOL_FILES,
|
|
13
|
+
declarationSkillTargets,
|
|
14
|
+
inspectWorkflowPathSegments,
|
|
15
|
+
} from '../protocol-utils.mjs';
|
|
16
|
+
import { evidencePayloadProblems, looksLikeObjectLiteral, toPersistedProtocolPath } from '../state-schema.mjs';
|
|
17
|
+
import { formatLocalTimestamp, nowTimestamp } from '../time-utils.mjs';
|
|
13
18
|
import { probeProject, classify, printDetection, validateContext, printGenerationGuide } from '../context-init.mjs';
|
|
14
|
-
import { fileExists, findActiveChange, readState, writeState, specsDir, runRootDir, hasExactSpecsEntry } from './state-io.mjs';
|
|
15
|
-
import { hasNodeSkillDeclaration, verifySkillLoadMarkers,
|
|
19
|
+
import { fileExists, findActiveChange, readState, writeState, specsDir, runRootDir, hasExactSpecsEntry, resolveChangeLocation, inFlightChangeName, stateFile, recoveryActionTextAt } from './state-io.mjs';
|
|
20
|
+
import { hasNodeSkillDeclaration, verifySkillLoadMarkers, verifyTemplateDeclaration } from './state-skillmarkers.mjs';
|
|
16
21
|
import { determineNode, normalAdvanceExempt } from './state-determine.mjs';
|
|
17
22
|
import { isInsideWorkTree, gitBranchName, branchExists, printBranchLine } from './state-branch.mjs';
|
|
18
23
|
import { printEvolveDueHint } from './state-evolve-hint.mjs';
|
|
19
24
|
import { reportIntelScanDrift } from './state-intelscan.mjs';
|
|
25
|
+
// 命令文本的唯一实现(平台化脚本根 + 整条路径加引号):运行期 PREFLIGHT 与 handoff result /
|
|
26
|
+
// guard 恢复指引 / explain 的 COMMAND 行同源(L-067:同一推导两处表达必然分叉)。声明命令与守卫族
|
|
27
|
+
// 同一装配(declarationCommands)+ 本族的运行上下文(commandContext)——不再各拼一份文本。
|
|
28
|
+
import { commandContext, declarationCommands, protocolContextArgs, scriptCommand } from './state-explain.mjs';
|
|
29
|
+
// 协调者提示的单一来源:entry(门禁族)与 next / record(本模块)共用同一常量,各输出面逐字
|
|
30
|
+
// 一致。常量落在中立模块(state-explain)而不是门禁族——本模块只为一句措辞去依赖整个上游门禁面
|
|
31
|
+
// 是一条反向边——为此状态命令族不再 import 门禁族。
|
|
32
|
+
import { COORDINATOR_NOTICE } from './state-explain.mjs';
|
|
33
|
+
|
|
34
|
+
// 本模块位于 <技能包>/scripts/lib:脚本目录由自身位置推导一次(与 guard-evidence-gates 同形态)。
|
|
35
|
+
// 「自己在哪」是本模块可提供的事实,平台化与引号形态本身留在 state-explain。
|
|
36
|
+
const scriptsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
|
|
20
37
|
|
|
21
38
|
// --json-file 路径校验:解析后必须位于项目根内(拒绝相对/绝对形式的越界路径,
|
|
22
39
|
// 如 ../..、其他盘符——防读取任意文件内容进 evidence)。runRoot 内的绝对路径合法
|
|
@@ -70,13 +87,461 @@ function printNext(protocol, nodeId, executionMode = 'subagent') {
|
|
|
70
87
|
if (executionMode === 'direct' && nodeId === 'execute') {
|
|
71
88
|
console.log('EXECUTION-MODE: direct(主代理直接执行串行任务,必须加载 flow-comet-dev 完整协议;parallel 任务仍由 subagent-execute 委托)');
|
|
72
89
|
} else {
|
|
73
|
-
|
|
90
|
+
// 现行架构口径(ADR-014 / 并行委派四属性契约):委托按**平台的身份通道**判定,不是按
|
|
91
|
+
// 建树方式;独立 worktree 只是「① 写权限」的一种实现,共享工作区同样受支持(边界来自
|
|
92
|
+
// 互不重叠的任务写集、提交时点纪律与最小保护集)。文案取 guard-gates 的单一常量——
|
|
93
|
+
// entry 与 next 逐字相同;旧句「只能通过 Agent 工具 worktree isolation 委托子代理」不得
|
|
94
|
+
// 在任何一处复活。
|
|
95
|
+
console.log('COORDINATOR: ' + COORDINATOR_NOTICE);
|
|
74
96
|
console.log('EXECUTION-MODE: ' + (executionMode === 'direct' ? 'direct' : 'subagent'));
|
|
75
97
|
}
|
|
76
98
|
}
|
|
77
99
|
}
|
|
78
100
|
|
|
101
|
+
// ---------- 位置门(单一实现 · 身份在办时位置必须可解析) ----------
|
|
102
|
+
// 身份由状态判定(findActiveChange),位置由 state-io 的唯一解析器给出。两者分开之后出现一类新的
|
|
103
|
+
// 非法态:**身份在办但两处目录都没有**(running-orphan:目录被手工删除 / 搬移失败)。此时命令层
|
|
104
|
+
// 既不能照旧打 no-change(那是在说「没有在办 change」),也不能编一个节点出来——只能 fail-closed
|
|
105
|
+
// 点名两处路径。报文与退出码归本族(state-io 只回传 { ok, message },自己不 exit),status / next /
|
|
106
|
+
// record 三面因此说同一句话。
|
|
107
|
+
async function requireChangeLocation(changeName, state) {
|
|
108
|
+
const located = await resolveChangeLocation({
|
|
109
|
+
root: runRootDir(),
|
|
110
|
+
changeName,
|
|
111
|
+
createdAt: state?.createdAt,
|
|
112
|
+
});
|
|
113
|
+
if (!located.ok) {
|
|
114
|
+
console.error(located.message);
|
|
115
|
+
process.exit(1);
|
|
116
|
+
}
|
|
117
|
+
return located.resolution;
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
// ---------- 节点视图(单一实现):state 原值 / 产物推导 / 进行中保护 → 路由视图 ----------
|
|
121
|
+
// 「我现在该在哪个节点」只有这一份判定(同一事实两处实现必然分叉——LESSONS 的路由单一权威族)。
|
|
122
|
+
// 收敛前 next 内联一份、status 只报产物推导:同一 state 下两条命令报不同节点,执行者按任一输出
|
|
123
|
+
// 行动都可能撞上节点顺序门禁。收敛后三视图各归其位:
|
|
124
|
+
// derivedNode = 产物推导(既有键 currentNode 的语义,逐字不变);
|
|
125
|
+
// stateNode = state.currentNode 原值(既有键 stateCurrentNode 的语义,逐字不变);
|
|
126
|
+
// routeNode = 经「进行中保护」/「Fix 受控归位」后的路由视图(next 的 NODE 行的唯一来源)。
|
|
127
|
+
// 纯判定:只读 state 与产物,不写 state、不打印(展示由各命令渲染)。
|
|
128
|
+
// 消费方:status / next(本模块)与 workflow-handoff 的 result 提示(import 本函数,不复制第二份
|
|
129
|
+
// 判定——Fix 归位态若在 handoff 侧另取 state.currentNode,会指到被 Fix 批次门禁拦下的源节点)。
|
|
130
|
+
//
|
|
131
|
+
// routeNode 为 null 是**合法取值**:此态 next 会 BLOCKED 且不打印 NODE(节点顺序门禁 / Fix 归位第 4
|
|
132
|
+
// 轮无授权 / 单趟零进展),视图不得编一个节点出来——编出来的那个就是「status 叫人去一个 next 不会去
|
|
133
|
+
// 的地方」。
|
|
134
|
+
|
|
135
|
+
// ---------- 「此态 next 会 BLOCKED」的只读判定(status 用) ----------
|
|
136
|
+
// next 有三条**不打印 NODE**、直接 BLOCKED 的分支:① Fix 受控归位第 4 轮无授权;② 节点顺序门禁
|
|
137
|
+
// (「疑似未 exit」);③ 单趟零进展。只读视图若照常给节点,同一 state 下两条命令就是两个答案(执行者
|
|
138
|
+
// 按 status 动手必然撞 BLOCKED),故三个判定都在视图里求值、由 resolveNodeView 回报,next 消费同一
|
|
139
|
+
// 字段而不另判一份。
|
|
140
|
+
// BLOCKED 报文 → 单行原因(ROUTE: 行只放一句原因,完整报文与恢复指引仍由 next 打印)。
|
|
141
|
+
function blockedReason(message) {
|
|
142
|
+
return String(message ?? '').split('\n')[0].replace(/^BLOCKED:\s*/, '');
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
// 单趟零进展防呆(三重防呆决策之二·状态机侧):路由落在 execute/subagent-execute,但既无可委托的
|
|
146
|
+
// 并行任务(依赖已满足集合为空)又无串行 pending,且 TASK 尚未全 done——剩余 pending 全部是依赖
|
|
147
|
+
// 无法满足的孤儿并行任务(数据异常:depends_on 引用不存在的任务 id 或执行期出现依赖环)。命中即
|
|
148
|
+
// 返回 BLOCKED 报文(判定行 + 恢复指引行),否则 null。协议无 subagent-execute 节点时不适用
|
|
149
|
+
// (parallel 任务由 execute 直接消化,无孤儿语义)。依赖环的常规拦截点在 plan 出口(guard 前置),
|
|
150
|
+
// 此处兜底执行期数据异常(如手改 TASK 绕过签名校验的极端态)。
|
|
151
|
+
async function resolveZeroProgressBlock({ changeName, protocol, nodeId }) {
|
|
152
|
+
if (!EXECUTE_FAMILY_NODE_IDS.has(nodeId)) return null;
|
|
153
|
+
if (!hasSubagentNode(protocol)) return null;
|
|
154
|
+
try {
|
|
155
|
+
const zpBlocks = taskBlocks(await fs.readFile(protocolTaskFilePath(protocol, changeName, specsDir()), 'utf8'));
|
|
156
|
+
const zpAttrs = zpBlocks.map(taskOpeningAttrs).filter(Boolean);
|
|
157
|
+
const zpPending = zpAttrs.filter((a) => a.status === 'pending');
|
|
158
|
+
if (zpPending.length === 0) return null;
|
|
159
|
+
const zpDoneIds = new Set(zpAttrs.filter((a) => a.status === 'done' && a.id).map((a) => a.id));
|
|
160
|
+
const zpEligible = zpBlocks.filter((block) => {
|
|
161
|
+
const a = taskOpeningAttrs(block);
|
|
162
|
+
if (!a || !a.parallel || a.status !== 'pending') return false;
|
|
163
|
+
const depsMatch = block.match(/<depends_on>([\s\S]*?)<\/depends_on>/);
|
|
164
|
+
if (!depsMatch || !depsMatch[1].trim()) return true;
|
|
165
|
+
return depsMatch[1].trim().split(/[,\s]+/).filter(Boolean).every((d) => zpDoneIds.has(d));
|
|
166
|
+
});
|
|
167
|
+
const zpSerial = zpPending.filter((a) => !a.parallel);
|
|
168
|
+
if (zpEligible.length === 0 && zpSerial.length === 0) {
|
|
169
|
+
return [
|
|
170
|
+
'BLOCKED: 路由零进展——既无可委托的并行任务(依赖已满足集合为空)也无串行 pending,但 TASK 尚有 ' + zpPending.length + ' 个未完成任务',
|
|
171
|
+
'疑似孤儿并行任务依赖无法满足(检查 depends_on):' + zpPending.map((a) => a.id).join(', ') + '——修正 depends_on 为真实存在且无环的任务 id 后重试;执行期出现此异常请核对 TASK.md 是否被手改',
|
|
172
|
+
].join('\n');
|
|
173
|
+
}
|
|
174
|
+
} catch {}
|
|
175
|
+
return null;
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
// 节点顺序门禁(严格模式)→ BLOCKED 报文;判定与 next 的反例语义逐字不变(本函数自 next 内联判定
|
|
179
|
+
// 原样搬入,搬的是**同一份**判据与报文,不是第二份):
|
|
180
|
+
// state.currentNode 非 null、不在 completedNodes、且 evidence 无该节点记录 → 上一节点从未 exit 就
|
|
181
|
+
// 推进。状态漂移校正保留:已完成节点(currentNode ∈ completedNodes,或 evidence 已记录——节点已被
|
|
182
|
+
// record/exit 处理过)正常推进不受影响;本判定只拦「证据完全缺失的疑似跳阶段」。
|
|
183
|
+
// 豁免两条(独立判断,任一成立即放行):① 回退豁免(TASK.md 有 pending 回退修复任务 → execute 家族,
|
|
184
|
+
// 与 FIX-BATCH 决策同一谓词);② 正常推进豁免(exit --apply 推进后的下一节点,见 normalAdvanceExempt)
|
|
185
|
+
// ——真乱序(跳节点)仍严格 BLOCK。
|
|
186
|
+
// 归属:next 曾内联这一份,而 status 照常给节点——同一 state 下「status 叫人 exit 一个 next 根本不会
|
|
187
|
+
// 打印的节点」。搬进共享视图后 next 只消费 view.blocked,两份判定不再可能分叉。
|
|
188
|
+
async function resolveNodeOrderBlock({ changeName, protocol, completedArr, state, changeDir = null }) {
|
|
189
|
+
if (!state.currentNode || completedArr.includes(state.currentNode)) return null;
|
|
190
|
+
const nodeEvidence = state.evidence && typeof state.evidence === 'object'
|
|
191
|
+
? state.evidence[state.currentNode]
|
|
192
|
+
: null;
|
|
193
|
+
if (nodeEvidence && typeof nodeEvidence === 'object' && !Array.isArray(nodeEvidence)) return null;
|
|
194
|
+
const rollbackExempt = await resolveFixRollbackState({
|
|
195
|
+
runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr, currentNode: state.currentNode,
|
|
196
|
+
history: state.history,
|
|
197
|
+
});
|
|
198
|
+
const advanceExempt = await normalAdvanceExempt(state, protocol, completedArr, state.currentNode, changeName, changeDir);
|
|
199
|
+
if (rollbackExempt || advanceExempt) return null;
|
|
200
|
+
// 第二行的恢复动作按目录在哪分叉——与出口侧(转移前置 / entry 记录门 / 证据门)同一实现
|
|
201
|
+
// (state-io.recoveryActionTextAt):目录已搬进归档时 advance / select 都走不通(select 要求活动
|
|
202
|
+
// 目录在场,advance 的产物推导读活动路径),只给可执行的那一步(把目录移回活动位置)。活动态下
|
|
203
|
+
// 该函数原样返回 activeText,输出因此与改动前逐字相同。
|
|
204
|
+
return [
|
|
205
|
+
'BLOCKED: 疑似未 exit 节点 ' + state.currentNode + ',先 workflow-guard.mjs exit ' + state.currentNode + ' --apply',
|
|
206
|
+
'恢复: 确认当前节点实际已完成 → 用 exit <节点> --apply 正常推进;节点状态漂移/卡死 → '
|
|
207
|
+
+ recoveryActionTextAt(runRootDir(), changeName, '用 workflow-state.mjs advance(强制推进)或 select(切换 change);禁止手改 state 机器字段'),
|
|
208
|
+
].join('\n');
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
// 回程态判定(与 next 的 RETURN 分支同一谓词):resolveFixReturnNode 给出回程源节点、它就是
|
|
212
|
+
// state.currentNode,且产物推导确实把路由推到了它**之后**(跳过)⇒ next 保留源节点跑出口,路由视图
|
|
213
|
+
// 也只能是源节点。artifactNext 落在源节点之前(如 execute 产物缺失时回退)不是合法回程态——
|
|
214
|
+
// 回落既有门禁,不越界放宽。
|
|
215
|
+
async function resolveFixReturnTarget({ changeName, protocol, completedArr, state, derivedNode, currentNodeIdx, derivedIdx }) {
|
|
216
|
+
if (!state.activeChange) return null;
|
|
217
|
+
const sourceNode = await resolveFixReturnNode({
|
|
218
|
+
runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr,
|
|
219
|
+
});
|
|
220
|
+
if (sourceNode === null || sourceNode !== state.currentNode) return null;
|
|
221
|
+
if (derivedNode === state.currentNode) return null;
|
|
222
|
+
if (currentNodeIdx < 0 || derivedIdx <= currentNodeIdx) return null;
|
|
223
|
+
return sourceNode;
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
// location = 位置门解析到的结果(state-io.resolveChangeDir);缺省 null 时按 .specs/<changeName> 解析
|
|
227
|
+
// (既有形态)。产物推导必须与位置解析认同一个目录:目录搬进归档后仍按活动路径推导,视图会回退到
|
|
228
|
+
// 协议首节点(「移动后 record 打 NODE: open」的成因)。
|
|
229
|
+
export async function resolveNodeView({ changeName, protocol, state, location = null }) {
|
|
230
|
+
const completedArr = Array.isArray(state.completedNodes) ? state.completedNodes : [];
|
|
231
|
+
const changeDir = location === null ? null : location.relative;
|
|
232
|
+
const derivedNode = await determineNode(changeName, protocol, completedArr, changeDir);
|
|
233
|
+
// 进行中节点保护:currentNode 未 exit(不在 completedNodes)且已 entry(enteredNodes 含该节点)
|
|
234
|
+
// 或已 record(evidence 记录过)→ 视为进行中(可能 exit 被内容级拦截后重跑),不校正推走——
|
|
235
|
+
// 否则被拦截节点的 exit 前置校验(currentNode 匹配)无法重跑,advance/select 均不恢复 → 死结
|
|
236
|
+
// (实测教训)。旧 state 无 enteredNodes 时回退 evidence 判定(既有语义不回归)。
|
|
237
|
+
const currentNodeEvidence = state.currentNode && state.evidence && typeof state.evidence === 'object'
|
|
238
|
+
? state.evidence[state.currentNode]
|
|
239
|
+
: null;
|
|
240
|
+
const currentNodeEntered = !!(
|
|
241
|
+
state.enteredNodes && Array.isArray(state.enteredNodes) && state.enteredNodes.includes(state.currentNode)
|
|
242
|
+
);
|
|
243
|
+
const routeIds = route(protocol).map((n) => n.id);
|
|
244
|
+
const currentNodeIdx = state.currentNode ? routeIds.indexOf(state.currentNode) : -1;
|
|
245
|
+
// 推导为 currentNode 的**路由后继**(与 guard 出口同源:把 currentNode 视为已完成再加入
|
|
246
|
+
// completedNodes 求 resolveNextNode)→ 该节点产物已齐待 exit、路由自然推进到 derivedNode
|
|
247
|
+
// (平行转换 plan→subagent-execute、趟间回流 subagent-execute→execute 均属此形态)→ 保护。
|
|
248
|
+
// 反过度修复锚(同族:产物全齐但无推进史形态):completedNodes 为空(无任何 exit 推进史,
|
|
249
|
+
// currentNode 仅是初始陈旧节点)时不做路由后继保护——产物推导继续生效推进到最终节点。
|
|
250
|
+
// 推导跳跃/跨节点或回退 → 产物权威校正(漂移,防过度修复)。静态直接后继兜底(串行推进原语义)。
|
|
251
|
+
const routingSuccessorOfCurrent = state.currentNode
|
|
252
|
+
? await determineNode(changeName, protocol, [...completedArr, state.currentNode], changeDir)
|
|
253
|
+
: null;
|
|
254
|
+
// 「相等」还不是后继:等号只在两处推导同值时成立,派生的节点仍可能在 currentNode **之前**
|
|
255
|
+
// (currentNode 之后的节点产物缺失 → 派生回退;或 Fix 归位把任务推回 execute)——此时按等号
|
|
256
|
+
// 保护会把路由钉在 currentNode、吞掉产物权威校正(实测:verify 驻留 + REVIEW.md 缺失仍报
|
|
257
|
+
// verify)。故补协议 route 顺序条件:derived 的下标必须严格大于 currentNode 的下标。
|
|
258
|
+
// 两个例外都维持既有语义:① execute 家族之内——execute ⇄ subagent-execute 是同一个多趟
|
|
259
|
+
// **循环**,route 里的一前一后不是先后关系(趟间回边本就是文档化转换);波次收齐后只剩串行
|
|
260
|
+
// pending 时若按序号判「之前」,next 会把 currentNode 推回 execute,波次出口再也无法重跑
|
|
261
|
+
// (L-060 型死结)。② currentNode 不在协议 route 内(无先后可比)。
|
|
262
|
+
const derivedIdx = routeIds.indexOf(derivedNode);
|
|
263
|
+
const insideExecuteFamily = EXECUTE_FAMILY_NODE_IDS.has(derivedNode)
|
|
264
|
+
&& EXECUTE_FAMILY_NODE_IDS.has(state.currentNode);
|
|
265
|
+
const derivedIsAfterCurrent = currentNodeIdx < 0
|
|
266
|
+
|| insideExecuteFamily
|
|
267
|
+
|| (derivedIdx >= 0 && derivedIdx > currentNodeIdx);
|
|
268
|
+
const routingSuccessorProtects = !!(completedArr.length > 0
|
|
269
|
+
&& routingSuccessorOfCurrent !== null
|
|
270
|
+
&& routingSuccessorOfCurrent === derivedNode
|
|
271
|
+
&& derivedIsAfterCurrent);
|
|
272
|
+
const derivedIsDirectSuccessor = currentNodeIdx >= 0
|
|
273
|
+
&& currentNodeIdx + 1 < routeIds.length
|
|
274
|
+
&& routeIds[currentNodeIdx + 1] === derivedNode;
|
|
275
|
+
const derivedIsSuccessor = routingSuccessorProtects || derivedIsDirectSuccessor;
|
|
276
|
+
const inProgress = !!(
|
|
277
|
+
state.currentNode
|
|
278
|
+
&& !completedArr.includes(state.currentNode)
|
|
279
|
+
&& (currentNodeEntered
|
|
280
|
+
|| (currentNodeEvidence && typeof currentNodeEvidence === 'object' && !Array.isArray(currentNodeEvidence)))
|
|
281
|
+
&& derivedIsSuccessor
|
|
282
|
+
);
|
|
283
|
+
// Fix 受控归位(同一事实同一说法):next 的 FIX-BATCH 分支在共享视图之前返回并打印归位目标,
|
|
284
|
+
// status 只走共享视图 ⇒ 同一 state 下两条命令报不同节点,且 status 会叫人 exit 一个正在被
|
|
285
|
+
// Fix 批次门禁拦下的源节点(C1)。此处只读消费同一决策(纯读:不写盘、不计轮次),命中即把
|
|
286
|
+
// 归位目标作为路由视图——它是 next 的 NODE 行会打印的节点。
|
|
287
|
+
const fixRollback = await resolveFixRollbackDecision({
|
|
288
|
+
runRoot: runRootDir(),
|
|
289
|
+
changeName,
|
|
290
|
+
protocol,
|
|
291
|
+
completedNodes: completedArr,
|
|
292
|
+
currentNode: state.currentNode,
|
|
293
|
+
history: state.history,
|
|
294
|
+
});
|
|
295
|
+
const fixRollbackTarget = fixRollback === null ? null : fixRollback.target;
|
|
296
|
+
// 归位**只读预演**:next 在归位分支命中后会调 applyFixRollbackRound(唯一写点)计数,第 4 轮
|
|
297
|
+
// 无授权时在任何写盘之前 BLOCK——status 若照常给节点,给的就是 next 根本不会打印的那个答案。
|
|
298
|
+
// 预演在 state 的**副本**上跑同一 helper:阈值/授权/渐进放行的判据与 next 逐字同源(不是第二份
|
|
299
|
+
// 实现),而真 state 的字段(含 fixRoundsByChange)不可能被改动,也不写盘(字节零改写)。
|
|
300
|
+
const fixRollbackPreview = fixRollback === null
|
|
301
|
+
? null
|
|
302
|
+
: applyFixRollbackRound({
|
|
303
|
+
state: structuredClone(state),
|
|
304
|
+
sourceNode: state.currentNode,
|
|
305
|
+
decision: fixRollback,
|
|
306
|
+
});
|
|
307
|
+
// 三个 blocked 来源按 next 的分支顺序求值(同一先后,不是另一套优先级):
|
|
308
|
+
// ① Fix 受控归位第 4 轮无授权(next 的 FIX-BATCH 分支最先 BLOCK);
|
|
309
|
+
// ② 节点顺序门禁(next 的「疑似未 exit」);
|
|
310
|
+
// ③ 单趟零进展。
|
|
311
|
+
// 回程(fixReturnTarget)夹在 ② 之前:回程态下「源节点未出口」正是回程语义本身,顺序门禁不得推翻
|
|
312
|
+
// next 的回程分支(next 的回程分支先于顺序门禁返回);顺序门禁又先于零进展(零进展是路由落到
|
|
313
|
+
// execute 家族后的形态,执行者先要处理当前节点)。零进展成立时不再求回程——与 next 的既有先后一致
|
|
314
|
+
// (零进展态下回程分支不会被走到)。
|
|
315
|
+
const fixRoundBlockedMessage = fixRollbackPreview?.blocked ? fixRollbackPreview.blockedMessage : null;
|
|
316
|
+
const zeroProgressMessage = fixRoundBlockedMessage === null
|
|
317
|
+
? await resolveZeroProgressBlock({ changeName, protocol, nodeId: derivedNode })
|
|
318
|
+
: null;
|
|
319
|
+
const fixReturnTarget = fixRoundBlockedMessage === null && zeroProgressMessage === null
|
|
320
|
+
? await resolveFixReturnTarget({
|
|
321
|
+
changeName, protocol, completedArr, state, derivedNode, currentNodeIdx, derivedIdx,
|
|
322
|
+
})
|
|
323
|
+
: null;
|
|
324
|
+
const orderBlockedMessage = fixRoundBlockedMessage === null && fixReturnTarget === null
|
|
325
|
+
? await resolveNodeOrderBlock({ changeName, protocol, completedArr, state, changeDir })
|
|
326
|
+
: null;
|
|
327
|
+
const blockedMessage = fixRoundBlockedMessage ?? orderBlockedMessage ?? zeroProgressMessage;
|
|
328
|
+
const blocked = blockedMessage === null
|
|
329
|
+
? null
|
|
330
|
+
: { message: blockedMessage, reason: blockedReason(blockedMessage) };
|
|
331
|
+
return {
|
|
332
|
+
derivedNode,
|
|
333
|
+
stateNode: state.currentNode ?? null,
|
|
334
|
+
// 优先级与 next 的分支顺序一致:BLOCKED(不打印节点)→ Fix 归位 → 回程 → 进行中保护 → 产物推导。
|
|
335
|
+
// Fix 归位优先于进行中保护:保护输出的是源节点,而归位态下源节点的动作(exit)会被拦下。
|
|
336
|
+
routeNode: blocked !== null
|
|
337
|
+
? null
|
|
338
|
+
: (fixRollbackTarget ?? fixReturnTarget ?? (inProgress ? state.currentNode : derivedNode)),
|
|
339
|
+
inProgress,
|
|
340
|
+
fixRollbackTarget,
|
|
341
|
+
fixReturnTarget,
|
|
342
|
+
blocked,
|
|
343
|
+
};
|
|
344
|
+
}
|
|
345
|
+
|
|
346
|
+
// 人读诊断(status):JSON 块之后的一行三视图对账——derived = 产物推导、state = state 原值、
|
|
347
|
+
// route = 路由视图(= next 的 NODE);尾部原因与 printWhyLine 的分支一一对应(同一停留原因在四个
|
|
348
|
+
// 输出面上说同一句话):Fix 归位态点名「先按 next 的 FIX-BATCH 归位」——此时源节点的 exit 会被 Fix
|
|
349
|
+
// 批次门禁拦下,指引不得指向它;回程态说明「产物在场且未出口、保留源节点跑出口」——否则两列并排
|
|
350
|
+
// 却不给原因,读起来就是「产物推导指向源节点」;进行中点名「先 exit 该节点」。
|
|
351
|
+
// 前缀严格为 `ROUTE: `。
|
|
352
|
+
// BLOCKED 态(route=null)与 next 的实际行为一致:next 此刻不打印 NODE 而是直接 BLOCKED,ROUTE: 行
|
|
353
|
+
// 因此明确写「next 将 BLOCKED:<原因>」并把人推回恢复指引,而不是编一个节点让人去跑。
|
|
354
|
+
function formatRouteLine(view) {
|
|
355
|
+
const head = 'derived=' + (view.derivedNode ?? 'null') + '(产物推导)'
|
|
356
|
+
+ ' state=' + (view.stateNode ?? 'null') + '(state 原值)';
|
|
357
|
+
if (view.blocked !== null) {
|
|
358
|
+
return head + ' route=null(路由视图);next 将 BLOCKED:' + view.blocked.reason + '(先按恢复指引处理)';
|
|
359
|
+
}
|
|
360
|
+
const tail = view.fixRollbackTarget
|
|
361
|
+
? ';Fix 批次:先按 next 的 FIX-BATCH 归位 ' + view.fixRollbackTarget + ' 并跑完其出口'
|
|
362
|
+
: (view.fixReturnTarget
|
|
363
|
+
? ';回程:产物在场且未出口——保留源节点 ' + view.routeNode + ' 跑出口'
|
|
364
|
+
: (view.inProgress
|
|
365
|
+
? ';进行中:' + view.stateNode + ' 已 entry 未 exit——先 exit ' + view.stateNode + ' 再推进'
|
|
366
|
+
: ''));
|
|
367
|
+
return head + ' route=' + (view.routeNode ?? 'null') + '(路由视图)' + tail;
|
|
368
|
+
}
|
|
369
|
+
|
|
370
|
+
// 人读诊断(next):为什么停在这个节点。四种停留原因在同一实现里各有一段文案:
|
|
371
|
+
// · Fix 受控归位——归位目标待跑出口(源节点此时 exit 会被 Fix 批次门禁拦下,指引不得指向 exit);
|
|
372
|
+
// · 回程——产物已在场把路由推后,但源节点未出口(保留源节点跑出口,不是「产物推导指向源节点」);
|
|
373
|
+
// · 进行中——已 entry 未 exit(保护生效),动作是 exit 本节点;
|
|
374
|
+
// · 其余——产物推导。
|
|
375
|
+
// 共享节点视图路径、Fix 归位分支与回程分支都经本函数:同源不只在 NODE 行,解释行也是同一段文案。
|
|
376
|
+
function printWhyLine(view) {
|
|
377
|
+
if (view.routeNode === null) return;
|
|
378
|
+
let reason;
|
|
379
|
+
if (view.fixRollbackTarget) {
|
|
380
|
+
reason = 'Fix 批次归位 ' + view.fixRollbackTarget
|
|
381
|
+
+ (view.stateNode ? '(源节点 ' + view.stateNode + ')' : '')
|
|
382
|
+
+ '——先跑 ' + view.fixRollbackTarget + ' 四类出口,再回源节点 exit';
|
|
383
|
+
} else if (view.fixReturnTarget) {
|
|
384
|
+
// 回程态:节点停在源节点不是产物推导的结果(产物已把它推后),解释必须说清「为什么保留源节点」——
|
|
385
|
+
// 否则 WHY: 行会把它读成「产物推导指向源节点(无进行中节点)」这类错因。
|
|
386
|
+
reason = '回程源节点 ' + view.routeNode + ':产物在场且未出口,保留源节点跑出口';
|
|
387
|
+
} else if (view.inProgress) {
|
|
388
|
+
reason = '停在 ' + view.routeNode + '——已 entry 未 exit(进行中保护),先 exit ' + view.routeNode + ' 再推进';
|
|
389
|
+
} else {
|
|
390
|
+
reason = '产物推导指向 ' + view.routeNode + '(无进行中节点)';
|
|
391
|
+
}
|
|
392
|
+
console.log('WHY: ' + reason);
|
|
393
|
+
}
|
|
394
|
+
|
|
395
|
+
// 结构预检提示的命令段(单一实现,两个运行期输出面共用:next 与 handoff result):--preflight 只跑
|
|
396
|
+
// 结构性门禁(不写 state、不写提示账本、不推进状态),它**不是**节点收尾的预演——完整 exit(不带
|
|
397
|
+
// --apply)才是全链预演。两句必须同行,否则同一个 PREFLIGHT 会被读成两条命令。节点由
|
|
398
|
+
// 调用方按**路由视图**传入(与 NODE 行同源),不得取 state 原值:Fix 归位态下源节点的 exit 会被
|
|
399
|
+
// Fix 批次门禁拦下。
|
|
400
|
+
export function structuralPreflightHint(nodeId) {
|
|
401
|
+
// 命令文本与 handoff result 的 PREFLIGHT 走同一实现(scriptCommand):平台化脚本根 + 整条
|
|
402
|
+
// 路径加引号——裸脚本名在 codex / dsh 单平台安装上照抄会落空(pathReplacements 只处理 .md)。
|
|
403
|
+
return '可运行 ' + scriptCommand({
|
|
404
|
+
scriptsDir, runRoot: runRootDir(), script: 'workflow-guard.mjs', args: ['exit', nodeId, '--preflight'],
|
|
405
|
+
}) + ' 做结构预检(只跑结构性门禁,不写 state、不推进状态);完整 exit(不带 --apply)是节点收尾的全链预演';
|
|
406
|
+
}
|
|
407
|
+
|
|
408
|
+
// 预检提示(next):只在 execute / subagent-execute 路由上打印——让每任务的模板结构反馈前移到
|
|
409
|
+
// 任务收尾,而不是攒到节点出口。贴什么命令、两句如何分工见 structuralPreflightHint(单一实现)。
|
|
410
|
+
function printPreflightLine(nodeId) {
|
|
411
|
+
if (!nodeId || !EXECUTE_FAMILY_NODE_IDS.has(nodeId)) return;
|
|
412
|
+
console.log('PREFLIGHT: ' + structuralPreflightHint(nodeId));
|
|
413
|
+
}
|
|
414
|
+
|
|
415
|
+
// ---------- init 覆盖在途 change:默认阻断 + --replace 留档 ----------
|
|
416
|
+
// 「进行中」的身份口径与 status / next / record 同一份(state.activeChange 非空 ∧ status ≠
|
|
417
|
+
// 'completed',判据 = state-io.inFlightChangeName):只有**另一个** change 在办才进闸门——同 id
|
|
418
|
+
// 重跑走既有 WARN 路径(不阻断,行为不变)。覆盖别的 change 会连同它的节点进度 / evidence 一起
|
|
419
|
+
// 清掉,是破坏性动作,故「沉默即拒绝」:必须显式 --replace <在途 change> --reason <非空原因>,
|
|
420
|
+
// 且放行前先把旧 state 按**原始字节**留档(快照 + 记录)到旧 change 目录的 recovery/。留档写不成
|
|
421
|
+
// 就不覆盖——旧状态不得无痕消失。无在途 change 时整段不进入:零备份、零新参数要求,正常 init 的
|
|
422
|
+
// 输出保持原样。
|
|
423
|
+
//
|
|
424
|
+
// 位置:留档落点走唯一解析器(resolveChangeLocation)而不是硬拼 .specs/<旧>/——在办 change 可能
|
|
425
|
+
// 已被搬进 .specs/archive/(移动后尚未 exit),留档必须跟着 change 走;两处都没有 / 多候选判不出
|
|
426
|
+
// 时拒绝覆盖(拿不准落点就不许销毁旧状态)。
|
|
427
|
+
//
|
|
428
|
+
// 返回:null(无需留档)或 RECOVERY 块要打印的信息;任何不合法的放行形态在这里 fail-closed
|
|
429
|
+
//(BLOCKED + 非零退出,state 字节零改写),调用方不重复判定。
|
|
430
|
+
async function gateInitOverInFlightChange({ protocolArgv, changeName, prevState, replaceChange, replaceReason }) {
|
|
431
|
+
const inFlightChange = inFlightChangeName(prevState);
|
|
432
|
+
if (!inFlightChange || inFlightChange === changeName) return null;
|
|
433
|
+
const context = commandContext({ argv: protocolArgv, runRoot: runRootDir() });
|
|
434
|
+
const stateDisplay = path.relative(runRootDir(), stateFile()).split(path.sep).join('/');
|
|
435
|
+
const statusCommand = scriptCommand({
|
|
436
|
+
scriptsDir: context.scriptsDir, runRoot: context.runRoot, script: 'workflow-state.mjs', args: ['status'],
|
|
437
|
+
});
|
|
438
|
+
// 恢复指引里的**那一条命令**:形态与 record / 声明命令同源(平台化脚本路径 + 整条加引号),
|
|
439
|
+
// 参数面按本次实际调用生成(--protocol 上下文同样带上),照抄即可执行。
|
|
440
|
+
const replaceCommand = scriptCommand({
|
|
441
|
+
scriptsDir: context.scriptsDir,
|
|
442
|
+
runRoot: context.runRoot,
|
|
443
|
+
script: 'workflow-state.mjs',
|
|
444
|
+
args: ['init', changeName, '--replace', inFlightChange, '--reason', '"<原因>"', ...protocolContextArgs(context)],
|
|
445
|
+
});
|
|
446
|
+
const inFlightShape = '(status: ' + String(prevState?.status ?? '-')
|
|
447
|
+
+ ',当前节点: ' + String(prevState?.currentNode ?? '-') + ')';
|
|
448
|
+
const block = (lines) => {
|
|
449
|
+
for (const line of lines) console.error(line);
|
|
450
|
+
process.exit(1);
|
|
451
|
+
};
|
|
452
|
+
if (replaceChange === null) {
|
|
453
|
+
block([
|
|
454
|
+
'BLOCKED: 在途 change "' + inFlightChange + '" 尚未完成' + inFlightShape
|
|
455
|
+
+ '——init "' + changeName + '" 会覆盖它的机器状态(节点进度 / evidence),默认阻断;未改写任何状态。',
|
|
456
|
+
'恢复: ① 先完成在途 change(查看进度: ' + statusCommand + ');',
|
|
457
|
+
' ② 或确认覆盖并留档后重跑: ' + replaceCommand,
|
|
458
|
+
]);
|
|
459
|
+
}
|
|
460
|
+
if (replaceChange !== inFlightChange) {
|
|
461
|
+
block([
|
|
462
|
+
'BLOCKED: --replace 的 change 名 "' + replaceChange + '" 与在途 change "' + inFlightChange
|
|
463
|
+
+ '" 不一致——只能覆盖当前在办的那一个;未改写任何状态。',
|
|
464
|
+
'恢复: ' + replaceCommand,
|
|
465
|
+
]);
|
|
466
|
+
}
|
|
467
|
+
if (replaceReason === null || replaceReason.trim() === '') {
|
|
468
|
+
block([
|
|
469
|
+
'BLOCKED: --replace "' + inFlightChange + '" 还需要非空的 --reason <原因文本>(原因会写进留档,'
|
|
470
|
+
+ '供事后追溯);未改写任何状态。',
|
|
471
|
+
'恢复: ' + replaceCommand,
|
|
472
|
+
]);
|
|
473
|
+
}
|
|
474
|
+
// change 名形态 = 单段目录名(与受控重入 / select 同一判据):不合法就没有可落笔的留档位置
|
|
475
|
+
if (!isSingleSegmentChangeName(inFlightChange)) {
|
|
476
|
+
block([
|
|
477
|
+
'BLOCKED: 在途 change 名 "' + inFlightChange + '" 不是单段目录名——拒绝在它名下写留档;未改写任何状态。',
|
|
478
|
+
'恢复: 修正 ' + stateDisplay + ' 的 activeChange(机器字段由脚本通道写,不要手改)后重跑。',
|
|
479
|
+
]);
|
|
480
|
+
}
|
|
481
|
+
const location = await resolveChangeLocation({
|
|
482
|
+
root: runRootDir(),
|
|
483
|
+
changeName: inFlightChange,
|
|
484
|
+
createdAt: prevState?.createdAt,
|
|
485
|
+
});
|
|
486
|
+
if (!location.ok) {
|
|
487
|
+
block([
|
|
488
|
+
'BLOCKED: 覆盖前必须先把在途 change "' + inFlightChange + '" 的旧状态留档,但它的目录解析不到——未改写任何状态。',
|
|
489
|
+
'原因: ' + location.message.replace(/^BLOCKED: /, ''),
|
|
490
|
+
'恢复: 先运行 ' + statusCommand + ' 查看位置解析结果,按提示恢复该目录后重跑。',
|
|
491
|
+
]);
|
|
492
|
+
}
|
|
493
|
+
const stamp = formatLocalTimestamp();
|
|
494
|
+
const stampSafe = stamp.replace(/:/g, '-');
|
|
495
|
+
const recoveryDir = path.join(location.resolution.dir, 'recovery');
|
|
496
|
+
const recoveryDisplay = location.resolution.display + '/recovery';
|
|
497
|
+
const snapshotName = stampSafe + '-pre-init.state.json';
|
|
498
|
+
const recordName = stampSafe + '-pre-init.md';
|
|
499
|
+
const snapshotDisplay = recoveryDisplay + '/' + snapshotName;
|
|
500
|
+
const recordDisplay = recoveryDisplay + '/' + recordName;
|
|
501
|
+
// 回滚 = 把快照字节原样写回状态文件。命令用 node + copyFileSync 而不是 cp / copy:cp 在 cmd 下
|
|
502
|
+
// 不存在、copy 是内建命令且覆盖时会二次确认——两条路径参数各自加引号,跨平台整行可照抄。
|
|
503
|
+
const rollbackCommand = 'node -e "require(\'fs\').copyFileSync(process.argv[1],process.argv[2])"'
|
|
504
|
+
+ ' "' + snapshotDisplay + '" "' + stateDisplay + '"';
|
|
505
|
+
const recordLines = [
|
|
506
|
+
'# 留档:init 覆盖在途 change "' + inFlightChange + '"',
|
|
507
|
+
'',
|
|
508
|
+
'- **时间**: ' + stamp,
|
|
509
|
+
'- **init 目标**: ' + changeName,
|
|
510
|
+
'- **覆盖前状态**: change `' + inFlightChange + '` · currentNode `' + String(prevState?.currentNode ?? '-')
|
|
511
|
+
+ '` · status `' + String(prevState?.status ?? '-') + '`',
|
|
512
|
+
'- **原因**: ' + replaceReason,
|
|
513
|
+
'- **快照**: ' + snapshotDisplay + '(旧状态文件的逐字节副本)',
|
|
514
|
+
'- **回滚命令**(在项目根执行,恢复旧状态字节):',
|
|
515
|
+
'',
|
|
516
|
+
'```bash',
|
|
517
|
+
rollbackCommand,
|
|
518
|
+
'```',
|
|
519
|
+
'',
|
|
520
|
+
];
|
|
521
|
+
try {
|
|
522
|
+
// 逐字节:读原始 bytes、写同一份 bytes(BOM / 行尾都不改)——JSON 深比会漏掉格式化与序列化漂移
|
|
523
|
+
const snapshotBytes = await fs.readFile(stateFile());
|
|
524
|
+
await fs.mkdir(recoveryDir, { recursive: true });
|
|
525
|
+
await fs.writeFile(path.join(recoveryDir, snapshotName), snapshotBytes);
|
|
526
|
+
await fs.writeFile(path.join(recoveryDir, recordName), recordLines.join('\n'), 'utf8');
|
|
527
|
+
} catch (error) {
|
|
528
|
+
block([
|
|
529
|
+
'BLOCKED: 在途 change "' + inFlightChange + '" 的旧状态留档写入失败(' + error.message + ')——未改写任何状态。',
|
|
530
|
+
'恢复: 检查 ' + recoveryDisplay + '/ 的写权限后重跑同一条命令。',
|
|
531
|
+
]);
|
|
532
|
+
}
|
|
533
|
+
return {
|
|
534
|
+
inFlight: inFlightChange,
|
|
535
|
+
currentNode: String(prevState?.currentNode ?? '-'),
|
|
536
|
+
status: String(prevState?.status ?? '-'),
|
|
537
|
+
snapshotDisplay,
|
|
538
|
+
recordDisplay,
|
|
539
|
+
rollbackCommand,
|
|
540
|
+
};
|
|
541
|
+
}
|
|
542
|
+
|
|
79
543
|
// init <change-id> [--branch-prefix <prefix>] [--init-context|--init-skip]
|
|
544
|
+
// [--replace <在途 change> --reason <原因>]
|
|
80
545
|
// protocolPath = 入口 resolveProtocol 解析出的协议路径(协议来源绑定的持久化取值)
|
|
81
546
|
export async function runInit(protocol, argv, protocolPath) {
|
|
82
547
|
const changeName = argv[3];
|
|
@@ -88,12 +553,16 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
88
553
|
// 参数误用防护:以 -- 开头的参数(如 --help)是选项不是 change 名——报错并提示用法,
|
|
89
554
|
// 防止被当作 change id 执行(自动开 change、建分支、写状态——有破坏性)
|
|
90
555
|
if (normalizedChangeName.startsWith('--')) {
|
|
91
|
-
throw new Error('init: ' + normalizedChangeName + ' looks like a flag, not a change name. Usage: workflow-state.mjs init <change-id> [--branch-prefix <prefix>] [--init-context|--init-skip]');
|
|
556
|
+
throw new Error('init: ' + normalizedChangeName + ' looks like a flag, not a change name. Usage: workflow-state.mjs init <change-id> [--branch-prefix <prefix>] [--init-context|--init-skip] [--replace <in-flight-change> --reason <text>]');
|
|
92
557
|
}
|
|
93
558
|
// --branch-prefix <prefix>(缺省 'change/');--init-context / --init-skip(自动初始化检测授权)
|
|
559
|
+
// --replace <在途 change> / --reason <原因>:覆盖另一个在途 change 的显式放行参数(缺省 = 默认阻断;
|
|
560
|
+
// 取值形态在这里只做「有没有给 / 给了什么」,是否放行由下方覆盖闸门单点判定)
|
|
94
561
|
let branchPrefix = 'change/';
|
|
95
562
|
let initContext = false;
|
|
96
563
|
let initSkip = false;
|
|
564
|
+
let replaceChange = null;
|
|
565
|
+
let replaceReason = null;
|
|
97
566
|
const initArgs = argv.slice(4);
|
|
98
567
|
for (let i = 0; i < initArgs.length; i++) {
|
|
99
568
|
if (initArgs[i] === '--branch-prefix') {
|
|
@@ -112,6 +581,23 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
112
581
|
initContext = true;
|
|
113
582
|
} else if (initArgs[i] === '--init-skip') {
|
|
114
583
|
initSkip = true;
|
|
584
|
+
} else if (initArgs[i] === '--replace' || initArgs[i] === '--reason') {
|
|
585
|
+
// 空格形与等号形同义(与 --branch-prefix 的既有形态一致):值缺失 / 空串不在这里 exit——
|
|
586
|
+
// 形态不符的报文与退出码由下方覆盖闸门统一给出(同一件事一处措辞),这里只记录「给了什么」。
|
|
587
|
+
// 值位紧跟另一个选项(如 `--reason --init-skip`)是漏写原因,不是把选项当原因:记为没给,
|
|
588
|
+
// 让覆盖闸门给出「需要非空 --reason」。消费成功的值同时跳过,不再被下一轮当成选项处理。
|
|
589
|
+
const value = initArgs[i + 1];
|
|
590
|
+
const usable = typeof value === 'string' && value.trim() !== '' && !value.trim().startsWith('--');
|
|
591
|
+
const text = usable ? value.trim() : '';
|
|
592
|
+
// 没给到值(缺值 / 值位是另一个选项 / 纯空白)视为**没给**:`--replace` 留 null 走「默认阻断」,
|
|
593
|
+
// 报「change 名 "" 与在途 change 不一致」会把「漏写」渲染成「给了个空名字」,误导排查。
|
|
594
|
+
if (initArgs[i] === '--replace') replaceChange = usable ? text : null; else replaceReason = text;
|
|
595
|
+
if (usable) i += 1;
|
|
596
|
+
} else if (typeof initArgs[i] === 'string'
|
|
597
|
+
&& (initArgs[i].startsWith('--replace=') || initArgs[i].startsWith('--reason='))) {
|
|
598
|
+
const equalsAt = initArgs[i].indexOf('=');
|
|
599
|
+
const text = initArgs[i].slice(equalsAt + 1).trim();
|
|
600
|
+
if (initArgs[i].slice(0, equalsAt) === '--replace') replaceChange = text; else replaceReason = text;
|
|
115
601
|
}
|
|
116
602
|
}
|
|
117
603
|
// 自动初始化检测(前置步骤):读旧 state(项目级字段跨 change 保留)→ 探测 → 判决 → 提示/执行
|
|
@@ -119,6 +605,11 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
119
605
|
// (intel-scan 语义);生成后重跑 → 脚本校验 7 段结构 → 通过写 last_intel_scan(确定性校验)。
|
|
120
606
|
let prevState = null;
|
|
121
607
|
try { prevState = await readState(); } catch { prevState = null; }
|
|
608
|
+
// init 覆盖在途 change:默认阻断 + --replace 留档——判定与留档收在单一实现
|
|
609
|
+
//(gateInitOverInFlightChange),本处只取它给出的留档信息用于成功路径的 RECOVERY 块。
|
|
610
|
+
const initRecovery = await gateInitOverInFlightChange({
|
|
611
|
+
protocolArgv: argv, changeName, prevState, replaceChange, replaceReason,
|
|
612
|
+
});
|
|
122
613
|
const probe = await probeProject(runRootDir(), prevState);
|
|
123
614
|
const verdict = classify(probe, prevState);
|
|
124
615
|
let ctxValid = null; // null=未进入校验(非 init-context 或已新鲜);true/false=校验结果
|
|
@@ -160,7 +651,9 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
160
651
|
if (prevState?.activeChange === changeName || specsDirExists) {
|
|
161
652
|
console.error('WARN: change ' + changeName + ' 已存在——重跑 init 将重置节点状态(completedNodes/evidence 清空)。若需继续已有 change,请用 advance/select 而非重跑 init。');
|
|
162
653
|
}
|
|
163
|
-
// E1: branchMode 自动判定——git
|
|
654
|
+
// E1: branchMode 自动判定——git 仓库 → true;非 git 仓库 → false。git 命令一律以运行根为 cwd
|
|
655
|
+
//(state-branch 族统一取 runRootDir)——分支判定/创建与状态落点因此跟同一个根,不会一个走 cwd、
|
|
656
|
+
// 一个走变量根。
|
|
164
657
|
const branchMode = isInsideWorkTree();
|
|
165
658
|
const state = {
|
|
166
659
|
activeChange: changeName,
|
|
@@ -182,9 +675,7 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
182
675
|
enablePrReview: false,
|
|
183
676
|
branchPrefix,
|
|
184
677
|
status: 'running',
|
|
185
|
-
//
|
|
186
|
-
newChange: true,
|
|
187
|
-
// 进入证据容器——entry 追加节点;未 entry 检测(新 change 强制)
|
|
678
|
+
// 进入证据容器——entry 追加节点;未 entry 检测强制
|
|
188
679
|
enteredNodes: [],
|
|
189
680
|
createdAt: new Date().toISOString(),
|
|
190
681
|
// 项目级上下文字段跨 change 保留(迁移旧 state;--init-context 刷新扫描时间;--init-skip 记拒绝)
|
|
@@ -239,6 +730,15 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
239
730
|
}
|
|
240
731
|
console.log('Initialized: ' + changeName);
|
|
241
732
|
console.log('BRANCH: ' + (branchMode && !emptyRepo ? expectedBranch : 'none(非 git 仓库或空仓库)'));
|
|
733
|
+
// 留档可见性:覆盖在途 change 的异常路径必须在成功输出里**看得见**——快照路径 + 回滚命令
|
|
734
|
+
// 整行可照抄(回滚命令只在 RECOVERY 块里给一次,.md 记录里是同一行)。
|
|
735
|
+
if (initRecovery) {
|
|
736
|
+
console.log('RECOVERY: 在途 change "' + initRecovery.inFlight + '" 的状态已留档(覆盖前 currentNode: '
|
|
737
|
+
+ initRecovery.currentNode + ' · status: ' + initRecovery.status + ')');
|
|
738
|
+
console.log('RECOVERY: 快照 ' + initRecovery.snapshotDisplay);
|
|
739
|
+
console.log('RECOVERY: 记录 ' + initRecovery.recordDisplay);
|
|
740
|
+
console.log('RECOVERY: 回滚 ' + initRecovery.rollbackCommand);
|
|
741
|
+
}
|
|
242
742
|
// init 输出取协议首节点(与 state.currentNode 一致——内置协议 = open,行为不变)
|
|
243
743
|
printNext(protocol, route(protocol)[0]?.id ?? 'open');
|
|
244
744
|
return;
|
|
@@ -254,7 +754,13 @@ export async function runStatus(protocol) {
|
|
|
254
754
|
return;
|
|
255
755
|
}
|
|
256
756
|
const state = await readState();
|
|
257
|
-
|
|
757
|
+
// 位置门(先于任何视图):身份在办但两处目录都没有 → fail-closed,**不得**回落到 no-change
|
|
758
|
+
// (no-change 的语义是「没有在办 change」,与这里的事实相反)。
|
|
759
|
+
const location = await requireChangeLocation(changeName, state);
|
|
760
|
+
// 节点视图(与 next 共用同一判定):currentNode 仍取产物推导(既有键语义逐字不变),
|
|
761
|
+
// routeNode 才是经「进行中保护」后的路由视图(= next 的 NODE 行)。
|
|
762
|
+
const nodeView = await resolveNodeView({ changeName, protocol, state, location });
|
|
763
|
+
const detectedNode = nodeView.derivedNode;
|
|
258
764
|
// 派生视图(ADR-013 决策 11;改为事件为准):被强制推进的节点以
|
|
259
765
|
// state.history 中本 change 的 advance-forced 事件为唯一判据——按 change 过滤(兼容旧事件
|
|
260
766
|
// 无 change 字段),取 e.node 集合后与 completedNodes 求交。旧「completedNodes 含而 evidence
|
|
@@ -286,17 +792,22 @@ export async function runStatus(protocol) {
|
|
|
286
792
|
change: changeName,
|
|
287
793
|
currentNode: detectedNode,
|
|
288
794
|
stateCurrentNode: state.currentNode,
|
|
795
|
+
// 增量字段:next 会打印的路由视图(进行中保护后的节点);不写 state、既有键语义不变
|
|
796
|
+
routeNode: nodeView.routeNode,
|
|
289
797
|
completedNodes: state.completedNodes,
|
|
290
798
|
forcedNodes,
|
|
291
799
|
executionMode: state.executionMode ?? 'subagent',
|
|
292
800
|
directOverride: state.directOverride ?? false,
|
|
293
801
|
branchMode: isInsideWorkTree(),
|
|
294
802
|
enablePrReview: state.enablePrReview ?? false,
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
//
|
|
298
|
-
|
|
803
|
+
// 产物根 = 位置解析到的目录(活动 / 归档):移动后仍报 .specs/<id> 就是在说一个不存在的落点。
|
|
804
|
+
artifactRoot: location.display,
|
|
805
|
+
// 与 routeNode 同一判定(One predicate):本键回答「协调者模式是否生效」,必须指向路由视图
|
|
806
|
+
// 那个节点——若另取产物推导,进行中态会在同一响应里给出两个「当前节点」口径(routeNode=
|
|
807
|
+
// execute 而 coordinatorMode=false)。既有键名/类型/位置不变,只换判定来源。
|
|
808
|
+
coordinatorMode: EXECUTE_FAMILY_NODE_IDS.has(nodeView.routeNode)
|
|
299
809
|
}, null, 2));
|
|
810
|
+
console.log('ROUTE: ' + formatRouteLine(nodeView));
|
|
300
811
|
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
301
812
|
await printEvolveDueHint(state);
|
|
302
813
|
return;
|
|
@@ -311,6 +822,9 @@ export async function runNext(protocol) {
|
|
|
311
822
|
return;
|
|
312
823
|
}
|
|
313
824
|
const state = await readState();
|
|
825
|
+
// 位置门(同 status):解析不到就 fail-closed,不打印 NODE / NEXT: done——那是「没有在办 change」
|
|
826
|
+
// 或「已无待跑节点」的措辞,两者都在说假话。
|
|
827
|
+
const location = await requireChangeLocation(changeName, state);
|
|
314
828
|
const completedArr = Array.isArray(state.completedNodes) ? state.completedNodes : [];
|
|
315
829
|
// Fix 回退显式分支——必须早于「疑似未 exit」门禁与进行中漂移保护:
|
|
316
830
|
// review/verify 驻留 + TASK 有 pending 修复任务(串行/并行)或未闭合家族出口签名时,把工作
|
|
@@ -322,8 +836,8 @@ export async function runNext(protocol) {
|
|
|
322
836
|
});
|
|
323
837
|
if (fixRollbackDecision) {
|
|
324
838
|
const sourceNode = state.currentNode;
|
|
325
|
-
// 轮次计数与阈值/授权判定全部走共享 helper:分支②不计数;第 4
|
|
326
|
-
// (此处尚未写盘,满足不写 currentNode
|
|
839
|
+
// 轮次计数与阈值/授权判定全部走共享 helper:分支②不计数;第 4 轮无授权时先 BLOCK
|
|
840
|
+
// (此处尚未写盘,满足不写 currentNode;单一判级,无按 change 新旧的放行侧)。
|
|
327
841
|
const rollbackRound = applyFixRollbackRound({ state, sourceNode, decision: fixRollbackDecision });
|
|
328
842
|
if (rollbackRound.blocked) {
|
|
329
843
|
console.error(rollbackRound.blockedMessage);
|
|
@@ -334,6 +848,14 @@ export async function runNext(protocol) {
|
|
|
334
848
|
await writeState(state);
|
|
335
849
|
console.log('FIX-BATCH: 归位 ' + fixRollbackDecision.target + '(源节点 ' + sourceNode + ')' + rollbackRound.auditSuffix);
|
|
336
850
|
printNext(protocol, fixRollbackDecision.target, state.executionMode ?? 'subagent');
|
|
851
|
+
// 解释行与共享视图同一实现(printWhyLine):status 的 routeNode 与这行点名的节点是同一事实。
|
|
852
|
+
printWhyLine({
|
|
853
|
+
routeNode: fixRollbackDecision.target,
|
|
854
|
+
stateNode: sourceNode,
|
|
855
|
+
inProgress: false,
|
|
856
|
+
fixRollbackTarget: fixRollbackDecision.target,
|
|
857
|
+
});
|
|
858
|
+
printPreflightLine(fixRollbackDecision.target);
|
|
337
859
|
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
338
860
|
return;
|
|
339
861
|
}
|
|
@@ -342,136 +864,47 @@ export async function runNext(protocol) {
|
|
|
342
864
|
// 源节点;仅当源节点未完成、任务全 done、firstIncompletePostExecNode === currentNode
|
|
343
865
|
// 且 resolveNextNode 确实会跳过该节点时显式放行(只读不改写 state)。artifactNext ===
|
|
344
866
|
// currentNode 的形态落回既有正常逻辑(normalAdvanceExempt 覆盖),不放宽豁免面。
|
|
867
|
+
// 本块只做「可能是回程态」的廉价前置筛选(源节点未完成 = 回程谓词的必要条件),真正的判定取共享
|
|
868
|
+
// 视图的 fixReturnTarget——回程分支的 NODE 与 status.routeNode 是同一个值,源节点未 entry /
|
|
869
|
+
// 无 evidence 的构造态里两者不再分叉(旧实现直接打印 state.currentNode,status 报产物后继)。
|
|
345
870
|
const fixReturnNode = state.activeChange
|
|
346
871
|
? await resolveFixReturnNode({ runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr })
|
|
347
872
|
: null;
|
|
348
873
|
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');
|
|
874
|
+
const returnView = await resolveNodeView({ changeName, protocol, state, location });
|
|
875
|
+
if (returnView.fixReturnTarget !== null) {
|
|
876
|
+
console.log('RETURN: 回程源节点 ' + returnView.fixReturnTarget + '(源节点产物在场且未出口;保留源节点跑出口)');
|
|
877
|
+
printNext(protocol, returnView.routeNode, state.executionMode ?? 'subagent');
|
|
878
|
+
printWhyLine(returnView);
|
|
361
879
|
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
362
880
|
return;
|
|
363
881
|
}
|
|
364
882
|
}
|
|
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
|
-
}
|
|
883
|
+
// 节点视图(与 status 共用同一判定,见 resolveNodeView——节点顺序门禁也在其中,本命令不再内联
|
|
884
|
+
// 第二份):derivedNode 供零进展防呆与漂移校正使用,routeNode 才是输出节点(next 的 NODE 行)。
|
|
885
|
+
const nodeView = await resolveNodeView({ changeName, protocol, state, location });
|
|
886
|
+
const detectedNode = nodeView.derivedNode;
|
|
887
|
+
// 此态 next 不打印 NODE、直接 BLOCKED(节点顺序门禁 / 单趟零进展 / Fix 归位第 4 轮无授权):三个
|
|
888
|
+
// 判定与报文都在共享视图里(resolveNodeOrderBlock / resolveZeroProgressBlock / applyFixRollbackRound
|
|
889
|
+
// 的只读预演),本命令只消费而不另判一份——status 的「route=null + next 将 BLOCKED」来自同一字段,
|
|
890
|
+
// 两边答案因此一致。Fix 第 4 轮在 FIX-BATCH 分支已先行 BLOCK,此处的 blocked 只会是顺序门禁或零进展。
|
|
891
|
+
if (nodeView.blocked !== null) {
|
|
892
|
+
console.error(nodeView.blocked.message);
|
|
893
|
+
process.exit(1);
|
|
426
894
|
}
|
|
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) {
|
|
895
|
+
// 状态漂移自动校正——以文件产物为准(determineNode)校正 state.currentNode。进行中节点不校正
|
|
896
|
+
// (已 entry / 已 record 且未 exit、路由仍在其后继):判定统一在 resolveNodeView 内,本命令不再
|
|
897
|
+
// 内联第二份(与 status 共用;被拦截节点若被推走,其 exit 前置 currentNode 校验无法重跑 → 死结)。
|
|
898
|
+
if (!nodeView.inProgress && state.currentNode !== detectedNode) {
|
|
468
899
|
state.currentNode = detectedNode;
|
|
469
900
|
await writeState(state);
|
|
470
901
|
}
|
|
471
|
-
//
|
|
472
|
-
//
|
|
473
|
-
const printNode =
|
|
902
|
+
// 输出跟随路由视图:进行中时输出 state.currentNode(而非产物推导——否则 state 保持 review 但
|
|
903
|
+
// 输出 NODE: verify,执行者按输出 action 仍然死结);非进行中即产物推导节点。
|
|
904
|
+
const printNode = nodeView.routeNode;
|
|
474
905
|
printNext(protocol, printNode, state.executionMode ?? 'subagent');
|
|
906
|
+
printWhyLine(nodeView);
|
|
907
|
+
printPreflightLine(printNode);
|
|
475
908
|
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
476
909
|
return;
|
|
477
910
|
}
|
|
@@ -512,10 +945,13 @@ export async function runSelect(protocol, argv) {
|
|
|
512
945
|
return;
|
|
513
946
|
}
|
|
514
947
|
|
|
515
|
-
// record <node> <payload>:写证据(技能加载声明标记校验 +
|
|
948
|
+
// record <node> <payload>:写证据(技能加载声明标记校验 + 前置门)
|
|
516
949
|
export async function runRecord(protocol, argv) {
|
|
517
950
|
const nodeId = argv[3];
|
|
518
951
|
if (!nodeId) throw new Error('record requires a Node id.');
|
|
952
|
+
// 声明命令的运行上下文(脚本路径 / 运行根 / 包根 / 本次解析到的协议):本命令的两处恢复指引都要
|
|
953
|
+
// 打印可照抄的命令,一次取好往下传——各调用点各取一次就是同一事实的多处表达。
|
|
954
|
+
const declarationContext = commandContext({ argv });
|
|
519
955
|
const state = await readState();
|
|
520
956
|
state.evidence = state.evidence || {};
|
|
521
957
|
// 解析 JSON 参数并展开到 evidence 顶层(summary/completedChecks/output-schema evidence 等);
|
|
@@ -550,7 +986,6 @@ export async function runRecord(protocol, argv) {
|
|
|
550
986
|
// trim 后以 {/[ 开头 → 视作"形似对象字面量";若 JSON.parse 失败 → fail-closed。
|
|
551
987
|
try {
|
|
552
988
|
parsed = raw ? JSON.parse(raw) : {};
|
|
553
|
-
if (typeof parsed !== 'object' || Array.isArray(parsed)) parsed = { summary: String(parsed) };
|
|
554
989
|
} catch {
|
|
555
990
|
// 契约解析失败 fail-closed:payload 形似对象但 JSON.parse 失败 → 报错并
|
|
556
991
|
// process.exit(1),不写 evidence——防状态污染(旧语义把不可解析 raw 静默作
|
|
@@ -568,99 +1003,109 @@ export async function runRecord(protocol, argv) {
|
|
|
568
1003
|
}
|
|
569
1004
|
parsed = { summary: raw || 'recorded' };
|
|
570
1005
|
}
|
|
1006
|
+
// 载荷本身必须是对象(入口判据,先于形状校验与任何写盘):JSON 可解析的非对象取值
|
|
1007
|
+
// (null / 数组 / 字符串 / 数字)旧实现两条路都错——null 一路放行到读 parsed.completedChecks 时
|
|
1008
|
+
// 抛 TypeError(报文是堆栈,既不说哪一步错了、也不说载荷该长什么样),数组/字符串/数字则被静默
|
|
1009
|
+
// 改写成 { summary: String(...) }(替调用方编了一份它没说过的载荷,证据从此不可按字段消费)。
|
|
1010
|
+
// 本判据只在本入口:形状表(state-schema.evidencePayloadProblems)判的是「对象各字段的类型」,
|
|
1011
|
+
// 载荷不是对象时它按设计放行——两件事各守自己边界内的事实,不互相越界。
|
|
1012
|
+
if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
|
1013
|
+
const payloadTypeName = parsed === null ? 'null' : (Array.isArray(parsed) ? 'array' : typeof parsed);
|
|
1014
|
+
console.error('ERROR: record 载荷必须是对象(当前是 ' + payloadTypeName + ')—— state 未改写');
|
|
1015
|
+
console.error('恢复: ' + scriptCommand({
|
|
1016
|
+
scriptsDir,
|
|
1017
|
+
runRoot: runRootDir(),
|
|
1018
|
+
script: 'workflow-state.mjs',
|
|
1019
|
+
args: ['record', nodeId, `'{"summary":"<本节点完成摘要>"}'`],
|
|
1020
|
+
}) + ' 用对象载荷重试;载荷里的引号被 shell 吞掉时改用 --json-file <path> 传入 JSON 文件'
|
|
1021
|
+
+ '(cmd.exe 请把单引号换成双引号,并转义载荷里原有的双引号)');
|
|
1022
|
+
process.exit(1);
|
|
1023
|
+
}
|
|
1024
|
+
// 载荷形状校验(写入前 fail-closed;判定单一来源 = state-schema.evidencePayloadProblems):
|
|
1025
|
+
// 类型错误的载荷不得落库——否则下游出口门禁只会报「缺 evidence: <schema>」,出错的是 record、
|
|
1026
|
+
// 报错的却是 exit,执行者得自己反推载荷该写什么形状。故在此拦下:点名字段路径与当前类型,
|
|
1027
|
+
// 给出可照抄的正确形态;只判类型/非空,取值是否合法(扫描份数、提名编号是否登记)仍归出口门禁。
|
|
1028
|
+
const shapeProblems = evidencePayloadProblems(parsed);
|
|
1029
|
+
if (shapeProblems.length > 0) {
|
|
1030
|
+
console.error('ERROR: record 载荷形状不合法(写入前拒绝,state 未改写):');
|
|
1031
|
+
for (const problem of shapeProblems) {
|
|
1032
|
+
console.error(' ' + problem.field + ': ' + problem.message);
|
|
1033
|
+
}
|
|
1034
|
+
console.error('恢复: ' + scriptCommand({
|
|
1035
|
+
scriptsDir,
|
|
1036
|
+
runRoot: runRootDir(),
|
|
1037
|
+
script: 'workflow-state.mjs',
|
|
1038
|
+
args: ['record', nodeId, `'{"summary":"<本节点完成摘要>"}'`],
|
|
1039
|
+
}) + ' 用类型合法的载荷重试(summary 为非空字符串;completedChecks 为字符串数组;'
|
|
1040
|
+
+ 'lessonsNomination 为 { scanned, nominated[], reasonIfNone },nominated 元素是条目编号字符串)'
|
|
1041
|
+
+ ';载荷里的引号被 shell 吞掉时改用 --json-file <path> 传入 JSON 文件'
|
|
1042
|
+
+ '(cmd.exe 请把单引号换成双引号,并转义载荷里原有的双引号)');
|
|
1043
|
+
process.exit(1);
|
|
1044
|
+
}
|
|
571
1045
|
// completedChecks 真实性校验(skill-load 声明标记)——解析本次 record 写入的
|
|
572
1046
|
// completedChecks 的 required-skill:<node>.<skill> 条目 → 对应声明标记必须存在,
|
|
573
1047
|
// 缺失 → BLOCKED + 指引先加载 skill 并运行 skill-load;标记 at 必须 ≤ 本次记录时间
|
|
574
1048
|
// (交叉自洽:标记先于记录声明)。仅校验本次写入的 payload,旧 evidence 不追溯(旧 change 兼容)。
|
|
575
1049
|
const recordedAt = new Date().toISOString();
|
|
576
|
-
//
|
|
577
|
-
//
|
|
1050
|
+
// 身份与位置(与 status / next 同源;先于任何写盘与声明门):身份在办 → 位置必须可解析;解析不到
|
|
1051
|
+
// 就 fail-closed(不写 evidence、不猜落点)。此前位置解析隐式散在两条取值路径上(标记归属与尾部
|
|
1052
|
+
// 节点视图各算一次),移动后两处会各自给出「目录不存在」的假答案。
|
|
1053
|
+
// 排序:载荷的形状校验在前(它判的是本命令自己的参数面,报的是「你怎么调用的」),位置门在后
|
|
1054
|
+
// (它判的是这次记录能不能落地)——两者都 fail-closed,但先把参数问题说清楚。
|
|
1055
|
+
const identityChange = state.activeChange || await findActiveChange();
|
|
1056
|
+
const location = identityChange === null ? null : await requireChangeLocation(identityChange, state);
|
|
1057
|
+
// 标记归属 change 与 evidence 一致:身份取值与 status / next / 尾部视图**同一份**(上方一次
|
|
1058
|
+
// 取好);无身份 → verifySkillLoadMarkers 内 fail-closed BLOCK。
|
|
578
1059
|
// 传入 protocol + state——按 requiredSkillCalls scope 分类条目(handoff scope 豁免标记,
|
|
579
1060
|
// 以共用证据库 handoffResult 为证据)
|
|
580
|
-
const markerChange =
|
|
581
|
-
const markerCheck = await verifySkillLoadMarkers(parsed.completedChecks, markerChange, recordedAt, protocol, state);
|
|
1061
|
+
const markerChange = identityChange;
|
|
1062
|
+
const markerCheck = await verifySkillLoadMarkers(parsed.completedChecks, markerChange, recordedAt, protocol, state, declarationContext);
|
|
582
1063
|
if (!markerCheck.ok) {
|
|
583
1064
|
console.error('BLOCKED: ' + markerCheck.reason);
|
|
584
1065
|
process.exit(1);
|
|
585
1066
|
}
|
|
586
1067
|
// 技能加载前置门(方案 A):节点完成记录必须先有本节点
|
|
587
1068
|
// skill-load 声明标记——无论 payload 是否含 completedChecks 都校验(堵"先干活后补
|
|
588
|
-
// 声明"旁路):缺失 →
|
|
589
|
-
//
|
|
590
|
-
// verifySkillLoadMarkers 的 scope 豁免一致)——本门按
|
|
591
|
-
//
|
|
592
|
-
//
|
|
1069
|
+
// 声明"旁路):缺失 → BLOCKED(单一判级)。指引先加载技能,再照抄派生出的
|
|
1070
|
+
// 声明命令(该节点每个必需技能各一条,全部协议文件 + 模板全清单)后重试。handoff scope 技能
|
|
1071
|
+
// (子代理加载)不要求协调者声明(与 verifySkillLoadMarkers 的 scope 豁免一致)——本门按
|
|
1072
|
+
// <node>-*.json 存在性判定,与 guard exit 侧协议声明标记校验同构。仅对存在于当前协议的节点生效
|
|
1073
|
+
// (协议外节点名的记录不适用前置门),无 active change 时无法定位标记而不重复报错(遗留兼容)。
|
|
593
1074
|
const recordNodeDef = (protocol.nodes ?? []).find((n) => n.id === nodeId);
|
|
594
1075
|
if (recordNodeDef && markerChange) {
|
|
595
1076
|
const declaredForNode = await hasNodeSkillDeclaration(nodeId, markerChange);
|
|
596
1077
|
if (!declaredForNode) {
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
|
|
1078
|
+
// 声明命令由协议派生(该节点每个必需技能各一条,每条都带该节点全部协议文件、模板全清单与
|
|
1079
|
+
// 协议上下文),与守卫侧恢复段同一装配:旧形态是手拼的 "skill-load <node> <skill>"——位置实参位
|
|
1080
|
+
// 写占位符在 bash 里是重定向,照抄直接语法失败;换成真名也只声明了一个技能、不带模板清单,
|
|
1081
|
+
// record 放行后 exit 还要再拦一次。
|
|
1082
|
+
const loadGuide = '先加载技能(用 Skill 工具,禁止跳过),再照抄下面的命令声明本节点技能加载'
|
|
1083
|
+
+ '(同一 node-skill 重跑会覆写该标记):\n '
|
|
1084
|
+
+ declarationCommands({
|
|
1085
|
+
node: recordNodeDef,
|
|
1086
|
+
skills: declarationSkillTargets(recordNodeDef),
|
|
1087
|
+
context: declarationContext,
|
|
1088
|
+
}).map((entry) => entry.command).join('\n ')
|
|
1089
|
+
+ '\n然后重试 record';
|
|
1090
|
+
console.error('BLOCKED: 节点 ' + nodeId + ' 缺少技能加载声明标记(.skill-loads/' + nodeId + '-*.json)——' + loadGuide);
|
|
1091
|
+
process.exit(1);
|
|
603
1092
|
}
|
|
604
|
-
// 模板声明核对(C11)——声明标记里必须有与该节点映射一致的 templates
|
|
605
|
-
//
|
|
1093
|
+
// 模板声明核对(C11)——声明标记里必须有与该节点映射一致的 templates 集合:缺失 / 多写 /
|
|
1094
|
+
// 漏写 / 错名 BLOCK(fail-closed,不让人「声明了但说得不对」)。
|
|
606
1095
|
// 自定义协议节点不比对(C12);无活动 change / 声明机制未激活时不在这里报(见该函数的边界注释)。
|
|
607
1096
|
const templateCheck = await verifyTemplateDeclaration({
|
|
608
1097
|
protocol,
|
|
609
1098
|
nodeId,
|
|
610
1099
|
changeName: markerChange,
|
|
611
|
-
|
|
1100
|
+
commandContext: declarationContext,
|
|
612
1101
|
});
|
|
613
|
-
if (templateCheck.warn) console.error('WARN: ' + templateCheck.warn);
|
|
614
1102
|
if (!templateCheck.ok) {
|
|
615
1103
|
console.error('BLOCKED: ' + templateCheck.reason);
|
|
616
1104
|
process.exit(1);
|
|
617
1105
|
}
|
|
618
1106
|
}
|
|
619
|
-
//
|
|
620
|
-
//
|
|
621
|
-
// 由 record 代记;与手动 skill-load 标记同体系,exit 协议声明校验共用)
|
|
622
|
-
// 新 change 下 required 条目停用自动补写(手动声明唯一路径,否则抵消前置门);
|
|
623
|
-
// 旧 change 保留兜底(渐进兼容)。
|
|
624
|
-
if (recordNodeDef && markerChange && state.newChange !== true) {
|
|
625
|
-
const recordProtoFiles = NODE_PROTOCOL_FILES[nodeId] ?? [];
|
|
626
|
-
// 标记目录解析:活动路径优先;change 已归档(活动目录不存在但归档目录存在)
|
|
627
|
-
// 时写归档路径——防重建已归档的活动目录(归档移动语义;与 findSkillLoadsDir 双路径一致)。
|
|
628
|
-
// 跳过条件:活动与归档均无 .skill-loads **且活动 change 目录已不存在**(归档移动后)
|
|
629
|
-
// ——此时 writeJsonAtomic 的 mkdir recursive 会把已归档的活动目录残留回来;
|
|
630
|
-
// 活动 change 目录仍存在(正常流程)时创建 .skill-loads 子目录是自动补写的正常职责,不跳过
|
|
631
|
-
const activeLoadsDir = path.join(specsDir(), markerChange, '.skill-loads');
|
|
632
|
-
let targetLoadsDir = activeLoadsDir;
|
|
633
|
-
if (!(await fileExists(activeLoadsDir))) {
|
|
634
|
-
const archived = await findSkillLoadsDir(markerChange);
|
|
635
|
-
if (archived !== null && archived.dir !== activeLoadsDir) {
|
|
636
|
-
targetLoadsDir = archived.dir;
|
|
637
|
-
} else if (archived === null && !(await fileExists(path.join(specsDir(), markerChange)))) {
|
|
638
|
-
targetLoadsDir = null;
|
|
639
|
-
}
|
|
640
|
-
}
|
|
641
|
-
if (targetLoadsDir !== null) {
|
|
642
|
-
for (const binding of recordNodeDef.requiredSkillCalls ?? []) {
|
|
643
|
-
// handoff scope 技能由子代理加载(协调者不声明)——不自动补协调者标记
|
|
644
|
-
if (binding.scope === 'handoff') continue;
|
|
645
|
-
const markerFile = path.join(targetLoadsDir, nodeId + '-' + binding.skill + '.json');
|
|
646
|
-
let markerExists = false;
|
|
647
|
-
try { await fs.access(markerFile); markerExists = true; } catch { /* 标记不存在 */ }
|
|
648
|
-
if (!markerExists) {
|
|
649
|
-
// 自动补的 protocol 字段按 skill 归属协议文件(如 open 的 requirement 标记应写
|
|
650
|
-
// 1-requirement.md 而非节点首文件 0-change.md——所有 skill 都写首文件会让
|
|
651
|
-
// 标记的协议归属语义错误;exit 校验只查归属集合故能通过,但标记不可信)
|
|
652
|
-
const skillProtoFiles = SKILL_PROTOCOL_FILES[binding.skill] ?? [];
|
|
653
|
-
await writeJsonAtomic(markerFile, {
|
|
654
|
-
node: nodeId,
|
|
655
|
-
skill: binding.skill,
|
|
656
|
-
protocol: skillProtoFiles.length > 0 ? skillProtoFiles[0] : null,
|
|
657
|
-
at: recordedAt,
|
|
658
|
-
auto: true,
|
|
659
|
-
});
|
|
660
|
-
}
|
|
661
|
-
}
|
|
662
|
-
}
|
|
663
|
-
}
|
|
1107
|
+
// 声明标记的唯一写入通道 = 执行者手动 skill-load(本命令不代记任何标记):缺声明在上一道
|
|
1108
|
+
// 前置门已 BLOCKED,走到这里说明声明齐备。
|
|
664
1109
|
state.evidence[nodeId] = {
|
|
665
1110
|
...(state.evidence[nodeId] || {}),
|
|
666
1111
|
...parsed,
|
|
@@ -668,9 +1113,22 @@ export async function runRecord(protocol, argv) {
|
|
|
668
1113
|
};
|
|
669
1114
|
await writeState(state);
|
|
670
1115
|
console.log('EVIDENCE: ' + nodeId);
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
1116
|
+
// 节点视图与 next / status 同源(L-067 族):record 也是「我现在该在哪个节点」的输出面。直接取
|
|
1117
|
+
// 产物推导会让三面在**进行中保护**生效时分叉(record 报 review,而 next / status.routeNode 报
|
|
1118
|
+
// execute)——故复用 resolveNodeView 的 routeNode:本命令不自持第二份判定,也不改变自己的写面
|
|
1119
|
+
// (record 只写证据,不写 currentNode,视图是纯读)。
|
|
1120
|
+
const changeName = identityChange;
|
|
1121
|
+
const nodeView = changeName ? await resolveNodeView({ changeName, protocol, state, location }) : null;
|
|
1122
|
+
// 边界态(next 会 BLOCKED、不打印 NODE):record 是同一事实的第四个输出面,尾巴不得再声称
|
|
1123
|
+
// 「NEXT: done」——那是在说「没有下一节点了」,与 next 的 BLOCKED、status.routeNode=null 相反。
|
|
1124
|
+
// 命中时改打与 ROUTE: 行同源的一句(原因 + 先按恢复指引处理),NODE / SKILL 一律不打(next 此刻
|
|
1125
|
+
// 也不打)。blocked 来自共享视图在 state 副本上的只读预演:轮次与 currentNode 不动,本命令的写面
|
|
1126
|
+
// 仍只有它自己的证据。
|
|
1127
|
+
if (nodeView?.blocked) {
|
|
1128
|
+
console.log('NEXT: blocked(' + nodeView.blocked.reason + ';先按恢复指引处理)');
|
|
1129
|
+
return;
|
|
1130
|
+
}
|
|
1131
|
+
printNext(protocol, nodeView?.routeNode ?? null, state.executionMode ?? 'subagent');
|
|
674
1132
|
return;
|
|
675
1133
|
}
|
|
676
1134
|
|