pulseed 0.6.3 → 0.6.5

package/dist/orchestrator/execution/task/task-verifier.js

@@ -25,6 +25,7 @@ import { runMechanicalVerification, clampDimensionUpdate, checkDimensionDirectio
 import { runLLMReview } from "./task-verifier-llm.js";
 import { appendTaskOutcomeEvent } from "./task-outcome-ledger.js";
 import { resolveTaskWorkspacePath } from "./task-workspace.js";
+import { verifyTaskArtifactContract } from "./task-artifact-contract.js";
 function formatSelfReportEvidence(executorReport) {
     const segments = [
         executorReport.summary.trim(),
@@ -41,6 +42,166 @@ function formatSelfReportEvidence(executorReport) {
     ].filter((segment) => segment.length > 0);
     return segments.join("\n");
 }
+function statusAfterIncompleteVerification(task) {
+    if (task.status === "timed_out" || task.status === "cancelled" || task.status === "blocked")
+        return task.status;
+    return "error";
+}
+function getDimensionThresholdType(dim) {
+    return dim && typeof dim.threshold === "object" && dim.threshold !== null
+        ? dim.threshold.type
+        : undefined;
+}
+function applyThresholdProgressDelta(prevVal, scaledDelta, thresholdType) {
+    const directionalDelta = thresholdType === "max" ? -scaledDelta : scaledDelta;
+    return prevVal !== null ? prevVal + directionalDelta : directionalDelta;
+}
+function isDimensionUpdateDirectionAllowed(input) {
+    const thresholdType = getDimensionThresholdType(input.dim);
+    if (thresholdType === "min" && input.newValue < input.previousValue) {
+        input.logger?.warn?.(`[handleVerdict] Skipping dimension update for ${String(input.dim.name)}: update moves away from min threshold`);
+        return false;
+    }
+    if (thresholdType === "max" && input.newValue > input.previousValue) {
+        input.logger?.warn?.(`[handleVerdict] Skipping dimension update for ${String(input.dim.name)}: update moves away from max threshold`);
+        return false;
+    }
+    return checkDimensionDirection(input.intendedDirection, input.previousValue, input.newValue, input.logger, String(input.dim.name));
+}
+function isolatedWorkspaceHandoff(context) {
+    const workspace = context.agentLoopWorkspace;
+    if (workspace?.isolatedWorkspace === true &&
+        workspace.workspaceDisposition === "handoff_required") {
+        return workspace;
+    }
+    return null;
+}
+function discardedDirtyIsolatedWorkspace(context) {
+    const workspace = context.agentLoopWorkspace;
+    if (workspace?.isolatedWorkspace === true &&
+        workspace.workspaceDirty === true &&
+        workspace.workspaceDisposition === "discarded") {
+        return workspace;
+    }
+    return null;
+}
+function shouldCollectDiffsFromRequestedWorkspace(executionResult) {
+    if (executionResult.agentLoop?.isolatedWorkspace !== true)
+        return true;
+    if (executionResult.agentLoop.workspaceDirty !== true)
+        return true;
+    return executionResult.agentLoop.workspaceDisposition !== "handoff_required" &&
+        executionResult.agentLoop.workspaceDisposition !== "discarded";
+}
+function formatIsolatedWorkspaceHandoffReason(workspace) {
+    const executionCwd = workspace.executionCwd ?? "unknown isolated worktree";
+    const requestedCwd = workspace.requestedCwd ?? "unknown requested workspace";
+    return [
+        `dirty isolated worktree retained at ${executionCwd}`,
+        `requested workspace ${requestedCwd} was not reverted or discarded`,
+        "operator review is required before completion",
+    ].join("; ");
+}
+function formatDiscardedDirtyIsolatedWorkspaceReason(workspace) {
+    const executionCwd = workspace.executionCwd ?? "unknown isolated worktree";
+    const requestedCwd = workspace.requestedCwd ?? "unknown requested workspace";
+    return [
+        `dirty isolated worktree changes were discarded from ${executionCwd}`,
+        `requested workspace ${requestedCwd} was not reverted or discarded`,
+        "task must be retried from the requested workspace",
+    ].join("; ");
+}
+export function applyVerdictHandlingContextGuards(verificationResult, context) {
+    const workspace = isolatedWorkspaceHandoff(context) ?? discardedDirtyIsolatedWorkspace(context);
+    if (!workspace)
+        return verificationResult;
+    const reason = workspace.workspaceDisposition === "discarded"
+        ? formatDiscardedDirtyIsolatedWorkspaceReason(workspace)
+        : formatIsolatedWorkspaceHandoffReason(workspace);
+    return {
+        ...verificationResult,
+        verdict: "fail",
+        confidence: Math.max(verificationResult.confidence ?? 0, 0.95),
+        evidence: [
+            {
+                layer: "mechanical",
+                description: reason,
+                confidence: 0.95,
+            },
+            ...(verificationResult.evidence ?? []),
+        ],
+    };
+}
+function mergeMechanicalAndArtifactVerification(mechanical, artifact) {
+    if (!artifact.applicable)
+        return mechanical;
+    if (isArtifactFreshnessDisagreement(mechanical, artifact)) {
+        return {
+            applicable: true,
+            passed: true,
+            description: `${artifact.description}; mechanical --check-contract reported a stale-artifact freshness failure, but PulSeed artifact_contract passed using task-start freshness: ${mechanical.description}`,
+        };
+    }
+    if (!mechanical.applicable) {
+        return {
+            applicable: true,
+            passed: artifact.passed,
+            description: artifact.description,
+        };
+    }
+    return {
+        applicable: true,
+        passed: mechanical.passed && artifact.passed,
+        description: `${mechanical.description}; ${artifact.description}`,
+    };
+}
+function isArtifactFreshnessDisagreement(mechanical, artifact) {
+    return artifact.applicable &&
+        artifact.passed &&
+        mechanical.applicable &&
+        !mechanical.passed &&
+        /\bstale artifact:/i.test(mechanical.description);
+}
+function isTimedOutAgentLoopResult(executionResult) {
+    return executionResult.stopped_reason === "timeout" || executionResult.agentLoop?.stopReason === "timeout";
+}
+function isRecoverableAgentLoopFinalizationFailure(executionResult) {
+    if (executionResult.success)
+        return false;
+    const stopReason = executionResult.agentLoop?.stopReason;
+    return stopReason === "max_model_turns" ||
+        stopReason === "schema_error" ||
+        stopReason === "completion_gate_failed";
+}
+function formatTimeoutBudgetEvidence(executionResult) {
+    const details = [
+        "AgentLoop stopped because the wall-clock budget timed out",
+        typeof executionResult.agentLoop?.generatedEstimateMs === "number"
+            ? `generated estimate: ${executionResult.agentLoop.generatedEstimateMs}ms`
+            : "",
+        typeof executionResult.agentLoop?.activeBudgetMs === "number"
+            ? `active budget: ${executionResult.agentLoop.activeBudgetMs}ms`
+            : "",
+    ].filter(Boolean);
+    return details.join("; ");
+}
+function isCompletionJudgerUnavailable(result) {
+    return result.passed === false &&
+        result.partial === false &&
+        result.confidence === 0 &&
+        result.description.startsWith("completion_judger failed after ");
+}
+function boundCompletionJudgerForTimedOutTask(deps) {
+    const existing = deps.completionJudgerConfig;
+    return {
+        ...deps,
+        completionJudgerConfig: {
+            timeoutMs: Math.min(existing?.timeoutMs ?? 30_000, 5_000),
+            maxRetries: 0,
+            retryBackoffMs: 0,
+        },
+    };
+}
 function quoteShellArg(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -48,16 +209,20 @@ async function collectVerificationDiffs(deps, task, executionResult) {
     if (executionResult.fileDiffs && executionResult.fileDiffs.length > 0) {
         return executionResult.fileDiffs;
     }
+    if (!shouldCollectDiffsFromRequestedWorkspace(executionResult))
+        return [];
     if (!deps.toolExecutor)
         return [];
     const cwd = executionResult.agentLoop?.requestedCwd ??
         executionResult.agentLoop?.executionCwd ??
-        await resolveTaskWorkspacePath({ stateManager: deps.stateManager, task }) ??
+        await resolveTaskWorkspacePath({ stateManager: deps.stateManager, task, fallbackCwd: deps.revertCwd }) ??
         process.cwd();
     const changedPaths = [
         ...(executionResult.filesChangedPaths ?? []),
         ...(executionResult.agentLoop?.filesChangedPaths ?? []),
     ].filter((path, index, all) => path.length > 0 && all.indexOf(path) === index);
+    const hasExplicitExecutionDiffPaths = executionResult.filesChangedPaths !== undefined ||
+        executionResult.agentLoop?.filesChangedPaths !== undefined;
     const toolContext = {
         cwd,
         goalId: task.goal_id,
@@ -102,6 +267,9 @@ async function collectVerificationDiffs(deps, task, executionResult) {
         const diffs = await Promise.all(changedPaths.slice(0, 5).map((path) => collectForPath(path)));
         return diffs.filter((diff) => diff !== null);
     }
+    if (hasExplicitExecutionDiffPaths) {
+        return [];
+    }
     try {
         const result = await deps.toolExecutor.execute("git_diff", { target: "unstaged", maxLines: 240 }, toolContext);
         if (!result.success || typeof result.data !== "string" || !result.data.trim())
@@ -139,6 +307,16 @@ async function collectVerificationDiffs(deps, task, executionResult) {
  * - L1 SKIP → use L2 only (lower confidence)
  */
 export async function verifyTask(deps, task, executionResult) {
+    let goalForArtifactContract = null;
+    try {
+        goalForArtifactContract = await deps.stateManager.loadGoal(task.goal_id);
+    }
+    catch {
+        goalForArtifactContract = null;
+    }
+    const artifactResult = await verifyTaskArtifactContract(task, executionResult.agentLoop?.executionCwd
+        ?? executionResult.agentLoop?.requestedCwd
+        ?? await resolveTaskWorkspacePath({ stateManager: deps.stateManager, task, fallbackCwd: deps.revertCwd }), { goal: goalForArtifactContract });
     // ─── Short-circuit: GitHub issue URL evidence ───
     // When execution succeeded and output contains a GitHub issue URL,
     // treat as mechanical pass without running full L1/L2 verification.
@@ -146,7 +324,8 @@ export async function verifyTask(deps, task, executionResult) {
     const githubIssueUrlPattern = /github\.com\/.+\/issues\/\d+/;
     if (executionResult.success === true &&
         executionResult.output &&
-        githubIssueUrlPattern.test(executionResult.output)) {
+        githubIssueUrlPattern.test(executionResult.output) &&
+        (!artifactResult.applicable || artifactResult.passed)) {
         const scResult = VerificationResultSchema.parse({
             task_id: task.id,
             verdict: "pass",
@@ -157,14 +336,98 @@ export async function verifyTask(deps, task, executionResult) {
                     description: "GitHub issue URL found in execution output — mechanical evidence of successful issue creation",
                     confidence: 0.95,
                 },
+                ...(artifactResult.applicable
+                    ? [{
+                            layer: "mechanical",
+                            description: artifactResult.description,
+                            confidence: 0.9,
+                        }]
+                    : []),
             ],
             dimension_updates: [],
+            artifact_contract_status: artifactResult,
             timestamp: new Date().toISOString(),
         });
         return scResult;
     }
     // ─── Layer 1: Mechanical verification ───
     const l1Result = await runMechanicalVerification(deps, task);
+    const artifactFreshnessDisagreement = isArtifactFreshnessDisagreement(l1Result, artifactResult);
+    const effectiveL1Result = mergeMechanicalAndArtifactVerification(l1Result, artifactResult);
+    if (isRecoverableAgentLoopFinalizationFailure(executionResult) &&
+        effectiveL1Result.applicable &&
+        effectiveL1Result.passed &&
+        (artifactResult.passed || (executionResult.agentLoop?.completionEvidence?.length ?? 0) > 0)) {
+        deps.logger?.info?.("[completion_judger] Skipping completion judging for AgentLoop finalization failure with mechanical salvage evidence", {
+            taskId: task.id,
+            stoppedReason: executionResult.stopped_reason,
+            agentLoopStopReason: executionResult.agentLoop?.stopReason,
+        });
+        return VerificationResultSchema.parse({
+            task_id: task.id,
+            verdict: "pass",
+            confidence: 0.85,
+            evidence: [
+                {
+                    layer: "mechanical",
+                    description: effectiveL1Result.description,
+                    confidence: 0.9,
+                },
+                {
+                    layer: "independent_review",
+                    description: `completion judging skipped because AgentLoop stopped with ${executionResult.agentLoop?.stopReason ?? executionResult.stopped_reason} after mechanical/artifact evidence passed`,
+                    confidence: 0.85,
+                },
+                {
+                    layer: "self_report",
+                    description: formatSelfReportEvidence(parseExecutorReport(executionResult)),
+                    confidence: 0.3,
+                },
+            ],
+            dimension_updates: [],
+            file_diffs: await collectVerificationDiffs(deps, task, executionResult),
+            artifact_contract_status: artifactResult,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    const timedOutAgentLoop = isTimedOutAgentLoopResult(executionResult);
+    if (timedOutAgentLoop && !effectiveL1Result.passed) {
+        deps.logger?.info?.("[completion_judger] Skipping completion judging for timed-out AgentLoop task without mechanical salvage evidence", {
+            taskId: task.id,
+            stoppedReason: executionResult.stopped_reason,
+            generatedEstimateMs: executionResult.agentLoop?.generatedEstimateMs,
+            activeBudgetMs: executionResult.agentLoop?.activeBudgetMs,
+        });
+        const evidence = [
+            ...(effectiveL1Result.applicable
+                ? [{
+                        layer: "mechanical",
+                        description: effectiveL1Result.description,
+                        confidence: 0.9,
+                    }]
+                : []),
+            {
+                layer: "independent_review",
+                description: `${formatTimeoutBudgetEvidence(executionResult)}; completion judging skipped because timeout is the primary terminal reason and no mechanical salvage evidence passed`,
+                confidence: 0,
+            },
+            {
+                layer: "self_report",
+                description: formatSelfReportEvidence(parseExecutorReport(executionResult)),
+                confidence: 0.3,
+            },
+        ];
+        return VerificationResultSchema.parse({
+            task_id: task.id,
+            verdict: "fail",
+            confidence: 0.9,
+            evidence,
+            dimension_updates: [],
+            file_diffs: await collectVerificationDiffs(deps, task, executionResult),
+            artifact_contract_status: artifactResult,
+            timestamp: new Date().toISOString(),
+        });
+    }
     // ─── Build optional enrichment blocks for LLM review ───
     let knowledgeBlock = "";
     if (deps.knowledgeManager?.getRelevantKnowledge) {
@@ -193,26 +456,54 @@ export async function verifyTask(deps, task, executionResult) {
     }
     catch { /* state enrichment is optional */ }
     // ─── Layer 2: LLM task reviewer (independent) ───
-    const l2Result = await runLLMReview(deps, task, executionResult, knowledgeBlock, stateBlock);
+    const reviewDeps = timedOutAgentLoop ? boundCompletionJudgerForTimedOutTask(deps) : deps;
+    if (timedOutAgentLoop) {
+        deps.logger?.info?.("[completion_judger] Running sharply bounded completion judging for timed-out AgentLoop task with mechanical salvage evidence", {
+            taskId: task.id,
+            stoppedReason: executionResult.stopped_reason,
+            generatedEstimateMs: executionResult.agentLoop?.generatedEstimateMs,
+            activeBudgetMs: executionResult.agentLoop?.activeBudgetMs,
+            timeoutMs: reviewDeps.completionJudgerConfig?.timeoutMs,
+            maxRetries: reviewDeps.completionJudgerConfig?.maxRetries,
+        });
+    }
+    const l2Result = artifactFreshnessDisagreement && executionResult.success === true
+        ? {
+            passed: true,
+            partial: false,
+            description: "completion judging skipped because PulSeed artifact_contract is authoritative for fresh_after_task_start and the contract passed",
+            confidence: 0.85,
+            tokensUsed: 0,
+        }
+        : await runLLMReview(reviewDeps, task, executionResult, knowledgeBlock, stateBlock);
     // ─── Layer 3: Executor self-report (reference only) ───
     const executorReport = parseExecutorReport(executionResult);
     // ─── Contradiction resolution ───
     let verdict;
     let confidence;
     let l2Retry;
-    if (l1Result.applicable) {
-        if (l1Result.passed && l2Result.passed) {
+    const l2Unavailable = isCompletionJudgerUnavailable(l2Result);
+    const l2UnavailableButMechanicallyPassed = l2Unavailable &&
+        executionResult.success === true &&
+        effectiveL1Result.applicable &&
+        effectiveL1Result.passed;
+    if (effectiveL1Result.applicable) {
+        if (l2UnavailableButMechanicallyPassed) {
+            verdict = "pass";
+            confidence = 0.85;
+        }
+        else if (effectiveL1Result.passed && l2Result.passed) {
             verdict = "pass";
             confidence = 0.9;
         }
-        else if (l1Result.passed && l2Result.partial) {
+        else if (effectiveL1Result.passed && l2Result.partial) {
             // L1 pass + L2 partial → partial
             verdict = "partial";
             confidence = 0.7;
         }
-        else if (l1Result.passed && !l2Result.passed && !l2Result.partial) {
+        else if (effectiveL1Result.passed && !l2Result.passed && !l2Result.partial) {
             // L1 pass + L2 fail → re-review
-            l2Retry = await runLLMReview(deps, task, executionResult, knowledgeBlock, stateBlock, 'main');
+            l2Retry = timedOutAgentLoop ? l2Result : await runLLMReview(deps, task, executionResult, knowledgeBlock, stateBlock, 'main');
             if (l2Retry.passed) {
                 verdict = "pass";
                 confidence = 0.75;
@@ -226,7 +517,7 @@ export async function verifyTask(deps, task, executionResult) {
                 confidence = 0.8;
             }
         }
-        else if (!l1Result.passed && l2Result.passed) {
+        else if (!effectiveL1Result.passed && l2Result.passed) {
             // Mechanical verification takes priority
             verdict = "fail";
             confidence = 0.85;
@@ -253,25 +544,28 @@ export async function verifyTask(deps, task, executionResult) {
         }
     }
     // Handle partial from L2 when L1 is applicable but didn't fail
-    if (l1Result.applicable && l2Result.partial && verdict !== "fail") {
+    if (effectiveL1Result.applicable && l2Result.partial && verdict !== "fail") {
         verdict = "partial";
     }
     // Use retry result for evidence when a retry occurred, to keep audit trail accurate
     const effectiveL2 = l2Retry ?? l2Result;
+    const independentReviewDescription = l2UnavailableButMechanicallyPassed
+        ? `${effectiveL2.description}; using passing mechanical/artifact evidence because completion judging was unavailable`
+        : effectiveL2.description;
     const now = new Date().toISOString();
     const evidence = [
-        ...(l1Result.applicable
+        ...(effectiveL1Result.applicable
             ? [
                 {
                     layer: "mechanical",
-                    description: l1Result.description,
+                    description: effectiveL1Result.description,
                     confidence: 0.9,
                 },
             ]
             : []),
         {
             layer: "independent_review",
-            description: effectiveL2.description,
+            description: independentReviewDescription,
             confidence: effectiveL2.confidence,
         },
         {
@@ -320,7 +614,8 @@ export async function verifyTask(deps, task, executionResult) {
                     scaledDelta = progressDelta * (threshold.high - threshold.low);
                 }
             }
-            const newVal = prevVal !== null ? prevVal + scaledDelta : scaledDelta;
+            const thresholdType = threshold?.type;
+            const newVal = applyThresholdProgressDelta(prevVal, scaledDelta, thresholdType);
             return {
                 dimension_name: dimName,
                 previous_value: prevVal,
@@ -335,6 +630,7 @@ export async function verifyTask(deps, task, executionResult) {
         evidence,
         dimension_updates,
         file_diffs: await collectVerificationDiffs(deps, task, executionResult),
+        artifact_contract_status: artifactResult,
         timestamp: now,
     });
     // Post-verification: analyze impact for unintended side effects (opt-in)
@@ -374,7 +670,7 @@ export async function verifyTask(deps, task, executionResult) {
 /**
  * Handle a verification verdict (pass/partial/fail).
  */
-export async function handleVerdict(deps, task, verificationResult) {
+export async function handleVerdict(deps, task, verificationResult, context = {}) {
     // P0: Progress-verdict contradiction check (§4.1)
     if (verificationResult.verdict === "pass" && verificationResult.dimension_updates?.length > 0) {
         const goalRawForGuard = await deps.stateManager.readRaw(`goals/${task.goal_id}/goal.json`);
@@ -405,6 +701,9 @@ export async function handleVerdict(deps, task, verificationResult) {
             verificationResult = { ...verificationResult, verdict: "partial" };
         }
     }
+    if (context.verificationGuardsApplied !== true) {
+        verificationResult = applyVerdictHandlingContextGuards(verificationResult, context);
+    }
     // Save failure context for fail/partial verdicts (§4.7)
     if (verificationResult.verdict === "fail" || verificationResult.verdict === "partial") {
         const firstEvidence = verificationResult.evidence?.[0];
@@ -466,7 +765,13 @@ export async function handleVerdict(deps, task, verificationResult) {
                         const update = verificationResult.dimension_updates.find((u) => u.dimension_name === dim.name);
                         if (update !== undefined && typeof update.new_value === "number") {
                             const prev = typeof dim.current_value === "number" ? dim.current_value : 0;
-                            if (!checkDimensionDirection(task.intended_direction, prev, update.new_value, deps.logger, String(dim.name))) {
+                            if (!isDimensionUpdateDirectionAllowed({
+                                intendedDirection: task.intended_direction,
+                                dim,
+                                previousValue: prev,
+                                newValue: update.new_value,
+                                logger: deps.logger,
+                            })) {
                                 continue;
                             }
                             dim.current_value = clampDimensionUpdate(prev, update.new_value, deps.logger, String(dim.name));
@@ -505,7 +810,13 @@ export async function handleVerdict(deps, task, verificationResult) {
                             const update = verificationResult.dimension_updates.find((u) => u.dimension_name === dim.name);
                             if (update !== undefined && typeof update.new_value === "number") {
                                 const prev = typeof dim.current_value === "number" ? dim.current_value : 0;
-                                if (!checkDimensionDirection(task.intended_direction, prev, update.new_value, deps.logger, String(dim.name))) {
+                                if (!isDimensionUpdateDirectionAllowed({
+                                    intendedDirection: task.intended_direction,
+                                    dim,
+                                    previousValue: prev,
+                                    newValue: update.new_value,
+                                    logger: deps.logger,
+                                })) {
                                     continue;
                                 }
                                 dim.current_value = clampDimensionUpdate(prev, update.new_value, deps.logger, String(dim.name));
@@ -518,6 +829,7 @@ export async function handleVerdict(deps, task, verificationResult) {
                 }
                 const partialTask = {
                     ...task,
+                    status: statusAfterIncompleteVerification(task),
                     verification_verdict: verificationResult.verdict,
                     verification_evidence: verificationResult.evidence?.map((e) => e.description ?? String(e)) ?? [],
                 };
@@ -530,13 +842,14 @@ export async function handleVerdict(deps, task, verificationResult) {
                     action: "keep",
                     verificationResult,
                     reason: "partial progress kept for follow-up work",
+                    stoppedReason: context.stoppedReason ?? undefined,
                 });
                 return { action: "keep", task: partialTask };
             }
-            return handleFailure(deps, task, verificationResult);
+            return handleFailure(deps, task, verificationResult, context);
         }
         case "fail": {
-            return handleFailure(deps, task, verificationResult);
+            return handleFailure(deps, task, verificationResult, context);
         }
     }
 }
@@ -545,9 +858,10 @@ export async function handleVerdict(deps, task, verificationResult) {
  * Handle a task failure: increment failure count, record failure,
  * decide keep/discard/escalate.
  */
-export async function handleFailure(deps, task, verificationResult) {
+export async function handleFailure(deps, task, verificationResult, context = {}) {
     const updatedTask = {
         ...task,
+        status: statusAfterIncompleteVerification(task),
         consecutive_failure_count: task.consecutive_failure_count + 1,
         verification_verdict: verificationResult.verdict,
         verification_evidence: verificationResult.evidence?.map((e) => e.description ?? String(e)) ?? [],
@@ -559,6 +873,7 @@ export async function handleFailure(deps, task, verificationResult) {
         type: "failed",
         attempt: updatedTask.consecutive_failure_count,
         verificationResult,
+        stoppedReason: context.stoppedReason ?? undefined,
     });
     if (updatedTask.consecutive_failure_count >= 3) {
         deps.stallDetector.checkConsecutiveFailures(task.goal_id, task.primary_dimension, updatedTask.consecutive_failure_count);
@@ -570,9 +885,40 @@ export async function handleFailure(deps, task, verificationResult) {
             action: "escalate",
             verificationResult,
             reason: "consecutive failure threshold reached",
+            stoppedReason: context.stoppedReason ?? undefined,
+        });
+        return { action: "escalate", task: updatedTask };
+    }
+    const handoffWorkspace = isolatedWorkspaceHandoff(context);
+    if (handoffWorkspace) {
+        const reason = formatIsolatedWorkspaceHandoffReason(handoffWorkspace);
+        await appendTaskHistory(deps, task.goal_id, updatedTask);
+        await appendTaskOutcomeEvent(deps.stateManager, {
+            task: updatedTask,
+            type: "abandoned",
+            attempt: updatedTask.consecutive_failure_count,
+            action: "escalate",
+            verificationResult,
+            reason,
+            stoppedReason: context.stoppedReason ?? undefined,
         });
         return { action: "escalate", task: updatedTask };
     }
+    const discardedWorkspace = discardedDirtyIsolatedWorkspace(context);
+    if (discardedWorkspace) {
+        const reason = formatDiscardedDirtyIsolatedWorkspaceReason(discardedWorkspace);
+        await appendTaskHistory(deps, task.goal_id, updatedTask);
+        await appendTaskOutcomeEvent(deps.stateManager, {
+            task: updatedTask,
+            type: "abandoned",
+            attempt: updatedTask.consecutive_failure_count,
+            action: "discard",
+            verificationResult,
+            reason,
+            stoppedReason: context.stoppedReason ?? undefined,
+        });
+        return { action: "discard", task: updatedTask };
+    }
     const directionCorrect = isDirectionCorrect(verificationResult);
     if (directionCorrect) {
         await appendTaskHistory(deps, task.goal_id, updatedTask);
@@ -583,20 +929,36 @@ export async function handleFailure(deps, task, verificationResult) {
             action: "keep",
             verificationResult,
             reason: "failure kept for retry because direction remained correct",
+            stoppedReason: context.stoppedReason ?? undefined,
         });
         return { action: "keep", task: updatedTask };
     }
     if (updatedTask.reversibility === "reversible") {
+        const fileDiffs = verificationResult.file_diffs ?? [];
         const concreteRevertPaths = [
-            ...new Set((verificationResult.file_diffs ?? [])
+            ...new Set(fileDiffs
+                .filter((diff) => diff.safe_to_revert !== false)
+                .map((diff) => diff.path)
+                .filter((filePath) => filePath.trim().length > 0)),
+        ];
+        const unsafeRevertPaths = [
+            ...new Set(fileDiffs
+                .filter((diff) => diff.safe_to_revert === false)
                 .map((diff) => diff.path)
                 .filter((filePath) => filePath.trim().length > 0)),
         ];
         const revertSuccess = await attemptRevert(deps, updatedTask, {
             concretePaths: concreteRevertPaths,
+            unsafePaths: unsafeRevertPaths,
+        });
+        deps.logger?.warn(`[task] revert attempted`, {
+            taskId: task.id,
+            success: revertSuccess.success,
+            reason: revertSuccess.reason,
+            concretePaths: revertSuccess.concretePaths,
+            unsafePaths: revertSuccess.unsafePaths,
         });
-        deps.logger?.warn(`[task] revert attempted`, { taskId: task.id, success: revertSuccess });
-        if (revertSuccess) {
+        if (revertSuccess.success) {
             await appendTaskHistory(deps, task.goal_id, updatedTask);
             await appendTaskOutcomeEvent(deps.stateManager, {
                 task: updatedTask,
@@ -604,7 +966,8 @@ export async function handleFailure(deps, task, verificationResult) {
                 attempt: updatedTask.consecutive_failure_count,
                 action: "discard",
                 verificationResult,
-                reason: "task discarded after successful revert",
+                reason: `task discarded after successful ${revertSuccess.method ?? "revert"} for ${revertSuccess.concretePaths.length} concrete paths`,
+                stoppedReason: context.stoppedReason ?? undefined,
             });
             return { action: "discard", task: updatedTask };
         }
@@ -617,7 +980,14 @@ export async function handleFailure(deps, task, verificationResult) {
             attempt: updatedTask.consecutive_failure_count,
             action: "escalate",
             verificationResult,
-            reason: "revert failed after wrong-direction result",
+            reason: revertSuccess.method === "git_unavailable"
+                ? `${revertSuccess.reason}; git restore is unavailable for this non-git workspace, so changed filesystem paths and artifacts require operator handoff`
+                : (revertSuccess.unsafePaths?.length ?? 0) > 0
+                    ? `revert could not safely discard all task changes because some share pre-existing dirty paths: ${revertSuccess.unsafePaths?.join(", ")}`
+                    : revertSuccess.concretePaths.length === 0
+                        ? "revert skipped because no concrete changed paths were captured; task output requires operator review"
+                        : `revert failed after wrong-direction result: ${revertSuccess.reason}`,
+            stoppedReason: context.stoppedReason ?? undefined,
         });
         return { action: "escalate", task: updatedTask };
     }
@@ -629,6 +999,7 @@ export async function handleFailure(deps, task, verificationResult) {
         action: "escalate",
         verificationResult,
         reason: "task cannot be safely retried or reverted",
+        stoppedReason: context.stoppedReason ?? undefined,
     });
     return { action: "escalate", task: updatedTask };
 }