@martinloop/mcp 0.3.8 → 0.5.0

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

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { delimiter, dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { basename, delimiter, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { diffStatsFromNumstat } from "./runtime-support.js";
 const gitRepositoryRootCache = new Map();
@@ -32,7 +32,7 @@ export async function runSubprocess(command, args, options) {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            resolveOnce({ exitCode: 1, stdout: "", stderr: message, launched: false });
+            resolveOnce({ exitCode: 1, stdout: "", stderr: message, launched: false, completed: false, crashed: true });
             return;
         }
         const trackOutput = (chunks, chunk) => {
@@ -53,6 +53,18 @@ export async function runSubprocess(command, args, options) {
             terminationReason = reason;
             proc.kill("SIGTERM");
         };
+        // Honour the harness abort signal — kill the subprocess immediately
+        if (options.signal !== undefined) {
+            const sig = options.signal;
+            if (sig.aborted) {
+                proc.kill("SIGTERM");
+            }
+            else {
+                const onAbort = () => { proc.kill("SIGTERM"); };
+                sig.addEventListener("abort", onAbort, { once: true });
+                proc.on("close", () => { sig.removeEventListener("abort", onAbort); });
+            }
+        }
         proc.stdout?.on("data", (chunk) => {
             if (outputCapped || timedOut || terminationReason) {
                 return;
@@ -93,15 +105,18 @@ export async function runSubprocess(command, args, options) {
         });
         proc.on("error", (error) => {
             clearTimeout(timer);
-            resolveOnce({ exitCode: 1, stdout: "", stderr: error.message, launched: false });
+            resolveOnce({ exitCode: 1, stdout: "", stderr: error.message, launched: false, completed: false, crashed: true });
         });
         proc.on("close", (code) => {
             clearTimeout(timer);
+            const completed = code !== null && !timedOut && !outputCapped && !terminationReason;
             resolveOnce({
                 exitCode: code ?? 1,
                 stdout: Buffer.concat(stdoutChunks).toString("utf8"),
                 stderr: Buffer.concat(stderrChunks).toString("utf8"),
-                launched: true
+                launched: true,
+                completed,
+                crashed: !completed && !timedOut && !outputCapped && !terminationReason,
             });
         });
         if (options.stdinData !== undefined && proc.stdin) {
@@ -116,22 +131,30 @@ export async function runSubprocess(command, args, options) {
                         exitCode: 1,
                         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
                         stderr: stdinError.message,
-                        launched: false
+                        launched: false,
+                        completed: false,
+                        crashed: true,
                     });
                 }
             }
         }
     });
 }
-export async function runVerification(commands, cwd, timeoutMs, verificationStack, spawnImpl) {
+export async function runVerification(commands, cwd, timeoutMs, verificationStack, spawnImpl, binding) {
     const steps = verificationStack && verificationStack.length > 0
         ? verificationStack.map((step) => ({
             command: step.command,
             fastFail: step.fastFail !== false
         }))
         : commands.map((command) => ({ command, fastFail: true }));
+    const executionBinding = {
+        runId: binding?.runId ?? "unbound",
+        workspaceId: binding?.workspaceId ?? "unbound",
+        cwd: binding?.cwd ?? cwd,
+        commands: steps.map((step) => step.command),
+    };
     if (steps.length === 0) {
-        return { passed: true, summary: "No verification commands specified.", steps: [] };
+        return { passed: true, summary: "No verification commands specified.", steps: [], binding: executionBinding };
     }
     const failedSteps = [];
     const stepOutcomes = [];
@@ -169,6 +192,8 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
         stepOutcomes.push({
             command: step.command,
             launched: result.launched,
+            completed: result.completed,
+            crashed: result.crashed,
             exitCode: result.exitCode,
             timedOut: result.timedOut,
             fastFail: step.fastFail,
@@ -179,6 +204,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
                 passed: false,
                 summary: `Verification timed out: ${step.command}`,
                 steps: stepOutcomes,
+                binding: executionBinding,
                 ...(warnings.length ? { warnings } : {})
             };
         }
@@ -188,7 +214,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
                 warnings.push(`Verifier never launched: ${step.command}`);
             }
             if (step.fastFail) {
-                return { passed: false, summary, steps: stepOutcomes, ...(warnings.length ? { warnings } : {}) };
+                return { passed: false, summary, steps: stepOutcomes, binding: executionBinding, ...(warnings.length ? { warnings } : {}) };
             }
             failedSteps.push(step.command);
         }
@@ -198,6 +224,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
             passed: false,
             summary: `Failed steps: ${failedSteps.join(", ")}`,
             steps: stepOutcomes,
+            binding: executionBinding,
             ...(warnings.length ? { warnings } : {})
         };
     }
@@ -205,6 +232,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
         passed: true,
         summary: `All ${String(steps.length)} verification step(s) passed.`,
         steps: stepOutcomes,
+        binding: executionBinding,
         ...(warnings.length ? { warnings } : {})
     };
 }
@@ -365,19 +393,32 @@ export function resolveNpmShimScript(shimPath) {
     }
     const shimDir = dirname(shimPath);
     const scriptPathPattern = /["']?(?:%~?dp0%?|\$basedir)[\\/]([^"'\s]+\.[cm]?js)["']?/gi;
-    const matches = contents.matchAll(scriptPathPattern);
+    const matches = [...contents.matchAll(scriptPathPattern)];
+    // Collect all candidate scripts that exist on disk.
+    const candidates = [];
     for (const match of matches) {
         const relativeScript = match[1];
-        if (!relativeScript) {
+        if (!relativeScript)
             continue;
-        }
         const segments = relativeScript.split(/[\\/]+/u).filter(Boolean);
         const resolvedScript = resolve(shimDir, ...segments);
         if (existsSync(resolvedScript)) {
-            return resolvedScript;
+            candidates.push(resolvedScript);
         }
     }
-    return undefined;
+    if (candidates.length === 0)
+        return undefined;
+    // npm.cmd / npm.ps1 / npm.bat shims reference both npm-prefix.js and npm-cli.js.
+    // npm-cli.js is the semantic npm CLI entry point — never pick npm-prefix.js for
+    // these. Fail closed: if npm-cli.js is not among the resolved candidates, return
+    // undefined so the caller falls back to wrapper-shell behavior.
+    const shimBasename = basename(shimPath).toLowerCase();
+    if (/^npm(\.(cmd|ps1|bat))?$/.test(shimBasename)) {
+        return candidates.find((p) => basename(p).toLowerCase() === "npm-cli.js");
+    }
+    // For all other npm-installed executables (codex.cmd, claude.ps1, etc.), the
+    // shim wraps exactly one package bin target — use the first resolving candidate.
+    return candidates[0];
 }
 /**
  * Resolve a reliable `node` executable for spawning CLI scripts on Windows.

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

@@ -43,7 +43,67 @@ export interface CodexExecArgsOptions {
     mode?: "prompt" | "probe";
 }
 type SpawnSyncLike = typeof spawnSync;
-export declare const DEFAULT_CODEX_CHATGPT_MODEL = "gpt-5.4";
+/**
+ * Outcome when the preflight probe confirms the working directory is writable.
+ * capabilitySource is always "probe" — result is measured, not assumed.
+ */
+export interface CodexSandboxPreflightOk {
+    ok: true;
+    effectiveSandbox: "read-only" | "workspace-write";
+    capabilitySource: "probe";
+    writableRoot: string;
+}
+/**
+ * Outcome when the working directory cannot be written but workspace-write
+ * was requested.  This is a first-class typed failure — distinct from a
+ * provider-unavailable or environment-mismatch error.  No model call has
+ * been attempted when this is returned.
+ */
+export interface CodexSandboxPreflightReadOnly {
+    ok: false;
+    code: "provider_sandbox_read_only";
+    requestedCapability: "workspace-write";
+    detectedCapability: "read-only";
+    effectiveSandbox: "read-only";
+    affectedPath: string;
+    writableRoot: string;
+    capabilitySource: "probe";
+    remediation: string;
+}
+export type CodexSandboxPreflightOutcome = CodexSandboxPreflightOk | CodexSandboxPreflightReadOnly;
+/**
+ * Probes whether the given directory is writable by the current process.
+ *
+ * Strategy: create a uniquely named temp file inside the directory, write a
+ * sentinel byte, then remove it.  This is a real filesystem action — not an
+ * inference from binary metadata or launch-probe output.
+ *
+ * The probe leaves no file behind on either success or failure.
+ *
+ * Exported for unit testing with a real tmp directory.
+ */
+export declare function probeFilesystemWriteCapability(directory: string): {
+    writable: true;
+} | {
+    writable: false;
+    reason: string;
+};
+/**
+ * Checks whether the requested sandbox mode is achievable for the given
+ * working directory.  The adapter receives `requestedSandbox` from CLI/core —
+ * it does not decide the mode itself.
+ *
+ * When `requestedSandbox` is "workspace-write" and the working directory is not
+ * writable, this function returns `provider_sandbox_read_only` before any model
+ * execution is attempted.
+ *
+ * When `requestedSandbox` is "read-only" no write probe is performed; the
+ * outcome is `ok: true, effectiveSandbox: "read-only"` immediately.
+ */
+export declare function checkCodexSandboxPreflight(input: {
+    requestedSandbox: "read-only" | "workspace-write";
+    workingDirectory: string;
+}): CodexSandboxPreflightOutcome;
 export interface CodexProbeCandidateResult {
     path: string;
     installKind: CodexInstallKind;

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

@@ -1,9 +1,100 @@
 import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
 import { resolveNpmShimScript } from "./cli-bridge.js";
 const codexLaunchProbeCache = new Map();
-export const DEFAULT_CODEX_CHATGPT_MODEL = "gpt-5.4";
+/**
+ * Probes whether the given directory is writable by the current process.
+ *
+ * Strategy: create a uniquely named temp file inside the directory, write a
+ * sentinel byte, then remove it.  This is a real filesystem action — not an
+ * inference from binary metadata or launch-probe output.
+ *
+ * The probe leaves no file behind on either success or failure.
+ *
+ * Exported for unit testing with a real tmp directory.
+ */
+export function probeFilesystemWriteCapability(directory) {
+    // Ensure the directory exists before probing.
+    try {
+        mkdirSync(directory, { recursive: true });
+    }
+    catch (err) {
+        return {
+            writable: false,
+            reason: `Could not create directory ${directory}: ${err instanceof Error ? err.message : String(err)}`
+        };
+    }
+    // Use mkdtempSync so the filename is guaranteed unique even under concurrent runs.
+    let tempDir;
+    try {
+        tempDir = mkdtempSync(join(directory, ".ml-write-probe-"));
+        const tempFile = join(tempDir, "capability.tmp");
+        writeFileSync(tempFile, "\x01", { encoding: "binary", flag: "wx" });
+        unlinkSync(tempFile);
+        return { writable: true };
+    }
+    catch (err) {
+        return {
+            writable: false,
+            reason: err instanceof Error ? err.message : String(err)
+        };
+    }
+    finally {
+        if (tempDir) {
+            try {
+                rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch { /* ignore cleanup errors */ }
+        }
+    }
+}
+/**
+ * Checks whether the requested sandbox mode is achievable for the given
+ * working directory.  The adapter receives `requestedSandbox` from CLI/core —
+ * it does not decide the mode itself.
+ *
+ * When `requestedSandbox` is "workspace-write" and the working directory is not
+ * writable, this function returns `provider_sandbox_read_only` before any model
+ * execution is attempted.
+ *
+ * When `requestedSandbox` is "read-only" no write probe is performed; the
+ * outcome is `ok: true, effectiveSandbox: "read-only"` immediately.
+ */
+export function checkCodexSandboxPreflight(input) {
+    const dir = resolve(input.workingDirectory);
+    if (input.requestedSandbox === "read-only") {
+        return {
+            ok: true,
+            effectiveSandbox: "read-only",
+            capabilitySource: "probe",
+            writableRoot: dir
+        };
+    }
+    // workspace-write: run the actual filesystem probe.
+    const probeResult = probeFilesystemWriteCapability(dir);
+    if (probeResult.writable) {
+        return {
+            ok: true,
+            effectiveSandbox: "workspace-write",
+            capabilitySource: "probe",
+            writableRoot: dir
+        };
+    }
+    return {
+        ok: false,
+        code: "provider_sandbox_read_only",
+        requestedCapability: "workspace-write",
+        detectedCapability: "read-only",
+        effectiveSandbox: "read-only",
+        affectedPath: dir,
+        writableRoot: dir,
+        capabilitySource: "probe",
+        remediation: `The working directory ${dir} is not writable by the current process. ` +
+            "Launch MartinLoop in a session with write access to that directory, or use " +
+            "`--sandbox read-only` for inspection-only work."
+    };
+}
 const CODEX_LAUNCH_PROBE_PROMPT = [
     "You are validating MartinLoop Codex host readiness.",
     "Do not edit files.",
@@ -17,7 +108,7 @@ function buildProbeCacheKey(input) {
         workingDirectory: resolve(input.workingDirectory),
         platform: input.platform,
         candidatePaths: input.candidatePaths,
-        model: input.model ?? DEFAULT_CODEX_CHATGPT_MODEL
+        model: input.model
     });
 }
 function isInsideGitRepository(workingDirectory) {
@@ -89,6 +180,17 @@ function codexProbePreference(diagnosis) {
     }
     return 3;
 }
+function codexProbeCandidatePreference(path, diagnosis, platform) {
+    const hostPreference = codexProbePreference(diagnosis) * 10;
+    if (platform !== "win32" || diagnosis.installKind !== "windows_shim") {
+        return hostPreference;
+    }
+    // `where codex` commonly returns npm's extensionless POSIX shim before
+    // `codex.cmd`. Node cannot spawn that text shim directly on Windows, while
+    // the .cmd/.ps1 shim has a supported invocation path (or can be unwrapped).
+    const extension = extname(path).toLowerCase();
+    return hostPreference + (extension === ".cmd" || extension === ".bat" || extension === ".ps1" ? 0 : 1);
+}
 function buildProbeCandidates(input) {
     const pathCandidates = normalizeCandidates(input.availability.candidatePaths ?? [input.availability.resolvedPath ?? input.availability.command]);
     const desktopCandidates = input.platform === "win32" && input.includeDesktopCandidates
@@ -106,7 +208,9 @@ function buildProbeCandidates(input) {
         return {
             path,
             diagnosis,
-            preference: input.platform === "win32" ? codexProbePreference(diagnosis) : 0,
+            preference: input.platform === "win32"
+                ? codexProbeCandidatePreference(path, diagnosis, input.platform)
+                : 0,
             discoveryIndex
         };
     })
@@ -205,11 +309,11 @@ function classifyProbeFailure(stderr, stdout, diagnosis) {
             warnings.push(unsupportedModelWarning);
         }
         return {
-            summary: `Codex launched with a model that is not supported for ChatGPT-account authentication. Use an explicit supported model such as \`${DEFAULT_CODEX_CHATGPT_MODEL}\` for governed Codex work.`,
+            summary: "Codex launched with a model that is not supported for ChatGPT-account authentication. Pass an explicit model that your ChatGPT account supports for governed Codex work.",
             diagnosis: {
                 ...diagnosis,
                 warnings,
-                remediation: `Override the Codex launch model to a ChatGPT-account-supported option such as \`${DEFAULT_CODEX_CHATGPT_MODEL}\` before running governed Codex work.`
+                remediation: "Override the Codex launch model to a ChatGPT-account-supported option before running governed Codex work."
             }
         };
     }
@@ -275,14 +379,18 @@ export function buildCodexExecArgs(options) {
     const sandbox = options.sandbox ?? "workspace-write";
     const modelArgs = options.model ? ["--model", options.model] : [];
     const extraArgs = options.extraArgs ?? [];
+    const sandboxArgs = sandbox === "workspace-write"
+        // In Codex CLI, --approve-for-me is the write-enabled automatic-review
+        // mode and is mutually exclusive with --sandbox workspace-write.
+        ? ["--approve-for-me"]
+        : ["--sandbox", sandbox];
     return [
         "exec",
         // Governed MartinLoop runs should not inherit auth-sensitive default MCP/plugin state.
         "--ignore-user-config",
         "--cd",
         options.workingDirectory,
-        "--sandbox",
-        sandbox,
+        ...sandboxArgs,
         "--json",
         "--color",
         "never",
@@ -357,10 +465,6 @@ function discoverCommandOffPath(command, platform, env) {
         const localAppData = env.LOCALAPPDATA;
         if (localAppData)
             dirs.push(join(localAppData, "OpenAI", "Codex", "bin"));
-        // Claude Code native installer places binary at %USERPROFILE%\.local\bin
-        const userProfile = env.USERPROFILE ?? env.HOMEPATH;
-        if (userProfile)
-            dirs.push(join(userProfile, ".local", "bin"));
         if (home)
             dirs.push(join(home, "scoop", "shims"));
     }
@@ -387,13 +491,8 @@ function discoverCommandOffPath(command, platform, env) {
     return undefined;
 }
 function suggestInstall(command) {
-    if (command === "claude") {
-        const installCmd = process.platform === "win32"
-            ? "irm https://claude.ai/install.ps1 | iex"
-            : "curl -fsSL https://claude.ai/install.sh | bash";
-        return `Install with: ${installCmd}`;
-    }
     const installs = {
+        claude: "Install with: npm install -g @anthropic-ai/claude-code",
         codex: "Install with: npm install -g @openai/codex",
         gemini: "Install with: npm install -g @google/gemini-cli"
     };
@@ -471,7 +570,7 @@ export function probeCodexLaunch(input) {
     });
     const args = buildCodexExecArgs({
         workingDirectory: input.workingDirectory,
-        model: input.model ?? DEFAULT_CODEX_CHATGPT_MODEL,
+        model: input.model,
         mode: "probe"
     });
     if (!availability.available) {

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

@@ -1,8 +1,6 @@
 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, createGeminiCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type CodexCliAdapterOptions, type GeminiCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
-export { createVerifierOnlyAdapter, type VerifierOnlyAdapterOptions } from "./verifier-only.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 { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability, type CliCommandAvailability, type CodexHostDiagnosis, type CodexHostPlatform, type CodexLaunchProbeResult, checkCodexSandboxPreflight, probeFilesystemWriteCapability, type CodexSandboxPreflightOk, type CodexSandboxPreflightOutcome, type CodexSandboxPreflightReadOnly } 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,8 +1,6 @@
 export { createDirectProviderAdapter } from "./direct-provider.js";
 export { createStubDirectProviderAdapter } from "./stub-direct-provider.js";
-export { createStubAgentCliAdapter } from "./stub-agent-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 { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability, checkCodexSandboxPreflight, probeFilesystemWriteCapability } from "./codex-launcher.js";
 export { createSpawnPlan } from "./cli-bridge.js";

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

@@ -69,15 +69,32 @@ function estimateCost(model, inputChars, outputChars) {
     const actualUsd = (tokensIn / 1000) * pricing.inputPer1K + (tokensOut / 1000) * pricing.outputPer1K;
     return { tokensIn, tokensOut, actualUsd };
 }
+function normalizeOpenAiCompatibleUsage(input) {
+    const hasKnownPricing = KNOWN_MODEL_PRICING[input.model] !== undefined;
+    const pricing = KNOWN_MODEL_PRICING[input.model] ?? {
+        inputPer1K: FALLBACK_INPUT_PER_1K,
+        outputPer1K: FALLBACK_OUTPUT_PER_1K
+    };
+    const actualUsd = (input.tokensIn / 1000) * pricing.inputPer1K +
+        (input.tokensOut / 1000) * pricing.outputPer1K;
+    const provenance = input.usageWasFullyProviderReported && hasKnownPricing ? "actual" : "estimated";
+    return normalizeUsage({
+        actualUsd,
+        ...(provenance === "estimated" ? { estimatedUsd: actualUsd } : {}),
+        tokensIn: input.tokensIn,
+        tokensOut: input.tokensOut,
+        provenance
+    });
+}
 // ---------------------------------------------------------------------------
 // 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.
+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";
@@ -172,10 +189,12 @@ export function createOpenAiCompatibleAdapter(options) {
             // indicate a permanent configuration problem.
             const MAX_RETRIES = 3;
             const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+            const NON_RETRYABLE_STATUS = new Set([400, 401, 403]);
             const endpoint = `${baseUrl}/v1/chat/completions`;
             let responseText = "";
             let tokensIn = estimated.tokensIn;
             let tokensOut = 0;
+            let usageWasFullyProviderReported = false;
             const headers = { "Content-Type": "application/json" };
             if (apiKey)
                 headers["Authorization"] = `Bearer ${apiKey}`;
@@ -207,6 +226,17 @@ export function createOpenAiCompatibleAdapter(options) {
                     const body = (await res.json());
                     if (!res.ok || body.error) {
                         const errMsg = body.error?.message ?? `HTTP ${res.status}`;
+                        // Fail immediately on non-retryable errors (auth, bad request)
+                        if (NON_RETRYABLE_STATUS.has(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" }
+                            };
+                        }
+                        // Retry on transient errors
                         if (RETRYABLE_STATUS.has(res.status) && attempt < MAX_RETRIES - 1) {
                             lastError = errMsg;
                             // Exponential backoff: 1s, 2s, 4s
@@ -223,8 +253,13 @@ export function createOpenAiCompatibleAdapter(options) {
                     }
                     responseText = body.choices?.[0]?.message?.content ?? "";
                     if (body.usage) {
-                        tokensIn = body.usage.prompt_tokens ?? tokensIn;
-                        tokensOut = body.usage.completion_tokens ?? 0;
+                        const providerPromptTokens = body.usage.prompt_tokens;
+                        const providerCompletionTokens = body.usage.completion_tokens;
+                        usageWasFullyProviderReported =
+                            typeof providerPromptTokens === "number" &&
+                                typeof providerCompletionTokens === "number";
+                        tokensIn = providerPromptTokens ?? tokensIn;
+                        tokensOut = providerCompletionTokens ?? Math.ceil(responseText.length / CHARS_PER_TOKEN);
                     }
                     else {
                         tokensOut = Math.ceil(responseText.length / CHARS_PER_TOKEN);
@@ -267,33 +302,37 @@ export function createOpenAiCompatibleAdapter(options) {
                 return {
                     status: "failed",
                     summary: `${model} returned an empty response.`,
-                    usage: normalizeUsage({ actualUsd: 0, tokensIn, tokensOut: 0, provenance: "actual" }),
+                    usage: normalizeOpenAiCompatibleUsage({
+                        model,
+                        tokensIn,
+                        tokensOut: 0,
+                        usageWasFullyProviderReported
+                    }),
                     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 verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack, undefined, {
+                runId: request.loopId,
+                workspaceId: request.workspaceId,
+                cwd: workingDirectory,
+            });
             const execution = {
                 changedFiles: hasVerificationSteps
                     ? (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,
+                usage: normalizeOpenAiCompatibleUsage({
+                    model,
                     tokensIn,
                     tokensOut,
-                    provenance: "actual"
+                    usageWasFullyProviderReported
                 }),
                 verification,
                 execution,

package/dist/vendor/contracts/adapter-capabilities.d.ts

@@ -1,5 +1,5 @@
 export type DiffVisibilityLevel = "none" | "git" | "adapter_reported";
-export type VerifierCompatibility = "full" | "verify_only" | "unsupported";
+export type VerifierCompatibility = "full" | "proof" | "unsupported";
 export type SandboxExpectation = "host_process" | "workspace_write" | "provider_managed" | "not_applicable";
 export type LaunchReadiness = "path_lookup" | "configured_endpoint" | "built_in";
 export type AdapterUsageSettlement = "actual" | "estimated" | "unavailable";