flow-comet 1.6.2 → 1.6.4
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 +64 -46
- package/.flow-comet/skills/flow-comet/reference/KNOWN-ISSUES-template.md +1 -1
- package/.flow-comet/skills/flow-comet/reference/commit-discipline.md +32 -0
- package/.flow-comet/skills/flow-comet/reference/dirty-worktree.md +1 -1
- package/.flow-comet/skills/flow-comet/{GUIDANCE.md → reference/entry-detail.md} +18 -28
- package/.flow-comet/skills/flow-comet/reference/fix-loop.md +57 -0
- package/.flow-comet/skills/flow-comet/reference/platform-facts.md +58 -0
- package/.flow-comet/skills/flow-comet/reference/replan.md +23 -0
- package/.flow-comet/skills/flow-comet/scripts/comet-check.mjs +5 -4
- package/.flow-comet/skills/flow-comet/scripts/comet-hook-guard.mjs +266 -25
- package/.flow-comet/skills/flow-comet/scripts/context-init.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/evolve.mjs +6 -6
- package/.flow-comet/skills/flow-comet/scripts/guard-self-test.mjs +67 -16325
- package/.flow-comet/skills/flow-comet/scripts/health.mjs +1 -1
- package/.flow-comet/skills/flow-comet/scripts/items/a.mjs +1030 -0
- package/.flow-comet/skills/flow-comet/scripts/items/b.mjs +830 -0
- package/.flow-comet/skills/flow-comet/scripts/items/c.mjs +781 -0
- package/.flow-comet/skills/flow-comet/scripts/items/d.mjs +99 -0
- package/.flow-comet/skills/flow-comet/scripts/items/e.mjs +185 -0
- package/.flow-comet/skills/flow-comet/scripts/items/f.mjs +90 -0
- package/.flow-comet/skills/flow-comet/scripts/items/g.mjs +59 -0
- package/.flow-comet/skills/flow-comet/scripts/items/h.mjs +815 -0
- package/.flow-comet/skills/flow-comet/scripts/items/i.mjs +77 -0
- package/.flow-comet/skills/flow-comet/scripts/items/j.mjs +75 -0
- package/.flow-comet/skills/flow-comet/scripts/items/k.mjs +1427 -0
- package/.flow-comet/skills/flow-comet/scripts/items/l.mjs +275 -0
- package/.flow-comet/skills/flow-comet/scripts/items/m.mjs +614 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/count-derivation.mjs +97 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/fix-loop-node.mjs +196 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-evidence-gates.mjs +553 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-gates.mjs +837 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-routing.mjs +404 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-state-io.mjs +404 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-template-fidelity.mjs +302 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/guard-uidesign.mjs +133 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/reentry-node.mjs +237 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/replan-node.mjs +209 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-branch.mjs +49 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-bridgecheck.mjs +201 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-admin.mjs +141 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-flow.mjs +700 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-commands-recovery.mjs +578 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-determine.mjs +52 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-evolve-hint.mjs +55 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-explain.mjs +106 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-intelscan.mjs +58 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-io.mjs +147 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/state-skillmarkers.mjs +189 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/system-fixtures.mjs +1441 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/task-graph.mjs +471 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/test-assertions.mjs +509 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/test-fixtures.mjs +1228 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/test-helpers.mjs +237 -0
- package/.flow-comet/skills/flow-comet/scripts/lib/text-anchor-checks.mjs +2484 -0
- package/.flow-comet/skills/flow-comet/scripts/protocol-utils.mjs +2 -2
- package/.flow-comet/skills/flow-comet/scripts/route-node.mjs +73 -1077
- package/.flow-comet/skills/flow-comet/scripts/scenarios/a.mjs +966 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/b.mjs +1233 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/c.mjs +1382 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/d.mjs +483 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/e.mjs +1388 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/f.mjs +1466 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/g.mjs +1364 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/h.mjs +1287 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/i.mjs +1436 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/j.mjs +1384 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/k.mjs +1338 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/l.mjs +1484 -0
- package/.flow-comet/skills/flow-comet/scripts/scenarios/m.mjs +971 -0
- package/.flow-comet/skills/flow-comet/scripts/state-schema.mjs +14 -1
- package/.flow-comet/skills/flow-comet/scripts/system-test.mjs +58 -6692
- package/.flow-comet/skills/flow-comet/scripts/time-utils.mjs +4 -4
- package/.flow-comet/skills/flow-comet/scripts/workflow-guard.mjs +151 -2428
- package/.flow-comet/skills/flow-comet/scripts/workflow-handoff.mjs +116 -9
- package/.flow-comet/skills/flow-comet/scripts/workflow-state.mjs +29 -2086
- package/.flow-comet/skills/flow-comet-archive/SKILL.md +10 -19
- package/.flow-comet/skills/flow-comet-change/SKILL.md +2 -3
- package/.flow-comet/skills/flow-comet-compose/SKILL.md +1 -1
- package/.flow-comet/skills/flow-comet-design/SKILL.md +6 -6
- package/.flow-comet/skills/flow-comet-execute/SKILL.md +58 -16
- package/.flow-comet/skills/flow-comet-integration/SKILL.md +8 -5
- package/.flow-comet/skills/flow-comet-open/SKILL.md +5 -1
- 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 +9 -12
- package/.flow-comet/skills/flow-comet-subagent-execute/SKILL.md +59 -16
- package/.flow-comet/skills/flow-comet-task/SKILL.md +3 -2
- package/.flow-comet/skills/flow-comet-ui-design/SKILL.md +3 -3
- package/.flow-comet/skills/flow-comet-verify/SKILL.md +8 -17
- package/README.md +53 -70
- package/package.json +3 -2
- package/scripts/dsh-bridge.mjs +59 -26
- package/scripts/lib/installer-cleanup.mjs +152 -0
- package/scripts/lib/installer-flowkit.mjs +119 -0
- package/scripts/lib/installer-hooks.mjs +363 -0
- package/scripts/lib/installer-loader.mjs +220 -0
- package/scripts/lib/installer-migrate.mjs +236 -0
- package/scripts/lib/installer-platforms.mjs +314 -0
- package/scripts/prepare-env.mjs +36 -1164
- package/.flow-comet/skills/flow-comet/reference/TEST-MATRIX.md +0 -116
- package/.flow-comet/skills/flow-comet/reference/composition-report.md +0 -65
- package/.flow-comet/skills/flow-comet/reference/dsh-platform.md +0 -184
- package/.flow-comet/skills/flow-comet/reference/resolved-skills.json +0 -661
- package/.flow-comet/skills/flow-comet/reference/skill-review.md +0 -13
- package/.flow-comet/skills/flow-comet/reference/subagents/script-author.md +0 -7
- package/.flow-comet/skills/flow-comet/reference/worktree-notes.md +0 -70
|
@@ -0,0 +1,700 @@
|
|
|
1
|
+
// state 命令族 · 流程面(单一归属):init / status / next / select / record / advance。
|
|
2
|
+
// 本模块只编排各判定族的共享实现(state-io · state-determine · state-branch · state-evolve-hint ·
|
|
3
|
+
// state-intelscan · state-skillmarkers 与既有共享模块),不复制任何判据;argv = 进程参数原样
|
|
4
|
+
// (位置参数取值形态与入口分派前一致)。
|
|
5
|
+
import { execFileSync } from 'child_process';
|
|
6
|
+
import { promises as fs } from 'fs';
|
|
7
|
+
import path from 'path';
|
|
8
|
+
import { route, resolveNextNode, hasSubagentNode, protocolTaskFilePath, resolveFixRollbackDecision, resolveFixRollbackState, applyFixRollbackRound, resolveFixReturnNode, isSingleSegmentChangeName, EXECUTE_FAMILY_NODE_IDS } from '../route-node.mjs';
|
|
9
|
+
import { taskOpeningAttrs, taskBlocks } from '../task-parsing.mjs';
|
|
10
|
+
import { NODE_PROTOCOL_FILES, SKILL_PROTOCOL_FILES, inspectWorkflowPathSegments } from '../protocol-utils.mjs';
|
|
11
|
+
import { looksLikeObjectLiteral, toPersistedProtocolPath, writeJsonAtomic } from '../state-schema.mjs';
|
|
12
|
+
import { nowTimestamp } from '../time-utils.mjs';
|
|
13
|
+
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, findSkillLoadsDir } from './state-skillmarkers.mjs';
|
|
16
|
+
import { determineNode, normalAdvanceExempt } from './state-determine.mjs';
|
|
17
|
+
import { isInsideWorkTree, gitBranchName, branchExists, printBranchLine } from './state-branch.mjs';
|
|
18
|
+
import { printEvolveDueHint } from './state-evolve-hint.mjs';
|
|
19
|
+
import { reportIntelScanDrift } from './state-intelscan.mjs';
|
|
20
|
+
|
|
21
|
+
// --json-file 路径校验:解析后必须位于项目根内(拒绝相对/绝对形式的越界路径,
|
|
22
|
+
// 如 ../..、其他盘符——防读取任意文件内容进 evidence)。runRoot 内的绝对路径合法
|
|
23
|
+
// (场景内文件常见写法,与 record/handoff 的既有用法一致)。符号链接解析后的实际路径
|
|
24
|
+
// 同样必须在项目根内(词法校验不防 symlink 穿越——realpath 后再次校验)。
|
|
25
|
+
// 非字符串/空值(如 --json-file 为最后一个参数)→ 用法错误,不落 path.resolve
|
|
26
|
+
// (undefined 会抛 TypeError、空串解析为 runRoot 报 EISDIR——应是用法错误而非类型错误)
|
|
27
|
+
async function resolveJsonFileWithinRunRoot(jsonFile) {
|
|
28
|
+
if (typeof jsonFile !== 'string' || jsonFile.trim() === '') {
|
|
29
|
+
throw new Error('--json-file requires a path argument');
|
|
30
|
+
}
|
|
31
|
+
const runRoot = runRootDir();
|
|
32
|
+
const abs = path.resolve(runRoot, jsonFile);
|
|
33
|
+
const rel = path.relative(runRoot, abs);
|
|
34
|
+
if (path.isAbsolute(rel) || rel === '..' || rel.startsWith('..' + path.sep)) {
|
|
35
|
+
throw new Error('--json-file 路径必须在项目根内: ' + jsonFile);
|
|
36
|
+
}
|
|
37
|
+
// 统一对 runRoot 也 realpath——Windows 上 runRoot 可能是 8.3 短路径(如 LONGYI~1),
|
|
38
|
+
// realpath 会展开为长路径,两者直接 relative 会误判越界
|
|
39
|
+
const realRoot = await fs.realpath(runRoot);
|
|
40
|
+
const real = await fs.realpath(abs);
|
|
41
|
+
const realRel = path.relative(realRoot, real);
|
|
42
|
+
if (path.isAbsolute(realRel) || realRel === '..' || realRel.startsWith('..' + path.sep)) {
|
|
43
|
+
throw new Error('--json-file 路径经符号链接解析后越出项目根: ' + jsonFile);
|
|
44
|
+
}
|
|
45
|
+
return abs;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
function generatedNodeSkillName(protocol, nodeId) {
|
|
49
|
+
return protocol.name + '-' + nodeId;
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
function printNext(protocol, nodeId, executionMode = 'subagent') {
|
|
53
|
+
if (!nodeId) {
|
|
54
|
+
console.log('NEXT: done');
|
|
55
|
+
return;
|
|
56
|
+
}
|
|
57
|
+
console.log('NEXT: auto');
|
|
58
|
+
console.log('NODE: ' + nodeId);
|
|
59
|
+
console.log('SKILL: ' + generatedNodeSkillName(protocol, nodeId));
|
|
60
|
+
// 输出点名(机器点名下一节点技能):下一节点实现技能必须经 Skill 工具加载——
|
|
61
|
+
// skill 名取节点实现 skill(与 SKILL: 行一致;内置协议 = flow-comet-open 等)
|
|
62
|
+
const implNode = (protocol.nodes ?? []).find((n) => n.id === nodeId);
|
|
63
|
+
const implSkill = implNode && typeof implNode.implementation === 'object' && implNode.implementation !== null
|
|
64
|
+
? implNode.implementation.skill
|
|
65
|
+
: null;
|
|
66
|
+
if (implSkill) {
|
|
67
|
+
console.log('LOAD SKILL: ' + implSkill + '(用 Skill 工具,禁止跳过)');
|
|
68
|
+
}
|
|
69
|
+
if (EXECUTE_FAMILY_NODE_IDS.has(nodeId)) {
|
|
70
|
+
if (executionMode === 'direct' && nodeId === 'execute') {
|
|
71
|
+
console.log('EXECUTION-MODE: direct(主代理直接执行串行任务,必须加载 flow-comet-dev 完整协议;parallel 任务仍由 subagent-execute 委托)');
|
|
72
|
+
} else {
|
|
73
|
+
console.log('COORDINATOR: 你是协调者,不是执行者。禁止在主会话直接修改源码;只能通过 Agent 工具 worktree isolation 委托子代理;子代理回传后仅更新 TASK.md / SUMMARY / handoff evidence。');
|
|
74
|
+
console.log('EXECUTION-MODE: ' + (executionMode === 'direct' ? 'direct' : 'subagent'));
|
|
75
|
+
}
|
|
76
|
+
}
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
// init <change-id> [--branch-prefix <prefix>] [--init-context|--init-skip]
|
|
80
|
+
// protocolPath = 入口 resolveProtocol 解析出的协议路径(协议来源绑定的持久化取值)
|
|
81
|
+
export async function runInit(protocol, argv, protocolPath) {
|
|
82
|
+
const changeName = argv[3];
|
|
83
|
+
if (!changeName) throw new Error('init requires a change name.');
|
|
84
|
+
// trim 后校验:带前导/尾随空白的输入(如 " --help")不得绕过 flag 检测;
|
|
85
|
+
// 纯空白与缺参同义
|
|
86
|
+
const normalizedChangeName = changeName.trim();
|
|
87
|
+
if (!normalizedChangeName) throw new Error('init requires a change name.');
|
|
88
|
+
// 参数误用防护:以 -- 开头的参数(如 --help)是选项不是 change 名——报错并提示用法,
|
|
89
|
+
// 防止被当作 change id 执行(自动开 change、建分支、写状态——有破坏性)
|
|
90
|
+
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]');
|
|
92
|
+
}
|
|
93
|
+
// --branch-prefix <prefix>(缺省 'change/');--init-context / --init-skip(自动初始化检测授权)
|
|
94
|
+
let branchPrefix = 'change/';
|
|
95
|
+
let initContext = false;
|
|
96
|
+
let initSkip = false;
|
|
97
|
+
const initArgs = argv.slice(4);
|
|
98
|
+
for (let i = 0; i < initArgs.length; i++) {
|
|
99
|
+
if (initArgs[i] === '--branch-prefix') {
|
|
100
|
+
const value = initArgs[i + 1];
|
|
101
|
+
if (typeof value !== 'string' || value.trim() === '') {
|
|
102
|
+
throw new Error('--branch-prefix requires a non-empty prefix (e.g. feat/)');
|
|
103
|
+
}
|
|
104
|
+
branchPrefix = value.trim().endsWith('/') ? value.trim() : value.trim() + '/';
|
|
105
|
+
} else if (typeof initArgs[i] === 'string' && initArgs[i].startsWith('--branch-prefix=')) {
|
|
106
|
+
const value = initArgs[i].slice('--branch-prefix='.length);
|
|
107
|
+
if (value === '') {
|
|
108
|
+
throw new Error('--branch-prefix requires a non-empty prefix (e.g. feat/)');
|
|
109
|
+
}
|
|
110
|
+
branchPrefix = value.endsWith('/') ? value : value + '/';
|
|
111
|
+
} else if (initArgs[i] === '--init-context') {
|
|
112
|
+
initContext = true;
|
|
113
|
+
} else if (initArgs[i] === '--init-skip') {
|
|
114
|
+
initSkip = true;
|
|
115
|
+
}
|
|
116
|
+
}
|
|
117
|
+
// 自动初始化检测(前置步骤):读旧 state(项目级字段跨 change 保留)→ 探测 → 判决 → 提示/执行
|
|
118
|
+
// 生成职责:--init-context 时 CONTEXT 缺失 → 输出 INIT-GENERATE 指引,由 agent 全量阅读生成
|
|
119
|
+
// (intel-scan 语义);生成后重跑 → 脚本校验 7 段结构 → 通过写 last_intel_scan(确定性校验)。
|
|
120
|
+
let prevState = null;
|
|
121
|
+
try { prevState = await readState(); } catch { prevState = null; }
|
|
122
|
+
const probe = await probeProject(runRootDir(), prevState);
|
|
123
|
+
const verdict = classify(probe, prevState);
|
|
124
|
+
let ctxValid = null; // null=未进入校验(非 init-context 或已新鲜);true/false=校验结果
|
|
125
|
+
if (initContext || initSkip) {
|
|
126
|
+
// 显式授权路径:--init-context 生成协作(agent 生成 + 脚本校验);--init-skip 记 none
|
|
127
|
+
if (initContext) {
|
|
128
|
+
// 显式 --init-context 总是校验结构(含 verdict=skip 新鲜/记忆场景)——防 CONTEXT 损坏漏检
|
|
129
|
+
let ctxExists = false;
|
|
130
|
+
try { await fs.access(path.join(specsDir(), 'CONTEXT.md')); ctxExists = true; } catch { /* 文件不存在 */ }
|
|
131
|
+
if (ctxExists) {
|
|
132
|
+
const { missingSections, formatIssues } = await validateContext(runRootDir());
|
|
133
|
+
if (missingSections.length === 0 && formatIssues.length === 0) {
|
|
134
|
+
ctxValid = true;
|
|
135
|
+
if (verdict === 'skip') {
|
|
136
|
+
console.log('INIT-DONE: 项目上下文已存在且新鲜,跳过生成。');
|
|
137
|
+
} else {
|
|
138
|
+
console.log('INIT-DONE: 项目上下文(CONTEXT.md)已就绪(7 段 + 模板格式校验通过)。');
|
|
139
|
+
}
|
|
140
|
+
} else {
|
|
141
|
+
// 存在但不满足模板(缺段/格式不符/损坏)——引导 agent 重写(保留既有累积内容)
|
|
142
|
+
const problems = [...formatIssues, ...missingSections.map((s) => '缺段 ' + s)];
|
|
143
|
+
await printGenerationGuide(runRootDir(), probe, { rewrite: true, problems });
|
|
144
|
+
}
|
|
145
|
+
} else if (verdict !== 'skip') {
|
|
146
|
+
await printGenerationGuide(runRootDir(), probe);
|
|
147
|
+
}
|
|
148
|
+
// verdict=skip(记忆 A 拒绝 / 新鲜 B)且 CONTEXT 缺失 → 尊重既有决策,不输出
|
|
149
|
+
}
|
|
150
|
+
if (initSkip && !initContext) {
|
|
151
|
+
console.log('INIT-SKIPPED: 已记录跳过初始化。');
|
|
152
|
+
}
|
|
153
|
+
} else {
|
|
154
|
+
await printDetection(runRootDir(), probe, verdict);
|
|
155
|
+
}
|
|
156
|
+
// init 同 id 重跑防护——.specs/<id>/ 已存在或 activeChange 相同 → WARN 不阻断
|
|
157
|
+
//(向后兼容;正常流程 init 只在 open 前执行一次,防护针对误操作清空进度)
|
|
158
|
+
let specsDirExists = false;
|
|
159
|
+
try { await fs.access(path.join(specsDir(), changeName)); specsDirExists = true; } catch { /* 目录不存在 */ }
|
|
160
|
+
if (prevState?.activeChange === changeName || specsDirExists) {
|
|
161
|
+
console.error('WARN: change ' + changeName + ' 已存在——重跑 init 将重置节点状态(completedNodes/evidence 清空)。若需继续已有 change,请用 advance/select 而非重跑 init。');
|
|
162
|
+
}
|
|
163
|
+
// E1: branchMode 自动判定——git 仓库(cwd=runRoot)→ true;非 git 仓库 → false
|
|
164
|
+
const branchMode = isInsideWorkTree();
|
|
165
|
+
const state = {
|
|
166
|
+
activeChange: changeName,
|
|
167
|
+
// 协议来源绑定:init 解析出的协议路径持久化(项目根相对 POSIX;旧 state 缺字段 = 未绑定,
|
|
168
|
+
// 归属/节点门禁按渐进语义回退环境变量/默认协议)
|
|
169
|
+
protocolPath: toPersistedProtocolPath(runRootDir(), protocolPath),
|
|
170
|
+
// currentNode 取协议首节点(内置协议 = open,行为不变;自定义协议 = 首节点,如 brainstorm)
|
|
171
|
+
currentNode: route(protocol)[0]?.id ?? 'open',
|
|
172
|
+
completedNodes: [],
|
|
173
|
+
evidence: {},
|
|
174
|
+
verifyFailures: 0,
|
|
175
|
+
// verifyFailures 按 change 存储——init 新 change 从零计数(切换 change 不串扰)
|
|
176
|
+
verifyFailuresByChange: {},
|
|
177
|
+
// Fix 受控归位轮次按 change 存储——init 写空对象;旧 state 缺字段按 0 读取
|
|
178
|
+
fixRoundsByChange: {},
|
|
179
|
+
executionMode: 'subagent',
|
|
180
|
+
directOverride: false,
|
|
181
|
+
branchMode,
|
|
182
|
+
enablePrReview: false,
|
|
183
|
+
branchPrefix,
|
|
184
|
+
status: 'running',
|
|
185
|
+
// 新 change 标记——init 即新 change(严格模式开启,不依赖 entry;旧 change 无此字段渐进兼容)
|
|
186
|
+
newChange: true,
|
|
187
|
+
// 进入证据容器——entry 追加节点;未 entry 检测(新 change 强制)
|
|
188
|
+
enteredNodes: [],
|
|
189
|
+
createdAt: new Date().toISOString(),
|
|
190
|
+
// 项目级上下文字段跨 change 保留(迁移旧 state;--init-context 刷新扫描时间;--init-skip 记拒绝)
|
|
191
|
+
...(prevState?.ai_context_doc !== undefined ? { ai_context_doc: prevState.ai_context_doc } : {}),
|
|
192
|
+
...(initSkip ? { ai_context_doc: 'none' } : {}),
|
|
193
|
+
// last_intel_scan 仅在校验通过后写入(agent 生成 → 脚本校验 7 段 → 记录扫描时间);形态一律经
|
|
194
|
+
// time-utils 的 nowTimestamp()(本地时间 + 显式偏移)——与 context-scan 的落点形态同源,不在本
|
|
195
|
+
// 模块内联第二份格式化。段侧**不在本命令的写面内**(该段行的改写与备份只有 context-scan 一份
|
|
196
|
+
// 实现):两处取值不一致由 reportIntelScanDrift 检出并给出可见提示,不静默漂移。
|
|
197
|
+
...(ctxValid === true
|
|
198
|
+
? { last_intel_scan: nowTimestamp() }
|
|
199
|
+
: (prevState?.last_intel_scan !== undefined ? { last_intel_scan: prevState.last_intel_scan } : {})),
|
|
200
|
+
// last_evolve_at 同为**项目级**字段(evolve 的跨 change 基线,写通道 = config set)——init 换
|
|
201
|
+
// change 必须原样保留:丢了它,增量窗口静默退化为全量扫描、到期提示从此不再触发(保留判据与
|
|
202
|
+
// 上一行同形:字段缺席 = 从未跑过 evolve,不得凭空制造该字段——state-schema 不接受 null)
|
|
203
|
+
...(prevState?.last_evolve_at !== undefined ? { last_evolve_at: prevState.last_evolve_at } : {})
|
|
204
|
+
};
|
|
205
|
+
await writeState(state);
|
|
206
|
+
// 扫描时刻的双落点一致性(state ↔ `.specs/CONTEXT.md` 的 `## intel-scan 元数据` 段):本命令写
|
|
207
|
+
// state 后即比对段侧取值——不一致(含同一时刻的两种形态)输出可见提示并点名收敛命令;一致或
|
|
208
|
+
// 无可比对面则静默(不误报)。段行的写通道只有 context-scan,故此处是检测、不是第二份改写实现。
|
|
209
|
+
await reportIntelScanDrift(path.join(specsDir(), 'CONTEXT.md'), state.last_intel_scan);
|
|
210
|
+
// init 创建 .specs/<id>/ 目录——文件即真相从 init 起成立,findActiveChange 立即可识别
|
|
211
|
+
//(init 不创建该目录时,next/status 会报 No active change,与 SKILL 启动协议 init → next 矛盾)
|
|
212
|
+
const specsChangeDir = path.join(specsDir(), changeName);
|
|
213
|
+
await fs.mkdir(specsChangeDir, { recursive: true });
|
|
214
|
+
// 分支创建——branchMode && 当前分支 ≠ <prefix><id> && 分支不存在 → git checkout -b
|
|
215
|
+
// 前缀由 --branch-prefix 指定(缺省 'change/',向后兼容;可适配仓库自身分支规范如 feat/)
|
|
216
|
+
// 失败 → WARN 不 BLOCK,继续纯文件模式(向后兼容)
|
|
217
|
+
const expectedBranch = branchPrefix + changeName;
|
|
218
|
+
// 空仓库状态(带到 BRANCH 输出——声称与实际一致:空仓库无分支)
|
|
219
|
+
let emptyRepo = false;
|
|
220
|
+
if (branchMode) {
|
|
221
|
+
const currentBranch = gitBranchName();
|
|
222
|
+
// 空仓库检测——无提交(git rev-parse HEAD 失败)时分支创建不可行,输出提示
|
|
223
|
+
// (不 BLOCK;纯文件模式继续)并跳过分支创建——警告与行为一致(跳过时 BRANCH 行
|
|
224
|
+
// 若仍声称分支已创建,即与实际矛盾)
|
|
225
|
+
try {
|
|
226
|
+
execFileSync('git', ['rev-parse', 'HEAD'], { cwd: runRootDir(), stdio: 'pipe' });
|
|
227
|
+
} catch {
|
|
228
|
+
emptyRepo = true;
|
|
229
|
+
}
|
|
230
|
+
if (emptyRepo) {
|
|
231
|
+
console.error('INIT EMPTY-REPO WARN: 仓库无提交(git 空仓库),无法创建 ' + expectedBranch + ' 分支——先 git commit 初始提交再 init 启用分支模式,或继续纯文件模式');
|
|
232
|
+
} else if (currentBranch !== null && currentBranch !== expectedBranch && !branchExists(expectedBranch)) {
|
|
233
|
+
try {
|
|
234
|
+
execFileSync('git', ['checkout', '-b', expectedBranch], { cwd: runRootDir(), stdio: 'pipe' });
|
|
235
|
+
} catch {
|
|
236
|
+
console.error('WARN: 创建分支 ' + expectedBranch + ' 失败——继续纯文件模式(分支功能降级;可稍后手动 git checkout -b ' + expectedBranch + ')');
|
|
237
|
+
}
|
|
238
|
+
}
|
|
239
|
+
}
|
|
240
|
+
console.log('Initialized: ' + changeName);
|
|
241
|
+
console.log('BRANCH: ' + (branchMode && !emptyRepo ? expectedBranch : 'none(非 git 仓库或空仓库)'));
|
|
242
|
+
// init 输出取协议首节点(与 state.currentNode 一致——内置协议 = open,行为不变)
|
|
243
|
+
printNext(protocol, route(protocol)[0]?.id ?? 'open');
|
|
244
|
+
return;
|
|
245
|
+
}
|
|
246
|
+
|
|
247
|
+
// status:只读输出当前 change 与节点(派生视图 + 分支行 + evolve 到期提示)
|
|
248
|
+
export async function runStatus(protocol) {
|
|
249
|
+
const changeName = await findActiveChange();
|
|
250
|
+
if (!changeName) {
|
|
251
|
+
console.log(JSON.stringify({ status: 'no-change', message: 'No active change in .specs/' }, null, 2));
|
|
252
|
+
// 到期提示属**项目级**元数据(与是否有 active change 无关):无活跃 change 时同样按阈值输出
|
|
253
|
+
await printEvolveDueHint(await readState());
|
|
254
|
+
return;
|
|
255
|
+
}
|
|
256
|
+
const state = await readState();
|
|
257
|
+
const detectedNode = await determineNode(changeName, protocol, state.completedNodes);
|
|
258
|
+
// 派生视图(ADR-013 决策 11;改为事件为准):被强制推进的节点以
|
|
259
|
+
// state.history 中本 change 的 advance-forced 事件为唯一判据——按 change 过滤(兼容旧事件
|
|
260
|
+
// 无 change 字段),取 e.node 集合后与 completedNodes 求交。旧「completedNodes 含而 evidence
|
|
261
|
+
// 不含」推断会漏报两类真实反例:① record 后被 advance;② replan/reenter 写授权留痕
|
|
262
|
+
// (evidence.<node>.replanAuthorization)后被 advance。state.history === undefined 的旧 state
|
|
263
|
+
// 无事件可依(advance 当时无痕)→ 回退本「缺 evidence」判据。
|
|
264
|
+
const completedArr = Array.isArray(state.completedNodes) ? state.completedNodes : [];
|
|
265
|
+
let forcedNodes;
|
|
266
|
+
if (state.history === undefined) {
|
|
267
|
+
const evidenceMap = state.evidence && typeof state.evidence === 'object' && !Array.isArray(state.evidence)
|
|
268
|
+
? state.evidence
|
|
269
|
+
: {};
|
|
270
|
+
forcedNodes = completedArr.filter((id) => {
|
|
271
|
+
const record = evidenceMap[id];
|
|
272
|
+
return !(record && typeof record === 'object' && !Array.isArray(record));
|
|
273
|
+
});
|
|
274
|
+
} else {
|
|
275
|
+
const forcedSet = new Set(
|
|
276
|
+
(Array.isArray(state.history) ? state.history : [])
|
|
277
|
+
.filter((e) => e
|
|
278
|
+
&& e.event === 'advance-forced'
|
|
279
|
+
&& (typeof e.change !== 'string' || e.change === changeName))
|
|
280
|
+
.map((e) => e.node)
|
|
281
|
+
);
|
|
282
|
+
forcedNodes = completedArr.filter((id) => forcedSet.has(id));
|
|
283
|
+
}
|
|
284
|
+
console.log(JSON.stringify({
|
|
285
|
+
status: 'running',
|
|
286
|
+
change: changeName,
|
|
287
|
+
currentNode: detectedNode,
|
|
288
|
+
stateCurrentNode: state.currentNode,
|
|
289
|
+
completedNodes: state.completedNodes,
|
|
290
|
+
forcedNodes,
|
|
291
|
+
executionMode: state.executionMode ?? 'subagent',
|
|
292
|
+
directOverride: state.directOverride ?? false,
|
|
293
|
+
branchMode: isInsideWorkTree(),
|
|
294
|
+
enablePrReview: state.enablePrReview ?? false,
|
|
295
|
+
artifactRoot: '.specs/' + changeName,
|
|
296
|
+
coordinatorMode: EXECUTE_FAMILY_NODE_IDS.has(detectedNode),
|
|
297
|
+
// 新旧 change 标记——newChange true = 新 change(严格模式);false/缺失 = 旧 change(渐进)
|
|
298
|
+
newChange: state.newChange === true
|
|
299
|
+
}, null, 2));
|
|
300
|
+
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
301
|
+
await printEvolveDueHint(state);
|
|
302
|
+
return;
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
// next:下一节点与技能(含 Fix 回退 / 回程 / 漂移校正分支)
|
|
306
|
+
export async function runNext(protocol) {
|
|
307
|
+
const changeName = await findActiveChange();
|
|
308
|
+
if (!changeName) {
|
|
309
|
+
console.log('NEXT: done');
|
|
310
|
+
console.log('MESSAGE: No active change. Run: node workflow-state.mjs init <change-name>');
|
|
311
|
+
return;
|
|
312
|
+
}
|
|
313
|
+
const state = await readState();
|
|
314
|
+
const completedArr = Array.isArray(state.completedNodes) ? state.completedNodes : [];
|
|
315
|
+
// Fix 回退显式分支——必须早于「疑似未 exit」门禁与进行中漂移保护:
|
|
316
|
+
// review/verify 驻留 + TASK 有 pending 修复任务(串行/并行)或未闭合家族出口签名时,把工作
|
|
317
|
+
// 归属受控归位共享谓词返回的 execute 家族目标(写盘)并显式输出 NODE: <目标>,不再依赖
|
|
318
|
+
// inProgress 保护副作用(否则并行任务 next 输出仍停在源节点)。判定复用 route-node 共享纯函数。
|
|
319
|
+
const fixRollbackDecision = await resolveFixRollbackDecision({
|
|
320
|
+
runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr, currentNode: state.currentNode,
|
|
321
|
+
history: state.history,
|
|
322
|
+
});
|
|
323
|
+
if (fixRollbackDecision) {
|
|
324
|
+
const sourceNode = state.currentNode;
|
|
325
|
+
// 轮次计数与阈值/授权判定全部走共享 helper:分支②不计数;第 4 轮新 change 先 BLOCK
|
|
326
|
+
// (此处尚未写盘,满足不写 currentNode),旧 change WARN 后照常归位。
|
|
327
|
+
const rollbackRound = applyFixRollbackRound({ state, sourceNode, decision: fixRollbackDecision });
|
|
328
|
+
if (rollbackRound.blocked) {
|
|
329
|
+
console.error(rollbackRound.blockedMessage);
|
|
330
|
+
process.exit(1);
|
|
331
|
+
}
|
|
332
|
+
if (rollbackRound.warn) console.error(rollbackRound.warnMessage);
|
|
333
|
+
state.currentNode = fixRollbackDecision.target;
|
|
334
|
+
await writeState(state);
|
|
335
|
+
console.log('FIX-BATCH: 归位 ' + fixRollbackDecision.target + '(源节点 ' + sourceNode + ')' + rollbackRound.auditSuffix);
|
|
336
|
+
printNext(protocol, fixRollbackDecision.target, state.executionMode ?? 'subagent');
|
|
337
|
+
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
338
|
+
return;
|
|
339
|
+
}
|
|
340
|
+
// Fix 回程豁免——exit execute --apply 二次完成把 currentNode 回推源节点后,
|
|
341
|
+
// 源节点产物(REVIEW.md / TEST.md+UAT.md)已在场会让 resolveNextNode 跳过尚未 exit 的
|
|
342
|
+
// 源节点;仅当源节点未完成、任务全 done、firstIncompletePostExecNode === currentNode
|
|
343
|
+
// 且 resolveNextNode 确实会跳过该节点时显式放行(只读不改写 state)。artifactNext ===
|
|
344
|
+
// currentNode 的形态落回既有正常逻辑(normalAdvanceExempt 覆盖),不放宽豁免面。
|
|
345
|
+
const fixReturnNode = state.activeChange
|
|
346
|
+
? await resolveFixReturnNode({ runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr })
|
|
347
|
+
: null;
|
|
348
|
+
if (fixReturnNode !== null && fixReturnNode === state.currentNode) {
|
|
349
|
+
const artifactNext = await resolveNextNode({ runRoot: runRootDir(), changeName, protocol, completedNodes: completedArr });
|
|
350
|
+
const routeIds = route(protocol).map((node) => node.id);
|
|
351
|
+
const artifactNextIdx = routeIds.indexOf(artifactNext);
|
|
352
|
+
const currentIdx = routeIds.indexOf(state.currentNode);
|
|
353
|
+
// 「跳过」必须是产物存在性把路由推到源节点之后;artifactNext 落在源节点之前(如 execute
|
|
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');
|
|
361
|
+
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
362
|
+
return;
|
|
363
|
+
}
|
|
364
|
+
}
|
|
365
|
+
// 节点顺序校验(严格模式)——state.currentNode 非 null、不在 completedNodes、
|
|
366
|
+
// 且 evidence 无该节点记录 → 上一节点从未 exit 就推进 → BLOCKED(exit 1)。
|
|
367
|
+
// 状态漂移校正保留:已完成节点(currentNode ∈ completedNodes,或 evidence 已记录——
|
|
368
|
+
// 节点已被 record/exit 处理过)正常推进不受影响;本校验只拦"证据完全缺失的疑似跳阶段"。
|
|
369
|
+
// 豁免(两种独立判断,任一成立即放行):回退豁免(TASK.md 有 pending 回退修复任务 → execute);
|
|
370
|
+
// 正常推进豁免(currentNode 是 completedNodes 最后节点 exit 推进的正常下一节点,
|
|
371
|
+
// 见 normalAdvanceExempt)——真乱序(跳节点)仍严格 BLOCK
|
|
372
|
+
if (state.currentNode && !completedArr.includes(state.currentNode)) {
|
|
373
|
+
const nodeEvidence = state.evidence && typeof state.evidence === 'object'
|
|
374
|
+
? state.evidence[state.currentNode]
|
|
375
|
+
: null;
|
|
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
|
+
}
|
|
426
|
+
}
|
|
427
|
+
// 状态漂移自动校正——以文件产物为准(determineNode)校正 state.currentNode。
|
|
428
|
+
// 进行中节点保护:currentNode 未 exit(不在 completedNodes)且已记录 evidence(record 过)
|
|
429
|
+
// → 视为节点进行中(可能 exit 被内容级拦截后重跑),不校正推走——否则被拦截节点
|
|
430
|
+
// 的 exit 前置校验(currentNode 匹配)无法重跑,advance/select 均不恢复 → 死结(实测教训)
|
|
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) {
|
|
468
|
+
state.currentNode = detectedNode;
|
|
469
|
+
await writeState(state);
|
|
470
|
+
}
|
|
471
|
+
// 进行中节点保护:不校正时输出也跟随 currentNode(而非产物推导的 detectedNode——
|
|
472
|
+
// 否则 state 保持 review 但输出 NODE: verify,执行者按输出 action 仍然死结)
|
|
473
|
+
const printNode = inProgress ? state.currentNode : detectedNode;
|
|
474
|
+
printNext(protocol, printNode, state.executionMode ?? 'subagent');
|
|
475
|
+
printBranchLine(changeName, state.branchPrefix ?? 'change/');
|
|
476
|
+
return;
|
|
477
|
+
}
|
|
478
|
+
|
|
479
|
+
// select <change-id>:切换 activeChange(目录边界 + 名字逐字相等)
|
|
480
|
+
export async function runSelect(protocol, argv) {
|
|
481
|
+
const changeName = argv[3];
|
|
482
|
+
if (!changeName) throw new Error('select requires a change name.');
|
|
483
|
+
// change 名必须是 .specs/ 下的单段目录名(形态单一权威在 route-node.mjs):拒绝路径分隔符、
|
|
484
|
+
// . / .. 与保留目录 archive(归档区不是活跃 change)——多段路径会把归档目录等非 change
|
|
485
|
+
// 目录选成 activeChange,进而污染后续命令的 change 归属与轮次派生。
|
|
486
|
+
if (!isSingleSegmentChangeName(changeName)) {
|
|
487
|
+
throw new Error('select change 名必须是 .specs/ 下的单段目录名(拒绝路径分隔符、. / .. 与保留目录 archive): '
|
|
488
|
+
+ JSON.stringify(changeName));
|
|
489
|
+
}
|
|
490
|
+
const changeDir = path.join(specsDir(), changeName);
|
|
491
|
+
// 目录必须真实存在且不是 symlink/junction、realpath 归一后仍在 .specs/ 内(复用路径段扫描
|
|
492
|
+
// 单一权威);越界 / 链接形态一律拒绝,不把非真实目录选为 activeChange。
|
|
493
|
+
let inspection;
|
|
494
|
+
try {
|
|
495
|
+
inspection = await inspectWorkflowPathSegments(specsDir(), changeDir, 'select change dir', 'directory');
|
|
496
|
+
} catch (error) {
|
|
497
|
+
throw new Error('Change not found or path unsafe: ' + changeDir + '(' + (error && error.message ? error.message : error) + ')');
|
|
498
|
+
}
|
|
499
|
+
if (!inspection.exists) throw new Error('Change not found: ' + changeDir);
|
|
500
|
+
// 名字必须与 .specs/ 下真实目录条目逐字相等:大小写/空白变体(如 .specs/ch 用 'CH' 选中)
|
|
501
|
+
// 在大小写不敏感文件系统上同样可达,但会把 activeChange 存成变体字符串——轮次事件按
|
|
502
|
+
// activeChange 精确匹配(配额被换键重置)。名字变体一律拒绝,不得改写 activeChange。
|
|
503
|
+
if (!(await hasExactSpecsEntry(changeName))) {
|
|
504
|
+
throw new Error('select change 名必须与 .specs/ 下真实目录名逐字相等(大小写/空白变体会使 activeChange 与实际目录不一致): '
|
|
505
|
+
+ JSON.stringify(changeName));
|
|
506
|
+
}
|
|
507
|
+
const state = await readState();
|
|
508
|
+
state.activeChange = changeName;
|
|
509
|
+
if (!state.currentNode) state.currentNode = await determineNode(changeName, protocol, state.completedNodes);
|
|
510
|
+
await writeState(state);
|
|
511
|
+
console.log('Selected: ' + changeName);
|
|
512
|
+
return;
|
|
513
|
+
}
|
|
514
|
+
|
|
515
|
+
// record <node> <payload>:写证据(技能加载声明标记校验 + 前置门 + 旧 change 自动补写)
|
|
516
|
+
export async function runRecord(protocol, argv) {
|
|
517
|
+
const nodeId = argv[3];
|
|
518
|
+
if (!nodeId) throw new Error('record requires a Node id.');
|
|
519
|
+
const state = await readState();
|
|
520
|
+
state.evidence = state.evidence || {};
|
|
521
|
+
// 解析 JSON 参数并展开到 evidence 顶层(summary/completedChecks/output-schema evidence 等);
|
|
522
|
+
// 若不可解析则作为 summary 字符串
|
|
523
|
+
// payload 解析前剥离 --protocol(及 --protocol=<p>)——resolveProtocol 已全局提取协议路径,
|
|
524
|
+
// 此处仅防其拼入 payload 导致 JSON 解析失败(结构字段丢失)
|
|
525
|
+
// --json-file <path>(或 --json-file=<path>):从文件读 JSON payload——规避 Windows
|
|
526
|
+
// PowerShell 传参剥离内嵌双引号导致 JSON 损坏(record 存成 {summary:...} 脏数据)
|
|
527
|
+
let parsed = {};
|
|
528
|
+
let jsonFile = null;
|
|
529
|
+
const payloadArgs = [];
|
|
530
|
+
const recordArgs = argv.slice(4);
|
|
531
|
+
for (let i = 0; i < recordArgs.length; i++) {
|
|
532
|
+
const arg = recordArgs[i];
|
|
533
|
+
if (arg === '--protocol') { i += 1; continue; }
|
|
534
|
+
if (typeof arg === 'string' && arg.startsWith('--protocol=')) continue;
|
|
535
|
+
if (arg === '--json-file') {
|
|
536
|
+
jsonFile = recordArgs[i + 1];
|
|
537
|
+
i += 1;
|
|
538
|
+
continue;
|
|
539
|
+
}
|
|
540
|
+
if (typeof arg === 'string' && arg.startsWith('--json-file=')) {
|
|
541
|
+
jsonFile = arg.slice('--json-file='.length);
|
|
542
|
+
continue;
|
|
543
|
+
}
|
|
544
|
+
payloadArgs.push(arg);
|
|
545
|
+
}
|
|
546
|
+
const raw = jsonFile !== null
|
|
547
|
+
? await fs.readFile(await resolveJsonFileWithinRunRoot(jsonFile), 'utf8')
|
|
548
|
+
: payloadArgs.join(' ');
|
|
549
|
+
// 契约解析失败判定(单一来源):looksLikeObjectLiteral 由 state-schema.mjs 导出——
|
|
550
|
+
// trim 后以 {/[ 开头 → 视作"形似对象字面量";若 JSON.parse 失败 → fail-closed。
|
|
551
|
+
try {
|
|
552
|
+
parsed = raw ? JSON.parse(raw) : {};
|
|
553
|
+
if (typeof parsed !== 'object' || Array.isArray(parsed)) parsed = { summary: String(parsed) };
|
|
554
|
+
} catch {
|
|
555
|
+
// 契约解析失败 fail-closed:payload 形似对象但 JSON.parse 失败 → 报错并
|
|
556
|
+
// process.exit(1),不写 evidence——防状态污染(旧语义把不可解析 raw 静默作
|
|
557
|
+
// summary 字符串落库 = 静默落脏)
|
|
558
|
+
// 消息按参数来源分级:--json-file 传入且文件内容损坏 →
|
|
559
|
+
// "文件内容不是合法 JSON" + 长度元数据;内联传参损坏 → 保留 --json-file 建议。
|
|
560
|
+
// 安全:错误消息只含固定前缀 + 长度元数据,绝不打印 raw 内容(含截断)。
|
|
561
|
+
if (looksLikeObjectLiteral(raw)) {
|
|
562
|
+
if (jsonFile !== null) {
|
|
563
|
+
console.error('文件内容不是合法 JSON (length=' + String(raw ?? '').length + ')');
|
|
564
|
+
} else {
|
|
565
|
+
console.error('payload looks like an object literal but is not valid JSON (length=' + String(raw ?? '').length + '); use --json-file <path> to pass the payload');
|
|
566
|
+
}
|
|
567
|
+
process.exit(1);
|
|
568
|
+
}
|
|
569
|
+
parsed = { summary: raw || 'recorded' };
|
|
570
|
+
}
|
|
571
|
+
// completedChecks 真实性校验(skill-load 声明标记)——解析本次 record 写入的
|
|
572
|
+
// completedChecks 的 required-skill:<node>.<skill> 条目 → 对应声明标记必须存在,
|
|
573
|
+
// 缺失 → BLOCKED + 指引先加载 skill 并运行 skill-load;标记 at 必须 ≤ 本次记录时间
|
|
574
|
+
// (交叉自洽:标记先于记录声明)。仅校验本次写入的 payload,旧 evidence 不追溯(旧 change 兼容)。
|
|
575
|
+
const recordedAt = new Date().toISOString();
|
|
576
|
+
// 标记归属 change 与 evidence 一致:优先 state.activeChange,缺失时回退 findActiveChange(与
|
|
577
|
+
// 下方 NEXT 推导同语义);两者皆无 → verifySkillLoadMarkers 内 fail-closed BLOCK。
|
|
578
|
+
// 传入 protocol + state——按 requiredSkillCalls scope 分类条目(handoff scope 豁免标记,
|
|
579
|
+
// 以共用证据库 handoffResult 为证据)
|
|
580
|
+
const markerChange = state.activeChange || await findActiveChange();
|
|
581
|
+
const markerCheck = await verifySkillLoadMarkers(parsed.completedChecks, markerChange, recordedAt, protocol, state);
|
|
582
|
+
if (!markerCheck.ok) {
|
|
583
|
+
console.error('BLOCKED: ' + markerCheck.reason);
|
|
584
|
+
process.exit(1);
|
|
585
|
+
}
|
|
586
|
+
// 技能加载前置门(方案 A):节点完成记录必须先有本节点
|
|
587
|
+
// skill-load 声明标记——无论 payload 是否含 completedChecks 都校验(堵"先干活后补
|
|
588
|
+
// 声明"旁路):缺失 → 新 change BLOCK / 旧 change 渐进 WARN。指引先加载技能并运行
|
|
589
|
+
// skill-load 再重试。handoff scope 技能(子代理加载)不要求协调者声明(与
|
|
590
|
+
// verifySkillLoadMarkers 的 scope 豁免一致)——本门按 <node>-*.json 存在性判定,
|
|
591
|
+
// 与 guard exit 侧协议声明标记校验同构。仅对存在于当前协议的节点生效(协议外节点名
|
|
592
|
+
// 的记录不适用前置门),无 active change 时无法定位标记而不重复报错(遗留兼容)。
|
|
593
|
+
const recordNodeDef = (protocol.nodes ?? []).find((n) => n.id === nodeId);
|
|
594
|
+
if (recordNodeDef && markerChange) {
|
|
595
|
+
const declaredForNode = await hasNodeSkillDeclaration(nodeId, markerChange);
|
|
596
|
+
if (!declaredForNode) {
|
|
597
|
+
const loadGuide = '先加载技能(用 Skill 工具,禁止跳过)并运行 workflow-state.mjs skill-load ' + nodeId + ' <skill> 再重试';
|
|
598
|
+
if (state.newChange === true) {
|
|
599
|
+
console.error('BLOCKED: 节点 ' + nodeId + ' 缺少技能加载声明标记(.skill-loads/' + nodeId + '-*.json)——' + loadGuide);
|
|
600
|
+
process.exit(1);
|
|
601
|
+
}
|
|
602
|
+
console.error('WARN: 节点 ' + nodeId + ' 缺少技能加载声明标记(.skill-loads/' + nodeId + '-*.json)——' + loadGuide + '(旧 change 渐进不阻断,记录继续)');
|
|
603
|
+
}
|
|
604
|
+
}
|
|
605
|
+
// 声明自动化——record 时按协议 requiredSkillCalls 自动补写缺失的声明标记
|
|
606
|
+
// (执行者无需手动 skill-load;标记如实记录"节点完成即视为其实现/协议技能已加载",
|
|
607
|
+
// 由 record 代记;与手动 skill-load 标记同体系,exit 协议声明校验共用)
|
|
608
|
+
// 新 change 下 required 条目停用自动补写(手动声明唯一路径,否则抵消前置门);
|
|
609
|
+
// 旧 change 保留兜底(渐进兼容)。
|
|
610
|
+
if (recordNodeDef && markerChange && state.newChange !== true) {
|
|
611
|
+
const recordProtoFiles = NODE_PROTOCOL_FILES[nodeId] ?? [];
|
|
612
|
+
// 标记目录解析:活动路径优先;change 已归档(活动目录不存在但归档目录存在)
|
|
613
|
+
// 时写归档路径——防重建已归档的活动目录(归档移动语义;与 findSkillLoadsDir 双路径一致)。
|
|
614
|
+
// 跳过条件:活动与归档均无 .skill-loads **且活动 change 目录已不存在**(归档移动后)
|
|
615
|
+
// ——此时 writeJsonAtomic 的 mkdir recursive 会把已归档的活动目录残留回来;
|
|
616
|
+
// 活动 change 目录仍存在(正常流程)时创建 .skill-loads 子目录是自动补写的正常职责,不跳过
|
|
617
|
+
const activeLoadsDir = path.join(specsDir(), markerChange, '.skill-loads');
|
|
618
|
+
let targetLoadsDir = activeLoadsDir;
|
|
619
|
+
if (!(await fileExists(activeLoadsDir))) {
|
|
620
|
+
const archived = await findSkillLoadsDir(markerChange);
|
|
621
|
+
if (archived !== null && archived.dir !== activeLoadsDir) {
|
|
622
|
+
targetLoadsDir = archived.dir;
|
|
623
|
+
} else if (archived === null && !(await fileExists(path.join(specsDir(), markerChange)))) {
|
|
624
|
+
targetLoadsDir = null;
|
|
625
|
+
}
|
|
626
|
+
}
|
|
627
|
+
if (targetLoadsDir !== null) {
|
|
628
|
+
for (const binding of recordNodeDef.requiredSkillCalls ?? []) {
|
|
629
|
+
// handoff scope 技能由子代理加载(协调者不声明)——不自动补协调者标记
|
|
630
|
+
if (binding.scope === 'handoff') continue;
|
|
631
|
+
const markerFile = path.join(targetLoadsDir, nodeId + '-' + binding.skill + '.json');
|
|
632
|
+
let markerExists = false;
|
|
633
|
+
try { await fs.access(markerFile); markerExists = true; } catch { /* 标记不存在 */ }
|
|
634
|
+
if (!markerExists) {
|
|
635
|
+
// 自动补的 protocol 字段按 skill 归属协议文件(如 open 的 requirement 标记应写
|
|
636
|
+
// 1-requirement.md 而非节点首文件 0-change.md——所有 skill 都写首文件会让
|
|
637
|
+
// 标记的协议归属语义错误;exit 校验只查归属集合故能通过,但标记不可信)
|
|
638
|
+
const skillProtoFiles = SKILL_PROTOCOL_FILES[binding.skill] ?? [];
|
|
639
|
+
await writeJsonAtomic(markerFile, {
|
|
640
|
+
node: nodeId,
|
|
641
|
+
skill: binding.skill,
|
|
642
|
+
protocol: skillProtoFiles.length > 0 ? skillProtoFiles[0] : null,
|
|
643
|
+
at: recordedAt,
|
|
644
|
+
auto: true,
|
|
645
|
+
});
|
|
646
|
+
}
|
|
647
|
+
}
|
|
648
|
+
}
|
|
649
|
+
}
|
|
650
|
+
state.evidence[nodeId] = {
|
|
651
|
+
...(state.evidence[nodeId] || {}),
|
|
652
|
+
...parsed,
|
|
653
|
+
recordedAt,
|
|
654
|
+
};
|
|
655
|
+
await writeState(state);
|
|
656
|
+
console.log('EVIDENCE: ' + nodeId);
|
|
657
|
+
const changeName = state.activeChange || await findActiveChange();
|
|
658
|
+
const nextNode = changeName ? await determineNode(changeName, protocol, state.completedNodes) : null;
|
|
659
|
+
printNext(protocol, nextNode ?? null, state.executionMode ?? 'subagent');
|
|
660
|
+
return;
|
|
661
|
+
}
|
|
662
|
+
|
|
663
|
+
// advance:强制推进(append-only 审计事件 + 跳过出口门禁的可见性)
|
|
664
|
+
export async function runAdvance(protocol) {
|
|
665
|
+
const state = await readState();
|
|
666
|
+
if (!state.activeChange) {
|
|
667
|
+
console.log('No active change. Use select first.');
|
|
668
|
+
return;
|
|
669
|
+
}
|
|
670
|
+
// 被强制推进的节点 = 推进前的 currentNode:exit 门禁未跑(无出口证据),这正是留痕与
|
|
671
|
+
// 可见性的依据(ADR-013 决策 10/11)。advance 的推进语义保持不变,但每次使用都必须写
|
|
672
|
+
// 审计事件并在输出显式列出被跳过的出口门禁。
|
|
673
|
+
const forcedNode = state.currentNode;
|
|
674
|
+
const forcedNodeId = typeof forcedNode === 'string' && forcedNode !== '' ? forcedNode : null;
|
|
675
|
+
if (!state.completedNodes.includes(state.currentNode)) {
|
|
676
|
+
state.completedNodes.push(state.currentNode);
|
|
677
|
+
}
|
|
678
|
+
// Use determineNode to get the actual next node (reads TASK.md)
|
|
679
|
+
const detected = await determineNode(state.activeChange, protocol, state.completedNodes);
|
|
680
|
+
state.currentNode = detected;
|
|
681
|
+
if (forcedNodeId !== null) {
|
|
682
|
+
// append-only 审计事件:change 供跨 change 检索,skipped 标识被跳过的出口门禁
|
|
683
|
+
// (exit:<node>),reason 固定 'advance'(本 CLI 无其它原因面)。
|
|
684
|
+
const existingHistory = Array.isArray(state.history) ? state.history : [];
|
|
685
|
+
state.history = existingHistory.concat([{
|
|
686
|
+
event: 'advance-forced',
|
|
687
|
+
change: state.activeChange,
|
|
688
|
+
node: forcedNode,
|
|
689
|
+
skipped: ['exit:' + forcedNode],
|
|
690
|
+
reason: 'advance',
|
|
691
|
+
at: new Date().toISOString(),
|
|
692
|
+
}]);
|
|
693
|
+
}
|
|
694
|
+
await writeState(state);
|
|
695
|
+
console.log('Advanced to: ' + state.currentNode);
|
|
696
|
+
if (forcedNodeId !== null) {
|
|
697
|
+
console.log('ADVANCE-AUDIT: 跳过 ' + forcedNodeId + ' 的 exit 门禁;该节点无出口证据');
|
|
698
|
+
}
|
|
699
|
+
return;
|
|
700
|
+
}
|