@martinloop/mcp 0.3.8 → 0.5.0

package/dist/vendor/adapters/core/src/index.js

@@ -1,1495 +0,0 @@
-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";
-import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
-import { captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary } from "./rollback.js";
-import { compilePromptPacket } from "./compiler.js";
-import { makeLedgerEvent, resolveRunsRoot, runDir } from "./persistence/index.js";
-import { runContextIntegrityPrecheck } from "./context-integrity.js";
-import { decideCircuitBreak } from "./trajectory.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";
-// ─── Routing economics ─────────────────────────────────────────────────────
-export { classifyRoute, evaluatePreworkBurnPolicy, resolveModelForTier, selectBestEngine } from "./routing.js";
-// ─── Test Integrity Validation ──────────────────────────────────────────────
-export { validateTestIntegrity, snapshotTestFiles, identifyNewTests, findTestFiles, isTestFile, extractImports, hasTrivialAssertionsOnly, importsPreExistingCode } from "./test-integrity.js";
-// ─── Repo Style Analyzer ────────────────────────────────────────────────────
-export { analyzeRepoStyle, buildPromptDirectives } from "./repo-analyzer.js";
-// ─── Context Integrity Pre-gate ──────────────────────────────────────────────
-export { runContextIntegrityPrecheck } from "./context-integrity.js";
-// ─── Prompt packet compiler ──────────────────────────────────────────────────
-export { compilePromptPacket } from "./compiler.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";
-// ─── MartinLoop Memory Store ────────────────────────────────────────────────
-export { appendMemory, readMemoryEntries, getPreference, buildMemorySummary, recordPreference, recordConsent } from "./persistence/memory-store.js";
-// ─── Trace Intelligence Store ───────────────────────────────────────────────
-export { appendTraceEntry, readTraceEntries, aggregateTraces, getHistoricalDirectSuccessRate } from "./persistence/trace-store.js";
-/**
- * Admission gate — must pass before any attempt is executed.
- * Evaluates budget headroom, oscillation, and repetitive failure patterns.
- * PolicyPhase remains explicit: attempts are only admitted in ADMIT phase.
- */
-export function evaluateAttemptPolicy(input) {
-    const { request, projectedUsd } = input;
-    const trajectoryAttempts = request.previousAttempts.map((attempt) => ({
-        index: attempt.index,
-        summary: attempt.summary,
-        failureClass: attempt.failureClass
-    }));
-    const circuitBreakDecision = decideCircuitBreak({
-        objective: request.context.objective,
-        verificationPlan: request.context.verificationPlan,
-        attempts: trajectoryAttempts,
-        remainingIterations: request.context.remainingIterations
-    });
-    const trajectoryAssessment = circuitBreakDecision.assessment;
-    if (circuitBreakDecision.shouldStop) {
-        return {
-            allowed: false,
-            reason: circuitBreakDecision.reason,
-            recommendedIntervention: circuitBreakDecision.recommendedIntervention,
-            trajectoryAssessment,
-            circuitBreakDecision
-        };
-    }
-    // Budget gate: reject if projected cost exceeds remaining
-    if (projectedUsd > request.context.remainingBudgetUsd) {
-        return {
-            allowed: false,
-            reason: `Projected cost $${projectedUsd} exceeds remaining budget $${request.context.remainingBudgetUsd}.`,
-            recommendedIntervention: "stop_loop",
-            trajectoryAssessment,
-            circuitBreakDecision
-        };
-    }
-    // Iteration gate
-    if (request.context.remainingIterations <= 0) {
-        return {
-            allowed: false,
-            reason: "No remaining iterations in the budget.",
-            recommendedIntervention: "stop_loop",
-            trajectoryAssessment,
-            circuitBreakDecision
-        };
-    }
-    // Oscillation detection: A/B/A pattern in failure classes
-    const failures = request.previousAttempts
-        .map((a) => a.failureClass)
-        .filter((fc) => Boolean(fc));
-    if (failures.length >= 3) {
-        const last3 = failures.slice(-3);
-        const isOscillating = last3[0] !== last3[1] && last3[0] === last3[2];
-        if (isOscillating) {
-            return {
-                allowed: false,
-                reason: "Oscillating failure pattern detected. Escalating to human.",
-                recommendedIntervention: "escalate_human",
-                trajectoryAssessment,
-                circuitBreakDecision
-            };
-        }
-    }
-    // Materially repetitive detection: same summary content pattern 3x
-    if (request.previousAttempts.length >= 3) {
-        const lastThree = request.previousAttempts.slice(-3);
-        const summaries = lastThree
-            .map((a) => a.summary?.toLowerCase() ?? "")
-            .filter((s) => s.length > 10);
-        if (summaries.length === 3) {
-            // Compute rough similarity: shared significant tokens
-            const tokenize = (s) => new Set(s.match(/[a-z]{4,}/g) ?? []);
-            const tokens0 = tokenize(summaries[0] ?? "");
-            const tokens2 = tokenize(summaries[2] ?? "");
-            const shared = [...tokens0].filter((t) => tokens2.has(t));
-            const similarity = shared.length / Math.max(tokens0.size, 1);
-            if (similarity > 0.5) {
-                return {
-                    allowed: false,
-                    reason: "Materially repetitive attempts detected. Escalating to human.",
-                    recommendedIntervention: "escalate_human",
-                    trajectoryAssessment,
-                    circuitBreakDecision
-                };
-            }
-        }
-    }
-    return {
-        allowed: true,
-        reason: "Attempt admitted.",
-        trajectoryAssessment,
-        circuitBreakDecision
-    };
-}
-export function distillContext(loop, options = {}) {
-    const maxRecentAttempts = options.maxRecentAttempts ?? 3;
-    const recentAttempts = loop.attempts.slice(-maxRecentAttempts);
-    return {
-        focus: `${loop.task.objective} Follow the verification plan and stay inside the configured budget.`,
-        recentAttempts,
-        constraints: {
-            remainingBudgetUsd: roundUsd(loop.budget.maxUsd - loop.cost.actualUsd),
-            remainingIterations: Math.max(loop.budget.maxIterations - loop.attempts.length, 0),
-            remainingTokens: Math.max(loop.budget.maxTokens - loop.cost.tokensIn - loop.cost.tokensOut, 0)
-        }
-    };
-}
-export async function runMartin(input) {
-    const now = input.now ?? (() => new Date().toISOString());
-    const idFactory = input.idFactory;
-    let loop = createLoopRecord({
-        workspaceId: input.workspaceId,
-        projectId: input.projectId,
-        task: input.task,
-        budget: input.budget,
-        ...(input.receiptScope ? { receiptScope: input.receiptScope } : {}),
-        ...(input.teamId ? { teamId: input.teamId } : {}),
-        ...(input.metadata ? { metadata: input.metadata } : {})
-    }, { now: now(), idFactory });
-    loop = appendLoopEvent(loop, {
-        type: "run.started",
-        lifecycleState: "running",
-        payload: {
-            adapterId: input.adapter.adapterId,
-            providerId: input.adapter.metadata.providerId,
-            model: input.adapter.metadata.model,
-            transport: getAdapterTransport(input.adapter)
-        }
-    }, { now: now(), idFactory });
-    if (input.store) {
-        await input.store.initRun({
-            runId: loop.loopId,
-            workspaceId: input.workspaceId,
-            projectId: input.projectId,
-            task: input.task,
-            budget: input.budget,
-            createdAt: loop.createdAt,
-            ...(input.metadata ? { metadata: input.metadata } : {})
-        });
-        await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-            kind: "contract.created",
-            runId: loop.loopId,
-            payload: { workspaceId: input.workspaceId, projectId: input.projectId }
-        }));
-        await persistLoopRecordIfSupported(input.store, loop);
-    }
-    const DEFAULT_FALLBACK_MODELS = [
-        "claude-haiku-4-5",
-        "claude-sonnet-4-6",
-        "claude-opus-4-6"
-    ];
-    const adapterChain = [input.adapter, ...(input.fallbackAdapters ?? [])];
-    let currentAdapterIndex = 0;
-    let currentAdapter = adapterChain[currentAdapterIndex] ?? input.adapter;
-    let useCompressedContext = false;
-    const isVerifyOnly = input.task.mutationMode === "verify_only";
-    const executionProfile = resolveExecutionProfile({
-        executionProfile: input.task.executionProfile,
-        allowedNetworkDomains: input.task.allowedNetworkDomains
-    });
-    // Safety leash: block destructive verifier commands before any attempt
-    const leashDecision = evaluateVerificationLeash({
-        verificationPlan: input.task.verificationPlan,
-        verificationStack: input.task.verificationStack,
-        executionProfile: input.task.executionProfile,
-        allowedNetworkDomains: input.task.allowedNetworkDomains
-    });
-    if (!leashDecision.allowed) {
-        const reason = `${leashDecision.reason ?? "Safety leash blocked verifier commands."} Blocked: ${leashDecision.blockedCommands.join(", ")}`;
-        const leashExitDecision = {
-            shouldExit: true,
-            lifecycleState: "human_escalation",
-            status: "exited",
-            reason,
-            ...classifySafetyLeashExit(leashDecision, "verifier")
-        };
-        if (input.store) {
-            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                kind: "safety.violations_found",
-                runId: loop.loopId,
-                payload: {
-                    surface: leashDecision.surface,
-                    blocked: true,
-                    profile: leashDecision.profile ?? executionProfile.name,
-                    violations: serializeSafetyViolations(leashDecision)
-                }
-            }));
-            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                kind: "run.exited",
-                runId: loop.loopId,
-                payload: createRunExitPayload(leashExitDecision)
-            }));
-        }
-        const finalizedLoop = finalizeLoop(loop, leashExitDecision, now(), idFactory);
-        await persistLoopRecordIfSupported(input.store, finalizedLoop);
-        return {
-            loop: finalizedLoop,
-            decision: leashExitDecision
-        };
-    }
-    const secretDecision = evaluateSecretLeash({
-        values: [
-            input.task.title,
-            input.task.objective,
-            ...(input.task.acceptanceCriteria ?? [])
-        ]
-    });
-    if (!secretDecision.allowed) {
-        const secretExitDecision = {
-            shouldExit: true,
-            lifecycleState: "human_escalation",
-            status: "exited",
-            reason: secretDecision.reason ?? "Safety leash blocked secret-like values in the runtime context.",
-            ...classifySafetyLeashExit(secretDecision, "secret")
-        };
-        if (input.store) {
-            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                kind: "safety.violations_found",
-                runId: loop.loopId,
-                payload: {
-                    surface: "secret",
-                    blocked: true,
-                    violations: secretDecision.violations.map((violation) => violation.match ?? violation.message)
-                }
-            }));
-            await input.store.appendLedger(loop.loopId, makeLedgerEvent({
-                kind: "run.exited",
-                runId: loop.loopId,
-                payload: createRunExitPayload(secretExitDecision)
-            }));
-        }
-        const finalizedLoop = finalizeLoop(loop, secretExitDecision, now(), idFactory);
-        await persistLoopRecordIfSupported(input.store, finalizedLoop);
-        return {
-            loop: finalizedLoop,
-            decision: secretExitDecision
-        };
-    }
-    // Explicit PolicyPhase state machine — starts at GATHER, advances per attempt
-    let currentPhase = "GATHER";
-    let phaseRetryCount = 0;
-    // Routing economics: track first meaningful workspace delta
-    const runStartMs = Date.now();
-    let firstDeltaDetected = false;
-    let firstDeltaTimestampMs;
-    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
-            };
-            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)
-                }));
-            }
-            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"
-                    }
-                }));
-            }
-            const finalizedLoop = finalizeLoop(loop, poisoningExitDecision, now(), idFactory);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision: poisoningExitDecision
-            };
-        }
-        const admissionDecision = evaluateAttemptPolicy({
-            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.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)
-                }));
-            }
-            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: {
-                attemptId,
-                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 }
-                    : {}),
-                ...(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 });
-            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
-            });
-            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,
-                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
-                }
-            }));
-        }
-        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 = !isVerifyOnly && !isVerifierOnlyAdapter && changedFileEvidenceAvailable;
-        if (isVerifyOnly && changedFiles.length > 0) {
-            const patchDecision = evaluatePatchDecision({
-                verificationPassed: verification.passed,
-                previousVerifierScore,
-                verifierScore: verification.passed ? 1 : 0,
-                scopeViolationCount: changedFiles.length,
-                changedFileCount: changedFiles.length,
-                diffNovelty: 1,
-                diffStats: result.execution?.diffStats,
-                costUsd: getUsageUsd(result.usage),
-                summary: result.summary
-            });
-            const verifyOnlyExitDecision = {
-                shouldExit: true,
-                lifecycleState: "human_escalation",
-                status: "exited",
-                reason: "Verify-only mode forbids file changes.",
-                failureClass: "safety_leash_blocked",
-                safetySurface: "filesystem",
-                reasonCode: "verify_only_write_attempt"
-            };
-            const rollbackOutcome = await restoreRollbackBoundary({
-                repoRoot: request.context.repoRoot,
-                boundary: rollbackBoundary,
-                restoredAt: attemptCompletedAt,
-                decision: patchDecision.decision
-            });
-            if (input.store) {
-                const verifyOnlyViolation = {
-                    kind: "path_not_allowed",
-                    message: `Verify-only mode forbids changed files: ${changedFiles.join(", ")}`,
-                    file: changedFiles[0]
-                };
-                await input.store.writeAttemptArtifacts(loop.loopId, currentAttemptIndex, {
-                    compiledContext,
-                    leash: createLeashArtifact({
-                        surface: "filesystem",
-                        reason: verifyOnlyExitDecision.reason,
-                        violations: [verifyOnlyViolation]
-                    }, 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: [
-                            {
-                                kind: "path_not_allowed",
-                                message: verifyOnlyExitDecision.reason,
-                                files: changedFiles
-                            }
-                        ]
-                    }
-                }));
-                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(verifyOnlyExitDecision)
-                }));
-            }
-            const finalizedLoop = finalizeLoop(loop, verifyOnlyExitDecision, now(), idFactory);
-            await persistLoopRecordIfSupported(input.store, finalizedLoop);
-            return {
-                loop: finalizedLoop,
-                decision: verifyOnlyExitDecision
-            };
-        }
-        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
-            });
-            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)
-                }));
-            }
-            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)
-                }));
-            }
-            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) {
-                    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
-            }
-        }
-        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,
-                    payload: {
-                        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 }
-                }));
-            }
-        }
-        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: {
-                    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 });
-        }
-        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)
-                }));
-            }
-            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 } : {})
-                }
-            }
-            : 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)
-        }));
-    }
-    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 {
-        lifecycleState: decision.lifecycleState,
-        status: decision.status,
-        reason: decision.reason,
-        ...(decision.failureClass ? { failureClass: decision.failureClass } : {}),
-        ...(decision.safetySurface ? { safetySurface: decision.safetySurface } : {}),
-        ...(decision.reasonCode ? { reasonCode: decision.reasonCode } : {})
-    };
-}
-function classifySafetyLeashExit(decision, safetySurface = decision.surface) {
-    return {
-        failureClass: "safety_leash_blocked",
-        safetySurface,
-        reasonCode: safetyLeashReasonCode(decision, safetySurface)
-    };
-}
-function safetyLeashReasonCode(decision, safetySurface) {
-    const kind = decision.violations[0]?.kind;
-    switch (kind) {
-        case "command_blocked":
-            return safetySurface === "verifier" ? "destructive_verifier_command" : "command_blocked";
-        case "network_blocked":
-            return safetySurface === "verifier" ? "verifier_network_blocked" : "network_access_blocked";
-        case "secret_value":
-            return "secret_context_value";
-        case "path_denied":
-        case "protected_path":
-            return "protected_surface_write";
-        case "path_not_allowed":
-            return "surface_write_not_allowed";
-        case "path_outside_repo":
-            return "outside_repo_write";
-        case "dependency_approval_required":
-            return "dependency_approval_required";
-        case "migration_approval_required":
-            return "migration_approval_required";
-        case "config_change_approval_required":
-            return "config_change_approval_required";
-        default:
-            return `${safetySurface}_safety_block`;
-    }
-}
-function finalizeLoop(loop, decision, timestamp, idFactory, routingEconomicsInput) {
-    const finalized = appendLoopEvent(loop, {
-        type: "run.completed",
-        lifecycleState: decision.lifecycleState,
-        payload: createRunExitPayload(decision)
-    }, { now: timestamp, idFactory });
-    const routingEconomics = routingEconomicsInput
-        ? buildRoutingEconomics(finalized, routingEconomicsInput, decision)
-        : undefined;
-    return {
-        ...finalized,
-        status: decision.status,
-        lifecycleState: decision.lifecycleState,
-        updatedAt: timestamp,
-        ...(routingEconomics ? { routingEconomics } : {})
-    };
-}
-function buildRoutingEconomics(loop, input, decision) {
-    const totalCost = loop.cost.actualUsd;
-    const preworkCost = roundUsd(Math.max(input.preDeltaCostUsd, 0));
-    const executionCost = roundUsd(Math.max(totalCost - preworkCost, 0));
-    const preworkBurnPct = totalCost > 0 ? Math.round((preworkCost / totalCost) * 100) : 0;
-    const timeToFirstDeltaMs = input.firstDeltaTimestampMs
-        ? input.firstDeltaTimestampMs - input.runStartMs
-        : undefined;
-    const accepted = decision.lifecycleState === "completed";
-    // Route recommendation based on prework burn
-    let routeRecommendation;
-    let routeRecommendationReason;
-    if (preworkBurnPct > 50) {
-        routeRecommendation = "direct_worker";
-        routeRecommendationReason = `${String(preworkBurnPct)}% of spend was pre-work coordination. Use direct execution for similar tasks.`;
-    }
-    else if (preworkBurnPct > 30) {
-        routeRecommendation = "direct_worker";
-        routeRecommendationReason = `${String(preworkBurnPct)}% pre-work burn is high. Consider direct execution.`;
-    }
-    else {
-        routeRecommendation = "same_route";
-        routeRecommendationReason = `Pre-work burn at ${String(preworkBurnPct)}% is within acceptable range.`;
-    }
-    return {
-        preworkCostUsd: preworkCost,
-        executionCostUsd: executionCost,
-        verificationCostUsd: 0,
-        retryCostUsd: 0,
-        totalCostUsd: totalCost,
-        preworkBurnPct,
-        timeToFirstDeltaMs,
-        firstDelta: {
-            detected: input.firstDeltaDetected,
-            ...(input.firstDeltaTimestampMs ? { timestampMs: input.firstDeltaTimestampMs } : {}),
-            ...(input.firstDeltaFilePath ? { filePath: input.firstDeltaFilePath } : {}),
-            ...(input.firstDeltaChangeType ? { changeType: input.firstDeltaChangeType } : {}),
-            ...(timeToFirstDeltaMs !== undefined ? { timeToFirstDeltaMs } : {})
-        },
-        ...(accepted ? { costPerAcceptedChange: totalCost } : {}),
-        routeRecommendation,
-        routeRecommendationReason
-    };
-}
-const MARTINLOOP_METADATA_PATTERNS = [
-    /^PROGRESS\.md$/u,
-    /^\.martin\//u,
-    /\.lock$/u,
-    /^node_modules\//u,
-    /^\.git\//u,
-    /^\.cache\//u,
-];
-function isMartinLoopMetadata(filePath) {
-    return MARTINLOOP_METADATA_PATTERNS.some((p) => p.test(filePath));
-}
-async function persistLoopRecordIfSupported(store, loop) {
-    await store?.writeLoopRecord?.(loop.loopId, loop);
-}
-function getAdapterTransport(adapter) {
-    return adapter.metadata.transport ?? (adapter.kind === "agent-cli" ? "cli" : "http");
-}
-function getUsageUsd(usage) {
-    return roundUsd(usage.actualUsd);
-}
-function getUsageProvenance(usage) {
-    if (usage.provenance) {
-        return usage.provenance;
-    }
-    if (usage.estimatedUsd !== undefined) {
-        return "estimated";
-    }
-    return "actual";
-}
-const COST_PROVENANCE_RANK = {
-    unavailable: 0,
-    estimated: 1,
-    actual: 2
-};
-/**
- * Aggregates cost provenance across attempts. The cumulative loop provenance
- * can only be as trustworthy as its weakest attempt: if any attempt's cost was
- * estimated or unavailable, the cumulative total must reflect that, even if a
- * later attempt reports an authoritative actual cost.
- */
-function mergeCostProvenance(previous, current) {
-    if (previous === undefined) {
-        return current;
-    }
-    return COST_PROVENANCE_RANK[current] < COST_PROVENANCE_RANK[previous] ? current : previous;
-}
-function resolveChangedFiles(result, repoRoot, rollbackBoundary) {
-    if (result.execution?.changedFiles !== undefined) {
-        return result.execution.changedFiles;
-    }
-    return listAttemptChangedFilesSinceBoundary({ repoRoot, boundary: rollbackBoundary });
-}
-function buildPatchDiff(result, changedFiles) {
-    // Use structured diff stats to build a minimal diff header if no raw diff is available
-    if (result.execution?.changedFiles?.length) {
-        // Build a synthetic diff header from changed file list
-        return result.execution.changedFiles
-            .map((file) => `--- a/${file}\n+++ b/${file}\n@@ -0,0 +1 @@\n+`)
-            .join("\n");
-    }
-    if (changedFiles.length > 0) {
-        return changedFiles
-            .map((file) => `--- a/${file}\n+++ b/${file}\n@@ -0,0 +1 @@\n+`)
-            .join("\n");
-    }
-    return undefined;
-}
-function createBudgetSettlement(input) {
-    const totalActualUsd = getUsageUsd(input.usage);
-    return {
-        runId: input.runId,
-        attemptIndex: input.attemptIndex,
-        patchCost: {
-            usd: totalActualUsd,
-            tokensIn: input.usage.tokensIn,
-            tokensOut: input.usage.tokensOut,
-            provenance: getUsageProvenance(input.usage)
-        },
-        verificationCost: {
-            usd: 0,
-            provenance: "unavailable"
-        },
-        ...(input.usage.providerSettlement
-            ? { providerSettlement: input.usage.providerSettlement }
-            : {}),
-        totalActualUsd,
-        preflightEstimateUsd: input.estimate.estimatedAttemptCostUsd,
-        varianceUsd: roundUsd(totalActualUsd - input.estimate.estimatedAttemptCostUsd),
-        settledAt: input.settledAt
-    };
-}
-function roundUsd(value) {
-    return Math.round(value * 100) / 100;
-}
-function makeId(prefix, idFactory) {
-    if (idFactory)
-        return idFactory(prefix);
-    return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
-}
-function serializeSafetyViolations(decision) {
-    if (decision.surface === "command") {
-        return decision.blockedCommands;
-    }
-    return decision.violations;
-}
-function createLeashArtifact(decision, attemptIndex) {
-    return {
-        attemptIndex,
-        surface: decision.surface,
-        blocked: true,
-        ...(decision.profile ? { profile: decision.profile } : {}),
-        ...(decision.reason ? { reason: decision.reason } : {}),
-        violations: decision.violations
-    };
-}
-function getLastVerifierScore(loop) {
-    for (let index = loop.events.length - 1; index >= 0; index -= 1) {
-        const event = loop.events[index];
-        if (event?.type !== "verification.completed") {
-            continue;
-        }
-        return event.payload["passed"] === true ? 1 : 0;
-    }
-    return 0;
-}
-function truncateVerificationDetail(text, maxLength) {
-    return text.length <= maxLength ? text : `${text.slice(0, maxLength - 1)}…`;
-}
-function normalizeVerificationOutcome(result) {
-    const warnings = [...(result.verification.warnings ?? [])];
-    const contradiction = detectVerificationContradiction(result);
-    if (contradiction && !warnings.includes(contradiction)) {
-        warnings.push(contradiction);
-    }
-    return {
-        passed: result.verification.passed,
-        summary: result.verification.summary,
-        ...(result.verification.steps?.length ? { steps: result.verification.steps } : {}),
-        ...(warnings.length ? { warnings } : {})
-    };
-}
-function detectVerificationContradiction(result) {
-    if (!result.verification.passed) {
-        return undefined;
-    }
-    const sources = [result.summary, result.failure?.message]
-        .filter((value) => typeof value === "string" && value.trim().length > 0);
-    const contradictionPatterns = [
-        /createprocessasuserw failed:\s*\d+/iu,
-        /\bverifier not run\b/iu,
-        /\bfailed before verifier\b/iu,
-        /\bnever launched\b/iu,
-        /\bfailed to launch\b/iu,
-        /\bcould not launch\b/iu
-    ];
-    for (const source of sources) {
-        const match = contradictionPatterns.find((pattern) => pattern.test(source));
-        if (!match) {
-            continue;
-        }
-        const excerpt = truncateVerificationDetail(source.trim().replace(/\s+/gu, " "), 220);
-        return `Adapter output reported a tool-launch problem before MartinLoop ran its own verifier: ${excerpt}`;
-    }
-    return undefined;
-}
-function resolveActiveRunsRoot(store) {
-    const configuredRunsRoot = store?.runsRoot?.trim();
-    return configuredRunsRoot && configuredRunsRoot.length > 0 ? configuredRunsRoot : resolveRunsRoot();
-}
-function toPatchDecisionArtifact(decision) {
-    return {
-        decision: decision.decision,
-        summary: decision.summary,
-        reasonCodes: decision.reasonCodes
-    };
-}
-const SANDBOX_WRITE_BLOCKED_PATTERNS = [
-    /createprocessasuserw failed:\s*\d+/iu,
-    /windows sandbox: runner error/iu,
-    /writing is blocked by read-only sandbox/iu,
-    /read-only filesystem sandbox/iu,
-    /approval is disabled/iu
-];
-function detectSandboxWriteBlocked(result) {
-    const sources = [result.summary, result.failure?.message]
-        .filter((value) => typeof value === "string" && value.trim().length > 0);
-    return sources.some((source) => SANDBOX_WRITE_BLOCKED_PATTERNS.some((pattern) => pattern.test(source)));
-}
-function classifyPatchDecisionFailure(decision, result) {
-    if (decision.reasonCodes.includes("grounding_failure")) {
-        return {
-            failureClass: "repo_grounding_failure",
-            rationale: "Patch truth discarded the attempt because grounding evidence contradicted the patch.",
-            retryable: true,
-            recommendedIntervention: "run_verifier"
-        };
-    }
-    if (decision.reasonCodes.includes("scope_violation")) {
-        return {
-            failureClass: "scope_creep",
-            rationale: "Patch truth discarded the attempt because it changed files outside the task scope.",
-            retryable: true,
-            recommendedIntervention: "tighten_task"
-        };
-    }
-    if (decision.reasonCodes.includes("verifier_regressed") ||
-        decision.reasonCodes.includes("large_diff_no_improvement")) {
-        return {
-            failureClass: "test_regression",
-            rationale: "Patch truth discarded the attempt because the verifier regressed or stopped improving.",
-            retryable: true,
-            recommendedIntervention: "run_verifier"
-        };
-    }
-    if (decision.reasonCodes.includes("human_approval_required")) {
-        return {
-            failureClass: "scope_creep",
-            rationale: "Patch truth escalated the attempt because it requires explicit human approval.",
-            retryable: false,
-            recommendedIntervention: "escalate_human"
-        };
-    }
-    if (decision.reasonCodes.includes("safety_violation")) {
-        return {
-            failureClass: "scope_creep",
-            rationale: "Patch truth escalated the attempt because safety evidence blocked it.",
-            retryable: false,
-            recommendedIntervention: "escalate_human"
-        };
-    }
-    if (result && detectSandboxWriteBlocked(result)) {
-        return {
-            failureClass: "sandbox_write_blocked",
-            rationale: "The adapter reported a completed patch but the workspace-write sandbox blocked the underlying file write, so no trustworthy code change landed on disk.",
-            retryable: true,
-            recommendedIntervention: "switch_adapter"
-        };
-    }
-    return {
-        failureClass: "no_progress",
-        rationale: "Patch truth discarded the attempt because it did not produce a trustworthy code change.",
-        retryable: true,
-        recommendedIntervention: "compress_context"
-    };
-}
-function applyPatchFailureToLoop(loop, input) {
-    return {
-        ...loop,
-        attempts: loop.attempts.map((attempt) => attempt.attemptId === input.attemptId
-            ? {
-                ...attempt,
-                summary: input.summary,
-                failureClass: input.failure.failureClass,
-                intervention: input.failure.recommendedIntervention
-            }
-            : attempt)
-    };
-}