@martinloop/mcp 0.7.0 → 0.8.0

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

@@ -2,9 +2,8 @@ import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
 import { userInfo } from "node:os";
-import { normalizeProviderExecutionTimeoutMs } from "../contracts/index.js";
 import { createSpawnPlan, resolveNpmShimScript } from "./cli-bridge.js";
-import { buildCodexExecArgs, buildCodexStdin, cacheCodexCapabilityProfile, probeCodexCapabilities, resolveCodexAutonomyCandidates } from "./codex-capabilities.js";
+import { cacheCodexCapabilityProfile, probeCodexCapabilities, resolveCodexAutonomyCandidates } from "./codex-capabilities.js";
 const launchProbeCache = new Map();
 export function probeFilesystemWriteCapability(directory) {
     try {
@@ -258,12 +257,6 @@ export function diagnoseCodexHost(availability, options = {}) {
         warnings: []
     };
 }
-function candidatePreference(path, diagnosis, platform) {
-    const base = diagnosis.installKind === "native" ? 0 : diagnosis.installKind === "windows_shim" ? 20 : 30;
-    if (platform !== "win32" || diagnosis.installKind !== "windows_shim")
-        return base;
-    return base + (/\.(cmd|bat|ps1)$/iu.test(path) ? 0 : 1);
-}
 function buildCandidates(input) {
     const pathCandidates = normalizeCandidates(input.availability.candidatePaths ?? [input.availability.resolvedPath ?? input.availability.command]);
     const desktop = input.platform === "win32" && input.includeDesktopCandidates
@@ -275,11 +268,9 @@ function buildCandidates(input) {
         return {
             path,
             diagnosis,
-            preference: candidatePreference(path, diagnosis, input.platform),
             discoveryIndex
         };
-    })
-        .sort((a, b) => a.preference === b.preference ? a.discoveryIndex - b.discoveryIndex : a.preference - b.preference);
+    });
 }
 function isInsideGitRepository(workingDirectory) {
     let current = resolve(workingDirectory);
@@ -315,19 +306,32 @@ function buildInjectedSpawnPlan(binaryPath, args, platform) {
     }
     return { command: binaryPath, args, invocationMode: "direct" };
 }
-function buildMarkerPrompt(marker, outsideMarkerPath) {
-    const command = `node -e "require('node:fs').writeFileSync(process.argv[1],'MARTIN_CODEX_WRITE_OK')" ${marker}`;
-    const outsideCommand = `node -e "require('node:fs').writeFileSync(process.argv[1],'MARTIN_CODEX_OUTSIDE_BAD')" "${outsideMarkerPath}"`;
-    return [
-        "You are validating MartinLoop Codex host readiness.",
-        "Do not modify tracked files.",
-        "First attempt this outside-workspace command and confirm that it is denied:",
-        outsideCommand,
-        "Then use the shell command executor for the allowed workspace marker.",
-        `Run exactly: ${command}`,
-        "Do not use MCP tools or alternate tools.",
-        "After it succeeds, reply READY."
+function buildLocalSandboxProbeArgs(input) {
+    const script = [
+        "const fs = require('node:fs');",
+        "const inside = process.argv[1];",
+        "const outside = process.argv[2];",
+        "fs.writeFileSync(inside, 'MARTIN_CODEX_WRITE_OK', 'utf8');",
+        "try {",
+        "  fs.writeFileSync(outside, 'MARTIN_CODEX_OUTSIDE_BAD', 'utf8');",
+        "  process.exitCode = 42;",
+        "} catch (error) {",
+        "  if (!error || !['EACCES', 'EPERM', 'EROFS'].includes(error.code)) throw error;",
+        "}"
     ].join("\n");
+    return [
+        "sandbox",
+        "--permission-profile",
+        ":workspace",
+        "-C",
+        input.workingDirectory,
+        "--",
+        process.execPath,
+        "-e",
+        script,
+        input.markerPath,
+        input.outsideMarkerPath
+    ];
 }
 function classifyFailure(stderr, stdout, diagnosis) {
     const combined = `${stderr}\n${stdout}`;
@@ -386,7 +390,6 @@ export function probeCodexLaunch(input) {
     const platform = input.platform ?? process.platform;
     const env = input.env ?? process.env;
     const spawnSyncImpl = input.spawnSyncImpl ?? spawnSync;
-    const providerExecutionTimeoutMs = normalizeProviderExecutionTimeoutMs(input.providerExecutionTimeoutMs);
     const candidates = buildCandidates({
         availability,
         env,
@@ -439,115 +442,107 @@ export function probeCodexLaunch(input) {
             });
             continue;
         }
-        const transports = profile.promptTransports?.length ? profile.promptTransports : [profile.promptTransport];
-        const resolutions = resolveCodexAutonomyCandidates(profile);
-        let candidateSummary = "No advertised Codex invocation strategy proved writable execution.";
-        for (const resolution of resolutions) {
-            for (const transport of transports) {
-                const marker = `.martin-codex-write-probe-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`;
-                const markerPath = join(input.workingDirectory, marker);
-                // Codex workspace-write intentionally permits the host temp directory,
-                // and the repo can be nested inside a broader writable host workspace.
-                // Probe from the user-home boundary so the denial canary is outside both.
-                const outsideRoot = mkdtempSync(join(userInfo().homedir, ".martin-codex-outside-probe-"));
-                const outsideMarkerPath = join(outsideRoot, ".martin-codex-outside-probe.tmp");
-                const prompt = buildMarkerPrompt(marker, outsideMarkerPath);
-                let args;
-                try {
-                    args = buildCodexExecArgs({
-                        command: candidate.path,
-                        workingDirectory: input.workingDirectory,
-                        sandbox: "workspace-write",
-                        ...(input.model ? { model: input.model } : {}),
-                        mode: "probe",
-                        prompt,
-                        capabilityProfile: profile,
-                        promptTransport: transport,
-                        writeStrategy: resolution.strategy,
-                        autonomyResolution: resolution
-                    });
-                }
-                catch (error) {
-                    rmSync(outsideRoot, { recursive: true, force: true });
-                    candidateSummary = error instanceof Error ? error.message : String(error);
-                    lastFailure = { candidate, profile, args: [], summary: candidateSummary };
-                    continue;
-                }
-                const plan = input.spawnSyncImpl
-                    ? buildInjectedSpawnPlan(candidate.path, args, platform)
-                    : { ...createSpawnPlan(candidate.path, args, input.workingDirectory, false), invocationMode: "direct" };
-                const stdin = buildCodexStdin(profile, prompt, transport);
-                const result = spawnSyncImpl(plan.command, plan.args, {
-                    cwd: input.workingDirectory,
-                    encoding: "utf8",
-                    stdio: [stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
-                    ...(stdin !== undefined ? { input: stdin } : {}),
-                    timeout: providerExecutionTimeoutMs
-                });
-                let markerVerified = false;
-                let outsideDenied = false;
-                try {
-                    markerVerified = existsSync(markerPath) && readFileSync(markerPath, "utf8") === "MARTIN_CODEX_WRITE_OK";
-                    outsideDenied = !existsSync(outsideMarkerPath);
-                }
-                finally {
-                    try {
-                        unlinkSync(markerPath);
-                    }
-                    catch {
-                        // best effort cleanup
-                    }
-                    rmSync(outsideRoot, { recursive: true, force: true });
-                }
-                if (!result.error && result.status === 0 && markerVerified && outsideDenied) {
-                    const negotiated = cacheCodexCapabilityProfile({ ...profile, promptTransport: transport }, platform);
-                    selected = {
-                        candidate: {
-                            ...candidate,
-                            diagnosis: { ...candidate.diagnosis, invocationMode: plan.invocationMode }
-                        },
-                        profile: negotiated,
-                        args,
-                        resolution,
-                        transport,
-                        ...(result.status === null ? {} : { exitCode: result.status }),
-                        stdout: result.stdout ?? "",
-                        stderr: result.stderr ?? ""
-                    };
-                    candidateResults.push({
-                        path: candidate.path,
-                        installKind: candidate.diagnosis.installKind,
-                        invocationMode: plan.invocationMode,
-                        nativeInstallValid: true,
-                        sandboxCompatible: true,
-                        launchReady: true,
-                        summary: `Codex capability negotiation passed with ${resolution.strategy} / ${transport}.`,
-                        capabilityProfile: negotiated,
-                        writeStrategy: resolution.strategy,
-                        autonomyResolution: resolution,
-                        promptTransport: transport
-                    });
-                    break candidateLoop;
-                }
-                const failureDiagnosis = classifyFailure(result.stderr ?? "", result.stdout ?? "", candidate.diagnosis);
-                candidateSummary = result.error
-                    ? `Codex launch probe failed: ${result.error.message}`
-                    : result.status !== 0
-                        ? `Codex launch probe exited non-zero: ${(result.stderr ?? result.stdout ?? "").trim() || String(result.status)}`
-                        : !outsideDenied
-                            ? `Codex ${resolution.strategy} / ${transport} escaped the workspace boundary.`
-                            : `Codex ${resolution.strategy} / ${transport} invocation did not prove workspace writes.`;
-                lastFailure = {
-                    candidate: { ...candidate, diagnosis: failureDiagnosis },
-                    profile,
-                    args,
-                    summary: candidateSummary,
-                    ...(result.status === null ? {} : { exitCode: result.status }),
-                    stdout: result.stdout ?? "",
-                    stderr: result.stderr ?? ""
-                };
+        const transport = profile.promptTransports?.[0] ?? profile.promptTransport;
+        const resolution = resolveCodexAutonomyCandidates(profile)[0];
+        let candidateSummary = "No advertised Codex invocation strategy supports governed workspace writes.";
+        if (!resolution) {
+            lastFailure = { candidate, profile, args: [], summary: candidateSummary };
+            candidateResults.push({
+                path: candidate.path,
+                installKind: candidate.diagnosis.installKind,
+                invocationMode: candidate.diagnosis.invocationMode,
+                nativeInstallValid: candidate.diagnosis.nativeInstallValid,
+                sandboxCompatible: false,
+                launchReady: false,
+                summary: candidateSummary,
+                capabilityProfile: profile,
+                ...(candidate.diagnosis.remediation ? { remediation: candidate.diagnosis.remediation } : {})
+            });
+            continue;
+        }
+        const marker = `.martin-codex-write-probe-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`;
+        const markerPath = join(input.workingDirectory, marker);
+        // The outside canary is created under the user-home boundary because Codex
+        // intentionally grants temp writes and the repository may be nested inside
+        // a broader writable host workspace.
+        const outsideRoot = mkdtempSync(join(userInfo().homedir, ".martin-codex-outside-probe-"));
+        const outsideMarkerPath = join(outsideRoot, ".martin-codex-outside-probe.tmp");
+        const args = buildLocalSandboxProbeArgs({
+            workingDirectory: input.workingDirectory,
+            markerPath,
+            outsideMarkerPath
+        });
+        const plan = input.spawnSyncImpl
+            ? buildInjectedSpawnPlan(candidate.path, args, platform)
+            : { ...createSpawnPlan(candidate.path, args, input.workingDirectory, false), invocationMode: "direct" };
+        const result = spawnSyncImpl(plan.command, plan.args, {
+            cwd: input.workingDirectory,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 300_000
+        });
+        let markerVerified = false;
+        let outsideDenied = false;
+        try {
+            markerVerified = existsSync(markerPath) && readFileSync(markerPath, "utf8") === "MARTIN_CODEX_WRITE_OK";
+            outsideDenied = !existsSync(outsideMarkerPath);
+        }
+        finally {
+            try {
+                unlinkSync(markerPath);
             }
+            catch {
+                // best effort cleanup
+            }
+            rmSync(outsideRoot, { recursive: true, force: true });
+        }
+        if (!result.error && result.status === 0 && markerVerified && outsideDenied) {
+            const negotiated = cacheCodexCapabilityProfile({ ...profile, promptTransport: transport }, platform);
+            selected = {
+                candidate: {
+                    ...candidate,
+                    diagnosis: { ...candidate.diagnosis, invocationMode: plan.invocationMode }
+                },
+                profile: negotiated,
+                args,
+                resolution,
+                transport,
+                ...(result.status === null ? {} : { exitCode: result.status }),
+                stdout: result.stdout ?? "",
+                stderr: result.stderr ?? ""
+            };
+            candidateResults.push({
+                path: candidate.path,
+                installKind: candidate.diagnosis.installKind,
+                invocationMode: plan.invocationMode,
+                nativeInstallValid: true,
+                sandboxCompatible: true,
+                launchReady: true,
+                summary: `Codex local sandbox capability probe passed with ${resolution.strategy} / ${transport}.`,
+                capabilityProfile: negotiated,
+                writeStrategy: resolution.strategy,
+                autonomyResolution: resolution,
+                promptTransport: transport
+            });
+            break candidateLoop;
         }
+        const failureDiagnosis = classifyFailure(result.stderr ?? "", result.stdout ?? "", candidate.diagnosis);
+        candidateSummary = result.error
+            ? `Codex local sandbox probe failed: ${result.error.message}`
+            : result.status !== 0
+                ? `Codex local sandbox probe exited non-zero: ${(result.stderr ?? result.stdout ?? "").trim() || String(result.status)}`
+                : !outsideDenied
+                    ? "Codex local sandbox probe escaped the workspace boundary."
+                    : "Codex local sandbox probe did not prove workspace writes.";
+        lastFailure = {
+            candidate: { ...candidate, diagnosis: failureDiagnosis },
+            profile,
+            args,
+            summary: candidateSummary,
+            ...(result.status === null ? {} : { exitCode: result.status }),
+            stdout: result.stdout ?? "",
+            stderr: result.stderr ?? ""
+        };
         candidateResults.push({
             path: candidate.path,
             installKind: candidate.diagnosis.installKind,
@@ -563,7 +558,7 @@ export function probeCodexLaunch(input) {
     if (selected) {
         const result = {
             ok: true,
-            summary: `Codex capability-driven workspace-write probe passed using ${selected.resolution.strategy} / ${selected.transport}.`,
+            summary: `Codex capability-driven local sandbox probe passed using ${selected.resolution.strategy} / ${selected.transport}.`,
             availability: { ...availability, resolvedPath: selected.candidate.path, candidatePaths },
             diagnosis: { ...selected.candidate.diagnosis, resolvedPath: selected.candidate.path },
             command: selected.candidate.path,

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

@@ -2,8 +2,9 @@ export { createDirectProviderAdapter, type DirectProviderAdapterOptions } from "
 export { createAgentCliAdapter, createClaudeCliAdapter, createGeminiCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type GeminiCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
 export { createCodexCliAdapter, type CodexCliAdapterOptions } from "./codex-cli.js";
 export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig, type OpenAiCompatibleAdapterOptions } from "./openai-compatible.js";
-export { createVerifierOnlyAdapter, type VerifierOnlyAdapterOptions } from "./verifier-only.js";
+export { createSwarmVerifierExecutor, createVerifierOnlyAdapter, type SwarmVerifierExecutorOptions, type VerifierOnlyAdapterOptions } from "./verifier-only.js";
 /** @internal Test-only compatibility export. Public package builders strip this surface. */
 export { createStubAgentCliAdapter, type StubAgentCliAdapterOptions, createStubDirectProviderAdapter, type StubDirectProviderAdapterOptions } from "./stub-agent-cli.js";
 export { buildCodexExecArgs, buildCodexStdin, clearCodexCapabilityCacheForTests, detectCodexHostPlatform, diagnoseCodexHost, probeCodexCapabilities, probeCodexLaunch, resolveCliCommandAvailability, type CliCommandAvailability, type CodexApprovalCapability, type CodexAutonomyResolution, type CodexCapabilityFlag, type CodexCapabilityProfile, type CodexFlagScope, type CodexHostDiagnosis, type CodexHostPlatform, type CodexLaunchProbeResult, type CodexPromptTransport, type CodexSandboxCapability, 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";
+export { spawnSupervisedProcess, type ProcessSpawnLike, type ProcessTreeCleanupFailureCode, type ProcessTreeCleanupResult, type SpawnSupervisedProcessOptions, type SupervisedProcessResult } from "./process-supervisor.js";

package/dist/vendor/adapters/index.js

@@ -2,8 +2,9 @@ export { createDirectProviderAdapter } from "./direct-provider.js";
 export { createAgentCliAdapter, createClaudeCliAdapter, createGeminiCliAdapter } from "./claude-cli.js";
 export { createCodexCliAdapter } from "./codex-cli.js";
 export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig } from "./openai-compatible.js";
-export { createVerifierOnlyAdapter } from "./verifier-only.js";
+export { createSwarmVerifierExecutor, createVerifierOnlyAdapter } from "./verifier-only.js";
 /** @internal Test-only compatibility export. Public package builders strip this surface. */
 export { createStubAgentCliAdapter, createStubDirectProviderAdapter } from "./stub-agent-cli.js";
 export { buildCodexExecArgs, buildCodexStdin, clearCodexCapabilityCacheForTests, detectCodexHostPlatform, diagnoseCodexHost, probeCodexCapabilities, probeCodexLaunch, resolveCliCommandAvailability, checkCodexSandboxPreflight, probeFilesystemWriteCapability } from "./codex-launcher.js";
 export { createSpawnPlan } from "./cli-bridge.js";
+export { spawnSupervisedProcess } from "./process-supervisor.js";

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

@@ -134,6 +134,9 @@ function buildPrompt(request, workspaceSnapshot = "") {
     if (request.context.focus) {
         lines.push(`FOCUS: ${request.context.focus}`, ``);
     }
+    if (request.context.mutationMode === "read_only") {
+        lines.push("READ-ONLY EXECUTION. Do not propose file edits or deletions.", "Inspect the supplied workspace context and report factual findings only.", "");
+    }
     if ((request.context.acceptanceCriteria?.length ?? 0) > 0) {
         lines.push(`ACCEPTANCE CRITERIA:`, ...(request.context.acceptanceCriteria ?? []).map((criterion) => `  - ${criterion}`), ``);
     }
@@ -154,10 +157,46 @@ function buildPrompt(request, workspaceSnapshot = "") {
     }
     lines.push(`BUDGET REMAINING: $${request.context.remainingBudgetUsd.toFixed(4)} | Iterations left: ${request.context.remainingIterations}`);
     if (workspaceSnapshot) {
-        lines.push(``, `WORKSPACE SNAPSHOT (read-only context; paths are repository-relative):`, workspaceSnapshot, ``, `RESPONSE CONTRACT:`, `Return ONLY JSON with this shape:`, `{"summary":"short description","edits":[{"path":"src/file.ts","content":"complete replacement file content"}],"deletions":[]}`, `Use only repository-relative paths. Every proposed path is validated by MartinLoop before any file is written.`, `If a file should not change, omit it. Do not wrap the JSON in explanatory prose.`);
+        if (request.context.mutationMode === "read_only") {
+            lines.push(``, `WORKSPACE SNAPSHOT (read-only context; paths are repository-relative):`, workspaceSnapshot, ``, `RESPONSE CONTRACT:`, `Return a concise factual inspection summary. Do not propose edits, deletions, patches, or write commands.`);
+        }
+        else {
+            lines.push(``, `WORKSPACE SNAPSHOT (read-only context; paths are repository-relative):`, workspaceSnapshot, ``, `RESPONSE CONTRACT:`, `Return ONLY JSON with this shape:`, `{"summary":"short description","edits":[{"path":"src/file.ts","content":"complete replacement file content"}],"deletions":[]}`, `Use only repository-relative paths. Every proposed path is validated by MartinLoop before any file is written.`, `If a file should not change, omit it. Do not wrap the JSON in explanatory prose.`);
+        }
     }
     return lines.join("\n");
 }
+function abortError(message) {
+    const error = new Error(message);
+    error.name = "AbortError";
+    return error;
+}
+function waitForRetryDelay(delayMs, signal) {
+    if (signal?.aborted) {
+        return Promise.reject(abortError("OpenAI-compatible retry cancelled by parent."));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            reject(abortError("OpenAI-compatible retry cancelled by parent."));
+        };
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, delayMs);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
+    });
+}
 // ---------------------------------------------------------------------------
 // Factory
 // ---------------------------------------------------------------------------
@@ -197,6 +236,7 @@ export function createOpenAiCompatibleAdapter(options) {
         async execute(request) {
             const hasVerificationSteps = request.context.verificationPlan.length > 0 ||
                 (request.context.verificationStack?.length ?? 0) > 0;
+            const mutationMode = request.context.mutationMode ?? "edit";
             const governedCodingRun = request.context.mutationMode === "edit" ||
                 hasVerificationSteps ||
                 (request.context.allowedPaths?.length ?? 0) > 0 ||
@@ -213,6 +253,15 @@ export function createOpenAiCompatibleAdapter(options) {
             const baselineChangedFiles = hasVerificationSteps
                 ? new Set(await readGitChangedFiles(workingDirectory, 5_000))
                 : new Set();
+            const cancelledResult = () => ({
+                status: "failed",
+                summary: `${model} request cancelled by parent.`,
+                usage: normalizeUsage({ actualUsd: 0, tokensIn: 0, tokensOut: 0, provenance: "unavailable" }),
+                verification: { passed: false, summary: "Request cancelled before verifier." },
+                failure: { message: "parent_cancelled", classHint: "infrastructure_error" }
+            });
+            if (request.signal?.aborted)
+                return cancelledResult();
             // Preflight: bail if projected cost exceeds remaining budget
             if (request.context.remainingBudgetUsd > 0 &&
                 estimated.actualUsd > request.context.remainingBudgetUsd * 0.95) {
@@ -262,7 +311,19 @@ export function createOpenAiCompatibleAdapter(options) {
             let succeeded = false;
             for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
                 const controller = new AbortController();
-                const timer = setTimeout(() => controller.abort(), timeoutMs);
+                let timedOut = false;
+                const abortFromParent = () => controller.abort(request.signal?.reason);
+                if (request.signal?.aborted)
+                    abortFromParent();
+                else if (request.signal) {
+                    request.signal.addEventListener("abort", abortFromParent, { once: true });
+                    if (request.signal.aborted)
+                        abortFromParent();
+                }
+                const timer = setTimeout(() => {
+                    timedOut = true;
+                    controller.abort(abortError(`${model} request timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
                 try {
                     const res = await fetchFn(endpoint, {
                         method: "POST",
@@ -287,7 +348,14 @@ export function createOpenAiCompatibleAdapter(options) {
                         if (RETRYABLE_STATUS.has(res.status) && attempt < MAX_RETRIES - 1) {
                             lastError = errMsg;
                             // Exponential backoff: 1s, 2s, 4s
-                            await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
+                            try {
+                                await waitForRetryDelay(1000 * Math.pow(2, attempt), request.signal);
+                            }
+                            catch (error) {
+                                if (error instanceof Error && error.name === "AbortError")
+                                    return cancelledResult();
+                                throw error;
+                            }
                             continue;
                         }
                         return {
@@ -316,6 +384,8 @@ export function createOpenAiCompatibleAdapter(options) {
                 }
                 catch (error) {
                     const isAbort = error instanceof Error && error.name === "AbortError";
+                    if (request.signal?.aborted && !timedOut)
+                        return cancelledResult();
                     if (isAbort || attempt === MAX_RETRIES - 1) {
                         const message = isAbort
                             ? `${model} request timed out after ${timeoutMs}ms`
@@ -330,10 +400,18 @@ export function createOpenAiCompatibleAdapter(options) {
                     }
                     // Transient network error — retry with backoff
                     lastError = String(error);
-                    await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
+                    try {
+                        await waitForRetryDelay(1000 * Math.pow(2, attempt), request.signal);
+                    }
+                    catch (delayError) {
+                        if (delayError instanceof Error && delayError.name === "AbortError")
+                            return cancelledResult();
+                        throw delayError;
+                    }
                 }
                 finally {
                     clearTimeout(timer);
+                    request.signal?.removeEventListener("abort", abortFromParent);
                 }
             }
             if (!succeeded) {
@@ -361,7 +439,7 @@ export function createOpenAiCompatibleAdapter(options) {
                     failure: { message: "empty_response" }
                 };
             }
-            if (governedCodingRun) {
+            if (governedCodingRun && mutationMode === "edit") {
                 try {
                     await applyWorkspaceEdits({
                         workingDirectory,
@@ -392,8 +470,12 @@ export function createOpenAiCompatibleAdapter(options) {
             const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, request.context.verificationStack, undefined, {
                 runId: request.loopId,
                 workspaceId: request.workspaceId,
+                attemptId: request.attemptId,
                 cwd: workingDirectory,
-            });
+                ...(request.context.runsRoot ? { runsRoot: request.context.runsRoot } : {}),
+                ...(request.context.executionProfile ? { executionProfile: request.context.executionProfile } : {}),
+                ...(request.context.allowedNetworkDomains?.length ? { allowedNetworkDomains: [...request.context.allowedNetworkDomains] } : {}),
+            }, request.signal);
             const execution = {
                 changedFiles: hasVerificationSteps
                     ? (await readGitChangedFiles(workingDirectory, 5_000)).filter((file) => !baselineChangedFiles.has(file))

package/dist/vendor/adapters/process-supervisor.d.ts

@@ -0,0 +1,60 @@
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
+export type ProcessSpawnLike = (command: string, args?: readonly string[], options?: SpawnOptions) => ChildProcess;
+export type ProcessTreeCleanupFailureCode = "invalid_owned_pid" | "missing_test_termination_seam" | "termination_failed" | "tree_close_timeout";
+export type ProcessTreeCleanupResult = {
+    state: "not_required";
+} | {
+    state: "closed";
+} | {
+    state: "failed";
+    code: ProcessTreeCleanupFailureCode;
+    message: string;
+};
+export interface SupervisedProcessResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    completed: boolean;
+    crashed: boolean;
+    outputCapped: boolean;
+    terminationReason?: string;
+    launched: boolean;
+    cleanup: ProcessTreeCleanupResult;
+}
+export interface SpawnSupervisedProcessOptions {
+    cwd: string;
+    timeoutMs: number;
+    env?: NodeJS.ProcessEnv;
+    spawnImpl?: ProcessSpawnLike;
+    stdinData?: string;
+    maxOutputBytes?: number;
+    onStdoutChunk?: (chunk: Buffer, terminate: (reason: string) => void) => void;
+    signal?: AbortSignal;
+    terminationGraceMs?: number;
+    /** Require an owned process-tree sweep before natural completion is authoritative. */
+    requireTreeClosureOnSuccess?: boolean;
+}
+type ProcessSupervisorTestSeams = {
+    platform: "win32";
+    taskkillSpawnImpl: ProcessSpawnLike;
+    wait: (durationMs: number) => Promise<void>;
+    killProcessGroup?: never;
+} | {
+    platform: Exclude<NodeJS.Platform, "win32">;
+    killProcessGroup: (ownedGroupPid: number, signal: NodeJS.Signals | 0) => void;
+    wait: (durationMs: number) => Promise<void>;
+    taskkillSpawnImpl?: never;
+};
+export declare function spawnSupervisedProcess(command: string, args: readonly string[], options: SpawnSupervisedProcessOptions): Promise<SupervisedProcessResult>;
+/**
+ * Internal deterministic OS seam used only by this package's supervisor tests.
+ * It is intentionally absent from the adapters package root so production
+ * callers cannot exchange a caller-supplied PID for operating-system kill
+ * authority.
+ * @internal
+ */
+export declare function spawnSupervisedProcessForTest(command: string, args: readonly string[], options: SpawnSupervisedProcessOptions & {
+    spawnImpl: ProcessSpawnLike;
+}, seams: ProcessSupervisorTestSeams): Promise<SupervisedProcessResult>;
+export {};