@martinloop/mcp 0.3.4 → 0.3.5

package/dist/discovery-metadata.d.ts

@@ -1,10 +1,10 @@
-export declare const MARTIN_TOOL_NAMES: readonly ["martin_run", "martin_inspect", "martin_status", "martin_doctor", "martin_plan", "martin_preflight", "martin_logs", "martin_pause", "martin_cancel", "martin_continue", "martin_list_runs", "martin_triage_runs", "martin_get_run", "martin_get_attempt", "martin_get_verification_results", "martin_run_dossier", "martin_dossier", "martin_eval", "martin_pr_summary", "martin_create_pr", "martin_review_pr"];
-export declare const MARTIN_STARTER_TOOL_NAMES: readonly ["martin_doctor", "martin_plan", "martin_preflight", "martin_run", "martin_triage_runs", "martin_dossier"];
-export declare const MARTIN_MINIMAL_TOOL_NAMES: readonly ["martin_doctor", "martin_plan", "martin_preflight", "martin_list_runs", "martin_triage_runs", "martin_dossier"];
-export declare const MARTIN_DIAGNOSTIC_TOOL_NAMES: readonly ["martin_doctor", "martin_plan", "martin_preflight", "martin_logs", "martin_list_runs", "martin_triage_runs", "martin_get_run", "martin_get_attempt", "martin_get_verification_results", "martin_dossier", "martin_eval"];
+export declare const MARTIN_TOOL_NAMES: readonly ["martin_run", "martin_inspect", "martin_status", "martin_doctor", "martin_plan", "martin_preflight", "martin_estimate", "martin_logs", "martin_pause", "martin_cancel", "martin_continue", "martin_list_runs", "martin_triage_runs", "martin_get_run", "martin_get_attempt", "martin_get_verification_results", "martin_run_dossier", "martin_dossier", "martin_eval", "martin_pr_summary", "martin_create_pr", "martin_review_pr"];
+export declare const MARTIN_STARTER_TOOL_NAMES: readonly ["martin_doctor", "martin_plan", "martin_preflight", "martin_estimate", "martin_run", "martin_triage_runs", "martin_dossier"];
+export declare const MARTIN_MINIMAL_TOOL_NAMES: readonly ["martin_doctor", "martin_plan", "martin_preflight", "martin_estimate", "martin_list_runs", "martin_triage_runs", "martin_dossier"];
+export declare const MARTIN_DIAGNOSTIC_TOOL_NAMES: readonly ["martin_doctor", "martin_plan", "martin_preflight", "martin_estimate", "martin_logs", "martin_list_runs", "martin_triage_runs", "martin_get_run", "martin_get_attempt", "martin_get_verification_results", "martin_dossier", "martin_eval"];
 export declare const MARTIN_GITHUB_REVIEW_TOOL_NAMES: readonly ["martin_doctor", "martin_plan", "martin_preflight", "martin_dossier", "martin_eval", "martin_pr_summary", "martin_create_pr", "martin_review_pr"];
-export declare const MARTIN_PAID_REMOTE_TOOL_NAMES: readonly ["martin_doctor", "martin_plan", "martin_preflight", "martin_run", "martin_list_runs", "martin_triage_runs", "martin_get_run", "martin_get_verification_results", "martin_dossier", "martin_eval"];
-export declare const MARTIN_RESOURCE_URIS: readonly ["martin://server/health", "martin://runs/recent", "martin://runs/triage", "martin://runs/latest", "martin://runs/latest/summary", "martin://runs/latest/proof-card", "martin://runs/latest/budget-status", "martin://runs/latest/verifier-evidence", "martin://runs/latest/rollback-evidence", "martin://policies/current", "martin://repo/risk-map", "martin://verifiers/results", "martin://agent/next-step", "martin://guides/mcp-usage", "martin://guides/agent-start", "martin://guides/command-map", "martin://guides/ide-onboarding", "martin://guides/operating-rules", "martin://guides/publish-readiness"];
+export declare const MARTIN_PAID_REMOTE_TOOL_NAMES: readonly ["martin_doctor", "martin_plan", "martin_preflight", "martin_estimate", "martin_run", "martin_list_runs", "martin_triage_runs", "martin_get_run", "martin_get_verification_results", "martin_dossier", "martin_eval"];
+export declare const MARTIN_RESOURCE_URIS: readonly ["martin://server/health", "martin://runs/recent", "martin://runs/triage", "martin://runs/latest", "martin://runs/latest/summary", "martin://runs/latest/proof-card", "martin://runs/latest/budget-status", "martin://runs/latest/verifier-evidence", "martin://runs/latest/rollback-evidence", "martin://policies/current", "martin://repo/risk-map", "martin://verifiers/results", "martin://agent/next-step", "martin://agent/governance-status", "martin://guides/mcp-usage", "martin://guides/agent-start", "martin://guides/command-map", "martin://guides/ide-onboarding", "martin://guides/operating-rules", "martin://guides/publish-readiness"];
 export declare const MARTIN_RESOURCE_TEMPLATE_URIS: readonly ["martin://runs/{loopId}", "martin://runs/{loopId}/dossier", "martin://runs/{loopId}/attempts/{attemptIndex}", "martin://runs/{loopId}/verification"];
 export declare const MARTIN_PROMPT_NAMES: readonly ["martin_start", "martin_preflight", "martin_triage", "martin_resume", "martin_prove", "martin_release_check", "martin_governed_coding_kickoff", "martin_debug_failed_run", "martin_publish_readiness_review", "martin_triage_run_store", "safe_bug_fix", "write_tests_first", "small_refactor", "security_review", "pr_review", "release_check"];
 export interface MartinDiscoveryMetadata {

package/dist/discovery-metadata.js

@@ -6,6 +6,7 @@ export const MARTIN_TOOL_NAMES = [
     "martin_doctor",
     "martin_plan",
     "martin_preflight",
+    "martin_estimate",
     "martin_logs",
     "martin_pause",
     "martin_cancel",
@@ -26,6 +27,7 @@ export const MARTIN_STARTER_TOOL_NAMES = [
     "martin_doctor",
     "martin_plan",
     "martin_preflight",
+    "martin_estimate",
     "martin_run",
     "martin_triage_runs",
     "martin_dossier"
@@ -34,6 +36,7 @@ export const MARTIN_MINIMAL_TOOL_NAMES = [
     "martin_doctor",
     "martin_plan",
     "martin_preflight",
+    "martin_estimate",
     "martin_list_runs",
     "martin_triage_runs",
     "martin_dossier"
@@ -42,6 +45,7 @@ export const MARTIN_DIAGNOSTIC_TOOL_NAMES = [
     "martin_doctor",
     "martin_plan",
     "martin_preflight",
+    "martin_estimate",
     "martin_logs",
     "martin_list_runs",
     "martin_triage_runs",
@@ -65,6 +69,7 @@ export const MARTIN_PAID_REMOTE_TOOL_NAMES = [
     "martin_doctor",
     "martin_plan",
     "martin_preflight",
+    "martin_estimate",
     "martin_run",
     "martin_list_runs",
     "martin_triage_runs",
@@ -87,6 +92,7 @@ export const MARTIN_RESOURCE_URIS = [
     "martin://repo/risk-map",
     "martin://verifiers/results",
     "martin://agent/next-step",
+    "martin://agent/governance-status",
     "martin://guides/mcp-usage",
     "martin://guides/agent-start",
     "martin://guides/command-map",

package/dist/resources.d.ts

@@ -20,6 +20,7 @@ export declare const MARTIN_STATIC_RESOURCE_URIS: {
     readonly ideOnboardingGuide: "martin://guides/ide-onboarding";
     readonly operatingRulesGuide: "martin://guides/operating-rules";
     readonly publishReadinessGuide: "martin://guides/publish-readiness";
+    readonly governanceStatus: "martin://agent/governance-status";
 };
 export declare const MARTIN_RESOURCE_TEMPLATES: ResourceTemplate[];
 export declare const MARTIN_STATIC_RESOURCES: Resource[];

package/dist/resources.js

@@ -5,6 +5,7 @@ import { martinDoctorTool } from "./tools/doctor.js";
 import { martinTriageRunsTool } from "./tools/triage-runs.js";
 import { martinRunDossierTool } from "./tools/run-dossier.js";
 import { inspectRepoSignals, buildPolicyPackDefinition, buildRepoRiskMap } from "./tools/workflow-governance.js";
+import { readWorkflowState } from "./workflow-state.js";
 import { buildAttemptSnapshot, buildPersistedLoopPreview, buildVerificationHistorySnapshot, parseAttemptIndex, resolveMartinDiscoveryContext, toPrettyJson } from "./discovery-support.js";
 import { loadDetailedLoopRecord, readLedgerEvents } from "./tools/run-store.js";
 import { invalidArgumentsError, MartinToolError } from "./tools/tool-errors.js";
@@ -27,7 +28,8 @@ export const MARTIN_STATIC_RESOURCE_URIS = {
     commandMapGuide: "martin://guides/command-map",
     ideOnboardingGuide: "martin://guides/ide-onboarding",
     operatingRulesGuide: "martin://guides/operating-rules",
-    publishReadinessGuide: "martin://guides/publish-readiness"
+    publishReadinessGuide: "martin://guides/publish-readiness",
+    governanceStatus: "martin://agent/governance-status"
 };
 export const MARTIN_RESOURCE_TEMPLATES = [
     {
@@ -188,6 +190,13 @@ export const MARTIN_STATIC_RESOURCES = [
         title: "Martin Publish Readiness Guide",
         description: "Checklist-oriented guide for MCP publish readiness reviews.",
         mimeType: "text/markdown"
+    },
+    {
+        uri: MARTIN_STATIC_RESOURCE_URIS.governanceStatus,
+        name: "martin_governance_status",
+        title: "Martin Governance Status",
+        description: "Proactive governance status: whether work is governed, budget remaining, unreceipted runs, and recommended next action. Read this before starting agent work.",
+        mimeType: "application/json"
     }
 ];
 export function listMartinResources() {
@@ -237,6 +246,8 @@ export async function readMartinResource(input) {
             return jsonResource(input.uri, withDiscoveryMetadata(buildRepoRiskMap(inspectRepoSignals(context.workingDirectory)), context.runsRoot));
         case MARTIN_STATIC_RESOURCE_URIS.verifierResults:
             return jsonResource(input.uri, withDiscoveryMetadata(await buildLatestVerifierEvidenceResource(context.runsRoot), context.runsRoot));
+        case MARTIN_STATIC_RESOURCE_URIS.governanceStatus:
+            return jsonResource(input.uri, withDiscoveryMetadata(await buildGovernanceStatusResource(context.runsRoot, context.workingDirectory), context.runsRoot));
         case MARTIN_STATIC_RESOURCE_URIS.agentNextStep:
             return jsonResource(input.uri, withDiscoveryMetadata(await buildAgentNextStepResource(context.runsRoot), context.runsRoot));
         case MARTIN_STATIC_RESOURCE_URIS.mcpUsageGuide:
@@ -565,6 +576,57 @@ function compactEmptyState(kind, runsRoot, warnings) {
         warnings
     };
 }
+async function buildGovernanceStatusResource(runsRoot, workingDirectory) {
+    const state = await readWorkflowState(runsRoot);
+    const mcpState = state.mcp ?? {};
+    const hasDoctor = Boolean(mcpState.doctor);
+    const hasPlan = Boolean(mcpState.plan);
+    const hasPreflight = Boolean(mcpState.preflight);
+    const governed = hasDoctor && hasPlan && hasPreflight;
+    const latest = await loadLatestRunForCompactResource(runsRoot);
+    const budgetRemaining = (!latest.empty && latest.detail)
+        ? buildPersistedLoopPreview(latest.detail.loop).remainingBudgetUsd
+        : null;
+    let unreceiptedRuns = 0;
+    try {
+        const inspection = await inspectLoopTool({ runsDir: runsRoot });
+        const total = inspection.loopCount ?? 0;
+        const completed = (inspection.statusBreakdown?.completed ?? 0) + (inspection.statusBreakdown?.failed ?? 0);
+        unreceiptedRuns = Math.max(0, total - completed);
+    }
+    catch {
+        // No runs yet
+    }
+    const missingSteps = [];
+    if (!hasDoctor)
+        missingSteps.push("martin_doctor");
+    if (!hasPlan)
+        missingSteps.push("martin_plan");
+    if (!hasPreflight)
+        missingSteps.push("martin_preflight");
+    const recommendedAction = !hasDoctor
+        ? "Run martin_doctor to confirm environment before any work."
+        : !hasPlan
+            ? "Run martin_plan with your objective to scope the task."
+            : !hasPreflight
+                ? "Run martin_preflight to validate the run contract before execution."
+                : "Governance complete. You may proceed with martin_run.";
+    return {
+        kind: "governance-status",
+        governed,
+        workflowReceipts: {
+            doctor: hasDoctor ? { recordedAt: mcpState.doctor.recordedAt } : null,
+            plan: hasPlan ? { recordedAt: mcpState.plan.recordedAt } : null,
+            preflight: hasPreflight ? { recordedAt: mcpState.preflight.recordedAt } : null
+        },
+        missingSteps,
+        budgetRemaining,
+        unreceiptedRuns,
+        recommendedAction,
+        requiredSequence: ["martin_doctor", "martin_plan", "martin_preflight", "martin_run", "martin_dossier"],
+        warning: governed ? undefined : "This session is NOT governed. Complete the required sequence before making changes."
+    };
+}
 function buildCurrentPoliciesResource(workingDirectory) {
     const signals = inspectRepoSignals(workingDirectory);
     const recommended = buildPolicyPackDefinition(undefined, signals);

package/dist/server.js

@@ -43,6 +43,7 @@ import { createRunControlReceipt } from "./tools/run-controls.js";
 import { martinTriageRunsTool } from "./tools/triage-runs.js";
 import { runLoopTool } from "./tools/run-loop.js";
 import { MARTIN_ENGINE_VALUES } from "./tools/tool-support.js";
+import { classifyRoute } from "./vendor/core/index.js";
 import { createToolErrorResult, createToolSuccessResult } from "./tools/tool-response.js";
 import { MartinToolError, toToolFailure } from "./tools/tool-errors.js";
 import { normalizeLoopBudget } from "./tools/workflow-governance.js";
@@ -1370,6 +1371,59 @@ export function createMartinMcpServer(serverInfo) {
                     oneOf: [{ required: ["file"] }, { required: ["loopId"] }, { required: ["latest"] }]
                 },
                 outputSchema: prReviewOutputSchema
+            },
+            {
+                name: "martin_estimate",
+                description: "Estimate the cost, recommended route, and Pre Work Burn for an objective without spending anything. Use before martin_run to understand what a task will cost.",
+                annotations: {
+                    readOnlyHint: true,
+                    idempotentHint: true
+                },
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        objective: {
+                            type: "string",
+                            description: "The coding task to estimate."
+                        },
+                        engine: {
+                            type: "string",
+                            enum: [...MARTIN_ENGINE_VALUES],
+                            description: "Which agent CLI would be used. Defaults to claude."
+                        },
+                        budgetUsd: {
+                            type: "number",
+                            exclusiveMinimum: 0,
+                            description: "Budget ceiling for estimation. Defaults to 5."
+                        },
+                        fileScope: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional file paths to scope the estimate."
+                        }
+                    },
+                    required: ["objective"]
+                },
+                outputSchema: {
+                    type: "object",
+                    additionalProperties: true,
+                    properties: {
+                        objective: { type: "string" },
+                        engine: { type: "string" },
+                        budgetUsd: { type: "number" },
+                        selectedMode: { type: "string" },
+                        confidence: { type: "number" },
+                        expectedCostUsd: { type: "number" },
+                        expectedPreworkBurnPct: { type: "number" },
+                        reason: { type: "array", items: { type: "string" } },
+                        blockedSteps: { type: "array", items: { type: "string" } },
+                        compressed: { type: "boolean" },
+                        compressionSummary: { type: "string" },
+                        recommendedBudgetUsd: { type: "number" }
+                    },
+                    required: ["objective", "engine", "budgetUsd", "selectedMode", "confidence", "expectedCostUsd", "expectedPreworkBurnPct", "reason"]
+                }
             }
         ]
     }));
@@ -1580,6 +1634,38 @@ export function createMartinMcpServer(serverInfo) {
                 const output = await martinReviewPrTool(input);
                 return createToolSuccessResult(output, `PR review verdict for ${output.loopId}: ${output.verdict}.`);
             }
+            if (name === "martin_estimate") {
+                const input = args;
+                const objective = input.objective;
+                const engine = input.engine ?? "claude";
+                const budgetUsd = input.budgetUsd ?? 5;
+                const fileScope = input.fileScope ?? [];
+                const route = classifyRoute({
+                    objective,
+                    verificationPlan: [],
+                    budgetUsd,
+                    allowedPaths: fileScope,
+                    scopedFileCount: fileScope.length > 0 ? fileScope.length : undefined
+                });
+                const recommendedBudgetUsd = route.selectedMode === "direct"
+                    ? Math.max(2, Math.round(route.expectedCostUsd * 3 * 100) / 100)
+                    : Math.max(5, Math.round(route.expectedCostUsd * 2 * 100) / 100);
+                const output = {
+                    objective,
+                    engine,
+                    budgetUsd,
+                    selectedMode: route.selectedMode,
+                    confidence: route.confidence,
+                    expectedCostUsd: route.expectedCostUsd,
+                    expectedPreworkBurnPct: route.expectedPreworkBurnPct,
+                    reason: route.reason,
+                    blockedSteps: route.blockedSteps,
+                    compressed: route.compressed,
+                    ...(route.compressionSummary ? { compressionSummary: route.compressionSummary } : {}),
+                    recommendedBudgetUsd
+                };
+                return createToolSuccessResult(output, `Estimate: ${route.selectedMode} route, ~$${route.expectedCostUsd.toFixed(2)} expected cost, ${route.expectedPreworkBurnPct}% pre-work burn. Recommended budget: $${recommendedBudgetUsd.toFixed(2)}.`);
+            }
             return createToolErrorResult(toToolFailure(new Error(`Unknown tool: ${name}`)));
         }
         catch (error) {

package/dist/tools/run-store.js

@@ -16,17 +16,17 @@ async function attachReceiptIntegrity(detail) {
             loopRecordPath: detail.canonicalLoopRecordPath,
             ledgerPath
         }).catch(() => ({
-            state: "material_missing",
+            state: "unsigned",
             reason: "Receipt integrity verification could not be completed."
         }))
         : detail.canonicalLoopRecordPath && detail.canonicalRunDirectory
             ? ({
-                state: "material_missing",
+                state: "unsigned",
                 reason: "Receipt integrity material is incomplete for this canonical run."
             })
             : ({
-                state: "selector_noncanonical",
-                reason: "Receipt integrity is only available for canonical run selectors."
+                state: "unsigned",
+                reason: "Receipt integrity is only available for canonical run directories."
             });
     const receiptScope = resolveReceiptScope(detail.loop, detail.runsRoot);
     return {

package/dist/tools/tool-support.d.ts

@@ -14,6 +14,7 @@ export interface InspectableLoopRecord extends Omit<LoopRunRecord, "attempts" |
     metadata?: Record<string, string>;
     receiptIntegrity?: ReceiptIntegritySummary;
     receiptScope?: ReceiptScope;
+    routingEconomics?: import("../vendor/contracts/index.js").RoutingEconomics;
 }
 export interface LoopPreview {
     loopId: string;
@@ -32,6 +33,7 @@ export interface LoopPreview {
     remainingIterations: number;
     remainingTokens: number;
     lastAttempt?: AttemptSummary;
+    routingEconomics?: Record<string, unknown>;
 }
 export interface AttemptArtifactFiles {
     directory: string;

package/dist/tools/tool-support.js

@@ -214,7 +214,22 @@ export function buildLoopPreview(loop) {
         remainingBudgetUsd: costState.remainingBudgetUsd,
         remainingIterations: costState.remainingIterations,
         remainingTokens: costState.remainingTokens,
-        ...(lastAttempt ? { lastAttempt: buildAttemptSummary(lastAttempt) } : {})
+        ...(lastAttempt ? { lastAttempt: buildAttemptSummary(lastAttempt) } : {}),
+        ...(loop.routingEconomics ? { routingEconomics: buildRoutingEconomicsSummary(loop.routingEconomics) } : {})
+    };
+}
+function buildRoutingEconomicsSummary(economics) {
+    return {
+        preworkBurnPct: economics.preworkBurnPct,
+        preworkCostUsd: economics.preworkCostUsd,
+        executionCostUsd: economics.executionCostUsd,
+        totalCostUsd: economics.totalCostUsd,
+        ...(economics.timeToFirstDeltaMs !== undefined ? { timeToFirstDeltaMs: economics.timeToFirstDeltaMs } : {}),
+        ...(economics.costPerAcceptedChange !== undefined ? { costPerAcceptedChange: economics.costPerAcceptedChange } : {}),
+        ...(economics.routeRecommendation ? {
+            routeRecommendation: economics.routeRecommendation,
+            routeRecommendationReason: economics.routeRecommendationReason
+        } : {})
     };
 }
 export function buildAttemptSummary(attempt, artifacts) {

package/dist/vendor/adapters/claude-cli.js

@@ -12,7 +12,7 @@
  * MCP tools and integration tests use the same factories.
  */
 import { readGitExecutionArtifacts, resolveGitRepositoryRoot, runSubprocess, runVerification } from "./cli-bridge.js";
-import { buildCodexExecArgs } from "./codex-launcher.js";
+import { buildCodexExecArgs, DEFAULT_CODEX_CHATGPT_MODEL } from "./codex-launcher.js";
 import { createAdapterCapabilities, normalizeStructuredErrors, normalizeUsage } from "./runtime-support.js";
 // ---------------------------------------------------------------------------
 // Cost estimation
@@ -253,6 +253,10 @@ function createStreamingUsageInspector(capUsd, modelLabel) {
     const bytesCeiling = blendedCostPerChar > 0
         ? Math.ceil((capUsd / blendedCostPerChar) * 2)
         : 100_000_000;
+    // Time-based fallback: if we receive data but no usage events for this long,
+    // estimate spend from byte volume and enforce the cap. Prevents the inspector
+    // from going blind when Claude changes its stream-json event format.
+    const USAGE_BLIND_TIMEOUT_MS = 30_000;
     let buffer = "";
     let cumulativeUsd = 0;
     let tokensIn = 0;
@@ -260,6 +264,7 @@ function createStreamingUsageInspector(capUsd, modelLabel) {
     let turns = 0;
     let totalBytes = 0;
     let usageEventSeen = false;
+    let firstChunkAt;
     let finalResult;
     const checkBudgetExceeded = (terminate) => {
         if (capUsd > 0 && cumulativeUsd > effectiveCapUsd) {
@@ -324,6 +329,7 @@ function createStreamingUsageInspector(capUsd, modelLabel) {
             const chunkStr = chunk.toString("utf8");
             totalBytes += chunk.byteLength;
             buffer += chunkStr;
+            firstChunkAt ??= Date.now();
             // Token-count ceiling fallback: if we've ingested a lot of bytes but
             // never seen a single usage event, the event format may have changed
             // and the inspector is silently blind. Terminate as a last resort.
@@ -333,6 +339,23 @@ function createStreamingUsageInspector(capUsd, modelLabel) {
                     `Subprocess terminated as a fallback budget guard for cap $${capUsd.toFixed(4)}.`);
                 return;
             }
+            // Time-based fallback: if we've been receiving data for 30+ seconds
+            // without a single usage event, estimate spend from byte volume and
+            // enforce the cap. This catches cases where Claude's event format
+            // changed but bytes are still flowing.
+            if (!usageEventSeen &&
+                capUsd > 0 &&
+                firstChunkAt !== undefined &&
+                Date.now() - firstChunkAt > USAGE_BLIND_TIMEOUT_MS &&
+                totalBytes > 10_000) {
+                const estimatedUsd = totalBytes * blendedCostPerChar;
+                if (estimatedUsd > effectiveCapUsd) {
+                    terminate(`No usage events received after ${String(Math.round((Date.now() - firstChunkAt) / 1000))}s ` +
+                        `(${String(totalBytes)} bytes). Estimated cost ~$${estimatedUsd.toFixed(4)} exceeds cap ` +
+                        `$${capUsd.toFixed(4)}. Subprocess terminated to prevent unmetered spend.`);
+                    return;
+                }
+            }
             let newlineIndex = buffer.indexOf("\n");
             while (newlineIndex !== -1) {
                 const line = buffer.slice(0, newlineIndex);
@@ -773,6 +796,11 @@ export function createClaudeCliAdapter(options = {}) {
             "--verbose",
             "--print",
             "--dangerously-skip-permissions",
+            // Prevent the child Claude process from loading the parent's MCP servers.
+            // Without this, a MartinLoop MCP server in the user's config gets spawned
+            // inside the governed subprocess, causing conflicts and "MCP server being
+            // overwritten" errors.
+            "--strict-mcp-config",
             ...modelArgs,
             ...extraArgs
         ],
@@ -797,6 +825,7 @@ export function createCodexCliAdapter(options = {}) {
     const sandbox = options.sandbox ?? "workspace-write";
     const workingDirectory = options.workingDirectory ?? process.cwd();
     const command = options.command ?? "codex";
+    const launchModel = options.model ?? DEFAULT_CODEX_CHATGPT_MODEL;
     return createAgentCliAdapter({
         command,
         adapterIdSuffix: "codex",
@@ -810,7 +839,7 @@ export function createCodexCliAdapter(options = {}) {
         argsBuilder: () => buildCodexExecArgs({
             workingDirectory,
             sandbox,
-            ...(options.model ? { model: options.model } : {}),
+            model: launchModel,
             extraArgs,
             mode: "prompt"
         }),

package/dist/vendor/adapters/cli-bridge.d.ts

@@ -71,6 +71,16 @@ export declare function readGitExecutionArtifacts(repoRoot: string, timeoutMs: n
     diffStats?: ReturnType<typeof diffStatsFromNumstat>;
 }>;
 export declare function readGitChangedFiles(repoRoot: string, timeoutMs: number, spawnImpl?: SpawnLike): Promise<string[]>;
+/**
+ * Detects whether a meaningful workspace delta has occurred by checking
+ * git status for changed files that aren't MartinLoop metadata, lockfiles,
+ * or cache artifacts. Returns the first meaningful changed file if found.
+ */
+export declare function detectFirstDelta(repoRoot: string, timeoutMs: number, spawnImpl?: SpawnLike): Promise<{
+    detected: boolean;
+    filePath?: string;
+    changeType?: "create" | "modify" | "delete";
+}>;
 export declare function resolveGitRepositoryRoot(workingDirectory: string): string | undefined;
 export interface SpawnPlan {
     command: string;

package/dist/vendor/adapters/cli-bridge.js

@@ -236,6 +236,36 @@ export async function readGitChangedFiles(repoRoot, timeoutMs, spawnImpl) {
     }
     return parsePorcelainEntries(statusResult.stdout).filter((entry) => typeof entry === "string" && entry.length > 0);
 }
+// Ignore paths that are not meaningful code changes for first-delta detection
+const FIRST_DELTA_IGNORE = [
+    /^\.martin\//u,
+    /^PROGRESS\.md$/u,
+    /\.lock$/u,
+    /^node_modules\//u,
+    /^\.git\//u,
+    /^\.cache\//u,
+];
+/**
+ * Detects whether a meaningful workspace delta has occurred by checking
+ * git status for changed files that aren't MartinLoop metadata, lockfiles,
+ * or cache artifacts. Returns the first meaningful changed file if found.
+ */
+export async function detectFirstDelta(repoRoot, timeoutMs, spawnImpl) {
+    const changedFiles = await readGitChangedFiles(repoRoot, timeoutMs, spawnImpl);
+    for (const file of changedFiles) {
+        if (FIRST_DELTA_IGNORE.some((pattern) => pattern.test(file))) {
+            continue;
+        }
+        // Classify: new file = create, deleted = delete, else modify
+        const diffResult = await runSubprocess("git", ["status", "--porcelain", "--", file], { cwd: repoRoot, timeoutMs: 3000, spawnImpl });
+        const status = diffResult.stdout.trim().slice(0, 2);
+        const changeType = status.includes("?") ? "create"
+            : status.includes("D") ? "delete"
+                : "modify";
+        return { detected: true, filePath: file, changeType };
+    }
+    return { detected: false };
+}
 export function resolveGitRepositoryRoot(workingDirectory) {
     const resolvedWorkingDirectory = resolve(workingDirectory);
     const cached = gitRepositoryRootCache.get(resolvedWorkingDirectory);

package/dist/vendor/adapters/codex-launcher.d.ts

@@ -43,6 +43,7 @@ export interface CodexExecArgsOptions {
     mode?: "prompt" | "probe";
 }
 type SpawnSyncLike = typeof spawnSync;
+export declare const DEFAULT_CODEX_CHATGPT_MODEL = "gpt-5.4";
 export interface CodexProbeCandidateResult {
     path: string;
     installKind: CodexInstallKind;
@@ -72,5 +73,6 @@ export declare function probeCodexLaunch(input: {
     env?: NodeJS.ProcessEnv;
     platform?: NodeJS.Platform;
     spawnSyncImpl?: SpawnSyncLike;
+    model?: string;
 }): CodexLaunchProbeResult;
 export {};

package/dist/vendor/adapters/codex-launcher.js

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
 const codexLaunchProbeCache = new Map();
+export const DEFAULT_CODEX_CHATGPT_MODEL = "gpt-5.4";
 const CODEX_LAUNCH_PROBE_PROMPT = [
     "You are validating MartinLoop Codex host readiness.",
     "Do not edit files.",
@@ -14,7 +15,8 @@ function buildProbeCacheKey(input) {
     return JSON.stringify({
         workingDirectory: resolve(input.workingDirectory),
         platform: input.platform,
-        candidatePaths: input.candidatePaths
+        candidatePaths: input.candidatePaths,
+        model: input.model ?? DEFAULT_CODEX_CHATGPT_MODEL
     });
 }
 function isInsideGitRepository(workingDirectory) {
@@ -167,6 +169,39 @@ function detectInvocationMode(resolvedPath, platform) {
 }
 function classifyProbeFailure(stderr, stdout, diagnosis) {
     const combined = `${stderr}\n${stdout}`;
+    if (/MARTIN_REMOTE_TOKEN/iu.test(combined) ||
+        /AuthRequired\(AuthRequiredError/iu.test(combined) ||
+        /www_authenticate_header/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const configCollisionWarning = "Codex inherited auth-sensitive MCP or plugin state from the operator's default user config.";
+        if (!warnings.includes(configCollisionWarning)) {
+            warnings.push(configCollisionWarning);
+        }
+        return {
+            summary: "Codex inherited auth-sensitive MCP or plugin state from the operator's default user config. Governed Codex runs should launch with `exec --ignore-user-config` so missing remote tokens or third-party auth do not abort MartinLoop work.",
+            diagnosis: {
+                ...diagnosis,
+                warnings,
+                remediation: "Retry the governed Codex launch with `exec --ignore-user-config`, or remove auth-sensitive MCP/plugin dependencies from the default Codex user config before running MartinLoop."
+            }
+        };
+    }
+    if (/not supported when using Codex with a ChatGPT account/iu.test(combined) ||
+        /gpt-5\.3-codex/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const unsupportedModelWarning = "Codex tried to use a model that is not supported for ChatGPT-account authentication.";
+        if (!warnings.includes(unsupportedModelWarning)) {
+            warnings.push(unsupportedModelWarning);
+        }
+        return {
+            summary: `Codex launched with a model that is not supported for ChatGPT-account authentication. Use an explicit supported model such as \`${DEFAULT_CODEX_CHATGPT_MODEL}\` for governed Codex work.`,
+            diagnosis: {
+                ...diagnosis,
+                warnings,
+                remediation: `Override the Codex launch model to a ChatGPT-account-supported option such as \`${DEFAULT_CODEX_CHATGPT_MODEL}\` before running governed Codex work.`
+            }
+        };
+    }
     if (/@openai\/codex-linux-x64/iu.test(combined) ||
         /cannot find module ['"]@openai\/codex-linux-x64['"]/iu.test(combined)) {
         const warnings = [...diagnosis.warnings];
@@ -205,6 +240,24 @@ function classifyProbeFailure(stderr, stdout, diagnosis) {
             }
         };
     }
+    if (/writing is blocked by read-only sandbox/iu.test(combined) ||
+        /read-only filesystem sandbox/iu.test(combined) ||
+        /approval is disabled/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const readOnlySandboxWarning = "Codex stayed in a read-only or approval-disabled sandbox even though MartinLoop requested workspace-write.";
+        if (!warnings.includes(readOnlySandboxWarning)) {
+            warnings.push(readOnlySandboxWarning);
+        }
+        return {
+            summary: "Codex stayed in a read-only or approval-disabled sandbox even though MartinLoop requested workspace-write.",
+            diagnosis: {
+                ...diagnosis,
+                sandboxCompatible: false,
+                warnings,
+                remediation: "Launch governed Codex runs with `codex exec --ignore-user-config --sandbox workspace-write`. If the session still reports a read-only sandbox, treat it as a host/runtime mismatch and repair or relocate the affected Codex workspace before resuming governed work."
+            }
+        };
+    }
     return {};
 }
 export function buildCodexExecArgs(options) {
@@ -213,6 +266,8 @@ export function buildCodexExecArgs(options) {
     const extraArgs = options.extraArgs ?? [];
     return [
         "exec",
+        // Governed MartinLoop runs should not inherit auth-sensitive default MCP/plugin state.
+        "--ignore-user-config",
         "--cd",
         options.workingDirectory,
         "--sandbox",
@@ -396,6 +451,7 @@ export function probeCodexLaunch(input) {
     });
     const args = buildCodexExecArgs({
         workingDirectory: input.workingDirectory,
+        model: input.model ?? DEFAULT_CODEX_CHATGPT_MODEL,
         mode: "probe"
     });
     if (!availability.available) {
@@ -431,7 +487,8 @@ export function probeCodexLaunch(input) {
     const cacheKey = buildProbeCacheKey({
         workingDirectory: input.workingDirectory,
         platform,
-        candidatePaths
+        candidatePaths,
+        model: input.model
     });
     if (input.spawnSyncImpl === undefined) {
         const cached = codexLaunchProbeCache.get(cacheKey);

package/dist/vendor/contracts/execution-policy.d.ts

@@ -59,4 +59,20 @@ export interface ExecutionPolicyCompileInput {
     config?: ExecutionPolicyConfigInput;
     request: ExecutionPolicyRequestInput;
 }
+export type RoutingMode = "direct" | "manager" | "adaptive" | "consensus";
+export interface RoutingPolicy {
+    enabled: boolean;
+    mode: RoutingMode;
+    /** Max percentage of total budget that can be spent before first code change. */
+    maxPreworkBudgetPct: number;
+    /** Hard dollar cap on pre-work spend. */
+    maxPreworkCostUsd: number;
+    /** Max model calls allowed for manager/router/planner before worker starts. */
+    maxManagerCalls: number;
+    /** Skip orchestration entirely if task confidence is above this threshold (0-1). */
+    skipOrchestrationIfConfidenceAbove: number;
+    /** Force direct execution for tasks classified as simple. */
+    requireDirectForSimpleTasks: boolean;
+}
+export declare const DEFAULT_ROUTING_POLICY: RoutingPolicy;
 export declare function cloneExecutionPolicy(policy: ExecutionPolicy): ExecutionPolicy;

package/dist/vendor/contracts/execution-policy.js

@@ -1,3 +1,12 @@
+export const DEFAULT_ROUTING_POLICY = {
+    enabled: true,
+    mode: "adaptive",
+    maxPreworkBudgetPct: 25,
+    maxPreworkCostUsd: 2.0,
+    maxManagerCalls: 2,
+    skipOrchestrationIfConfidenceAbove: 0.85,
+    requireDirectForSimpleTasks: true
+};
 export function cloneExecutionPolicy(policy) {
     return {
         configPath: policy.configPath,