feat: execute two owned workers in isolated Git workspaces with frozen scopes

This commit is contained in:
Agent Workbench Dev
2026-10-31 01:05:32 +08:00
parent 15ad5aa652
commit 1a847c1577
22 changed files with 975 additions and 30 deletions
+13
View File
@@ -0,0 +1,13 @@
# 1.13 开发与验收记录
2026-10-31。本阶段尚未发行,正式服务仍保持不可变1.12.1。这里记录切片结果,不将局部测试或夹具成功计为真实模型交付。
## 切片一:父子记录与受限执行
已实现稳定父协作与两个预分配子Task身份、串行真实Git工作区、原源码/契约工件、同宿主Provider受限启动、范围内提案和应用、累计预算、真实检查完成门槛与原成果封存。父子记录采用稳定控制Run与单独当前Run,续接不能改变SQLite归属或重置Task预算;原会话没有新增空导出字段。
核心6/6、已有文件批次/检查/工作区32/32通过;构建通过。两项确认问题为worker行迁移runId导致控制保存失败,以及把变更集completed误读为applied;已修复并实际复验。最初夹具按plan_id读取检查计划也已按真实id纠正,原失败保留。
原TAP见worker-core-first、worker-core-diagnosis、worker-core-ownership-fix、worker-core-output-diagnosis、worker-core-final、worker-core-regression;前四份是原失败/诊断,不能登记为最终通过。核心使用自有声明模型夹具,真实执行Git、文件审查应用和npm检查,真实模型请求为0。
待完成:父成果/冲突/合并审查、停止与崩溃专项、HTTP与控制台实际验收、三个本地工程样本、完整独立源码/便携与保留正式状态发行。
+51
View File
@@ -0,0 +1,51 @@
✖ real isolated changes, approvals and npm checks produce original owned outputs, not model completion claims (11294.7189ms)
✖ a completion-only model pauses each worker without fabricated changes or checks (9093.3029ms)
ℹ tests 2
ℹ suites 0
ℹ pass 0
ℹ fail 2
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 20508.9926
✖ failing tests:
test at tests\workers.test.mjs:45:1
✖ real isolated changes, approvals and npm checks produce original owned outputs, not model completion claims (11294.7189ms)
AssertionError [ERR_ASSERTION]: [{"status":"failed","summary":"持久执行记录不能移动到其他任务或项目。","failure":null},{"status":"failed","summary":"持久执行记录不能移动到其他任务或项目。","failure":null}]
+ actual - expected
+ 'paused'
- 'ready_to_collect'
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/tests/workers.test.mjs:47:10)
at async Test.run (node:internal/test_runner/test:1409:7)
at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
generatedMessage: false,
code: 'ERR_ASSERTION',
actual: 'paused',
expected: 'ready_to_collect',
operator: 'strictEqual',
diff: 'simple'
}
test at tests\workers.test.mjs:75:1
✖ a completion-only model pauses each worker without fabricated changes or checks (9093.3029ms)
AssertionError [ERR_ASSERTION]: "持久执行记录不能移动到其他任务或项目。"
+ actual - expected
+ null
- 'worker_incomplete'
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/tests/workers.test.mjs:80:110)
at process.processTicksAndRejections (node:internal/process/task_queues:104:5)
at async Test.run (node:internal/test_runner/test:1409:7)
at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
generatedMessage: false,
code: 'ERR_ASSERTION',
actual: null,
expected: 'worker_incomplete',
operator: 'strictEqual',
diff: 'simple'
}
+14
View File
@@ -0,0 +1,14 @@
✔ worker scopes and allocated budgets reject aliases, extra permissions and aggregate overflow (587.18ms)
✔ two sequential Git workspaces freeze a new parent goal, separate owned tasks and preserve all source bytes (8633.5423ms)
✔ real isolated changes, approvals and npm checks produce original owned outputs, not model completion claims (19461.1322ms)
✔ forged worker tools cannot execute terminal or Git even when absent from the advertised tool list (8691.5541ms)
✔ a completion-only model pauses each worker without fabricated changes or checks (10455.2706ms)
✔ restart retains frozen scope and marks interrupted parent and workers unknown without sending requests (8392.3437ms)
ℹ tests 6
ℹ suites 0
ℹ pass 6
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 56336.5639
+55
View File
@@ -0,0 +1,55 @@
✔ worker scopes and allocated budgets reject aliases, extra permissions and aggregate overflow (637.895ms)
✔ two sequential Git workspaces freeze a new parent goal, separate owned tasks and preserve all source bytes (8247.1926ms)
✖ real isolated changes, approvals and npm checks produce original owned outputs, not model completion claims (11356.0679ms)
✔ forged worker tools cannot execute terminal or Git even when absent from the advertised tool list (8663.1033ms)
✖ a completion-only model pauses each worker without fabricated changes or checks (8897.8571ms)
✔ restart retains frozen scope and marks interrupted parent and workers unknown without sending requests (8453.4236ms)
ℹ tests 6
ℹ suites 0
ℹ pass 4
ℹ fail 2
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 46372.7737
✖ failing tests:
test at tests\workers.test.mjs:45:1
✖ real isolated changes, approvals and npm checks produce original owned outputs, not model completion claims (11356.0679ms)
AssertionError [ERR_ASSERTION]: 子任务已停止或需要处理,已完成结果保留。
+ actual - expected
+ 'paused'
- 'ready_to_collect'
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/tests/workers.test.mjs:47:10)
at async Test.run (node:internal/test_runner/test:1409:7)
at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
generatedMessage: false,
code: 'ERR_ASSERTION',
actual: 'paused',
expected: 'ready_to_collect',
operator: 'strictEqual',
diff: 'simple'
}
test at tests\workers.test.mjs:75:1
✖ a completion-only model pauses each worker without fabricated changes or checks (8897.8571ms)
AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
+ actual - expected
+ null
- 'worker_incomplete'
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/tests/workers.test.mjs:80:110)
at process.processTicksAndRejections (node:internal/process/task_queues:104:5)
at async Test.run (node:internal/test_runner/test:1409:7)
at async Test.processPendingSubtests (node:internal/test_runner/test:974:7) {
generatedMessage: true,
code: 'ERR_ASSERTION',
actual: null,
expected: 'worker_incomplete',
operator: 'strictEqual',
diff: 'simple'
}
+30
View File
@@ -0,0 +1,30 @@
✖ real isolated changes, approvals and npm checks produce original owned outputs, not model completion claims (17786.5763ms)
ℹ tests 1
ℹ suites 0
ℹ pass 0
ℹ fail 1
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 17901.7218
✖ failing tests:
test at tests\workers.test.mjs:45:1
✖ real isolated changes, approvals and npm checks produce original owned outputs, not model completion claims (17786.5763ms)
AssertionError [ERR_ASSERTION]: [{"status":"paused","summary":"原子任务已保存,等待审查或继续。","failure":null,"reason":"worker_incomplete","messages":["从已保存的执行记录继续,已完成的工具结果保留。","夹具声称完成,宿主仍需核验","子任务还不能交付:子成果中的批次没有完整应用结果:src/a.mjs。原目标和结果已保存。"]},{"status":"paused","summary":"原子任务已保存,等待审查或继续。","failure":null,"reason":"worker_incomplete","messages":["从已保存的执行记录继续,已完成的工具结果保留。","夹具声称完成,宿主仍需核验","子任务还不能交付:子成果中的批次没有完整应用结果:src/b.mjs。原目标和结果已保存。"]}]
+ actual - expected
+ 'paused'
- 'ready_to_collect'
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/tests/workers.test.mjs:47:10)
at async Test.run (node:internal/test_runner/test:1409:7)
at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
generatedMessage: false,
code: 'ERR_ASSERTION',
actual: 'paused',
expected: 'ready_to_collect',
operator: 'strictEqual',
diff: 'simple'
}
+31
View File
@@ -0,0 +1,31 @@
✖ real isolated changes, approvals and npm checks produce original owned outputs, not model completion claims (17354.4449ms)
✔ a completion-only model pauses each worker without fabricated changes or checks (10289.3832ms)
ℹ tests 2
ℹ suites 0
ℹ pass 1
ℹ fail 1
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 27758.5238
✖ failing tests:
test at tests\workers.test.mjs:45:1
✖ real isolated changes, approvals and npm checks produce original owned outputs, not model completion claims (17354.4449ms)
AssertionError [ERR_ASSERTION]: [{"status":"paused","summary":"原子任务已保存,等待审查或继续。","failure":null},{"status":"paused","summary":"原子任务已保存,等待审查或继续。","failure":null}]
+ actual - expected
+ 'paused'
- 'ready_to_collect'
at TestContext.<anonymous> (file:///D:/Ai-project/REA%E9%80%86%E5%90%91/Agent-Workbench/tests/workers.test.mjs:47:10)
at async Test.run (node:internal/test_runner/test:1409:7)
at async startSubtestAfterBootstrap (node:internal/test_runner/harness:387:3) {
generatedMessage: false,
code: 'ERR_ASSERTION',
actual: 'paused',
expected: 'ready_to_collect',
operator: 'strictEqual',
diff: 'simple'
}
+43
View File
@@ -0,0 +1,43 @@
warning: in the working copy of 'README.md', LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of 'src/two.mjs', LF will be replaced by CRLF the next time Git touches it
✔ sealed batches preserve bytes until review, then apply and explicitly restore BOM/CRLF/new files (2328.8361ms)
Switched to a new branch 'owner-branch'
✔ a conflict in the last file or Git branch prevents writing every file in the batch (2849.7417ms)
✔ duplicate canonical paths, ancestor collisions, links, dependencies and Windows aliases never form a batch (958.2824ms)
✔ fingerprints, changed proposals and corrupt snapshot artifacts cannot write or restore any target (2246.286ms)
✔ a failure after replacement restores only batch bytes and never retries an old application (1887.1675ms)
✔ rollback preserves owner edits, blocks other project writers, and explicit acknowledgement releases recovery (1717.7744ms)
✔ an unattempted owner-created file identical to a suggestion remains external and is never removed (1508.44ms)
✔ active batch requests are serialized and cancellation leaves a verifiable ended batch (1707.1052ms)
✔ batch application and rollback preserve unrelated Git index and worktree bytes (3473.6038ms)
✔ recovery reuses exact staged bytes but retains a conflicting temporary file for owner inspection (2697.1792ms)
✔ one Task can seal pending proposals from earlier Runs while snapshots retain each source Run (2091.2088ms)
✔ engineering inspection preserves a dirty Git baseline and treats project rules as data (2263.3827ms)
✔ real npm tests and build produce counted results, log artifacts and persistent verification (2604.4731ms)
✔ an actual failing test retains the nonzero exit code and failed count (2134.3808ms)
✔ zero tests, skipped tests and unrecognized stdout cannot become verification passes (7110.2094ms)
✔ a successful build with no selected tests does not verify the task (1903.2808ms)
✔ stale check plans and forged script names execute no project commands (1191.0967ms)
✔ applying a later proposal invalidates the prior passed engineering snapshot (2558.1788ms)
✔ stopping an actual check terminates its child process and blocks concurrent jobs (2195.3353ms)
✔ check timeout records a failure with its actual termination result (2310.8461ms)
✔ source edits during a successful check make the result stale (2999.3104ms)
✔ bounded large logs retain the test footer and readable artifact instead of inventing counts (1569.0375ms)
✔ model-selected checks require a run-bound decision and denial creates no check job (2567.6394ms)
✔ check APIs expose owned plans and jobs and preserve the authoritative results across restart (3716.4954ms)
✔ reviewed changes continue the original task without reopening a generic completed run (2246.0716ms)
✔ concurrent review-continuation API requests accept one run and retain the goal after restart (4478.3583ms)
✔ the model reads owned failure logs without running the check again (2665.5831ms)
✔ process exit at check queued preserves results and never replays commands (1334.1134ms)
✔ process exit at check result_committed preserves results and never replays commands (1732.2751ms)
✔ managed worktree preserves source index and dirty files, opens a distinct project and binds Run identity (4827.2507ms)
✔ stale review, branch/path collisions and forged ownership do not run worktree creation (3383.8726ms)
✔ workspace project verification is read-only and rejects physical Git identity changes (4400.677ms)
ℹ tests 32
ℹ suites 0
ℹ pass 32
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 47703.7776
+8
View File
@@ -7,6 +7,14 @@
- beginRun对failed/paused旧Task会复用;父协作必须创建明确的新Task,稳定冻结父子身份、写入范围、模型快照和总预算。子运行完成需实际应用修改及当前检查,文字回复不代替成果。
- 新记录导出仅在存在时追加字段,保持旧会话完整导出格式;新增Manager纳入全部活动、停止、配置和升级门控。成果须由父Task重新生成提案及变更集,不复用子变更ID。
- 前次rg将Windows通配符作为字面路径导致error123,改为目录加-g;本次误从父目录读取AGENTS失败,已在Agent-Workbench根读取。过宽历史记录输出截断,后续窄段读取,不当作完整证据。
- Store.save失败会从SQLite恢复全部核心Map并原地恢复已有对象,可复用父/子记录事务回退;多会话建立需分别写入意图后核对,不能假定一次多对象更新原子。新Task应显式创建后进入控制运行,避免旧failed任务追加目标。
- Runtime目录与executeTool分别限制子工具;检查审批已有所属Task/Run及源码计划,父stop需要等待两个子运行/检查结束。模型迟到响应当前在signal核对后才入账,子预算与未知请求需另行核实,避免未报告用量被遗忘。
- Workspace.prepare/start和register已有持久意图及独立子Project/Session预分配身份;复用创建器时锁仅排除同协作父会话的受控内部调用,不能排除其他项目活动。第二次工作区快照需容纳第一次已登记分支,但不能忽略来源文件或索引变化。
- ChangeSet.prepare/start可复用32文件/4MB原字节封存、逐文件写入/恢复与失败核对;Worker范围契约须放入该入口和proposeFile/applyChange,阻断HTTP绕过。一次查询错误写成src/server/server.mjs,实际入口为app.mjs/index.mjs,已更正。
- 已新增collaboration/worker持久种类、预分配身份、父控制Task、子原始源码与契约工件、同Provider受限启动、范围校验与串行worktree创建。实际采用同宿主两个子运行和所属检查子进程,凭据不跨进程复制。
- WorkerManager使用私有创建器和显式父操作排除,普通Workspace/Check/Git操作仍应纳入协作活动,不能扩大排除范围。源码没有shared/contracts/checks.mjs,原检查核验为core/delivery-report.mjs的verifiedCheck;已按实际函数复用。
- 一次Runtime补丁使用了不存在的换行锚点导致整体拒绝,核对无局部写入后按实际单行函数重新应用。核心尚未验收,不登记为可交付。
- 首轮专项实际暴露worker行更新runId违反SQLite不可迁移归属契约,导致子运行启动后控制记录保存失败;已改为稳定控制runId和单独currentRunId,保持旧归属。保存/启动失败会先停止并等待已创建子运行;父调度不能忽略Promise拒绝或把仍running记录当paused。原失败与诊断TAP单独保留。
## 2026-10-30 项目所属stdio MCP接续
+3
View File
@@ -6,6 +6,9 @@
- 继续使用planning-with-files并沿用已读frontend-design方向;按核心契约、受限执行、成果审查、控制台与独立发行切片推进,每个切片回顾及小步本地提交。
- 本阶段不主动委派助手子代理,不读取真实连接凭据、不发真实模型请求。独立本地模型夹具与实际Git/文件/检查/页面分别验收。
- 读取路径和过宽查询错误已保存findings;下一步窄范围核对Store恢复/事务、Runtime执行、Workspace登记、当前检查证据与HTTP/UI接口,再落实产品代码。
- 父子核心与受限目录已写入;首轮6项专项4通过/2失败,原TAP保存.qa/workers-core-first.tap。工作区来源/预算范围/工具拒绝/恢复通过;实际成果和纯文字完成用例仍失败,正核对原子任务错误,不登记完成。夹具plan_checks误按plan_id读取已修正为实际所属计划id,诊断复验另存,不覆盖原失败。
- 切片一最终核心6/6和已有文件批次/检查/工作区32/32通过,独立新控制台草稿构建通过;原失败原因已核对为稳定Run归属及completed状态判断并修复。原TAP复制封存docs,不覆盖失败。HTTP/界面仍为待验草稿,父合并与停止恢复继续推进,正式1.12.1未升级。
- 一次PLAN-1.13修改使用了段落中的短句锚点导致拒绝,无写入;后续按完整段落更新。回归命令中core.test.mjs不存在,Node24按匹配的另外三文件执行32项,统计明确只对应文件批次/检查/工作区,不声称核心旧全量已验。
## 2026-10-30 里程碑审查与1.12.1候选
+3
View File
@@ -9,6 +9,7 @@ import { assertChangeSetsResolved } from '../shared/contracts/change-sets.mjs';
import { assertWorkspacesResolved } from '../shared/contracts/workspaces.mjs';
import { verifyWorkspaceProject } from './workspaces/git-workspaces.mjs';
import { assertMcpResolved } from './tools/mcp-contract.mjs';
import { assertWorkersResolved } from '../shared/contracts/workers.mjs';
import { bindPythonChecks, preparePythonInvocation, pythonEnvironment, readPythonEvidence, pythonResultBinding } from './python-runtime.mjs';
import { projectEnvironment } from './process-environment.mjs';
@@ -63,6 +64,7 @@ export class CheckRunner {
projectActive(projectId) { return this.projects.has(projectId); }
async plan(session, names) {
assertWorkersResolved(this.store, session.projectId);
assertChangeSetsResolved(this.store, session.projectId);
assertWorkspacesResolved(this.store, session.projectId, { includePrepared: true });
await verifyWorkspaceProject(this.store, this.store.project(session.projectId));
@@ -102,6 +104,7 @@ export class CheckRunner {
}
async start(session, planId, { signal, source = 'user' } = {}) {
assertWorkersResolved(this.store, session.projectId);
assertMcpResolved(this.store, session.projectId);
assertChangeSetsResolved(this.store, session.projectId, { includePrepared: true });
assertWorkspacesResolved(this.store, session.projectId, { includePrepared: true });
+3
View File
@@ -15,6 +15,7 @@ import { currentBrowserVerification } from './browser/browser-manager.mjs';
import { assertBrowserResolved } from '../shared/contracts/browser.mjs';
import { TaskPlanManager } from './tasks/task-plan-manager.mjs';
import { assertMcpResolved } from './tools/mcp-contract.mjs';
import { assertWorkersResolved, workerForProject } from '../shared/contracts/workers.mjs';
const at = () => new Date().toISOString();
const sha = value => createHash('sha256').update(value).digest('hex');
@@ -202,6 +203,8 @@ export class GitDelivery {
}
async plan(session, options = {}, { source = 'user' } = {}) {
assertWorkersResolved(this.store, session.projectId);
if (workerForProject(this.store, session.projectId)) throw conflict('受限子任务不能独立Git提交;请在父任务审查合并后交付。');
const idleOptions = { exceptSessionId: source === 'agent' ? session.id : null };
this.assertIdle(session, idleOptions); const { task, run } = this.assertTask(session);
const identity = { taskId: task.id, runId: run.id }, project = this.store.project(session.projectId);
+335
View File
@@ -0,0 +1,335 @@
import fs from 'node:fs';
import { randomUUID } from 'node:crypto';
import { createTask, createRun, modelSnapshot, accountedTokens, BudgetExceeded } from '../../shared/contracts/execution.mjs';
import { COLLABORATION_ACTIVE, COLLABORATION_CLOSED, collaborationInput, collaborationSeal, workerSeal, workerHash,
workerConflict, workerForProject, workerForSession, workerPath, pathInWorkerScope, workerPathKey, workerUsage, assertWorkersResolved } from '../../shared/contracts/workers.mjs';
import { WorkspaceManager, verifyWorkspaceProject } from '../workspaces/git-workspaces.mjs';
import { projectWorkspaceIdentity } from '../../shared/contracts/workspaces.mjs';
import { assertChangeSetsResolved } from '../../shared/contracts/change-sets.mjs';
import { assertMcpResolved } from '../tools/mcp-contract.mjs';
import { inspectProject } from '../project-inspector.mjs';
import { safePath, readText, proposeFile } from '../../server/files.mjs';
import { verifiedCheck } from '../delivery-report.mjs';
const at = () => new Date().toISOString();
const sourceIdentity = source => Object.fromEntries(['root', 'head', 'reference', 'branch', 'gitDir', 'commonDir', 'indexSha256',
'statusSha256', 'sourceFingerprint', 'treeSha256', 'configuration', 'filterDrivers'].map(key => [key, source[key]]));
const configView = config => Object.fromEntries(['mode', 'baseUrl', 'model', 'contextLimit', 'maxOutputTokens', 'configRevision',
'maxSteps', 'maxRunDurationMs', 'maxRunTokens', 'maxTaskTokens', ...(config.modelRouting ? ['modelRouting'] : [])].map(key => [key, structuredClone(config[key])]));
const alive = pid => { if (!pid) return false; try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; } };
export class WorkerManager {
constructor(store, runtime, { faultInjector = null } = {}) {
this.store = store; this.runtime = runtime; this.faultInjector = faultInjector;
this.active = new Map(); this.preparingGroupId = null;
this.workspaces = new WorkspaceManager(store, { projectBusy: projectId => runtime.projectHasActivity(projectId, null, { excludeGroupId: this.preparingGroupId }) });
}
groups(session) { return [...this.store.core.collaboration.values()].filter(group => group.sessionId === session.id); }
view(session) {
return { groups: this.groups(session).map(group => ({ ...group, workers: group.children.map(child => {
const record = this.store.core.worker.get(child.id);
return record ? { ...record, usage: workerUsage(this.store, record), sessionStatus: this.store.session(record.sessionId).status } : { ...child, status: 'unprepared', usage: null };
}) })), worker: workerForProject(this.store, session.projectId) };
}
isActive(sessionId) { return [...this.active.values()].some(value => value.sessionId === sessionId); }
projectActive(projectId, excludeGroupId = null) {
return [...this.active.entries()].some(([id, value]) => id !== excludeGroupId && (value.projectId === projectId
|| ['preparing', 'collecting', 'reconciling', 'merge_preparing'].includes(value.group.status) && value.group.children.some(child => child.projectId === projectId)));
}
assertIdle(session) {
if (this.runtime.projectHasActivity(session.projectId)) throw workerConflict('项目已有执行或协作操作,请等待结束。');
assertWorkersResolved(this.store, session.projectId); assertMcpResolved(this.store, session.projectId);
assertChangeSetsResolved(this.store, session.projectId, { includePrepared: true });
if (session.changes.some(change => ['pending', 'conflict'].includes(change.status))) throw workerConflict('请先审查当前待处理改动,再创建协作目标。');
}
own(session, id, fingerprint = null) {
const group = this.store.owned('collaboration', id, session.id);
if (group.taskId !== session.taskId || group.runId !== session.runId || group.projectId !== session.projectId
|| workerHash(collaborationSeal(group)) !== group.fingerprint || fingerprint !== null && fingerprint !== group.fingerprint) throw workerConflict('父任务或原协作分工指纹已变化,请核对原记录。');
const artifact = this.store.owned('artifact', group.planArtifactId, session.id);
if (artifact.kind !== 'collaboration-plan' || artifact.taskId !== group.taskId || artifact.runId !== group.runId
|| artifact.sha256 !== group.planSha256 || this.store.artifactStore.read(artifact) !== JSON.stringify(collaborationSeal(group))) throw workerConflict('协作计划与原封存工件不一致。');
return group;
}
save(session, group, phase) {
group.updatedAt = at(); group.phase = phase;
group.usage = group.children.reduce((total, child) => {
const worker = this.store.core.worker.get(child.id), usage = worker ? workerUsage(this.store, worker) : {};
for (const key of ['accountedTokens', 'steps', 'toolCalls', 'requests', 'unknownRequests', 'estimatedUnknownTokens', 'totalTokens']) total[key] = (total[key] ?? 0) + (usage[key] ?? 0);
return total;
}, {});
return this.store.putRecord('collaboration', session, group, 'collaboration.' + phase);
}
async sourceFor(group) {
const source = await this.workspaces.snapshot(this.store.project(group.projectId));
if (JSON.stringify(sourceIdentity(source)) !== JSON.stringify(group.source.identity)) throw workerConflict('来源HEAD、索引、配置或已有修改已变化;原工作区保留,请重新审查协作来源。');
return source;
}
async plan(session, input) {
this.assertIdle(session);
if (workerForProject(this.store, session.projectId)) throw workerConflict('受限子任务不能创建嵌套协作。');
if (this.groups(session).some(group => !COLLABORATION_CLOSED.has(group.status))
|| [...this.store.core.collaboration.values()].some(group => group.projectId === session.projectId && !COLLABORATION_CLOSED.has(group.status))) throw workerConflict('项目已有未收尾的父协作,请先完成或明确保留原成果。');
const initial = structuredClone(this.store.config), config = this.runtime.provider.prepareConfig ? this.runtime.provider.prepareConfig(initial, this.store) : initial;
const definition = collaborationInput(input, config), project = this.store.project(session.projectId);
const temporaryId = randomUUID(), controller = new AbortController(), active = { sessionId: session.id, projectId: project.id, group: { children: [], status: 'planning' }, controller };
active.promise = new Promise(resolve => { active.settle = resolve; });
this.active.set(temporaryId, active);
try {
this.preparingGroupId = temporaryId;
const source = await this.workspaces.snapshot(project);
controller.signal.throwIfAborted();
if (source.changedPathCount > 32) throw workerConflict('来源已有修改超过32个路径,请先缩小范围;不会遗漏原修改后合并。');
for (const child of definition.children) for (const relative of child.paths) safePath(project, relative, true);
const run = this.store.beginRun(session, definition.goal, false, config, { forceNewTask: true });
session.status = 'paused'; this.store.finishRun(session, run, 'worker_control');
const group = { schemaVersion: 1, id: randomUUID(), projectId: project.id, sessionId: session.id, taskId: session.taskId, runId: run.id,
goal: definition.goal, budget: definition.budget, model: modelSnapshot(config), config: configView(config),
source: { identity: sourceIdentity(source), changedPaths: source.changedPaths, dirty: source.dirty, scope: source.scope },
children: definition.children.map(child => ({ ...child, id: randomUUID(), workspaceId: randomUUID(), projectId: randomUUID(), sessionId: randomUUID(), taskId: randomUUID() })),
status: 'planned', requiresVerification: false, createdAt: at(), updatedAt: at(), startedAt: null, deadline: null, finishedAt: null,
summary: '父子目标、范围、模型和预算已封存,尚未创建工作区或请求模型。', collection: null, merge: null };
group.fingerprint = workerHash(collaborationSeal(group));
const artifact = this.store.artifactStore.write(session, run, collaborationSeal(group), { kind: 'collaboration-plan' });
this.store.core.artifact.set(artifact.id, artifact); group.planArtifactId = artifact.id; group.planSha256 = artifact.sha256;
const task = this.store.core.task.get(group.taskId); task.origin = 'worker-coordination'; task.budget.maxTokens = group.budget.maxTokens;
task.collaborationId = group.id;
this.store.message(session, 'user', group.goal);
this.save(session, group, 'planned'); return group;
} finally { this.preparingGroupId = null; this.active.delete(temporaryId); active.settle(); }
}
launch(session, group, status, execute) {
if (this.active.has(group.id) || this.runtime.projectHasActivity(group.projectId)) throw workerConflict('协作操作正在执行,不能重复启动。');
const controller = new AbortController(), active = { sessionId: session.id, projectId: group.projectId, group, controller, promise: null };
group.status = status; this.active.set(group.id, active);
try {
this.save(session, group, status);
active.promise = execute(controller.signal).finally(() => { this.active.delete(group.id); if (this.preparingGroupId === group.id) this.preparingGroupId = null; });
active.promise.catch(() => {}); return { group, promise: active.promise };
} catch (error) { this.active.delete(group.id); throw error; }
}
prepare(session, id, fingerprint) {
const group = this.own(session, id, fingerprint);
if (!['planned', 'partially_prepared'].includes(group.status) || group.requiresVerification) throw workerConflict('工作区已创建、正在执行或待核对,不能重放创建。');
return this.launch(session, group, 'preparing', async signal => {
this.preparingGroupId = group.id;
try {
await this.sourceFor(group);
for (const child of group.children) {
signal.throwIfAborted();
const existing = this.store.core.workspace.get(child.workspaceId);
if (existing && existing.status !== 'ready') throw workerConflict('原工作区记录需要核对,不能再次执行创建。');
if (!existing) {
this.save(session, group, 'workspace_intent');
const workspace = await this.workspaces.prepare(session, child.label, { id: child.workspaceId, childProjectId: child.projectId, childSessionId: child.sessionId });
signal.throwIfAborted();
const result = await (await this.workspaces.start(session, workspace.id, workspace.fingerprint)).promise;
if (result.status !== 'ready') throw workerConflict(result.summary);
}
await this.initializeChild(group, child); this.save(session, group, 'workspace_registered');
await this.faultInjector?.('workspace_registered', group, child); signal.throwIfAborted();
}
await this.sourceFor(group); group.status = 'ready'; group.summary = '两个独立工作区已核对,来源HEAD、索引和已有修改保持。可以开始受限子任务。';
} catch (error) {
const uncertain = group.children.some(child => { const workspace = this.store.core.workspace.get(child.workspaceId); return workspace && workspace.status !== 'ready'; });
group.status = uncertain ? 'unknown' : signal.aborted ? 'partially_prepared' : 'stale'; group.requiresVerification = uncertain;
group.summary = this.runtime.provider.redact(error.message ?? String(error));
}
this.save(session, group, group.status); return group;
});
}
async inventory(project) {
const inspection = await inspectProject(project, { includeFiles: true });
if (!inspection.scope.complete) throw workerConflict('子工程超出完整快照范围,不能封存或合并成果。');
const files = inspection.files.map(file => {
const bytes = fs.readFileSync(safePath(project, file.path));
return { path: file.path, sha256: workerHash(bytes), bytes: bytes.length };
}).sort((a, b) => a.path.localeCompare(b.path));
return { inspection, files };
}
async initializeChild(group, child) {
if (this.store.core.worker.has(child.id)) { workerForSession(this.store, this.store.session(child.sessionId)); return; }
const project = this.store.project(child.projectId), session = this.store.session(child.sessionId);
await verifyWorkspaceProject(this.store, project);
if (session.taskId || session.messages.length || session.changes.length) throw workerConflict('新工作区已有其他任务记录,不能覆盖其身份。');
const config = { ...group.config, maxTaskTokens: child.budget.maxTokens }, task = createTask(session, child.goal, config);
task.id = child.taskId; task.origin = 'isolated-worker'; task.workspaceIdentity = projectWorkspaceIdentity(project);
task.budget.maxTokens = child.budget.maxTokens; task.workerId = child.id;
task.constraints = ['允许修改范围:' + child.paths.join('、'), '只接受原提案应用和当前工程检查;禁止独立Git提交、任意终端及外部工具。'];
const run = createRun(session, task, config); run.workspaceIdentity = projectWorkspaceIdentity(project);
this.store.core.task.set(task.id, task); this.store.core.run.set(run.id, run);
session.taskId = task.id; session.runId = run.id; session.status = 'paused'; this.store.finishRun(session, run, 'worker_prepared');
const { files, inspection } = await this.inventory(project), git = await this.workspaces.snapshot(project);
if (git.head !== group.source.identity.head || git.dirty) throw workerConflict('子工作区初始HEAD或源码不符合封存来源。');
const worker = { schemaVersion: 1, ...child, collaborationId: group.id, parentProjectId: group.projectId, parentSessionId: group.sessionId,
parentTaskId: group.taskId, parentRunId: group.runId, baseCommit: group.source.identity.head, model: group.model,
runId: run.id, currentRunId: null, status: 'ready', requiresVerification: false, runIds: [], startedAt: null, finishedAt: null,
ownerPid: null, summary: '独立工作区与原始源码已封存,尚未请求模型。', result: null };
const baseline = this.store.artifactStore.write(session, run, { schemaVersion: 1, workerId: worker.id, collaborationId: group.id,
projectId: project.id, sessionId: session.id, taskId: task.id, runId: run.id, groupFingerprint: group.fingerprint,
files, sourceFingerprint: inspection.sourceFingerprint, git: sourceIdentity(git) }, { kind: 'worker-baseline' });
this.store.core.artifact.set(baseline.id, baseline);
worker.baselineArtifactId = baseline.id; worker.baselineSha256 = baseline.sha256; worker.baselineRunId = run.id;
worker.fingerprint = workerHash(workerSeal(worker));
const contract = this.store.artifactStore.write(session, run, workerSeal(worker), { kind: 'worker-contract' });
this.store.core.artifact.set(contract.id, contract); worker.contractArtifactId = contract.id; worker.contractSha256 = contract.sha256;
this.store.putRecord('worker', session, worker, 'worker.ready'); return worker;
}
configFor(group, worker) {
const initial = structuredClone(this.store.config), current = this.runtime.provider.prepareConfig ? this.runtime.provider.prepareConfig(initial, this.store) : initial;
if (JSON.stringify(modelSnapshot(current)) !== JSON.stringify(group.model)) throw workerConflict('模型连接或池快照已变化;不能在原协作中悄悄替换模型。');
const usage = workerUsage(this.store, worker), remaining = group.deadline - Date.now();
if (remaining <= 0) throw new BudgetExceeded('time_limit', '父协作总时限已用完,原任务与成果保留。');
if (usage.accountedTokens >= worker.budget.maxTokens || usage.steps >= worker.budget.maxSteps || usage.toolCalls >= worker.budget.maxToolCalls) throw new BudgetExceeded('worker_budget', '子任务累计预算已用完,续接不能重置预算。');
return { ...group.config, maxSteps: worker.budget.maxSteps - usage.steps, maxTaskTokens: worker.budget.maxTokens,
maxRunTokens: worker.budget.maxTokens - usage.accountedTokens, maxRunDurationMs: remaining };
}
start(session, id, fingerprint, workerId = null) {
const group = this.own(session, id, fingerprint);
if (!['ready', 'paused', 'awaiting_review'].includes(group.status) || group.requiresVerification) throw workerConflict('协作尚未就绪、已封存或待核对,不能重新执行。');
const chosen = group.children.filter(child => workerId === null || child.id === workerId).map(child => this.store.core.worker.get(child.id));
if (!chosen.length || chosen.some(worker => !worker)) throw workerConflict('子任务不属于当前父目标。');
const candidates = chosen.filter(worker => worker.status !== 'completed');
if (!candidates.length) throw workerConflict('所选子任务已经完成,不会重放。');
for (const worker of candidates) {
const childSession = this.store.session(worker.sessionId); workerForSession(this.store, childSession); assertWorkersResolved(this.store, childSession.projectId);
if (childSession.changes.some(change => ['pending', 'conflict'].includes(change.status))) throw workerConflict('请在子任务中先审查改动,再继续原目标。');
if (worker.requiresVerification) throw workerConflict('子任务结果待核对,不能续接。');
}
return this.launch(session, group, 'starting', async signal => {
try {
await this.sourceFor(group); signal.throwIfAborted();
group.startedAt ??= at(); group.deadline ??= Date.parse(group.startedAt) + group.budget.maxDurationMs;
const configs = candidates.map(worker => this.configFor(group, worker));
group.status = 'running'; session.status = 'running'; this.save(session, group, 'running');
const promises = candidates.map((worker, index) => this.runChild(group, worker, configs[index], signal));
const outcomes = await Promise.allSettled(promises);
const workers = group.children.map(child => this.store.core.worker.get(child.id));
group.requiresVerification = outcomes.some(outcome => outcome.status === 'rejected') || workers.some(worker => worker.requiresVerification || ['running', 'stopping'].includes(worker.status));
group.status = group.requiresVerification ? 'unknown' : workers.every(worker => worker.status === 'completed') ? 'ready_to_collect'
: workers.some(worker => this.store.session(worker.sessionId).status === 'needs_review') ? 'awaiting_review' : 'paused';
group.summary = group.status === 'ready_to_collect' ? '两个子任务均有实际改动和当前通过的检查,等待父任务核对原成果。'
: group.status === 'awaiting_review' ? '子任务提案已保存,请分别审查应用后继续;完成状态以实际检查为准。' : '子任务已停止或需要处理,已完成结果保留。';
} catch (error) { group.status = 'paused'; group.summary = this.runtime.provider.redact(error.message ?? String(error)); }
session.status = group.status === 'awaiting_review' ? 'needs_review' : 'paused'; this.save(session, group, group.status); return group;
});
}
async runChild(group, worker, config, signal) {
const session = this.store.session(worker.sessionId);
try {
signal.throwIfAborted(); worker.status = 'running'; worker.startedAt ??= at(); worker.ownerPid = process.pid;
this.store.putRecord('worker', session, worker, 'worker.starting');
this.runtime.startWorker(session, worker, config);
const active = this.runtime.active.get(session.id); worker.currentRunId = active.id; worker.runIds.push(active.id);
this.store.putRecord('worker', session, worker, 'worker.running');
const stop = () => active.controller.abort(signal.reason);
signal.addEventListener('abort', stop, { once: true }); if (signal.aborted) stop();
try { await active.promise; } finally { signal.removeEventListener('abort', stop); }
const unknown = this.uncertain(worker);
worker.requiresVerification = unknown.length > 0;
worker.status = unknown.length ? 'unknown' : session.status === 'needs_review' ? 'awaiting_review' : session.status === 'failed' ? 'failed' : 'paused';
if (session.status === 'completed' && !unknown.length) {
const output = await this.output(session, worker);
const artifact = this.store.artifactStore.write(session, this.store.owned('run', worker.currentRunId, session.id), output, { kind: 'worker-result' });
this.store.core.artifact.set(artifact.id, artifact);
worker.result = { artifactId: artifact.id, sha256: artifact.sha256, fingerprint: workerHash(output), checkJobId: output.check.id, paths: output.files.map(file => file.path) };
worker.status = 'completed'; worker.summary = '实际改动与原检查证据已封存,等待父任务归集。';
} else worker.summary = unknown.length ? '执行结果或原进程待核对,不会重放。' : session.failure?.message ?? '原子任务已保存,等待审查或继续。';
} catch (error) {
const active = this.runtime.active.get(session.id);
if (active?.taskId === worker.taskId) { active.controller.abort(error); await Promise.allSettled([active.promise]); }
worker.requiresVerification = this.uncertain(worker).length > 0; worker.status = worker.requiresVerification ? 'unknown' : 'failed'; worker.summary = this.runtime.provider.redact(error.message ?? String(error));
}
finally { worker.ownerPid = null; worker.finishedAt = at(); this.store.putRecord('worker', session, worker, 'worker.' + worker.status); }
return worker;
}
uncertain(worker) {
return ['tool', 'check_job', 'change_set', 'delivery_job'].flatMap(kind => [...this.store.core[kind].values()]
.filter(value => value.taskId === worker.taskId && (value.requiresVerification || value.status === 'unknown' || value.state === 'unknown'))
.map(value => ({ kind, id: value.id })));
}
baseline(session, worker) {
workerForSession(this.store, session);
const artifact = this.store.owned('artifact', worker.baselineArtifactId, session.id);
if (artifact.kind !== 'worker-baseline' || artifact.taskId !== worker.taskId || artifact.runId !== worker.baselineRunId
|| artifact.sha256 !== worker.baselineSha256) throw workerConflict('子任务初始源码工件归属无效。');
const baseline = JSON.parse(this.store.artifactStore.read(artifact)), group = this.store.core.collaboration.get(worker.collaborationId);
if (baseline.workerId !== worker.id || baseline.collaborationId !== group.id || baseline.groupFingerprint !== group.fingerprint
|| baseline.projectId !== worker.projectId || baseline.sessionId !== worker.sessionId || baseline.taskId !== worker.taskId
|| baseline.runId !== worker.baselineRunId || baseline.git.head !== worker.baseCommit) throw workerConflict('子任务初始来源与封存契约不一致。');
return baseline;
}
async output(session, worker) {
workerForSession(this.store, session);
const baseline = this.baseline(session, worker), project = this.store.project(worker.projectId);
await verifyWorkspaceProject(this.store, project);
if (this.uncertain(worker).length) throw workerConflict('子任务仍有结果未知的工具、检查或文件批次');
if (session.changes.some(change => ['pending', 'conflict'].includes(change.status))) throw workerConflict('子任务仍有未审查改动');
const before = new Map(baseline.files.map(file => [workerPathKey(file.path), file]));
const { inspection, files: current } = await this.inventory(project), after = new Map(current.map(file => [workerPathKey(file.path), file]));
const git = await this.workspaces.snapshot(project);
if (git.head !== worker.baseCommit || git.indexSha256 !== baseline.git.indexSha256 || git.reference !== baseline.git.reference
|| git.gitDir !== baseline.git.gitDir || git.commonDir !== baseline.git.commonDir
|| JSON.stringify(git.configuration) !== JSON.stringify(baseline.git.configuration)) throw workerConflict('子任务HEAD、索引或Git配置已变化,独立提交或暂存不能作为原成果');
const paths = [...new Set([...before.keys(), ...after.keys()])].filter(key => before.get(key)?.sha256 !== after.get(key)?.sha256);
if (!paths.length || paths.length > 32) throw workerConflict('可交付成果需要1到32个实际文本改动');
let bytes = 0;
const files = paths.map(key => {
const original = before.get(key), actual = after.get(key), relative = actual?.path ?? original.path;
workerPath(relative);
if (!pathInWorkerScope(relative, worker.paths)) throw workerConflict('实际改动超出子任务范围:' + relative);
if (!actual) throw workerConflict('本阶段不支持合并删除:' + relative);
const chain = session.changes.filter(change => change.taskId === worker.taskId && workerPathKey(change.path) === key && change.status === 'applied');
if (!chain.length) throw workerConflict('实际修改缺少原Task已应用提案:' + relative);
let expected = original?.sha256 ?? null;
for (const change of chain) {
if (change.baseExists !== (expected !== null) || change.baseSha256 !== expected || workerHash(Buffer.from(change.content, 'utf8')) !== change.sha256
|| change.baseExists && workerHash(Buffer.from(change.baseContent, 'utf8')) !== change.baseSha256) throw workerConflict('应用提案的原字节链不连续:' + relative);
if (change.changeSetId) {
const set = this.store.owned('change_set', change.changeSetId, session.id);
if (set.status !== 'completed' || set.requiresVerification) throw workerConflict('子成果中的批次没有完整应用结果:' + relative);
this.runtime.changeSetManager().snapshots(session, set);
}
expected = change.sha256;
}
if (expected !== actual.sha256) throw workerConflict('当前文件与最后已应用提案不一致:' + relative);
const text = readText(project, relative), last = chain.at(-1), first = chain[0];
if (text.sha256 !== last.sha256) throw workerConflict('成果读取期间原文件发生变化:' + relative);
const raw = fs.readFileSync(safePath(project, relative)); bytes += raw.length + Buffer.byteLength(first.baseContent, 'utf8');
if (raw.length > 512000 || bytes > 4 * 1024 * 1024) throw workerConflict('成果超过单文件512KB或原文/建议合计4MB范围');
return { path: relative, beforeSha256: original?.sha256 ?? null, sha256: actual.sha256, bytes: raw.length,
before: original ? Buffer.from(first.baseContent, 'utf8').toString('base64') : null, after: raw.toString('base64'), changeIds: chain.map(change => change.id) };
}).sort((a, b) => a.path.localeCompare(b.path));
const check = verifiedCheck(this.store, session, inspection);
if (!check) throw workerConflict('缺少与当前源码一致、日志完整且测试数量明确的通过记录');
this.runtime.checkRunner().planFor(session, check.planId);
const latest = await this.inventory(project);
if (latest.inspection.sourceFingerprint !== inspection.sourceFingerprint || JSON.stringify(latest.files) !== JSON.stringify(current)) throw workerConflict('核验期间子工程发生变化');
return { schemaVersion: 1, workerId: worker.id, collaborationId: worker.collaborationId, workerFingerprint: worker.fingerprint,
projectId: worker.projectId, sessionId: worker.sessionId, taskId: worker.taskId, baseCommit: worker.baseCommit,
sourceFingerprint: inspection.sourceFingerprint, files, inventoryFingerprint: workerHash(current),
check: { id: check.id, planId: check.planId, runId: check.runId, sourceFingerprint: check.sourceFingerprint, results: check.results.map(result => ({
id: result.id, name: result.name, tests: result.tests, exitCode: result.exitCode, logArtifactId: result.logArtifactId,
logSha256: this.store.owned('artifact', result.logArtifactId, session.id).sha256,
...(result.metricsArtifactId ? { metricsArtifactId: result.metricsArtifactId, metricsSha256: result.metricsSha256 } : {}),
})) }, usage: workerUsage(this.store, worker), runIds: worker.runIds };
}
async stopParent(sessionId) {
const running = [...this.active.values()].filter(value => value.sessionId === sessionId && value.controller);
for (const value of running) {
if (this.store.core.collaboration.has(value.group.id)) { value.group.status = 'stopping'; this.save(this.store.session(sessionId), value.group, 'stopping'); }
value.controller.abort(new Error('父任务已停止。'));
await this.workspaces.stop(sessionId);
await Promise.allSettled(value.group.children.map(child => this.runtime.stop(child.sessionId)));
await value.promise;
}
}
async stopAll() { await Promise.all([...new Set([...this.active.values()].map(value => value.sessionId))].map(id => this.stopParent(id))); }
discard(session, id, fingerprint) {
const group = this.own(session, id, fingerprint);
if (this.active.has(group.id) || group.requiresVerification || group.merge?.changeSetId) throw workerConflict('协作仍在执行、待核对或已有合并审查,请先处理原记录。');
group.status = group.children.some(child => this.store.core.workspace.has(child.workspaceId)) ? 'resolved_external' : 'discarded';
group.finishedAt = at(); group.summary = '已明确保留原工作区、任务和成果,结束本次协作;未删除、重置或声明交付完成。';
session.status = 'paused'; this.save(session, group, 'discarded'); return group;
}
}
+4
View File
@@ -7,6 +7,7 @@ import { assertChangeSetsResolved, CHANGE_SET_OPEN } from '../../shared/contract
import { assertWorkspacesResolved } from '../../shared/contracts/workspaces.mjs';
import { verifyWorkspaceProject } from './git-workspaces.mjs';
import { assertMcpResolved } from '../tools/mcp-contract.mjs';
import { assertWorkersResolved, assertWorkerWriteScope } from '../../shared/contracts/workers.mjs';
const at = () => new Date().toISOString();
const conflict = message => Object.assign(new Error(message), { status: 409 });
@@ -81,6 +82,7 @@ export class ChangeSetManager {
}
save(session, set, phase) { this.store.save(session, { type: 'change_set.' + phase, detail: { changeSetId: set.id } }); }
requireIdle(session, { source = 'user', exceptId = null, includePrepared = false } = {}) {
assertWorkersResolved(this.store, session.projectId);
assertMcpResolved(this.store, session.projectId);
if (this.projectActive(session.projectId) || this.projectBusy(session.projectId, source === 'agent' ? session.id : null)) {
throw conflict('同一项目正在执行任务、检查、提交或文件批次,请等待结束后再操作。');
@@ -99,6 +101,7 @@ export class ChangeSetManager {
if (set.root !== project.root || hash(Buffer.from(JSON.stringify(sealed(set)))) !== set.fingerprint) throw conflict('变更集封存信息校验失败,请核对原批次。');
validatePaths(project, set.files);
return set.files.map(file => {
assertWorkerWriteScope(this.store, session, file.path, { readOnly: true });
const change = session.changes.find(value => value.id === file.changeId);
if (!change || change.taskId !== set.taskId || change.runId !== file.sourceRunId || targetFor(project, change.path).path !== file.path
|| change.baseExists !== file.baseExists || change.baseSha256 !== file.baseSha256 || change.sha256 !== file.sha256
@@ -141,6 +144,7 @@ export class ChangeSetManager {
if (changes.some(value => !value || value.taskId !== task.id || this.store.core.run.get(value.runId)?.taskId !== task.id || value.status !== 'pending'
|| value.changeSetId && CHANGE_SET_OPEN.has(this.store.core.change_set.get(value.changeSetId)?.status))) throw conflict('变更集只能封存当前Task的待审查提案。');
const project = this.store.project(session.projectId);
for (const change of changes) assertWorkerWriteScope(this.store, session, change.path);
validatePaths(project, changes);
const temporaryId = randomUUID(); this.projects.set(project.id, temporaryId);
try {
+12 -4
View File
@@ -7,6 +7,8 @@ import { safePath, excludedFromInventory } from '../../server/files.mjs';
import { assertChangeSetsResolved } from '../../shared/contracts/change-sets.mjs';
import { assertWorkspacesResolved, assertWorkspacePath, WORKSPACE_ACTIVE } from '../../shared/contracts/workspaces.mjs';
import { assertMcpResolved } from '../tools/mcp-contract.mjs';
import { isId } from '../../shared/contracts/execution.mjs';
import { assertWorkersResolved, workerForProject } from '../../shared/contracts/workers.mjs';
const at = () => new Date().toISOString();
const hash = value => createHash('sha256').update(typeof value === 'string' || Buffer.isBuffer(value) ? value : JSON.stringify(value)).digest('hex');
@@ -209,19 +211,25 @@ export class WorkspaceManager {
return { ...snapshot, fingerprint: hash(snapshot) };
}
prepare(session, label) { return this.track(session, () => this.prepareOwned(session, label)); }
async prepareOwned(session, label) {
prepare(session, label, identities = null) { return this.track(session, () => this.prepareOwned(session, label, identities)); }
async prepareOwned(session, label, identities = null) {
assertWorkersResolved(this.store, session.projectId);
if (workerForProject(this.store, session.projectId)) throw conflict('受限子任务不能创建嵌套工作区。');
if (identities && (Object.keys(identities).some(key => !['id', 'childProjectId', 'childSessionId'].includes(key))
|| ['id', 'childProjectId', 'childSessionId'].some(key => !isId(identities[key]))
|| this.store.core.workspace.has(identities.id) || this.store.projects.some(project => project.id === identities.childProjectId)
|| this.store.sessions.has(identities.childSessionId))) throw conflict('预分配的隔离工作区身份无效或已使用。');
if (typeof label !== 'string' || !label.trim() || label.length > 64 || /[\x00-\x1f]/.test(label)) throw new Error('工作区名称需要1到64个普通字符。');
this.assertIdle(session);
if ([...this.store.core.workspace.values()].some(value => value.projectId === session.projectId && value.status === 'prepared')) throw conflict('这个项目已有待确认的工作区计划,请先处理该记录。');
this.projects.set(session.projectId, 'preparing');
try {
const source = await this.snapshot(this.store.project(session.projectId)), id = randomUUID();
const source = await this.snapshot(this.store.project(session.projectId)), id = identities?.id ?? randomUUID();
const slug = label.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 32) || 'task';
const record = { schemaVersion: 1, id, projectId: session.projectId, sessionId: session.id,
taskId: session.taskId ?? null, runId: session.runId ?? null, label: label.trim(), source,
root: path.join(this.outputRoot, 'w-' + hash(id).slice(0, 20)), branch: 'workbench/' + slug + '-' + id.slice(0, 12),
childProjectId: randomUUID(), childSessionId: randomUUID(), createdAt: at(), updatedAt: at(), finishedAt: null,
childProjectId: identities?.childProjectId ?? randomUUID(), childSessionId: identities?.childSessionId ?? randomUUID(), createdAt: at(), updatedAt: at(), finishedAt: null,
status: 'prepared', phase: 'prepared', creationAttempted: false, requiresVerification: false, ownerPid: null, gitPid: null,
sourcePreserved: null, observation: null, summary: '已封存来源提交和原工作区状态,确认后创建独立Git工作区。' };
this.target(record, { absent: true });
+5
View File
@@ -6,6 +6,7 @@ import { now } from './store.mjs';
import { assertChangeSetsResolved, assertProposalUnsealed } from '../shared/contracts/change-sets.mjs';
import { assertWorkspacePath, assertWorkspacesResolved } from '../shared/contracts/workspaces.mjs';
import { assertMcpResolved } from '../core/tools/mcp-contract.mjs';
import { assertWorkersResolved, assertWorkerWriteScope } from '../shared/contracts/workers.mjs';
export const hash = bytes => createHash('sha256').update(bytes).digest('hex');
const ignored = new Set(['node_modules', '.git', '.next', '.data', 'bin', 'obj', 'dist', 'dist-client', 'dist-server', '__pycache__', '.venv', 'venv', '.tox', '.pytest_cache', '.mypy_cache', '.ruff_cache', 'htmlcov']);
@@ -127,6 +128,8 @@ export function searchFiles(project, args) {
}
export function proposeFile(store, session, args, { patch = null } = {}) {
assertWorkersResolved(store, session.projectId);
assertWorkerWriteScope(store, session, args.path);
assertMcpResolved(store, session.projectId);
assertChangeSetsResolved(store, session.projectId);
assertWorkspacesResolved(store, session.projectId, { includePrepared: true });
@@ -191,11 +194,13 @@ export function proposePatch(store, session, args) {
}
export function applyChange(store, session, id) {
assertWorkersResolved(store, session.projectId);
assertMcpResolved(store, session.projectId);
assertChangeSetsResolved(store, session.projectId);
assertWorkspacesResolved(store, session.projectId, { includePrepared: true });
const change = session.changes.find(item => item.id === id);
if (!change || change.status !== 'pending') throw new Error('这项改动不处于待审查状态。');
assertWorkerWriteScope(store, session, change.path);
assertProposalUnsealed(store, change);
const project = store.project(session.projectId);
const target = safePath(project, change.path, true);
+60 -20
View File
@@ -32,6 +32,10 @@ import { TaskCheckpointManager } from '../core/tasks/task-checkpoint-manager.mjs
import { SkillRegistry, skillToolDefinitions, skillReadInput } from '../core/skills/skill-registry.mjs';
import { McpRegistry } from '../core/tools/mcp-registry.mjs';
import { mcpToolDefinitions, mcpCallInput, assertMcpResolved } from '../core/tools/mcp-contract.mjs';
import { WorkerManager } from '../core/tasks/worker-manager.mjs';
import { WORKER_TOOLS, COLLABORATION_CLOSED, workerForSession, assertWorkerTool, assertWorkersResolved, workerUsage, workerConflict } from '../shared/contracts/workers.mjs';
const workerAuthority = Symbol('internal-worker-start');
const labels = { inspect_session: '核对工作台运行记录', inspect_project: '识别工程与Git基线', index_project: '建立工程符号索引', query_code: '定位工程符号与导入', propose_patch: '准备精确补丁', plan_checks: '准备工程检查计划', run_checks: '执行工程检查', plan_delivery: '准备Git交付预览', delivery_report: '生成工程证据报告', read_artifact: '读取执行日志工件', list_files: '查看项目文件', read_file: '读取文件', search_files: '搜索项目', propose_file: '准备文件改动', run_command: '运行终端命令' };
@@ -101,8 +105,9 @@ export class Runtime {
this.appDirectory = appDirectory;
this.active = new Map(); this.waiters = new Map();
}
isActive(id) { return this.active.has(id) || !!this.checks?.isActive(id) || !!this.deliveries?.isActive(id) || !!this.changeSets?.isActive(id) || !!this.workspaces?.isActive(id) || !!this.research?.isActive(id) || !!this.engines?.isActive(id) || !!this.browser?.isActive(id) || !!this.taskPlans?.isActive(id); }
hasActivity() { return (this.provider.activeRequests ?? 0) > 0 || (this.provider.hub?.waiting ?? 0) > 0 || this.active.size > 0 || (this.checks?.active.size ?? 0) > 0 || (this.deliveries?.active.size ?? 0) > 0 || (this.changeSets?.projects.size ?? 0) > 0 || (this.workspaces?.projects.size ?? 0) > 0 || (this.workspaces?.pending.size ?? 0) > 0 || (this.research?.active.size ?? 0) > 0 || (this.engines?.active.size ?? 0) > 0 || (this.browser?.active.size ?? 0) > 0 || (this.taskPlans?.active.size ?? 0) > 0; }
isActive(id) { return this.active.has(id) || !!this.workers?.isActive(id) || !!this.checks?.isActive(id) || !!this.deliveries?.isActive(id) || !!this.changeSets?.isActive(id) || !!this.workspaces?.isActive(id) || !!this.research?.isActive(id) || !!this.engines?.isActive(id) || !!this.browser?.isActive(id) || !!this.taskPlans?.isActive(id); }
hasActivity() { return (this.provider.activeRequests ?? 0) > 0 || (this.provider.hub?.waiting ?? 0) > 0 || this.active.size > 0 || (this.workers?.active.size ?? 0) > 0 || (this.checks?.active.size ?? 0) > 0 || (this.deliveries?.active.size ?? 0) > 0 || (this.changeSets?.projects.size ?? 0) > 0 || (this.workspaces?.projects.size ?? 0) > 0 || (this.workspaces?.pending.size ?? 0) > 0 || (this.research?.active.size ?? 0) > 0 || (this.engines?.active.size ?? 0) > 0 || (this.browser?.active.size ?? 0) > 0 || (this.taskPlans?.active.size ?? 0) > 0; }
workerManager() { return this.workers ??= new WorkerManager(this.store, this); }
projectIndexer() { return this.codeIndex ??= new ProjectIndex(); }
taskPlanner() { return this.taskPlans ??= new TaskPlanManager(this.store, { redact: value => this.provider.redact(value),
projectBusy: (projectId, exceptId) => this.projectHasActivity(projectId, exceptId) }); }
@@ -124,31 +129,41 @@ export class Runtime {
return this.research ??= new ResearchManager(this.store, { appDirectory: this.appDirectory,
redact: value => this.provider.redact(value), projectBusy: (projectId, exceptId) => this.projectHasActivity(projectId, exceptId) });
}
projectHasActivity(projectId, exceptSessionId = null) {
return [...this.active.entries()].some(([id, run]) => id !== exceptSessionId && run.project.id === projectId) || !!this.checks?.projectActive(projectId) || !!this.deliveries?.projectActive(projectId) || !!this.changeSets?.projectActive(projectId) || !!this.workspaces?.projectActive(projectId) || !!this.research?.projectActive(projectId) || !!this.engines?.projectActive(projectId) || !!this.browser?.projectActive(projectId) || !!this.taskPlans?.projectActive(projectId);
projectHasActivity(projectId, exceptSessionId = null, { excludeGroupId = null } = {}) {
return !!this.workers?.projectActive(projectId, excludeGroupId) || [...this.active.entries()].some(([id, run]) => id !== exceptSessionId && run.project.id === projectId) || !!this.checks?.projectActive(projectId) || !!this.deliveries?.projectActive(projectId) || !!this.changeSets?.projectActive(projectId) || !!this.workspaces?.projectActive(projectId) || !!this.research?.projectActive(projectId) || !!this.engines?.projectActive(projectId) || !!this.browser?.projectActive(projectId) || !!this.taskPlans?.projectActive(projectId);
}
workspaceManager() {
return this.workspaces ??= new WorkspaceManager(this.store, { initialize: this.store.core.workspace.size === 0,
redact: value => this.provider.redact(value), projectBusy: projectId =>
[...this.active.values()].some(run => run.project.id === projectId) || !!this.checks?.projectActive(projectId)
!!this.workers?.projectActive(projectId) || [...this.active.values()].some(run => run.project.id === projectId) || !!this.checks?.projectActive(projectId)
|| !!this.deliveries?.projectActive(projectId) || !!this.changeSets?.projectActive(projectId) || !!this.research?.projectActive(projectId) || !!this.engines?.projectActive(projectId) || !!this.browser?.projectActive(projectId) || !!this.taskPlans?.projectActive(projectId) });
}
changeSetManager() {
return this.changeSets ??= new ChangeSetManager(this.store, { projectBusy: (projectId, exceptId) =>
[...this.active.entries()].some(([id, run]) => id !== exceptId && run.project.id === projectId)
!!this.workers?.projectActive(projectId) || [...this.active.entries()].some(([id, run]) => id !== exceptId && run.project.id === projectId)
|| !!this.checks?.projectActive(projectId) || !!this.deliveries?.projectActive(projectId) || !!this.workspaces?.projectActive(projectId) || !!this.research?.projectActive(projectId) || !!this.engines?.projectActive(projectId) || !!this.browser?.projectActive(projectId) || !!this.taskPlans?.projectActive(projectId) });
}
checkRunner() {
return this.checks ??= new CheckRunner(this.store, { redact: value => this.provider.redact(value), runtimeDirectory: this.appDirectory ? path.join(this.appDirectory, 'runtime') : null,
pythonRunnerPath: path.join(this.appDirectory ?? process.cwd(), 'scripts', 'python-check-runner.py'),
projectBusy: (projectId, exceptId) => [...this.active.entries()].some(([id, run]) => id !== exceptId && run.project.id === projectId) || !!this.deliveries?.projectActive(projectId) || !!this.changeSets?.projectActive(projectId) || !!this.workspaces?.projectActive(projectId) || !!this.research?.projectActive(projectId) || !!this.engines?.projectActive(projectId) || !!this.browser?.projectActive(projectId) || !!this.taskPlans?.projectActive(projectId) });
projectBusy: (projectId, exceptId) => !!this.workers?.projectActive(projectId) || [...this.active.entries()].some(([id, run]) => id !== exceptId && run.project.id === projectId) || !!this.deliveries?.projectActive(projectId) || !!this.changeSets?.projectActive(projectId) || !!this.workspaces?.projectActive(projectId) || !!this.research?.projectActive(projectId) || !!this.engines?.projectActive(projectId) || !!this.browser?.projectActive(projectId) || !!this.taskPlans?.projectActive(projectId) });
}
gitDelivery() {
return this.deliveries ??= new GitDelivery(this.store, { redact: value => this.provider.redact(value),
projectBusy: (projectId, exceptId) => [...this.active.entries()].some(([id, run]) => id !== exceptId && run.project.id === projectId) || !!this.checks?.projectActive(projectId) || !!this.changeSets?.projectActive(projectId) || !!this.workspaces?.projectActive(projectId) || !!this.research?.projectActive(projectId) || !!this.engines?.projectActive(projectId) || !!this.browser?.projectActive(projectId) || !!this.taskPlans?.projectActive(projectId) });
projectBusy: (projectId, exceptId) => !!this.workers?.projectActive(projectId) || [...this.active.entries()].some(([id, run]) => id !== exceptId && run.project.id === projectId) || !!this.checks?.projectActive(projectId) || !!this.changeSets?.projectActive(projectId) || !!this.workspaces?.projectActive(projectId) || !!this.research?.projectActive(projectId) || !!this.engines?.projectActive(projectId) || !!this.browser?.projectActive(projectId) || !!this.taskPlans?.projectActive(projectId) });
}
start(id, content, resume = false, { instructionSource = null } = {}) {
startWorker(session, worker, config) {
if (workerForSession(this.store, session) !== worker || !this.workers?.active.has(worker.collaborationId)
|| this.store.core.collaboration.get(worker.collaborationId)?.status !== 'running') throw workerConflict('子任务只能由所属父协作启动。');
return this.start(session.id, worker.goal, true, { workerAuthorization: workerAuthority, worker, workerConfig: config });
}
start(id, content, resume = false, { instructionSource = null, workerAuthorization = null, worker = null, workerConfig = null } = {}) {
const session = this.store.session(id);
assertWorkersResolved(this.store, session.projectId);
const boundWorker = workerForSession(this.store, session);
if (workerAuthorization !== null && workerAuthorization !== workerAuthority || workerConfig && workerAuthorization !== workerAuthority
|| boundWorker && (workerAuthorization !== workerAuthority || boundWorker !== worker)) throw workerConflict('受限子任务请在父协作中开始或继续,不能替换目标或配置。');
if (!boundWorker && [...this.store.core.collaboration.values()].some(group => group.projectId === session.projectId && !COLLABORATION_CLOSED.has(group.status))) throw workerConflict('项目已有未收尾父协作,请先处理子任务和合并审查,再发送新目标。');
assertMcpResolved(this.store, session.projectId);
if (pendingDeliveryReview(this.store, session)) throw Object.assign(new Error('当前任务已有待确认的Git交付预览。请在任务记录中审查并确认提交,或撤回预览后继续。'), { status: 409 });
assertChangeSetsResolved(this.store, session.projectId, { includePrepared: true });
@@ -159,11 +174,11 @@ export class Runtime {
const project = this.store.project(session.projectId);
safePath(project);
const controller = new AbortController();
const initialConfig = structuredClone(this.store.config);
const config = this.provider.prepareConfig ? this.provider.prepareConfig(initialConfig, this.store) : initialConfig;
const initialConfig = structuredClone(workerConfig ?? this.store.config);
const config = workerConfig ? initialConfig : this.provider.prepareConfig ? this.provider.prepareConfig(initialConfig, this.store) : initialConfig;
if (config.mode !== 'demo') this.provider.validate(config);
const record = this.store.beginRun(session, content, resume, config, { instructionSource });
const run = { controller, id: record.id, taskId: record.taskId, project, record, config };
const run = { controller, id: record.id, taskId: record.taskId, project, record, config, ...(worker ? { worker } : {}) };
this.active.set(id, run);
session.status = 'running'; session.recoveryNotice = null; session.executionMode = config.mode;
session.runId = run.id;
@@ -180,6 +195,7 @@ export class Runtime {
clearTimeout(deadline); this.active.delete(id);
this.store.finishRun(session, record, run.stopReason ?? null);
});
run.promise.catch(() => {});
return session;
}
resume(id, content) {
@@ -218,7 +234,10 @@ export class Runtime {
.map(change => ({ path: change.path, status: change.status, id: change.id, changeSetId: change.changeSetId ?? null }));
const unknown = [...this.store.core.tool.values()].filter(tool => tool.taskId === task.id && tool.requiresVerification)
.map(tool => ({ invocation_id: tool.id, call_id: tool.callId, tool: tool.tool, status: tool.state, requires_verification: true }));
const context = this.provider.redact(projectContext(run.project) + '\n当前项目/会话/任务身份:' + JSON.stringify({
const context = this.provider.redact(projectContext(run.project) + (run.worker ? '\n受限子任务执行契约(宿主权限,不可扩展):' + JSON.stringify({
parent_task_id: run.worker.parentTaskId, worker_id: run.worker.id, write_paths: run.worker.paths, budget: run.worker.budget,
rule: '只有范围内提案、审查应用和当前工程检查构成完成;不得请求任意终端、独立Git提交、外部工具或嵌套协作。',
}) : '') + '\n当前项目/会话/任务身份:' + JSON.stringify({
project_id: run.project.id, session_id: session.id, task_id: task.id, workspace: projectWorkspaceIdentity(run.project) }) + '\n当前Task文件提案状态:' + JSON.stringify(state)
+ '\n当前任务目标与全部追加要求(用户任务数据,完整保留):\n' + JSON.stringify({
goal: task.goal, instructions: task.instructions, constraints: task.constraints ?? [], acceptance: task.acceptance ?? [],
@@ -230,13 +249,14 @@ export class Runtime {
remaining_steps: taskPlan.remaining_steps, error: taskPlan.error,
steps: taskPlan.steps.map(({ candidates, evidence, ...step }) => ({ ...step, evidence_id: evidence?.id ?? null })),
}) : ''));
const skillCatalog = this.skillRegistry().catalog(session.projectId);
const mcpCatalog = this.mcpRegistry().catalog(session.projectId);
const tools = [...toolDefinitions, ...taskPlanToolDefinitions, ...(skillCatalog.entries.some(value => value.status === 'current') ? skillToolDefinitions : []),
...(mcpCatalog.entries.length ? mcpToolDefinitions : []),
const skillCatalog = run.worker ? null : this.skillRegistry().catalog(session.projectId);
const mcpCatalog = run.worker ? null : this.mcpRegistry().catalog(session.projectId);
const availableTools = [...toolDefinitions, ...taskPlanToolDefinitions, ...(skillCatalog?.entries.some(value => value.status === 'current') ? skillToolDefinitions : []),
...(mcpCatalog?.entries.length ? mcpToolDefinitions : []),
...([...this.store.core.research_target.values()].some(target => target.sessionId === session.id && target.taskId === run.taskId) ? researchToolDefinitions : []),
...([...this.store.core.engine_job.values()].some(job => job.sessionId === session.id && job.taskId === run.taskId) ? engineToolDefinitions : []),
...(this.browserManager().builds(run.project).length || [...this.store.core.browser_plan.values()].some(plan => plan.sessionId === session.id && plan.taskId === run.taskId) ? browserToolDefinitions : [])];
const tools = run.worker ? availableTools.filter(tool => WORKER_TOOLS.has(tool.function.name)) : availableTools;
const projectMemory = await this.memoryManager().context(session, { redact: value => this.provider.redact(value) });
signal.throwIfAborted();
const planned = this.requestPlanner().prepare(session, run.record, config, { system: context, tools, stepId: stepRecord.id, projectMemory, skillCatalog, mcpCatalog });
@@ -247,9 +267,10 @@ export class Runtime {
' tokens;省略 ' + planned.record.archivedGroups + ' 个完整消息组,原历史和参数已保存为SHA256工件。估算与服务实际用量分别记录。' });
}
let requestEvent;
let response;
let response, requestStarted = false, responseAccounted = false;
try {
signal.throwIfAborted(); checkBudget(run.record, task);
requestStarted = true;
response = await this.provider.complete(config, planned.messages, run.project, signal, progress => {
if (!requestEvent) requestEvent = this.store.event(session, { kind: 'model', runId: run.id, source: 'model_connection', label: '请求模型服务', phase: 'running', startedAt: now(), contextPlanId: planned.record.id });
planned.record.status = progress.phase === 'running' || progress.phase === 'retrying' ? 'requesting' : planned.record.status;
@@ -267,18 +288,27 @@ export class Runtime {
this.store.save(session);
}, planned.record, tools);
this.requestPlanner().finish(session, planned.record, { response, attempts: planned.record.requestAttempts });
if (run.worker) {
this.store.recordResponse(session, run.record, response.usage, planned.record.estimatedInputTokens + Math.ceil(Buffer.byteLength(JSON.stringify(response.message), 'utf8') / 3) + 8);
responseAccounted = true; this.store.save(session);
}
} catch (error) {
this.requestPlanner().finish(session, planned.record, { error: Object.assign(new Error(this.provider.redact(error.message ?? String(error))), { name: signal.aborted ? 'AbortError' : error.name }), attempts: planned.record.requestAttempts });
if (run.worker && requestStarted && !responseAccounted) {
this.store.recordResponse(session, run.record, null, planned.record.estimatedInputTokens + config.maxOutputTokens);
this.store.save(session, { type: 'worker.request_usage_unknown' });
}
throw error;
}
signal.throwIfAborted();
const message = response.message;
const calls = message.tool_calls ?? [];
if (run.worker && (calls.length > 16 || workerUsage(this.store, run.worker).toolCalls + calls.length > run.worker.budget.maxToolCalls)) throw new BudgetExceeded('worker_tool_limit', '子任务工具次数超出固定累计预算或单次16项上限;这批工具未执行,原响应和用量已保存。');
run.readMessageBytes = readMessageBudget(planned.record, message);
const previousIds = new Set(session.providerMessages.flatMap(item => (item.tool_calls ?? []).map(call => call.id)));
if (new Set(calls.map(call => call.id)).size !== calls.length || calls.some(call => previousIds.has(call.id))) throw new Error('模型返回了重复的工具调用 ID,请重新发送任务。');
session.providerMessages.push(message);
this.store.recordResponse(session, run.record, response.usage, planned.record.estimatedInputTokens + Math.ceil(Buffer.byteLength(JSON.stringify(message), 'utf8') / 3) + 8);
if (!responseAccounted) this.store.recordResponse(session, run.record, response.usage, planned.record.estimatedInputTokens + Math.ceil(Buffer.byteLength(JSON.stringify(message), 'utf8') / 3) + 8);
for (const call of calls) {
const event = { id: randomUUID(), createdAt: now(), startedAt: now(), kind: 'tool', phase: 'queued',
toolCallId: call.id, tool: call.function.name, label: labels[call.function.name] ?? call.function.name, taskId: run.taskId, runId: run.id };
@@ -290,6 +320,14 @@ export class Runtime {
if (!calls.length) {
this.store.finishStep(session, stepRecord);
session.status = session.changes.some(change => ['pending', 'conflict'].includes(change.status)) ? 'needs_review' : 'completed';
if (session.status === 'completed' && run.worker) {
try { await this.workerManager().output(session, run.worker); signal.throwIfAborted(); }
catch (error) {
if (signal.aborted) throw error;
session.status = 'paused'; run.stopReason = 'worker_incomplete';
this.store.message(session, 'system', '子任务还不能交付:' + this.provider.redact(error.message ?? String(error)) + '。原目标和结果已保存。');
}
}
if (session.status === 'completed' && task.currentTaskPlanId) {
const finalPlan = await this.taskPlanner().inspect(session, { candidates: false });
if (!finalPlan.all_verified) {
@@ -377,6 +415,7 @@ export class Runtime {
try {
const args = JSON.parse(call.function.arguments);
validateToolArgs(tool, args);
assertWorkerTool(this.store, session, tool, args);
event.input = JSON.parse(this.provider.redact(JSON.stringify(args)));
const proofHint = !!this.store.core.task.get(run.taskId)?.currentTaskPlanId && PLAN_READ_TOOLS.includes(tool);
const readMetadata = { ...(proofHint ? { tool_invocation_id: event.invocationId } : {}),
@@ -595,6 +634,7 @@ export class Runtime {
});
}
async stop(sessionId) {
await this.workers?.stopParent(sessionId);
const run = this.active.get(sessionId);
if (!run) { await this.checks?.stop(sessionId); await this.deliveries?.stop(sessionId); await this.changeSets?.stop(sessionId); await this.workspaces?.stop(sessionId); await this.research?.stop(sessionId); await this.engines?.stop(sessionId); await this.browser?.stop(sessionId); await this.mcp?.stop(sessionId); await this.taskPlans?.settle(sessionId); return; }
const session = this.store.session(sessionId);
@@ -602,5 +642,5 @@ export class Runtime {
run.controller.abort(new Error('用户停止任务'));
await run.promise;
}
async stopAll() { await Promise.all([...this.active.keys()].map(id => this.stop(id))); await this.checks?.stopAll(); await this.deliveries?.stopAll(); await this.changeSets?.stopAll(); await this.workspaces?.stopAll(); await this.research?.stopAll(); await this.engines?.stopAll(); await this.browser?.stopAll(); await this.mcp?.stopAll(); await this.taskPlans?.settle(); }
async stopAll() { await this.workers?.stopAll(); await Promise.all([...this.active.keys()].map(id => this.stop(id))); await this.checks?.stopAll(); await this.deliveries?.stopAll(); await this.changeSets?.stopAll(); await this.workspaces?.stopAll(); await this.research?.stopAll(); await this.engines?.stopAll(); await this.browser?.stopAll(); await this.mcp?.stopAll(); await this.taskPlans?.settle(); }
}
+19 -2
View File
@@ -13,6 +13,7 @@ import { ENGINE_ACTIVE, publicEngineJob } from '../shared/contracts/engines.mjs'
import { BROWSER_ACTIVE } from '../shared/contracts/browser.mjs';
import { publicBrowserPlan } from '../core/browser/browser-manager.mjs';
import { MCP_ACTIVE } from '../core/tools/mcp-contract.mjs';
import { COLLABORATION_ACTIVE } from '../shared/contracts/workers.mjs';
export const now = () => new Date().toISOString();
@@ -232,6 +233,16 @@ export class Store extends EventEmitter {
job.status = 'unknown'; job.requiresVerification = true; job.finishedAt = now();
job.error = { code: 'MCP_HOST_INTERRUPTED', message: '宿主中断,外部MCP结果及原进程状态待核对。不按历史PID停止进程,不重放请求。' }; changed = true;
}
for (const group of this.core.collaboration.values()) if (group.sessionId === session.id && COLLABORATION_ACTIVE.has(group.status)) {
group.status = 'unknown'; group.requiresVerification = true; group.finishedAt = now();
group.summary = '父协作在宿主中断时没有完整收尾;保留子任务和工作区,核对原输入与现场后显式处理,不自动重放。';
session.status = 'paused'; session.recoveryNotice = group.summary; changed = true;
}
for (const worker of this.core.worker.values()) if (worker.sessionId === session.id && ['running', 'stopping'].includes(worker.status)) {
worker.status = 'unknown'; worker.requiresVerification = true; worker.finishedAt = now();
worker.summary = '子执行在宿主中断时没有完整收尾;原进程结束及实际修改待核对,不按历史PID停止进程或重放工具。';
session.status = 'paused'; session.recoveryNotice = worker.summary; changed = true;
}
for (const job of this.core.engine_job.values()) if (job.sessionId === session.id && ENGINE_ACTIVE.has(job.status)) {
job.status = 'unknown'; job.requiresVerification = true; job.verification = null; job.finishedAt = now();
job.summary = '外部引擎连接检查中断,原进程关闭状态未知。不会根据历史PID停止进程或重放请求,请查看所属原记录。';
@@ -385,10 +396,10 @@ export class Store extends EventEmitter {
return session;
}
beginRun(session, content, resume, config, { instructionSource = null } = {}) {
beginRun(session, content, resume, config, { instructionSource = null, forceNewTask = false } = {}) {
let task = this.core.task.get(session.taskId);
const previousRunId = session.runId ?? null;
if (!task || !resume && ['completed', 'idle'].includes(task.status)) {
if (forceNewTask || !task || !resume && ['completed', 'idle'].includes(task.status)) {
const previous = task?.id ?? null;
const goal = content || session.messages.find(message => message.role === 'user')?.content || session.title;
task = createTask(session, goal, config, previous); this.core.task.set(task.id, task);
@@ -558,6 +569,12 @@ export class Store extends EventEmitter {
...value, baseline: { head: snapshot.head, branch: snapshot.branch, reference: snapshot.reference },
})),
accountedTaskTokens: accountedTokens(task?.usage),
...([...this.core.collaboration.values()].some(value => value.sessionId === session.id) ? {
collaborations: [...this.core.collaboration.values()].filter(value => value.sessionId === session.id),
} : {}),
...([...this.core.worker.values()].some(value => value.sessionId === session.id) ? {
workers: [...this.core.worker.values()].filter(value => value.sessionId === session.id),
} : {}),
};
}
+1 -1
View File
@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
export const EXECUTION_SCHEMA = 1;
export const ACTIVE_STATES = new Set(['running', 'awaiting_approval', 'stopping']);
export const CORE_KINDS = ['task', 'run', 'step', 'tool', 'artifact', 'check_plan', 'check_job', 'delivery_plan', 'delivery_job', 'change_set', 'context_plan', 'workspace', 'research_target', 'research_job', 'engine_job', 'browser_plan', 'browser_job', 'task_plan', 'task_proof', 'memory', 'task_checkpoint', 'mcp_job'];
export const CORE_KINDS = ['task', 'run', 'step', 'tool', 'artifact', 'check_plan', 'check_job', 'delivery_plan', 'delivery_job', 'change_set', 'context_plan', 'workspace', 'research_target', 'research_job', 'engine_job', 'browser_plan', 'browser_job', 'task_plan', 'task_proof', 'memory', 'task_checkpoint', 'mcp_job', 'collaboration', 'worker'];
export const timestamp = () => new Date().toISOString();
export const isId = value => typeof value === 'string' && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(value);
+119
View File
@@ -0,0 +1,119 @@
import { createHash } from 'node:crypto';
import { isId, accountedTokens, emptyUsage } from './execution.mjs';
export const WORKER_TOOLS = new Set(['inspect_session', 'inspect_project', 'index_project', 'query_code', 'read_artifact',
'list_files', 'read_file', 'search_files', 'propose_file', 'propose_patch', 'prepare_change_set', 'plan_checks', 'run_checks']);
export const COLLABORATION_ACTIVE = new Set(['preparing', 'starting', 'running', 'stopping', 'collecting', 'merge_preparing', 'reconciling']);
export const COLLABORATION_CLOSED = new Set(['completed', 'discarded', 'resolved_external']);
export const workerConflict = message => Object.assign(new Error(message), { status: 409 });
export const workerHash = value => createHash('sha256').update(typeof value === 'string' || Buffer.isBuffer(value) ? value : JSON.stringify(value)).digest('hex');
export function workerPath(value) {
if (typeof value !== 'string' || !value || value.length > 240 || /[\\:\x00-\x1f*?"<>|]/.test(value)
|| value.startsWith('/') || value.endsWith('/') || value.split('/').some(part => !part || part === '.' || part === '..'
|| /[. ]$/.test(part) || /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part))) throw workerConflict('子任务范围需要明确的项目相对文件或目录,不能使用通配符、别名或上级路径。');
if (value.split('/').some(part => /^(?:\.git|node_modules|dist|dist-server|\.qa|\.awb-.+|\.env.*|credentials.*|secrets?.*)$/i.test(part))) throw workerConflict('子任务修改范围不能包含内部目录、依赖或凭据。');
return value;
}
export const workerPathKey = value => value.toLowerCase();
export const pathInWorkerScope = (value, paths) => paths.some(scope => workerPathKey(value) === workerPathKey(scope) || workerPathKey(value).startsWith(workerPathKey(scope) + '/'));
function bounded(value, fallback, minimum, maximum, label) {
const result = value === undefined ? fallback : value;
if (!Number.isSafeInteger(result) || result < minimum || result > maximum) throw workerConflict(label + '超出允许范围。');
return result;
}
const text = (value, maximum, label) => {
if (typeof value !== 'string' || !value.trim() || value.length > maximum || !value.isWellFormed() || /[\x00-\x08\x0b\x0c\x0e-\x1f]/.test(value)) throw workerConflict(label + '不能为空或超过长度范围。');
return value.trim();
};
export function collaborationInput(input, config) {
if (!input || Array.isArray(input) || Object.keys(input).some(key => !['goal', 'budget', 'children'].includes(key))) throw workerConflict('协作只接受父目标、预算和两个子任务。');
if (!Array.isArray(input.children) || input.children.length !== 2) throw workerConflict('本阶段需要两个受限子任务。');
const raw = input.budget ?? {};
if (!raw || typeof raw !== 'object' || Array.isArray(raw) || Object.keys(raw).some(key => !['maxTokens', 'maxSteps', 'maxToolCalls', 'maxDurationMs'].includes(key))) throw workerConflict('协作预算字段无效。');
const tokenMaximum = Math.min(config.maxTaskTokens ?? 1000000, config.maxRunTokens ?? 200000);
const budget = {
maxTokens: bounded(raw.maxTokens, tokenMaximum, 1000, tokenMaximum, '总token预算'),
maxSteps: bounded(raw.maxSteps, Math.min(200, (config.maxSteps ?? 12) * 2), 2, 200, '总请求步数'),
maxToolCalls: bounded(raw.maxToolCalls, 96, 2, 512, '总工具次数'),
maxDurationMs: bounded(raw.maxDurationMs, config.maxRunDurationMs ?? 600000, 1000, Math.min(3600000, config.maxRunDurationMs ?? 600000), '总时限'),
};
const children = input.children.map((item, index) => {
if (!item || typeof item !== 'object' || Array.isArray(item) || Object.keys(item).some(key => !['label', 'goal', 'paths', 'budget'].includes(key))) throw workerConflict('子任务字段无效。');
if (!Array.isArray(item.paths) || !item.paths.length || item.paths.length > 16) throw workerConflict('每个子任务需要1到16个修改范围。');
const paths = item.paths.map(workerPath).sort();
if (new Set(paths.map(workerPathKey)).size !== paths.length) throw workerConflict('子任务范围不能重复。');
const part = item.budget ?? {};
if (!part || Array.isArray(part) || Object.keys(part).some(key => !['maxTokens', 'maxSteps', 'maxToolCalls'].includes(key))) throw workerConflict('子预算字段无效。');
const allocate = key => index === 0 ? Math.floor(budget[key] / 2) : budget[key] - Math.floor(budget[key] / 2);
return { label: text(item.label, 64, '子任务名称'), goal: text(item.goal, 8000, '子目标'), paths,
budget: Object.fromEntries(['maxTokens', 'maxSteps', 'maxToolCalls'].map(key => [key, bounded(part[key], allocate(key), key === 'maxTokens' ? 500 : 1, budget[key], key)])) };
});
for (const key of ['maxTokens', 'maxSteps', 'maxToolCalls']) if (children.reduce((sum, child) => sum + child.budget[key], 0) > budget[key]) throw workerConflict('子任务预算之和不能超过父预算:' + key);
return { goal: text(input.goal, 20000, '父目标'), budget, children };
}
export function collaborationSeal(group) {
return { schemaVersion: 1, id: group.id, projectId: group.projectId, sessionId: group.sessionId, taskId: group.taskId, runId: group.runId,
goal: group.goal, budget: group.budget, model: group.model, config: group.config, source: group.source, children: group.children };
}
export function workerSeal(worker) {
return { schemaVersion: 1, id: worker.id, collaborationId: worker.collaborationId, parentProjectId: worker.parentProjectId,
parentSessionId: worker.parentSessionId, parentTaskId: worker.parentTaskId, parentRunId: worker.parentRunId,
projectId: worker.projectId, sessionId: worker.sessionId, taskId: worker.taskId, workspaceId: worker.workspaceId,
label: worker.label, goal: worker.goal, paths: worker.paths, budget: worker.budget, model: worker.model, baseCommit: worker.baseCommit,
baselineArtifactId: worker.baselineArtifactId, baselineSha256: worker.baselineSha256, baselineRunId: worker.baselineRunId };
}
export function workerForProject(store, projectId) {
return [...(store.core.worker?.values() ?? [])].find(value => value.projectId === projectId) ?? null;
}
export function workerForSession(store, session) {
const worker = workerForProject(store, session.projectId);
if (!worker) return null;
if (worker.sessionId !== session.id || worker.taskId !== session.taskId || workerHash(workerSeal(worker)) !== worker.fingerprint) throw workerConflict('隔离项目只允许原受限子任务操作,身份或范围已变化。');
const group = store.core.collaboration.get(worker.collaborationId);
const definition = group?.children.find(child => child.id === worker.id);
if (!group || workerHash(collaborationSeal(group)) !== group.fingerprint || !definition
|| definition.taskId !== worker.taskId || definition.projectId !== worker.projectId || definition.sessionId !== worker.sessionId
|| definition.workspaceId !== worker.workspaceId || JSON.stringify(definition.paths) !== JSON.stringify(worker.paths)
|| JSON.stringify(definition.budget) !== JSON.stringify(worker.budget) || definition.goal !== worker.goal
|| JSON.stringify(group.model) !== JSON.stringify(worker.model)) throw workerConflict('子任务与父任务的封存分工不一致。');
const task = store.core.task.get(worker.taskId);
if (!task || task.goal !== worker.goal || task.workerId !== worker.id || task.budget.maxTokens !== worker.budget.maxTokens) throw workerConflict('子任务目标、身份或累计预算已变化。');
const original = store.owned('artifact', worker.contractArtifactId, session.id);
if (original.kind !== 'worker-contract' || original.taskId !== worker.taskId || original.sha256 !== worker.contractSha256
|| store.artifactStore.read(original) !== JSON.stringify(workerSeal(worker))) throw workerConflict('受限子任务契约与原工件不一致。');
const plan = store.owned('artifact', group.planArtifactId, group.sessionId);
if (plan.kind !== 'collaboration-plan' || plan.taskId !== group.taskId || plan.sha256 !== group.planSha256
|| store.artifactStore.read(plan) !== JSON.stringify(collaborationSeal(group))) throw workerConflict('父任务分工与原封存工件不一致。');
return worker;
}
export function assertWorkerWriteScope(store, session, value, { readOnly = false } = {}) {
const worker = workerForSession(store, session);
if (!worker) return;
const portable = workerPath(value);
if (!pathInWorkerScope(portable, worker.paths)) throw workerConflict('文件超出子任务的固定修改范围:' + portable);
if (!readOnly && ['unknown', 'completed', 'resolved_external'].includes(worker.status)) throw workerConflict('子任务已封存或结果待核对,不能修改原成果。');
}
export function assertWorkerTool(store, session, tool, args) {
const worker = workerForSession(store, session);
if (!worker) return;
if (!WORKER_TOOLS.has(tool)) throw workerConflict('受限子任务不开放这个工具:' + tool);
if (tool === 'propose_file' || tool === 'propose_patch') assertWorkerWriteScope(store, session, args.path);
}
export function assertWorkersResolved(store, projectId) {
const group = [...(store.core.collaboration?.values() ?? [])].find(value => value.requiresVerification
&& (value.projectId === projectId || value.children.some(child => child.projectId === projectId)));
const worker = workerForProject(store, projectId);
if (group || worker?.requiresVerification) throw workerConflict('协作执行结果待核对,请返回父任务查看原输入和现场,不会自动重放。');
}
export function workerUsage(store, worker) {
const task = store.core.task.get(worker.taskId), runs = [...store.core.run.values()].filter(run => run.taskId === worker.taskId);
return { ...emptyUsage(), ...task?.usage, accountedTokens: accountedTokens(task?.usage),
steps: runs.reduce((sum, run) => sum + run.steps, 0), toolCalls: runs.reduce((sum, run) => sum + run.toolCalls, 0) };
}
export function assertWorkerIds(value) {
for (const field of ['id', 'workspaceId', 'projectId', 'sessionId', 'taskId']) if (!isId(value[field])) throw workerConflict('子任务预分配身份无效。');
}
+3 -3
View File
@@ -4,9 +4,9 @@
用户授权进入下一阶段全量开发,并要求及时回顾。基线f0fcefd/1.12.1保持;在feat/isolated-workers-1.13分支开发,正式服务不普通重启、不读取/复制Key、不发送真实模型请求。每个切片检查实现、原证据及遗留项后小步本地提交。
1. [in_progress] 复用Task/Run、独立Git工作区、审批、预算、检查与恢复契约;保存1.13范围/状态/权限/验收方案。独立工作区不宣称为OS沙箱。
2. [pending] 实现父子任务、不可变分工/写入范围、两个工作区、预算分配、所属执行与状态记录;创建串行,执行最多两个并行。
3. [pending] 接入受限模型工具、逐次审批、停止传播、原进程结束/迟到响应/超时与宿主恢复;未知副作用不自动重放,原任务/结果保持。
1. [complete] Task/Run、独立Git工作区、审批、预算、检查及持久归属契约已复用,PLAN-1.13已封存。工作区不宣称为OS沙箱。
2. [complete] 父子记录、不可变范围/预算/模型、预分配身份、两个串行工作区与并行受限执行已实现;核心6/6、文件批次/检查/工作区32/32通过并保存原失败。源码仍1.12.1,不登记为发行。
3. [in_progress] 受限工具/审批及真实检查完成门槛已接入;继续停止传播、所属进程、迟到响应、预算/崩溃/未知核对专项,原任务/结果保持。
4. [pending] 收集实际diff与当前检查证据;来源/范围/输入变化及重叠修改阻止合并;父任务按现有封存变更集进行显式审查及检查/Git交付。
5. [pending] 协作控制台桌面/390px与Node/React/Python三个独立实际工程样本,覆盖正常、修复、冲突、停止及恢复;声明夹具与真实模型语义分别记录。
6. [pending] 切片回顾及本地提交后,完整UI/独立源码/不可变源码与便携验收、保留当前Provider/全部历史正式升级;封存1.13报告并更新下一阶段起点。
+66
View File
@@ -0,0 +1,66 @@
import fs from 'node:fs';
import path from 'node:path';
import { randomUUID } from 'node:crypto';
import { Provider } from '../../src/server/provider.mjs';
import { Runtime } from '../../src/server/runtime.mjs';
import { createDeliveryProject, writeDeliveryFile, deliveryGit } from './delivery-project.mjs';
import { call, until } from '../helpers.mjs';
export const workerDefinition = (paths = ['src/a.mjs', 'src/b.mjs']) => ({ goal: '交付两个独立改进并核对父工程',
children: paths.map((relative, index) => ({ label: 'worker-' + (index + 1), goal: '实现子任务' + (index + 1), paths: [relative] })) });
export function prepareWorkerFixture(f, { ownerChanges = true, respond = null } = {}) {
createDeliveryProject(f, { broken: false, ownerChanges });
const provider = new Provider(), requests = [];
provider.complete = async (config, messages, project, signal, progress, planned, tools) => {
requests.push({ config, messages, projectId: project.id, tools: tools.map(value => value.function.name) });
if (respond) return respond({ config, messages, project, signal, progress, planned, tools });
const session = [...f.store.sessions.values()].find(value => value.projectId === project.id), task = f.store.core.task.get(session.taskId);
const worker = [...f.store.core.worker.values()].find(value => value.taskId === task.id);
const plan = [...f.store.core.check_plan.values()].filter(value => value.taskId === task.id).at(-1);
const job = [...f.store.core.check_job.values()].filter(value => value.taskId === task.id).at(-1);
let calls = [];
if (!session.changes.some(change => change.taskId === task.id)) calls = [call(randomUUID(), 'propose_file', {
path: worker.paths[0], content: 'export const value = ' + (worker.label.endsWith('1') ? '1' : '2') + ';\n', reason: '自有夹具中的独立修改' })];
else if (session.changes.some(change => change.status === 'pending')) calls = [];
else if (!plan) calls = [call(randomUUID(), 'plan_checks', { names: ['test', 'build'] })];
else if (!job) calls = [call(randomUUID(), 'run_checks', { plan_id: plan.id })];
return { message: { role: 'assistant', content: calls.length ? '' : '夹具声称完成,宿主仍需核验', ...(calls.length ? { tool_calls: calls } : {}) }, usage: { total_tokens: 168, prompt_tokens: 123, completion_tokens: 45 } };
};
const runtime = new Runtime(f.store, provider), manager = runtime.workerManager();
f.onCleanup(() => runtime.stopAll());
return { runtime, manager, provider, requests };
}
export async function applyWorkerProposals(f, runtime, group) {
for (const child of group.children) {
const session = f.store.session(child.sessionId), ids = session.changes.filter(change => change.status === 'pending').map(change => change.id);
if (!ids.length) continue;
const set = await runtime.changeSetManager().prepare(session, ids);
await (await runtime.changeSetManager().start(session, set.id, set.fingerprint)).promise;
if (set.status !== 'completed') throw new Error(set.summary);
}
}
export async function approveWorkerChecks(f, runtime, group, started) {
let done = false, error;
started.promise.then(() => { done = true; }, failure => { error = failure; done = true; });
while (!done) {
for (const child of group.children) {
const session = f.store.session(child.sessionId);
for (const approval of session.approvals.filter(value => value.status === 'pending')) runtime.decide(session.id, approval.id, true);
}
await new Promise(resolve => setTimeout(resolve, 20));
}
if (error) throw error;
return started.promise;
}
export const ownerBytes = f => ({ head: deliveryGit(f, ['rev-parse', 'HEAD']).trim(), index: fs.readFileSync(path.join(f.projectRoot, '.git/index')).toString('base64'),
files: Object.fromEntries(['owner-staged.txt', 'owner-unstaged.txt', 'owner-untracked.txt'].filter(name => fs.existsSync(path.join(f.projectRoot, name))).map(name => [name, fs.readFileSync(path.join(f.projectRoot, name)).toString('base64')])) });
export async function completedWorkers(f, options = {}) {
const context = prepareWorkerFixture(f, options), original = ownerBytes(f);
const group = await context.manager.plan(f.session, workerDefinition(options.paths));
await (await context.manager.prepare(f.session, group.id, group.fingerprint)).promise;
if (group.status !== 'ready') throw new Error(group.summary);
await (await context.manager.start(f.session, group.id, group.fingerprint)).promise;
await applyWorkerProposals(f, context.runtime, group);
await approveWorkerChecks(f, context.runtime, group, context.manager.start(f.session, group.id, group.fingerprint));
return { ...context, group, original };
}
+97
View File
@@ -0,0 +1,97 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import { randomUUID } from 'node:crypto';
import { fixture, call, until, assertToolPairs } from './helpers.mjs';
import { workerDefinition, prepareWorkerFixture, completedWorkers, ownerBytes } from './fixtures/workers-project.mjs';
import { collaborationInput, workerPath, workerForSession } from '../src/shared/contracts/workers.mjs';
import { proposeFile } from '../src/server/files.mjs';
import { Store } from '../src/server/store.mjs';
test('worker scopes and allocated budgets reject aliases, extra permissions and aggregate overflow', t => {
const f = fixture(t);
for (const value of ['../outside', 'C:/elsewhere', '/root', 'src\\file', 'src/../x', 'src/a.', 'src/a ', 'CON.mjs', '.git/config', '.env', 'src/*']) assert.throws(() => workerPath(value));
const valid = collaborationInput(workerDefinition(), f.store.config);
assert.equal(valid.children.length, 2);
assert.equal(valid.children.reduce((sum, child) => sum + child.budget.maxTokens, 0), valid.budget.maxTokens);
assert.throws(() => collaborationInput({ ...workerDefinition(), children: [workerDefinition().children[0]] }, f.store.config), /两个/);
assert.throws(() => collaborationInput({ ...workerDefinition(), children: workerDefinition().children.map(child => ({ ...child, budget: { maxTokens: valid.budget.maxTokens } })) }, f.store.config), /之和/);
assert.throws(() => collaborationInput({ ...workerDefinition(), command: 'powershell' }, f.store.config), /只接受/);
});
test('two sequential Git workspaces freeze a new parent goal, separate owned tasks and preserve all source bytes', async t => {
const f = fixture(t), { manager, runtime } = prepareWorkerFixture(f);
const oldTaskId = f.session.taskId, original = ownerBytes(f); f.session.status = 'failed'; f.store.save(f.session);
const group = await manager.plan(f.session, workerDefinition());
assert.notEqual(group.taskId, oldTaskId); assert.equal(f.store.core.task.get(oldTaskId).goal, 'Repair addition, verify the project and deliver only reviewed files');
const preparation = manager.prepare(f.session, group.id, group.fingerprint);
assert.equal(runtime.hasActivity(), true);
assert.throws(() => manager.prepare(f.session, group.id, group.fingerprint), /创建|执行|重放/);
await preparation.promise; assert.equal(group.status, 'ready', group.summary);
assert.deepEqual(ownerBytes(f), original); assert.equal(new Set(group.children.map(child => child.projectId)).size, 2);
for (const child of group.children) {
const worker = f.store.core.worker.get(child.id), session = f.store.session(child.sessionId);
assert.equal(workerForSession(f.store, session).id, child.id);
assert.equal(f.store.core.task.get(child.taskId).goal, child.goal);
assert.notEqual(f.store.project(child.projectId).root, f.projectRoot);
assert.throws(() => runtime.start(session.id, '替换目标'), /父协作|受限/);
assert.throws(() => proposeFile(f.store, session, { path: 'README.md', content: 'outside', reason: 'outside' }), /范围/);
const other = f.store.createSession(child.projectId);
assert.throws(() => proposeFile(f.store, other, { path: child.paths[0], content: 'other', reason: 'other' }), /原受限/);
}
});
test('real isolated changes, approvals and npm checks produce original owned outputs, not model completion claims', async t => {
const f = fixture(t), { group, manager, runtime, requests, original } = await completedWorkers(f);
assert.equal(group.status, 'ready_to_collect', JSON.stringify(manager.view(f.session).groups[0].workers.map(worker => {
const session = f.store.session(worker.sessionId);
return { status: worker.status, summary: worker.summary, failure: session.failure, reason: f.store.core.run.get(session.runId).stopReason,
messages: session.messages.slice(-3).map(message => message.content), checks: session.execution?.checks };
})));
assert.deepEqual(ownerBytes(f), original);
assert.equal(requests.some(request => request.tools.includes('run_command')), false);
assert.equal(requests.some(request => request.tools.includes('plan_delivery')), false);
assert.equal(requests.some(request => request.tools.includes('call_registered_mcp')), false);
for (const child of group.children) {
const worker = f.store.core.worker.get(child.id), session = f.store.session(child.sessionId);
assert.equal(worker.status, 'completed', worker.summary); assert.ok(worker.result);
assert.equal((await manager.output(session, worker)).check.results[0].tests.passed, 3);
assert.equal(session.approvals.filter(approval => approval.status === 'approved').length, 1);
assertToolPairs(session.providerMessages);
assert.throws(() => proposeFile(f.store, session, { path: child.paths[0], content: 'changed', reason: 'changed' }), /封存/);
}
assert.equal(runtime.hasActivity(), false);
});
test('forged worker tools cannot execute terminal or Git even when absent from the advertised tool list', async t => {
const f = fixture(t), { manager, runtime } = prepareWorkerFixture(f);
const group = await manager.plan(f.session, workerDefinition()); await (await manager.prepare(f.session, group.id, group.fingerprint)).promise;
const child = group.children[0], session = f.store.session(child.sessionId), record = f.store.core.run.get(session.runId);
for (const tool of ['run_command', 'plan_delivery', 'plan_task']) {
const invocation = call(randomUUID(), tool, tool === 'run_command' ? { command: 'write file', reason: 'forged' } : tool === 'plan_task' ? { expected_revision: 0, steps: [] } : {});
const result = await runtime.executeTool(session, invocation, { id: record.id, taskId: child.taskId, record, project: f.store.project(child.projectId), controller: new AbortController(), config: f.store.config });
assert.equal(result.status, 'error');
}
assert.equal(session.approvals.length, 0);
});
test('a completion-only model pauses each worker without fabricated changes or checks', async t => {
const f = fixture(t), { manager } = prepareWorkerFixture(f, { respond: async () => ({ message: { role: 'assistant', content: '全部完成' }, usage: { total_tokens: 10 } }) });
const group = await manager.plan(f.session, workerDefinition()); await (await manager.prepare(f.session, group.id, group.fingerprint)).promise;
await (await manager.start(f.session, group.id, group.fingerprint)).promise;
assert.equal(group.status, 'paused');
for (const child of group.children) { assert.equal(f.store.core.worker.get(child.id).result, null); assert.equal(f.store.core.run.get(f.store.session(child.sessionId).runId).stopReason, 'worker_incomplete', JSON.stringify(f.store.session(child.sessionId).failure ?? f.store.core.worker.get(child.id).summary)); }
});
test('restart retains frozen scope and marks interrupted parent and workers unknown without sending requests', async t => {
const f = fixture(t), { manager } = prepareWorkerFixture(f);
const group = await manager.plan(f.session, workerDefinition()); await (await manager.prepare(f.session, group.id, group.fingerprint)).promise;
group.status = 'running'; f.store.save(f.session);
const worker = f.store.core.worker.get(group.children[0].id), session = f.store.session(worker.sessionId); worker.status = 'running'; f.store.save(session);
f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
assert.equal(reopened.core.collaboration.get(group.id).status, 'unknown');
assert.equal(reopened.core.worker.get(worker.id).status, 'unknown');
assert.equal(reopened.core.worker.get(worker.id).requiresVerification, true);
assert.deepEqual(reopened.core.worker.get(worker.id).paths, worker.paths);
});