harness-engineering-agent 0.3.32 → 0.3.34

package/dist/controller/task-executor.js

@@ -1,14 +1,16 @@
 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 { createGitWorkspaceAdapter, createGitWorktreeAdapter, } from "../workspace/index.js";
 import { createEvidence } from "./evidence-factory.js";
 import { resolveFailureAnalysis } from "./failure-analysis.js";
 import { classifyFailureScope } from "./failure-classification.js";
 import { createContextGapFailure, createImplementationFailure, createMergeConflictFailure, createModelFailure, createScopeDriftFailure, createVerificationEnvironmentFailure, } from "./failure-factory.js";
 import { orderTasks } from "./graph-validator.js";
+import { createParallelTaskDelta } from "./parallel-task-delta.js";
 import { reassessRemainingTasks } from "./reassessor.js";
 import { runRepairLoop } from "./repair-loop.js";
+import { resolveRoute } from "./route-resolver.js";
 import { finalizeRunAcceptance } from "./run-acceptance.js";
 import { consumeBudget, parsePlannedRun, RunBudgetExceededError, withParts, withPlannedStatus, withTask, } from "./run-state.js";
 import { readFailureAnalyzerOutput, readTaskReviewOutput, readWorkerOutput, } from "./task-agent-output.js";
@@ -712,11 +714,56 @@ export const createTaskExecutor = (input) => {
     const runTasks = async (run) => {
         let currentRun = run;
         const orderedTasks = orderTasks(currentRun.taskGraph);
-        const isParallelRoute = currentRun.routingDecision?.scheduling === "parallel" ||
-            currentRun.resolvedRoute === "parallel";
-        if (isParallelRoute) {
-            const completedTaskIds = new Set();
-            const remainingTaskIds = new Set(orderedTasks.map((task) => task.taskId));
+        let schedulingMode = currentRun.routingDecision?.scheduling ?? "serial";
+        const refreshBatchRouting = async (candidate, completedTaskIds) => {
+            const assessment = candidate.complexityAssessment ?? {
+                tier: "complex",
+                rationale: "No Intake assessment was persisted.",
+                estimatedFileCount: Math.max(1, candidate.taskGraph.tasks.length),
+                estimatedCrossModuleDeps: 0,
+                suggestedRoute: "full",
+                confidence: "low",
+            };
+            const resolution = resolveRoute(assessment, {
+                taskGraph: candidate.taskGraph,
+                workspaceMode: candidate.workspace.git.mode,
+                completedTaskIds,
+            });
+            const currentScheduling = candidate.routingDecision?.scheduling ?? "serial";
+            const currentGovernance = candidate.routingDecision?.governance ??
+                (candidate.resolvedRoute === "parallel" ? "full" : candidate.resolvedRoute);
+            const currentRoute = candidate.resolvedRoute;
+            const nextRoute = resolution.resolvedRoute;
+            if (currentScheduling === resolution.routingDecision.scheduling &&
+                currentGovernance === resolution.routingDecision.governance &&
+                candidate.resolvedTier === resolution.resolvedTier &&
+                currentRoute === nextRoute) {
+                schedulingMode = resolution.routingDecision.scheduling;
+                return candidate;
+            }
+            const routed = parsePlannedRun({
+                ...candidate,
+                resolvedTier: resolution.resolvedTier,
+                resolvedRoute: nextRoute,
+                routingDecision: { ...resolution.routingDecision, source: "task-graph" },
+            });
+            schedulingMode = routed.routingDecision?.scheduling ?? "serial";
+            await input.writer.persist(routed, input.writer.createEvent(candidate.runId, "run.scheduling.recalculated", {
+                previousScheduling: currentScheduling,
+                scheduling: schedulingMode,
+                previousRoute: currentRoute,
+                route: nextRoute,
+                completedTaskIds: [...completedTaskIds].sort(),
+                reasons: resolution.routingDecision.reasons,
+            }));
+            return routed;
+        };
+        while (true) {
+            const completedTaskIds = new Set(currentRun.taskGraph.tasks
+                .filter((task) => task.status === "completed")
+                .map((task) => task.taskId));
+            const remainingTaskIds = new Set(orderedTasks.map((task) => task.taskId).filter((taskId) => !completedTaskIds.has(taskId)));
+            currentRun = await refreshBatchRouting(currentRun, completedTaskIds);
             while (remainingTaskIds.size > 0) {
                 const readyTasks = orderedTasks.filter((task) => {
                     if (completedTaskIds.has(task.taskId))
@@ -726,10 +773,10 @@ export const createTaskExecutor = (input) => {
                 if (readyTasks.length === 0) {
                     break;
                 }
-                if (readyTasks.length >= 2) {
-                    const batchResult = await runParallelReadyBatch(currentRun, readyTasks);
+                if (readyTasks.length >= 2 && schedulingMode === "parallel") {
+                    const batchResult = await runParallelReadyBatch(currentRun, orderedTasks, completedTaskIds);
                     if (batchResult.kind === "paused") {
-                        return batchResult.run;
+                        return reassessAfterFailure(batchResult.run);
                     }
                     if (batchResult.kind === "completed") {
                         currentRun = batchResult.run;
@@ -786,7 +833,7 @@ export const createTaskExecutor = (input) => {
                         break;
                     currentRun = await runTask(currentRun, task);
                     if (currentRun.status !== "executing") {
-                        return currentRun;
+                        return reassessAfterFailure(currentRun);
                     }
                     const completedTask = currentRun.taskGraph.tasks.find((candidate) => candidate.taskId === task.taskId);
                     if (completedTask?.status === "completed") {
@@ -830,62 +877,19 @@ export const createTaskExecutor = (input) => {
                                 reason: event.reason,
                             }));
                         }
+                        const nextCompletedTaskIds = new Set(currentRun.taskGraph.tasks
+                            .filter((candidate) => candidate.status === "completed")
+                            .map((candidate) => candidate.taskId));
+                        currentRun = await refreshBatchRouting(currentRun, nextCompletedTaskIds);
+                        if (schedulingMode === "parallel")
+                            break;
                     }
                 }
             }
-        }
-        else {
-            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 completedTask = currentRun.taskGraph.tasks.find((candidate) => candidate.taskId === task.taskId);
-                if (completedTask?.status === "completed") {
-                    const reassessment = reassessRemainingTasks({
-                        run: currentRun,
-                        completedTask,
-                        allTasks: currentRun.taskGraph.tasks,
-                    });
-                    if (reassessment.shouldReassess && reassessment.event && reassessment.newTier) {
-                        const event = reassessment.event;
-                        const newTier = reassessment.newTier;
-                        const updatedTasks = currentRun.taskGraph.tasks.map((t) => {
-                            if (t.taskId === completedTask.taskId)
-                                return t;
-                            if (!event.affectedRemainingTasks.includes(t.taskId))
-                                return t;
-                            return { ...t, complexityTier: newTier };
-                        });
-                        currentRun = parsePlannedRun({
-                            ...currentRun,
-                            resolvedTier: newTier,
-                            routingDecision: {
-                                ...currentRun.routingDecision,
-                                tier: newTier,
-                                governance: newTier === "complex"
-                                    ? "full"
-                                    : (currentRun.routingDecision?.governance ?? "streamlined"),
-                                scheduling: currentRun.routingDecision?.scheduling ?? "serial",
-                                source: "reassessment",
-                                reasons: [event.reason],
-                            },
-                            reassessmentHistory: [...currentRun.reassessmentHistory, event],
-                            taskGraph: { ...currentRun.taskGraph, tasks: updatedTasks },
-                        });
-                        await input.writer.persist(currentRun, input.writer.createEvent(currentRun.runId, "task.reassessment", {
-                            triggerTaskId: event.triggerTaskId,
-                            previousTier: event.previousTier,
-                            newTier: event.newTier,
-                            reason: event.reason,
-                        }));
-                    }
-                }
+            if (remainingTaskIds.size > 0 && schedulingMode === "parallel") {
+                continue;
             }
+            break;
         }
         currentRun = await runIntegrationVerification(currentRun);
         const runAcceptanceResult = await finalizeRunAcceptance({
@@ -893,9 +897,27 @@ export const createTaskExecutor = (input) => {
             runtime: input.runtime,
             run: currentRun,
         });
+        const acceptanceBlockingDetails = runAcceptanceResult.status === "blocked"
+            ? {
+                kind: "blocked",
+                missingContext: runAcceptanceResult.runAcceptance.criterionDecisions
+                    .filter((decision) => decision.status === "blocked" || decision.status === "unknown")
+                    .map((decision) => decision.criterionId),
+                discoveredEvidence: runAcceptanceResult.runAcceptance.criterionDecisions.flatMap((decision) => decision.evidenceIds),
+                nextActions: ["补充缺失证据后执行 resume", "检查阻塞 criterion 后重新验收"],
+                failureIds: runAcceptanceResult.runAcceptance.criterionDecisions.flatMap((decision) => decision.failureIds),
+                criterionIds: runAcceptanceResult.runAcceptance.criterionDecisions
+                    .filter((decision) => decision.status === "blocked" || decision.status === "unknown")
+                    .map((decision) => decision.criterionId),
+                allowedOperations: ["resume", "report", "cancel"],
+            }
+            : undefined;
         const completed = withPlannedStatus(withParts(parsePlannedRun({
             ...currentRun,
             runAcceptance: runAcceptanceResult.runAcceptance,
+            ...(acceptanceBlockingDetails === undefined
+                ? {}
+                : { blockingDetails: acceptanceBlockingDetails }),
         }), {
             evidence: currentRun.evidence,
             failures: runAcceptanceResult.failure === undefined
@@ -921,10 +943,6 @@ export const createTaskExecutor = (input) => {
                 verificationCommands: commands,
                 defaultWorkingDirectory: runWorkingDirectory(run),
             });
-            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,
@@ -940,6 +958,63 @@ export const createTaskExecutor = (input) => {
                 agentResults: run.agentResults,
                 workspace: run.workspace,
             });
+            if (result.records.length === 0) {
+                const failure = createContextGapFailure({
+                    failureId: input.options.ids.createFailureId(`${run.runId}-integration-empty`),
+                    runId: run.runId,
+                    taskId: task.taskId,
+                    relatedEvidenceIds: [],
+                    summary: "Integration verification produced no evidence records.",
+                    detail: "At least one integration verification record is required before acceptance.",
+                    recoveryPlan: "Rerun integration verification and capture a real result.",
+                    missingContext: ["integration-verification-record"],
+                });
+                return (await analyzeFailure({
+                    run: withParts(verified, {
+                        evidence: verified.evidence,
+                        failures: [...verified.failures, failure],
+                        agentResults: verified.agentResults,
+                        workspace: verified.workspace,
+                    }),
+                    task,
+                    attempt: 1,
+                    failure,
+                    evidence,
+                })).run;
+            }
+            if (result.records.some((record) => record.status !== VerificationExecutionStatus.passed)) {
+                const failure = createImplementationFailure({
+                    failureId: input.options.ids.createFailureId(`${run.runId}-integration-failed`),
+                    runId: run.runId,
+                    taskId: task.taskId,
+                    ...(evidence[0] === undefined ? {} : { failingEvidenceId: evidence[0].evidenceId }),
+                    summary: "Integration verification failed after task execution.",
+                    detail: "A run-level integration verification command returned a failed result.",
+                    recoveryPlan: "Analyze the integration failure before authorizing a bounded repair.",
+                });
+                const analyzed = await analyzeFailure({
+                    run: withParts(verified, {
+                        evidence: verified.evidence,
+                        failures: [...verified.failures, failure],
+                        agentResults: verified.agentResults,
+                        workspace: verified.workspace,
+                    }),
+                    task,
+                    attempt: 1,
+                    failure,
+                    evidence,
+                });
+                if (analyzed.repairRequested && analyzed.run.status === "executing" && task.repairEnabled) {
+                    return handleRepairRequest({
+                        run: analyzed.run,
+                        task,
+                        attempt: 1,
+                        failure: analyzed.failure,
+                        evidence,
+                    });
+                }
+                return analyzed.run;
+            }
             await input.writer.persist(verified, input.writer.createEvent(run.runId, "run.integration.verified", {
                 evidenceIds: evidence.map((item) => item.evidenceId),
             }));
@@ -948,34 +1023,42 @@ export const createTaskExecutor = (input) => {
         catch (error) {
             if (!(error instanceof Error))
                 throw error;
-            return persistIntegrationVerificationFailure(run, task, error.message);
+            const failure = createVerificationEnvironmentFailure({
+                failureId: input.options.ids.createFailureId(`${run.runId}-integration-environment`),
+                runId: run.runId,
+                taskId: task.taskId,
+                commandName: commands[0]?.name ?? "integration verification",
+                detail: error.message,
+            });
+            const blocked = withPlannedStatus(withParts(run, {
+                evidence: run.evidence,
+                failures: [...run.failures, failure],
+                agentResults: run.agentResults,
+                workspace: run.workspace,
+            }), "blocked");
+            const withDetails = parsePlannedRun({
+                ...blocked,
+                blockingDetails: {
+                    kind: "blocked",
+                    missingContext: ["integration-environment"],
+                    discoveredEvidence: [],
+                    nextActions: ["修复集成验证环境后执行 resume"],
+                    failureIds: [failure.failureId],
+                    criterionIds: [],
+                    allowedOperations: ["resume", "report", "cancel"],
+                },
+            });
+            await input.writer.persist(withDetails, input.writer.createEvent(run.runId, "run.integration.blocked", {
+                failureId: failure.failureId,
+            }));
+            return withDetails;
         }
     };
-    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) {
+    async function runParallelReadyBatch(run, orderedTasks, completedTaskIds) {
         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) {
@@ -1046,7 +1129,10 @@ export const createTaskExecutor = (input) => {
                 return { kind: "completed", run: serialRun };
             }
             case "parallel-completed":
-                return { kind: "completed", run: mergeChildRuns(run, childRuns) };
+                return {
+                    kind: "completed",
+                    run: mergeChildRuns(run, childRuns, new Map(result.results.map((item) => [item.task.taskId, item.lease]))),
+                };
             case "merge-conflict":
                 return { kind: "paused", run: await persistMergeConflict(run, result.conflict.detail) };
             case "execution-failed":
@@ -1061,24 +1147,68 @@ export const createTaskExecutor = (input) => {
         const result = run.agentResults.findLast((candidate) => candidate.role === "worker" && candidate.taskId === task.taskId);
         return result?.status === "completed" ? result.changedPaths : [];
     }
-    function mergeChildRuns(parentRun, childRuns) {
+    function mergeChildRuns(parentRun, childRuns, leasesByTaskId) {
         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);
-                }
+        const appliedDeltaIds = new Set();
+        const deltas = childRuns
+            .map((childRun) => {
+            const task = childRun.taskGraph.tasks.find((candidate) => candidate.status === "completed" && candidate.taskId);
+            if (task === undefined)
+                return undefined;
+            const lease = leasesByTaskId.get(task.taskId);
+            if (lease === undefined)
+                return undefined;
+            return createParallelTaskDelta({
+                parentRun,
+                childRun,
+                task,
+                lease,
+            });
+        })
+            .filter((delta) => delta !== undefined)
+            .sort((left, right) => left.taskId.localeCompare(right.taskId));
+        for (const delta of deltas) {
+            if (delta.runId !== merged.runId)
+                continue;
+            if (appliedDeltaIds.has(delta.deltaId))
+                continue;
+            const parentTask = merged.taskGraph.tasks.find((candidate) => candidate.taskId === delta.taskId);
+            if (parentTask === undefined)
+                continue;
+            if (delta.baselineDigest !== parentRun.workspace.git.baselineDiffDigest) {
+                throw new Error(`stale parallel task delta baseline for ${delta.taskId}`);
             }
+            appliedDeltaIds.add(delta.deltaId);
+            merged = withTask(merged, delta.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,
+                evidence: uniqueById([...merged.evidence, ...delta.evidence], (item) => item.evidenceId),
+                failures: uniqueById([...merged.failures, ...delta.failures], (item) => item.failureId),
+                agentResults: uniqueById([...merged.agentResults, ...delta.agentResults], (item) => item.resultId),
+                workspace: merged.workspace,
             });
+            merged = applyBudgetDelta(merged, delta.budgetDelta);
         }
         return merged;
     }
+    function applyBudgetDelta(run, delta) {
+        return parsePlannedRun({
+            ...run,
+            budgets: Object.fromEntries(Object.entries(run.budgets).map(([key, counter]) => [
+                key,
+                {
+                    ...counter,
+                    used: checkedBudgetUsage(counter.used, delta[key] ?? 0, counter.limit, key, run.runId),
+                },
+            ])),
+        });
+    }
+    function checkedBudgetUsage(used, delta, limit, budget, runId) {
+        const next = used + delta;
+        if (next > limit) {
+            throw new RunBudgetExceededError(runId, budget, limit);
+        }
+        return next;
+    }
     async function persistMergeConflict(run, detail) {
         const task = firstIncompleteTask(run);
         const failure = createMergeConflictFailure({
@@ -1149,6 +1279,54 @@ export const createTaskExecutor = (input) => {
         }));
         return paused;
     }
+    async function reassessAfterFailure(run) {
+        const failure = run.failures.at(-1);
+        if (failure === undefined ||
+            !["implementation-defect", "scope-drift", "merge-conflict"].includes(failure.category)) {
+            return run;
+        }
+        const affectedRemainingTasks = run.taskGraph.tasks
+            .filter((task) => task.status !== "completed")
+            .map((task) => task.taskId);
+        if (affectedRemainingTasks.length === 0 || run.resolvedTier === "complex") {
+            return run;
+        }
+        const event = {
+            triggerTaskId: failure.taskId,
+            previousTier: run.resolvedTier,
+            newTier: "complex",
+            reason: `Failure ${failure.failureId} requires conservative complexity escalation`,
+            affectedRemainingTasks,
+        };
+        const updated = parsePlannedRun({
+            ...run,
+            resolvedTier: "complex",
+            resolvedRoute: "full",
+            routingDecision: {
+                ...run.routingDecision,
+                tier: "complex",
+                governance: "full",
+                scheduling: run.routingDecision?.scheduling ?? "serial",
+                source: "reassessment",
+                reasons: [event.reason],
+            },
+            reassessmentHistory: [...run.reassessmentHistory, event],
+            taskGraph: {
+                ...run.taskGraph,
+                tasks: run.taskGraph.tasks.map((task) => affectedRemainingTasks.includes(task.taskId)
+                    ? { ...task, complexityTier: "complex" }
+                    : task),
+            },
+        });
+        await input.writer.persist(updated, input.writer.createEvent(run.runId, "task.reassessment.after_failure", {
+            triggerTaskId: event.triggerTaskId,
+            failureId: failure.failureId,
+            previousTier: event.previousTier,
+            newTier: event.newTier,
+            affectedRemainingTasks,
+        }));
+        return updated;
+    }
 };
 const findWorkerScopeViolations = (task, output) => {
     const violations = [];