From 1a847c15779282d7af51d92602e8ab063899f0e9 Mon Sep 17 00:00:00 2001 From: Agent Workbench Dev Date: Sat, 31 Oct 2026 01:05:32 +0800 Subject: [PATCH] feat: execute two owned workers in isolated Git workspaces with frozen scopes --- docs/QA-1.13.md | 13 + docs/workers-core-diagnosis.tap | 51 ++++ docs/workers-core-final.tap | 14 ++ docs/workers-core-first.tap | 55 ++++ docs/workers-core-output-diagnosis.tap | 30 +++ docs/workers-core-ownership-fix.tap | 31 +++ docs/workers-core-regression.tap | 43 ++++ findings.md | 8 + progress.md | 3 + src/core/check-runner.mjs | 3 + src/core/git-delivery.mjs | 3 + src/core/tasks/worker-manager.mjs | 335 +++++++++++++++++++++++++ src/core/workspaces/change-sets.mjs | 4 + src/core/workspaces/git-workspaces.mjs | 16 +- src/server/files.mjs | 5 + src/server/runtime.mjs | 80 ++++-- src/server/store.mjs | 21 +- src/shared/contracts/execution.mjs | 2 +- src/shared/contracts/workers.mjs | 119 +++++++++ task_plan.md | 6 +- tests/fixtures/workers-project.mjs | 66 +++++ tests/workers.test.mjs | 97 +++++++ 22 files changed, 975 insertions(+), 30 deletions(-) create mode 100644 docs/QA-1.13.md create mode 100644 docs/workers-core-diagnosis.tap create mode 100644 docs/workers-core-final.tap create mode 100644 docs/workers-core-first.tap create mode 100644 docs/workers-core-output-diagnosis.tap create mode 100644 docs/workers-core-ownership-fix.tap create mode 100644 docs/workers-core-regression.tap create mode 100644 src/core/tasks/worker-manager.mjs create mode 100644 src/shared/contracts/workers.mjs create mode 100644 tests/fixtures/workers-project.mjs create mode 100644 tests/workers.test.mjs diff --git a/docs/QA-1.13.md b/docs/QA-1.13.md new file mode 100644 index 00000000..3f1d0ce7 --- /dev/null +++ b/docs/QA-1.13.md @@ -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与控制台实际验收、三个本地工程样本、完整独立源码/便携与保留正式状态发行。 diff --git a/docs/workers-core-diagnosis.tap b/docs/workers-core-diagnosis.tap new file mode 100644 index 00000000..48853c62 --- /dev/null +++ b/docs/workers-core-diagnosis.tap @@ -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. (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. (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' + } diff --git a/docs/workers-core-final.tap b/docs/workers-core-final.tap new file mode 100644 index 00000000..228242fe --- /dev/null +++ b/docs/workers-core-final.tap @@ -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 diff --git a/docs/workers-core-first.tap b/docs/workers-core-first.tap new file mode 100644 index 00000000..0e8f3873 --- /dev/null +++ b/docs/workers-core-first.tap @@ -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. (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. (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' + } diff --git a/docs/workers-core-output-diagnosis.tap b/docs/workers-core-output-diagnosis.tap new file mode 100644 index 00000000..ee78152d --- /dev/null +++ b/docs/workers-core-output-diagnosis.tap @@ -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. (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' + } diff --git a/docs/workers-core-ownership-fix.tap b/docs/workers-core-ownership-fix.tap new file mode 100644 index 00000000..84534aa2 --- /dev/null +++ b/docs/workers-core-ownership-fix.tap @@ -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. (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' + } diff --git a/docs/workers-core-regression.tap b/docs/workers-core-regression.tap new file mode 100644 index 00000000..de61846a --- /dev/null +++ b/docs/workers-core-regression.tap @@ -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 diff --git a/findings.md b/findings.md index 6abc2d6b..ff1bcd9b 100644 --- a/findings.md +++ b/findings.md @@ -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接续 diff --git a/progress.md b/progress.md index e716ec99..5f9c9032 100644 --- a/progress.md +++ b/progress.md @@ -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候选 diff --git a/src/core/check-runner.mjs b/src/core/check-runner.mjs index 24cfc9ad..b8e745d8 100644 --- a/src/core/check-runner.mjs +++ b/src/core/check-runner.mjs @@ -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 }); diff --git a/src/core/git-delivery.mjs b/src/core/git-delivery.mjs index fb59b91d..6a696851 100644 --- a/src/core/git-delivery.mjs +++ b/src/core/git-delivery.mjs @@ -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); diff --git a/src/core/tasks/worker-manager.mjs b/src/core/tasks/worker-manager.mjs new file mode 100644 index 00000000..0a138649 --- /dev/null +++ b/src/core/tasks/worker-manager.mjs @@ -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; + } +} diff --git a/src/core/workspaces/change-sets.mjs b/src/core/workspaces/change-sets.mjs index 59f266e8..7b85224a 100644 --- a/src/core/workspaces/change-sets.mjs +++ b/src/core/workspaces/change-sets.mjs @@ -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 { diff --git a/src/core/workspaces/git-workspaces.mjs b/src/core/workspaces/git-workspaces.mjs index b9197eae..c63612dc 100644 --- a/src/core/workspaces/git-workspaces.mjs +++ b/src/core/workspaces/git-workspaces.mjs @@ -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 }); diff --git a/src/server/files.mjs b/src/server/files.mjs index 6f727310..36145b5b 100644 --- a/src/server/files.mjs +++ b/src/server/files.mjs @@ -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); diff --git a/src/server/runtime.mjs b/src/server/runtime.mjs index 4d95b7f4..95698ffb 100644 --- a/src/server/runtime.mjs +++ b/src/server/runtime.mjs @@ -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(); } } diff --git a/src/server/store.mjs b/src/server/store.mjs index 413b049f..99f8223b 100644 --- a/src/server/store.mjs +++ b/src/server/store.mjs @@ -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), + } : {}), }; } diff --git a/src/shared/contracts/execution.mjs b/src/shared/contracts/execution.mjs index ae7ad46e..ec873391 100644 --- a/src/shared/contracts/execution.mjs +++ b/src/shared/contracts/execution.mjs @@ -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); diff --git a/src/shared/contracts/workers.mjs b/src/shared/contracts/workers.mjs new file mode 100644 index 00000000..2d31009f --- /dev/null +++ b/src/shared/contracts/workers.mjs @@ -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('子任务预分配身份无效。'); +} diff --git a/task_plan.md b/task_plan.md index 09730b41..1a1778ea 100644 --- a/task_plan.md +++ b/task_plan.md @@ -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报告并更新下一阶段起点。 diff --git a/tests/fixtures/workers-project.mjs b/tests/fixtures/workers-project.mjs new file mode 100644 index 00000000..d45ffaee --- /dev/null +++ b/tests/fixtures/workers-project.mjs @@ -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 }; +} diff --git a/tests/workers.test.mjs b/tests/workers.test.mjs new file mode 100644 index 00000000..e7b8f3d3 --- /dev/null +++ b/tests/workers.test.mjs @@ -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); +});