@martinloop/mcp 0.7.1 → 0.8.1

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

@@ -1,146 +1,23 @@
-import { spawn } from "node:child_process";
 import { basename, delimiter, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { diffStatsFromNumstat } from "./runtime-support.js";
+import { spawnSupervisedProcess } from "./process-supervisor.js";
 const gitRepositoryRootCache = new Map();
 export async function runSubprocess(command, args, options) {
-    return new Promise((resolve) => {
-        let timedOut = false;
-        let outputCapped = false;
-        let terminationReason;
-        let settled = false;
-        let exited = false;
-        let outputBytes = 0;
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        const stdinMode = options.stdinData !== undefined ? "pipe" : "ignore";
-        const resolveOnce = (result) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            resolve({ ...result, timedOut, outputCapped, ...(terminationReason ? { terminationReason } : {}) });
-        };
-        let proc;
-        try {
-            const spawnPlan = createSpawnPlan(command, args, options.cwd, options.spawnImpl !== undefined);
-            proc = (options.spawnImpl ?? spawn)(spawnPlan.command, spawnPlan.args, {
-                cwd: options.cwd,
-                stdio: [stdinMode, "pipe", "pipe"],
-                env: process.env
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            resolveOnce({ exitCode: 1, stdout: "", stderr: message, launched: false, completed: false, crashed: true });
-            return;
-        }
-        const trackOutput = (chunks, chunk) => {
-            if (outputCapped || timedOut || terminationReason) {
-                return;
-            }
-            chunks.push(chunk);
-            outputBytes += chunk.byteLength;
-            if (options.maxOutputBytes !== undefined && outputBytes > options.maxOutputBytes) {
-                outputCapped = true;
-                proc.kill("SIGTERM");
-            }
-        };
-        const terminateEarly = (reason) => {
-            if (terminationReason || timedOut || outputCapped) {
-                return;
-            }
-            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;
-            }
-            trackOutput(stdoutChunks, chunk);
-            if (options.onStdoutChunk) {
-                try {
-                    options.onStdoutChunk(chunk, terminateEarly);
-                }
-                catch (error) {
-                    terminateEarly(`stdout inspector error: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        });
-        proc.stderr?.on("data", (chunk) => {
-            if (outputCapped || timedOut || terminationReason) {
-                return;
-            }
-            trackOutput(stderrChunks, chunk);
-        });
-        proc.stdin?.on("error", (error) => {
-            // Some CLIs exit before consuming stdin in tests and on fast-fail paths.
-            // Treat the closed pipe as a handled subprocess lifecycle condition.
-            if (error.code === "EPIPE") {
-                return;
-            }
-            stderrChunks.push(Buffer.from(`${error.message}\n`, "utf8"));
-        });
-        const timer = setTimeout(() => {
-            if (settled || exited || proc.exitCode !== null) {
-                return;
-            }
-            timedOut = true;
-            proc.kill("SIGTERM");
-        }, options.timeoutMs);
-        proc.on("exit", () => {
-            exited = true;
-        });
-        proc.on("error", (error) => {
-            clearTimeout(timer);
-            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,
-                completed,
-                crashed: !completed && !timedOut && !outputCapped && !terminationReason,
-            });
-        });
-        if (options.stdinData !== undefined && proc.stdin) {
-            try {
-                proc.stdin.end(options.stdinData, "utf8");
-            }
-            catch (error) {
-                const stdinError = error;
-                if (stdinError.code !== "EPIPE") {
-                    clearTimeout(timer);
-                    resolveOnce({
-                        exitCode: 1,
-                        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-                        stderr: stdinError.message,
-                        launched: false,
-                        completed: false,
-                        crashed: true,
-                    });
-                }
-            }
-        }
+    const spawnPlan = createSpawnPlan(command, args, options.cwd, options.spawnImpl !== undefined);
+    return spawnSupervisedProcess(spawnPlan.command, spawnPlan.args, {
+        cwd: options.cwd,
+        timeoutMs: options.timeoutMs,
+        ...(options.env ? { env: options.env } : {}),
+        ...(options.spawnImpl ? { spawnImpl: options.spawnImpl } : {}),
+        ...(options.stdinData !== undefined ? { stdinData: options.stdinData } : {}),
+        ...(options.maxOutputBytes !== undefined ? { maxOutputBytes: options.maxOutputBytes } : {}),
+        ...(options.onStdoutChunk ? { onStdoutChunk: options.onStdoutChunk } : {}),
+        ...(options.signal ? { signal: options.signal } : {}),
+        ...(options.requireTreeClosureOnSuccess ? { requireTreeClosureOnSuccess: true } : {})
     });
 }
-export async function runVerification(commands, cwd, timeoutMs, verificationStack, spawnImpl, binding) {
+export async function runVerification(commands, cwd, timeoutMs, verificationStack, spawnImpl, binding, signal) {
     const steps = verificationStack && verificationStack.length > 0
         ? verificationStack.map((step) => ({
             command: step.command,
@@ -150,12 +27,29 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
     const executionBinding = {
         runId: binding?.runId ?? "unbound",
         workspaceId: binding?.workspaceId ?? "unbound",
+        ...(binding?.attemptId ? { attemptId: binding.attemptId } : {}),
         cwd: binding?.cwd ?? cwd,
+        ...(binding?.runsRoot ? { runsRoot: binding.runsRoot } : {}),
+        ...(binding?.executionProfile ? { executionProfile: binding.executionProfile } : {}),
+        ...(binding?.allowedNetworkDomains?.length ? { allowedNetworkDomains: [...binding.allowedNetworkDomains] } : {}),
         commands: steps.map((step) => step.command),
     };
+    const verifierEnv = {
+        ...process.env,
+        MARTIN_RUN_ID: executionBinding.runId,
+        MARTIN_WORKSPACE_ID: executionBinding.workspaceId,
+        ...(executionBinding.attemptId ? { MARTIN_ATTEMPT_ID: executionBinding.attemptId } : {}),
+        MARTIN_VERIFIER_CWD: executionBinding.cwd,
+        ...(executionBinding.runsRoot ? { MARTIN_RUNS_DIR: executionBinding.runsRoot } : {}),
+        ...(executionBinding.executionProfile ? { MARTIN_EXECUTION_PROFILE: executionBinding.executionProfile } : {}),
+        ...(executionBinding.allowedNetworkDomains?.length
+            ? { MARTIN_ALLOWED_NETWORK_DOMAINS: JSON.stringify(executionBinding.allowedNetworkDomains) }
+            : {}),
+    };
     if (steps.length === 0) {
         return {
             passed: false,
+            processCloseState: "not_required",
             summary: "No verification commands specified; execution is not VERIFIED.",
             steps: [],
             warnings: ["Execution completed without verifier evidence."],
@@ -165,6 +59,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
     const failedSteps = [];
     const stepOutcomes = [];
     const warnings = [];
+    let processCloseState = "not_required";
     for (const step of steps) {
         let bin;
         let args;
@@ -193,8 +88,17 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
         if (!bin) {
             continue;
         }
-        const result = await runSubprocess(bin, args, { cwd, timeoutMs, spawnImpl });
+        const result = await runSubprocess(bin, args, {
+            cwd,
+            timeoutMs,
+            env: verifierEnv,
+            spawnImpl,
+            ...(signal ? { signal } : {}),
+            requireTreeClosureOnSuccess: true
+        });
         const detail = truncate(result.stderr.trim() || result.stdout.trim(), 500);
+        processCloseState = combineProcessCloseState(processCloseState, result.cleanup.state);
+        const evidence = parseExternalOutcomeEvidenceReference(result.stdout);
         stepOutcomes.push({
             command: step.command,
             launched: result.launched,
@@ -203,11 +107,23 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
             exitCode: result.exitCode,
             timedOut: result.timedOut,
             fastFail: step.fastFail,
-            ...(detail ? { detail } : {})
+            ...(detail ? { detail } : {}),
+            ...(evidence ? { evidence } : {})
         });
+        if (result.cleanup.state === "failed") {
+            return {
+                passed: false,
+                processCloseState,
+                summary: `Verifier process-tree closure failed: ${step.command}`,
+                steps: stepOutcomes,
+                binding: executionBinding,
+                warnings: [result.cleanup.message]
+            };
+        }
         if (result.timedOut) {
             return {
                 passed: false,
+                processCloseState,
                 summary: `Verification timed out: ${step.command}`,
                 steps: stepOutcomes,
                 binding: executionBinding,
@@ -220,7 +136,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, binding: executionBinding, ...(warnings.length ? { warnings } : {}) };
+                return { passed: false, processCloseState, summary, steps: stepOutcomes, binding: executionBinding, ...(warnings.length ? { warnings } : {}) };
             }
             failedSteps.push(step.command);
         }
@@ -228,6 +144,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
     if (failedSteps.length > 0) {
         return {
             passed: false,
+            processCloseState,
             summary: `Failed steps: ${failedSteps.join(", ")}`,
             steps: stepOutcomes,
             binding: executionBinding,
@@ -236,30 +153,93 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
     }
     return {
         passed: true,
+        processCloseState,
         summary: `All ${String(steps.length)} verification step(s) passed.`,
         steps: stepOutcomes,
         binding: executionBinding,
         ...(warnings.length ? { warnings } : {})
     };
 }
-export async function readGitExecutionArtifacts(repoRoot, timeoutMs, spawnImpl) {
+function parseExternalOutcomeEvidenceReference(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        const evidence = parsed.evidence;
+        if (evidence?.kind !== "external_outcome"
+            || typeof evidence.contractId !== "string"
+            || typeof evidence.path !== "string"
+            || typeof evidence.sha256 !== "string"
+            || !/^[a-f0-9]{64}$/u.test(evidence.sha256))
+            return undefined;
+        return {
+            kind: "external_outcome",
+            contractId: evidence.contractId,
+            path: evidence.path,
+            sha256: evidence.sha256,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function combineProcessCloseState(current, next) {
+    if (current === "failed" || next === "failed")
+        return "failed";
+    if (current === "closed" || next === "closed")
+        return "closed";
+    return "not_required";
+}
+export async function readGitExecutionArtifacts(repoRoot, timeoutMs, spawnImpl, requestedChangedFiles) {
     if (!resolveGitRepositoryRoot(repoRoot)) {
         return {};
     }
-    const changedFilesResult = await runSubprocess("git", ["diff", "--name-only", "HEAD"], { cwd: repoRoot, timeoutMs, spawnImpl });
-    const numstatResult = await runSubprocess("git", ["diff", "--numstat", "HEAD"], { cwd: repoRoot, timeoutMs, spawnImpl });
-    const changedFiles = changedFilesResult.exitCode === 0
-        ? changedFilesResult.stdout
-            .split(/\r?\n/u)
-            .map((entry) => entry.trim())
-            .filter(Boolean)
-        : [];
-    const diffStats = numstatResult.exitCode === 0 ? diffStatsFromNumstat(numstatResult.stdout) : undefined;
+    const observedChangedFiles = requestedChangedFiles
+        ? [...requestedChangedFiles]
+        : await readGitChangedFiles(repoRoot, timeoutMs, spawnImpl);
+    const changedFiles = observedChangedFiles.filter(isSafeRepoRelativeGitPath);
+    const patchParts = [];
+    const numstatParts = [];
+    const nullDevice = process.platform === "win32" ? "NUL" : "/dev/null";
+    for (const file of changedFiles) {
+        const trackedPatch = await runSubprocess("git", ["diff", "--binary", "--no-ext-diff", "HEAD", "--", file], { cwd: repoRoot, timeoutMs, spawnImpl });
+        const trackedNumstat = await runSubprocess("git", ["diff", "--numstat", "HEAD", "--", file], { cwd: repoRoot, timeoutMs, spawnImpl });
+        if (trackedPatch.exitCode === 0 && trackedPatch.stdout.length > 0) {
+            patchParts.push(trackedPatch.stdout);
+            if (trackedNumstat.exitCode === 0 && trackedNumstat.stdout.length > 0) {
+                numstatParts.push(trackedNumstat.stdout);
+            }
+            continue;
+        }
+        // Git does not include untracked files in `git diff HEAD`. Diff each such
+        // path against the null tree so the parent runtime receives its content,
+        // not merely a synthetic filename-only patch.
+        const untrackedPatch = await runSubprocess("git", ["diff", "--binary", "--no-ext-diff", "--no-index", "--", nullDevice, file], { cwd: repoRoot, timeoutMs, spawnImpl });
+        if ((untrackedPatch.exitCode === 0 || untrackedPatch.exitCode === 1) && untrackedPatch.stdout.length > 0) {
+            patchParts.push(untrackedPatch.stdout);
+        }
+        const untrackedNumstat = await runSubprocess("git", ["diff", "--numstat", "--no-index", "--", nullDevice, file], { cwd: repoRoot, timeoutMs, spawnImpl });
+        if ((untrackedNumstat.exitCode === 0 || untrackedNumstat.exitCode === 1) && untrackedNumstat.stdout.length > 0) {
+            numstatParts.push(untrackedNumstat.stdout);
+        }
+    }
+    const patch = patchParts.join("\n");
+    const numstat = numstatParts.join("\n");
+    const diffStats = numstat.length > 0 ? diffStatsFromNumstat(numstat) : undefined;
     return {
         ...(changedFiles.length > 0 ? { changedFiles } : {}),
+        ...(patch.length > 0 ? { patch } : {}),
         ...(diffStats ? { diffStats } : {})
     };
 }
+function isSafeRepoRelativeGitPath(file) {
+    if (file.length === 0 || file.includes("\u0000") || isAbsolute(file)) {
+        return false;
+    }
+    const segments = file.replace(/\\/gu, "/").split("/");
+    return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
 export async function readGitChangedFiles(repoRoot, timeoutMs, spawnImpl) {
     if (!resolveGitRepositoryRoot(repoRoot)) {
         return [];

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

@@ -1,6 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { type AgentExecutionIntent } from "../contracts/index.js";
-export type CodexFlagScope = "global" | "exec";
+export type CodexFlagScope = "global" | "exec" | "sandbox";
 export type CodexPromptTransport = "stdin-dash" | "argv";
 export type CodexWriteStrategy = "sandbox+approval" | "automation";
 export interface CodexCapabilityFlag {
@@ -26,6 +26,8 @@ export interface CodexCapabilityProfile {
     supportsExec: boolean;
     probeSucceeded: boolean;
     probeError?: string;
+    config?: CodexCapabilityFlag;
+    sandboxConfig?: CodexCapabilityFlag;
     model?: CodexCapabilityFlag;
     cwd?: CodexCapabilityFlag;
     sandbox?: CodexSandboxCapability;
@@ -44,6 +46,7 @@ export interface CodexCapabilityProfile {
 export interface CodexExecArgsOptions {
     command?: string;
     workingDirectory: string;
+    platform?: NodeJS.Platform;
     sandbox?: "read-only" | "workspace-write" | "danger-full-access";
     model?: string;
     extraArgs?: string[];

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

@@ -134,8 +134,18 @@ export function probeCodexCapabilities(binaryPath, options = {}) {
         spawnSyncImpl,
         injected
     });
+    const sandboxProbe = platform === "win32"
+        ? runHelpProbe({
+            binaryPath,
+            args: ["sandbox", "--help"],
+            platform,
+            spawnSyncImpl,
+            injected
+        })
+        : { text: "", status: null };
     const globalHelp = globalProbe.text;
     const execHelp = execProbe.text;
+    const sandboxCommandHelp = sandboxProbe.text;
     const supportsExec = execProbe.status === 0 &&
         !/(unknown command|unrecognized subcommand|unexpected argument ['"]?exec)/iu.test(execHelp);
     const sandboxFlag = locateFlag(globalHelp, execHelp, ["--sandbox", "-s"]);
@@ -160,7 +170,8 @@ export function probeCodexCapabilities(binaryPath, options = {}) {
         ? `${flagContext(globalHelp, colorFlag.flag)}\n${flagContext(execHelp, colorFlag.flag)}`
         : "";
     const promptTransports = parsePromptTransports(execHelp);
-    const probeError = globalProbe.error ?? execProbe.error;
+    const probeError = globalProbe.error ?? execProbe.error ?? sandboxProbe.error;
+    const sandboxConfigFlag = ["--config", "-c"].find((flag) => flagPattern(flag).test(sandboxCommandHelp));
     const profile = {
         binaryPath,
         supportsExec,
@@ -169,6 +180,12 @@ export function probeCodexCapabilities(binaryPath, options = {}) {
         ...(locateFlag(globalHelp, execHelp, ["--model", "-m"])
             ? { model: locateFlag(globalHelp, execHelp, ["--model", "-m"]) }
             : {}),
+        ...(locateFlag(globalHelp, execHelp, ["--config", "-c"])
+            ? { config: locateFlag(globalHelp, execHelp, ["--config", "-c"]) }
+            : {}),
+        ...(sandboxConfigFlag
+            ? { sandboxConfig: { flag: sandboxConfigFlag, scope: "sandbox" } }
+            : {}),
         ...(locateFlag(globalHelp, execHelp, ["--cd", "--cwd", "--working-dir", "-C"])
             ? { cwd: locateFlag(globalHelp, execHelp, ["--cd", "--cwd", "--working-dir", "-C"]) }
             : {}),
@@ -242,18 +259,33 @@ export function buildCodexExecArgs(options) {
     if (options.mode !== "probe" && !resolution) {
         throw new Error(`Resolved Codex binary ${profile.binaryPath} has no negotiated governed-autonomous execution resolution.`);
     }
-    const permissionFlags = [profile.sandbox?.flag, profile.automation?.flag, profile.approvalPolicy?.flag]
+    const controlledFlags = [
+        profile.sandbox?.flag,
+        profile.automation?.flag,
+        profile.approvalPolicy?.flag,
+        profile.config?.flag
+    ]
         .filter((value) => Boolean(value));
-    if ((options.extraArgs ?? []).some((arg) => arg === "danger-full-access" || permissionFlags.some((flag) => arg === flag || arg.startsWith(`${flag}=`)))) {
-        throw new Error("Permission and sandbox controls cannot be supplied through extraArgs.");
+    if ((options.extraArgs ?? []).some((arg) => {
+        const isReservedConfig = arg === "--config" ||
+            arg.startsWith("--config=") ||
+            arg === "-c" ||
+            (arg.startsWith("-c") && arg.length > 2);
+        return arg === "danger-full-access" || isReservedConfig || controlledFlags.some((flag) => arg === flag || arg.startsWith(`${flag}=`));
+    })) {
+        throw new Error("Permission, sandbox, and configuration controls cannot be supplied through extraArgs.");
     }
     const globalArgs = [];
     const execArgs = [];
+    const platform = options.platform ?? process.platform;
     const requestedSandbox = options.sandbox ?? "workspace-write";
     const strategy = resolution?.strategy ?? options.writeStrategy;
     const promptTransport = options.promptTransport ?? profile.promptTransport;
     if (profile.userConfigIsolation)
         pushCapabilityArg(globalArgs, execArgs, profile.userConfigIsolation);
+    if (platform === "win32" && profile.userConfigIsolation && profile.config) {
+        pushCapabilityArg(globalArgs, execArgs, profile.config, 'windows.sandbox="elevated"');
+    }
     if (profile.cwd)
         pushCapabilityArg(globalArgs, execArgs, profile.cwd, options.workingDirectory);
     if (requestedSandbox === "workspace-write") {

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

@@ -1,5 +1,12 @@
 import { type CodexCliAdapterOptions as LegacyCodexCliAdapterOptions } from "./claude-cli.js";
 import { type CodexAutonomyResolution, type CodexCapabilityProfile } from "./codex-launcher.js";
+/**
+ * Conservative admission floor for one Codex CLI turn. Codex reports token
+ * usage in turn.completed, after the first turn has already consumed context,
+ * so smaller explicit caps cannot be enforced before spend.
+ */
+export declare const CODEX_MINIMUM_VIABLE_TOKEN_BUDGET = 128000;
+export declare const CODEX_TOKEN_BUDGET_PREFLIGHT_BASIS = "codex_first_turn_usage_reports_after_completion";
 export interface CodexCliAdapterOptions extends Omit<LegacyCodexCliAdapterOptions, "command"> {
     /** Exact resolved executable selected by the Codex launch probe. */
     command?: string;
@@ -16,8 +23,8 @@ export interface CodexCliAdapterOptions extends Omit<LegacyCodexCliAdapterOption
  *
  * Provider identity remains `codex` even when doctor/preflight selected an
  * absolute native binary or npm shim. The selected binary's cached capability
- * profile builds both the real argv and stdin transport, while the spawn router
- * sends only the Codex subprocess to that exact executable. Git/verifier
- * subprocesses retain their normal commands.
+ * profile builds both the real argv and stdin transport. The generic adapter's
+ * execution-command boundary sends only the Codex subprocess to that exact
+ * executable, while Git/verifier subprocesses retain normal OS-owned spawning.
  */
 export declare function createCodexCliAdapter(options?: CodexCliAdapterOptions): import("../core/index.js").MartinAdapter;

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

@@ -1,26 +1,20 @@
-import { spawn } from "node:child_process";
 import { createAgentCliAdapter } from "./claude-cli.js";
 import { buildCodexExecArgs, buildCodexStdin, isCodexAutonomyResolutionVerifiedByLaunchProbe, probeCodexCapabilities } from "./codex-launcher.js";
-import { createSpawnPlan } from "./cli-bridge.js";
-function createCodexSpawnRouter(input) {
-    if (input.injectedSpawn) {
-        return (command, args = [], options) => input.injectedSpawn?.(command === "codex" ? input.selectedBinary : command, args, options);
-    }
-    return (command, args = [], options) => {
-        const executable = command === "codex" ? input.selectedBinary : command;
-        const cwd = typeof options?.cwd === "string" ? options.cwd : input.workingDirectory;
-        const plan = createSpawnPlan(executable, [...args], cwd, false);
-        return spawn(plan.command, plan.args, options ?? {});
-    };
-}
+/**
+ * Conservative admission floor for one Codex CLI turn. Codex reports token
+ * usage in turn.completed, after the first turn has already consumed context,
+ * so smaller explicit caps cannot be enforced before spend.
+ */
+export const CODEX_MINIMUM_VIABLE_TOKEN_BUDGET = 128_000;
+export const CODEX_TOKEN_BUDGET_PREFLIGHT_BASIS = "codex_first_turn_usage_reports_after_completion";
 /**
  * Capability-driven Codex CLI adapter.
  *
  * Provider identity remains `codex` even when doctor/preflight selected an
  * absolute native binary or npm shim. The selected binary's cached capability
- * profile builds both the real argv and stdin transport, while the spawn router
- * sends only the Codex subprocess to that exact executable. Git/verifier
- * subprocesses retain their normal commands.
+ * profile builds both the real argv and stdin transport. The generic adapter's
+ * execution-command boundary sends only the Codex subprocess to that exact
+ * executable, while Git/verifier subprocesses retain normal OS-owned spawning.
  */
 export function createCodexCliAdapter(options = {}) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
@@ -39,16 +33,12 @@ export function createCodexCliAdapter(options = {}) {
     const sandbox = options.sandbox ?? "workspace-write";
     const extraArgs = options.extraArgs ?? [];
     const launchModel = options.model;
-    const spawnImpl = createCodexSpawnRouter({
-        selectedBinary,
-        workingDirectory,
-        ...(options.spawnImpl ? { injectedSpawn: options.spawnImpl } : {})
-    });
     return createAgentCliAdapter({
         // Keep semantic provider identity stable for usage parsing, pricing,
-        // diagnostics, and adapter metadata. The spawn router maps this to the
-        // exact selected binary at process launch time.
+        // diagnostics, and adapter metadata. executionCommand selects the exact
+        // binary without disguising production OS spawning as a test injection.
         command: "codex",
+        executionCommand: selectedBinary,
         adapterIdSuffix: "codex",
         model: options.model,
         label: options.label ?? "Codex CLI adapter",
@@ -58,7 +48,14 @@ export function createCodexCliAdapter(options = {}) {
         providerExecutionTimeoutMs: options.providerExecutionTimeoutMs,
         verifyTimeoutMs: options.verifyTimeoutMs,
         supportsJsonOutput: false,
-        spawnImpl,
+        streamingUsageCap: true,
+        streamingTokenCap: true,
+        streamingUsageDetailsIncludedInTotals: true,
+        budgetPreflight: {
+            minimumViableTokens: CODEX_MINIMUM_VIABLE_TOKEN_BUDGET,
+            basis: CODEX_TOKEN_BUDGET_PREFLIGHT_BASIS
+        },
+        spawnImpl: options.spawnImpl,
         argsBuilder: (prompt) => buildCodexExecArgs({
             command: selectedBinary,
             workingDirectory,