harness-engineering-agent 0.1.7 → 0.1.9

package/dist/controller/task-executor.js

@@ -1,19 +1,129 @@
 import { AgentResultSchema } from "../domain/index.js";
+import { normalizeVerificationCommand } from "../verification/command-policy.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 { createContextGapFailure, createImplementationFailure, createMergeConflictFailure, createModelFailure, createScopeDriftFailure, createVerificationEnvironmentFailure, } from "./failure-factory.js";
 import { orderTasks } from "./graph-validator.js";
 import { runRepairLoop } from "./repair-loop.js";
+import { finalizeRunAcceptance } from "./run-acceptance.js";
 import { consumeBudget, parsePlannedRun, RunBudgetExceededError, withParts, withPlannedStatus, withTask, } from "./run-state.js";
-import { readAcceptanceOutput, readFailureAnalyzerOutput, readVerifierOutput, readWorkerOutput, } from "./task-agent-output.js";
+import { readFailureAnalyzerOutput, readTaskReviewOutput, 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 refreshRunBoundary = async (run) => {
+        const latest = await input.loadRun(run.runId);
+        if (!("taskGraph" in latest)) {
+            throw new TypeError(`run ${run.runId} lost its task graph during advancement`);
+        }
+        switch (latest.status) {
+            case "plan_ready":
+            case "executing":
+            case "verifying":
+                return parsePlannedRun(latest.status === "executing" ? latest : { ...latest, status: "executing" });
+            case "paused":
+            case "cancelled":
+            case "failed":
+            case "completed":
+            case "evidence_gap":
+            case "blocked":
+                return parsePlannedRun(latest);
+            default:
+                return assertNever(latest);
+        }
+    };
+    const runDiagnosticProbe = async (params) => {
+        try {
+            normalizeVerificationCommand({
+                workspaceRoot: input.options.workingDirectory,
+                command: params.probe.verificationCommand,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            return {
+                kind: "failed",
+                failure: createImplementationFailure({
+                    failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-diagnostic-probe-policy`),
+                    runId: params.run.runId,
+                    taskId: params.task.taskId,
+                    summary: "Failure analyzer proposed an invalid diagnostic probe.",
+                    detail: error.message,
+                    recoveryPlan: "Reject the probe and require a minimal read-only verification command.",
+                }),
+            };
+        }
+        await input.writer.persist(withPlannedStatus(params.run, "verifying"), input.writer.createEvent(params.run.runId, "task.diagnostic.probe.started", {
+            taskId: params.task.taskId,
+            attempt: params.attempt,
+            commandName: params.probe.verificationCommand.name,
+        }));
+        let verificationResult;
+        try {
+            verificationResult = await input.options.verificationRunner.run({
+                verificationCommands: [params.probe.verificationCommand],
+                defaultWorkingDirectory: input.options.workingDirectory,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            return {
+                kind: "failed",
+                failure: createVerificationEnvironmentFailure({
+                    failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-diagnostic-probe-environment`),
+                    runId: params.run.runId,
+                    taskId: params.task.taskId,
+                    commandName: params.probe.verificationCommand.name,
+                    detail: error.message,
+                }),
+            };
+        }
+        if (verificationResult.records.length === 0) {
+            return {
+                kind: "failed",
+                failure: createContextGapFailure({
+                    failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-diagnostic-probe-empty`),
+                    runId: params.run.runId,
+                    taskId: params.task.taskId,
+                    relatedEvidenceIds: [],
+                    summary: "Diagnostic probe produced no verification records.",
+                    detail: params.probe.summary,
+                    recoveryPlan: "Capture a real read-only verification record before confirming the root cause.",
+                    missingContext: ["diagnostic-probe-record"],
+                }),
+            };
+        }
+        const evidence = verificationResult.records.map((record, index) => createEvidence({
+            ids: input.options.ids,
+            runId: params.run.runId,
+            task: params.task,
+            record,
+            label: `${params.task.taskId}-${params.attempt}-diagnostic-probe-${index}`,
+            kind: "verification",
+            summary: `diagnostic-probe:${record.command.name}`,
+        }));
+        const nextRun = withParts(params.run, {
+            evidence: [...params.run.evidence, ...evidence],
+            failures: params.run.failures,
+            agentResults: params.run.agentResults,
+            workspace: params.run.workspace,
+        });
+        await input.writer.persist(withPlannedStatus(nextRun, "executing"), input.writer.createEvent(params.run.runId, "task.diagnostic.probe.completed", {
+            taskId: params.task.taskId,
+            attempt: params.attempt,
+            evidenceIds: evidence.map((item) => item.evidenceId),
+        }));
+        return { kind: "approved", evidence };
+    };
     const analyzeFailure = async (params) => {
         const analysisResult = await readFailureAnalyzerOutput({
             input,
@@ -50,6 +160,50 @@ export const createTaskExecutor = (input) => {
             evidence: params.evidence,
             analysis: analysisResult.output,
         });
+        if (analysisResult.output.action === "probe") {
+            const probeResult = await runDiagnosticProbe({
+                run: params.run,
+                task: params.task,
+                attempt: params.attempt,
+                probe: analysisResult.output.diagnosticProbe,
+            });
+            if (probeResult.kind === "failed") {
+                const failedRun = withParts(withTask(params.run, { ...params.task, status: "failed" }), {
+                    evidence: params.run.evidence,
+                    failures: [
+                        ...params.run.failures,
+                        params.failure,
+                        resolution.failure,
+                        probeResult.failure,
+                    ],
+                    agentResults: [...params.run.agentResults, resolution.result],
+                    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: probeResult.failure.failureId,
+                }));
+                return {
+                    run: withPlannedStatus(failedRun, "failed"),
+                    repairRequested: false,
+                    failure: probeResult.failure,
+                };
+            }
+            const probeRun = withParts(params.run, {
+                evidence: [...params.run.evidence, ...probeResult.evidence],
+                failures: params.run.failures,
+                agentResults: params.run.agentResults,
+                workspace: params.run.workspace,
+            });
+            return analyzeFailure({
+                run: probeRun,
+                task: params.task,
+                attempt: params.attempt,
+                failure: params.failure,
+                evidence: [...params.evidence, ...probeResult.evidence],
+            });
+        }
         const nextTask = { ...params.task, status: resolution.taskStatus };
         const nextRun = withParts(withTask(params.run, nextTask), {
             evidence: params.run.evidence,
@@ -64,13 +218,14 @@ export const createTaskExecutor = (input) => {
             failure: resolution.failure,
         };
     };
-    const verifyAndAccept = async (params) => {
-        const verifierOutput = await readVerifierOutput({
+    const reviewTask = async (params) => {
+        const verifierOutput = await readTaskReviewOutput({
             input,
             run: params.run,
             task: params.task,
             attempt: params.attempt,
             evidence: params.evidence,
+            changedPaths: params.changedPaths,
         });
         if (verifierOutput.kind === "failed") {
             const resolution = await analyzeFailure({
@@ -82,38 +237,6 @@ export const createTaskExecutor = (input) => {
             });
             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}`),
@@ -127,7 +250,7 @@ export const createTaskExecutor = (input) => {
         });
         const verifierResult = AgentResultSchema.parse({
             schemaVersion: "1.0.0",
-            resultId: input.options.ids.createAgentResultId(`verifier-${params.task.taskId}-${params.attempt}`),
+            resultId: input.options.ids.createAgentResultId(`task-review-${params.task.taskId}-${params.attempt}`),
             runId: params.run.runId,
             taskId: params.task.taskId,
             role: "verifier",
@@ -136,71 +259,58 @@ export const createTaskExecutor = (input) => {
             evidenceIds: params.evidence.map((item) => item.evidenceId),
             changedPaths: [],
         });
-        const acceptedRun = withParts(params.run, {
+        const reviewedRun = 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", {
+        const runWithTaskReview = parsePlannedRun({
+            ...reviewedRun,
+            taskReviews: [...reviewedRun.taskReviews, verifierOutput.output.taskReview],
+        });
+        const reviewing = withPlannedStatus(runWithTaskReview, "verifying");
+        await input.writer.persist(reviewing, input.writer.createEvent(params.run.runId, "task.review.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"
+        if (verifierOutput.output.status !== "passed") {
+            const taskReviewFailure = verifierOutput.output.status === "evidence_gap"
                 ? createContextGapFailure({
-                    failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-acceptance-evidence-gap`),
+                    failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-task-review-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,
+                    summary: verifierOutput.output.summary,
+                    detail: verifierOutput.output.missingEvidenceKinds.join(", "),
+                    recoveryPlan: "Collect the missing task review evidence before completing.",
+                    missingContext: verifierOutput.output.missingEvidenceKinds,
                 })
                 : params.evidence[0] === undefined
                     ? createContextGapFailure({
-                        failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-acceptance-missing-evidence`),
+                        failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-task-review-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"],
+                        summary: verifierOutput.output.summary,
+                        detail: "TaskReview reported failed but no deterministic evidence exists.",
+                        recoveryPlan: "Capture real deterministic evidence before processing task review failure.",
+                        missingContext: ["task-review-evidence"],
                     })
-                    : createAcceptanceFailure({
-                        failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-acceptance`),
+                    : createImplementationFailure({
+                        failureId: input.options.ids.createFailureId(`${params.task.taskId}-${params.attempt}-task-review`),
                         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.",
+                        summary: verifierOutput.output.summary,
+                        detail: verifierOutput.output.taskReview?.summary ?? verifierOutput.output.status,
+                        recoveryPlan: "Address the task review findings before completing the task.",
                     });
             const resolution = await analyzeFailure({
-                run: accepting,
+                run: reviewing,
                 task: params.task,
                 attempt: params.attempt,
-                failure: acceptanceFailure,
+                failure: taskReviewFailure,
                 evidence: params.evidence,
             });
             return resolution.run;
@@ -213,22 +323,11 @@ export const createTaskExecutor = (input) => {
                 ...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,
+        const currentRun = withPlannedStatus(withParts(withTask(reviewing, completedTask), {
+            evidence: reviewing.evidence,
+            failures: reviewing.failures,
+            agentResults: reviewing.agentResults,
+            workspace: reviewing.workspace,
         }), "executing");
         await input.writer.persist(currentRun, input.writer.createEvent(params.run.runId, "task.completed", {
             taskId: params.task.taskId,
@@ -264,7 +363,7 @@ export const createTaskExecutor = (input) => {
         if (repaired.kind === "terminal") {
             return repaired.run;
         }
-        return verifyAndAccept({
+        return reviewTask({
             run: repaired.run,
             task: params.task,
             attempt: params.attempt,
@@ -280,6 +379,10 @@ export const createTaskExecutor = (input) => {
         let currentRun = run;
         let lastFailure;
         for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            currentRun = await refreshRunBoundary(currentRun);
+            if (currentRun.status !== "executing") {
+                return currentRun;
+            }
             try {
                 currentRun = claimTaskAttemptBudget(currentRun, attempt);
             }
@@ -307,6 +410,10 @@ export const createTaskExecutor = (input) => {
                 attempt,
                 workingDirectory: executionCwd,
             });
+            currentRun = await refreshRunBoundary(currentRun);
+            if (currentRun.status !== "executing") {
+                return currentRun;
+            }
             const workspaceAfterWorker = await taskWorkspaceAdapter.captureCurrentState();
             if (workerOutput.kind === "failed") {
                 lastFailure = workerOutput.failure;
@@ -328,12 +435,16 @@ export const createTaskExecutor = (input) => {
                     taskId: task.taskId,
                     attempt,
                 }));
+                const taskVerificationCommands = task.verificationPlan.filter((command) => command.scope !== "integration");
                 let verificationResult;
                 try {
-                    verificationResult = await input.options.verificationRunner.run({
-                        verificationCommands: task.verificationPlan,
-                        defaultWorkingDirectory: executionCwd,
-                    });
+                    verificationResult =
+                        taskVerificationCommands.length === 0
+                            ? { records: [], stoppedEarly: false }
+                            : await input.options.verificationRunner.run({
+                                verificationCommands: taskVerificationCommands,
+                                defaultWorkingDirectory: executionCwd,
+                            });
                 }
                 catch (error) {
                     if (!(error instanceof Error)) {
@@ -343,10 +454,14 @@ export const createTaskExecutor = (input) => {
                         failureId: input.options.ids.createFailureId(`${task.taskId}-${attempt}-verification-environment`),
                         runId: run.runId,
                         taskId: task.taskId,
-                        commandName: task.verificationPlan[0]?.name ?? "verification",
+                        commandName: taskVerificationCommands[0]?.name ?? "verification",
                         detail: error.message,
                     });
                 }
+                currentRun = await refreshRunBoundary(currentRun);
+                if (currentRun.status !== "executing") {
+                    return currentRun;
+                }
                 const workspaceAfterVerification = await taskWorkspaceAdapter.captureCurrentState();
                 if (currentRun.workspace.git.mode === "git") {
                     const workspaceAssessment = await taskWorkspaceAdapter.assessTaskChanges({
@@ -417,7 +532,7 @@ export const createTaskExecutor = (input) => {
                         });
                     }
                 }
-                else if (verificationResult.records.length === 0) {
+                else if (verificationResult.records.length === 0 && taskVerificationCommands.length > 0) {
                     lastFailure = createContextGapFailure({
                         failureId: input.options.ids.createFailureId(`${task.taskId}-${attempt}-verification-empty`),
                         runId: run.runId,
@@ -456,7 +571,7 @@ export const createTaskExecutor = (input) => {
                         record,
                         label: `${task.taskId}-${attempt}-${index}`,
                         changedPaths: workerOutput.output.changedPaths,
-                        acceptanceCriterionIds: paramsAcceptanceCriterionIds(run),
+                        acceptanceCriterionIds: [],
                     }));
                     currentRun = withParts(currentRun, {
                         evidence: [...currentRun.evidence, ...evidence],
@@ -496,12 +611,15 @@ export const createTaskExecutor = (input) => {
                         }
                     }
                     else {
-                        const finalized = await verifyAndAccept({
+                        const reconciledChangedPaths = currentRun.workspace.git.mode === "git"
+                            ? currentRun.workspace.git.harnessChangedPaths.filter((path) => task.allowedPaths.some((allowedPath) => path === allowedPath || path.startsWith(`${allowedPath}/`)))
+                            : workerOutput.output.changedPaths;
+                        const finalized = await reviewTask({
                             run: currentRun,
                             task,
                             attempt,
                             evidence,
-                            changedPaths: workerOutput.output.changedPaths,
+                            changedPaths: reconciledChangedPaths,
                         });
                         if (finalized.status !== "executing") {
                             return finalized;
@@ -564,10 +682,89 @@ export const createTaskExecutor = (input) => {
                 return currentRun;
             }
         }
-        const completed = withPlannedStatus(currentRun, "completed");
-        await input.writer.persist(completed, input.writer.createEvent(completed.runId, "run.completed", { status: "completed" }));
+        currentRun = await runIntegrationVerification(currentRun);
+        const runAcceptanceResult = await finalizeRunAcceptance({
+            options: input.options,
+            runtime: input.runtime,
+            run: currentRun,
+        });
+        const completed = withPlannedStatus(withParts(parsePlannedRun({
+            ...currentRun,
+            runAcceptance: runAcceptanceResult.runAcceptance,
+        }), {
+            evidence: currentRun.evidence,
+            failures: runAcceptanceResult.failure === undefined
+                ? currentRun.failures
+                : [...currentRun.failures, runAcceptanceResult.failure],
+            agentResults: runAcceptanceResult.agentResult === undefined
+                ? currentRun.agentResults
+                : [...currentRun.agentResults, runAcceptanceResult.agentResult],
+            workspace: currentRun.workspace,
+        }), runAcceptanceResult.status);
+        await input.writer.persist(completed, input.writer.createEvent(completed.runId, "run.completed", { status: completed.status }));
         return completed;
     };
+    const runIntegrationVerification = async (run) => {
+        const commands = run.taskGraph.tasks.flatMap((task) => task.verificationPlan.filter((command) => command.scope === "integration"));
+        if (commands.length === 0)
+            return run;
+        const task = run.taskGraph.tasks.at(-1);
+        if (task === undefined)
+            return run;
+        try {
+            const result = await input.options.verificationRunner.run({
+                verificationCommands: commands,
+                defaultWorkingDirectory: input.options.workingDirectory,
+            });
+            if (result.records.length === 0 ||
+                result.records.some((record) => record.status !== VerificationExecutionStatus.passed)) {
+                return persistIntegrationVerificationFailure(run, task, "integration verification failed");
+            }
+            const evidence = result.records.map((record, index) => createEvidence({
+                ids: input.options.ids,
+                runId: run.runId,
+                task,
+                record,
+                label: `integration-${task.taskId}-${index}`,
+                changedPaths: [],
+                acceptanceCriterionIds: [],
+            }));
+            const verified = withParts(run, {
+                evidence: [...run.evidence, ...evidence],
+                failures: run.failures,
+                agentResults: run.agentResults,
+                workspace: run.workspace,
+            });
+            await input.writer.persist(verified, input.writer.createEvent(run.runId, "run.integration.verified", {
+                evidenceIds: evidence.map((item) => item.evidenceId),
+            }));
+            return verified;
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            return persistIntegrationVerificationFailure(run, task, error.message);
+        }
+    };
+    const persistIntegrationVerificationFailure = async (run, task, detail) => {
+        const failure = createVerificationEnvironmentFailure({
+            failureId: input.options.ids.createFailureId(`${run.runId}-integration`),
+            runId: run.runId,
+            taskId: task.taskId,
+            commandName: "integration verification",
+            detail,
+        });
+        const nextRun = withParts(run, {
+            evidence: run.evidence,
+            failures: [...run.failures, failure],
+            agentResults: run.agentResults,
+            workspace: run.workspace,
+        });
+        await input.writer.persist(nextRun, input.writer.createEvent(run.runId, "run.integration.failed", {
+            failureId: failure.failureId,
+        }));
+        return nextRun;
+    };
     return { runTasks };
     async function runParallelReadyBatch(run, orderedTasks) {
         if (run.workspace.git.mode !== "git") {
@@ -719,6 +916,9 @@ export const createTaskExecutor = (input) => {
         return paused;
     }
 };
+const assertNever = (value) => {
+    throw new TypeError(`Unexpected run state: ${JSON.stringify(value)}`);
+};
 const uniqueById = (items, getId) => {
     const seen = new Set();
     const unique = [];
@@ -747,5 +947,4 @@ const claimTaskAttemptBudget = (run, attempt) => {
     }
     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