@martinloop/mcp 0.3.4 → 0.3.6

package/dist/server-validation.js

@@ -18,6 +18,8 @@ export function validateToolInput(name, args) {
             return validatePlanInput(args);
         case "martin_preflight":
             return validatePreflightInput(args);
+        case "martin_estimate":
+            return validateEstimateInput(args);
         case "martin_logs":
             return validateLogsInput(args);
         case "martin_cancel":
@@ -258,6 +260,21 @@ function validatePreflightInput(args) {
 function validatePlanInput(args) {
     return validateRunInput(args);
 }
+function validateEstimateInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["objective", "engine", "budgetUsd", "fileScope", "workingDirectory"]);
+    const engine = optionalEnum(record.engine, "engine", MARTIN_ENGINE_VALUES);
+    const fileScope = normalizeSafePathPatterns(record.fileScope, "fileScope");
+    return {
+        objective: requireString(record.objective, "objective"),
+        ...(engine ? { engine } : {}),
+        ...optionalPositiveNumber(record.budgetUsd, "budgetUsd"),
+        ...(fileScope ? { fileScope } : {}),
+        ...(record.workingDirectory !== undefined
+            ? { workingDirectory: resolveSafeRepoRoot(requireString(record.workingDirectory, "workingDirectory")) }
+            : {})
+    };
+}
 function validateLogsInput(args) {
     const record = requireObject(args);
     assertAllowedKeys(record, ["file", "loopId", "runsDir", "latest", "limit"]);

package/dist/server.d.ts

@@ -16,6 +16,7 @@
  * Manual start:
  *   node dist/server.js
  */
+import { type Server as NodeHttpServer } from "node:http";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 export declare function createMartinMcpServer(serverInfo?: {
     name?: string;
@@ -88,4 +89,26 @@ export declare function connectMartinMcpStdioServer(): Promise<Server<{
         } | undefined;
     } | undefined;
 }>>;
+export interface MartinMcpHttpServerOptions {
+    host?: string;
+    port?: number;
+    path?: string;
+}
+export interface MartinMcpHttpServerHandle {
+    server: NodeHttpServer;
+    host: string;
+    port: number;
+    path: string;
+    endpoint: string;
+    close: () => Promise<void>;
+}
+export declare function parseMartinMcpServerArgs(argv: string[]): {
+    transport: "stdio";
+} | {
+    transport: "http";
+    host: string;
+    port: number;
+    path: string;
+};
+export declare function connectMartinMcpHttpServer(options?: MartinMcpHttpServerOptions): Promise<MartinMcpHttpServerHandle>;
 export declare function isDirectExecutionEntry(entryPath: string | undefined, moduleUrl?: string): boolean;

package/dist/server.js

@@ -16,12 +16,14 @@
  * Manual start:
  *   node dist/server.js
  */
+import { createServer as createHttpServer } from "node:http";
 import { fileURLToPath } from "node:url";
 import { realpathSync } from "node:fs";
 import path from "node:path";
 import { resolveRunsRoot } from "./vendor/core/index.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { MARTIN_MCP_PACKAGE_VERSION } from "./package-version.js";
 import { getMartinPrompt, listMartinPrompts } from "./prompts.js";
@@ -43,6 +45,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";
@@ -720,7 +723,7 @@ export function createMartinMcpServer(serverInfo) {
         tools: [
             {
                 name: "martin_run",
-                description: "Execute a governed Martin Loop run on a coding task and return the run summary, spend, artifact rollup, and verification state. This hard-blocks until martin_doctor, martin_plan, and martin_preflight receipts exist for the same task.",
+                description: "Execute a governed Martin Loop run on a coding task and return the run summary, spend, artifact rollup, and verification state. This hard-blocks until martin_doctor, martin_estimate, martin_plan, and martin_preflight receipts exist for the same task.",
                 annotations: {
                     destructiveHint: true,
                     idempotentHint: false,
@@ -1370,6 +1373,63 @@ 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."
+                        },
+                        workingDirectory: {
+                            type: "string",
+                            description: "Optional workspace path for recording the estimate receipt against the same task root you plan to run."
+                        }
+                    },
+                    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 +1640,55 @@ 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 = validateToolInput("martin_estimate", args);
+                const objective = input.objective;
+                const engine = input.engine ?? "claude";
+                const budgetUsd = input.budgetUsd ?? 5;
+                const fileScope = input.fileScope ?? [];
+                const runsRoot = resolveRunsRoot(process.env);
+                const workingDirectory = input.workingDirectory ?? resolveSafeRepoRoot();
+                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,
+                    recommendedModelTier: route.recommendedModelTier,
+                    estimatedSavingVsSonnetUsd: route.estimatedSavingVsSonnetUsd
+                };
+                await recordMcpWorkflowStep({
+                    runsRoot,
+                    step: "estimate",
+                    workingDirectory,
+                    objective,
+                    engine,
+                    receiptScope: {
+                        invocationRoot: resolveSafeRepoRoot(),
+                        workingDirectory,
+                        repoRoot: workingDirectory,
+                        runsRoot
+                    }
+                }).catch(() => { });
+                return createToolSuccessResult(output, `Estimate: ${route.selectedMode} route (${route.recommendedModelTier}), ~$${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) {
@@ -1601,6 +1710,114 @@ export async function connectMartinMcpStdioServer() {
     await server.connect(transport);
     return server;
 }
+export function parseMartinMcpServerArgs(argv) {
+    let transport = "stdio";
+    let host = "127.0.0.1";
+    let port = 3033;
+    let path = "/mcp";
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--http") {
+            transport = "http";
+            continue;
+        }
+        if (token === "--port") {
+            const next = argv[index + 1];
+            const parsed = Number(next);
+            if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+                throw new Error(`Invalid --port value '${next ?? ""}'.`);
+            }
+            port = parsed;
+            index += 1;
+            continue;
+        }
+        if (token === "--host") {
+            const next = argv[index + 1];
+            if (!next) {
+                throw new Error("Missing value for --host.");
+            }
+            host = next;
+            index += 1;
+            continue;
+        }
+        if (token === "--path") {
+            const next = argv[index + 1];
+            if (!next || !next.startsWith("/")) {
+                throw new Error("MCP HTTP path must start with '/'.");
+            }
+            path = next;
+            index += 1;
+        }
+    }
+    return transport === "http"
+        ? { transport, host, port, path }
+        : { transport };
+}
+export async function connectMartinMcpHttpServer(options = {}) {
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? 3033;
+    const path = options.path ?? "/mcp";
+    const mcpServer = createMartinMcpServer();
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined
+    });
+    await mcpServer.connect(transport);
+    const httpServer = createHttpServer(async (req, res) => {
+        try {
+            const requestUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? `${host}:${port}`}`);
+            if (requestUrl.pathname !== path) {
+                res.statusCode = 404;
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ error: "not_found", path: requestUrl.pathname }));
+                return;
+            }
+            if (req.method === "POST") {
+                const parsedBody = await readJsonBody(req, res);
+                if (res.writableEnded) {
+                    return;
+                }
+                await transport.handleRequest(req, res, parsedBody);
+                return;
+            }
+            if (req.method === "GET" || req.method === "DELETE") {
+                await transport.handleRequest(req, res);
+                return;
+            }
+            res.statusCode = 405;
+            res.setHeader("allow", "GET, POST, DELETE");
+            res.end();
+        }
+        catch (error) {
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ error: "internal_error", message: error.message }));
+            }
+        }
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.once("error", reject);
+        httpServer.listen(port, host, () => {
+            httpServer.off("error", reject);
+            resolve();
+        });
+    });
+    const address = httpServer.address();
+    const resolvedPort = typeof address === "object" && address ? address.port : port;
+    return {
+        server: httpServer,
+        host,
+        port: resolvedPort,
+        path,
+        endpoint: `http://${host}:${resolvedPort}${path}`,
+        close: async () => {
+            await transport.close();
+            await new Promise((resolve) => {
+                httpServer.close(() => resolve());
+            });
+        }
+    };
+}
 export function isDirectExecutionEntry(entryPath, moduleUrl = import.meta.url) {
     if (typeof entryPath !== "string" || entryPath.length === 0) {
         return false;
@@ -1621,5 +1838,30 @@ function realPathOrResolved(filePath) {
     }
 }
 if (isDirectExecution()) {
-    await connectMartinMcpStdioServer();
+    const startup = parseMartinMcpServerArgs(process.argv.slice(2));
+    if (startup.transport === "http") {
+        await connectMartinMcpHttpServer(startup);
+    }
+    else {
+        await connectMartinMcpStdioServer();
+    }
+}
+async function readJsonBody(req, res) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks).toString("utf8").trim();
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        res.statusCode = 400;
+        res.setHeader("content-type", "application/json");
+        res.end(JSON.stringify({ error: "invalid_json" }));
+        return undefined;
+    }
 }

package/dist/tools/doctor.js

@@ -113,6 +113,12 @@ export async function martinDoctorTool(input) {
                 available: gemini.available,
                 detail: gemini.detail,
                 ...(gemini.resolvedPath ? { resolvedPath: gemini.resolvedPath } : {})
+            },
+            openai: {
+                available: Boolean(process.env.MARTIN_OPENAI_API_KEY),
+                detail: process.env.MARTIN_OPENAI_API_KEY
+                    ? `OpenAI-compatible endpoint configured (model: ${process.env.MARTIN_OPENAI_MODEL ?? "gpt-4.1-mini"})`
+                    : "Set MARTIN_OPENAI_API_KEY and optionally MARTIN_OPENAI_BASE_URL + MARTIN_OPENAI_MODEL to enable."
             }
         },
         ...(input.engine ? { requestedEngine: input.engine } : {}),

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

@@ -1,6 +1,6 @@
 import type { LoopArtifact, LoopBudget, LoopCost, LoopEvent, LoopTask, ReceiptIntegritySummary, ReceiptScope } from "../vendor/contracts/index.js";
 import { type LedgerEvent, type LoopAttemptRecord, type LoopRunRecord } from "../vendor/core/index.js";
-export declare const MARTIN_ENGINE_VALUES: readonly ["claude", "codex", "gemini"];
+export declare const MARTIN_ENGINE_VALUES: readonly ["claude", "codex", "gemini", "openai"];
 export type MartinEngine = (typeof MARTIN_ENGINE_VALUES)[number];
 export interface InspectableLoopAttempt extends LoopAttemptRecord {
     attemptId?: string;
@@ -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

@@ -3,7 +3,7 @@ import { readdir, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { evaluateCostGovernor, resolveRunsRoot } from "../vendor/core/index.js";
 import { readAllLoopRecordsSafely } from "./run-store.js";
-export const MARTIN_ENGINE_VALUES = ["claude", "codex", "gemini"];
+export const MARTIN_ENGINE_VALUES = ["claude", "codex", "gemini", "openai"];
 const CLI_CACHE_TTL_MS = 60_000;
 const RUN_STORE_CACHE_TTL_MS = 5_000;
 const cliAvailabilityCache = new Map();
@@ -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.d.ts

@@ -11,14 +11,14 @@
  *
  * MCP tools and integration tests use the same factories.
  */
-import type { MartinAdapter } from "../core/index.js";
+import type { MartinAdapter, MartinAdapterRequest } from "../core/index.js";
 import { type SpawnLike } from "./cli-bridge.js";
 /**
  * Given a prompt string, returns the full argv array to pass to spawn().
  * Example for Claude:  () => ["--output-format", "json", "--print"]
  * Example for Codex:   () => ["exec", "--sandbox", "workspace-write", "-"]
  */
-export type CliArgsBuilder = (prompt: string) => string[];
+export type CliArgsBuilder = (prompt: string, request: MartinAdapterRequest) => string[];
 export type CliStdinBuilder = (prompt: string) => string | undefined;
 export interface AgentCliAdapterOptions {
     /** The executable to spawn (e.g. "claude", "codex"). */

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
@@ -239,13 +239,15 @@ function extractGeminiJsonResult(stdout, modelLabel) {
         })
     };
 }
-function createStreamingUsageInspector(capUsd, modelLabel) {
+function createStreamingUsageInspector(capUsd, modelLabel, promptTokenEstimate) {
     const pricing = (modelLabel ? MODEL_PRICING[modelLabel] : undefined) ??
         { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
     // Safety margin: terminate at 80% of cap to bound one-turn overshoot.
     // Without this, a single expensive turn can blow past the cap before the
     // next check fires (proven live: $1.50 cap → $28.42 actual).
-    const effectiveCapUsd = capUsd * 0.8;
+    const largeContext = promptTokenEstimate > 10_000;
+    const effectiveCapRatio = largeContext ? 0.7 : 0.8;
+    const effectiveCapUsd = capUsd * effectiveCapRatio;
     // Token-count ceiling fallback: if no usage events are ever parsed (e.g.
     // Claude changes its stream-json event format), use raw byte volume as a
     // last-resort circuit breaker. Derived from budget / blended cost per char.
@@ -253,6 +255,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,11 +266,12 @@ 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) {
             terminate(`Streaming usage cap exceeded after ${String(turns)} turn(s): cumulative cost ~$${cumulativeUsd.toFixed(4)} ` +
-                `surpassed the per-attempt cap $${capUsd.toFixed(4)} (80% threshold: $${effectiveCapUsd.toFixed(4)}). ` +
+                `surpassed the per-attempt cap $${capUsd.toFixed(4)} (${String(Math.round(effectiveCapRatio * 100))}% threshold: $${effectiveCapUsd.toFixed(4)}). ` +
                 `Subprocess terminated to bound runaway overspend.`);
         }
     };
@@ -295,11 +302,23 @@ function createStreamingUsageInspector(capUsd, modelLabel) {
         if (turnTokensIn === 0 && turnTokensOut === 0) {
             return;
         }
+        const turnUsd = (turnTokensIn / 1000) * pricing.inputPer1K + (turnTokensOut / 1000) * pricing.outputPer1K;
+        const remainingBudgetBeforeTurn = Math.max(capUsd - cumulativeUsd, 0);
+        if (capUsd > 0 && remainingBudgetBeforeTurn > 0 && turnUsd > remainingBudgetBeforeTurn * 0.5) {
+            cumulativeUsd += turnUsd;
+            tokensIn += turnTokensIn;
+            tokensOut += turnTokensOut;
+            turns += 1;
+            usageEventSeen = true;
+            terminate(`Single turn spend ~$${turnUsd.toFixed(4)} consumed more than 50% of the remaining per-attempt budget ` +
+                `($${remainingBudgetBeforeTurn.toFixed(4)} before the turn). Subprocess terminated to prevent a one-turn overshoot.`);
+            return;
+        }
         tokensIn += turnTokensIn;
         tokensOut += turnTokensOut;
         turns += 1;
         usageEventSeen = true;
-        cumulativeUsd += (turnTokensIn / 1000) * pricing.inputPer1K + (turnTokensOut / 1000) * pricing.outputPer1K;
+        cumulativeUsd += turnUsd;
         checkBudgetExceeded(terminate);
     };
     const ingestLine = (line, terminate) => {
@@ -324,6 +343,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 +353,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);
@@ -440,7 +477,7 @@ export function createAgentCliAdapter(options) {
                     };
                 }
             }
-            const args = options.argsBuilder(prompt);
+            const args = options.argsBuilder(prompt, request);
             const stdinData = options.stdinBuilder?.(prompt);
             // Live cumulative-cost circuit breaker: a single attempt should never be
             // allowed to spend more than the loop has left. `--output-format json`
@@ -449,7 +486,7 @@ export function createAgentCliAdapter(options) {
             // instant projected spend crosses what remains — bounding the worst case
             // to roughly one turn's overshoot rather than the entire runaway session.
             const streamingUsage = options.streamingUsageCap && request.context.remainingBudgetUsd > 0
-                ? createStreamingUsageInspector(request.context.remainingBudgetUsd, options.model ?? options.command)
+                ? createStreamingUsageInspector(request.context.remainingBudgetUsd, options.model ?? options.command, estimatedUsage.tokensIn)
                 : undefined;
             const agentResult = await runSubprocess(options.command, args, {
                 cwd: workingDirectory,
@@ -767,12 +804,18 @@ export function createClaudeCliAdapter(options = {}) {
         supportsJsonOutput: true,
         streamingUsageCap: true,
         spawnImpl: options.spawnImpl,
-        argsBuilder: (_prompt) => [
+        argsBuilder: (_prompt, request) => [
             "--output-format",
             "stream-json",
             "--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",
+            ...(request.context.remainingTokens > 0 ? ["--max-tokens", String(request.context.remainingTokens)] : []),
             ...modelArgs,
             ...extraArgs
         ],
@@ -797,6 +840,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 +854,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,12 +71,29 @@ 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;
     args: string[];
 }
 export declare function createSpawnPlan(command: string, args: string[], cwd: string, preserveRawForInjectedSpawn: boolean): SpawnPlan;
+/**
+ * npm generates Windows shims (.cmd/.ps1, occasionally .bat) that ultimately just exec
+ * `node <real-cli-script>.js <args>` relative to the shim's own directory. Parse the shim text to
+ * find that real script path and return it if it resolves to a file that actually exists on disk;
+ * otherwise return undefined so callers fall back to the existing wrapper-shell behavior unchanged.
+ */
+export declare function resolveNpmShimScript(shimPath: string): string | undefined;
 /**
  * Returns true if the command string contains shell operators that cannot be
  * passed as literal arguments to spawn(). These must be routed through a