harness-engineering-agent 0.1.0

package/dist/controller/task-executor.js

@@ -0,0 +1,751 @@
+import { AgentResultSchema } from "../domain/index.js";
+import { VerificationExecutionStatus } from "../verification/index.js";
+import { createGitWorkspaceAdapter, createGitWorktreeAdapter } from "../workspace/index.js";
+import { createEvidence } from "./evidence-factory.js";
+import { resolveFailureAnalysis } from "./failure-analysis.js";
+import { createAcceptanceFailure, createContextGapFailure, createImplementationFailure, createMergeConflictFailure, createModelFailure, createScopeDriftFailure, createVerificationEnvironmentFailure, } from "./failure-factory.js";
+import { orderTasks } from "./graph-validator.js";
+import { runRepairLoop } from "./repair-loop.js";
+import { consumeBudget, parsePlannedRun, RunBudgetExceededError, withParts, withPlannedStatus, withTask, } from "./run-state.js";
+import { readAcceptanceOutput, readFailureAnalyzerOutput, readVerifierOutput, readWorkerOutput, } from "./task-agent-output.js";
+import { isAllowedPath } from "./task-paths.js";
+import { persistTaskFailed, persistTaskRetry } from "./task-retry.js";
+import { createWorktreeScheduler } from "./worktree-scheduler.js";
+export const createTaskExecutor = (input) => {
+    const workspaceAdapter = input.options.workspaceAdapter ?? createGitWorkspaceAdapter(input.options.workingDirectory);
+    const workspaceAdapterFactory = input.options.workspaceAdapterFactory ?? createGitWorkspaceAdapter;
+    const analyzeFailure = async (params) => {
+        const analysisResult = await readFailureAnalyzerOutput({
+            input,
+            run: params.run,
+            task: params.task,
+            attempt: params.attempt,
+            failure: params.failure,
+            evidence: params.evidence,
+        });
+        if (analysisResult.kind === "failed") {
+            const failedRun = withParts(withTask(params.run, { ...params.task, status: "failed" }), {
+                evidence: params.run.evidence,
+                failures: [...params.run.failures, params.failure, analysisResult.failure],
+                agentResults: params.run.agentResults,
+                workspace: params.run.workspace,
+            });
+            await input.writer.persist(withPlannedStatus(failedRun, "failed"), input.writer.createEvent(params.run.runId, "task.failed", {
+                taskId: params.task.taskId,
+                attempt: params.attempt,
+                failureId: analysisResult.failure.failureId,
+            }));
+            return {
+                run: withPlannedStatus(failedRun, "failed"),
+                repairRequested: false,
+                failure: analysisResult.failure,
+            };
+        }
+        const resolution = resolveFailureAnalysis({
+            options: input.options,
+            run: params.run,
+            task: params.task,
+            attempt: params.attempt,
+            sourceFailure: params.failure,
+            evidence: params.evidence,
+            analysis: analysisResult.output,
+        });
+        const nextTask = { ...params.task, status: resolution.taskStatus };
+        const nextRun = withParts(withTask(params.run, nextTask), {
+            evidence: params.run.evidence,
+            failures: [...params.run.failures, params.failure, resolution.failure],
+            agentResults: [...params.run.agentResults, resolution.result],
+            workspace: params.run.workspace,
+        });
+        await input.writer.persist(withPlannedStatus(nextRun, resolution.nextStatus), input.writer.createEvent(params.run.runId, resolution.eventType, resolution.eventPayload));
+        return {
+            run: withPlannedStatus(nextRun, resolution.nextStatus),
+            repairRequested: resolution.eventType === "task.repair.requested",
+            failure: resolution.failure,
+        };
+    };
+    const verifyAndAccept = async (params) => {
+        const verifierOutput = await readVerifierOutput({
+            input,
+            run: params.run,
+            task: params.task,
+            attempt: params.attempt,
+            evidence: params.evidence,
+        });
+        if (verifierOutput.kind === "failed") {
+            const resolution = await analyzeFailure({
+                run: params.run,
+                task: params.task,
+                attempt: params.attempt,
+                failure: verifierOutput.failure,
+                evidence: params.evidence,
+            });
+            return resolution.run;
+        }
+        if (verifierOutput.output.status !== "passed") {
+            const verifierFailure = verifierOutput.output.status === "evidence_gap"
+                ? createContextGapFailure({
+                    failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-verifier-evidence-gap`),
+                    runId: params.run.runId,
+                    taskId: params.task.taskId,
+                    relatedEvidenceIds: params.evidence.map((item) => item.evidenceId),
+                    summary: verifierOutput.output.summary,
+                    detail: verifierOutput.output.missingEvidenceKinds.join(", "),
+                    recoveryPlan: "Collect the missing verification evidence before retrying.",
+                    missingContext: verifierOutput.output.missingEvidenceKinds,
+                })
+                : createImplementationFailure({
+                    failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-verifier`),
+                    runId: params.run.runId,
+                    taskId: params.task.taskId,
+                    ...(params.evidence[0] === undefined
+                        ? {}
+                        : { failingEvidenceId: params.evidence[0].evidenceId }),
+                    summary: verifierOutput.output.summary,
+                    detail: verifierOutput.output.status,
+                    recoveryPlan: "Retry the task with fresh evidence.",
+                });
+            const resolution = await analyzeFailure({
+                run: params.run,
+                task: params.task,
+                attempt: params.attempt,
+                failure: verifierFailure,
+                evidence: params.evidence,
+            });
+            return resolution.run;
+        }
+        const workerResult = AgentResultSchema.parse({
+            schemaVersion: "1.0.0",
+            resultId: input.options.ids.createAgentResultId(`worker-${params.task.taskId}-${params.attempt}`),
+            runId: params.run.runId,
+            taskId: params.task.taskId,
+            role: "worker",
+            status: "completed",
+            summary: `Task ${params.task.taskId} completed`,
+            evidenceIds: params.evidence.map((item) => item.evidenceId),
+            changedPaths: params.changedPaths,
+        });
+        const verifierResult = AgentResultSchema.parse({
+            schemaVersion: "1.0.0",
+            resultId: input.options.ids.createAgentResultId(`verifier-${params.task.taskId}-${params.attempt}`),
+            runId: params.run.runId,
+            taskId: params.task.taskId,
+            role: "verifier",
+            status: "completed",
+            summary: verifierOutput.output.summary,
+            evidenceIds: params.evidence.map((item) => item.evidenceId),
+            changedPaths: [],
+        });
+        const acceptedRun = withParts(params.run, {
+            evidence: params.run.evidence,
+            failures: params.run.failures,
+            agentResults: [...params.run.agentResults, workerResult, verifierResult],
+            workspace: params.run.workspace,
+        });
+        const accepting = withPlannedStatus(acceptedRun, "verifying");
+        await input.writer.persist(accepting, input.writer.createEvent(params.run.runId, "task.acceptance.started", {
+            taskId: params.task.taskId,
+            attempt: params.attempt,
+        }));
+        const acceptanceOutput = await readAcceptanceOutput({
+            input,
+            run: accepting,
+            task: params.task,
+            attempt: params.attempt,
+            evidence: params.evidence,
+        });
+        if (acceptanceOutput.kind === "failed") {
+            const resolution = await analyzeFailure({
+                run: accepting,
+                task: params.task,
+                attempt: params.attempt,
+                failure: acceptanceOutput.failure,
+                evidence: params.evidence,
+            });
+            return resolution.run;
+        }
+        if (acceptanceOutput.output.status !== "accepted") {
+            const acceptanceFailure = acceptanceOutput.output.status === "evidence_gap"
+                ? createContextGapFailure({
+                    failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-acceptance-evidence-gap`),
+                    runId: params.run.runId,
+                    taskId: params.task.taskId,
+                    relatedEvidenceIds: params.evidence.map((item) => item.evidenceId),
+                    summary: acceptanceOutput.output.summary,
+                    detail: acceptanceOutput.output.missingEvidenceKinds.join(", "),
+                    recoveryPlan: "Collect the missing acceptance evidence before completing.",
+                    missingContext: acceptanceOutput.output.missingEvidenceKinds,
+                })
+                : params.evidence[0] === undefined
+                    ? createContextGapFailure({
+                        failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-acceptance-missing-evidence`),
+                        runId: params.run.runId,
+                        taskId: params.task.taskId,
+                        relatedEvidenceIds: [],
+                        summary: acceptanceOutput.output.summary,
+                        detail: "Acceptance reported failed but no deterministic evidence exists.",
+                        recoveryPlan: "Capture real deterministic evidence before processing acceptance failure.",
+                        missingContext: ["acceptance-evidence"],
+                    })
+                    : createAcceptanceFailure({
+                        failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-acceptance`),
+                        runId: params.run.runId,
+                        taskId: params.task.taskId,
+                        failingEvidenceId: params.evidence[0].evidenceId,
+                        summary: acceptanceOutput.output.summary,
+                        detail: acceptanceOutput.output.status,
+                        recoveryPlan: "Address the acceptance findings before completing the task.",
+                    });
+            const resolution = await analyzeFailure({
+                run: accepting,
+                task: params.task,
+                attempt: params.attempt,
+                failure: acceptanceFailure,
+                evidence: params.evidence,
+            });
+            return resolution.run;
+        }
+        const completedTask = {
+            ...params.task,
+            status: "completed",
+            evidenceRefs: [
+                ...params.task.evidenceRefs,
+                ...params.evidence.map((item) => item.evidenceId),
+            ],
+        };
+        const acceptanceResult = AgentResultSchema.parse({
+            schemaVersion: "1.0.0",
+            resultId: input.options.ids.createAgentResultId(`acceptance-${params.task.taskId}-${params.attempt}`),
+            runId: params.run.runId,
+            taskId: params.task.taskId,
+            role: "acceptance",
+            status: "completed",
+            summary: acceptanceOutput.output.summary,
+            evidenceIds: params.evidence.map((item) => item.evidenceId),
+            changedPaths: [],
+        });
+        const currentRun = withPlannedStatus(withParts(withTask(accepting, completedTask), {
+            evidence: accepting.evidence,
+            failures: accepting.failures,
+            agentResults: [...accepting.agentResults, acceptanceResult],
+            workspace: accepting.workspace,
+        }), "executing");
+        await input.writer.persist(currentRun, input.writer.createEvent(params.run.runId, "task.completed", {
+            taskId: params.task.taskId,
+            attempt: params.attempt,
+        }));
+        return currentRun;
+    };
+    const handleRepairRequest = async (params) => {
+        if (params.task.retryBudget.maxRepairAttempts <= 0) {
+            return persistTaskFailed({
+                run: params.run,
+                failure: createImplementationFailure({
+                    failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-repair-budget`),
+                    runId: params.run.runId,
+                    taskId: params.task.taskId,
+                    summary: "Repair budget exhausted before automatic repair could begin.",
+                    detail: `task ${params.task.taskId} has maxRepairAttempts=${params.task.retryBudget.maxRepairAttempts}`,
+                    recoveryPlan: "Increase the repair budget or resolve the failure manually.",
+                }),
+                task: params.task,
+                writer: input.writer,
+            });
+        }
+        const repaired = await runRepairLoop({
+            executor: input,
+            run: params.run,
+            task: params.task,
+            attempt: params.attempt,
+            failure: params.failure,
+            evidence: params.evidence,
+            analyzeFailure,
+        });
+        if (repaired.kind === "terminal") {
+            return repaired.run;
+        }
+        return verifyAndAccept({
+            run: repaired.run,
+            task: params.task,
+            attempt: params.attempt,
+            evidence: repaired.evidence,
+            changedPaths: repaired.changedPaths,
+        });
+    };
+    const runTask = async (run, task, executionCwd = input.options.workingDirectory) => {
+        const taskWorkspaceAdapter = executionCwd === input.options.workingDirectory
+            ? workspaceAdapter
+            : workspaceAdapterFactory(executionCwd);
+        const maxAttempts = Math.max(task.retryBudget.maxAttempts, 1);
+        let currentRun = run;
+        let lastFailure;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            try {
+                currentRun = claimTaskAttemptBudget(currentRun, attempt);
+            }
+            catch (error) {
+                if (!(error instanceof RunBudgetExceededError)) {
+                    throw error;
+                }
+                lastFailure = createImplementationFailure({
+                    failureId: input.options.ids.createFailureId(`${task.taskId}-${attempt}-budget`),
+                    runId: run.runId,
+                    taskId: task.taskId,
+                    summary: `${error.budget} budget exhausted.`,
+                    detail: error.message,
+                    recoveryPlan: "Request a manual decision or expand the relevant budget.",
+                });
+                break;
+            }
+            currentRun = withTask(currentRun, { ...task, status: "in_progress" });
+            await input.writer.persist(withPlannedStatus(currentRun, "executing"), input.writer.createEvent(run.runId, "task.started", { taskId: task.taskId, attempt }));
+            const workspaceBeforeTask = await taskWorkspaceAdapter.captureCurrentState();
+            const workerOutput = await readWorkerOutput({
+                input,
+                run,
+                task,
+                attempt,
+                workingDirectory: executionCwd,
+            });
+            const workspaceAfterWorker = await taskWorkspaceAdapter.captureCurrentState();
+            if (workerOutput.kind === "failed") {
+                lastFailure = workerOutput.failure;
+            }
+            else if (!workerOutput.output.changedPaths.every((path) => isAllowedPath(path, task.allowedPaths))) {
+                lastFailure = createModelFailure({
+                    failureId: input.options.ids.createFailureId(`${task.taskId}-${attempt}-worker-scope`),
+                    runId: run.runId,
+                    taskId: task.taskId,
+                    provider: "worker",
+                    summary: "Worker reported paths outside the allowed task scope.",
+                    detail: workerOutput.output.changedPaths.join(", "),
+                    recoveryPlan: "Retry with a constrained task scope and bounded output.",
+                });
+            }
+            else {
+                const verifying = withPlannedStatus(currentRun, "verifying");
+                await input.writer.persist(verifying, input.writer.createEvent(run.runId, "task.verification.started", {
+                    taskId: task.taskId,
+                    attempt,
+                }));
+                let verificationResult;
+                try {
+                    verificationResult = await input.options.verificationRunner.run({
+                        verificationCommands: task.verificationPlan,
+                        defaultWorkingDirectory: executionCwd,
+                    });
+                }
+                catch (error) {
+                    if (!(error instanceof Error)) {
+                        throw error;
+                    }
+                    lastFailure = createVerificationEnvironmentFailure({
+                        failureId: input.options.ids.createFailureId(`${task.taskId}-${attempt}-verification-environment`),
+                        runId: run.runId,
+                        taskId: task.taskId,
+                        commandName: task.verificationPlan[0]?.name ?? "verification",
+                        detail: error.message,
+                    });
+                }
+                const workspaceAfterVerification = await taskWorkspaceAdapter.captureCurrentState();
+                if (currentRun.workspace.git.mode === "git") {
+                    const workspaceAssessment = await taskWorkspaceAdapter.assessTaskChanges({
+                        baseline: currentRun.workspace.git,
+                        before: workspaceBeforeTask,
+                        afterWorker: workspaceAfterWorker,
+                        afterVerification: workspaceAfterVerification,
+                        claimedChangedPaths: workerOutput.output.changedPaths,
+                        allowedPaths: task.allowedPaths,
+                    });
+                    if (workspaceAssessment.status === "paused") {
+                        const workspaceFailure = createScopeDriftFailure({
+                            failureId: input.options.ids.createFailureId(`${task.taskId}-${attempt}-workspace-drift`),
+                            runId: run.runId,
+                            taskId: task.taskId,
+                            driftedPaths: workspaceAssessment.driftedPaths,
+                            summary: "Workspace protection paused the task after git baseline drift.",
+                            detail: workspaceAssessment.detail,
+                            recoveryPlan: "Inspect external or out-of-scope changes before resuming the task.",
+                        });
+                        const pausedRun = withPlannedStatus(withParts(withTask(currentRun, { ...task, status: "paused" }), {
+                            evidence: currentRun.evidence,
+                            failures: [...currentRun.failures, workspaceFailure],
+                            agentResults: currentRun.agentResults,
+                            workspace: currentRun.workspace,
+                        }), "paused");
+                        await input.writer.persist(pausedRun, input.writer.createEvent(run.runId, "task.paused.external_change", {
+                            taskId: task.taskId,
+                            attempt,
+                            changedPaths: workspaceAssessment.actualChangedPaths,
+                            driftedPaths: workspaceAssessment.driftedPaths,
+                        }));
+                        return pausedRun;
+                    }
+                    currentRun = withParts(currentRun, {
+                        evidence: currentRun.evidence,
+                        failures: currentRun.failures,
+                        agentResults: currentRun.agentResults,
+                        workspace: { git: workspaceAssessment.nextWorkspace },
+                    });
+                }
+                if (verificationResult === undefined) {
+                    const resolution = await analyzeFailure({
+                        run: currentRun,
+                        task,
+                        attempt,
+                        failure: lastFailure ??
+                            createImplementationFailure({
+                                failureId: input.options.ids.createFailureId(`${task.taskId}-${attempt}-verification`),
+                                runId: run.runId,
+                                taskId: task.taskId,
+                                summary: "Verification did not produce a usable result.",
+                                detail: "verificationResult was undefined",
+                                recoveryPlan: "Retry the task with a stable verification environment.",
+                            }),
+                        evidence: [],
+                    });
+                    currentRun = resolution.run;
+                    if (resolution.repairRequested &&
+                        currentRun.status === "executing" &&
+                        task.repairEnabled) {
+                        return handleRepairRequest({
+                            run: currentRun,
+                            task,
+                            attempt,
+                            failure: resolution.failure,
+                            evidence: [],
+                        });
+                    }
+                }
+                else if (verificationResult.records.length === 0) {
+                    lastFailure = createContextGapFailure({
+                        failureId: input.options.ids.createFailureId(`${task.taskId}-${attempt}-verification-empty`),
+                        runId: run.runId,
+                        taskId: task.taskId,
+                        relatedEvidenceIds: [],
+                        summary: "Deterministic verification produced no evidence records.",
+                        detail: "At least one deterministic verification record is required before verifier or acceptance can run.",
+                        recoveryPlan: "Re-run deterministic verification and capture at least one real evidence record.",
+                        missingContext: ["verification-record"],
+                    });
+                    const resolution = await analyzeFailure({
+                        run: currentRun,
+                        task,
+                        attempt,
+                        failure: lastFailure,
+                        evidence: [],
+                    });
+                    currentRun = resolution.run;
+                    if (resolution.repairRequested &&
+                        currentRun.status === "executing" &&
+                        task.repairEnabled) {
+                        return handleRepairRequest({
+                            run: currentRun,
+                            task,
+                            attempt,
+                            failure: resolution.failure,
+                            evidence: [],
+                        });
+                    }
+                }
+                else {
+                    const evidence = verificationResult.records.map((record, index) => createEvidence({
+                        ids: input.options.ids,
+                        runId: run.runId,
+                        task,
+                        record,
+                        label: `${task.taskId}-${attempt}-${index}`,
+                        changedPaths: workerOutput.output.changedPaths,
+                        acceptanceCriterionIds: paramsAcceptanceCriterionIds(run),
+                    }));
+                    currentRun = withParts(currentRun, {
+                        evidence: [...currentRun.evidence, ...evidence],
+                        failures: currentRun.failures,
+                        agentResults: currentRun.agentResults,
+                        workspace: currentRun.workspace,
+                    });
+                    const deterministicPassed = verificationResult.records.every((record) => record.status === VerificationExecutionStatus.passed);
+                    if (!deterministicPassed) {
+                        lastFailure = createImplementationFailure({
+                            failureId: input.options.ids.createFailureId(`${task.taskId}-${attempt}-verification`),
+                            runId: run.runId,
+                            taskId: task.taskId,
+                            ...(evidence[0] === undefined ? {} : { failingEvidenceId: evidence[0].evidenceId }),
+                            summary: "Verification command failed after replay.",
+                            detail: "A deterministic verification command failed or timed out.",
+                            recoveryPlan: "Retry the task within its bounded attempt budget.",
+                        });
+                        const resolution = await analyzeFailure({
+                            run: currentRun,
+                            task,
+                            attempt,
+                            failure: lastFailure,
+                            evidence,
+                        });
+                        currentRun = resolution.run;
+                        if (resolution.repairRequested &&
+                            currentRun.status === "executing" &&
+                            task.repairEnabled) {
+                            return handleRepairRequest({
+                                run: currentRun,
+                                task,
+                                attempt,
+                                failure: resolution.failure,
+                                evidence,
+                            });
+                        }
+                    }
+                    else {
+                        const finalized = await verifyAndAccept({
+                            run: currentRun,
+                            task,
+                            attempt,
+                            evidence,
+                            changedPaths: workerOutput.output.changedPaths,
+                        });
+                        if (finalized.status !== "executing") {
+                            return finalized;
+                        }
+                        currentRun = finalized;
+                        const finalizedTask = currentRun.taskGraph.tasks.find((candidate) => candidate.taskId === task.taskId);
+                        if (finalizedTask?.status === "completed") {
+                            return currentRun;
+                        }
+                        lastFailure = currentRun.failures.at(-1);
+                    }
+                }
+            }
+            if (currentRun.status !== "executing") {
+                return currentRun;
+            }
+            if (attempt < maxAttempts && lastFailure !== undefined) {
+                currentRun = await persistTaskRetry({
+                    run: currentRun,
+                    failure: lastFailure,
+                    task,
+                    attempt,
+                    writer: input.writer,
+                });
+            }
+        }
+        const failure = lastFailure ??
+            createImplementationFailure({
+                failureId: input.options.ids.createFailureId(`${task.taskId}-exhausted`),
+                runId: run.runId,
+                taskId: task.taskId,
+                summary: "Task exhausted its retry budget.",
+                detail: "No successful worker/verifier cycle completed before the retry budget expired.",
+                recoveryPlan: "Increase retry budget or fix the underlying implementation.",
+            });
+        return persistTaskFailed({
+            run: currentRun,
+            failure,
+            task,
+            writer: input.writer,
+        });
+    };
+    const runTasks = async (run) => {
+        let currentRun = run;
+        const orderedTasks = orderTasks(currentRun.taskGraph);
+        const parallelResult = await runParallelReadyBatch(currentRun, orderedTasks);
+        if (parallelResult.kind === "paused") {
+            return parallelResult.run;
+        }
+        if (parallelResult.kind === "completed") {
+            currentRun = parallelResult.run;
+        }
+        for (const task of orderedTasks) {
+            const currentTask = currentRun.taskGraph.tasks.find((candidate) => candidate.taskId === task.taskId);
+            if (currentTask?.status === "completed") {
+                continue;
+            }
+            currentRun = await runTask(currentRun, task);
+            if (currentRun.status !== "executing") {
+                return currentRun;
+            }
+        }
+        const completed = withPlannedStatus(currentRun, "completed");
+        await input.writer.persist(completed, input.writer.createEvent(completed.runId, "run.completed", { status: "completed" }));
+        return completed;
+    };
+    return { runTasks };
+    async function runParallelReadyBatch(run, orderedTasks) {
+        if (run.workspace.git.mode !== "git") {
+            return { kind: "skipped" };
+        }
+        const completedTaskIds = new Set(orderedTasks.filter((task) => task.status === "completed").map((task) => task.taskId));
+        const readyTasks = orderedTasks.filter((task) => task.status !== "completed" &&
+            task.dependencies.every((dependency) => completedTaskIds.has(dependency)));
+        if (readyTasks.length < 2) {
+            return { kind: "skipped" };
+        }
+        const childRuns = [];
+        const scheduler = createWorktreeScheduler(input.options.worktreeAdapter ??
+            createGitWorktreeAdapter({ repositoryRoot: input.options.workingDirectory }));
+        const result = await scheduler.runEligibleBatch({
+            mainWorkspaceCwd: input.options.workingDirectory,
+            tasks: readyTasks,
+            completedTaskIds,
+            async executeTask({ task, cwd }) {
+                const childRun = await runTask(run, task, cwd);
+                childRuns.push(childRun);
+                const completedTask = childRun.taskGraph.tasks.find((candidate) => candidate.taskId === task.taskId);
+                if (childRun.status !== "executing" || completedTask?.status !== "completed") {
+                    throw new Error(`parallel child task ${task.taskId} did not complete cleanly: run=${childRun.status}, task=${completedTask?.status ?? "missing"}`);
+                }
+                return {
+                    changedPaths: latestWorkerChangedPaths(childRun, task),
+                    evidenceRefs: completedTask?.evidenceRefs ?? [],
+                };
+            },
+            async runIntegrationVerification(cwd) {
+                const commands = readyTasks.flatMap((task) => task.verificationPlan.filter((command) => command.scope === "integration"));
+                if (commands.length === 0) {
+                    return { passed: true, detail: "no integration verification configured" };
+                }
+                const verification = await input.options.verificationRunner.run({
+                    verificationCommands: commands,
+                    defaultWorkingDirectory: cwd,
+                });
+                const passed = verification.records.every((record) => record.status === VerificationExecutionStatus.passed);
+                return { passed, detail: passed ? "passed" : "integration verification failed" };
+            },
+        });
+        switch (result.kind) {
+            case "serial-fallback":
+                return { kind: "skipped" };
+            case "parallel-completed":
+                return { kind: "completed", run: mergeChildRuns(run, childRuns) };
+            case "merge-conflict":
+                return { kind: "paused", run: await persistMergeConflict(run, result.conflict.detail) };
+            case "execution-failed":
+                return { kind: "paused", run: await persistIntegrationFailure(run, result.detail) };
+            case "integration-failed":
+                return { kind: "paused", run: await persistIntegrationFailure(run, result.detail) };
+            case "cleanup-failed":
+                return { kind: "paused", run: await persistCleanupFailure(run, result) };
+        }
+    }
+    function latestWorkerChangedPaths(run, task) {
+        const result = run.agentResults.findLast((candidate) => candidate.role === "worker" && candidate.taskId === task.taskId);
+        return result?.status === "completed" ? result.changedPaths : [];
+    }
+    function mergeChildRuns(parentRun, childRuns) {
+        let merged = parentRun;
+        for (const childRun of childRuns) {
+            for (const task of childRun.taskGraph.tasks) {
+                const parentTask = merged.taskGraph.tasks.find((candidate) => candidate.taskId === task.taskId);
+                if (parentTask !== undefined && task.status === "completed") {
+                    merged = withTask(merged, task);
+                }
+            }
+            merged = withParts(merged, {
+                evidence: uniqueById([...merged.evidence, ...childRun.evidence], (item) => item.evidenceId),
+                failures: uniqueById([...merged.failures, ...childRun.failures], (item) => item.failureId),
+                agentResults: uniqueById([...merged.agentResults, ...childRun.agentResults], (item) => item.resultId),
+                workspace: childRun.workspace,
+            });
+        }
+        return merged;
+    }
+    async function persistMergeConflict(run, detail) {
+        const task = firstIncompleteTask(run);
+        const failure = createMergeConflictFailure({
+            failureId: input.options.ids.createFailureId(`${task.taskId}-worktree-merge-conflict`),
+            runId: run.runId,
+            taskId: task.taskId,
+            conflictingPaths: ["worktree-merge"],
+            summary: "Worktree merge conflict paused parallel execution.",
+            detail,
+            recoveryPlan: "Inspect retained task worktrees and resolve the merge manually.",
+        });
+        const paused = withPlannedStatus(withParts(withTask(run, { ...task, status: "paused" }), {
+            evidence: run.evidence,
+            failures: [...run.failures, failure],
+            agentResults: run.agentResults,
+            workspace: run.workspace,
+        }), "paused");
+        await input.writer.persist(paused, input.writer.createEvent(run.runId, "task.paused.merge_conflict", {
+            taskId: task.taskId,
+            failureId: failure.failureId,
+        }));
+        return paused;
+    }
+    async function persistIntegrationFailure(run, detail) {
+        const task = firstIncompleteTask(run);
+        const failure = createVerificationEnvironmentFailure({
+            failureId: input.options.ids.createFailureId(`${task.taskId}-worktree-integration`),
+            runId: run.runId,
+            taskId: task.taskId,
+            commandName: "integration verification",
+            detail,
+        });
+        const paused = withPlannedStatus(withParts(withTask(run, { ...task, status: "paused" }), {
+            evidence: run.evidence,
+            failures: [...run.failures, failure],
+            agentResults: run.agentResults,
+            workspace: run.workspace,
+        }), "paused");
+        await input.writer.persist(paused, input.writer.createEvent(run.runId, "task.paused.integration_verification", {
+            taskId: task.taskId,
+            failureId: failure.failureId,
+        }));
+        return paused;
+    }
+    async function persistCleanupFailure(run, result) {
+        const task = firstIncompleteTask(run);
+        const detail = result.cleanupFailures
+            .map((failure) => `${failure.taskId}:${failure.path}:${failure.detail}`)
+            .join("\n");
+        const failure = createVerificationEnvironmentFailure({
+            failureId: input.options.ids.createFailureId(`${task.taskId}-worktree-cleanup`),
+            runId: run.runId,
+            taskId: task.taskId,
+            commandName: "worktree cleanup",
+            detail,
+        });
+        const paused = withPlannedStatus(withParts(withTask(run, { ...task, status: "paused" }), {
+            evidence: run.evidence,
+            failures: [...run.failures, failure],
+            agentResults: run.agentResults,
+            workspace: run.workspace,
+        }), "paused");
+        await input.writer.persist(paused, input.writer.createEvent(run.runId, "task.paused.cleanup_failed", {
+            taskId: task.taskId,
+            failureId: failure.failureId,
+            retainedWorktrees: result.retainedWorktrees.map((lease) => lease.path),
+            cleanupReceipts: result.cleanupReceipts,
+        }));
+        return paused;
+    }
+};
+const uniqueById = (items, getId) => {
+    const seen = new Set();
+    const unique = [];
+    for (const item of items) {
+        const id = getId(item);
+        if (seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        unique.push(item);
+    }
+    return unique;
+};
+const firstIncompleteTask = (run) => {
+    const task = run.taskGraph.tasks.find((candidate) => candidate.status !== "completed");
+    if (task === undefined) {
+        throw new TypeError("expected at least one incomplete task");
+    }
+    return task;
+};
+const claimTaskAttemptBudget = (run, attempt) => {
+    const consumedTaskBudget = parsePlannedRun(consumeBudget(run, "task"));
+    const consumedOverallBudget = parsePlannedRun(consumeBudget(consumedTaskBudget, "overall"));
+    if (attempt === 1) {
+        return consumedOverallBudget;
+    }
+    return parsePlannedRun(consumeBudget(consumedOverallBudget, "repair"));
+};
+const paramsAcceptanceCriterionIds = (run) => run.requirement.acceptanceCriteria.map((_criterion, index) => `${run.requirement.requirementId}-ac-${index + 1}`);
+//# sourceMappingURL=task-executor.js.map