feat: seal isolated worker recovery, parent integration and review console

This commit is contained in:
Agent Workbench Dev
2026-10-31 02:02:06 +08:00
parent 3abc0e8595
commit 2ada7b899f
34 changed files with 2877 additions and 64 deletions
+382 -17
View File
@@ -10,6 +10,11 @@ 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';
import { ChangeSetManager } from '../workspaces/change-sets.mjs';
import { parseTestEvidence } from '../check-runner.mjs';
import { verifyPlanEvidence } from '../context/request-plan.mjs';
import { repairToolPairs } from '../../server/store.mjs';
import { readOwnedProcessTree } from '../owned-process-tree.mjs';
const at = () => new Date().toISOString();
const sourceIdentity = source => Object.fromEntries(['root', 'head', 'reference', 'branch', 'gitDir', 'commonDir', 'indexSha256',
@@ -31,10 +36,14 @@ export class WorkerManager {
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); }
childActive(id) { return this.runtime.active.has(id) || !!this.runtime.checks?.isActive(id) || !!this.runtime.changeSets?.isActive(id) || !!this.workspaces?.isActive(id); }
isActive(sessionId) { return [...this.active.values()].some(value => value.sessionId === sessionId)
|| [...this.store.core.collaboration.values()].some(group => group.sessionId === sessionId && !COLLABORATION_CLOSED.has(group.status) && group.children.some(child => this.childActive(child.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)));
|| ['preparing', 'collecting', 'reconciling', 'merge_preparing'].includes(value.group.status) && value.group.children.some(child => child.projectId === projectId)))
|| [...this.store.core.collaboration.values()].some(group => group.id !== excludeGroupId && group.projectId === projectId
&& !COLLABORATION_CLOSED.has(group.status) && group.children.some(child => this.childActive(child.sessionId)));
}
assertIdle(session) {
if (this.runtime.projectHasActivity(session.projectId)) throw workerConflict('项目已有执行或协作操作,请等待结束。');
@@ -42,9 +51,9 @@ export class WorkerManager {
assertChangeSetsResolved(this.store, session.projectId, { includePrepared: true });
if (session.changes.some(change => ['pending', 'conflict'].includes(change.status))) throw workerConflict('请先审查当前待处理改动,再创建协作目标。');
}
own(session, id, fingerprint = null) {
own(session, id, fingerprint = null, { current = true } = {}) {
const group = this.store.owned('collaboration', id, session.id);
if (group.taskId !== session.taskId || group.runId !== session.runId || group.projectId !== session.projectId
if (current && (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
@@ -118,20 +127,24 @@ export class WorkerManager {
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 && !(existing.status === 'ready' || existing.status === 'prepared' && !existing.creationAttempted && !existing.requiresVerification)) 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);
} else if (existing.status === 'prepared') {
const result = await (await this.workspaces.start(session, existing.id, existing.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'; });
const uncertain = group.children.some(child => { const workspace = this.store.core.workspace.get(child.workspaceId); return workspace && (workspace.status !== 'ready'
|| !this.store.core.worker.has(child.id) && this.store.sessions.get(child.sessionId)?.taskId); });
group.status = uncertain ? 'unknown' : signal.aborted ? 'partially_prepared' : 'stale'; group.requiresVerification = uncertain;
group.summary = this.runtime.provider.redact(error.message ?? String(error));
}
@@ -151,14 +164,20 @@ export class WorkerManager {
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');
if (session.messages.length || session.changes.length) throw workerConflict('新工作区已有其他任务记录,不能覆盖其身份。');
const config = { ...group.config, maxTaskTokens: child.budget.maxTokens };
let task = this.store.core.task.get(session.taskId), run = this.store.core.run.get(session.runId);
if (session.taskId) {
if (task?.id !== child.taskId || task.goal !== child.goal || task.workerId !== child.id || task.origin !== 'isolated-worker'
|| run?.taskId !== task.id || run.stopReason !== 'worker_prepared' || !run.finishedAt) throw workerConflict('子任务初始化有其他或不完整记录,请保留现场核对。');
} else {
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提交、任意终端及外部工具。'];
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,
@@ -271,6 +290,7 @@ export class WorkerManager {
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配置已变化,独立提交或暂存不能作为原成果');
if (git.changedPathCount > 32 || git.changedPaths.some(file => !after.has(workerPathKey(file.path)))) throw workerConflict('实际Git修改包含删除、链接、排除文件或超出32文件范围,不能遗漏后合并');
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;
@@ -302,7 +322,14 @@ export class WorkerManager {
}).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 plan = this.runtime.checkRunner().planFor(session, check.planId);
for (const result of check.results) if (result.kind === 'test' && result.engine !== 'python') {
const spec = plan.checks.find(value => value.name === result.name);
const evidence = parseTestEvidence(this.store.artifactStore.read(this.store.owned('artifact', result.logArtifactId, session.id)), spec?.framework);
if (JSON.stringify(evidence) !== JSON.stringify(result.tests)) throw workerConflict('检查数量与原日志不一致');
}
const cache = new Map();
for (const request of this.store.core.context_plan.values()) if (request.taskId === worker.taskId) verifyPlanEvidence(this.store, session, request, cache);
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,
@@ -314,6 +341,319 @@ export class WorkerManager {
...(result.metricsArtifactId ? { metricsArtifactId: result.metricsArtifactId, metricsSha256: result.metricsSha256 } : {}),
})) }, usage: workerUsage(this.store, worker), runIds: worker.runIds };
}
async verifiedResult(group, child) {
const worker = this.store.core.worker.get(child.id), session = this.store.session(child.sessionId);
if (!worker || worker.status !== 'completed' || worker.requiresVerification || !worker.result) throw workerConflict('子任务尚未完成原成果封存:' + child.label);
const artifact = this.store.owned('artifact', worker.result.artifactId, session.id);
if (artifact.kind !== 'worker-result' || artifact.taskId !== worker.taskId || artifact.runId !== worker.currentRunId || artifact.sha256 !== worker.result.sha256) throw workerConflict('子成果工件归属或原散列不一致:' + child.label);
const original = JSON.parse(this.store.artifactStore.read(artifact));
if (workerHash(original) !== worker.result.fingerprint || original.workerId !== worker.id || original.collaborationId !== group.id
|| original.workerFingerprint !== worker.fingerprint || original.taskId !== worker.taskId) throw workerConflict('子成果与原分工不一致:' + child.label);
const current = await this.output(session, worker);
if (JSON.stringify(original) !== JSON.stringify(current)) throw workerConflict('子工程、检查、账本或原成果已变化:' + child.label);
return { worker, artifact, output: original };
}
async collectionFor(session, group) {
await this.sourceFor(group);
const proofs = [];
for (const child of group.children) proofs.push(await this.verifiedResult(group, child));
const conflicts = [], targets = [], project = this.store.project(group.projectId);
const all = proofs.flatMap(proof => proof.output.files.map(file => ({ ...file, workerId: proof.worker.id, label: proof.worker.label })));
for (let index = 0; index < all.length; index++) {
const file = all[index], key = workerPathKey(file.path);
for (const other of all.slice(index + 1)) {
const otherKey = workerPathKey(other.path);
if (key === otherKey || key.startsWith(otherKey + '/') || otherKey.startsWith(key + '/')) conflicts.push({ path: file.path, workerIds: [file.workerId, other.workerId], reason: '两个子成果修改同一路径或文件/目录相互包含;需要明确分工后重新审查。' });
}
const dirty = group.source.changedPaths.find(value => [value.path, value.originalPath].filter(Boolean).some(relative => {
const dirtyKey = workerPathKey(relative); return key === dirtyKey || key.startsWith(dirtyKey + '/') || dirtyKey.startsWith(key + '/');
}));
if (dirty) { conflicts.push({ path: file.path, workerIds: [file.workerId], reason: '父工程已有暂存、未提交或未跟踪修改:' + dirty.path }); continue; }
try {
const target = safePath(project, file.path, true), exists = fs.existsSync(target);
if (exists !== (file.before !== null)) throw workerConflict('父文件存在状态与子HEAD不一致,不能覆盖已有内容。');
const original = exists ? readText(project, file.path) : null, before = original ? fs.readFileSync(target) : null;
const childBefore = file.before === null ? null : Buffer.from(file.before, 'base64'), after = Buffer.from(file.after, 'base64');
if (workerHash(after) !== file.sha256 || childBefore && workerHash(childBefore) !== file.beforeSha256) throw workerConflict('子成果原字节不一致。');
const normalized = value => value.replace(/^\uFEFF/, '').replaceAll('\r\n', '\n');
if (before && normalized(before.toString('utf8')) !== normalized(childBefore.toString('utf8'))) throw workerConflict('父工程原内容与子HEAD不一致。');
let content = new TextDecoder('utf8', { fatal: true }).decode(after);
if (original) {
const source = original.content;
if (/\r\n/.test(source) && !/(?<!\r)\n/.test(source)) content = content.replace(/\r\n|\n/g, '\r\n');
else if (!/\r\n/.test(source)) content = content.replaceAll('\r\n', '\n');
if (original.bom) content = '\uFEFF' + content.replace(/^\uFEFF/, '');
} else if (after.subarray(0, 3).equals(Buffer.from([0xef, 0xbb, 0xbf]))) content = '\uFEFF' + content;
targets.push({ path: file.path, workerId: file.workerId, label: file.label, beforeSha256: original?.sha256 ?? null,
sha256: workerHash(Buffer.from(content, 'utf8')), childSha256: file.sha256, content });
} catch (error) { conflicts.push({ path: file.path, workerIds: [file.workerId], reason: this.runtime.provider.redact(error.message ?? String(error)) }); }
}
if (all.length > 32 || targets.reduce((sum, file) => sum + Buffer.byteLength(file.content, 'utf8'), 0) > 2 * 1024 * 1024) conflicts.push({ path: '(整批)', workerIds: group.children.map(child => child.id), reason: '合并超过32文件或2MB建议内容,请缩小交付范围。' });
await this.sourceFor(group);
return { schemaVersion: 1, collaborationId: group.id, groupFingerprint: group.fingerprint, projectId: group.projectId,
sessionId: session.id, taskId: group.taskId, runId: group.runId, source: group.source.identity,
workers: proofs.map(proof => ({ workerId: proof.worker.id, artifactId: proof.artifact.id, sha256: proof.artifact.sha256, fingerprint: proof.worker.fingerprint,
checkJobId: proof.output.check.id, paths: proof.output.files.map(file => file.path) })),
paths: all.map(file => file.path).sort(), conflicts, targets: targets.sort((a, b) => a.path.localeCompare(b.path)) };
}
collect(session, id, fingerprint) {
const group = this.own(session, id, fingerprint);
if (!['ready_to_collect', 'collected', 'conflict'].includes(group.status) || group.requiresVerification || group.merge) throw workerConflict('先完成两个子任务,已有合并审查不能重新归集。');
return this.launch(session, group, 'collecting', async signal => {
try {
const collection = await this.collectionFor(session, group); signal.throwIfAborted();
const artifact = this.store.artifactStore.write(session, this.store.owned('run', group.runId, session.id), collection, { kind: 'worker-collection' });
this.store.core.artifact.set(artifact.id, artifact);
group.collection = { artifactId: artifact.id, sha256: artifact.sha256, fingerprint: workerHash(collection), conflicts: collection.conflicts, paths: collection.paths };
group.status = collection.conflicts.length ? 'conflict' : 'collected';
group.summary = collection.conflicts.length ? '原成果已封存,存在具体路径冲突;父工程未改变。' : '原子成果、当前检查和来源均已核对,可以准备父Task的独立变更集审查。';
} catch (error) { group.status = signal.aborted ? 'ready_to_collect' : 'stale'; group.summary = this.runtime.provider.redact(error.message ?? String(error)); }
this.save(session, group, group.status); return group;
});
}
async readCollection(session, group) {
this.own(session, group.id, null, { current: false });
if (!group.collection) throw workerConflict('当前协作尚未封存成果归集。');
const artifact = this.store.owned('artifact', group.collection.artifactId, session.id);
if (artifact.kind !== 'worker-collection' || artifact.taskId !== group.taskId || artifact.runId !== group.runId || artifact.sha256 !== group.collection.sha256) throw workerConflict('成果归集工件归属或散列不一致。');
const record = JSON.parse(this.store.artifactStore.read(artifact));
if (record.collaborationId !== group.id || record.groupFingerprint !== group.fingerprint || workerHash(record) !== group.collection.fingerprint) throw workerConflict('成果归集与原协作不一致。');
return record;
}
async verifyCollection(session, group) {
const original = await this.readCollection(session, group), current = await this.collectionFor(session, group);
if (JSON.stringify(original) !== JSON.stringify(current) || current.conflicts.length) throw workerConflict('来源、原成果或检查证据已变化,不能使用旧合并审查。');
return original;
}
prepareMerge(session, id, fingerprint) {
const group = this.own(session, id, fingerprint);
if (group.status !== 'collected' || group.merge && group.merge.status !== 'proposing' || group.requiresVerification) throw workerConflict('只有没有冲突的原成果可以准备一次父合并审查。');
return this.launch(session, group, 'merge_preparing', async signal => {
try {
const collection = await this.verifyCollection(session, group); signal.throwIfAborted();
if (session.changes.some(change => ['pending', 'conflict'].includes(change.status) && change.sourceBinding?.collaborationId !== group.id)) throw workerConflict('父Task已有未处理提案,不能混入子成果。');
group.merge ??= { collectionSha256: group.collection.sha256, changeIds: [], status: 'proposing' };
const recovered = this.mergeProposals(session, group, collection);
group.merge.changeIds = recovered.map(change => change.id); this.save(session, group, 'merge_intent');
for (const file of collection.targets) {
signal.throwIfAborted();
if (recovered.some(change => change.path === file.path)) continue;
const proof = collection.workers.find(value => value.workerId === file.workerId);
const result = proposeFile(this.store, session, { path: file.path, base_sha256: file.beforeSha256, content: file.content, reason: '合并已核验子任务「' + file.label + '」的原成果' },
{ sourceBinding: { collaborationId: group.id, workerId: file.workerId, resultArtifactId: proof.artifactId, resultSha256: proof.sha256, collectionSha256: group.collection.sha256 } });
if (!result.change_id) throw workerConflict('原成果没有形成新的父提案,不能补造合并成功。');
group.merge.changeIds.push(result.change_id); this.save(session, group, 'merge_proposal');
await this.faultInjector?.('merge_proposal', group, file);
}
await this.verifyCollection(session, group); signal.throwIfAborted();
const manager = new ChangeSetManager(this.store, { projectBusy: (projectId, exceptId) => this.runtime.projectHasActivity(projectId, exceptId, { excludeGroupId: group.id }) });
const set = await manager.prepare(session, group.merge.changeIds, { collaborationBinding: { id: group.id, fingerprint: group.fingerprint,
collectionArtifactId: group.collection.artifactId, collectionSha256: group.collection.sha256 } });
group.merge.changeSetId = set.id; group.merge.fingerprint = set.fingerprint; group.merge.status = 'prepared';
group.status = 'merge_prepared'; group.summary = '父Task独立提案与原字节变更集已封存,等待明确审查应用;父工程尚未修改。';
session.status = 'needs_review';
} catch (error) {
group.status = group.merge ? 'unknown' : 'stale'; group.requiresVerification = !!group.merge;
group.summary = this.runtime.provider.redact(error.message ?? String(error));
}
this.save(session, group, group.status); return group;
});
}
mergeProposals(session, group, collection) {
const changes = session.changes.filter(change => change.sourceBinding?.collaborationId === group.id);
if (new Set(changes.map(change => workerPathKey(change.path))).size !== changes.length
|| group.merge.collectionSha256 !== group.collection.sha256
|| group.merge.changeIds.some(id => !changes.some(change => change.id === id))) throw workerConflict('原合并提案账本不连续,不能补造或重放。');
for (const change of changes) {
const target = collection.targets.find(file => file.path === change.path), proof = collection.workers.find(worker => worker.workerId === target?.workerId);
if (!target || !proof || change.taskId !== group.taskId || change.runId !== group.runId || change.status !== 'pending' || change.changeSetId
|| change.baseSha256 !== target.beforeSha256 || change.sha256 !== target.sha256 || workerHash(change.content) !== target.sha256
|| change.sourceBinding.workerId !== target.workerId || change.sourceBinding.resultArtifactId !== proof.artifactId
|| change.sourceBinding.resultSha256 !== proof.sha256 || change.sourceBinding.collectionSha256 !== group.collection.sha256) throw workerConflict('原父提案与封存子成果不一致,不能续封合并。');
}
return collection.targets.flatMap(file => changes.filter(change => change.path === file.path));
}
async recoverMerge(session, group) {
if (!group.merge) return;
const sets = [...this.store.core.change_set.values()].filter(set => set.collaborationBinding?.id === group.id || set.id === group.merge.changeSetId);
if (sets.length > 1) throw workerConflict('原协作存在多个父批次,不能猜测或重放。');
if (sets.length) {
const set = sets[0], binding = set.collaborationBinding;
if (set.sessionId !== session.id || set.taskId !== group.taskId || binding?.fingerprint !== group.fingerprint
|| binding.collectionArtifactId !== group.collection?.artifactId || binding.collectionSha256 !== group.collection?.sha256
|| !['prepared', 'completed'].includes(set.status) || set.requiresVerification
|| JSON.stringify(set.files.map(file => file.changeId)) !== JSON.stringify(group.merge.changeIds)) throw workerConflict('父批次仍需原恢复流程核对或只能保留现场结束。');
this.runtime.changeSetManager().snapshots(session, set);
group.merge.changeSetId = set.id; group.merge.fingerprint = set.fingerprint; group.merge.status = 'prepared';
} else {
const collection = await this.verifyCollection(session, group);
group.merge.changeIds = this.mergeProposals(session, group, collection).map(change => change.id); group.merge.status = 'proposing';
}
}
async verifyMerge(session, set) {
const linked = this.groups(session).find(group => group.merge?.changeSetId === set.id);
if (!set.collaborationBinding && !linked) return;
const group = this.own(session, set.collaborationBinding?.id ?? linked.id, set.collaborationBinding?.fingerprint ?? linked.fingerprint);
if (group.status !== 'merge_prepared' || group.requiresVerification || group.merge?.changeSetId !== set.id || group.merge.fingerprint !== set.fingerprint
|| set.collaborationBinding?.collectionArtifactId !== group.collection?.artifactId || set.collaborationBinding?.collectionSha256 !== group.collection?.sha256
|| JSON.stringify(set.files.map(file => file.changeId)) !== JSON.stringify(group.merge.changeIds)) throw workerConflict('父变更集与原协作/归集记录不一致,不能应用。');
const collection = await this.verifyCollection(session, group);
for (const file of set.files) {
const target = collection.targets.find(value => value.path === file.path), change = session.changes.find(value => value.id === file.changeId);
if (!target || target.sha256 !== file.sha256 || target.beforeSha256 !== file.baseSha256
|| change.sourceBinding?.collaborationId !== group.id || change.sourceBinding?.workerId !== target.workerId
|| change.sourceBinding?.collectionSha256 !== group.collection.sha256) throw workerConflict('父提案的原子成果绑定失效。');
}
}
async finalize(session, id, fingerprint) {
const group = this.own(session, id, fingerprint); this.assertIdle(session);
if (group.status !== 'merge_prepared' || !group.merge?.changeSetId) throw workerConflict('先审查应用原父变更集,再核对交付。');
const set = this.store.owned('change_set', group.merge.changeSetId, session.id);
if (set.status !== 'completed' || set.requiresVerification || set.fingerprint !== group.merge.fingerprint) throw workerConflict('原父变更集没有完整审查应用结果。');
this.runtime.changeSetManager().snapshots(session, set);
const inspection = await inspectProject(this.store.project(group.projectId)), check = verifiedCheck(this.store, session, inspection);
if (!check) throw workerConflict('合并后父工程需要当前源码的真实通过检查。');
for (const file of set.files) if (readText(this.store.project(group.projectId), file.path).sha256 !== file.sha256) throw workerConflict('父合并文件已变化,请先审查实际修复与重新归集。');
const delivery = [...this.store.core.delivery_job.values()].find(job => job.taskId === group.taskId && job.sessionId === session.id
&& job.status === 'completed' && !job.requiresVerification && job.commit === inspection.git.head && job.sourceFingerprint === inspection.sourceFingerprint);
if (!delivery || !delivery.reportArtifactId) throw workerConflict('父工程尚未完成当前成果的本地Git交付。');
const report = this.store.owned('artifact', delivery.reportArtifactId, session.id); this.store.artifactStore.read(report);
for (const child of group.children) await this.verifiedResult(group, child);
group.delivery = { jobId: delivery.id, commit: delivery.commit, checkJobId: check.id, reportArtifactId: report.id, reportSha256: report.sha256 };
group.status = 'completed'; group.finishedAt = at(); group.summary = '两个隔离子成果已审查合并,父工程重新检查通过并完成本地Git交付。';
session.status = 'completed'; this.save(session, group, 'completed'); return group;
}
async observe(group) {
const source = await this.workspaces.snapshot(this.store.project(group.projectId)), children = [];
for (const child of group.children) {
const workspace = this.store.core.workspace.get(child.workspaceId), worker = this.store.core.worker.get(child.id);
if (alive(workspace?.ownerPid) || alive(workspace?.gitPid) || alive(worker?.ownerPid)) throw workerConflict('历史所属PID仍存活,请先人工核对进程归属;工作台不会按历史PID停止进程。');
let inventory = null, inventoryError = null;
if (worker) {
this.baseline(this.store.session(child.sessionId), worker);
try { inventory = await this.inventory(this.store.project(child.projectId)); } catch (error) { inventoryError = error.message; }
}
const checks = [];
for (const job of [...this.store.core.check_job.values()].filter(value => value.taskId === child.taskId)) {
const processes = [job.currentCheck?.process, ...(job.unreportedProcesses ?? []), ...job.results.map(result => result.process)].filter(Boolean);
if (processes.some(processInfo => !processInfo.rootExited && alive(processInfo.pid))) throw workerConflict('原检查PID仍存活,结束状态需要人工核对;不能自动重试或按历史PID终止。');
if (job.requiresVerification || job.status === 'unknown') for (const processInfo of processes) {
const tree = await readOwnedProcessTree(processInfo);
if (tree.processes.length) throw workerConflict('原检查子进程PID仍存活:' + tree.processes.map(value => value.pid).join('、') + ';不能按历史PID自动终止或解除核对。');
}
checks.push({ id: job.id, status: job.status, requiresVerification: !!job.requiresVerification, processes,
results: job.results.map(result => ({ id: result.id, status: result.status, logArtifactId: result.logArtifactId,
logSha256: this.store.core.artifact.get(result.logArtifactId)?.sha256 ?? null })) });
}
const session = this.store.sessions.get(child.sessionId);
const tools = [...this.store.core.tool.values()].filter(value => value.taskId === child.taskId && value.requiresVerification).map(tool => {
const call = session?.providerMessages.flatMap(message => message.tool_calls ?? []).find(call => call.id === tool.callId);
const input = call?.function.arguments;
if (typeof input !== 'string' || workerHash(input) !== tool.argsSha256) throw workerConflict('原未知工具的输入哈希不一致,请保留现场。');
return { id: tool.id, callId: tool.callId, tool: tool.tool, state: tool.state, argsSha256: tool.argsSha256,
input: this.runtime.provider.redact(input).slice(0, 24000), inputTruncated: input.length > 24000, resultArtifactId: tool.resultArtifactId };
});
const changes = (session?.changes ?? []).filter(change => change.taskId === child.taskId).map(change => {
let sha256 = null, error = null;
try { const target = safePath(this.store.project(child.projectId), change.path, true); sha256 = fs.existsSync(target) ? readText(this.store.project(child.projectId), change.path).sha256 : null; }
catch (failure) { error = failure.message; }
return { id: change.id, path: change.path, status: change.status, baseSha256: change.baseSha256, proposedSha256: change.sha256, actualSha256: sha256, error };
});
children.push({ id: child.id, workspaceId: child.workspaceId, workspaceStatus: workspace?.status ?? 'absent',
workerStatus: worker?.status ?? 'absent', taskId: child.taskId, sessionId: child.sessionId, projectId: child.projectId,
inventoryFingerprint: inventory ? workerHash(inventory.files) : null, sourceFingerprint: inventory?.inspection.sourceFingerprint ?? null, inventoryError,
tools, checks, changes, changeSets: [...this.store.core.change_set.values()].filter(set => set.taskId === child.taskId).map(set => ({ id: set.id, status: set.status, requiresVerification: !!set.requiresVerification, observationFingerprint: set.observationFingerprint ?? null })) });
}
const parent = this.store.session(group.sessionId);
return { schemaVersion: 1, kind: 'worker-recovery-observation', collaborationId: group.id, groupFingerprint: group.fingerprint,
projectId: group.projectId, sessionId: group.sessionId, taskId: group.taskId, runId: group.runId, source: sourceIdentity(source), children,
parentChanges: parent.changes.filter(change => change.sourceBinding?.collaborationId === group.id).map(change => ({ id: change.id, path: change.path, status: change.status, sha256: change.sha256 })),
parentChangeSets: [...this.store.core.change_set.values()].filter(set => set.taskId === group.taskId).map(set => ({ id: set.id, status: set.status, requiresVerification: !!set.requiresVerification })),
note: '原输入及当前现场供用户核对;未报告的检查或工具结果保持未知,不补造完成、不执行模型或旧工具。' };
}
reconcile(session, id, fingerprint) {
const group = this.own(session, id, fingerprint);
if (!group.requiresVerification || group.status !== 'unknown') throw workerConflict('只有原结果未知的协作需要现场核对。');
return this.launch(session, group, 'reconciling', async signal => {
this.preparingGroupId = group.id;
try {
for (const child of group.children) {
const workspace = this.store.core.workspace.get(child.workspaceId);
if (workspace?.status === 'unknown') await this.workspaces.reconcile(session, workspace.id, workspace.fingerprint);
if (workspace?.status === 'ready' && !this.store.core.worker.has(child.id)) await this.initializeChild(group, child);
}
const observed = await this.observe(group); signal.throwIfAborted();
const artifact = this.store.artifactStore.write(session, this.store.owned('run', group.runId, session.id), observed, { kind: 'worker-recovery' });
this.store.core.artifact.set(artifact.id, artifact); group.evidence = { artifactId: artifact.id, sha256: artifact.sha256 };
group.summary = '原输入与现场核对已封存,请阅读后明确确认;不会自动发送模型、重放工具或补造检查通过。';
} catch (error) { group.summary = this.runtime.provider.redact(error.message ?? String(error)); }
group.status = 'unknown'; group.requiresVerification = true; this.save(session, group, 'observed'); return group;
});
}
readEvidence(session, group) {
this.own(session, group.id, null, { current: false });
const artifact = this.store.owned('artifact', group.evidence?.artifactId, session.id);
if (artifact.kind !== 'worker-recovery' || artifact.taskId !== group.taskId || artifact.runId !== group.runId || artifact.sha256 !== group.evidence.sha256) throw workerConflict('原核对工件不属于当前父协作。');
const record = JSON.parse(this.store.artifactStore.read(artifact));
if (record.groupFingerprint !== group.fingerprint || record.collaborationId !== group.id) throw workerConflict('核对记录与原协作不一致。');
return record;
}
async acknowledge(session, id, fingerprint, evidenceSha256, retain = false) {
const group = this.own(session, id, fingerprint);
if (group.status !== 'unknown' || !group.requiresVerification || typeof evidenceSha256 !== 'string' || evidenceSha256 !== group.evidence?.sha256) throw workerConflict('请先阅读原输入与现场核对工件,再提交原SHA256。');
const started = this.launch(session, group, 'reconciling', async signal => {
this.preparingGroupId = group.id;
try {
const original = this.readEvidence(session, group), current = await this.observe(group); signal.throwIfAborted();
if (JSON.stringify(original) !== JSON.stringify(current)) throw workerConflict('原输入或现场在核对后发生变化,请重新核对。');
const unresolvedSets = current.children.some(child => child.changeSets.some(set => set.requiresVerification)) || current.parentChangeSets.some(set => set.requiresVerification);
if (unresolvedSets) throw workerConflict('原文件批次仍待核对或回退,请先在所属任务记录处理实际原字节。');
const merged = group.merge?.changeSetId && this.store.core.change_set.get(group.merge.changeSetId)?.status === 'completed';
if (!retain && !merged && JSON.stringify(current.source) !== JSON.stringify(group.source.identity)) throw workerConflict('父来源已经变化,只能明确保留现场后重新规划。');
if (current.children.some(child => !['ready', 'absent', 'prepared', 'discarded', 'resolved_external'].includes(child.workspaceStatus))) throw workerConflict('原工作区仍需专门核对,不能开始子执行或结束恢复。');
if (!retain && current.children.some(child => ['discarded', 'resolved_external'].includes(child.workspaceStatus))) throw workerConflict('原工作区没有核对为可执行,只能明确保留现场结束。');
if (!retain) await this.recoverMerge(session, group);
for (const child of group.children) {
const worker = this.store.core.worker.get(child.id); if (!worker) continue;
const childSession = this.store.session(child.sessionId);
for (const tool of this.store.core.tool.values()) if (tool.taskId === child.taskId && tool.requiresVerification) {
tool.originalState = tool.state; tool.state = 'resolved_external'; tool.requiresVerification = false;
tool.review = { source: 'user', evidenceSha256, reviewedAt: at(), result: 'unknown-preserved' };
const run = this.store.core.run.get(tool.runId);
if (run) {
run.checkpoint.requiresVerification = run.checkpoint.requiresVerification.filter(id => id !== tool.id);
run.checkpoint.pendingToolIds = run.checkpoint.pendingToolIds.filter(id => id !== tool.id);
run.checkpoint.reviewedUnknownToolIds ??= []; if (!run.checkpoint.reviewedUnknownToolIds.includes(tool.id)) run.checkpoint.reviewedUnknownToolIds.push(tool.id);
}
}
for (const job of this.store.core.check_job.values()) if (job.taskId === child.taskId && (job.requiresVerification || job.status === 'unknown')) {
job.originalStatus = job.status; job.status = 'resolved_external'; job.requiresVerification = false; job.review = { evidenceSha256, reviewedAt: at() };
this.store.core.task.get(child.taskId).verification = { status: 'needs_checks', checkJobId: job.id };
}
if (worker.requiresVerification || ['unknown', 'running', 'stopping'].includes(worker.status)) {
worker.requiresVerification = false; worker.status = retain ? 'resolved_external' : 'paused'; worker.ownerPid = null;
worker.summary = '用户已核对原未知输入与现场;原结果保持未知,重新检查需要新计划与审批。';
childSession.providerMessages = repairToolPairs(childSession.providerMessages, callId => this.store.savedToolResult(childSession.id, callId)).messages;
childSession.providerMessages.push({ role: 'user', content: worker.summary + ' 核对记录SHA256:' + evidenceSha256 });
childSession.status = childSession.changes.some(change => ['pending', 'conflict'].includes(change.status)) ? 'needs_review' : 'paused';
this.store.putRecord('worker', childSession, worker, 'worker.reviewed_unknown');
}
}
group.requiresVerification = false;
if (retain) {
this.retain(session, group);
group.status = 'resolved_external'; group.finishedAt = at();
} else group.status = merged || group.merge?.changeSetId ? 'merge_prepared'
: group.merge ? 'collected'
: group.children.some(child => !this.store.core.worker.has(child.id)) ? 'partially_prepared'
: group.children.every(child => this.store.core.worker.get(child.id).status === 'completed') ? 'ready_to_collect'
: group.children.some(child => this.store.session(child.sessionId).status === 'needs_review') ? 'awaiting_review' : group.startedAt ? 'paused' : 'ready';
group.summary = retain ? '用户已明确保留原工作区、任务与未知结果,结束协作;没有声明交付成功。' : '原未知结果已按用户核对保留,可以显式继续;累计预算和原时限保持。';
session.status = 'paused'; this.save(session, group, 'reviewed_unknown'); return group;
} catch (error) { group.status = 'unknown'; group.requiresVerification = true; this.save(session, group, 'review_failed'); throw error; }
});
return started.promise;
}
async stopParent(sessionId) {
const running = [...this.active.values()].filter(value => value.sessionId === sessionId && value.controller);
for (const value of running) {
@@ -323,11 +663,36 @@ export class WorkerManager {
await Promise.allSettled(value.group.children.map(child => this.runtime.stop(child.sessionId)));
await value.promise;
}
for (const group of this.store.core.collaboration.values()) if (group.sessionId === sessionId && !COLLABORATION_CLOSED.has(group.status)
&& group.children.some(child => this.childActive(child.sessionId))) {
await Promise.allSettled(group.children.filter(child => this.store.sessions.has(child.sessionId)).map(child => this.runtime.stop(child.sessionId)));
group.summary = '父任务已等待所属子执行与检查结束,已完成记录保留。'; this.save(this.store.session(sessionId), group, 'stopped');
}
}
async stopAll() { await Promise.all([...new Set([...this.active.values()].map(value => value.sessionId).concat([...this.store.core.collaboration.values()]
.filter(group => !COLLABORATION_CLOSED.has(group.status) && group.children.some(child => this.childActive(child.sessionId))).map(group => group.sessionId)))].map(id => this.stopParent(id))); }
retain(session, group) {
const sessions = [session, ...group.children.flatMap(child => this.store.sessions.has(child.sessionId) ? [this.store.session(child.sessionId)] : [])];
for (const child of group.children) {
const workspace = this.store.core.workspace.get(child.workspaceId);
if (workspace?.status === 'prepared' && !workspace.creationAttempted) this.workspaces.discard(session, workspace.id, workspace.fingerprint);
}
const manager = new ChangeSetManager(this.store, { projectBusy: (projectId, exceptId) => this.runtime.projectHasActivity(projectId, exceptId, { excludeGroupId: group.id }) });
for (const owned of sessions) {
for (const set of this.store.core.change_set.values()) if (set.sessionId === owned.id && set.taskId === owned.taskId && !set.attemptedAt && ['prepared', 'stale'].includes(set.status)) {
manager.snapshots(owned, set); manager.discard(owned, set.id, set.fingerprint);
}
for (const change of owned.changes) if ((owned !== session || change.sourceBinding?.collaborationId === group.id) && ['pending', 'conflict'].includes(change.status) && !change.changeSetId) change.status = 'rejected';
const worker = workerForProject(this.store, owned.projectId);
if (worker && worker.status !== 'completed') { worker.status = 'resolved_external'; worker.requiresVerification = false; worker.ownerPid = null; }
owned.status = 'paused'; this.store.save(owned, { type: 'worker.retained' });
}
}
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('协作仍在执行、待核对或已有合并审查,请先处理原记录。');
if (this.runtime.projectHasActivity(group.projectId) || group.requiresVerification || group.children.some(child => this.store.core.worker.get(child.id)?.requiresVerification)
|| [...this.store.core.change_set.values()].some(set => (set.taskId === group.taskId || group.children.some(child => child.taskId === set.taskId)) && set.requiresVerification)) throw workerConflict('协作仍在执行或原批次待核对,请先处理原记录。');
this.retain(session, group);
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;