pulseed 0.6.4 → 0.6.6

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

@@ -14,6 +14,7 @@
  *   - task-verifier-types.ts  — interfaces, Zod schemas
  *   - task-verifier-rules.ts  — mechanical verification, dimension guards, history
  *   - task-verifier-llm.ts    — LLM review, timeout, retry
+ *   - task-verifier-evidence.ts — evidence formatting, terminal-state helpers
  */
 import { VerificationResultSchema } from "../../../base/types/task.js";
 import { wrapXmlTag, formatKnowledge } from "../../../prompt/formatters.js";
@@ -21,136 +22,14 @@ import { analyzeImpact } from "../impact-analyzer.js";
 export { CompletionJudgerResponseSchema } from "./task-verifier-types.js";
 // Re-export rule helpers (used by task-lifecycle.ts and tests)
 export { clampDimensionUpdate, checkDimensionDirection, } from "./task-verifier-rules.js";
-import { runMechanicalVerification, clampDimensionUpdate, checkDimensionDirection, parseExecutorReport, isDirectionCorrect, attemptRevert, setDimensionIntegrity, appendTaskHistory, } from "./task-verifier-rules.js";
+import { runMechanicalVerification, clampDimensionUpdate, parseExecutorReport, isDirectionCorrect, attemptRevert, setDimensionIntegrity, appendTaskHistory, } from "./task-verifier-rules.js";
 import { runLLMReview } from "./task-verifier-llm.js";
+import { applyVerdictHandlingContextGuards, discardedDirtyIsolatedWorkspace, formatDiscardedDirtyIsolatedWorkspaceReason, formatIsolatedWorkspaceHandoffReason, isolatedWorkspaceHandoff, shouldCollectDiffsFromRequestedWorkspace, } from "./task-verifier-workspace-guards.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(),
-        executorReport.stop_reason ? `stop reason: ${executorReport.stop_reason}` : "",
-        executorReport.completion_evidence.length > 0
-            ? `completion evidence: ${executorReport.completion_evidence.join("; ")}`
-            : "",
-        executorReport.verification_hints.length > 0
-            ? `verification hints: ${executorReport.verification_hints.join("; ")}`
-            : "",
-        executorReport.blockers.length > 0
-            ? `blockers: ${executorReport.blockers.join("; ")}`
-            : "",
-    ].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 (!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 quoteShellArg(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
+import { readTaskArtifactMetricValues, verifyTaskArtifactContract } from "./task-artifact-contract.js";
+import { applyThresholdProgressDelta, boundCompletionJudgerForTimedOutTask, formatSelfReportEvidence, formatTimeoutBudgetEvidence, getArtifactMetricValueForDimension, hasCapturedExecutionEvidence, hasGitHubIssueUrlEvidence, isArtifactFreshnessDisagreement, isCompletionJudgerUnavailable, isDimensionUpdateDirectionAllowed, isRecoverableAgentLoopFinalizationFailure, isTimedOutAgentLoopResult, mergeMechanicalAndArtifactVerification, quoteShellArg, statusAfterIncompleteVerification, } from "./task-verifier-evidence.js";
+export { applyVerdictHandlingContextGuards } from "./task-verifier-workspace-guards.js";
 async function collectVerificationDiffs(deps, task, executionResult) {
     if (executionResult.fileDiffs && executionResult.fileDiffs.length > 0) {
         return executionResult.fileDiffs;
@@ -260,17 +139,20 @@ export async function verifyTask(deps, task, executionResult) {
     catch {
         goalForArtifactContract = null;
     }
-    const artifactResult = await verifyTaskArtifactContract(task, executionResult.agentLoop?.executionCwd
+    const taskWorkspacePath = executionResult.agentLoop?.executionCwd
         ?? executionResult.agentLoop?.requestedCwd
-        ?? await resolveTaskWorkspacePath({ stateManager: deps.stateManager, task, fallbackCwd: deps.revertCwd }), { goal: goalForArtifactContract });
+        ?? await resolveTaskWorkspacePath({ stateManager: deps.stateManager, task, fallbackCwd: deps.revertCwd });
+    const artifactResult = await verifyTaskArtifactContract(task, taskWorkspacePath, { goal: goalForArtifactContract });
+    const artifactMetricValues = artifactResult.passed
+        ? await readTaskArtifactMetricValues(task, taskWorkspacePath)
+        : new Map();
     // ─── 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.
     // Dimension updates are left to ObservationEngine (next loop iteration).
-    const githubIssueUrlPattern = /github\.com\/.+\/issues\/\d+/;
     if (executionResult.success === true &&
         executionResult.output &&
-        githubIssueUrlPattern.test(executionResult.output) &&
+        hasGitHubIssueUrlEvidence(executionResult.output) &&
         (!artifactResult.applicable || artifactResult.passed)) {
         const scResult = VerificationResultSchema.parse({
             task_id: task.id,
@@ -291,13 +173,91 @@ export async function verifyTask(deps, task, executionResult) {
                     : []),
             ],
             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 ||
+            hasCapturedExecutionEvidence(executionResult))) {
+        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) {
@@ -311,10 +271,9 @@ export async function verifyTask(deps, task, executionResult) {
     }
     let stateBlock = "";
     try {
-        const goalDataForState = await deps.stateManager.readRaw(`goals/${task.goal_id}/goal.json`);
-        if (goalDataForState && typeof goalDataForState === "object") {
-            const dims = goalDataForState.dimensions;
-            const primaryDim = dims?.find((d) => d.name === task.primary_dimension);
+        const goalDataForState = await deps.stateManager.loadGoal(task.goal_id);
+        if (goalDataForState) {
+            const primaryDim = goalDataForState.dimensions.find((d) => d.name === task.primary_dimension);
             if (primaryDim) {
                 const currentValue = typeof primaryDim.current_value === "number" ? primaryDim.current_value : undefined;
                 const threshold = primaryDim.threshold;
@@ -326,15 +285,43 @@ 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;
+    const l2Unavailable = isCompletionJudgerUnavailable(l2Result);
+    const l2UnavailableButMechanicallyPassed = l2Unavailable &&
+        executionResult.success === true &&
+        effectiveL1Result.applicable &&
+        effectiveL1Result.passed;
     if (effectiveL1Result.applicable) {
-        if (effectiveL1Result.passed && l2Result.passed) {
+        if (l2UnavailableButMechanicallyPassed) {
+            verdict = "pass";
+            confidence = 0.85;
+        }
+        else if (effectiveL1Result.passed && l2Result.passed) {
             verdict = "pass";
             confidence = 0.9;
         }
@@ -345,7 +332,7 @@ export async function verifyTask(deps, task, executionResult) {
         }
         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;
@@ -391,6 +378,9 @@ export async function verifyTask(deps, task, executionResult) {
     }
     // 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 = [
         ...(effectiveL1Result.applicable
@@ -404,7 +394,7 @@ export async function verifyTask(deps, task, executionResult) {
             : []),
         {
             layer: "independent_review",
-            description: effectiveL2.description,
+            description: independentReviewDescription,
             confidence: effectiveL2.confidence,
         },
         {
@@ -422,17 +412,25 @@ export async function verifyTask(deps, task, executionResult) {
     };
     const progressDelta = progressByVerdict[verdict] ?? 0;
     // Read goal state to get actual current dimension values for previous_value / new_value.
-    const goalDataForUpdate = await deps.stateManager.readRaw(`goals/${task.goal_id}/goal.json`);
-    const goalDimsForUpdate = goalDataForUpdate && typeof goalDataForUpdate === "object"
-        ? goalDataForUpdate.dimensions
-        : undefined;
+    const goalDataForUpdate = await deps.stateManager.loadGoal(task.goal_id);
+    const goalDimsForUpdate = goalDataForUpdate?.dimensions;
     const dimension_updates = verdict === "fail"
         ? []
         : task.target_dimensions.map((dimName) => {
+            const artifactMetricValue = getArtifactMetricValueForDimension(artifactMetricValues, dimName);
             const dim = goalDimsForUpdate?.find((d) => d.name === dimName);
             const prevVal = dim !== undefined && typeof dim.current_value === "number"
                 ? dim.current_value
                 : null;
+            if (artifactMetricValue !== null) {
+                return {
+                    dimension_name: dimName,
+                    previous_value: prevVal,
+                    new_value: artifactMetricValue,
+                    confidence,
+                    source: "artifact_contract",
+                };
+            }
             // Scale the normalized delta to raw threshold-scale space.
             const threshold = dim !== undefined &&
                 typeof dim.threshold === "object" &&
@@ -460,6 +458,7 @@ export async function verifyTask(deps, task, executionResult) {
                 previous_value: prevVal,
                 new_value: newVal,
                 confidence,
+                source: "verdict_delta",
             };
         });
     const verificationResult = VerificationResultSchema.parse({
@@ -469,6 +468,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)
@@ -494,7 +494,7 @@ export async function verifyTask(deps, task, executionResult) {
             deps.logger?.warn("[task-verifier] Impact analysis failed (non-fatal)", { error: msg });
         }
     // Persist verification result — include criteria fields from LLM review for failure context
-    await deps.stateManager.writeRaw(`verification/${task.id}/verification-result.json`, {
+    await deps.stateManager.saveTaskVerificationResult(task.id, {
         ...verificationResult,
         criteria_met: effectiveL2.criteria_met,
         criteria_total: effectiveL2.criteria_total,
@@ -511,12 +511,8 @@ export async function verifyTask(deps, task, executionResult) {
 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`);
-        const goalDimsForGuard = (goalRawForGuard &&
-            typeof goalRawForGuard === "object" &&
-            Array.isArray(goalRawForGuard.dimensions)
-            ? goalRawForGuard.dimensions
-            : []);
+        const goalRawForGuard = await deps.stateManager.loadGoal(task.goal_id);
+        const goalDimsForGuard = goalRawForGuard?.dimensions ?? [];
         const anyWorsened = verificationResult.dimension_updates.some((u) => {
             const prev = typeof u.previous_value === "number" ? u.previous_value : null;
             const next = typeof u.new_value === "number" ? u.new_value : null;
@@ -549,7 +545,7 @@ export async function handleVerdict(deps, task, verificationResult, context = {}
         let criteria_met;
         let criteria_total;
         try {
-            const raw = await deps.stateManager.readRaw(`verification/${task.id}/verification-result.json`);
+            const raw = await deps.stateManager.loadTaskVerificationResult(task.id);
             if (raw && typeof raw.criteria_met === "number")
                 criteria_met = raw.criteria_met;
             if (raw && typeof raw.criteria_total === "number")
@@ -567,7 +563,7 @@ export async function handleVerdict(deps, task, verificationResult, context = {}
             timestamp: new Date().toISOString(),
         };
         try {
-            await deps.stateManager.writeRaw(`tasks/${task.goal_id}/last-failure-context.json`, failureContext);
+            await deps.stateManager.saveTaskFailureContext(task.goal_id, failureContext);
         }
         catch {
             // Non-fatal: failure context saving is best-effort
@@ -577,12 +573,12 @@ export async function handleVerdict(deps, task, verificationResult, context = {}
         case "pass": {
             // Clear stale failure context
             try {
-                await deps.stateManager.writeRaw(`tasks/${task.goal_id}/last-failure-context.json`, null);
+                await deps.stateManager.saveTaskFailureContext(task.goal_id, null);
             }
             catch {
                 // Non-fatal
             }
-            deps.trustManager.recordSuccess(task.task_category);
+            await deps.trustManager.recordSuccess(task.task_category);
             const now = new Date().toISOString();
             const completedTask = {
                 ...task,
@@ -592,36 +588,39 @@ export async function handleVerdict(deps, task, verificationResult, context = {}
                 verification_verdict: verificationResult.verdict,
                 verification_evidence: verificationResult.evidence?.map((e) => e.description ?? String(e)) ?? [],
             };
-            await deps.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, completedTask);
+            await deps.stateManager.saveTask(completedTask);
             // Apply dimension_updates
-            const goalData = await deps.stateManager.readRaw(`goals/${task.goal_id}/goal.json`);
-            if (goalData && typeof goalData === "object") {
-                const goal = goalData;
-                const dimensions = goal.dimensions;
-                if (dimensions) {
-                    for (const dim of dimensions) {
-                        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 (!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));
-                            dim.confidence = verificationResult.confidence ?? 0.70;
-                            dim.last_observed_layer = "mechanical";
-                        }
-                        if (dim.name === task.primary_dimension) {
-                            dim.last_updated = now;
+            const goalData = await deps.stateManager.loadGoal(task.goal_id);
+            if (goalData) {
+                const dimensions = goalData.dimensions.map((dimension) => {
+                    let dim = dimension;
+                    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 (!isDimensionUpdateDirectionAllowed({
+                            intendedDirection: task.intended_direction,
+                            dim,
+                            previousValue: prev,
+                            newValue: update.new_value,
+                            logger: deps.logger,
+                        })) {
+                            return dim;
                         }
+                        dim = {
+                            ...dim,
+                            current_value: update.source === "artifact_contract"
+                                ? update.new_value
+                                : clampDimensionUpdate(prev, update.new_value, deps.logger, String(dim.name)),
+                            confidence: verificationResult.confidence ?? 0.70,
+                            last_observed_layer: "mechanical",
+                        };
                     }
-                    await deps.stateManager.writeRaw(`goals/${task.goal_id}/goal.json`, goal);
-                }
+                    if (dim.name === task.primary_dimension) {
+                        dim = { ...dim, last_updated: now };
+                    }
+                    return dim;
+                });
+                await deps.stateManager.saveGoal({ ...goalData, dimensions });
             }
             await appendTaskHistory(deps, task.goal_id, completedTask);
             await appendTaskOutcomeEvent(deps.stateManager, {
@@ -639,31 +638,34 @@ export async function handleVerdict(deps, task, verificationResult, context = {}
         case "partial": {
             const directionCorrect = isDirectionCorrect(verificationResult);
             if (directionCorrect) {
-                const goalDataPartial = await deps.stateManager.readRaw(`goals/${task.goal_id}/goal.json`);
-                if (goalDataPartial && typeof goalDataPartial === "object") {
-                    const goal = goalDataPartial;
-                    const dimensions = goal.dimensions;
-                    if (dimensions) {
-                        for (const dim of dimensions) {
-                            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 (!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));
-                                dim.confidence = verificationResult.confidence ?? 0.70;
-                                dim.last_observed_layer = "mechanical";
+                const goalDataPartial = await deps.stateManager.loadGoal(task.goal_id);
+                if (goalDataPartial) {
+                    const dimensions = goalDataPartial.dimensions.map((dimension) => {
+                        let dim = dimension;
+                        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 (!isDimensionUpdateDirectionAllowed({
+                                intendedDirection: task.intended_direction,
+                                dim,
+                                previousValue: prev,
+                                newValue: update.new_value,
+                                logger: deps.logger,
+                            })) {
+                                return dim;
                             }
+                            dim = {
+                                ...dim,
+                                current_value: update.source === "artifact_contract"
+                                    ? update.new_value
+                                    : clampDimensionUpdate(prev, update.new_value, deps.logger, String(dim.name)),
+                                confidence: verificationResult.confidence ?? 0.70,
+                                last_observed_layer: "mechanical",
+                            };
                         }
-                        await deps.stateManager.writeRaw(`goals/${task.goal_id}/goal.json`, goal);
-                    }
+                        return dim;
+                    });
+                    await deps.stateManager.saveGoal({ ...goalDataPartial, dimensions });
                 }
                 const partialTask = {
                     ...task,
@@ -671,7 +673,7 @@ export async function handleVerdict(deps, task, verificationResult, context = {}
                     verification_verdict: verificationResult.verdict,
                     verification_evidence: verificationResult.evidence?.map((e) => e.description ?? String(e)) ?? [],
                 };
-                await deps.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, partialTask);
+                await deps.stateManager.saveTask(partialTask);
                 await appendTaskHistory(deps, task.goal_id, partialTask);
                 await appendTaskOutcomeEvent(deps.stateManager, {
                     task: partialTask,
@@ -704,8 +706,8 @@ export async function handleFailure(deps, task, verificationResult, context = {}
         verification_verdict: verificationResult.verdict,
         verification_evidence: verificationResult.evidence?.map((e) => e.description ?? String(e)) ?? [],
     };
-    deps.trustManager.recordFailure(task.task_category);
-    await deps.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, updatedTask);
+    await deps.trustManager.recordFailure(task.task_category);
+    await deps.stateManager.saveTask(updatedTask);
     await appendTaskOutcomeEvent(deps.stateManager, {
         task: updatedTask,
         type: "failed",
@@ -818,11 +820,13 @@ export async function handleFailure(deps, task, verificationResult, context = {}
             attempt: updatedTask.consecutive_failure_count,
             action: "escalate",
             verificationResult,
-            reason: (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}`,
+            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 };