@martinloop/mcp 0.3.8 → 0.5.0

package/dist/vendor/core/index.js

@@ -1,3 +1,5 @@
+import { spawnSync } from "node:child_process";
+import { isAbsolute, relative, resolve } from "node:path";
 import { appendLoopEvent, createLoopRecord } from "../contracts/index.js";
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe } from "./policy.js";
 import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLeash, redactSecretsFromText, resolveExecutionProfile, evaluateVerificationLeash } from "./leash.js";
@@ -5,13 +7,20 @@ import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGround
 import { captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary } from "./rollback.js";
 import { compilePromptPacket } from "./compiler.js";
 import { makeLedgerEvent, resolveRunsRoot, runDir } from "./persistence/index.js";
+import { createDefaultExitPolicy, evaluateExitPolicy, hashProgressState, toLegacyExitDecision } from "./exits.js";
+import { createFileExitSignalSource, startExitSignalMonitor } from "./exit-signal.js";
+import { persistTerminationEnvelope } from "./termination-store.js";
+import { calculateLoopAvoidedUsd } from "./savings.js";
 import { runContextIntegrityPrecheck } from "./context-integrity.js";
 import { decideCircuitBreak } from "./trajectory.js";
+import { verifyContextHandoff, decideContextCircuitBreak } from "./context-handoff.js";
+import { verifierActuallyPassed, } from "./verified-handoff.js";
 export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary };
 export { buildContextGraphSnapshot, queryContextGraph } from "./context-graph.js";
 export { createLocalIdentityAuthority, hasIdentityScope, issueIdentityToken, verifyIdentityToken } from "./identity.js";
 export { compileExecutionPolicy } from "./policy-compiler.js";
 export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
+export { calculateAvoidedUsd, calculateLoopAvoidedUsd } from "./savings.js";
 // ─── Routing economics ─────────────────────────────────────────────────────
 export { classifyRoute, evaluatePreworkBurnPolicy, resolveModelForTier, selectBestEngine } from "./routing.js";
 // ─── Test Integrity Validation ──────────────────────────────────────────────
@@ -22,9 +31,19 @@ export { analyzeRepoStyle, buildPromptDirectives } from "./repo-analyzer.js";
 export { runContextIntegrityPrecheck } from "./context-integrity.js";
 // ─── Prompt packet compiler ──────────────────────────────────────────────────
 export { compilePromptPacket } from "./compiler.js";
+// ─── Verified Handoff builder ────────────────────────────────────────────────
+export { buildVerifiedHandoff, resolveVerifiedHandoffOutcome, toTestIntegrityVerdict, verifierActuallyPassed, } from "./verified-handoff.js";
 // ─── Persistence (RunStore, LedgerEvent, FileRunStore) ──────────────────────
 export { createFileRunStore, makeLedgerEvent, readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile, resolveRunsRoot, resolveReceiptIntegrityPath, verifyReceiptIntegrityFromFiles, writeReceiptIntegrityMaterial } from "./persistence/index.js";
 export { compileAndPersistContext } from "./persistence/index.js";
+// ─── Context Shadow — A-CTX-0 ────────────────────────────────────────────────
+export { compileContextShadow, estimateContextTokens } from "./context-shadow.js";
+// ─── Context Compiler — A-CTX-1 ──────────────────────────────────────────────
+export { compileContext, HEURISTIC_ADAPTER, MAX_RENDER_PASSES } from "./context-compiler.js";
+// ─── Context Handoff — A-CTX-2 ───────────────────────────────────────────────
+export { verifyContextHandoff, decideContextCircuitBreak } from "./context-handoff.js";
+// ─── Context Chain Gate — C1 ─────────────────────────────────────────────────
+export { evaluateChainGate, renderGatePrComment } from "./context-chain-gate.js";
 // ─── MartinLoop Memory Store ────────────────────────────────────────────────
 export { appendMemory, readMemoryEntries, getPreference, buildMemorySummary, recordPreference, recordConsent } from "./persistence/memory-store.js";
 // ─── Trace Intelligence Store ───────────────────────────────────────────────
@@ -177,6 +196,75 @@ export async function runMartin(input) {
         }));
         await persistLoopRecordIfSupported(input.store, loop);
     }
+    // ── A-CTX-2 context handoff gate ─────────────────────────────────────────
+    // The gate runs before ANY adapter call. A blocked handoff hard-stops the run
+    // and emits ledger evidence — the adapter is never invoked.
+    if (input.contextHandoff !== undefined) {
+        const handoffVerification = verifyContextHandoff({
+            handoff: input.contextHandoff,
+            producerReceiptVerified: input.producerReceiptVerified ?? false,
+            availableArtifacts: input.availableArtifacts ?? new Map()
+        });
+        if (input.store) {
+            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                kind: "context.handoff.received",
+                runId: loop.loopId,
+                payload: {
+                    handoffId: input.contextHandoff.handoffId,
+                    chainId: input.contextHandoff.chainId,
+                    producerRunId: input.contextHandoff.producerRunId,
+                    upstreamIntegrity: input.contextHandoff.upstreamIntegrity
+                }
+            }));
+        }
+        const handoffGate = decideContextCircuitBreak(handoffVerification);
+        if (handoffGate.shouldStop) {
+            if (input.store) {
+                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                    kind: "context.handoff.blocked",
+                    runId: loop.loopId,
+                    payload: {
+                        reasonCode: handoffGate.reasonCode,
+                        message: handoffGate.message,
+                        integrity: handoffVerification.integrity,
+                        reasons: handoffVerification.reasons
+                    }
+                }));
+                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                    kind: "run.exited",
+                    runId: loop.loopId,
+                    payload: {
+                        status: "exited",
+                        lifecycleState: "human_escalation",
+                        reason: handoffGate.message ?? "Context handoff verification failed.",
+                        reasonCode: handoffGate.reasonCode ?? "handoff_verification_failed"
+                    }
+                }));
+            }
+            const handoffExitDecision = {
+                shouldExit: true,
+                lifecycleState: "human_escalation",
+                status: "exited",
+                reason: handoffGate.message ?? "Context handoff verification failed.",
+                reasonCode: handoffGate.reasonCode ?? "handoff_verification_failed"
+            };
+            const finalizedLoop = finalizeLoop(loop, handoffExitDecision, now(), idFactory);
+            await persistLoopRecordIfSupported(input.store, finalizedLoop);
+            return { loop: finalizedLoop, decision: handoffExitDecision };
+        }
+        if (input.store) {
+            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                kind: "context.handoff.verified",
+                runId: loop.loopId,
+                payload: {
+                    handoffId: input.contextHandoff.handoffId,
+                    chainId: input.contextHandoff.chainId,
+                    producerRunId: input.contextHandoff.producerRunId,
+                    integrity: handoffVerification.integrity
+                }
+            }));
+        }
+    }
     const DEFAULT_FALLBACK_MODELS = [
         "claude-haiku-4-5",
         "claude-sonnet-4-6",
@@ -278,104 +366,381 @@ export async function runMartin(input) {
     let firstDeltaFilePath;
     let firstDeltaChangeType;
     let preDeltaCostUsd = 0;
-    while (loop.attempts.length < loop.budget.maxIterations) {
-        const distilled = distillContext(loop, {
-            maxRecentAttempts: useCompressedContext ? 1 : (input.maxRecentAttempts ?? 3)
-        });
-        useCompressedContext = false;
-        const attemptStartedAt = now();
-        const attemptId = makeId("att", idFactory);
-        const executingAdapter = currentAdapter;
-        const budgetPreflight = evaluateBudgetPreflight({
-            promptCharCount: distilled.focus.length + loop.task.objective.length * 3,
-            attemptCount: loop.attempts.length,
-            remainingBudgetUsd: distilled.constraints.remainingBudgetUsd,
-            perAttemptCapUsd: loop.budget.maxUsd * 0.25
-        });
-        if (!budgetPreflight.allowed) {
-            const preflightExitDecision = {
-                shouldExit: true,
-                lifecycleState: "budget_exit",
-                status: "exited",
-                reason: budgetPreflight.reason
-            };
+    // ── Eight-exit runtime control state ─────────────────────────────────────
+    const nowMs = input.nowMs ?? (() => Date.now());
+    const exitPolicy = createDefaultExitPolicy(input.budget, input.exitPolicy);
+    let activeAttemptController;
+    let observedHumanInterrupt;
+    let observedExternalEvent;
+    let terminationPromise;
+    const recentStateHashes = [];
+    let consecutiveErrors = 0;
+    // governedTurnsUsed starts from the already-completed attempt count so
+    // resumed runs count correctly; incremented once per governed attempt.
+    let governedTurnsUsed = loop.attempts.length;
+    const runsRoot = input.store?.runsRoot ?? resolveRunsRoot();
+    const exitSignalSource = input.exitSignalSource ?? createFileExitSignalSource(runsRoot);
+    // Diagnostic writes fire from sync callbacks — track them so the finally
+    // block can await completion before the run tears down.
+    const pendingControlWrites = [];
+    // Non-null when the signal monitor itself fails — rethrown at the next
+    // evaluateCheckpoint so the run surfaces the error rather than silently
+    // losing cancellation.
+    let signalMonitorError;
+    function observeSignals(signals) {
+        for (const s of signals) {
+            if (s.kind === "human_interrupt")
+                observedHumanInterrupt = s;
+            else if (s.kind === "external_event" && s.externalEvent !== undefined)
+                observedExternalEvent = s.externalEvent;
+        }
+    }
+    function queueControlDiagnostic(code, details) {
+        if (!input.store)
+            return;
+        pendingControlWrites.push(input.store.appendLedger(loop.loopId, makeLedgerEvent({
+            kind: "run.diagnostic",
+            runId: loop.loopId,
+            payload: { code, details }
+        })));
+    }
+    const runController = new AbortController();
+    const wallTimer = exitPolicy.wallClock.maxElapsedMs > 0
+        ? setTimeout(() => {
+            activeAttemptController?.abort(new Error("MartinLoop wall-clock exit reached"));
+        }, exitPolicy.wallClock.maxElapsedMs)
+        : undefined;
+    wallTimer?.unref?.();
+    const disposeSignalMonitor = startExitSignalMonitor({
+        source: exitSignalSource,
+        runId: loop.loopId,
+        controller: runController,
+        pollIntervalMs: input.exitSignalPollIntervalMs,
+        onSignal: (signals) => {
+            observeSignals(signals);
+            activeAttemptController?.abort(signals);
+        },
+        onDiagnostic: (diagnostics) => {
+            queueControlDiagnostic("exit_signal_invalid", diagnostics.map(({ kind, error }) => ({ kind, error })));
+        },
+        onError: (err) => {
+            signalMonitorError = err instanceof Error ? err : new Error(String(err));
+            activeAttemptController?.abort(err);
+        }
+    });
+    // Snapshot of the current run state for eight-exit evaluation
+    function currentExitSnapshot(phase, result) {
+        return {
+            phase,
+            evaluatedAt: now(),
+            runStartedAtMs: runStartMs,
+            nowMs: nowMs(),
+            turnsUsed: governedTurnsUsed,
+            actualUsd: loop.cost.actualUsd,
+            tokensUsed: loop.cost.tokensIn + loop.cost.tokensOut,
+            recentStateHashes: [...recentStateHashes],
+            consecutiveErrors,
+            ...(result !== undefined
+                ? {
+                    result: {
+                        status: result.status,
+                        verificationPassed: result.verificationPassed,
+                        verifierScore: result.verificationPassed ? 1 : 0
+                    }
+                }
+                : {}),
+            ...(observedHumanInterrupt !== undefined ? { humanInterrupt: observedHumanInterrupt } : {}),
+            ...(observedExternalEvent !== undefined ? { externalEvent: observedExternalEvent } : {})
+        };
+    }
+    // Idempotent termination: only the first caller writes the envelope (A1 fix)
+    function finishFromEvaluation(evaluation) {
+        if (terminationPromise !== undefined)
+            return terminationPromise;
+        const envelope = {
+            schemaVersion: "termination/1",
+            class: "operational_exit",
+            exit: evaluation
+        };
+        terminationPromise = (async () => {
             if (input.store) {
+                // persistTerminationEnvelope is atomic and returns the winning envelope
+                // (may differ from ours if another path won the race — that's fine).
+                await persistTerminationEnvelope(runDir(runsRoot, loop.loopId), envelope);
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "attempt.rejected",
+                    kind: "run.terminated",
                     runId: loop.loopId,
-                    attemptIndex: loop.attempts.length + 1,
-                    payload: { reason: budgetPreflight.reason, source: "budget_preflight" }
-                }));
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "run.exited",
-                    runId: loop.loopId,
-                    payload: createRunExitPayload(preflightExitDecision)
+                    payload: {
+                        selectedExit: evaluation.primary,
+                        matchedExits: evaluation.matched,
+                        policyVersion: evaluation.policyVersion,
+                        evaluationVersion: evaluation.schemaVersion,
+                        terminationPhase: evaluation.phase
+                    }
                 }));
             }
-            const finalizedLoop = finalizeLoop(loop, preflightExitDecision, now(), idFactory);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision: preflightExitDecision
-            };
+            return envelope;
+        })();
+        return terminationPromise;
+    }
+    async function evaluateCheckpoint(phase, result) {
+        // Surface signal-monitor failures immediately rather than silently losing cancellation
+        if (signalMonitorError !== undefined)
+            throw signalMonitorError;
+        const evaluation = evaluateExitPolicy(exitPolicy, currentExitSnapshot(phase, result));
+        return evaluation.shouldExit ? finishFromEvaluation(evaluation) : undefined;
+    }
+    async function terminateRun(envelope) {
+        if (envelope.class !== "operational_exit") {
+            throw new Error("terminateRun: unexpected non-operational envelope");
         }
-        // GATHER → ADMIT: run admission control before executing
-        currentPhase = "ADMIT";
-        // T05: Context Integrity Pre-gate — blocks authority inversion / injection before reasoning
-        //
-        // Untrusted "tool output" re-entering the loop is verifier command output from prior
-        // attempts (e.g. test runners echoing attacker-controlled strings). Pull that text from
-        // already-persisted verification.completed events so the gate scans what actually
-        // re-enters subsequent prompts, matching the documented "tool output / test output" scope.
-        const priorVerifierOutput = loop.events
-            .filter((event) => event.type === "verification.completed")
-            .flatMap((event) => event.payload?.steps ?? [])
-            .map((step) => step.detail)
-            .filter((detail) => Boolean(detail))
-            .join("\n---\n");
-        const contextPrecheck = await runContextIntegrityPrecheck(loop.loopId, loop.attempts.length + 1, runDir(resolveActiveRunsRoot(input.store), loop.loopId), {
-            userPrompt: distilled.focus,
-            toolOutput: priorVerifierOutput || undefined,
-            history: loop.attempts.map(a => a.summary).join("\n")
-        });
-        if (contextPrecheck.verdict === "context_poisoning_block") {
-            currentPhase = "ABORT";
-            const poisoningExitDecision = {
-                shouldExit: true,
-                lifecycleState: "human_escalation",
-                status: "exited",
-                reason: "Context Integrity Pre-gate: context poisoning attempt detected.",
-                failureClass: "safety_leash_blocked",
-                safetySurface: "context_integrity",
-                reasonCode: "context_poisoning_blocked"
-            };
+        const legacyDecision = toLegacyExitDecision(envelope.exit, observedExternalEvent?.disposition);
+        const exitDecision = {
+            shouldExit: legacyDecision.shouldExit,
+            lifecycleState: legacyDecision.lifecycleState,
+            status: legacyDecision.status,
+            reason: legacyDecision.reason,
+            ...(legacyDecision.reasonCode ? { reasonCode: legacyDecision.reasonCode } : {}),
+            ...(legacyDecision.failureClass
+                ? { failureClass: legacyDecision.failureClass }
+                : {})
+        };
+        if (input.store) {
+            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                kind: "run.exited",
+                runId: loop.loopId,
+                payload: createRunExitPayload(exitDecision)
+            }));
+        }
+        const routingInput = {
+            runStartMs,
+            firstDeltaDetected,
+            firstDeltaTimestampMs,
+            firstDeltaFilePath,
+            firstDeltaChangeType,
+            preDeltaCostUsd
+        };
+        // Drain all pending diagnostic ledger writes BEFORE signing the receipt.
+        // persistLoopRecordIfSupported reads ledger.jsonl to compute the integrity hash;
+        // any write that lands after that read produces a false ledger_hash_mismatch on verify.
+        if (pendingControlWrites.length > 0) {
+            await Promise.all(pendingControlWrites.splice(0));
+        }
+        const finalizedLoop = finalizeLoop(loop, exitDecision, now(), idFactory, routingInput);
+        const finalizedWithEnvelope = { ...finalizedLoop, terminationEnvelope: envelope };
+        await persistLoopRecordIfSupported(input.store, finalizedWithEnvelope);
+        return { loop: finalizedWithEnvelope, decision: exitDecision };
+    }
+    try {
+        // Poll once synchronously before the first attempt so any signal written
+        // before the run started is observed immediately (not after the first poll interval).
+        const initial = await exitSignalSource.poll(loop.loopId);
+        observeSignals(initial.signals);
+        if (initial.diagnostics.length > 0) {
+            queueControlDiagnostic("exit_signal_invalid", initial.diagnostics);
+        }
+        // Pre-run check — catches signals written before the first attempt starts
+        const preRunTerminal = await evaluateCheckpoint("pre_run");
+        if (preRunTerminal !== undefined)
+            return await terminateRun(preRunTerminal);
+        while (loop.attempts.length < loop.budget.maxIterations) {
+            const distilled = distillContext(loop, {
+                maxRecentAttempts: useCompressedContext ? 1 : (input.maxRecentAttempts ?? 3)
+            });
+            useCompressedContext = false;
+            const attemptStartedAt = now();
+            const attemptId = makeId("att", idFactory);
+            const executingAdapter = currentAdapter;
+            const budgetPreflight = evaluateBudgetPreflight({
+                promptCharCount: distilled.focus.length + loop.task.objective.length * 3,
+                attemptCount: loop.attempts.length,
+                remainingBudgetUsd: distilled.constraints.remainingBudgetUsd,
+                perAttemptCapUsd: loop.budget.maxUsd * 0.25
+            });
+            if (!budgetPreflight.allowed) {
+                const preflightExitDecision = {
+                    shouldExit: true,
+                    lifecycleState: "budget_exit",
+                    status: "exited",
+                    reason: budgetPreflight.reason
+                };
+                if (input.store) {
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "attempt.rejected",
+                        runId: loop.loopId,
+                        attemptIndex: loop.attempts.length + 1,
+                        payload: { reason: budgetPreflight.reason, source: "budget_preflight" }
+                    }));
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "run.exited",
+                        runId: loop.loopId,
+                        payload: createRunExitPayload(preflightExitDecision)
+                    }));
+                }
+                if (pendingControlWrites.length > 0) {
+                    await Promise.all(pendingControlWrites.splice(0));
+                }
+                const finalizedLoop = finalizeLoop(loop, preflightExitDecision, now(), idFactory);
+                await persistLoopRecordIfSupported(input.store, finalizedLoop);
+                return {
+                    loop: finalizedLoop,
+                    decision: preflightExitDecision
+                };
+            }
+            // GATHER → ADMIT: run admission control before executing
+            currentPhase = "ADMIT";
+            // T05: Context Integrity Pre-gate — blocks authority inversion / injection before reasoning
+            //
+            // Untrusted "tool output" re-entering the loop is verifier command output from prior
+            // attempts (e.g. test runners echoing attacker-controlled strings). Pull that text from
+            // already-persisted verification.completed events so the gate scans what actually
+            // re-enters subsequent prompts, matching the documented "tool output / test output" scope.
+            const priorVerifierOutput = loop.events
+                .filter((event) => event.type === "verification.completed")
+                .flatMap((event) => event.payload?.steps ?? [])
+                .map((step) => step.detail)
+                .filter((detail) => Boolean(detail))
+                .join("\n---\n");
+            const contextPrecheck = await runContextIntegrityPrecheck(loop.loopId, loop.attempts.length + 1, runDir(resolveActiveRunsRoot(input.store), loop.loopId), {
+                userPrompt: distilled.focus,
+                toolOutput: priorVerifierOutput || undefined,
+                history: loop.attempts.map(a => a.summary).join("\n")
+            });
+            if (contextPrecheck.verdict === "context_poisoning_block") {
+                currentPhase = "ABORT";
+                const poisoningExitDecision = {
+                    shouldExit: true,
+                    lifecycleState: "human_escalation",
+                    status: "exited",
+                    reason: "Context Integrity Pre-gate: context poisoning attempt detected.",
+                    failureClass: "safety_leash_blocked",
+                    safetySurface: "context_integrity",
+                    reasonCode: "context_poisoning_blocked"
+                };
+                if (input.store) {
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "safety.violations_found",
+                        runId: loop.loopId,
+                        payload: {
+                            verdict: contextPrecheck.verdict,
+                            signals: contextPrecheck.detectedSignals,
+                            source: "context_integrity_pregate"
+                        }
+                    }));
+                }
+                if (pendingControlWrites.length > 0) {
+                    await Promise.all(pendingControlWrites.splice(0));
+                }
+                const finalizedLoop = finalizeLoop(loop, poisoningExitDecision, now(), idFactory);
+                await persistLoopRecordIfSupported(input.store, finalizedLoop);
+                return {
+                    loop: finalizedLoop,
+                    decision: poisoningExitDecision
+                };
+            }
+            const admissionDecision = evaluateAttemptPolicy({
+                request: {
+                    loopId: loop.loopId,
+                    workspaceId: loop.workspaceId,
+                    attemptId,
+                    context: {
+                        taskTitle: loop.task.title,
+                        objective: loop.task.objective,
+                        verificationPlan: loop.task.verificationPlan,
+                        ...(loop.task.verificationStack ? { verificationStack: loop.task.verificationStack } : {}),
+                        ...(loop.task.definitionOfDonePreSatisfied !== undefined
+                            ? { definitionOfDonePreSatisfied: loop.task.definitionOfDonePreSatisfied }
+                            : {}),
+                        ...(loop.task.repoRoot ? { repoRoot: loop.task.repoRoot } : {}),
+                        ...(loop.task.allowedPaths ? { allowedPaths: loop.task.allowedPaths } : {}),
+                        ...(loop.task.deniedPaths ? { deniedPaths: loop.task.deniedPaths } : {}),
+                        ...(loop.task.acceptanceCriteria ? { acceptanceCriteria: loop.task.acceptanceCriteria } : {}),
+                        ...(loop.task.executionProfile ? { executionProfile: loop.task.executionProfile } : {}),
+                        ...(loop.task.allowedNetworkDomains
+                            ? { allowedNetworkDomains: loop.task.allowedNetworkDomains }
+                            : {}),
+                        ...(loop.task.approvalPolicy ? { approvalPolicy: loop.task.approvalPolicy } : {}),
+                        focus: distilled.focus,
+                        remainingBudgetUsd: distilled.constraints.remainingBudgetUsd,
+                        remainingIterations: distilled.constraints.remainingIterations,
+                        remainingTokens: distilled.constraints.remainingTokens
+                    },
+                    previousAttempts: loop.attempts
+                },
+                projectedUsd: budgetPreflight.estimate.estimatedAttemptCostUsd
+            });
+            if (!admissionDecision.allowed) {
+                const exitReason = admissionDecision.reason;
+                const exitDecision = {
+                    shouldExit: true,
+                    lifecycleState: admissionDecision.recommendedIntervention === "escalate_human"
+                        ? "human_escalation"
+                        : "budget_exit",
+                    status: "exited",
+                    reason: exitReason
+                };
+                if (input.store) {
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "attempt.rejected",
+                        runId: loop.loopId,
+                        attemptIndex: loop.attempts.length + 1,
+                        payload: { reason: admissionDecision.reason }
+                    }));
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "run.exited",
+                        runId: loop.loopId,
+                        payload: createRunExitPayload(exitDecision)
+                    }));
+                }
+                if (pendingControlWrites.length > 0) {
+                    await Promise.all(pendingControlWrites.splice(0));
+                }
+                const finalizedLoop = finalizeLoop(loop, exitDecision, now(), idFactory);
+                await persistLoopRecordIfSupported(input.store, finalizedLoop);
+                return {
+                    loop: finalizedLoop,
+                    decision: exitDecision
+                };
+            }
             if (input.store) {
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "safety.violations_found",
+                    kind: "attempt.admitted",
                     runId: loop.loopId,
+                    attemptIndex: loop.attempts.length + 1,
                     payload: {
-                        verdict: contextPrecheck.verdict,
-                        signals: contextPrecheck.detectedSignals,
-                        source: "context_integrity_pregate"
+                        attemptId,
+                        adapterId: executingAdapter.adapterId,
+                        providerId: executingAdapter.metadata.providerId,
+                        model: executingAdapter.metadata.model,
+                        transport: getAdapterTransport(executingAdapter)
                     }
                 }));
             }
-            const finalizedLoop = finalizeLoop(loop, poisoningExitDecision, now(), idFactory);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision: poisoningExitDecision
-            };
-        }
-        const admissionDecision = evaluateAttemptPolicy({
-            request: {
+            // ADMIT → PATCH
+            currentPhase = "PATCH";
+            loop = appendLoopEvent(loop, {
+                type: "attempt.started",
+                lifecycleState: "running",
+                payload: {
+                    attemptId,
+                    adapterId: executingAdapter.adapterId,
+                    model: executingAdapter.metadata.model,
+                    policyPhase: currentPhase
+                }
+            }, { now: attemptStartedAt, idFactory });
+            const request = {
                 loopId: loop.loopId,
+                workspaceId: loop.workspaceId,
                 attemptId,
                 context: {
                     taskTitle: loop.task.title,
                     objective: loop.task.objective,
                     verificationPlan: loop.task.verificationPlan,
                     ...(loop.task.verificationStack ? { verificationStack: loop.task.verificationStack } : {}),
+                    ...(loop.task.mutationMode ? { mutationMode: loop.task.mutationMode } : {}),
+                    ...(loop.task.definitionOfDonePreSatisfied !== undefined
+                        ? { definitionOfDonePreSatisfied: loop.task.definitionOfDonePreSatisfied }
+                        : {}),
                     ...(loop.task.repoRoot ? { repoRoot: loop.task.repoRoot } : {}),
                     ...(loop.task.allowedPaths ? { allowedPaths: loop.task.allowedPaths } : {}),
                     ...(loop.task.deniedPaths ? { deniedPaths: loop.task.deniedPaths } : {}),
@@ -391,658 +756,659 @@ export async function runMartin(input) {
                     remainingTokens: distilled.constraints.remainingTokens
                 },
                 previousAttempts: loop.attempts
-            },
-            projectedUsd: budgetPreflight.estimate.estimatedAttemptCostUsd
-        });
-        if (!admissionDecision.allowed) {
-            const exitReason = admissionDecision.reason;
-            const exitDecision = {
-                shouldExit: true,
-                lifecycleState: admissionDecision.recommendedIntervention === "escalate_human"
-                    ? "human_escalation"
-                    : "budget_exit",
-                status: "exited",
-                reason: exitReason
             };
-            if (input.store) {
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "attempt.rejected",
-                    runId: loop.loopId,
-                    attemptIndex: loop.attempts.length + 1,
-                    payload: { reason: admissionDecision.reason }
-                }));
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "run.exited",
-                    runId: loop.loopId,
-                    payload: createRunExitPayload(exitDecision)
-                }));
+            const tracksWorkspaceMutations = request.context.repoRoot !== undefined &&
+                executingAdapter.metadata.capabilities?.workspaceMutations !== false;
+            // Pre-attempt: check signals that arrived during guard evaluation
+            const preAttemptTerminal = await evaluateCheckpoint("pre_attempt");
+            if (preAttemptTerminal !== undefined)
+                return await terminateRun(preAttemptTerminal);
+            activeAttemptController = new AbortController();
+            governedTurnsUsed += 1;
+            const rollbackBoundary = tracksWorkspaceMutations
+                ? await captureRollbackBoundary({
+                    repoRoot: request.context.repoRoot,
+                    capturedAt: attemptStartedAt
+                })
+                : undefined;
+            let result;
+            try {
+                result = await executingAdapter.execute({
+                    ...request,
+                    signal: activeAttemptController.signal
+                });
             }
-            const finalizedLoop = finalizeLoop(loop, exitDecision, now(), idFactory);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision: exitDecision
-            };
-        }
-        if (input.store) {
-            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                kind: "attempt.admitted",
-                runId: loop.loopId,
-                attemptIndex: loop.attempts.length + 1,
-                payload: {
-                    attemptId,
-                    adapterId: executingAdapter.adapterId,
-                    providerId: executingAdapter.metadata.providerId,
-                    model: executingAdapter.metadata.model,
-                    transport: getAdapterTransport(executingAdapter)
-                }
-            }));
-        }
-        // ADMIT → PATCH
-        currentPhase = "PATCH";
-        loop = appendLoopEvent(loop, {
-            type: "attempt.started",
-            lifecycleState: "running",
-            payload: {
+            catch (execError) {
+                // Convert an abort (wall-clock or signal-driven) into the correct exit
+                // rather than letting it propagate as an unhandled exception.
+                const abortTerminal = await evaluateCheckpoint("post_attempt");
+                if (abortTerminal !== undefined)
+                    return await terminateRun(abortTerminal);
+                throw execError;
+            }
+            finally {
+                activeAttemptController = undefined;
+            }
+            const attemptCompletedAt = now();
+            const compiledContext = compilePromptPacket(request);
+            const expectedVerifierBinding = resolveExpectedVerifierBinding(request);
+            const verification = normalizeVerificationOutcome(result, expectedVerifierBinding);
+            // PATCH → VERIFY
+            currentPhase = "VERIFY";
+            let failure = result.status === "failed"
+                ? classifyFailure({ attempts: loop.attempts, result })
+                : undefined;
+            const currentAttemptIndex = loop.attempts.length + 1;
+            const attempt = {
                 attemptId,
+                index: currentAttemptIndex,
                 adapterId: executingAdapter.adapterId,
                 model: executingAdapter.metadata.model,
-                policyPhase: currentPhase
-            }
-        }, { now: attemptStartedAt, idFactory });
-        const request = {
-            loopId: loop.loopId,
-            attemptId,
-            context: {
-                taskTitle: loop.task.title,
-                objective: loop.task.objective,
-                verificationPlan: loop.task.verificationPlan,
-                ...(loop.task.verificationStack ? { verificationStack: loop.task.verificationStack } : {}),
-                ...(loop.task.mutationMode ? { mutationMode: loop.task.mutationMode } : {}),
-                ...(loop.task.repoRoot ? { repoRoot: loop.task.repoRoot } : {}),
-                ...(loop.task.allowedPaths ? { allowedPaths: loop.task.allowedPaths } : {}),
-                ...(loop.task.deniedPaths ? { deniedPaths: loop.task.deniedPaths } : {}),
-                ...(loop.task.acceptanceCriteria ? { acceptanceCriteria: loop.task.acceptanceCriteria } : {}),
-                ...(loop.task.executionProfile ? { executionProfile: loop.task.executionProfile } : {}),
-                ...(loop.task.allowedNetworkDomains
-                    ? { allowedNetworkDomains: loop.task.allowedNetworkDomains }
+                startedAt: attemptStartedAt,
+                completedAt: attemptCompletedAt,
+                summary: result.summary,
+                ...(failure?.failureClass ? { failureClass: failure.failureClass } : {}),
+                ...(failure?.recommendedIntervention
+                    ? { intervention: failure.recommendedIntervention }
                     : {}),
-                ...(loop.task.approvalPolicy ? { approvalPolicy: loop.task.approvalPolicy } : {}),
-                focus: distilled.focus,
-                remainingBudgetUsd: distilled.constraints.remainingBudgetUsd,
-                remainingIterations: distilled.constraints.remainingIterations,
-                remainingTokens: distilled.constraints.remainingTokens
-            },
-            previousAttempts: loop.attempts
-        };
-        const tracksWorkspaceMutations = request.context.repoRoot !== undefined &&
-            executingAdapter.metadata.capabilities?.workspaceMutations !== false;
-        const rollbackBoundary = tracksWorkspaceMutations
-            ? await captureRollbackBoundary({
-                repoRoot: request.context.repoRoot,
-                capturedAt: attemptStartedAt
-            })
-            : undefined;
-        const result = await executingAdapter.execute(request);
-        const attemptCompletedAt = now();
-        const compiledContext = compilePromptPacket(request);
-        const verification = normalizeVerificationOutcome(result);
-        // PATCH → VERIFY
-        currentPhase = "VERIFY";
-        let failure = result.status === "failed"
-            ? classifyFailure({ attempts: loop.attempts, result })
-            : undefined;
-        const currentAttemptIndex = loop.attempts.length + 1;
-        const attempt = {
-            attemptId,
-            index: currentAttemptIndex,
-            adapterId: executingAdapter.adapterId,
-            model: executingAdapter.metadata.model,
-            startedAt: attemptStartedAt,
-            completedAt: attemptCompletedAt,
-            summary: result.summary,
-            ...(failure?.failureClass ? { failureClass: failure.failureClass } : {}),
-            ...(failure?.recommendedIntervention
-                ? { intervention: failure.recommendedIntervention }
-                : {}),
-            ...(failure?.diagnosticHint ? { diagnosticHint: failure.diagnosticHint } : {})
-        };
-        loop = {
-            ...loop,
-            attempts: [...loop.attempts, attempt],
-            cost: {
-                actualUsd: roundUsd(loop.cost.actualUsd + getUsageUsd(result.usage)),
-                avoidedUsd: loop.cost.avoidedUsd,
-                tokensIn: loop.cost.tokensIn + result.usage.tokensIn,
-                tokensOut: loop.cost.tokensOut + result.usage.tokensOut,
-                ...(result.usage.estimatedUsd !== undefined
-                    ? {
-                        estimatedUsd: roundUsd((loop.cost.estimatedUsd ?? loop.cost.actualUsd) + result.usage.estimatedUsd)
-                    }
-                    : {}),
-                provenance: mergeCostProvenance(loop.cost.provenance, getUsageProvenance(result.usage)),
-                ...(result.usage.providerSettlement
-                    ? { providerSettlement: result.usage.providerSettlement }
-                    : {})
-            },
-            updatedAt: attemptCompletedAt
-        };
-        loop = appendLoopEvent(loop, {
-            type: "attempt.completed",
-            lifecycleState: "running",
-            payload: { attemptId, status: result.status, summary: result.summary }
-        }, { now: attemptCompletedAt, idFactory });
-        const previousVerifierScore = getLastVerifierScore(loop);
-        if (failure) {
-            if (failure.recommendedIntervention === "compress_context") {
-                useCompressedContext = true;
-            }
-            let adapterSwitched = false;
-            if (failure.recommendedIntervention === "switch_adapter") {
-                const nextAdapter = adapterChain[currentAdapterIndex + 1];
-                if (nextAdapter) {
-                    currentAdapterIndex += 1;
-                    currentAdapter = nextAdapter;
-                    adapterSwitched = true;
-                }
-            }
-            if (failure.recommendedIntervention === "change_model" && currentAdapter.withModel) {
-                const fallbackModels = input.fallbackModels ?? DEFAULT_FALLBACK_MODELS;
-                const nextModel = fallbackModels[loop.attempts.length % fallbackModels.length];
-                if (nextModel) {
-                    currentAdapter = currentAdapter.withModel(nextModel);
-                }
-            }
-            loop = appendLoopEvent(loop, {
-                type: "failure.classified",
-                lifecycleState: "running",
-                payload: {
-                    attemptId,
-                    failureClass: failure.failureClass,
-                    rationale: failure.rationale
-                }
-            }, { now: attemptCompletedAt, idFactory });
+                ...(failure?.diagnosticHint ? { diagnosticHint: failure.diagnosticHint } : {})
+            };
+            loop = {
+                ...loop,
+                attempts: [...loop.attempts, attempt],
+                cost: {
+                    actualUsd: roundUsd(loop.cost.actualUsd + getUsageUsd(result.usage)),
+                    avoidedUsd: loop.cost.avoidedUsd,
+                    tokensIn: loop.cost.tokensIn + result.usage.tokensIn,
+                    tokensOut: loop.cost.tokensOut + result.usage.tokensOut,
+                    ...(result.usage.estimatedUsd !== undefined
+                        ? {
+                            estimatedUsd: roundUsd((loop.cost.estimatedUsd ?? loop.cost.actualUsd) + result.usage.estimatedUsd)
+                        }
+                        : {}),
+                    provenance: mergeCostProvenance(loop.cost.provenance, getUsageProvenance(result.usage)),
+                    ...(result.usage.providerSettlement
+                        ? { providerSettlement: result.usage.providerSettlement }
+                        : {})
+                },
+                updatedAt: attemptCompletedAt
+            };
+            // ── Eight-exit state tracking ─────────────────────────────────────────
+            consecutiveErrors = result.status === "failed" ? consecutiveErrors + 1 : 0;
+            const stateHash = hashProgressState({
+                summary: result.summary,
+                verificationPassed: verification.passed,
+                status: result.status
+            });
+            if (recentStateHashes.length >= exitPolicy.progress.windowSize)
+                recentStateHashes.shift();
+            recentStateHashes.push(stateHash);
             loop = appendLoopEvent(loop, {
-                type: "intervention.selected",
+                type: "attempt.completed",
                 lifecycleState: "running",
-                payload: { attemptId, intervention: failure.recommendedIntervention }
+                payload: { attemptId, status: result.status, summary: result.summary }
             }, { now: attemptCompletedAt, idFactory });
-            if (adapterSwitched) {
+            // post_attempt check is deferred until after verification.completed and all
+            // per-attempt ledger writes — see the check just before before_retry below.
+            const previousVerifierScore = getLastVerifierScore(loop);
+            if (failure) {
+                if (failure.recommendedIntervention === "compress_context") {
+                    useCompressedContext = true;
+                }
+                let adapterSwitched = false;
+                if (failure.recommendedIntervention === "switch_adapter") {
+                    const nextAdapter = adapterChain[currentAdapterIndex + 1];
+                    if (nextAdapter) {
+                        currentAdapterIndex += 1;
+                        currentAdapter = nextAdapter;
+                        adapterSwitched = true;
+                    }
+                }
+                if (failure.recommendedIntervention === "change_model" && currentAdapter.withModel) {
+                    const fallbackModels = input.fallbackModels ?? DEFAULT_FALLBACK_MODELS;
+                    const nextModel = fallbackModels[loop.attempts.length % fallbackModels.length];
+                    if (nextModel) {
+                        currentAdapter = currentAdapter.withModel(nextModel);
+                    }
+                }
                 loop = appendLoopEvent(loop, {
-                    type: "intervention.selected",
+                    type: "failure.classified",
                     lifecycleState: "running",
                     payload: {
                         attemptId,
-                        intervention: "switch_adapter",
-                        nextAdapterId: currentAdapter.adapterId,
-                        transport: getAdapterTransport(currentAdapter)
+                        failureClass: failure.failureClass,
+                        rationale: failure.rationale
                     }
                 }, { now: attemptCompletedAt, idFactory });
+                loop = appendLoopEvent(loop, {
+                    type: "intervention.selected",
+                    lifecycleState: "running",
+                    payload: { attemptId, intervention: failure.recommendedIntervention }
+                }, { now: attemptCompletedAt, idFactory });
+                if (adapterSwitched) {
+                    loop = appendLoopEvent(loop, {
+                        type: "intervention.selected",
+                        lifecycleState: "running",
+                        payload: {
+                            attemptId,
+                            intervention: "switch_adapter",
+                            nextAdapterId: currentAdapter.adapterId,
+                            transport: getAdapterTransport(currentAdapter)
+                        }
+                    }, { now: attemptCompletedAt, idFactory });
+                }
             }
-        }
-        loop = appendLoopEvent(loop, {
-            type: "verification.completed",
-            lifecycleState: verification.passed ? "completed" : "verifying",
-            payload: {
-                attemptId,
-                attemptIndex: currentAttemptIndex,
-                passed: verification.passed,
-                summary: verification.summary,
-                ...(verification.steps?.length ? { steps: verification.steps } : {}),
-                ...(verification.warnings?.length ? { warnings: verification.warnings } : {})
-            }
-        }, { now: attemptCompletedAt, idFactory });
-        const costState = evaluateCostGovernor({
-            budget: loop.budget,
-            cost: loop.cost,
-            attemptsUsed: loop.attempts.length
-        });
-        loop = appendLoopEvent(loop, {
-            type: "budget.updated",
-            lifecycleState: costState.shouldStop ? "budget_exit" : "running",
-            payload: {
-                actualUsd: loop.cost.actualUsd,
-                remainingBudgetUsd: costState.remainingBudgetUsd,
-                pressure: costState.pressure,
-                provenance: loop.cost.provenance
-            }
-        }, { now: now(), idFactory });
-        if (input.store) {
-            const settlement = createBudgetSettlement({
-                runId: loop.loopId,
-                attemptIndex: currentAttemptIndex,
-                usage: result.usage,
-                estimate: budgetPreflight.estimate,
-                settledAt: attemptCompletedAt
+            const costState = evaluateCostGovernor({
+                budget: loop.budget,
+                cost: loop.cost,
+                attemptsUsed: loop.attempts.length
             });
-            await input.store.writeAttemptArtifacts(loop.loopId, currentAttemptIndex, {
-                compiledContext,
-                verification,
-                ...(rollbackBoundary ? { rollbackBoundary } : {})
-            });
-            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                kind: "patch.generated",
-                runId: loop.loopId,
-                attemptIndex: currentAttemptIndex,
-                payload: { status: result.status, summary: result.summary }
-            }));
-            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                kind: "verification.completed",
-                runId: loop.loopId,
-                attemptIndex: currentAttemptIndex,
-                payload: {
-                    attemptId,
-                    passed: verification.passed,
-                    summary: verification.summary,
-                    ...(verification.steps?.length ? { steps: verification.steps } : {}),
-                    ...(verification.warnings?.length ? { warnings: verification.warnings } : {})
-                }
-            }));
-            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                kind: "budget.settled",
-                runId: loop.loopId,
-                attemptIndex: currentAttemptIndex,
+            loop = appendLoopEvent(loop, {
+                type: "budget.updated",
+                lifecycleState: costState.shouldStop ? "budget_exit" : "running",
                 payload: {
-                    actualUsd: settlement.totalActualUsd,
-                    estimatedUsd: result.usage.estimatedUsd,
-                    tokensIn: result.usage.tokensIn,
-                    tokensOut: result.usage.tokensOut,
-                    cachedInputTokens: result.usage.cachedInputTokens,
-                    reasoningTokensOut: result.usage.reasoningTokensOut,
-                    provenance: getUsageProvenance(result.usage),
-                    transport: getAdapterTransport(executingAdapter),
-                    providerId: executingAdapter.metadata.providerId,
-                    model: executingAdapter.metadata.model,
-                    providerSettlement: result.usage.providerSettlement,
-                    patchCost: settlement.patchCost,
-                    verificationCost: settlement.verificationCost,
-                    varianceUsd: settlement.varianceUsd,
-                    preflightEstimateUsd: settlement.preflightEstimateUsd
+                    actualUsd: loop.cost.actualUsd,
+                    remainingBudgetUsd: costState.remainingBudgetUsd,
+                    pressure: costState.pressure,
+                    provenance: loop.cost.provenance
                 }
-            }));
-        }
-        const changedFiles = tracksWorkspaceMutations
-            ? resolveChangedFiles(result, request.context.repoRoot, rollbackBoundary)
-            : [];
-        // Routing economics: detect first meaningful workspace delta
-        if (!firstDeltaDetected && changedFiles.length > 0) {
-            const meaningfulFile = changedFiles.find((f) => !isMartinLoopMetadata(f));
-            if (meaningfulFile) {
-                firstDeltaDetected = true;
-                firstDeltaTimestampMs = Date.now();
-                firstDeltaFilePath = meaningfulFile;
-                firstDeltaChangeType = "modify";
-                preDeltaCostUsd = roundUsd(loop.cost.actualUsd - getUsageUsd(result.usage));
-            }
-        }
-        if (!firstDeltaDetected) {
-            preDeltaCostUsd = loop.cost.actualUsd;
-        }
-        // Evidence is only reliable when the adapter explicitly reported files OR git actually
-        // returned a non-empty list. A repoRoot alone is insufficient — git may fail (e.g. not
-        // a git repo) and silently return [], which would falsely trigger no_code_change.
-        const changedFileEvidenceAvailable = result.execution?.changedFiles !== undefined || changedFiles.length > 0;
-        const isVerifierOnlyAdapter = executingAdapter.adapterId === "direct:verifier:verify-only";
-        const patchTruthCountsEdits = !isVerifierOnlyAdapter && changedFileEvidenceAvailable;
-        const filesystemDecision = evaluateFilesystemLeash({
-            repoRoot: request.context.repoRoot,
-            changedFiles,
-            allowedPaths: request.context.allowedPaths,
-            deniedPaths: request.context.deniedPaths
-        });
-        if (!filesystemDecision.allowed) {
-            const patchDecision = evaluatePatchDecision({
-                verificationPassed: result.verification.passed,
-                previousVerifierScore,
-                verifierScore: result.verification.passed ? 1 : 0,
-                scopeViolationCount: filesystemDecision.violations.length,
-                changedFileCount: changedFiles.length,
-                diffNovelty: changedFiles.length > 0 ? 1 : 0,
-                diffStats: result.execution?.diffStats,
-                costUsd: getUsageUsd(result.usage),
-                summary: result.summary
-            });
-            const filesystemExitDecision = {
-                shouldExit: true,
-                lifecycleState: "human_escalation",
-                status: "exited",
-                reason: filesystemDecision.reason ?? "Safety leash blocked filesystem changes.",
-                ...classifySafetyLeashExit(filesystemDecision, "filesystem")
-            };
-            const rollbackOutcome = await restoreRollbackBoundary({
-                repoRoot: request.context.repoRoot,
-                boundary: rollbackBoundary,
-                restoredAt: attemptCompletedAt,
-                decision: patchDecision.decision
-            });
+            }, { now: now(), idFactory });
             if (input.store) {
+                const settlement = createBudgetSettlement({
+                    runId: loop.loopId,
+                    attemptIndex: currentAttemptIndex,
+                    usage: result.usage,
+                    estimate: budgetPreflight.estimate,
+                    settledAt: attemptCompletedAt
+                });
                 await input.store.writeAttemptArtifacts(loop.loopId, currentAttemptIndex, {
                     compiledContext,
-                    leash: createLeashArtifact(filesystemDecision, currentAttemptIndex),
-                    patchScore: patchDecision.score,
-                    patchDecision: toPatchDecisionArtifact(patchDecision),
-                    ...(rollbackBoundary ? { rollbackBoundary } : {}),
-                    ...(rollbackOutcome ? { rollbackOutcome } : {})
+                    verification,
+                    ...(rollbackBoundary ? { rollbackBoundary } : {})
                 });
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "safety.violations_found",
+                    kind: "patch.generated",
                     runId: loop.loopId,
                     attemptIndex: currentAttemptIndex,
-                    payload: {
-                        surface: "filesystem",
-                        blocked: true,
-                        attemptIndex: currentAttemptIndex,
-                        violations: filesystemDecision.violations
-                    }
+                    payload: { status: result.status, summary: result.summary }
                 }));
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "attempt.discarded",
+                    kind: "budget.settled",
                     runId: loop.loopId,
                     attemptIndex: currentAttemptIndex,
                     payload: {
-                        decision: patchDecision.decision,
-                        reason: patchDecision.summary,
-                        reasonCodes: patchDecision.reasonCodes,
-                        score: patchDecision.score.score
+                        actualUsd: settlement.totalActualUsd,
+                        estimatedUsd: result.usage.estimatedUsd,
+                        tokensIn: result.usage.tokensIn,
+                        tokensOut: result.usage.tokensOut,
+                        cachedInputTokens: result.usage.cachedInputTokens,
+                        reasoningTokensOut: result.usage.reasoningTokensOut,
+                        provenance: getUsageProvenance(result.usage),
+                        transport: getAdapterTransport(executingAdapter),
+                        providerId: executingAdapter.metadata.providerId,
+                        model: executingAdapter.metadata.model,
+                        providerSettlement: result.usage.providerSettlement,
+                        patchCost: settlement.patchCost,
+                        verificationCost: settlement.verificationCost,
+                        varianceUsd: settlement.varianceUsd,
+                        preflightEstimateUsd: settlement.preflightEstimateUsd
                     }
                 }));
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "run.exited",
-                    runId: loop.loopId,
-                    payload: createRunExitPayload(filesystemExitDecision)
-                }));
             }
-            const finalizedLoop = finalizeLoop(loop, filesystemExitDecision, now(), idFactory);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision: filesystemExitDecision
-            };
-        }
-        const changeApprovalDecision = evaluateChangeApprovalLeash({
-            changedFiles,
-            executionProfile: request.context.executionProfile,
-            approvalPolicy: request.context.approvalPolicy
-        });
-        if (!changeApprovalDecision.allowed) {
-            const patchDecision = evaluatePatchDecision({
-                verificationPassed: result.verification.passed,
-                previousVerifierScore,
-                verifierScore: result.verification.passed ? 1 : 0,
-                safetyViolationCount: changeApprovalDecision.violations.length,
-                changedFileCount: changedFiles.length,
-                diffNovelty: changedFiles.length > 0 ? 1 : 0,
-                diffStats: result.execution?.diffStats,
-                costUsd: getUsageUsd(result.usage),
-                humanApprovalRequired: true,
-                summary: result.summary
-            });
-            const approvalExitDecision = {
-                shouldExit: true,
-                lifecycleState: "human_escalation",
-                status: "exited",
-                reason: changeApprovalDecision.reason ??
-                    "Safety leash blocked dependency or migration changes that require approval.",
-                ...classifySafetyLeashExit(changeApprovalDecision, "dependency")
-            };
-            const rollbackOutcome = await restoreRollbackBoundary({
+            const changedFiles = tracksWorkspaceMutations
+                ? resolveChangedFiles(result, request.context.repoRoot, rollbackBoundary)
+                : [];
+            // Routing economics: detect first meaningful workspace delta
+            if (!firstDeltaDetected && changedFiles.length > 0) {
+                const meaningfulFile = changedFiles.find((f) => !isMartinLoopMetadata(f));
+                if (meaningfulFile) {
+                    firstDeltaDetected = true;
+                    firstDeltaTimestampMs = Date.now();
+                    firstDeltaFilePath = meaningfulFile;
+                    firstDeltaChangeType = "modify";
+                    preDeltaCostUsd = roundUsd(loop.cost.actualUsd - getUsageUsd(result.usage));
+                }
+            }
+            if (!firstDeltaDetected) {
+                preDeltaCostUsd = loop.cost.actualUsd;
+            }
+            // Evidence is only reliable when the adapter explicitly reported files OR git actually
+            // returned a non-empty list. A repoRoot alone is insufficient — git may fail (e.g. not
+            // a git repo) and silently return [], which would falsely trigger no_code_change.
+            const changedFileEvidenceAvailable = result.execution?.changedFiles !== undefined || changedFiles.length > 0;
+            const filesystemDecision = evaluateFilesystemLeash({
                 repoRoot: request.context.repoRoot,
-                boundary: rollbackBoundary,
-                restoredAt: attemptCompletedAt,
-                decision: patchDecision.decision
+                changedFiles,
+                allowedPaths: request.context.allowedPaths,
+                deniedPaths: request.context.deniedPaths
+            });
+            if (!filesystemDecision.allowed) {
+                const patchDecision = evaluatePatchDecision({
+                    verificationPassed: result.verification.passed,
+                    previousVerifierScore,
+                    verifierScore: result.verification.passed ? 1 : 0,
+                    scopeViolationCount: filesystemDecision.violations.length,
+                    changedFileCount: changedFiles.length,
+                    diffNovelty: changedFiles.length > 0 ? 1 : 0,
+                    diffStats: result.execution?.diffStats,
+                    costUsd: getUsageUsd(result.usage),
+                    summary: result.summary
+                });
+                const filesystemExitDecision = {
+                    shouldExit: true,
+                    lifecycleState: "human_escalation",
+                    status: "exited",
+                    reason: filesystemDecision.reason ?? "Safety leash blocked filesystem changes.",
+                    ...classifySafetyLeashExit(filesystemDecision, "filesystem")
+                };
+                const rollbackOutcome = await restoreRollbackBoundary({
+                    repoRoot: request.context.repoRoot,
+                    boundary: rollbackBoundary,
+                    restoredAt: attemptCompletedAt,
+                    decision: patchDecision.decision
+                });
+                if (input.store) {
+                    await input.store.writeAttemptArtifacts(loop.loopId, currentAttemptIndex, {
+                        compiledContext,
+                        leash: createLeashArtifact(filesystemDecision, currentAttemptIndex),
+                        patchScore: patchDecision.score,
+                        patchDecision: toPatchDecisionArtifact(patchDecision),
+                        ...(rollbackBoundary ? { rollbackBoundary } : {}),
+                        ...(rollbackOutcome ? { rollbackOutcome } : {})
+                    });
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "safety.violations_found",
+                        runId: loop.loopId,
+                        attemptIndex: currentAttemptIndex,
+                        payload: {
+                            surface: "filesystem",
+                            blocked: true,
+                            attemptIndex: currentAttemptIndex,
+                            violations: filesystemDecision.violations
+                        }
+                    }));
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "attempt.discarded",
+                        runId: loop.loopId,
+                        attemptIndex: currentAttemptIndex,
+                        payload: {
+                            decision: patchDecision.decision,
+                            reason: patchDecision.summary,
+                            reasonCodes: patchDecision.reasonCodes,
+                            score: patchDecision.score.score
+                        }
+                    }));
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "run.exited",
+                        runId: loop.loopId,
+                        payload: createRunExitPayload(filesystemExitDecision)
+                    }));
+                }
+                if (pendingControlWrites.length > 0) {
+                    await Promise.all(pendingControlWrites.splice(0));
+                }
+                const finalizedLoop = finalizeLoop(loop, filesystemExitDecision, now(), idFactory);
+                await persistLoopRecordIfSupported(input.store, finalizedLoop);
+                return {
+                    loop: finalizedLoop,
+                    decision: filesystemExitDecision
+                };
+            }
+            const changeApprovalDecision = evaluateChangeApprovalLeash({
+                changedFiles,
+                executionProfile: request.context.executionProfile,
+                approvalPolicy: request.context.approvalPolicy
             });
+            if (!changeApprovalDecision.allowed) {
+                const patchDecision = evaluatePatchDecision({
+                    verificationPassed: result.verification.passed,
+                    previousVerifierScore,
+                    verifierScore: result.verification.passed ? 1 : 0,
+                    safetyViolationCount: changeApprovalDecision.violations.length,
+                    changedFileCount: changedFiles.length,
+                    diffNovelty: changedFiles.length > 0 ? 1 : 0,
+                    diffStats: result.execution?.diffStats,
+                    costUsd: getUsageUsd(result.usage),
+                    humanApprovalRequired: true,
+                    summary: result.summary
+                });
+                const approvalExitDecision = {
+                    shouldExit: true,
+                    lifecycleState: "human_escalation",
+                    status: "exited",
+                    reason: changeApprovalDecision.reason ??
+                        "Safety leash blocked dependency or migration changes that require approval.",
+                    ...classifySafetyLeashExit(changeApprovalDecision, "dependency")
+                };
+                const rollbackOutcome = await restoreRollbackBoundary({
+                    repoRoot: request.context.repoRoot,
+                    boundary: rollbackBoundary,
+                    restoredAt: attemptCompletedAt,
+                    decision: patchDecision.decision
+                });
+                if (input.store) {
+                    await input.store.writeAttemptArtifacts(loop.loopId, currentAttemptIndex, {
+                        compiledContext,
+                        leash: createLeashArtifact(changeApprovalDecision, currentAttemptIndex),
+                        patchScore: patchDecision.score,
+                        patchDecision: toPatchDecisionArtifact(patchDecision),
+                        ...(rollbackBoundary ? { rollbackBoundary } : {}),
+                        ...(rollbackOutcome ? { rollbackOutcome } : {})
+                    });
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "safety.violations_found",
+                        runId: loop.loopId,
+                        attemptIndex: currentAttemptIndex,
+                        payload: {
+                            surface: "dependency",
+                            blocked: true,
+                            profile: changeApprovalDecision.profile ?? executionProfile.name,
+                            attemptIndex: currentAttemptIndex,
+                            violations: changeApprovalDecision.violations
+                        }
+                    }));
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "attempt.discarded",
+                        runId: loop.loopId,
+                        attemptIndex: currentAttemptIndex,
+                        payload: {
+                            decision: patchDecision.decision,
+                            reason: patchDecision.summary,
+                            reasonCodes: patchDecision.reasonCodes,
+                            score: patchDecision.score.score
+                        }
+                    }));
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "run.exited",
+                        runId: loop.loopId,
+                        payload: createRunExitPayload(approvalExitDecision)
+                    }));
+                }
+                if (pendingControlWrites.length > 0) {
+                    await Promise.all(pendingControlWrites.splice(0));
+                }
+                const finalizedLoop = finalizeLoop(loop, approvalExitDecision, now(), idFactory);
+                await persistLoopRecordIfSupported(input.store, finalizedLoop);
+                return {
+                    loop: finalizedLoop,
+                    decision: approvalExitDecision
+                };
+            }
+            // VERIFY: Run grounding scan on patch diff if available
+            // Uses the task's repoRoot to build/load the grounding index, then scans any diff
+            let groundingScanResult;
+            const patchDiff = buildPatchDiff(result, changedFiles);
+            if (patchDiff && input.task.repoRoot) {
+                try {
+                    const groundingIndex = await loadOrBuildRepoGroundingIndex(input.task.repoRoot);
+                    groundingScanResult = reconcileExistingGroundingFiles(scanPatchForGroundingViolations(patchDiff, groundingIndex, {
+                        allowedPaths: input.task.allowedPaths
+                    }), input.task.repoRoot, rollbackBoundary);
+                    if (input.store && groundingScanResult.violations.length > 0) {
+                        await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                            kind: "grounding.violations_found",
+                            runId: loop.loopId,
+                            attemptIndex: currentAttemptIndex,
+                            payload: {
+                                violationCount: groundingScanResult.violations.length,
+                                resolvedFiles: groundingScanResult.resolvedFiles,
+                                contentOnly: groundingScanResult.contentOnly,
+                                violations: groundingScanResult.violations.slice(0, 10)
+                            }
+                        }));
+                    }
+                }
+                catch {
+                    // Grounding scan is best-effort — never fail the loop because of a scan error
+                }
+            }
+            const shouldEvaluatePatchTruth = result.status === "completed" && tracksWorkspaceMutations;
+            let patchDecision;
+            if (shouldEvaluatePatchTruth) {
+                patchDecision = evaluatePatchDecision({
+                    verificationPassed: verification.passed,
+                    previousVerifierScore,
+                    verifierScore: verification.passed ? 1 : 0,
+                    groundingViolationCount: groundingScanResult?.violations.length ?? 0,
+                    changedFileCount: changedFileEvidenceAvailable ? changedFiles.length : undefined,
+                    mutationRequired: request.context.mutationMode === "edit",
+                    definitionOfDonePreSatisfied: request.context.definitionOfDonePreSatisfied,
+                    diffNovelty: changedFileEvidenceAvailable ? (changedFiles.length > 0 ? 1 : 0) : undefined,
+                    diffStats: result.execution?.diffStats,
+                    costUsd: getUsageUsd(result.usage),
+                    summary: result.summary
+                });
+            }
+            let rollbackOutcome;
+            if (patchDecision && patchDecision.decision !== "KEEP") {
+                rollbackOutcome = await restoreRollbackBoundary({
+                    repoRoot: request.context.repoRoot,
+                    boundary: rollbackBoundary,
+                    restoredAt: attemptCompletedAt,
+                    decision: patchDecision.decision
+                });
+            }
+            else if (result.status === "failed") {
+                rollbackOutcome = await restoreRollbackBoundary({
+                    repoRoot: request.context.repoRoot,
+                    boundary: rollbackBoundary,
+                    restoredAt: attemptCompletedAt,
+                    decision: "DISCARD"
+                });
+            }
             if (input.store) {
                 await input.store.writeAttemptArtifacts(loop.loopId, currentAttemptIndex, {
                     compiledContext,
-                    leash: createLeashArtifact(changeApprovalDecision, currentAttemptIndex),
-                    patchScore: patchDecision.score,
-                    patchDecision: toPatchDecisionArtifact(patchDecision),
+                    ...(patchDiff ? { diff: patchDiff } : {}),
+                    ...(groundingScanResult ? { groundingScan: groundingScanResult } : {}),
+                    ...(patchDecision ? { patchScore: patchDecision.score } : {}),
+                    ...(patchDecision ? { patchDecision: toPatchDecisionArtifact(patchDecision) } : {}),
                     ...(rollbackBoundary ? { rollbackBoundary } : {}),
                     ...(rollbackOutcome ? { rollbackOutcome } : {})
                 });
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "safety.violations_found",
-                    runId: loop.loopId,
-                    attemptIndex: currentAttemptIndex,
-                    payload: {
-                        surface: "dependency",
-                        blocked: true,
-                        profile: changeApprovalDecision.profile ?? executionProfile.name,
-                        attemptIndex: currentAttemptIndex,
-                        violations: changeApprovalDecision.violations
-                    }
-                }));
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "attempt.discarded",
-                    runId: loop.loopId,
-                    attemptIndex: currentAttemptIndex,
-                    payload: {
-                        decision: patchDecision.decision,
-                        reason: patchDecision.summary,
-                        reasonCodes: patchDecision.reasonCodes,
-                        score: patchDecision.score.score
-                    }
-                }));
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "run.exited",
-                    runId: loop.loopId,
-                    payload: createRunExitPayload(approvalExitDecision)
-                }));
             }
-            const finalizedLoop = finalizeLoop(loop, approvalExitDecision, now(), idFactory);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision: approvalExitDecision
-            };
-        }
-        // VERIFY: Run grounding scan on patch diff if available
-        // Uses the task's repoRoot to build/load the grounding index, then scans any diff
-        let groundingScanResult;
-        const patchDiff = buildPatchDiff(result, changedFiles);
-        if (patchDiff && input.task.repoRoot) {
-            try {
-                const groundingIndex = await loadOrBuildRepoGroundingIndex(input.task.repoRoot);
-                groundingScanResult = scanPatchForGroundingViolations(patchDiff, groundingIndex, {
-                    allowedPaths: input.task.allowedPaths
-                });
-                if (input.store && groundingScanResult.violations.length > 0) {
+            if (input.store) {
+                if (patchDecision) {
                     await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                        kind: "grounding.violations_found",
+                        kind: patchDecision.decision === "KEEP" ? "attempt.kept" : "attempt.discarded",
                         runId: loop.loopId,
                         attemptIndex: currentAttemptIndex,
                         payload: {
-                            violationCount: groundingScanResult.violations.length,
-                            resolvedFiles: groundingScanResult.resolvedFiles,
-                            contentOnly: groundingScanResult.contentOnly,
-                            violations: groundingScanResult.violations.slice(0, 10)
+                            decision: patchDecision.decision,
+                            reason: patchDecision.summary,
+                            reasonCodes: patchDecision.reasonCodes,
+                            score: patchDecision.score.score
                         }
                     }));
                 }
+                else {
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: verification.passed ? "attempt.kept" : "attempt.discarded",
+                        runId: loop.loopId,
+                        attemptIndex: currentAttemptIndex,
+                        payload: { reason: verification.summary }
+                    }));
+                }
             }
-            catch {
-                // Grounding scan is best-effort — never fail the loop because of a scan error
-            }
-        }
-        let patchDecision;
-        if (result.status === "completed") {
-            patchDecision = evaluatePatchDecision({
-                verificationPassed: verification.passed,
-                previousVerifierScore,
-                verifierScore: verification.passed ? 1 : 0,
-                groundingViolationCount: groundingScanResult?.violations.length ?? 0,
-                changedFileCount: patchTruthCountsEdits ? changedFiles.length : undefined,
-                diffNovelty: patchTruthCountsEdits ? (changedFiles.length > 0 ? 1 : 0) : undefined,
-                diffStats: result.execution?.diffStats,
-                costUsd: getUsageUsd(result.usage),
-                summary: result.summary
-            });
-        }
-        let rollbackOutcome;
-        if (patchDecision && patchDecision.decision !== "KEEP") {
-            rollbackOutcome = await restoreRollbackBoundary({
-                repoRoot: request.context.repoRoot,
-                boundary: rollbackBoundary,
-                restoredAt: attemptCompletedAt,
-                decision: patchDecision.decision
-            });
-        }
-        else if (result.status === "failed") {
-            rollbackOutcome = await restoreRollbackBoundary({
-                repoRoot: request.context.repoRoot,
-                boundary: rollbackBoundary,
-                restoredAt: attemptCompletedAt,
-                decision: "DISCARD"
-            });
-        }
-        if (input.store) {
-            await input.store.writeAttemptArtifacts(loop.loopId, currentAttemptIndex, {
-                compiledContext,
-                ...(patchDiff ? { diff: patchDiff } : {}),
-                ...(groundingScanResult ? { groundingScan: groundingScanResult } : {}),
-                ...(patchDecision ? { patchScore: patchDecision.score } : {}),
-                ...(patchDecision ? { patchDecision: toPatchDecisionArtifact(patchDecision) } : {}),
-                ...(rollbackBoundary ? { rollbackBoundary } : {}),
-                ...(rollbackOutcome ? { rollbackOutcome } : {})
-            });
-        }
-        if (input.store) {
-            if (patchDecision) {
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: patchDecision.decision === "KEEP" ? "attempt.kept" : "attempt.discarded",
-                    runId: loop.loopId,
-                    attemptIndex: currentAttemptIndex,
+            if (patchDecision && patchDecision.decision !== "KEEP" && !failure) {
+                failure = classifyPatchDecisionFailure(patchDecision, result);
+                loop = applyPatchFailureToLoop(loop, {
+                    attemptId,
+                    summary: patchDecision.summary,
+                    failure
+                });
+                if (failure.recommendedIntervention === "compress_context") {
+                    useCompressedContext = true;
+                }
+                loop = appendLoopEvent(loop, {
+                    type: "failure.classified",
+                    lifecycleState: "running",
                     payload: {
-                        decision: patchDecision.decision,
-                        reason: patchDecision.summary,
-                        reasonCodes: patchDecision.reasonCodes,
-                        score: patchDecision.score.score
+                        attemptId,
+                        failureClass: failure.failureClass,
+                        rationale: failure.rationale
                     }
-                }));
+                }, { now: attemptCompletedAt, idFactory });
+                loop = appendLoopEvent(loop, {
+                    type: "intervention.selected",
+                    lifecycleState: "running",
+                    payload: { attemptId, intervention: failure.recommendedIntervention }
+                }, { now: attemptCompletedAt, idFactory });
             }
-            else {
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: verification.passed ? "attempt.kept" : "attempt.discarded",
-                    runId: loop.loopId,
-                    attemptIndex: currentAttemptIndex,
-                    payload: { reason: verification.summary }
-                }));
+            if (patchDecision?.decision === "ESCALATE" || patchDecision?.decision === "HANDOFF") {
+                const patchExitDecision = {
+                    shouldExit: true,
+                    lifecycleState: "human_escalation",
+                    status: "exited",
+                    reason: patchDecision.summary
+                };
+                if (input.store) {
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "run.exited",
+                        runId: loop.loopId,
+                        payload: createRunExitPayload(patchExitDecision)
+                    }));
+                }
+                if (pendingControlWrites.length > 0) {
+                    await Promise.all(pendingControlWrites.splice(0));
+                }
+                const finalizedLoop = finalizeLoop(loop, patchExitDecision, now(), idFactory);
+                await persistLoopRecordIfSupported(input.store, finalizedLoop);
+                return {
+                    loop: finalizedLoop,
+                    decision: patchExitDecision
+                };
             }
-        }
-        if (patchDecision && patchDecision.decision !== "KEEP" && !failure) {
-            failure = classifyPatchDecisionFailure(patchDecision, result);
-            loop = applyPatchFailureToLoop(loop, {
-                attemptId,
-                summary: patchDecision.summary,
-                failure
+            const effectiveResult = patchDecision && patchDecision.decision !== "KEEP"
+                ? {
+                    ...result,
+                    status: "failed",
+                    summary: patchDecision.summary,
+                    verification: {
+                        ...result.verification,
+                        passed: false,
+                        summary: patchDecision.summary
+                    },
+                    failure: {
+                        message: patchDecision.summary,
+                        ...(failure?.failureClass ? { classHint: failure.failureClass } : {})
+                    }
+                }
+                : result;
+            const decision = inferExit({
+                loop,
+                lastResult: effectiveResult,
+                lastFailure: failure,
+                costState,
+                canSwitchAdapter: failure?.recommendedIntervention === "switch_adapter" &&
+                    adapterChain[currentAdapterIndex] !== undefined &&
+                    currentAdapter.adapterId !== executingAdapter.adapterId
             });
-            if (failure.recommendedIntervention === "compress_context") {
-                useCompressedContext = true;
-            }
+            // Advance phase based on result
+            currentPhase = nextPolicyPhase(currentPhase, effectiveResult, costState, phaseRetryCount);
+            if (failure)
+                phaseRetryCount++;
+            else
+                phaseRetryCount = 0;
+            // Post-attempt: persisted verification and exit decisions must use the same
+            // authoritative outcome. effectiveResult reflects any grounding/leash override,
+            // so verification.completed is written here — never from the raw adapter result.
+            const effectiveVerification = normalizeVerificationOutcome(effectiveResult, expectedVerifierBinding);
             loop = appendLoopEvent(loop, {
-                type: "failure.classified",
-                lifecycleState: "running",
+                type: "verification.completed",
+                lifecycleState: effectiveVerification.passed ? "completed" : "verifying",
                 payload: {
                     attemptId,
-                    failureClass: failure.failureClass,
-                    rationale: failure.rationale
+                    attemptIndex: currentAttemptIndex,
+                    passed: effectiveVerification.passed,
+                    summary: effectiveVerification.summary,
+                    ...(effectiveVerification.steps?.length ? { steps: effectiveVerification.steps } : {}),
+                    ...(effectiveVerification.warnings?.length ? { warnings: effectiveVerification.warnings } : {}),
+                    ...(effectiveVerification.binding ? { binding: effectiveVerification.binding } : {}),
+                    changedFiles,
                 }
             }, { now: attemptCompletedAt, idFactory });
-            loop = appendLoopEvent(loop, {
-                type: "intervention.selected",
-                lifecycleState: "running",
-                payload: { attemptId, intervention: failure.recommendedIntervention }
-            }, { now: attemptCompletedAt, idFactory });
-        }
-        if (patchDecision?.decision === "ESCALATE" || patchDecision?.decision === "HANDOFF") {
-            const patchExitDecision = {
-                shouldExit: true,
-                lifecycleState: "human_escalation",
-                status: "exited",
-                reason: patchDecision.summary
-            };
             if (input.store) {
                 await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "run.exited",
+                    kind: "verification.completed",
                     runId: loop.loopId,
-                    payload: createRunExitPayload(patchExitDecision)
+                    attemptIndex: currentAttemptIndex,
+                    payload: {
+                        attemptId,
+                        passed: effectiveVerification.passed,
+                        summary: effectiveVerification.summary,
+                        ...(effectiveVerification.steps?.length ? { steps: effectiveVerification.steps } : {}),
+                        ...(effectiveVerification.warnings?.length ? { warnings: effectiveVerification.warnings } : {}),
+                        ...(effectiveVerification.binding ? { binding: effectiveVerification.binding } : {}),
+                        changedFiles,
+                    }
                 }));
             }
-            const finalizedLoop = finalizeLoop(loop, patchExitDecision, now(), idFactory);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision: patchExitDecision
-            };
-        }
-        const effectiveResult = patchDecision && patchDecision.decision !== "KEEP"
-            ? {
-                ...result,
-                status: "failed",
-                summary: patchDecision.summary,
-                verification: {
-                    ...result.verification,
-                    passed: false,
-                    summary: patchDecision.summary
-                },
-                failure: {
-                    message: patchDecision.summary,
-                    ...(failure?.failureClass ? { classHint: failure.failureClass } : {})
+            const postAttemptTerminal = await evaluateCheckpoint("post_attempt", {
+                status: effectiveResult.status === "completed" ? "completed" : "failed",
+                verificationPassed: effectiveVerification.passed
+            });
+            if (postAttemptTerminal !== undefined)
+                return await terminateRun(postAttemptTerminal);
+            // Before-retry: check signals before scheduling the next attempt
+            const preRetryTerminal = await evaluateCheckpoint("before_retry");
+            if (preRetryTerminal !== undefined)
+                return await terminateRun(preRetryTerminal);
+            if (decision.shouldExit) {
+                if (input.store) {
+                    await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                        kind: "run.exited",
+                        runId: loop.loopId,
+                        payload: createRunExitPayload(decision)
+                    }));
                 }
+                // Drain pending diagnostic ledger writes before receipt signing.
+                if (pendingControlWrites.length > 0) {
+                    await Promise.all(pendingControlWrites.splice(0));
+                }
+                const routingInput = { runStartMs, firstDeltaDetected, firstDeltaTimestampMs, firstDeltaFilePath, firstDeltaChangeType, preDeltaCostUsd };
+                const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory, routingInput);
+                await persistLoopRecordIfSupported(input.store, finalizedLoop);
+                return {
+                    loop: finalizedLoop,
+                    decision
+                };
             }
-            : result;
-        const decision = inferExit({
-            loop,
-            lastResult: effectiveResult,
-            lastFailure: failure,
-            costState,
-            canSwitchAdapter: failure?.recommendedIntervention === "switch_adapter" &&
-                adapterChain[currentAdapterIndex] !== undefined &&
-                currentAdapter.adapterId !== executingAdapter.adapterId
-        });
-        // Advance phase based on result
-        currentPhase = nextPolicyPhase(currentPhase, effectiveResult, costState, phaseRetryCount);
-        if (failure)
-            phaseRetryCount++;
-        else
-            phaseRetryCount = 0;
-        if (decision.shouldExit) {
-            if (input.store) {
-                await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                    kind: "run.exited",
-                    runId: loop.loopId,
-                    payload: createRunExitPayload(decision)
-                }));
-            }
-            const routingInput = { runStartMs, firstDeltaDetected, firstDeltaTimestampMs, firstDeltaFilePath, firstDeltaChangeType, preDeltaCostUsd };
-            const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory, routingInput);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision
-            };
         }
+        const decision = {
+            shouldExit: true,
+            lifecycleState: "budget_exit",
+            status: "exited",
+            reason: "Martin exited because the loop exhausted its configured iteration budget."
+        };
+        if (input.store) {
+            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
+                kind: "run.exited",
+                runId: loop.loopId,
+                payload: createRunExitPayload(decision)
+            }));
+        }
+        // Drain pending diagnostic ledger writes before receipt signing.
+        if (pendingControlWrites.length > 0) {
+            await Promise.all(pendingControlWrites.splice(0));
+        }
+        const routingInput = { runStartMs, firstDeltaDetected, firstDeltaTimestampMs, firstDeltaFilePath, firstDeltaChangeType, preDeltaCostUsd };
+        const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory, routingInput);
+        await persistLoopRecordIfSupported(input.store, finalizedLoop);
+        return {
+            loop: finalizedLoop,
+            decision
+        };
     }
-    const decision = {
-        shouldExit: true,
-        lifecycleState: "budget_exit",
-        status: "exited",
-        reason: "Martin exited because the loop exhausted its configured iteration budget."
-    };
-    if (input.store) {
-        await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-            kind: "run.exited",
-            runId: loop.loopId,
-            payload: createRunExitPayload(decision)
-        }));
+    finally {
+        if (wallTimer !== undefined)
+            clearTimeout(wallTimer);
+        disposeSignalMonitor();
+        runController.abort();
+        activeAttemptController?.abort();
+        // Flush any diagnostic ledger writes queued from signal callbacks
+        await Promise.all(pendingControlWrites);
     }
-    const routingInput = { runStartMs, firstDeltaDetected, firstDeltaTimestampMs, firstDeltaFilePath, firstDeltaChangeType, preDeltaCostUsd };
-    const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory, routingInput);
-    await persistLoopRecordIfSupported(input.store, finalizedLoop);
-    return {
-        loop: finalizedLoop,
-        decision
-    };
 }
 function createRunExitPayload(decision) {
     return {
@@ -1096,11 +1462,13 @@ function finalizeLoop(loop, decision, timestamp, idFactory, routingEconomicsInpu
     const routingEconomics = routingEconomicsInput
         ? buildRoutingEconomics(finalized, routingEconomicsInput, decision)
         : undefined;
+    const avoidedUsd = calculateLoopAvoidedUsd({ loop: finalized, decision });
     return {
         ...finalized,
         status: decision.status,
         lifecycleState: decision.lifecycleState,
         updatedAt: timestamp,
+        cost: { ...finalized.cost, avoidedUsd },
         ...(routingEconomics ? { routingEconomics } : {})
     };
 }
@@ -1195,6 +1563,9 @@ function mergeCostProvenance(previous, current) {
     return COST_PROVENANCE_RANK[current] < COST_PROVENANCE_RANK[previous] ? current : previous;
 }
 function resolveChangedFiles(result, repoRoot, rollbackBoundary) {
+    if (repoRoot && rollbackBoundary?.headRef) {
+        return listAttemptChangedFilesSinceBoundary({ repoRoot, boundary: rollbackBoundary });
+    }
     if (result.execution?.changedFiles !== undefined) {
         return result.execution.changedFiles;
     }
@@ -1215,6 +1586,41 @@ function buildPatchDiff(result, changedFiles) {
     }
     return undefined;
 }
+function reconcileExistingGroundingFiles(scan, repoRoot, boundary) {
+    const resolvedFiles = new Set(scan.resolvedFiles);
+    const violations = scan.violations.filter((violation) => {
+        if (violation.kind !== "file_not_found") {
+            return true;
+        }
+        const absolutePath = resolve(repoRoot, violation.reference);
+        const relativePath = relative(repoRoot, absolutePath);
+        const isInsideRepo = relativePath.length > 0 && !relativePath.startsWith("..") && !isAbsolute(relativePath);
+        if (!isInsideRepo || !isTrackedRepoFileAtBoundary(repoRoot, violation.reference, boundary)) {
+            return true;
+        }
+        resolvedFiles.add(violation.reference);
+        return false;
+    });
+    return {
+        ...scan,
+        violations,
+        resolvedFiles: [...resolvedFiles]
+    };
+}
+function isTrackedRepoFileAtBoundary(repoRoot, filePath, boundary) {
+    if (!boundary) {
+        return false;
+    }
+    const normalizedPath = filePath.replace(/\\/gu, "/");
+    if (boundary.snapshots.some((snapshot) => snapshot.existed && snapshot.path === normalizedPath)) {
+        return true;
+    }
+    if (!boundary.headRef) {
+        return false;
+    }
+    const result = spawnSync("git", ["-C", repoRoot, "cat-file", "-e", `${boundary.headRef}:${normalizedPath}`], { encoding: "utf8", stdio: "ignore", windowsHide: true });
+    return result.status === 0;
+}
 function createBudgetSettlement(input) {
     const totalActualUsd = getUsageUsd(input.usage);
     return {
@@ -1276,17 +1682,33 @@ function getLastVerifierScore(loop) {
 function truncateVerificationDetail(text, maxLength) {
     return text.length <= maxLength ? text : `${text.slice(0, maxLength - 1)}…`;
 }
-function normalizeVerificationOutcome(result) {
+function resolveExpectedVerifierBinding(request) {
+    const commands = request.context.verificationStack?.length
+        ? request.context.verificationStack.map((step) => step.command)
+        : request.context.verificationPlan;
+    return {
+        runId: request.loopId,
+        workspaceId: request.workspaceId,
+        cwd: request.context.repoRoot ?? process.cwd(),
+        commands,
+    };
+}
+function normalizeVerificationOutcome(result, expectedBinding) {
     const warnings = [...(result.verification.warnings ?? [])];
     const contradiction = detectVerificationContradiction(result);
     if (contradiction && !warnings.includes(contradiction)) {
         warnings.push(contradiction);
     }
+    const executionPassed = verifierActuallyPassed(result.verification, expectedBinding);
+    if (result.verification.passed && !executionPassed && !contradiction) {
+        warnings.push("Verification evidence conflicts with the configured run, workspace, cwd, command, or subprocess result.");
+    }
     return {
-        passed: result.verification.passed,
+        passed: executionPassed && !contradiction,
         summary: result.verification.summary,
         ...(result.verification.steps?.length ? { steps: result.verification.steps } : {}),
-        ...(warnings.length ? { warnings } : {})
+        ...(warnings.length ? { warnings } : {}),
+        ...(result.verification.binding ? { binding: result.verification.binding } : {})
     };
 }
 function detectVerificationContradiction(result) {
@@ -1406,5 +1828,7 @@ function applyPatchFailureToLoop(loop, input) {
             : attempt)
     };
 }
+export { createDefaultExitPolicy, evaluateExitPolicy, hashProgressState, toLegacyExitDecision, validateExitPolicy } from "./exits.js";
+export { SignalDiagnosticError, createFileExitSignalSource, exitSignalPath, readAllExitSignals, readExitSignal, startExitSignalMonitor, writeExitSignal } from "./exit-signal.js";
 // ─── R4 Delivery ─────────────────────────────────────────────────────────────
 export { cacheMessage, fetchSelectedMessage, getCliInstalledVersion, getMcpInstalledVersion, isCooldownExpired, isDismissed, isNewerVersion, loadDeliveryRecord, parseMessageSelectionResponse, recordDismissed, recordShown, resolveDefaultLedgerPath, saveDeliveryRecord, } from "./delivery/index.js";