@martinloop/mcp 0.3.0 → 0.3.1

package/README.md

@@ -2,16 +2,16 @@
 
 Governed MCP server for AI coding agents over local stdio.
 
-`@martinloop/mcp@0.2.7` is the current public baseline. It gives hosts one bounded execution entrypoint, strong read-only inspection, clear next-step guidance, and a safer default MartinLoop workflow.
+`@martinloop/mcp@0.3.0` is the live public baseline today. `0.3.1` is the current in-repo release candidate for the next public cut.
 
 This package stays local-first and stdio-first in the public OSS lane.
 
 ## Public release train
 
 - `0.2.7` made the guided MCP workflow easier to adopt and harder to misuse.
-- `0.3.0` is the next adoption release.
-- `0.3.1` is planned for review and handoff controls.
-- `0.3.2` is planned for opt-in execution controls.
+- `0.3.0` is the live adoption baseline that made host setup and onboarding clearer.
+- `0.3.1` is the review and handoff release candidate currently staged in-repo.
+- `0.3.2` remains the planned follow-on for opt-in execution controls.
 
 ## What ships today
 

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const MARTIN_MCP_PACKAGE_VERSION = "0.3.0";
+export declare const MARTIN_MCP_PACKAGE_VERSION = "0.3.1";

package/dist/package-version.js

@@ -1,3 +1,3 @@
 // Keep this aligned with packages/mcp/package.json during version bumps so the
 // runtime does not depend on package.json being present in every hosted bundle.
-export const MARTIN_MCP_PACKAGE_VERSION = "0.3.0";
+export const MARTIN_MCP_PACKAGE_VERSION = "0.3.1";

package/dist/server.js

@@ -44,8 +44,9 @@ import { martinTriageRunsTool } from "./tools/triage-runs.js";
 import { runLoopTool } from "./tools/run-loop.js";
 import { createToolErrorResult, createToolSuccessResult } from "./tools/tool-response.js";
 import { MartinToolError, toToolFailure } from "./tools/tool-errors.js";
-import { sanitizeToolErrorMessage, validateToolInput } from "./server-validation.js";
-import { recordMcpWorkflowStep } from "./workflow-state.js";
+import { normalizeLoopBudget } from "./tools/workflow-governance.js";
+import { resolveSafeRepoRoot, sanitizeToolErrorMessage, validateToolInput } from "./server-validation.js";
+import { evaluateMcpRunGate, recordMcpWorkflowStep } from "./workflow-state.js";
 const stringArraySchema = {
     type: "array",
     items: { type: "string" }
@@ -142,6 +143,17 @@ const verificationSchema = {
     },
     required: ["status", "eventCount", "ledgerEventCount", "warnings"]
 };
+const receiptScopeSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        invocationRoot: { type: "string" },
+        workingDirectory: { type: "string" },
+        repoRoot: { type: "string" },
+        runsRoot: { type: "string" }
+    },
+    required: ["invocationRoot", "workingDirectory", "repoRoot", "runsRoot"]
+};
 const artifactSummarySchema = {
     type: "object",
     additionalProperties: true,
@@ -391,6 +403,7 @@ const doctorOutputSchema = {
             },
             required: ["workspaceRoot", "workingDirectory", "runsRoot", "mode", "liveMode"]
         },
+        receiptScope: receiptScopeSchema,
         engines: {
             type: "object",
             additionalProperties: true
@@ -408,7 +421,7 @@ const doctorOutputSchema = {
         },
         warnings: stringArraySchema
     },
-    required: ["status", "summary", "server", "environment", "engines", "runStore", "warnings"]
+    required: ["status", "summary", "server", "environment", "receiptScope", "engines", "runStore", "warnings"]
 };
 const preflightOutputSchema = {
     type: "object",
@@ -417,6 +430,7 @@ const preflightOutputSchema = {
         ok: { type: "boolean" },
         summary: { type: "string" },
         warnings: stringArraySchema,
+        receiptScope: receiptScopeSchema,
         readiness: {
             type: "object",
             additionalProperties: false,
@@ -492,7 +506,7 @@ const preflightOutputSchema = {
             required: ["requestedEngine", "engineAvailability", "runsRoot", "pathScope", "expectedRunLayout"]
         }
     },
-    required: ["ok", "summary", "warnings", "readiness", "normalized", "execution"]
+    required: ["ok", "summary", "warnings", "receiptScope", "readiness", "normalized", "execution"]
 };
 const listRunsOutputSchema = {
     type: "object",
@@ -1397,6 +1411,36 @@ export function createMartinMcpServer(serverInfo) {
         try {
             if (name === "martin_run") {
                 const input = validateToolInput("martin_run", args);
+                const runsRoot = resolveRunsRoot(process.env);
+                const workingDirectory = input.workingDirectory ?? resolveSafeRepoRoot();
+                const receiptScope = {
+                    invocationRoot: resolveSafeRepoRoot(),
+                    workingDirectory,
+                    repoRoot: workingDirectory,
+                    runsRoot
+                };
+                const gate = await evaluateMcpRunGate({
+                    runsRoot,
+                    workingDirectory,
+                    objective: input.objective,
+                    engine: input.engine,
+                    verificationPlan: input.verificationPlan,
+                    receiptScope,
+                    allowedPaths: input.allowedPaths,
+                    deniedPaths: input.deniedPaths,
+                    budget: normalizeRunBudget(input)
+                });
+                if (!gate.allowed) {
+                    throw new MartinToolError("policy_blocked", gate.summary, {
+                        category: "policy_blocked",
+                        suggestion: gate.nextAction,
+                        retryable: false,
+                        details: {
+                            missingSteps: gate.missingSteps,
+                            receiptScope
+                        }
+                    });
+                }
                 const output = await runLoopTool(input);
                 return createToolSuccessResult(output, `Run ${output.loopId} is ${output.status}/${output.lifecycleState} after ${output.attempts} attempt(s); spend ${output.costUsd.toFixed(2)} USD.`);
             }
@@ -1417,7 +1461,8 @@ export function createMartinMcpServer(serverInfo) {
                     runsRoot: output.environment.runsRoot,
                     step: "doctor",
                     workingDirectory: output.environment.workingDirectory,
-                    engine: input.engine
+                    engine: input.engine,
+                    receiptScope: output.receiptScope
                 }).catch(() => { });
                 return createToolSuccessResult(output, output.summary);
             }
@@ -1428,7 +1473,13 @@ export function createMartinMcpServer(serverInfo) {
                     runsRoot: resolveRunsRoot(process.env),
                     step: "plan",
                     workingDirectory: output.workingDirectory,
-                    objective: output.objective
+                    objective: output.objective,
+                    receiptScope: {
+                        invocationRoot: resolveSafeRepoRoot(),
+                        workingDirectory: output.workingDirectory,
+                        repoRoot: output.workingDirectory,
+                        runsRoot: resolveRunsRoot(process.env)
+                    }
                 }).catch(() => { });
                 return createToolSuccessResult(output, `Plan ready for ${output.objective} with ${output.risk.level} risk and ${output.approvalRecommendation.replace(/_/gu, " ")} approval.`);
             }
@@ -1442,7 +1493,11 @@ export function createMartinMcpServer(serverInfo) {
                         workingDirectory: output.normalized.workingDirectory,
                         objective: output.normalized.objective,
                         engine: output.normalized.engine,
-                        verificationPlan: output.normalized.verificationPlan
+                        verificationPlan: output.normalized.verificationPlan,
+                        receiptScope: output.receiptScope,
+                        allowedPaths: output.normalized.allowedPaths,
+                        deniedPaths: output.normalized.deniedPaths,
+                        budget: output.normalized.budget
                     }).catch(() => { });
                 }
                 return createToolSuccessResult(output, output.summary);
@@ -1532,6 +1587,13 @@ export function createMartinMcpServer(serverInfo) {
     });
     return server;
 }
+function normalizeRunBudget(input) {
+    return normalizeLoopBudget({
+        maxUsd: input.maxUsd,
+        maxIterations: input.maxIterations,
+        maxTokens: input.maxTokens
+    });
+}
 export async function connectMartinMcpStdioServer() {
     const server = createMartinMcpServer();
     const transport = new StdioServerTransport();

package/dist/tools/doctor.d.ts

@@ -27,14 +27,41 @@ export interface MartinDoctorOutput {
         repoRoot: string;
         runsRoot: string;
     };
+    receiptScope: {
+        invocationRoot: string;
+        workingDirectory: string;
+        repoRoot: string;
+        runsRoot: string;
+    };
     engines: Record<MartinEngine, {
         available: boolean;
         detail: string;
         resolvedPath?: string;
+        candidatePaths?: string[];
+        selectedPath?: string;
         hostPlatform?: CodexHostPlatform;
+        installKind?: string;
         nativeInstallValid?: boolean;
+        invocationMode?: string;
+        sandboxMode?: string;
+        sandboxCompatible?: boolean;
+        nativeDependencyStatus?: string;
+        nativeDependencyPackage?: string;
         launchReady?: boolean;
         probeSummary?: string;
+        remediation?: string;
+        candidateProbeResults?: Array<{
+            path: string;
+            installKind: string;
+            invocationMode: string;
+            nativeInstallValid: boolean;
+            sandboxCompatible: boolean;
+            launchReady: boolean;
+            summary: string;
+            remediation?: string;
+            nativeDependencyStatus?: string;
+            nativeDependencyPackage?: string;
+        }>;
     }>;
     requestedEngine?: MartinEngine;
     runStore: {

package/dist/tools/doctor.js

@@ -1,26 +1,40 @@
 import { probeCodexLaunch, resolveCliCommandAvailability } from "../vendor/adapters/index.js";
 import { resolveRunsRoot } from "../vendor/core/index.js";
 import { resolveSafeRepoRoot, resolveSafeRunsRootPath } from "../server-validation.js";
-import { getEngineAvailability, inspectRunsRoot, resolveExecutionMode } from "./tool-support.js";
+import { createSkippedCliAvailability, getEngineAvailability, inspectRunsRoot, resolveExecutionMode } from "./tool-support.js";
 import { buildReadinessReport, inspectRepoSignals } from "./workflow-governance.js";
 export async function martinDoctorTool(input) {
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
     const runsRoot = resolveSafeRunsRootPath(input.runsDir, resolveRunsRoot(process.env));
     const workspaceRoot = resolveSafeRepoRoot();
     const executionMode = resolveExecutionMode();
-    const claude = getEngineAvailability("claude");
-    const codex = resolveCliCommandAvailability("codex");
-    const gemini = getEngineAvailability("gemini");
-    const codexProbe = executionMode.liveMode && codex.available
+    const claude = executionMode.liveMode
+        ? getEngineAvailability("claude")
+        : createSkippedCliAvailability("claude");
+    const codex = executionMode.liveMode
+        ? resolveCliCommandAvailability("codex")
+        : createSkippedCliAvailability("codex");
+    const gemini = executionMode.liveMode
+        ? getEngineAvailability("gemini")
+        : createSkippedCliAvailability("gemini");
+    const codexProbe = executionMode.liveMode && input.engine === "codex" && codex.available
         ? probeCodexLaunch({
             workingDirectory,
             availability: codex
         })
         : undefined;
     const runStore = await inspectRunsRoot(runsRoot);
-    const signals = inspectRepoSignals(workingDirectory);
+    const signals = inspectRepoSignals(workingDirectory, {
+        includeHostAvailability: executionMode.liveMode
+    });
     const readiness = buildReadinessReport(signals, runStore);
     const warnings = [];
+    const receiptScope = {
+        invocationRoot: workspaceRoot,
+        workingDirectory,
+        repoRoot: workingDirectory,
+        runsRoot
+    };
     if (!runStore.exists) {
         warnings.push("Configured Martin runs root does not exist yet.");
     }
@@ -57,11 +71,9 @@ export async function martinDoctorTool(input) {
             liveMode: executionMode.liveMode
         },
         scope: {
-            invocationRoot: workspaceRoot,
-            workingDirectory,
-            repoRoot: workingDirectory,
-            runsRoot
+            ...receiptScope
         },
+        receiptScope,
         engines: {
             claude: {
                 available: claude.available,
@@ -72,12 +84,28 @@ export async function martinDoctorTool(input) {
                 available: codex.available,
                 detail: codex.detail,
                 ...(codex.resolvedPath ? { resolvedPath: codex.resolvedPath } : {}),
+                ...(codex.candidatePaths?.length ? { candidatePaths: codex.candidatePaths } : {}),
                 ...(codexProbe
                     ? {
+                        selectedPath: codexProbe.command,
                         hostPlatform: codexProbe.diagnosis.hostPlatform,
+                        installKind: codexProbe.diagnosis.installKind,
                         nativeInstallValid: codexProbe.diagnosis.nativeInstallValid,
+                        invocationMode: codexProbe.diagnosis.invocationMode,
+                        sandboxMode: codexProbe.diagnosis.sandboxMode,
+                        sandboxCompatible: codexProbe.diagnosis.sandboxCompatible,
+                        ...(codexProbe.diagnosis.nativeDependencyStatus
+                            ? { nativeDependencyStatus: codexProbe.diagnosis.nativeDependencyStatus }
+                            : {}),
+                        ...(codexProbe.diagnosis.nativeDependencyPackage
+                            ? { nativeDependencyPackage: codexProbe.diagnosis.nativeDependencyPackage }
+                            : {}),
                         launchReady: codexProbe.ok,
-                        probeSummary: codexProbe.summary
+                        probeSummary: codexProbe.summary,
+                        ...(codexProbe.diagnosis.remediation ? { remediation: codexProbe.diagnosis.remediation } : {}),
+                        ...(codexProbe.candidateProbeResults?.length
+                            ? { candidateProbeResults: codexProbe.candidateProbeResults }
+                            : {})
                     }
                     : {})
             },

package/dist/tools/get-run.d.ts

@@ -1,5 +1,5 @@
 import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
-import type { ReceiptIntegritySummary } from "../vendor/contracts/index.js";
+import type { ReceiptIntegritySummary, ReceiptScope } from "../vendor/contracts/index.js";
 export interface MartinGetRunInput {
     file?: string;
     loopId?: string;
@@ -14,6 +14,7 @@ export interface MartinGetRunOutput {
     cost: ReturnType<typeof buildCostSnapshot>;
     verification: ReturnType<typeof buildVerificationSummary>;
     receiptIntegrity: ReceiptIntegritySummary;
+    receiptScope?: ReceiptScope;
     artifacts: ReturnType<typeof buildArtifactSummary>;
     inspection: {
         runsRoot: string;

package/dist/tools/get-run.js

@@ -12,6 +12,7 @@ export async function martinGetRunTool(input) {
         cost: buildCostSnapshot(detail.loop.cost),
         verification,
         receiptIntegrity: resolveReceiptIntegrity(detail.loop),
+        ...(detail.loop.receiptScope ? { receiptScope: detail.loop.receiptScope } : {}),
         artifacts: buildArtifactSummary(detail.loop),
         inspection: {
             runsRoot: detail.runsRoot,

package/dist/tools/get-verification-results.d.ts

@@ -1,5 +1,5 @@
 import { buildLoopPreview, buildVerificationSummary } from "./tool-support.js";
-import type { ReceiptIntegritySummary } from "../vendor/contracts/index.js";
+import type { ReceiptIntegritySummary, ReceiptScope } from "../vendor/contracts/index.js";
 export interface MartinGetVerificationResultsInput {
     file?: string;
     loopId?: string;
@@ -11,6 +11,7 @@ export interface MartinGetVerificationResultsOutput {
     loop: ReturnType<typeof buildLoopPreview>;
     verification: ReturnType<typeof buildVerificationSummary>;
     receiptIntegrity: ReceiptIntegritySummary;
+    receiptScope?: ReceiptScope;
     warnings: string[];
 }
 export declare function martinGetVerificationResultsTool(input: MartinGetVerificationResultsInput): Promise<MartinGetVerificationResultsOutput>;

package/dist/tools/get-verification-results.js

@@ -10,6 +10,7 @@ export async function martinGetVerificationResultsTool(input) {
         loop: buildLoopPreview(detail.loop),
         verification,
         receiptIntegrity: resolveReceiptIntegrity(detail.loop),
+        ...(detail.loop.receiptScope ? { receiptScope: detail.loop.receiptScope } : {}),
         warnings: [...detail.warnings, ...verification.warnings]
     };
 }

package/dist/tools/plan.js

@@ -1,8 +1,10 @@
 import { resolveSafeRepoRoot } from "../server-validation.js";
-import { buildPlanProposal } from "./workflow-governance.js";
+import { buildPlanProposal, inspectRepoSignals } from "./workflow-governance.js";
 export async function martinPlanTool(input) {
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
-    const proposal = buildPlanProposal(workingDirectory, input);
+    const proposal = buildPlanProposal(workingDirectory, input, {
+        signals: inspectRepoSignals(workingDirectory, { includeHostAvailability: false })
+    });
     return {
         workingDirectory,
         ...proposal

package/dist/tools/preflight.d.ts

@@ -24,6 +24,12 @@ export interface MartinPreflightOutput {
     ok: boolean;
     summary: string;
     warnings: string[];
+    receiptScope: {
+        invocationRoot: string;
+        workingDirectory: string;
+        repoRoot: string;
+        runsRoot: string;
+    };
     scope: {
         invocationRoot: string;
         workingDirectory: string;
@@ -58,12 +64,33 @@ export interface MartinPreflightOutput {
             available: boolean;
             detail: string;
             resolvedPath?: string;
+            candidatePaths?: string[];
         };
         codexDiagnostics?: {
+            selectedPath?: string;
             hostPlatform: CodexHostPlatform;
+            installKind: string;
             nativeInstallValid: boolean;
+            invocationMode: string;
+            sandboxMode: string;
+            sandboxCompatible: boolean;
+            nativeDependencyStatus?: string;
+            nativeDependencyPackage?: string;
             launchReady: boolean;
             summary: string;
+            remediation?: string;
+            candidateProbeResults?: Array<{
+                path: string;
+                installKind: string;
+                invocationMode: string;
+                nativeInstallValid: boolean;
+                sandboxCompatible: boolean;
+                launchReady: boolean;
+                summary: string;
+                remediation?: string;
+                nativeDependencyStatus?: string;
+                nativeDependencyPackage?: string;
+            }>;
         };
         runsRoot: string;
         pathScope: {

package/dist/tools/preflight.js

@@ -1,16 +1,21 @@
 import { probeCodexLaunch, resolveCliCommandAvailability } from "../vendor/adapters/index.js";
-import { DEFAULT_BUDGET } from "../vendor/contracts/index.js";
 import { resolveRunsRoot } from "../vendor/core/index.js";
 import { resolveSafeRepoRoot } from "../server-validation.js";
-import { formatUsd, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
-import { buildPlanProposal, buildRunContract, buildPolicyPackDefinition, inspectRepoSignals } from "./workflow-governance.js";
+import { createSkippedCliAvailability, formatUsd, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
+import { buildPlanProposal, normalizeLoopBudget, buildRunContract, buildPolicyPackDefinition, inspectRepoSignals } from "./workflow-governance.js";
 export async function martinPreflightTool(input) {
     const executionMode = resolveExecutionMode();
     const workspaceRoot = resolveSafeRepoRoot();
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
-    const signals = inspectRepoSignals(workingDirectory);
+    const signals = inspectRepoSignals(workingDirectory, {
+        includeHostAvailability: executionMode.liveMode
+    });
     const engine = input.engine ?? "claude";
-    const engineAvailability = engine === "codex" ? resolveCliCommandAvailability("codex") : getEngineAvailability(engine);
+    const engineAvailability = executionMode.liveMode
+        ? engine === "codex"
+            ? resolveCliCommandAvailability("codex")
+            : getEngineAvailability(engine)
+        : createSkippedCliAvailability(engine);
     const codexProbe = executionMode.liveMode && engine === "codex" && engineAvailability.available
         ? probeCodexLaunch({
             workingDirectory,
@@ -21,12 +26,11 @@ export async function martinPreflightTool(input) {
     const allowedPaths = input.allowedPaths ?? [];
     const deniedPaths = input.deniedPaths ?? [];
     const overlappingScopes = allowedPaths.filter((candidate) => deniedPaths.includes(candidate));
-    const budget = {
-        ...DEFAULT_BUDGET,
-        ...(input.maxUsd !== undefined ? { maxUsd: input.maxUsd } : {}),
-        ...(input.maxIterations !== undefined ? { maxIterations: input.maxIterations } : {}),
-        ...(input.maxTokens !== undefined ? { maxTokens: input.maxTokens } : {})
-    };
+    const budget = normalizeLoopBudget({
+        maxUsd: input.maxUsd,
+        maxIterations: input.maxIterations,
+        maxTokens: input.maxTokens
+    });
     if (!executionMode.liveMode) {
         warnings.push("Proof mode is active; preflight only proves configuration shape, not live CLI readiness.");
     }
@@ -45,12 +49,18 @@ export async function martinPreflightTool(input) {
     if (overlappingScopes.length > 0) {
         warnings.push(`Some path patterns appear in both allowedPaths and deniedPaths: ${overlappingScopes.join(", ")}.`);
     }
-    const plan = buildPlanProposal(workingDirectory, input);
-    const runContract = buildRunContract(workingDirectory, input);
+    const plan = buildPlanProposal(workingDirectory, input, { signals });
+    const runContract = buildRunContract(workingDirectory, input, { signals, plan });
     const policy = buildPolicyPackDefinition(input.policyPack, signals);
     const engineReady = !executionMode.liveMode ||
         (engineAvailability.available && (engine !== "codex" || codexProbe?.ok !== false));
     const ok = engineReady;
+    const receiptScope = {
+        invocationRoot: workspaceRoot,
+        workingDirectory,
+        repoRoot: workingDirectory,
+        runsRoot: resolveRunsRoot(process.env)
+    };
     return {
         ok,
         summary: ok
@@ -59,11 +69,9 @@ export async function martinPreflightTool(input) {
                 ? codexProbe.summary
                 : `${engine} is not available for live execution.`}`,
         warnings,
+        receiptScope,
         scope: {
-            invocationRoot: workspaceRoot,
-            workingDirectory,
-            repoRoot: workingDirectory,
-            runsRoot: resolveRunsRoot(process.env)
+            ...receiptScope
         },
         readiness: {
             mode: executionMode.mode,
@@ -87,17 +95,33 @@ export async function martinPreflightTool(input) {
             engineAvailability: {
                 available: engineAvailability.available,
                 detail: engineAvailability.detail,
-                ...(engineAvailability.resolvedPath
-                    ? { resolvedPath: engineAvailability.resolvedPath }
+                ...(engineAvailability.resolvedPath ? { resolvedPath: engineAvailability.resolvedPath } : {}),
+                ...(engineAvailability.candidatePaths?.length
+                    ? { candidatePaths: engineAvailability.candidatePaths }
                     : {})
             },
             ...(codexProbe
                 ? {
                     codexDiagnostics: {
+                        selectedPath: codexProbe.command,
                         hostPlatform: codexProbe.diagnosis.hostPlatform,
+                        installKind: codexProbe.diagnosis.installKind,
                         nativeInstallValid: codexProbe.diagnosis.nativeInstallValid,
+                        invocationMode: codexProbe.diagnosis.invocationMode,
+                        sandboxMode: codexProbe.diagnosis.sandboxMode,
+                        sandboxCompatible: codexProbe.diagnosis.sandboxCompatible,
+                        ...(codexProbe.diagnosis.nativeDependencyStatus
+                            ? { nativeDependencyStatus: codexProbe.diagnosis.nativeDependencyStatus }
+                            : {}),
+                        ...(codexProbe.diagnosis.nativeDependencyPackage
+                            ? { nativeDependencyPackage: codexProbe.diagnosis.nativeDependencyPackage }
+                            : {}),
                         launchReady: codexProbe.ok,
-                        summary: codexProbe.summary
+                        summary: codexProbe.summary,
+                        ...(codexProbe.diagnosis.remediation ? { remediation: codexProbe.diagnosis.remediation } : {}),
+                        ...(codexProbe.candidateProbeResults?.length
+                            ? { candidateProbeResults: codexProbe.candidateProbeResults }
+                            : {})
                     }
                 }
                 : {}),

package/dist/tools/run-dossier.d.ts

@@ -2,7 +2,7 @@ import { buildArtifactSummary, buildBudgetSnapshot, buildCostSnapshot, buildEven
 import { readRunControlState } from "./run-controls.js";
 import { martinEvalTool } from "./eval.js";
 import { assessRunRisk } from "./workflow-governance.js";
-import type { ReceiptIntegritySummary } from "../vendor/contracts/index.js";
+import type { ReceiptIntegritySummary, ReceiptScope } from "../vendor/contracts/index.js";
 export interface MartinRunDossierInput {
     file?: string;
     loopId?: string;
@@ -17,6 +17,7 @@ export interface MartinRunDossierOutput {
     budget: ReturnType<typeof buildBudgetSnapshot>;
     cost: ReturnType<typeof buildCostSnapshot>;
     receiptIntegrity: ReceiptIntegritySummary;
+    receiptScope?: ReceiptScope;
     attempts: Array<{
         index: number;
         attemptId?: string;

package/dist/tools/run-dossier.js

@@ -53,6 +53,7 @@ export async function martinRunDossierTool(input) {
         budget: buildBudgetSnapshot(detail.loop.budget),
         cost: buildCostSnapshot(detail.loop.cost),
         receiptIntegrity: resolveReceiptIntegrity(detail.loop),
+        ...(detail.loop.receiptScope ? { receiptScope: detail.loop.receiptScope } : {}),
         attempts,
         verification,
         artifacts: buildArtifactSummary(detail.loop),

package/dist/tools/run-loop.d.ts

@@ -1,4 +1,6 @@
-import { type LoopBudget, type ReceiptScope } from "../vendor/contracts/index.js";
+import { type SpawnLike } from "../vendor/adapters/index.js";
+import { type RunStore } from "../vendor/core/index.js";
+import type { LoopBudget, ReceiptScope } from "../vendor/contracts/index.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, type MartinEngine } from "./tool-support.js";
 export interface RunLoopInput {
     objective: string;
@@ -41,4 +43,6 @@ export interface RunLoopOutput {
         artifacts: ReturnType<typeof buildArtifactSummary>;
     };
 }
+export declare function __setProofModeVerifierSpawnImplForTests(spawnImpl?: SpawnLike): void;
+export declare function __setRunStoreOverrideForTests(store?: RunStore): void;
 export declare function runLoopTool(input: RunLoopInput): Promise<RunLoopOutput>;

package/dist/tools/run-loop.js

@@ -1,9 +1,17 @@
 import { createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, probeCodexLaunch, resolveCliCommandAvailability, createVerifierOnlyAdapter } from "../vendor/adapters/index.js";
 import { createFileRunStore, evaluateCostGovernor, resolveRunsRoot, runMartin } from "../vendor/core/index.js";
-import { DEFAULT_BUDGET } from "../vendor/contracts/index.js";
 import { normalizeSafePathPatterns, resolveSafeRepoRoot } from "../server-validation.js";
 import { MartinToolError } from "./tool-errors.js";
 import { buildArtifactSummary, buildVerificationSummary, buildLoopPreview, buildRunRecordPaths, getEngineAvailability, resolveExecutionMode } from "./tool-support.js";
+import { normalizeLoopBudget } from "./workflow-governance.js";
+let proofModeVerifierSpawnImpl;
+let runStoreOverrideForTests;
+export function __setProofModeVerifierSpawnImplForTests(spawnImpl) {
+    proofModeVerifierSpawnImpl = spawnImpl;
+}
+export function __setRunStoreOverrideForTests(store) {
+    runStoreOverrideForTests = store;
+}
 export async function runLoopTool(input) {
     const workingDirectory = resolveSafeRepoRoot(input.workingDirectory);
     const engine = input.engine ?? "claude";
@@ -19,6 +27,7 @@ export async function runLoopTool(input) {
         repoRoot: workingDirectory,
         runsRoot
     };
+    let codexCommandOverride;
     if (executionMode.liveMode) {
         if (engine === "codex") {
             const engineAvailability = resolveCliCommandAvailability("codex");
@@ -40,6 +49,7 @@ export async function runLoopTool(input) {
                     retryable: false
                 });
             }
+            codexCommandOverride = codexProbe.command;
         }
         else {
             const engineAvailability = getEngineAvailability(engine);
@@ -55,10 +65,15 @@ export async function runLoopTool(input) {
     const adapter = !executionMode.liveMode
         ? createVerifierOnlyAdapter({
             workingDirectory,
-            label: "Proof mode adapter (MARTIN_LIVE=false)"
+            label: "Proof mode adapter (MARTIN_LIVE=false)",
+            ...(proofModeVerifierSpawnImpl ? { spawnImpl: proofModeVerifierSpawnImpl } : {})
         })
         : engine === "codex"
-            ? createCodexCliAdapter({ workingDirectory, ...(model ? { model } : {}) })
+            ? createCodexCliAdapter({
+                workingDirectory,
+                ...(model ? { model } : {}),
+                ...(codexCommandOverride ? { command: codexCommandOverride } : {})
+            })
             : engine === "gemini"
                 ? createGeminiCliAdapter({ workingDirectory, ...(model ? { model } : {}) })
                 : createClaudeCliAdapter({ workingDirectory, ...(model ? { model } : {}) });
@@ -72,14 +87,11 @@ export async function runLoopTool(input) {
     if (input.maxTokens !== undefined) {
         partialBudget.maxTokens = input.maxTokens;
     }
-    const budget = {
-        ...DEFAULT_BUDGET,
-        ...partialBudget
-    };
+    const budget = normalizeLoopBudget(partialBudget);
     const result = await runMartin({
         workspaceId: input.workspaceId ?? "ws_mcp",
         projectId: input.projectId ?? "proj_mcp",
-        store: createFileRunStore({ runsRoot }),
+        store: runStoreOverrideForTests ?? createFileRunStore({ runsRoot }),
         receiptScope,
         task: {
             title: input.objective.slice(0, 100),