@martinloop/mcp 0.2.5 → 0.3.0

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

@@ -0,0 +1,247 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, extname, resolve } from "node:path";
+function isInsideGitRepository(workingDirectory) {
+    let current = resolve(workingDirectory);
+    while (true) {
+        if (existsSync(resolve(current, ".git"))) {
+            return true;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return false;
+        }
+        current = parent;
+    }
+}
+function selectResolvedPath(candidates, platform) {
+    const cleaned = candidates
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (cleaned.length === 0) {
+        return undefined;
+    }
+    if (platform !== "win32") {
+        return cleaned[0];
+    }
+    const preference = (candidate) => {
+        switch (extname(candidate).toLowerCase()) {
+            case ".cmd":
+                return 0;
+            case ".bat":
+                return 1;
+            case ".ps1":
+                return 2;
+            case ".exe":
+                return 3;
+            case "":
+                return 4;
+            default:
+                return 5;
+        }
+    };
+    const [firstCandidate, ...remainingCandidates] = cleaned;
+    if (firstCandidate === undefined) {
+        return undefined;
+    }
+    let bestCandidate = firstCandidate;
+    let bestPreference = preference(bestCandidate);
+    for (const candidate of remainingCandidates) {
+        const candidatePreference = preference(candidate);
+        if (candidatePreference < bestPreference) {
+            bestCandidate = candidate;
+            bestPreference = candidatePreference;
+        }
+    }
+    return bestCandidate;
+}
+function buildProbeCommand(command, args, platform) {
+    if (platform !== "win32") {
+        return { command, args };
+    }
+    const extension = extname(command).toLowerCase();
+    switch (extension) {
+        case ".cmd":
+        case ".bat":
+            return {
+                command: process.env.ComSpec || "cmd.exe",
+                args: ["/d", "/c", command, ...args]
+            };
+        case ".ps1":
+            return {
+                command: "powershell.exe",
+                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", command, ...args]
+            };
+        default:
+            return { command, args };
+    }
+}
+export function resolveCliCommandAvailability(command, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
+    const locator = platform === "win32" ? "where.exe" : "which";
+    const result = spawnSyncImpl(locator, [command], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    const resolvedPath = result.status === 0
+        ? selectResolvedPath((result.stdout ?? "").split(/\r?\n/u), platform)
+        : undefined;
+    return result.status === 0
+        ? {
+            command,
+            available: true,
+            locator,
+            detail: `${command} is available on PATH.`,
+            ...(resolvedPath ? { resolvedPath } : {})
+        }
+        : {
+            command,
+            available: false,
+            locator,
+            detail: `${command} is not available on PATH.`
+        };
+}
+export function detectCodexHostPlatform(env = process.env, platform = process.platform) {
+    if (platform === "win32") {
+        return "windows";
+    }
+    if (platform === "darwin") {
+        return "macos";
+    }
+    if (env["WSL_DISTRO_NAME"] || env["WSL_INTEROP"]) {
+        return "wsl";
+    }
+    return "linux";
+}
+export function diagnoseCodexHost(availability, options = {}) {
+    const hostPlatform = detectCodexHostPlatform(options.env ?? process.env, options.platform ?? process.platform);
+    const warnings = [];
+    if (!availability.available) {
+        return {
+            hostPlatform,
+            nativeInstallValid: false,
+            warnings,
+            remediation: "Install or expose the Codex CLI on PATH before running governed Codex work."
+        };
+    }
+    const resolvedPath = availability.resolvedPath?.replace(/\\/gu, "/").toLowerCase() ?? "";
+    const looksWindowsShim = resolvedPath.endsWith(".cmd") ||
+        resolvedPath.endsWith(".bat") ||
+        resolvedPath.endsWith(".ps1") ||
+        resolvedPath.includes("/appdata/roaming/npm/");
+    const looksMountedWindowsPath = resolvedPath.startsWith("/mnt/c/");
+    if ((hostPlatform === "linux" || hostPlatform === "wsl") && (looksWindowsShim || looksMountedWindowsPath)) {
+        warnings.push("Codex resolves to a Windows-hosted install from a Linux/WSL environment.");
+        return {
+            hostPlatform,
+            nativeInstallValid: false,
+            warnings,
+            remediation: "Install Codex natively inside this Linux/WSL environment instead of relying on a Windows PATH shim."
+        };
+    }
+    return {
+        hostPlatform,
+        nativeInstallValid: true,
+        warnings
+    };
+}
+export function probeCodexLaunch(input) {
+    const availability = input.availability ??
+        resolveCliCommandAvailability("codex", {
+            platform: input.platform,
+            spawnSyncImpl: input.spawnSyncImpl
+        });
+    const diagnosis = diagnoseCodexHost(availability, {
+        env: input.env,
+        platform: input.platform
+    });
+    const args = [
+        "exec",
+        "--cd",
+        input.workingDirectory,
+        "--sandbox",
+        "workspace-write",
+        "--json",
+        "--color",
+        "never",
+        "--help"
+    ];
+    if (!availability.available) {
+        return {
+            ok: false,
+            summary: availability.detail,
+            availability,
+            diagnosis,
+            command: availability.command,
+            args
+        };
+    }
+    if (!diagnosis.nativeInstallValid) {
+        return {
+            ok: false,
+            summary: diagnosis.remediation ?? "Codex host installation is not valid for this environment.",
+            availability,
+            diagnosis,
+            command: availability.resolvedPath ?? availability.command,
+            args
+        };
+    }
+    if (!isInsideGitRepository(input.workingDirectory)) {
+        return {
+            ok: false,
+            summary: "Working directory is not inside a git repository. Codex exec requires a trusted repo unless --skip-git-repo-check is explicitly enabled.",
+            availability,
+            diagnosis,
+            command: availability.resolvedPath ?? availability.command,
+            args
+        };
+    }
+    const spawnSyncImpl = input.spawnSyncImpl ?? spawnSync;
+    const platform = input.platform ?? process.platform;
+    const spawnPlan = buildProbeCommand(availability.resolvedPath ?? availability.command, args, platform);
+    const result = spawnSyncImpl(spawnPlan.command, spawnPlan.args, {
+        cwd: input.workingDirectory,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.error) {
+        return {
+            ok: false,
+            summary: `Codex launch probe failed: ${result.error.message}`,
+            availability,
+            diagnosis,
+            command: availability.resolvedPath ?? availability.command,
+            args,
+            stderr: result.stderr ?? "",
+            stdout: result.stdout ?? ""
+        };
+    }
+    if (result.status !== 0) {
+        const stderr = (result.stderr ?? "").trim();
+        return {
+            ok: false,
+            summary: stderr.length > 0
+                ? `Codex launch probe failed: ${stderr}`
+                : "Codex launch probe exited non-zero.",
+            availability,
+            diagnosis,
+            command: availability.resolvedPath ?? availability.command,
+            args,
+            exitCode: result.status ?? undefined,
+            stderr: result.stderr ?? "",
+            stdout: result.stdout ?? ""
+        };
+    }
+    return {
+        ok: true,
+        summary: "Codex exec launch probe passed for the current MartinLoop invocation shape.",
+        availability,
+        diagnosis,
+        command: availability.resolvedPath ?? availability.command,
+        args,
+        exitCode: result.status ?? undefined,
+        stderr: result.stderr ?? "",
+        stdout: result.stdout ?? ""
+    };
+}

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

@@ -1,6 +1,8 @@
 export { createDirectProviderAdapter, type DirectProviderAdapterOptions } from "./direct-provider.js";
 export { createStubDirectProviderAdapter, type StubDirectProviderAdapterOptions } from "./stub-direct-provider.js";
 export { createStubAgentCliAdapter, type StubAgentCliAdapterOptions } from "./stub-agent-cli.js";
-export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type CodexCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
+export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type CodexCliAdapterOptions, type GeminiCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
 export { createVerifierOnlyAdapter, type VerifierOnlyAdapterOptions } from "./verifier-only.js";
-export type { SpawnLike, SubprocessResult, VerificationOutcome } from "./cli-bridge.js";
+export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig, type OpenAiCompatibleAdapterOptions } from "./openai-compatible.js";
+export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability, type CliCommandAvailability, type CodexHostDiagnosis, type CodexHostPlatform, type CodexLaunchProbeResult } from "./codex-launcher.js";
+export { createSpawnPlan, type SpawnLike, type SpawnPlan, type SubprocessResult, type VerificationOutcome } from "./cli-bridge.js";

package/dist/vendor/adapters/index.js

@@ -1,5 +1,8 @@
 export { createDirectProviderAdapter } from "./direct-provider.js";
 export { createStubDirectProviderAdapter } from "./stub-direct-provider.js";
 export { createStubAgentCliAdapter } from "./stub-agent-cli.js";
-export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter } from "./claude-cli.js";
+export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter } from "./claude-cli.js";
 export { createVerifierOnlyAdapter } from "./verifier-only.js";
+export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig } from "./openai-compatible.js";
+export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability } from "./codex-launcher.js";
+export { createSpawnPlan } from "./cli-bridge.js";

package/dist/vendor/adapters/openai-compatible.d.ts

@@ -0,0 +1,62 @@
+/**
+ * OpenAI-compatible adapter for MartinLoop.
+ *
+ * Routes agent execution to any endpoint that implements the OpenAI
+ * Chat Completions API (`POST /v1/chat/completions`). This covers:
+ *
+ * Hosted via OpenRouter / Together.ai / Fireworks.ai:
+ *   DeepSeek-V3, DeepSeek-R1, Qwen3-235B, Mistral Large, Codestral,
+ *   Kimi k2, Nemotron-70B, and hundreds more.
+ *
+ * Local via Ollama / LM Studio / llama.cpp:
+ *   Llama 3.x, Mistral 7B, Phi-4, Gemma 3, any GGUF model.
+ *
+ * Usage:
+ *   # Defaults to OpenAI's hosted endpoint when MARTIN_OPENAI_BASE_URL is unset.
+ *   MARTIN_OPENAI_API_KEY=sk-...
+ *   MARTIN_OPENAI_MODEL=gpt-4.1-mini
+ *   martin-loop run "fix the bug" --engine openai
+ *
+ *   # Or route to a third-party / self-hosted OpenAI-compatible endpoint:
+ *   MARTIN_OPENAI_BASE_URL=https://openrouter.ai/api
+ *   MARTIN_OPENAI_API_KEY=sk-or-...
+ *   MARTIN_OPENAI_MODEL=deepseek/deepseek-chat
+ *   martin-loop run "fix the bug" --engine openai
+ *
+ * Or for Ollama:
+ *   MARTIN_OPENAI_BASE_URL=http://localhost:11434
+ *   MARTIN_OPENAI_MODEL=llama3.3
+ *   martin-loop run "fix the bug" --engine openai
+ */
+import type { MartinAdapter } from "../core/index.js";
+export interface OpenAiCompatibleAdapterOptions {
+    /** Base URL of the OpenAI-compatible API. No trailing slash. */
+    baseUrl?: string;
+    /** API key. Empty string for local (Ollama/LM Studio) endpoints. */
+    apiKey?: string;
+    /** Model identifier passed as-is to the API (e.g. "deepseek/deepseek-chat"). */
+    model?: string;
+    /**
+     * System prompt prepended before the MartinLoop task prompt.
+     * Default instructs the model to act as a focused coding assistant.
+     */
+    systemPrompt?: string;
+    /** Request timeout in milliseconds. Default: 300_000 (5 min). */
+    timeoutMs?: number;
+    /** Verifier timeout in milliseconds. Default: 60_000. */
+    verifyTimeoutMs?: number;
+    /** Working directory for git artifact collection and verification. */
+    workingDirectory?: string;
+    /** Optional fetch override for testing. */
+    fetchImpl?: typeof fetch;
+}
+export declare const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com";
+export declare const DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";
+export declare function resolveOpenAiCompatibleRuntimeConfig(env?: NodeJS.ProcessEnv): {
+    baseUrl: string;
+    model: string;
+    apiKey: string;
+    apiKeyConfigured: boolean;
+    authPosture: "api_key" | "anonymous_or_local";
+};
+export declare function createOpenAiCompatibleAdapter(options: OpenAiCompatibleAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/openai-compatible.js

@@ -0,0 +1,267 @@
+/**
+ * OpenAI-compatible adapter for MartinLoop.
+ *
+ * Routes agent execution to any endpoint that implements the OpenAI
+ * Chat Completions API (`POST /v1/chat/completions`). This covers:
+ *
+ * Hosted via OpenRouter / Together.ai / Fireworks.ai:
+ *   DeepSeek-V3, DeepSeek-R1, Qwen3-235B, Mistral Large, Codestral,
+ *   Kimi k2, Nemotron-70B, and hundreds more.
+ *
+ * Local via Ollama / LM Studio / llama.cpp:
+ *   Llama 3.x, Mistral 7B, Phi-4, Gemma 3, any GGUF model.
+ *
+ * Usage:
+ *   # Defaults to OpenAI's hosted endpoint when MARTIN_OPENAI_BASE_URL is unset.
+ *   MARTIN_OPENAI_API_KEY=sk-...
+ *   MARTIN_OPENAI_MODEL=gpt-4.1-mini
+ *   martin-loop run "fix the bug" --engine openai
+ *
+ *   # Or route to a third-party / self-hosted OpenAI-compatible endpoint:
+ *   MARTIN_OPENAI_BASE_URL=https://openrouter.ai/api
+ *   MARTIN_OPENAI_API_KEY=sk-or-...
+ *   MARTIN_OPENAI_MODEL=deepseek/deepseek-chat
+ *   martin-loop run "fix the bug" --engine openai
+ *
+ * Or for Ollama:
+ *   MARTIN_OPENAI_BASE_URL=http://localhost:11434
+ *   MARTIN_OPENAI_MODEL=llama3.3
+ *   martin-loop run "fix the bug" --engine openai
+ */
+import { readGitChangedFiles, runVerification } from "./cli-bridge.js";
+import { createAdapterCapabilities, normalizeUsage } from "./runtime-support.js";
+// ---------------------------------------------------------------------------
+// OpenRouter/OpenAI-compatible model pricing ($/1K tokens)
+// Automatically used when baseUrl contains openrouter.ai or known providers.
+// Defaults to a conservative blended estimate for unknown models.
+// ---------------------------------------------------------------------------
+const KNOWN_MODEL_PRICING = {
+    // DeepSeek
+    "deepseek/deepseek-chat": { inputPer1K: 0.00027, outputPer1K: 0.0011 },
+    "deepseek/deepseek-r1": { inputPer1K: 0.0008, outputPer1K: 0.0032 },
+    "deepseek/deepseek-coder": { inputPer1K: 0.00014, outputPer1K: 0.00028 },
+    // Qwen
+    "qwen/qwen3-235b-a22b": { inputPer1K: 0.00022, outputPer1K: 0.00088 },
+    "qwen/qwen3-32b": { inputPer1K: 0.00009, outputPer1K: 0.00009 },
+    "qwen/qwen-2.5-coder-32b-instruct": { inputPer1K: 0.00007, outputPer1K: 0.00007 },
+    // Mistral
+    "mistralai/codestral-latest": { inputPer1K: 0.0003, outputPer1K: 0.0009 },
+    "mistralai/mistral-large": { inputPer1K: 0.003, outputPer1K: 0.009 },
+    "mistralai/mistral-small": { inputPer1K: 0.0001, outputPer1K: 0.0003 },
+    // Kimi
+    "moonshotai/kimi-k2": { inputPer1K: 0.00065, outputPer1K: 0.0026 },
+    // Nemotron
+    "nvidia/llama-3.1-nemotron-70b-instruct": { inputPer1K: 0.00012, outputPer1K: 0.0003 },
+    // Llama (via OpenRouter)
+    "meta-llama/llama-3.3-70b-instruct": { inputPer1K: 0.00012, outputPer1K: 0.0003 },
+    "meta-llama/llama-3.1-405b-instruct": { inputPer1K: 0.0008, outputPer1K: 0.0008 },
+};
+const FALLBACK_INPUT_PER_1K = 0.0003;
+const FALLBACK_OUTPUT_PER_1K = 0.0012;
+const CHARS_PER_TOKEN = 4;
+function estimateCost(model, inputChars, outputChars) {
+    const pricing = KNOWN_MODEL_PRICING[model] ?? {
+        inputPer1K: FALLBACK_INPUT_PER_1K,
+        outputPer1K: FALLBACK_OUTPUT_PER_1K
+    };
+    const tokensIn = Math.ceil(inputChars / CHARS_PER_TOKEN);
+    const tokensOut = Math.ceil(outputChars / CHARS_PER_TOKEN);
+    const actualUsd = (tokensIn / 1000) * pricing.inputPer1K + (tokensOut / 1000) * pricing.outputPer1K;
+    return { tokensIn, tokensOut, actualUsd };
+}
+// ---------------------------------------------------------------------------
+// Prompt builder
+// ---------------------------------------------------------------------------
+const DEFAULT_SYSTEM_PROMPT = `You are an expert software engineer executing a governed coding task.
+Follow these rules exactly:
+- Read the task description carefully and implement only what is asked.
+- Do not add features, refactors, or improvements beyond the stated task.
+- If the task asks you to write or modify code, output the complete file content with changes applied.
+- Be precise, minimal, and test-backed in all changes.
+- State what you changed and why at the end of your response.`;
+export const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com";
+export const DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";
+export function resolveOpenAiCompatibleRuntimeConfig(env = process.env) {
+    const apiKey = env["MARTIN_OPENAI_API_KEY"] ?? "";
+    return {
+        baseUrl: env["MARTIN_OPENAI_BASE_URL"] ?? DEFAULT_OPENAI_BASE_URL,
+        model: env["MARTIN_OPENAI_MODEL"] ?? DEFAULT_OPENAI_MODEL,
+        apiKey,
+        apiKeyConfigured: apiKey.length > 0,
+        authPosture: apiKey.length > 0 ? "api_key" : "anonymous_or_local"
+    };
+}
+function buildPrompt(request) {
+    const lines = [
+        `TASK: ${request.context.taskTitle}`,
+        ``,
+        `OBJECTIVE:`,
+        request.context.objective,
+        ``
+    ];
+    if (request.context.focus) {
+        lines.push(`FOCUS: ${request.context.focus}`, ``);
+    }
+    if (request.context.verificationPlan.length > 0) {
+        lines.push(`VERIFICATION COMMANDS (must pass after your changes):`, ...request.context.verificationPlan.map((cmd) => `  ${cmd}`), ``);
+    }
+    if (request.previousAttempts.length > 0) {
+        const last = request.previousAttempts.at(-1);
+        if (last) {
+            lines.push(`PREVIOUS ATTEMPT SUMMARY:`, last.summary ?? "", ``);
+        }
+    }
+    lines.push(`BUDGET REMAINING: $${request.context.remainingBudgetUsd.toFixed(4)} | Iterations left: ${request.context.remainingIterations}`);
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export function createOpenAiCompatibleAdapter(options) {
+    const workingDirectory = options.workingDirectory ?? process.cwd();
+    const timeoutMs = options.timeoutMs ?? 300_000;
+    const verifyTimeoutMs = options.verifyTimeoutMs ?? 60_000;
+    const systemPrompt = options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    const fetchFn = options.fetchImpl ?? globalThis.fetch;
+    const runtimeConfig = resolveOpenAiCompatibleRuntimeConfig();
+    const baseUrl = (options.baseUrl ?? runtimeConfig.baseUrl).replace(/\/$/, "");
+    const model = options.model ?? runtimeConfig.model;
+    const apiKey = options.apiKey ?? runtimeConfig.apiKey;
+    return {
+        adapterId: `openai-compatible:${model}`,
+        kind: "direct-provider",
+        label: `OpenAI-compatible: ${model}`,
+        metadata: {
+            providerId: "openai-compatible",
+            model,
+            transport: "http",
+            capabilities: createAdapterCapabilities({
+                preflight: true,
+                usageSettlement: true,
+                diffArtifacts: true
+            })
+        },
+        async execute(request) {
+            const prompt = buildPrompt(request);
+            const estimated = estimateCost(model, prompt.length, 2000);
+            const baselineChangedFiles = new Set(await readGitChangedFiles(workingDirectory, 5_000));
+            // Preflight: bail if projected cost exceeds remaining budget
+            if (request.context.remainingBudgetUsd > 0 &&
+                estimated.actualUsd > request.context.remainingBudgetUsd * 0.95) {
+                return {
+                    status: "failed",
+                    summary: `Preflight: projected cost $${estimated.actualUsd.toFixed(4)} exceeds remaining budget $${request.context.remainingBudgetUsd.toFixed(4)}.`,
+                    usage: normalizeUsage({
+                        actualUsd: estimated.actualUsd,
+                        estimatedUsd: estimated.actualUsd,
+                        tokensIn: estimated.tokensIn,
+                        tokensOut: estimated.tokensOut,
+                        provenance: "estimated"
+                    }),
+                    verification: { passed: false, summary: "Stopped before execution: budget preflight failed." },
+                    failure: { message: "budget_preflight_exceeded", classHint: "budget_pressure" }
+                };
+            }
+            // Call the OpenAI-compatible endpoint
+            const endpoint = `${baseUrl}/v1/chat/completions`;
+            let responseText = "";
+            let tokensIn = estimated.tokensIn;
+            let tokensOut = 0;
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const headers = { "Content-Type": "application/json" };
+                if (apiKey)
+                    headers["Authorization"] = `Bearer ${apiKey}`;
+                // OpenRouter requires a site URL header for attribution
+                if (baseUrl.includes("openrouter")) {
+                    headers["HTTP-Referer"] = "https://martinloop.com";
+                    headers["X-Title"] = "MartinLoop";
+                }
+                const res = await fetchFn(endpoint, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify({
+                        model,
+                        messages: [
+                            { role: "system", content: systemPrompt },
+                            { role: "user", content: prompt }
+                        ],
+                        temperature: 0.2,
+                        max_tokens: 8192
+                    }),
+                    signal: controller.signal
+                });
+                const body = (await res.json());
+                if (!res.ok || body.error) {
+                    const errMsg = body.error?.message ?? `HTTP ${res.status}`;
+                    return {
+                        status: "failed",
+                        summary: `${model} API error: ${errMsg}`,
+                        usage: normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
+                        verification: { passed: false, summary: "API call failed before verifier." },
+                        failure: { message: errMsg, classHint: "infrastructure_error" }
+                    };
+                }
+                responseText = body.choices?.[0]?.message?.content ?? "";
+                if (body.usage) {
+                    tokensIn = body.usage.prompt_tokens ?? tokensIn;
+                    tokensOut = body.usage.completion_tokens ?? 0;
+                }
+                else {
+                    tokensOut = Math.ceil(responseText.length / CHARS_PER_TOKEN);
+                }
+            }
+            catch (error) {
+                const isAbort = error instanceof Error && error.name === "AbortError";
+                const message = isAbort ? `${model} request timed out after ${timeoutMs}ms` : String(error);
+                return {
+                    status: "failed",
+                    summary: message,
+                    usage: normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
+                    verification: { passed: false, summary: isAbort ? "Request timed out." : "Network error." },
+                    failure: { message, classHint: "infrastructure_error" }
+                };
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!responseText.trim()) {
+                return {
+                    status: "failed",
+                    summary: `${model} returned an empty response.`,
+                    usage: normalizeUsage({ actualUsd: 0, tokensIn, tokensOut: 0, provenance: "actual" }),
+                    verification: { passed: false, summary: "Empty response — nothing to verify." },
+                    failure: { message: "empty_response" }
+                };
+            }
+            // Run verification
+            const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack);
+            const execution = {
+                changedFiles: (await readGitChangedFiles(workingDirectory, 5_000)).filter((file) => !baselineChangedFiles.has(file))
+            };
+            const pricing = KNOWN_MODEL_PRICING[model] ?? {
+                inputPer1K: FALLBACK_INPUT_PER_1K,
+                outputPer1K: FALLBACK_OUTPUT_PER_1K
+            };
+            const actualUsd = (tokensIn / 1000) * pricing.inputPer1K + (tokensOut / 1000) * pricing.outputPer1K;
+            return {
+                status: verification.passed ? "completed" : "failed",
+                summary: verification.passed
+                    ? `${model} completed the task. Verifier passed.`
+                    : `${model} completed but verifier failed: ${verification.summary}`,
+                usage: normalizeUsage({
+                    actualUsd,
+                    tokensIn,
+                    tokensOut,
+                    provenance: "actual"
+                }),
+                verification,
+                execution,
+                ...(verification.passed ? {} : {
+                    failure: { message: verification.summary }
+                })
+            };
+        }
+    };
+}

package/dist/vendor/adapters/runtime-support.d.ts

@@ -7,7 +7,10 @@ export declare function normalizeUsage(input: {
     estimatedUsd?: number;
     tokensIn?: number;
     tokensOut?: number;
+    cachedInputTokens?: number;
+    reasoningTokensOut?: number;
     provenance?: MartinAdapterResult["usage"]["provenance"];
+    providerSettlement?: MartinAdapterResult["usage"]["providerSettlement"];
 }): MartinAdapterResult["usage"];
 export declare function diffStatsFromNumstat(stdout: string): DiffStats | undefined;
 export declare function normalizeStructuredErrors(errors: StructuredError[] | undefined): StructuredError[];

package/dist/vendor/adapters/runtime-support.js

@@ -21,7 +21,14 @@ export function normalizeUsage(input) {
             : {}),
         tokensIn: input.tokensIn ?? 0,
         tokensOut: input.tokensOut ?? 0,
-        provenance
+        ...(input.cachedInputTokens !== undefined
+            ? { cachedInputTokens: input.cachedInputTokens }
+            : {}),
+        ...(input.reasoningTokensOut !== undefined
+            ? { reasoningTokensOut: input.reasoningTokensOut }
+            : {}),
+        provenance,
+        ...(input.providerSettlement ? { providerSettlement: input.providerSettlement } : {})
     };
 }
 export function diffStatsFromNumstat(stdout) {

package/dist/vendor/adapters/verifier-only.js

@@ -1,4 +1,4 @@
-import { readGitExecutionArtifacts, runVerification } from "./cli-bridge.js";
+import { readGitChangedFiles, runVerification } from "./cli-bridge.js";
 import { createAdapterCapabilities, normalizeUsage } from "./runtime-support.js";
 export function createVerifierOnlyAdapter(options = {}) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
@@ -17,9 +17,10 @@ export function createVerifierOnlyAdapter(options = {}) {
             })
         },
         async execute(request) {
+            const baselineChangedFiles = new Set(await readGitChangedFiles(workingDirectory, 5_000));
             const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack);
-            const execution = await readGitExecutionArtifacts(workingDirectory, 5_000);
-            const changedFiles = execution.changedFiles ?? [];
+            const changedFiles = (await readGitChangedFiles(workingDirectory, 5_000)).filter((file) => !baselineChangedFiles.has(file));
+            const execution = { changedFiles };
             if (verification.passed) {
                 return {
                     status: "completed",