@martinloop/mcp 0.5.0 → 0.5.1

package/dist/vendor/core/index.d.ts

@@ -19,8 +19,8 @@ export { compileExecutionPolicy } from "./policy-compiler.js";
 export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
 export { calculateAvoidedUsd, calculateLoopAvoidedUsd } from "./savings.js";
 export type { AvoidedUsdInput } from "./savings.js";
-export { classifyRoute, evaluatePreworkBurnPolicy, resolveModelForTier, selectBestEngine } from "./routing.js";
-export type { RouteDecision, RouteClassificationInput, AvailableEngine } from "./routing.js";
+export { classifyRoute, evaluatePreworkBurnPolicy } from "./routing.js";
+export type { RouteDecision, RouteClassificationInput } from "./routing.js";
 export { validateTestIntegrity, snapshotTestFiles, identifyNewTests, findTestFiles, isTestFile, extractImports, hasTrivialAssertionsOnly, importsPreExistingCode } from "./test-integrity.js";
 export type { TestIntegrityReport, TestIntegrityFinding } from "./test-integrity.js";
 export { analyzeRepoStyle, buildPromptDirectives } from "./repo-analyzer.js";
@@ -29,7 +29,7 @@ export { runContextIntegrityPrecheck } from "./context-integrity.js";
 export type { ContextIntegrityPrecheck, ContextIntegrityVerdict } from "./context-integrity.js";
 export { compilePromptPacket } from "./compiler.js";
 export type { PromptPacket, CompilerAdapterRequest } from "./compiler.js";
-export { buildVerifiedHandoff, resolveVerifiedHandoffOutcome, toTestIntegrityVerdict, verifierActuallyPassed, } from "./verified-handoff.js";
+export { buildVerifiedHandoff, deriveVerifiedHandoffExecutionBoundary, resolveVerifiedHandoffOutcome, toTestIntegrityVerdict, verifierActuallyPassed, } from "./verified-handoff.js";
 export type { BoundVerifierEvidence, BuildVerifiedHandoffInput, VerifierExecutionBinding, } from "./verified-handoff.js";
 export { createFileRunStore, makeLedgerEvent, readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile, resolveRunsRoot, resolveReceiptIntegrityPath, verifyReceiptIntegrityFromFiles, writeReceiptIntegrityMaterial } from "./persistence/index.js";
 export type { AttemptArtifacts, LedgerEvent, LedgerEventKind, LoopAttemptRecord, LoopRunRecord, ReceiptIntegrityChainEntry, RunContract, RunStore, StoredReceiptIntegrityMaterial } from "./persistence/index.js";
@@ -142,7 +142,7 @@ export interface MartinAdapter {
     label: string;
     metadata: {
         providerId: string;
-        model: string;
+        model?: string;
         transport?: "cli" | "http" | "routed_http";
         capabilities?: {
             preflight?: boolean;
@@ -155,7 +155,6 @@ export interface MartinAdapter {
         [key: string]: unknown;
     };
     execute(request: MartinAdapterRequest): Promise<MartinAdapterResult>;
-    withModel?(model: string): MartinAdapter;
 }
 export interface DistilledContext {
     focus: string;
@@ -193,7 +192,6 @@ export interface RunMartinInput {
     now?: () => string;
     idFactory?: (prefix: string) => string;
     maxRecentAttempts?: number;
-    fallbackModels?: string[];
     fallbackAdapters?: MartinAdapter[];
     receiptScope?: ReceiptScope;
     /** Optional persistence store. When provided, runMartin writes artifacts on each lifecycle event. */

package/dist/vendor/core/index.js

@@ -22,7 +22,7 @@ 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";
+export { classifyRoute, evaluatePreworkBurnPolicy } from "./routing.js";
 // ─── Test Integrity Validation ──────────────────────────────────────────────
 export { validateTestIntegrity, snapshotTestFiles, identifyNewTests, findTestFiles, isTestFile, extractImports, hasTrivialAssertionsOnly, importsPreExistingCode } from "./test-integrity.js";
 // ─── Repo Style Analyzer ────────────────────────────────────────────────────
@@ -32,7 +32,7 @@ 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";
+export { buildVerifiedHandoff, deriveVerifiedHandoffExecutionBoundary, 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";
@@ -265,11 +265,6 @@ export async function runMartin(input) {
             }));
         }
     }
-    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;
@@ -803,7 +798,7 @@ export async function runMartin(input) {
                 attemptId,
                 index: currentAttemptIndex,
                 adapterId: executingAdapter.adapterId,
-                model: executingAdapter.metadata.model,
+                ...(executingAdapter.metadata.model ? { model: executingAdapter.metadata.model } : {}),
                 startedAt: attemptStartedAt,
                 completedAt: attemptCompletedAt,
                 summary: result.summary,
@@ -864,13 +859,6 @@ export async function runMartin(input) {
                         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",
@@ -1138,12 +1126,17 @@ export async function runMartin(input) {
             // 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) {
+            const workspaceMutationCapable = executingAdapter.metadata.capabilities?.workspaceMutations !== false;
+            const hasReportedOrObservedChanges = changedFiles.length > 0 || (result.execution?.changedFiles?.length ?? 0) > 0;
+            const groundingEvidenceRequired = result.status === "completed" && workspaceMutationCapable && hasReportedOrObservedChanges;
+            let groundingEvidenceAvailable = !groundingEvidenceRequired;
+            if (groundingEvidenceRequired && 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);
+                    groundingEvidenceAvailable = true;
                     if (input.store && groundingScanResult.violations.length > 0) {
                         await input.store.appendLedger(loop.loopId, makeLedgerEvent({
                             kind: "grounding.violations_found",
@@ -1159,10 +1152,22 @@ export async function runMartin(input) {
                     }
                 }
                 catch {
-                    // Grounding scan is best-effort — never fail the loop because of a scan error
+                    // Availability is persisted below so scanner failures and missing
+                    // grounding inputs follow the same recover-forward trust contract.
                 }
             }
-            const shouldEvaluatePatchTruth = result.status === "completed" && tracksWorkspaceMutations;
+            if (groundingEvidenceRequired && !groundingEvidenceAvailable) {
+                // The completed work remains useful, but unavailable grounding evidence
+                // cannot be converted into a zero-violation governance claim.
+                loop = {
+                    ...loop,
+                    metadata: {
+                        ...loop.metadata,
+                        groundingEvidenceStatus: "unavailable"
+                    }
+                };
+            }
+            const shouldEvaluatePatchTruth = result.status === "completed" && tracksWorkspaceMutations && groundingEvidenceAvailable;
             let patchDecision;
             if (shouldEvaluatePatchTruth) {
                 patchDecision = evaluatePatchDecision({
@@ -1548,7 +1553,8 @@ function getUsageProvenance(usage) {
 const COST_PROVENANCE_RANK = {
     unavailable: 0,
     estimated: 1,
-    actual: 2
+    calculated: 2,
+    actual: 3
 };
 /**
  * Aggregates cost provenance across attempts. The cumulative loop provenance

package/dist/vendor/core/persistence/runs-reader.d.ts

@@ -6,6 +6,7 @@
  * - legacy root JSONL files: <runsRoot>/*.jsonl
  * - canonical run trees: <runsRoot>/<loopId>/loop-record.json
  */
+import type { CostProvenance } from "../../contracts/index.js";
 export interface LoopAttemptRecord {
     index: number;
     model?: string;
@@ -32,6 +33,7 @@ export interface LoopRunRecord {
         tokensIn: number;
         tokensOut: number;
         avoidedUsd?: number;
+        provenance?: CostProvenance;
     };
     attempts: LoopAttemptRecord[];
     task: {

package/dist/vendor/core/policy.js

@@ -152,14 +152,14 @@ export function classifyFailure(input) {
             failureClass: "logic_error",
             rationale: "Oscillating failure pattern detected — switching strategy to break the cycle.",
             retryable: true,
-            recommendedIntervention: "change_model"
+            recommendedIntervention: "compress_context"
         };
     }
     return {
         failureClass: repeatedFailure ?? "logic_error",
         rationale: "The loop is still failing to produce a correct implementation.",
         retryable: true,
-        recommendedIntervention: repeatedFailure === "logic_error" ? "change_model" : "compress_context"
+        recommendedIntervention: "compress_context"
     };
 }
 export function evaluateCostGovernor(input) {
@@ -318,7 +318,7 @@ function mapClassHintToAssessment(classHint, attempts) {
                 failureClass: "hallucination",
                 rationale: "Structural evidence: suspiciously short or trivial agent response.",
                 retryable: true,
-                recommendedIntervention: repeatedFailure === "hallucination" ? "change_model" : "run_verifier"
+                recommendedIntervention: repeatedFailure === "hallucination" ? "compress_context" : "run_verifier"
             };
         case "verification_failure":
         case "test_regression":
@@ -333,7 +333,7 @@ function mapClassHintToAssessment(classHint, attempts) {
                 failureClass: classHint,
                 rationale: "Structural hint provided by adapter.",
                 retryable: true,
-                recommendedIntervention: repeatedFailure ? "change_model" : "compress_context"
+                recommendedIntervention: "compress_context"
             };
     }
 }
@@ -472,7 +472,7 @@ export function selectRecoveryRecipe(evidence) {
             return {
                 recipe: "strategy_swap",
                 rationale: "Very low diff novelty across repeated retries. Swap strategy.",
-                intervention: "change_model"
+                intervention: "compress_context"
             };
         }
         return {
@@ -485,7 +485,7 @@ export function selectRecoveryRecipe(evidence) {
         return {
             recipe: "downgrade_model",
             rationale: "Cost efficiency is degrading or retries are exhausted. Downgrade the model.",
-            intervention: "change_model"
+            intervention: "compress_context"
         };
     }
     return {

package/dist/vendor/core/red-blue/red-phase.d.ts

@@ -20,6 +20,7 @@ export interface MockModelClient {
         findings: RedFinding[];
         tokensUsed: number;
         costUsd: number;
+        model?: string;
     }>;
 }
 export interface RunRedPhaseOptions {
@@ -47,7 +48,7 @@ export interface PatchInput {
  *
  * - baseline: programmatic probes only, no model call
  * - high_risk: paranoid programmatic scan, no model call
- * - release_critical: paranoid scan + one Haiku model call
+ * - release_critical: paranoid scan + one configured model-client call
  */
 export declare function runRedPhase(patch: PatchInput, tier: RiskTier, blueBudgetUsd: number, options?: RunRedPhaseOptions): Promise<RedFindings>;
 /**

package/dist/vendor/core/red-blue/red-phase.js

@@ -1,4 +1,4 @@
-import { PROBE_COUNTS, RED_PHASE_MODEL, resolveRedBudgetPolicy } from "./risk-tiers.js";
+import { PROBE_COUNTS, resolveRedBudgetPolicy } from "./risk-tiers.js";
 // ─── Programmatic probes ──────────────────────────────────────────────────────
 function runProgrammaticProbes(patch, paranoid) {
     const findings = [];
@@ -62,7 +62,7 @@ function runProgrammaticProbes(patch, paranoid) {
  *
  * - baseline: programmatic probes only, no model call
  * - high_risk: paranoid programmatic scan, no model call
- * - release_critical: paranoid scan + one Haiku model call
+ * - release_critical: paranoid scan + one configured model-client call
  */
 export async function runRedPhase(patch, tier, blueBudgetUsd, options = {}) {
     const policy = resolveRedBudgetPolicy(tier, blueBudgetUsd);
@@ -77,7 +77,7 @@ export async function runRedPhase(patch, tier, blueBudgetUsd, options = {}) {
         const result = await options.modelClient.complete(prompt);
         findings = [...findings, ...result.findings];
         modelCallMade = true;
-        modelUsed = RED_PHASE_MODEL;
+        modelUsed = result.model;
         budgetUsedUsd += result.costUsd;
     }
     const result = {

package/dist/vendor/core/red-blue/risk-tiers.d.ts

@@ -4,7 +4,7 @@ export interface RedBudgetPolicy {
     blueBudgetUsd: number;
     /** Cap on Red phase spend: 30% / 100% / 150% of Blue */
     redBudgetCapUsd: number;
-    /** Only release_critical permits a Haiku model call */
+    /** Only release_critical permits an optional configured model-client call. */
     modelCallAllowed: boolean;
 }
 /**
@@ -15,8 +15,6 @@ export declare function resolveRedBudgetPolicy(tier: RiskTier, blueBudgetUsd: nu
  * Probe counts per tier.
  * baseline = standard 6-probe sweep
  * high_risk = paranoid 12-probe sweep
- * release_critical = paranoid 12-probe sweep + model
+ * release_critical = paranoid 12-probe sweep + configured model client
  */
 export declare const PROBE_COUNTS: Record<RiskTier, number>;
-/** The only model ever permitted in the Red phase. */
-export declare const RED_PHASE_MODEL: "claude-haiku-4-5-20251001";

package/dist/vendor/core/red-blue/risk-tiers.js

@@ -21,12 +21,10 @@ export function resolveRedBudgetPolicy(tier, blueBudgetUsd) {
  * Probe counts per tier.
  * baseline = standard 6-probe sweep
  * high_risk = paranoid 12-probe sweep
- * release_critical = paranoid 12-probe sweep + model
+ * release_critical = paranoid 12-probe sweep + configured model client
  */
 export const PROBE_COUNTS = {
     baseline: 6,
     high_risk: 12,
     release_critical: 12
 };
-/** The only model ever permitted in the Red phase. */
-export const RED_PHASE_MODEL = "claude-haiku-4-5-20251001";

package/dist/vendor/core/routing.d.ts

@@ -15,14 +15,6 @@ export interface RouteDecision {
     blockedSteps: string[];
     compressed: boolean;
     compressionSummary?: string;
-    /**
-     * Recommended model tier based on task complexity and route.
-     * Follows cost-aware routing: direct → haiku/sonnet, manager → sonnet,
-     * consensus → opus. Never use a more expensive model than the task needs.
-     */
-    recommendedModelTier: "haiku" | "sonnet" | "opus";
-    /** Estimated cost saving vs always using sonnet */
-    estimatedSavingVsSonnetUsd: number;
 }
 export interface RouteClassificationInput {
     objective: string;
@@ -37,40 +29,6 @@ export interface RouteClassificationInput {
     /** Historical success rate for similar tasks with direct execution (0-1). */
     historicalDirectSuccessRate?: number;
 }
-/**
- * Resolve a tier to a concrete model ID for a specific engine.
- * Allows downstream adapters to switch models automatically.
- */
-export declare function resolveModelForTier(tier: RouteDecision["recommendedModelTier"], engine: "claude" | "codex" | "gemini" | "openai" | string): string;
-/**
- * Available engine registry — describes what's installed and its capability.
- * Populated by doctor/preflight from PATH and env var detection.
- */
-export interface AvailableEngine {
-    id: string;
-    available: boolean;
-    /** Cost tier: cheap < mid < expensive */
-    costTier: "cheap" | "mid" | "expensive";
-    /** Capability tier: determines which task types this engine can handle */
-    capabilityTier: "haiku" | "sonnet" | "opus";
-}
-/**
- * Select the best available engine for a given tier requirement.
- *
- * When multiple engines are available, picks the cheapest that meets
- * the capability requirement. Falls back gracefully:
- * - If required tier unavailable, upgrades to next tier of same engine
- * - If only one engine family available, uses its best equivalent
- *
- * @param requiredTier - Minimum capability tier needed
- * @param availableEngines - What's installed and authenticated
- * @returns Best engine ID and concrete model to use
- */
-export declare function selectBestEngine(requiredTier: RouteDecision["recommendedModelTier"], availableEngines: AvailableEngine[]): {
-    engineId: string;
-    model: string;
-    reasoning: string;
-};
 export declare function classifyRoute(input: RouteClassificationInput): RouteDecision;
 /**
  * Checks whether a run's Pre Work Burn exceeds the routing policy limits.

package/dist/vendor/core/routing.js

@@ -84,144 +84,6 @@ function calculateDirectConfidence(signals, input) {
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// Cost-aware model tier routing
-//
-// Engine-agnostic tier system — each engine maps tiers to real model IDs.
-// Never pay for reasoning/orchestration on simple tasks.
-//
-// Tier → concrete model per engine:
-//   haiku  → claude-haiku-4-5, gpt-4o-mini, gemini-2.5-flash, deepseek-chat, qwen3-8b,  llama-3.1-8b
-//   sonnet → claude-sonnet-4-6, gpt-4o,     gemini-2.5-pro,  deepseek-r1,   qwen3-32b, llama-3.3-70b
-//   opus   → claude-opus-4-6,  o3,          gemini-2.5-ultra, deepseek-r1-671b, qwen3-235b, llama-3.1-405b
-//
-// Pricing reference (USD per 1M tokens, approx 2026):
-//   haiku:  $0.80 input / $4.00 output  (~1x baseline)
-//   sonnet: $3.00 input / $15.00 output (~4x haiku)
-//   opus:   $15.00 input / $75.00 output (~19x haiku)
-// ---------------------------------------------------------------------------
-const SONNET_AVG_COST_PER_USD_BUDGET = 0.35; // sonnet uses ~35% of budget on average
-const HAIKU_AVG_COST_PER_USD_BUDGET = 0.10; // haiku uses ~10% — ~3.5x cheaper
-function selectModelTier(mode) {
-    // Route already encodes complexity. Direct = passed the simplicity check → haiku.
-    if (mode === "direct")
-        return "haiku";
-    if (mode === "manager")
-        return "sonnet";
-    return "opus";
-}
-/**
- * Resolve a tier to a concrete model ID for a specific engine.
- * Allows downstream adapters to switch models automatically.
- */
-export function resolveModelForTier(tier, engine) {
-    const matrix = {
-        claude: {
-            haiku: "claude-haiku-4-5-20251001",
-            sonnet: "claude-sonnet-4-6",
-            opus: "claude-opus-4-6"
-        },
-        codex: {
-            haiku: "gpt-4o-mini",
-            sonnet: "gpt-4.1",
-            opus: "o3"
-        },
-        gemini: {
-            haiku: "gemini-2.5-flash",
-            sonnet: "gemini-2.5-pro",
-            opus: "gemini-2.5-ultra"
-        },
-        openai: {
-            haiku: "gpt-4o-mini",
-            sonnet: "gpt-4o",
-            opus: "o3"
-        },
-        deepseek: {
-            haiku: "deepseek-chat",
-            sonnet: "deepseek-r1",
-            opus: "deepseek-r1"
-        },
-        qwen: {
-            haiku: "qwen/qwen3-8b",
-            sonnet: "qwen/qwen3-32b",
-            opus: "qwen/qwen3-235b-a22b"
-        },
-        llama: {
-            haiku: "meta-llama/llama-3.1-8b-instruct",
-            sonnet: "meta-llama/llama-3.3-70b-instruct",
-            opus: "meta-llama/llama-3.1-405b-instruct"
-        }
-    };
-    const engineKey = engine.toLowerCase().split("-")[0] ?? engine;
-    const claudeMatrix = matrix.claude;
-    return matrix[engineKey]?.[tier] ?? claudeMatrix?.[tier] ?? "claude-sonnet-4-6";
-}
-function estimateSavingVsSonnet(tier, budgetUsd) {
-    if (tier === "sonnet")
-        return 0;
-    if (tier === "haiku")
-        return Math.round((SONNET_AVG_COST_PER_USD_BUDGET - HAIKU_AVG_COST_PER_USD_BUDGET) * budgetUsd * 100) / 100;
-    // opus costs more than sonnet — negative saving
-    return Math.round(-1 * SONNET_AVG_COST_PER_USD_BUDGET * budgetUsd * 0.5 * 100) / 100;
-}
-/**
- * Select the best available engine for a given tier requirement.
- *
- * When multiple engines are available, picks the cheapest that meets
- * the capability requirement. Falls back gracefully:
- * - If required tier unavailable, upgrades to next tier of same engine
- * - If only one engine family available, uses its best equivalent
- *
- * @param requiredTier - Minimum capability tier needed
- * @param availableEngines - What's installed and authenticated
- * @returns Best engine ID and concrete model to use
- */
-export function selectBestEngine(requiredTier, availableEngines) {
-    const available = availableEngines.filter((e) => e.available);
-    if (available.length === 0) {
-        // Nothing detected — default to claude (user must install)
-        return {
-            engineId: "claude",
-            model: resolveModelForTier(requiredTier, "claude"),
-            reasoning: "No engines detected. Defaulting to claude. Run martin doctor for setup instructions."
-        };
-    }
-    const tierRank = {
-        haiku: 0, sonnet: 1, opus: 2
-    };
-    const requiredRank = tierRank[requiredTier];
-    // Find the cheapest engine that meets or exceeds the required tier
-    const eligible = available
-        .filter((e) => tierRank[e.capabilityTier] >= requiredRank)
-        .sort((a, b) => {
-        // Sort by cost (cheap first), then by exact tier match
-        const costOrder = { cheap: 0, mid: 1, expensive: 2 };
-        if (costOrder[a.costTier] !== costOrder[b.costTier]) {
-            return costOrder[a.costTier] - costOrder[b.costTier];
-        }
-        // Prefer exact tier match over overqualified
-        const aExact = a.capabilityTier === requiredTier ? 0 : 1;
-        const bExact = b.capabilityTier === requiredTier ? 0 : 1;
-        return aExact - bExact;
-    });
-    if (eligible.length > 0) {
-        const best = eligible[0];
-        const model = resolveModelForTier(requiredTier, best.id);
-        return {
-            engineId: best.id,
-            model,
-            reasoning: `Selected ${best.id} (${model}) as cheapest available engine for ${requiredTier}-tier task.`
-        };
-    }
-    // All available engines are below required tier — upgrade to best available
-    const best = available.sort((a, b) => tierRank[b.capabilityTier] - tierRank[a.capabilityTier])[0];
-    const model = resolveModelForTier(best.capabilityTier, best.id);
-    return {
-        engineId: best.id,
-        model,
-        reasoning: `No ${requiredTier}-tier engine available. Upgrading to ${best.id} (${model}) — best available.`
-    };
-}
 export function classifyRoute(input) {
     const policy = { ...DEFAULT_ROUTING_POLICY, ...input.policy };
     const signals = extractComplexitySignals(input);
@@ -230,7 +92,6 @@ export function classifyRoute(input) {
     const blockedSteps = [];
     // Policy override: forced mode
     if (policy.mode === "direct") {
-        const tier = selectModelTier("direct");
         return {
             selectedMode: "direct",
             confidence: 1,
@@ -239,13 +100,10 @@ export function classifyRoute(input) {
             reason: ["Policy forces direct execution mode."],
             blockedSteps: ["manager", "planner", "router", "consensus"],
             compressed: true,
-            compressionSummary: "Policy: direct mode — skipping all orchestration.",
-            recommendedModelTier: tier,
-            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+            compressionSummary: "Policy: direct mode — skipping all orchestration."
         };
     }
     if (policy.mode === "consensus") {
-        const tier = selectModelTier("consensus");
         return {
             selectedMode: "consensus",
             confidence: 0.5,
@@ -253,9 +111,7 @@ export function classifyRoute(input) {
             expectedPreworkBurnPct: 35,
             reason: ["Policy forces consensus mode."],
             blockedSteps: [],
-            compressed: false,
-            recommendedModelTier: tier,
-            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+            compressed: false
         };
     }
     // Adaptive routing
@@ -268,7 +124,6 @@ export function classifyRoute(input) {
         if (signals.scopeRestricted)
             reason.push("Path scope is restricted.");
         blockedSteps.push("manager", "consensus");
-        const tier = selectModelTier("direct");
         return {
             selectedMode: "direct",
             confidence: directConfidence,
@@ -277,9 +132,7 @@ export function classifyRoute(input) {
             reason,
             blockedSteps,
             compressed: true,
-            compressionSummary: `Compressed from manager→planner→worker to direct worker. Estimated savings: ${String(Math.round(input.budgetUsd * 0.3 * 100) / 100)} USD.`,
-            recommendedModelTier: tier,
-            estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+            compressionSummary: `Compressed from manager→planner→worker to direct worker. Estimated savings: ${String(Math.round(input.budgetUsd * 0.3 * 100) / 100)} USD.`
         };
     }
     // Complex task — needs orchestration
@@ -293,7 +146,6 @@ export function classifyRoute(input) {
         reason.push(`Touches ${String(signals.fileCount)}+ files.`);
     const needsConsensus = signals.hasSecurityKeywords && signals.hasMigrationKeywords;
     const mode = needsConsensus ? "consensus" : "manager";
-    const tier = selectModelTier(mode);
     return {
         selectedMode: mode,
         confidence: directConfidence,
@@ -301,9 +153,7 @@ export function classifyRoute(input) {
         expectedPreworkBurnPct: needsConsensus ? 40 : 25,
         reason,
         blockedSteps: needsConsensus ? [] : ["consensus"],
-        compressed: false,
-        recommendedModelTier: tier,
-        estimatedSavingVsSonnetUsd: estimateSavingVsSonnet(tier, input.budgetUsd)
+        compressed: false
     };
 }
 function estimateDirectCost(budgetUsd) {

package/dist/vendor/core/verified-handoff.d.ts

@@ -1,4 +1,4 @@
-import type { LoopRecord, ReceiptIntegritySummary, TestIntegrityStatus, TestIntegrityVerdict, VerifiedHandoffOutcome, VerifiedHandoffRecoveryV1, VerifiedHandoffRequirementV1, VerifiedHandoffScopeV1, VerifiedHandoffTestIntegrityV1, VerifiedHandoffV1 } from "../contracts/index.js";
+import type { ExecutionMode, LoopRecord, ReceiptIntegritySummary, TestIntegrityStatus, TestIntegrityVerdict, VerifiedHandoffOutcome, VerifiedHandoffRecoveryV1, VerifiedHandoffRequirementV1, VerifiedHandoffScopeV1, VerifiedHandoffTestIntegrityV1, VerifiedHandoffV1 } from "../contracts/index.js";
 export declare function toTestIntegrityVerdict(status: TestIntegrityStatus): TestIntegrityVerdict;
 export interface VerifierExecutionBinding {
     runId: string;
@@ -30,8 +30,13 @@ export declare function resolveVerifiedHandoffOutcome(input: {
     changedFileCount?: number;
     definitionOfDonePreSatisfied?: boolean;
     evidenceContradicted?: boolean;
+    governanceClaimEligible?: boolean;
     unresolvedWorkCount: number;
 }): VerifiedHandoffOutcome;
+export declare function deriveVerifiedHandoffExecutionBoundary(loop: LoopRecord): {
+    executionMode: ExecutionMode;
+    governanceClaimEligible: boolean;
+};
 export interface BuildVerifiedHandoffInput {
     loop: LoopRecord;
     generatedAt?: string;

package/dist/vendor/core/verified-handoff.js

@@ -57,6 +57,7 @@ export function resolveVerifiedHandoffOutcome(input) {
         return "STOPPED";
     }
     if (input.executionStatus === "failed" ||
+        input.governanceClaimEligible === false ||
         input.evidenceContradicted === true ||
         (input.mutationRequired === true &&
             (input.changedFileCount ?? 0) === 0 &&
@@ -80,6 +81,29 @@ export function resolveVerifiedHandoffOutcome(input) {
     }
     return "NEEDS_REVIEW";
 }
+const SIMULATED_ADAPTER_PATTERN = /(?:^|:)(?:stub|fixture|synthetic)(?::|$)/u;
+function isExecutionMode(value) {
+    return value === "governed" || value === "verification_only" || value === "simulated";
+}
+export function deriveVerifiedHandoffExecutionBoundary(loop) {
+    const adapterIds = loop.attempts.map((attempt) => attempt.adapterId);
+    const hasSimulatedAdapter = adapterIds.some((adapterId) => adapterId === "direct:proof:no-mutation" ||
+        SIMULATED_ADAPTER_PATTERN.test(adapterId));
+    const hasVerifierOnlyAdapter = adapterIds.some((adapterId) => adapterId === "direct:verifier:verify-only");
+    const persistedMode = isExecutionMode(loop.metadata["executionMode"])
+        ? loop.metadata["executionMode"]
+        : undefined;
+    const groundingEvidenceAvailable = loop.metadata["groundingEvidenceStatus"] !== "unavailable";
+    const executionMode = hasSimulatedAdapter
+        ? "simulated"
+        : hasVerifierOnlyAdapter
+            ? "verification_only"
+            : persistedMode ?? (adapterIds.length > 0 ? "governed" : "simulated");
+    return {
+        executionMode,
+        governanceClaimEligible: executionMode === "governed" && adapterIds.length > 0 && groundingEvidenceAvailable,
+    };
+}
 function toEvidenceStatus(status) {
     switch (status) {
         case "passed":
@@ -132,6 +156,7 @@ export function buildVerifiedHandoff(input) {
         summary: input.testIntegrity?.summary ??
             "Test integrity was not evaluated for this run.",
     };
+    const executionBoundary = deriveVerifiedHandoffExecutionBoundary(input.loop);
     const outcome = resolveVerifiedHandoffOutcome({
         lifecycleState: input.loop.lifecycleState,
         executionStatus: input.executionStatus,
@@ -143,6 +168,7 @@ export function buildVerifiedHandoff(input) {
         changedFileCount: scope.changedFiles.length,
         definitionOfDonePreSatisfied: input.definitionOfDonePreSatisfied,
         evidenceContradicted: input.evidenceContradicted ?? input.verification.status === "contradicted",
+        governanceClaimEligible: executionBoundary.governanceClaimEligible,
         unresolvedWorkCount: unresolvedWork.length,
     });
     const handoffId = `vh_${createHash("sha256")
@@ -163,6 +189,8 @@ export function buildVerifiedHandoff(input) {
             verificationPlan: input.loop.task.verificationPlan,
         },
         outcome,
+        executionMode: executionBoundary.executionMode,
+        governanceClaimEligible: executionBoundary.governanceClaimEligible,
         sourceStatus: {
             status: input.loop.status,
             lifecycleState: input.loop.lifecycleState,