flow-comet 1.7.0 → 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 +16 -14
- package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +1 -1
- 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 +9 -9
- 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/items/a.mjs +25 -8
- package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +41 -38
- package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +11 -9
- package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/items/f.mjs +1 -1
- package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +112 -53
- package/.flow-comet/skills/flow-comet/scripts/items/k.mjs +357 -3
- package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +24 -1
- package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/items/n.mjs +9 -10
- package/.flow-comet/skills/flow-comet/scripts/lib/ac-coverage.mjs +8 -8
- package/.flow-comet/skills/flow-comet/scripts/lib/fix-loop-node.mjs +4 -15
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +79 -107
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +183 -232
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +91 -14
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +20 -32
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +10 -19
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +27 -17
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +240 -87
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +15 -22
- package/.flow-comet/skills/flow-comet/scripts/lib/state-determine.mjs +11 -4
- package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +192 -24
- package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +55 -44
- package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +2 -4
- package/.flow-comet/skills/flow-comet/scripts/lib/test-assertions.mjs +0 -3
- package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +191 -17
- package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +3 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +23 -5
- package/.flow-comet/skills/flow-comet/scripts/lib/wave-projection.mjs +10 -11
- package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +40 -3
- package/.flow-comet/skills/flow-comet/scripts/route-node.mjs +12 -5
- package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +193 -111
- package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +314 -57
- package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +311 -216
- package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +33 -62
- package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +188 -91
- package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +94 -37
- package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +36 -27
- package/.flow-comet/skills/flow-comet/scripts/scenarios/h.mjs +285 -9
- package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +2 -6
- package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +5 -15
- package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +6 -5
- package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +40 -36
- package/.flow-comet/skills/flow-comet/scripts/scenarios/m.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/scenarios/n.mjs +346 -25
- package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +0 -2
- package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +41 -54
- 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 +11 -11
- 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 +8 -8
- package/.flow-comet/skills/flow-comet-review/SKILL.md +8 -8
- package/.flow-comet/skills/flow-comet-subagent-execute/GUIDANCE.md +1 -1
- package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +14 -14
- package/.flow-comet/skills/flow-comet-task/SKILL.md +3 -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
|
@@ -10,15 +10,14 @@ import { route, hasSubagentNode, protocolTaskFilePath, resolveFixRollbackDecisio
|
|
|
10
10
|
import { taskOpeningAttrs, taskBlocks } from '../task-parsing.mjs';
|
|
11
11
|
import {
|
|
12
12
|
NODE_PROTOCOL_FILES,
|
|
13
|
-
SKILL_PROTOCOL_FILES,
|
|
14
13
|
declarationSkillTargets,
|
|
15
14
|
inspectWorkflowPathSegments,
|
|
16
15
|
} from '../protocol-utils.mjs';
|
|
17
|
-
import { evidencePayloadProblems, looksLikeObjectLiteral, toPersistedProtocolPath
|
|
18
|
-
import { nowTimestamp } from '../time-utils.mjs';
|
|
16
|
+
import { evidencePayloadProblems, looksLikeObjectLiteral, toPersistedProtocolPath } from '../state-schema.mjs';
|
|
17
|
+
import { formatLocalTimestamp, nowTimestamp } from '../time-utils.mjs';
|
|
19
18
|
import { probeProject, classify, printDetection, validateContext, printGenerationGuide } from '../context-init.mjs';
|
|
20
|
-
import { fileExists, findActiveChange, readState, writeState, specsDir, runRootDir, hasExactSpecsEntry } from './state-io.mjs';
|
|
21
|
-
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';
|
|
22
21
|
import { determineNode, normalAdvanceExempt } from './state-determine.mjs';
|
|
23
22
|
import { isInsideWorkTree, gitBranchName, branchExists, printBranchLine } from './state-branch.mjs';
|
|
24
23
|
import { printEvolveDueHint } from './state-evolve-hint.mjs';
|
|
@@ -26,7 +25,7 @@ import { reportIntelScanDrift } from './state-intelscan.mjs';
|
|
|
26
25
|
// 命令文本的唯一实现(平台化脚本根 + 整条路径加引号):运行期 PREFLIGHT 与 handoff result /
|
|
27
26
|
// guard 恢复指引 / explain 的 COMMAND 行同源(L-067:同一推导两处表达必然分叉)。声明命令与守卫族
|
|
28
27
|
// 同一装配(declarationCommands)+ 本族的运行上下文(commandContext)——不再各拼一份文本。
|
|
29
|
-
import { commandContext, declarationCommands, scriptCommand } from './state-explain.mjs';
|
|
28
|
+
import { commandContext, declarationCommands, protocolContextArgs, scriptCommand } from './state-explain.mjs';
|
|
30
29
|
// 协调者提示的单一来源:entry(门禁族)与 next / record(本模块)共用同一常量,各输出面逐字
|
|
31
30
|
// 一致。常量落在中立模块(state-explain)而不是门禁族——本模块只为一句措辞去依赖整个上游门禁面
|
|
32
31
|
// 是一条反向边——为此状态命令族不再 import 门禁族。
|
|
@@ -99,6 +98,25 @@ function printNext(protocol, nodeId, executionMode = 'subagent') {
|
|
|
99
98
|
}
|
|
100
99
|
}
|
|
101
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
|
+
|
|
102
120
|
// ---------- 节点视图(单一实现):state 原值 / 产物推导 / 进行中保护 → 路由视图 ----------
|
|
103
121
|
// 「我现在该在哪个节点」只有这一份判定(同一事实两处实现必然分叉——LESSONS 的路由单一权威族)。
|
|
104
122
|
// 收敛前 next 内联一份、status 只报产物推导:同一 state 下两条命令报不同节点,执行者按任一输出
|
|
@@ -167,7 +185,7 @@ async function resolveZeroProgressBlock({ changeName, protocol, nodeId }) {
|
|
|
167
185
|
// ——真乱序(跳节点)仍严格 BLOCK。
|
|
168
186
|
// 归属:next 曾内联这一份,而 status 照常给节点——同一 state 下「status 叫人 exit 一个 next 根本不会
|
|
169
187
|
// 打印的节点」。搬进共享视图后 next 只消费 view.blocked,两份判定不再可能分叉。
|
|
170
|
-
async function resolveNodeOrderBlock({ changeName, protocol, completedArr, state }) {
|
|
188
|
+
async function resolveNodeOrderBlock({ changeName, protocol, completedArr, state, changeDir = null }) {
|
|
171
189
|
if (!state.currentNode || completedArr.includes(state.currentNode)) return null;
|
|
172
190
|
const nodeEvidence = state.evidence && typeof state.evidence === 'object'
|
|
173
191
|
? state.evidence[state.currentNode]
|
|
@@ -177,11 +195,16 @@ async function resolveNodeOrderBlock({ changeName, protocol, completedArr, state
|
|
|
177
195
|
runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr, currentNode: state.currentNode,
|
|
178
196
|
history: state.history,
|
|
179
197
|
});
|
|
180
|
-
const advanceExempt = await normalAdvanceExempt(state, protocol, completedArr, state.currentNode, changeName);
|
|
198
|
+
const advanceExempt = await normalAdvanceExempt(state, protocol, completedArr, state.currentNode, changeName, changeDir);
|
|
181
199
|
if (rollbackExempt || advanceExempt) return null;
|
|
200
|
+
// 第二行的恢复动作按目录在哪分叉——与出口侧(转移前置 / entry 记录门 / 证据门)同一实现
|
|
201
|
+
// (state-io.recoveryActionTextAt):目录已搬进归档时 advance / select 都走不通(select 要求活动
|
|
202
|
+
// 目录在场,advance 的产物推导读活动路径),只给可执行的那一步(把目录移回活动位置)。活动态下
|
|
203
|
+
// 该函数原样返回 activeText,输出因此与改动前逐字相同。
|
|
182
204
|
return [
|
|
183
205
|
'BLOCKED: 疑似未 exit 节点 ' + state.currentNode + ',先 workflow-guard.mjs exit ' + state.currentNode + ' --apply',
|
|
184
|
-
'恢复: 确认当前节点实际已完成 → 用 exit <节点> --apply 正常推进;节点状态漂移/卡死 →
|
|
206
|
+
'恢复: 确认当前节点实际已完成 → 用 exit <节点> --apply 正常推进;节点状态漂移/卡死 → '
|
|
207
|
+
+ recoveryActionTextAt(runRootDir(), changeName, '用 workflow-state.mjs advance(强制推进)或 select(切换 change);禁止手改 state 机器字段'),
|
|
185
208
|
].join('\n');
|
|
186
209
|
}
|
|
187
210
|
|
|
@@ -200,9 +223,13 @@ async function resolveFixReturnTarget({ changeName, protocol, completedArr, stat
|
|
|
200
223
|
return sourceNode;
|
|
201
224
|
}
|
|
202
225
|
|
|
203
|
-
|
|
226
|
+
// location = 位置门解析到的结果(state-io.resolveChangeDir);缺省 null 时按 .specs/<changeName> 解析
|
|
227
|
+
// (既有形态)。产物推导必须与位置解析认同一个目录:目录搬进归档后仍按活动路径推导,视图会回退到
|
|
228
|
+
// 协议首节点(「移动后 record 打 NODE: open」的成因)。
|
|
229
|
+
export async function resolveNodeView({ changeName, protocol, state, location = null }) {
|
|
204
230
|
const completedArr = Array.isArray(state.completedNodes) ? state.completedNodes : [];
|
|
205
|
-
const
|
|
231
|
+
const changeDir = location === null ? null : location.relative;
|
|
232
|
+
const derivedNode = await determineNode(changeName, protocol, completedArr, changeDir);
|
|
206
233
|
// 进行中节点保护:currentNode 未 exit(不在 completedNodes)且已 entry(enteredNodes 含该节点)
|
|
207
234
|
// 或已 record(evidence 记录过)→ 视为进行中(可能 exit 被内容级拦截后重跑),不校正推走——
|
|
208
235
|
// 否则被拦截节点的 exit 前置校验(currentNode 匹配)无法重跑,advance/select 均不恢复 → 死结
|
|
@@ -222,7 +249,7 @@ export async function resolveNodeView({ changeName, protocol, state }) {
|
|
|
222
249
|
// currentNode 仅是初始陈旧节点)时不做路由后继保护——产物推导继续生效推进到最终节点。
|
|
223
250
|
// 推导跳跃/跨节点或回退 → 产物权威校正(漂移,防过度修复)。静态直接后继兜底(串行推进原语义)。
|
|
224
251
|
const routingSuccessorOfCurrent = state.currentNode
|
|
225
|
-
? await determineNode(changeName, protocol, [...completedArr, state.currentNode])
|
|
252
|
+
? await determineNode(changeName, protocol, [...completedArr, state.currentNode], changeDir)
|
|
226
253
|
: null;
|
|
227
254
|
// 「相等」还不是后继:等号只在两处推导同值时成立,派生的节点仍可能在 currentNode **之前**
|
|
228
255
|
// (currentNode 之后的节点产物缺失 → 派生回退;或 Fix 归位把任务推回 execute)——此时按等号
|
|
@@ -295,7 +322,7 @@ export async function resolveNodeView({ changeName, protocol, state }) {
|
|
|
295
322
|
})
|
|
296
323
|
: null;
|
|
297
324
|
const orderBlockedMessage = fixRoundBlockedMessage === null && fixReturnTarget === null
|
|
298
|
-
? await resolveNodeOrderBlock({ changeName, protocol, completedArr, state })
|
|
325
|
+
? await resolveNodeOrderBlock({ changeName, protocol, completedArr, state, changeDir })
|
|
299
326
|
: null;
|
|
300
327
|
const blockedMessage = fixRoundBlockedMessage ?? orderBlockedMessage ?? zeroProgressMessage;
|
|
301
328
|
const blocked = blockedMessage === null
|
|
@@ -385,7 +412,136 @@ function printPreflightLine(nodeId) {
|
|
|
385
412
|
console.log('PREFLIGHT: ' + structuralPreflightHint(nodeId));
|
|
386
413
|
}
|
|
387
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
|
+
|
|
388
543
|
// init <change-id> [--branch-prefix <prefix>] [--init-context|--init-skip]
|
|
544
|
+
// [--replace <在途 change> --reason <原因>]
|
|
389
545
|
// protocolPath = 入口 resolveProtocol 解析出的协议路径(协议来源绑定的持久化取值)
|
|
390
546
|
export async function runInit(protocol, argv, protocolPath) {
|
|
391
547
|
const changeName = argv[3];
|
|
@@ -397,12 +553,16 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
397
553
|
// 参数误用防护:以 -- 开头的参数(如 --help)是选项不是 change 名——报错并提示用法,
|
|
398
554
|
// 防止被当作 change id 执行(自动开 change、建分支、写状态——有破坏性)
|
|
399
555
|
if (normalizedChangeName.startsWith('--')) {
|
|
400
|
-
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>]');
|
|
401
557
|
}
|
|
402
558
|
// --branch-prefix <prefix>(缺省 'change/');--init-context / --init-skip(自动初始化检测授权)
|
|
559
|
+
// --replace <在途 change> / --reason <原因>:覆盖另一个在途 change 的显式放行参数(缺省 = 默认阻断;
|
|
560
|
+
// 取值形态在这里只做「有没有给 / 给了什么」,是否放行由下方覆盖闸门单点判定)
|
|
403
561
|
let branchPrefix = 'change/';
|
|
404
562
|
let initContext = false;
|
|
405
563
|
let initSkip = false;
|
|
564
|
+
let replaceChange = null;
|
|
565
|
+
let replaceReason = null;
|
|
406
566
|
const initArgs = argv.slice(4);
|
|
407
567
|
for (let i = 0; i < initArgs.length; i++) {
|
|
408
568
|
if (initArgs[i] === '--branch-prefix') {
|
|
@@ -421,6 +581,23 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
421
581
|
initContext = true;
|
|
422
582
|
} else if (initArgs[i] === '--init-skip') {
|
|
423
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;
|
|
424
601
|
}
|
|
425
602
|
}
|
|
426
603
|
// 自动初始化检测(前置步骤):读旧 state(项目级字段跨 change 保留)→ 探测 → 判决 → 提示/执行
|
|
@@ -428,6 +605,11 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
428
605
|
// (intel-scan 语义);生成后重跑 → 脚本校验 7 段结构 → 通过写 last_intel_scan(确定性校验)。
|
|
429
606
|
let prevState = null;
|
|
430
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
|
+
});
|
|
431
613
|
const probe = await probeProject(runRootDir(), prevState);
|
|
432
614
|
const verdict = classify(probe, prevState);
|
|
433
615
|
let ctxValid = null; // null=未进入校验(非 init-context 或已新鲜);true/false=校验结果
|
|
@@ -493,9 +675,7 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
493
675
|
enablePrReview: false,
|
|
494
676
|
branchPrefix,
|
|
495
677
|
status: 'running',
|
|
496
|
-
//
|
|
497
|
-
newChange: true,
|
|
498
|
-
// 进入证据容器——entry 追加节点;未 entry 检测(新 change 强制)
|
|
678
|
+
// 进入证据容器——entry 追加节点;未 entry 检测强制
|
|
499
679
|
enteredNodes: [],
|
|
500
680
|
createdAt: new Date().toISOString(),
|
|
501
681
|
// 项目级上下文字段跨 change 保留(迁移旧 state;--init-context 刷新扫描时间;--init-skip 记拒绝)
|
|
@@ -550,6 +730,15 @@ export async function runInit(protocol, argv, protocolPath) {
|
|
|
550
730
|
}
|
|
551
731
|
console.log('Initialized: ' + changeName);
|
|
552
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
|
+
}
|
|
553
742
|
// init 输出取协议首节点(与 state.currentNode 一致——内置协议 = open,行为不变)
|
|
554
743
|
printNext(protocol, route(protocol)[0]?.id ?? 'open');
|
|
555
744
|
return;
|
|
@@ -565,9 +754,12 @@ export async function runStatus(protocol) {
|
|
|
565
754
|
return;
|
|
566
755
|
}
|
|
567
756
|
const state = await readState();
|
|
757
|
+
// 位置门(先于任何视图):身份在办但两处目录都没有 → fail-closed,**不得**回落到 no-change
|
|
758
|
+
// (no-change 的语义是「没有在办 change」,与这里的事实相反)。
|
|
759
|
+
const location = await requireChangeLocation(changeName, state);
|
|
568
760
|
// 节点视图(与 next 共用同一判定):currentNode 仍取产物推导(既有键语义逐字不变),
|
|
569
761
|
// routeNode 才是经「进行中保护」后的路由视图(= next 的 NODE 行)。
|
|
570
|
-
const nodeView = await resolveNodeView({ changeName, protocol, state });
|
|
762
|
+
const nodeView = await resolveNodeView({ changeName, protocol, state, location });
|
|
571
763
|
const detectedNode = nodeView.derivedNode;
|
|
572
764
|
// 派生视图(ADR-013 决策 11;改为事件为准):被强制推进的节点以
|
|
573
765
|
// state.history 中本 change 的 advance-forced 事件为唯一判据——按 change 过滤(兼容旧事件
|
|
@@ -608,13 +800,12 @@ export async function runStatus(protocol) {
|
|
|
608
800
|
directOverride: state.directOverride ?? false,
|
|
609
801
|
branchMode: isInsideWorkTree(),
|
|
610
802
|
enablePrReview: state.enablePrReview ?? false,
|
|
611
|
-
|
|
803
|
+
// 产物根 = 位置解析到的目录(活动 / 归档):移动后仍报 .specs/<id> 就是在说一个不存在的落点。
|
|
804
|
+
artifactRoot: location.display,
|
|
612
805
|
// 与 routeNode 同一判定(One predicate):本键回答「协调者模式是否生效」,必须指向路由视图
|
|
613
806
|
// 那个节点——若另取产物推导,进行中态会在同一响应里给出两个「当前节点」口径(routeNode=
|
|
614
807
|
// execute 而 coordinatorMode=false)。既有键名/类型/位置不变,只换判定来源。
|
|
615
|
-
coordinatorMode: EXECUTE_FAMILY_NODE_IDS.has(nodeView.routeNode)
|
|
616
|
-
// 新旧 change 标记——newChange true = 新 change(严格模式);false/缺失 = 旧 change(渐进)
|
|
617
|
-
newChange: state.newChange === true
|
|
808
|
+
coordinatorMode: EXECUTE_FAMILY_NODE_IDS.has(nodeView.routeNode)
|
|
618
809
|
}, null, 2));
|
|
619
810
|
console.log('ROUTE: ' + formatRouteLine(nodeView));
|
|
620
811
|
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
@@ -631,6 +822,9 @@ export async function runNext(protocol) {
|
|
|
631
822
|
return;
|
|
632
823
|
}
|
|
633
824
|
const state = await readState();
|
|
825
|
+
// 位置门(同 status):解析不到就 fail-closed,不打印 NODE / NEXT: done——那是「没有在办 change」
|
|
826
|
+
// 或「已无待跑节点」的措辞,两者都在说假话。
|
|
827
|
+
const location = await requireChangeLocation(changeName, state);
|
|
634
828
|
const completedArr = Array.isArray(state.completedNodes) ? state.completedNodes : [];
|
|
635
829
|
// Fix 回退显式分支——必须早于「疑似未 exit」门禁与进行中漂移保护:
|
|
636
830
|
// review/verify 驻留 + TASK 有 pending 修复任务(串行/并行)或未闭合家族出口签名时,把工作
|
|
@@ -642,8 +836,8 @@ export async function runNext(protocol) {
|
|
|
642
836
|
});
|
|
643
837
|
if (fixRollbackDecision) {
|
|
644
838
|
const sourceNode = state.currentNode;
|
|
645
|
-
// 轮次计数与阈值/授权判定全部走共享 helper:分支②不计数;第 4
|
|
646
|
-
// (此处尚未写盘,满足不写 currentNode
|
|
839
|
+
// 轮次计数与阈值/授权判定全部走共享 helper:分支②不计数;第 4 轮无授权时先 BLOCK
|
|
840
|
+
// (此处尚未写盘,满足不写 currentNode;单一判级,无按 change 新旧的放行侧)。
|
|
647
841
|
const rollbackRound = applyFixRollbackRound({ state, sourceNode, decision: fixRollbackDecision });
|
|
648
842
|
if (rollbackRound.blocked) {
|
|
649
843
|
console.error(rollbackRound.blockedMessage);
|
|
@@ -677,7 +871,7 @@ export async function runNext(protocol) {
|
|
|
677
871
|
? await resolveFixReturnNode({ runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr })
|
|
678
872
|
: null;
|
|
679
873
|
if (fixReturnNode !== null && fixReturnNode === state.currentNode) {
|
|
680
|
-
const returnView = await resolveNodeView({ changeName, protocol, state });
|
|
874
|
+
const returnView = await resolveNodeView({ changeName, protocol, state, location });
|
|
681
875
|
if (returnView.fixReturnTarget !== null) {
|
|
682
876
|
console.log('RETURN: 回程源节点 ' + returnView.fixReturnTarget + '(源节点产物在场且未出口;保留源节点跑出口)');
|
|
683
877
|
printNext(protocol, returnView.routeNode, state.executionMode ?? 'subagent');
|
|
@@ -688,7 +882,7 @@ export async function runNext(protocol) {
|
|
|
688
882
|
}
|
|
689
883
|
// 节点视图(与 status 共用同一判定,见 resolveNodeView——节点顺序门禁也在其中,本命令不再内联
|
|
690
884
|
// 第二份):derivedNode 供零进展防呆与漂移校正使用,routeNode 才是输出节点(next 的 NODE 行)。
|
|
691
|
-
const nodeView = await resolveNodeView({ changeName, protocol, state });
|
|
885
|
+
const nodeView = await resolveNodeView({ changeName, protocol, state, location });
|
|
692
886
|
const detectedNode = nodeView.derivedNode;
|
|
693
887
|
// 此态 next 不打印 NODE、直接 BLOCKED(节点顺序门禁 / 单趟零进展 / Fix 归位第 4 轮无授权):三个
|
|
694
888
|
// 判定与报文都在共享视图里(resolveNodeOrderBlock / resolveZeroProgressBlock / applyFixRollbackRound
|
|
@@ -751,7 +945,7 @@ export async function runSelect(protocol, argv) {
|
|
|
751
945
|
return;
|
|
752
946
|
}
|
|
753
947
|
|
|
754
|
-
// record <node> <payload>:写证据(技能加载声明标记校验 +
|
|
948
|
+
// record <node> <payload>:写证据(技能加载声明标记校验 + 前置门)
|
|
755
949
|
export async function runRecord(protocol, argv) {
|
|
756
950
|
const nodeId = argv[3];
|
|
757
951
|
if (!nodeId) throw new Error('record requires a Node id.');
|
|
@@ -853,11 +1047,18 @@ export async function runRecord(protocol, argv) {
|
|
|
853
1047
|
// 缺失 → BLOCKED + 指引先加载 skill 并运行 skill-load;标记 at 必须 ≤ 本次记录时间
|
|
854
1048
|
// (交叉自洽:标记先于记录声明)。仅校验本次写入的 payload,旧 evidence 不追溯(旧 change 兼容)。
|
|
855
1049
|
const recordedAt = new Date().toISOString();
|
|
856
|
-
//
|
|
857
|
-
//
|
|
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。
|
|
858
1059
|
// 传入 protocol + state——按 requiredSkillCalls scope 分类条目(handoff scope 豁免标记,
|
|
859
1060
|
// 以共用证据库 handoffResult 为证据)
|
|
860
|
-
const markerChange =
|
|
1061
|
+
const markerChange = identityChange;
|
|
861
1062
|
const markerCheck = await verifySkillLoadMarkers(parsed.completedChecks, markerChange, recordedAt, protocol, state, declarationContext);
|
|
862
1063
|
if (!markerCheck.ok) {
|
|
863
1064
|
console.error('BLOCKED: ' + markerCheck.reason);
|
|
@@ -865,7 +1066,7 @@ export async function runRecord(protocol, argv) {
|
|
|
865
1066
|
}
|
|
866
1067
|
// 技能加载前置门(方案 A):节点完成记录必须先有本节点
|
|
867
1068
|
// skill-load 声明标记——无论 payload 是否含 completedChecks 都校验(堵"先干活后补
|
|
868
|
-
// 声明"旁路):缺失 →
|
|
1069
|
+
// 声明"旁路):缺失 → BLOCKED(单一判级)。指引先加载技能,再照抄派生出的
|
|
869
1070
|
// 声明命令(该节点每个必需技能各一条,全部协议文件 + 模板全清单)后重试。handoff scope 技能
|
|
870
1071
|
// (子代理加载)不要求协调者声明(与 verifySkillLoadMarkers 的 scope 豁免一致)——本门按
|
|
871
1072
|
// <node>-*.json 存在性判定,与 guard exit 侧协议声明标记校验同构。仅对存在于当前协议的节点生效
|
|
@@ -886,73 +1087,25 @@ export async function runRecord(protocol, argv) {
|
|
|
886
1087
|
context: declarationContext,
|
|
887
1088
|
}).map((entry) => entry.command).join('\n ')
|
|
888
1089
|
+ '\n然后重试 record';
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
process.exit(1);
|
|
892
|
-
}
|
|
893
|
-
console.error('WARN: 节点 ' + nodeId + ' 缺少技能加载声明标记(.skill-loads/' + nodeId + '-*.json)——' + loadGuide + '(旧 change 渐进不阻断,记录继续)');
|
|
1090
|
+
console.error('BLOCKED: 节点 ' + nodeId + ' 缺少技能加载声明标记(.skill-loads/' + nodeId + '-*.json)——' + loadGuide);
|
|
1091
|
+
process.exit(1);
|
|
894
1092
|
}
|
|
895
|
-
// 模板声明核对(C11)——声明标记里必须有与该节点映射一致的 templates
|
|
896
|
-
//
|
|
1093
|
+
// 模板声明核对(C11)——声明标记里必须有与该节点映射一致的 templates 集合:缺失 / 多写 /
|
|
1094
|
+
// 漏写 / 错名 BLOCK(fail-closed,不让人「声明了但说得不对」)。
|
|
897
1095
|
// 自定义协议节点不比对(C12);无活动 change / 声明机制未激活时不在这里报(见该函数的边界注释)。
|
|
898
1096
|
const templateCheck = await verifyTemplateDeclaration({
|
|
899
1097
|
protocol,
|
|
900
1098
|
nodeId,
|
|
901
1099
|
changeName: markerChange,
|
|
902
|
-
newChange: state.newChange === true,
|
|
903
1100
|
commandContext: declarationContext,
|
|
904
1101
|
});
|
|
905
|
-
if (templateCheck.warn) console.error('WARN: ' + templateCheck.warn);
|
|
906
1102
|
if (!templateCheck.ok) {
|
|
907
1103
|
console.error('BLOCKED: ' + templateCheck.reason);
|
|
908
1104
|
process.exit(1);
|
|
909
1105
|
}
|
|
910
1106
|
}
|
|
911
|
-
//
|
|
912
|
-
//
|
|
913
|
-
// 由 record 代记;与手动 skill-load 标记同体系,exit 协议声明校验共用)
|
|
914
|
-
// 新 change 下 required 条目停用自动补写(手动声明唯一路径,否则抵消前置门);
|
|
915
|
-
// 旧 change 保留兜底(渐进兼容)。
|
|
916
|
-
if (recordNodeDef && markerChange && state.newChange !== true) {
|
|
917
|
-
const recordProtoFiles = NODE_PROTOCOL_FILES[nodeId] ?? [];
|
|
918
|
-
// 标记目录解析:活动路径优先;change 已归档(活动目录不存在但归档目录存在)
|
|
919
|
-
// 时写归档路径——防重建已归档的活动目录(归档移动语义;与 findSkillLoadsDir 双路径一致)。
|
|
920
|
-
// 跳过条件:活动与归档均无 .skill-loads **且活动 change 目录已不存在**(归档移动后)
|
|
921
|
-
// ——此时 writeJsonAtomic 的 mkdir recursive 会把已归档的活动目录残留回来;
|
|
922
|
-
// 活动 change 目录仍存在(正常流程)时创建 .skill-loads 子目录是自动补写的正常职责,不跳过
|
|
923
|
-
const activeLoadsDir = path.join(specsDir(), markerChange, '.skill-loads');
|
|
924
|
-
let targetLoadsDir = activeLoadsDir;
|
|
925
|
-
if (!(await fileExists(activeLoadsDir))) {
|
|
926
|
-
const archived = await findSkillLoadsDir(markerChange);
|
|
927
|
-
if (archived !== null && archived.dir !== activeLoadsDir) {
|
|
928
|
-
targetLoadsDir = archived.dir;
|
|
929
|
-
} else if (archived === null && !(await fileExists(path.join(specsDir(), markerChange)))) {
|
|
930
|
-
targetLoadsDir = null;
|
|
931
|
-
}
|
|
932
|
-
}
|
|
933
|
-
if (targetLoadsDir !== null) {
|
|
934
|
-
for (const binding of recordNodeDef.requiredSkillCalls ?? []) {
|
|
935
|
-
// handoff scope 技能由子代理加载(协调者不声明)——不自动补协调者标记
|
|
936
|
-
if (binding.scope === 'handoff') continue;
|
|
937
|
-
const markerFile = path.join(targetLoadsDir, nodeId + '-' + binding.skill + '.json');
|
|
938
|
-
let markerExists = false;
|
|
939
|
-
try { await fs.access(markerFile); markerExists = true; } catch { /* 标记不存在 */ }
|
|
940
|
-
if (!markerExists) {
|
|
941
|
-
// 自动补的 protocol 字段按 skill 归属协议文件(如 open 的 requirement 标记应写
|
|
942
|
-
// 1-requirement.md 而非节点首文件 0-change.md——所有 skill 都写首文件会让
|
|
943
|
-
// 标记的协议归属语义错误;exit 校验只查归属集合故能通过,但标记不可信)
|
|
944
|
-
const skillProtoFiles = SKILL_PROTOCOL_FILES[binding.skill] ?? [];
|
|
945
|
-
await writeJsonAtomic(markerFile, {
|
|
946
|
-
node: nodeId,
|
|
947
|
-
skill: binding.skill,
|
|
948
|
-
protocol: skillProtoFiles.length > 0 ? skillProtoFiles[0] : null,
|
|
949
|
-
at: recordedAt,
|
|
950
|
-
auto: true,
|
|
951
|
-
});
|
|
952
|
-
}
|
|
953
|
-
}
|
|
954
|
-
}
|
|
955
|
-
}
|
|
1107
|
+
// 声明标记的唯一写入通道 = 执行者手动 skill-load(本命令不代记任何标记):缺声明在上一道
|
|
1108
|
+
// 前置门已 BLOCKED,走到这里说明声明齐备。
|
|
956
1109
|
state.evidence[nodeId] = {
|
|
957
1110
|
...(state.evidence[nodeId] || {}),
|
|
958
1111
|
...parsed,
|
|
@@ -964,8 +1117,8 @@ export async function runRecord(protocol, argv) {
|
|
|
964
1117
|
// 产物推导会让三面在**进行中保护**生效时分叉(record 报 review,而 next / status.routeNode 报
|
|
965
1118
|
// execute)——故复用 resolveNodeView 的 routeNode:本命令不自持第二份判定,也不改变自己的写面
|
|
966
1119
|
// (record 只写证据,不写 currentNode,视图是纯读)。
|
|
967
|
-
const changeName =
|
|
968
|
-
const nodeView = changeName ? await resolveNodeView({ changeName, protocol, state }) : null;
|
|
1120
|
+
const changeName = identityChange;
|
|
1121
|
+
const nodeView = changeName ? await resolveNodeView({ changeName, protocol, state, location }) : null;
|
|
969
1122
|
// 边界态(next 会 BLOCKED、不打印 NODE):record 是同一事实的第四个输出面,尾巴不得再声称
|
|
970
1123
|
// 「NEXT: done」——那是在说「没有下一节点了」,与 next 的 BLOCKED、status.routeNode=null 相反。
|
|
971
1124
|
// 命中时改打与 ROUTE: 行同源的一句(原因 + 先按恢复指引处理),NODE / SKILL 一律不打(next 此刻
|
|
@@ -282,7 +282,7 @@ export async function runReenter(protocol, argv) {
|
|
|
282
282
|
// 因此与 plan 出口**逐字一致**(escalate=false,两阶段口径不变);重校段的现场适配只落在恢复行:
|
|
283
283
|
// ① 缺的段名在这里点名(重校段没有提示账本可「再犯升级」,等第二次才说段名等于永远不说);
|
|
284
284
|
// ② 重试目标是本命令(人在 replan 现场,改完要重跑的是它)。分级沿用既有语义:新 change BLOCKED、
|
|
285
|
-
//
|
|
285
|
+
// 命中即 BLOCKED。
|
|
286
286
|
async function replanTaskStructureGate(state, taskContent) {
|
|
287
287
|
const taskArtifact = await evaluateArtifact('TASK', taskContent, {});
|
|
288
288
|
if (!taskArtifact.derived) return; // 模板缺席 ⇒ 段形无从派生(与 plan 出口同一支「未校验(模板缺失)」)
|
|
@@ -293,15 +293,12 @@ async function replanTaskStructureGate(state, taskContent) {
|
|
|
293
293
|
if (parts.length === 0) return;
|
|
294
294
|
const templateFile = taskArtifact.skeleton.file ?? '(登记表未登记模板路径)';
|
|
295
295
|
const failureLine = 'TASK.md 模板结构校验失败: ' + parts.join('; ') + '(模板: ' + templateFile + ')';
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
process.exit(1);
|
|
303
|
-
}
|
|
304
|
-
console.error('TEMPLATE-STRUCTURE WARN: ' + failureLine + '(旧 change 渐进,不阻断;新 change 将强制)');
|
|
296
|
+
const missingSections = taskArtifact.issues.missing ?? [];
|
|
297
|
+
console.error('BLOCKED: ' + failureLine);
|
|
298
|
+
console.error('恢复: 对照 ' + templateFile + ' 修正标题 / 首部字段 / 段序,并按模板补齐缺失的 H2 与结构型 H3 标题'
|
|
299
|
+
+ (missingSections.length > 0 ? '(缺失的段: ' + missingSections.join('、') + ')' : '')
|
|
300
|
+
+ '——承载段被删掉也算缺段,删段不是跳过判据的写法;改完重试 replan(replan 不做校验豁免,状态零改写)');
|
|
301
|
+
process.exit(1);
|
|
305
302
|
}
|
|
306
303
|
|
|
307
304
|
// replan <reason> --authorized-by <source> [--continue-round <n>]
|
|
@@ -465,19 +462,19 @@ export async function runReplan(protocol, argv) {
|
|
|
465
462
|
// 波次投影(波次 = 依赖层级的投影):与 plan 出口**同源**调用同一判定与同一报文构造(ADR-013:
|
|
466
463
|
// replan 绝不豁免——此处不判,改一改波次散文就能绕过 plan 出口的同一判据)。新 change 不一致
|
|
467
464
|
// (含未被 Wave 行声明的任务,明细取值「未声明」)→ BLOCK(逐条点名 + 恢复指引;本段全部先于
|
|
468
|
-
//
|
|
465
|
+
// 备份与写盘,故状态零改写)。「判不了」按成因二分——载体缺席(无段 / 段名
|
|
469
466
|
// 无从派生)打印「未校验」并跳过;内容不可判(段在场却无可对应任务)与 plan 出口同分级。
|
|
470
467
|
// 分级与措辞都由 waveReviewOutcome 一处产出(本段只派生 blocking):两处不可能各说一套,也不会
|
|
471
468
|
// 因为「分级规则只改了一处」而在另一处静默落后。
|
|
472
469
|
const waveReview = waveProjectionReview({ taskContent, blocks: taskList });
|
|
473
|
-
const waveOutcome = waveReviewOutcome(waveReview, { blocking:
|
|
470
|
+
const waveOutcome = waveReviewOutcome(waveReview, { blocking: true });
|
|
474
471
|
for (const line of waveOutcome.lines) console.error(line);
|
|
475
472
|
if (waveOutcome.block) process.exit(1);
|
|
476
473
|
// 同波可并行却漏标 [P]:plan 出口的第二条波次面判据,重校段同样不豁免(ADR-013)——否则执行期
|
|
477
474
|
// 重签就能把「本可并行却没标」的计划换一份发出去。波次分组复用上面同一次解析(waveReview.waves)。
|
|
478
475
|
const gapOutcome = parallelGapOutcome(
|
|
479
476
|
parallelGapReview({ taskContent, blocks: taskList, waves: waveReview.waves }),
|
|
480
|
-
{ blocking:
|
|
477
|
+
{ blocking: true },
|
|
481
478
|
);
|
|
482
479
|
for (const line of gapOutcome.lines) console.error(line);
|
|
483
480
|
if (gapOutcome.block) process.exit(1);
|
|
@@ -495,15 +492,14 @@ export async function runReplan(protocol, argv) {
|
|
|
495
492
|
}
|
|
496
493
|
}
|
|
497
494
|
if (replanTask7Broken.length > 0) {
|
|
498
|
-
if (replanTask7NewFormat
|
|
495
|
+
if (replanTask7NewFormat) {
|
|
499
496
|
// 文案的集合字符串**从判据常量派生**(不得在此再写一遍字面集合——第二处同口径表达会在
|
|
500
497
|
// 判据演进时静默落后于实现;构造方式不改变渲染结果)。
|
|
501
498
|
console.error('BLOCKED: TASK.md 任务缺 7 字段(' + TASK7_REQUIRED.join('/') + '): '
|
|
502
499
|
+ replanTask7Broken.join('; ') + ';恢复: 对照 flow-kit/templates/TASK.md 补齐每个 <task> 的缺字段后重试;replan 不做校验豁免');
|
|
503
500
|
process.exit(1);
|
|
504
501
|
}
|
|
505
|
-
console.error('TASK-7FIELD WARN: TASK.md ' + replanTask7Broken.join('; ')
|
|
506
|
-
+ (replanTask7NewFormat ? '(旧 change 渐进,不阻断)' : '(旧式一字段模板形态,渐进不阻断)'));
|
|
502
|
+
console.error('TASK-7FIELD WARN: TASK.md ' + replanTask7Broken.join('; ') + '(旧式一字段模板形态,渐进不阻断)');
|
|
507
503
|
}
|
|
508
504
|
// 路径边界:change 名必须是 .specs/ 下的单段真实目录(realpath 归一后仍在 .specs/ 内、
|
|
509
505
|
// 无 symlink/junction 逃逸;复用受控路径边界实现)——备份落点必须先通过该边界。
|
|
@@ -538,12 +534,9 @@ export async function runReplan(protocol, argv) {
|
|
|
538
534
|
if (crossTaskConflicts.length > 0) {
|
|
539
535
|
const crossDetail = crossTaskConflicts.map((c) => c.a + '×' + c.b + '(' + c.files.join(',') + ')').join('; ');
|
|
540
536
|
const crossGuide = ';恢复: 补显式 depends_on 或合并为一个任务后重试';
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
|
|
544
|
-
process.exit(1);
|
|
545
|
-
}
|
|
546
|
-
console.error('WARN: TASK.md 同文件跨任务且无依赖路径(旧 change 渐进不阻断): ' + crossDetail + crossGuide);
|
|
537
|
+
console.error('BLOCKED: TASK.md 同文件跨任务且无依赖路径: ' + crossDetail
|
|
538
|
+
+ '——replan 不做校验豁免,状态零改写' + crossGuide);
|
|
539
|
+
process.exit(1);
|
|
547
540
|
}
|
|
548
541
|
if (readWarnings.length > 0) {
|
|
549
542
|
console.error('WARN: TASK.md 并行任务 read∩write 隐式依赖嫌疑(一方读取对方写路径,建议补显式 depends_on 声明): '
|