@martinloop/mcp 0.3.4 → 0.3.6

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

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { delimiter, dirname, extname, isAbsolute, join, resolve } from "node:path";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { diffStatsFromNumstat } from "./runtime-support.js";
 const gitRepositoryRootCache = new Map();
 export async function runSubprocess(command, args, options) {
@@ -236,6 +236,36 @@ export async function readGitChangedFiles(repoRoot, timeoutMs, spawnImpl) {
     }
     return parsePorcelainEntries(statusResult.stdout).filter((entry) => typeof entry === "string" && entry.length > 0);
 }
+// Ignore paths that are not meaningful code changes for first-delta detection
+const FIRST_DELTA_IGNORE = [
+    /^\.martin\//u,
+    /^PROGRESS\.md$/u,
+    /\.lock$/u,
+    /^node_modules\//u,
+    /^\.git\//u,
+    /^\.cache\//u,
+];
+/**
+ * Detects whether a meaningful workspace delta has occurred by checking
+ * git status for changed files that aren't MartinLoop metadata, lockfiles,
+ * or cache artifacts. Returns the first meaningful changed file if found.
+ */
+export async function detectFirstDelta(repoRoot, timeoutMs, spawnImpl) {
+    const changedFiles = await readGitChangedFiles(repoRoot, timeoutMs, spawnImpl);
+    for (const file of changedFiles) {
+        if (FIRST_DELTA_IGNORE.some((pattern) => pattern.test(file))) {
+            continue;
+        }
+        // Classify: new file = create, deleted = delete, else modify
+        const diffResult = await runSubprocess("git", ["status", "--porcelain", "--", file], { cwd: repoRoot, timeoutMs: 3000, spawnImpl });
+        const status = diffResult.stdout.trim().slice(0, 2);
+        const changeType = status.includes("?") ? "create"
+            : status.includes("D") ? "delete"
+                : "modify";
+        return { detected: true, filePath: file, changeType };
+    }
+    return { detected: false };
+}
 export function resolveGitRepositoryRoot(workingDirectory) {
     const resolvedWorkingDirectory = resolve(workingDirectory);
     const cached = gitRepositoryRootCache.get(resolvedWorkingDirectory);
@@ -289,20 +319,106 @@ export function createSpawnPlan(command, args, cwd, preserveRawForInjectedSpawn)
         };
     }
     const extension = extname(resolvedOrUndefined).toLowerCase();
-    if (extension === ".cmd" || extension === ".bat") {
+    if (extension === ".cmd" || extension === ".bat" || extension === ".ps1") {
+        // npm-installed CLIs resolve to a generated shim on Windows. Wrapping that shim through an
+        // extra cmd.exe/powershell.exe hop adds a process layer that can lose the OS-level
+        // workspace-write sandbox permission when the whole tree is already nested inside another
+        // restricted parent process (e.g. VS Code's extension host), even though the same shim works
+        // fine from a top-level PowerShell window. When we can statically resolve the shim's real
+        // wrapped `node <script>` target, invoke that directly instead — this removes the extra hop
+        // for every Windows launch, nested or not, with no behavior change when resolution fails.
+        const directScript = resolveNpmShimScript(resolvedOrUndefined);
+        if (directScript !== undefined) {
+            // Use the system node rather than process.execPath. When MartinLoop runs
+            // inside Claude Code desktop or VS Code, process.execPath is Electron's
+            // bundled Node — which has different module resolution and may fail to
+            // load native CLI scripts. Prefer an explicit `node` from PATH instead.
+            const systemNode = resolveSystemNode();
+            return { command: systemNode, args: [directScript, ...args] };
+        }
+        if (extension === ".ps1") {
+            return {
+                command: "powershell.exe",
+                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", resolvedOrUndefined, ...args]
+            };
+        }
         return {
             command: process.env.ComSpec || "cmd.exe",
             args: ["/d", "/c", resolvedOrUndefined, ...args]
         };
     }
-    if (extension === ".ps1") {
-        return {
-            command: "powershell.exe",
-            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", resolvedOrUndefined, ...args]
-        };
-    }
     return { command: resolvedOrUndefined, args };
 }
+/**
+ * npm generates Windows shims (.cmd/.ps1, occasionally .bat) that ultimately just exec
+ * `node <real-cli-script>.js <args>` relative to the shim's own directory. Parse the shim text to
+ * find that real script path and return it if it resolves to a file that actually exists on disk;
+ * otherwise return undefined so callers fall back to the existing wrapper-shell behavior unchanged.
+ */
+export function resolveNpmShimScript(shimPath) {
+    let contents;
+    try {
+        contents = readFileSync(shimPath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const shimDir = dirname(shimPath);
+    const scriptPathPattern = /["']?(?:%~?dp0%?|\$basedir)[\\/]([^"'\s]+\.[cm]?js)["']?/gi;
+    const matches = contents.matchAll(scriptPathPattern);
+    for (const match of matches) {
+        const relativeScript = match[1];
+        if (!relativeScript) {
+            continue;
+        }
+        const segments = relativeScript.split(/[\\/]+/u).filter(Boolean);
+        const resolvedScript = resolve(shimDir, ...segments);
+        if (existsSync(resolvedScript)) {
+            return resolvedScript;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve a reliable `node` executable for spawning CLI scripts on Windows.
+ *
+ * When MartinLoop runs inside Claude Code desktop, VS Code, or the Codex IDE,
+ * `process.execPath` points to the host application's bundled Electron Node —
+ * not the system Node. Electron's Node has different module resolution paths
+ * and may fail to load native npm CLI scripts that expect the system Node.
+ *
+ * Strategy:
+ * 1. Use MARTIN_NODE_PATH env var if explicitly set (escape hatch for CI)
+ * 2. Look for `node` / `node.exe` on PATH — the system install
+ * 3. Fall back to process.execPath (Electron Node) if nothing else found
+ */
+function resolveSystemNode() {
+    // Explicit override — useful in CI or restricted environments
+    const envOverride = process.env.MARTIN_NODE_PATH?.trim();
+    if (envOverride && envOverride.length > 0 && existsSync(envOverride)) {
+        return envOverride;
+    }
+    // Search PATH for a real `node` executable, skipping Electron binaries.
+    // Electron's node path typically contains "electron" or "Claude" in it.
+    for (const dir of windowsPathDirectories()) {
+        for (const candidate of ["node.exe", "node.cmd", "node"]) {
+            const fullPath = join(dir, candidate);
+            if (existsSync(fullPath) && !isElectronNode(fullPath)) {
+                return fullPath;
+            }
+        }
+    }
+    // Last resort: use process.execPath even if it's Electron's node
+    return process.execPath;
+}
+function isElectronNode(nodePath) {
+    const lower = nodePath.toLowerCase();
+    return (lower.includes("electron") ||
+        lower.includes("claude") ||
+        lower.includes("vscode") ||
+        lower.includes("code.exe") ||
+        lower.includes("cursor"));
+}
 function resolveWindowsCommand(command, cwd) {
     const hasPathSegment = command.includes("\\") || command.includes("/");
     const baseCandidates = expandWindowsCommandCandidates(hasPathSegment ? resolve(cwd, command) : command);

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

@@ -43,6 +43,7 @@ export interface CodexExecArgsOptions {
     mode?: "prompt" | "probe";
 }
 type SpawnSyncLike = typeof spawnSync;
+export declare const DEFAULT_CODEX_CHATGPT_MODEL = "gpt-5.4";
 export interface CodexProbeCandidateResult {
     path: string;
     installKind: CodexInstallKind;
@@ -72,5 +73,6 @@ export declare function probeCodexLaunch(input: {
     env?: NodeJS.ProcessEnv;
     platform?: NodeJS.Platform;
     spawnSyncImpl?: SpawnSyncLike;
+    model?: string;
 }): CodexLaunchProbeResult;
 export {};

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

@@ -1,7 +1,9 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, statSync } 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";
 const CODEX_LAUNCH_PROBE_PROMPT = [
     "You are validating MartinLoop Codex host readiness.",
     "Do not edit files.",
@@ -14,7 +16,8 @@ function buildProbeCacheKey(input) {
     return JSON.stringify({
         workingDirectory: resolve(input.workingDirectory),
         platform: input.platform,
-        candidatePaths: input.candidatePaths
+        candidatePaths: input.candidatePaths,
+        model: input.model ?? DEFAULT_CODEX_CHATGPT_MODEL
     });
 }
 function isInsideGitRepository(workingDirectory) {
@@ -119,17 +122,27 @@ function buildProbeCommand(command, args, platform) {
     switch (extension) {
         case ".cmd":
         case ".bat":
+        case ".ps1": {
+            // Bypass the npm shim's cmd.exe/powershell.exe wrapper hop when we can statically resolve
+            // the real `node <script>` target it wraps — keeps the live probe's process-nesting depth
+            // consistent with the real run's invocation (see createSpawnPlan in cli-bridge.ts).
+            const directScript = resolveNpmShimScript(command);
+            if (directScript !== undefined) {
+                return { command: process.execPath, args: [directScript, ...args], invocationMode: "direct" };
+            }
+            if (extension === ".ps1") {
+                return {
+                    command: "powershell.exe",
+                    args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", command, ...args],
+                    invocationMode: "powershell"
+                };
+            }
             return {
                 command: process.env.ComSpec || "cmd.exe",
                 args: ["/d", "/c", command, ...args],
                 invocationMode: "cmd_shell"
             };
-        case ".ps1":
-            return {
-                command: "powershell.exe",
-                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", command, ...args],
-                invocationMode: "powershell"
-            };
+        }
         default:
             return { command, args, invocationMode: "direct" };
     }
@@ -167,6 +180,39 @@ function detectInvocationMode(resolvedPath, platform) {
 }
 function classifyProbeFailure(stderr, stdout, diagnosis) {
     const combined = `${stderr}\n${stdout}`;
+    if (/MARTIN_REMOTE_TOKEN/iu.test(combined) ||
+        /AuthRequired\(AuthRequiredError/iu.test(combined) ||
+        /www_authenticate_header/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const configCollisionWarning = "Codex inherited auth-sensitive MCP or plugin state from the operator's default user config.";
+        if (!warnings.includes(configCollisionWarning)) {
+            warnings.push(configCollisionWarning);
+        }
+        return {
+            summary: "Codex inherited auth-sensitive MCP or plugin state from the operator's default user config. Governed Codex runs should launch with `exec --ignore-user-config` so missing remote tokens or third-party auth do not abort MartinLoop work.",
+            diagnosis: {
+                ...diagnosis,
+                warnings,
+                remediation: "Retry the governed Codex launch with `exec --ignore-user-config`, or remove auth-sensitive MCP/plugin dependencies from the default Codex user config before running MartinLoop."
+            }
+        };
+    }
+    if (/not supported when using Codex with a ChatGPT account/iu.test(combined) ||
+        /gpt-5\.3-codex/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const unsupportedModelWarning = "Codex tried to use a model that is not supported for ChatGPT-account authentication.";
+        if (!warnings.includes(unsupportedModelWarning)) {
+            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.`,
+            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.`
+            }
+        };
+    }
     if (/@openai\/codex-linux-x64/iu.test(combined) ||
         /cannot find module ['"]@openai\/codex-linux-x64['"]/iu.test(combined)) {
         const warnings = [...diagnosis.warnings];
@@ -201,7 +247,25 @@ function classifyProbeFailure(stderr, stdout, diagnosis) {
                 ...diagnosis,
                 sandboxCompatible: false,
                 warnings,
-                remediation: "Update or reinstall Codex on this Windows host until `codex exec --sandbox workspace-write` can launch a simple shell command before running governed Codex work."
+                remediation: "MartinLoop already invokes Codex's underlying binary directly when it can resolve the npm shim (bypassing the cmd.exe/PowerShell wrapper hop), so this failure persisted even at the shallowest invocation depth available. Update or reinstall Codex on this Windows host until `codex exec --sandbox workspace-write` can launch a simple shell command before running governed Codex work."
+            }
+        };
+    }
+    if (/writing is blocked by read-only sandbox/iu.test(combined) ||
+        /read-only filesystem sandbox/iu.test(combined) ||
+        /approval is disabled/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const readOnlySandboxWarning = "Codex stayed in a read-only or approval-disabled sandbox even though MartinLoop requested workspace-write.";
+        if (!warnings.includes(readOnlySandboxWarning)) {
+            warnings.push(readOnlySandboxWarning);
+        }
+        return {
+            summary: "Codex stayed in a read-only or approval-disabled sandbox even though MartinLoop requested workspace-write.",
+            diagnosis: {
+                ...diagnosis,
+                sandboxCompatible: false,
+                warnings,
+                remediation: "Launch governed Codex runs with `codex exec --ignore-user-config --sandbox workspace-write`. If the session still reports a read-only sandbox, treat it as a host/runtime mismatch and repair or relocate the affected Codex workspace before resuming governed work."
             }
         };
     }
@@ -213,6 +277,8 @@ export function buildCodexExecArgs(options) {
     const extraArgs = options.extraArgs ?? [];
     return [
         "exec",
+        // Governed MartinLoop runs should not inherit auth-sensitive default MCP/plugin state.
+        "--ignore-user-config",
         "--cd",
         options.workingDirectory,
         "--sandbox",
@@ -396,6 +462,7 @@ export function probeCodexLaunch(input) {
     });
     const args = buildCodexExecArgs({
         workingDirectory: input.workingDirectory,
+        model: input.model ?? DEFAULT_CODEX_CHATGPT_MODEL,
         mode: "probe"
     });
     if (!availability.available) {
@@ -431,7 +498,8 @@ export function probeCodexLaunch(input) {
     const cacheKey = buildProbeCacheKey({
         workingDirectory: input.workingDirectory,
         platform,
-        candidatePaths
+        candidatePaths,
+        model: input.model
     });
     if (input.spawnSyncImpl === undefined) {
         const cached = codexLaunchProbeCache.get(cacheKey);

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

@@ -72,12 +72,12 @@ function estimateCost(model, inputChars, outputChars) {
 // ---------------------------------------------------------------------------
 // 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";
@@ -166,70 +166,103 @@ export function createOpenAiCompatibleAdapter(options) {
                     failure: { message: "budget_preflight_exceeded", classHint: "budget_pressure" }
                 };
             }
-            // Call the OpenAI-compatible endpoint
+            // Call the OpenAI-compatible endpoint with exponential-backoff retry on
+            // transient failures (429 rate-limit, 503/5xx server errors, network errors).
+            // Auth errors (401/403) and bad-request errors (400) are not retried — they
+            // indicate a permanent configuration problem.
+            const MAX_RETRIES = 3;
+            const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
             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" }
-                    };
+            const headers = { "Content-Type": "application/json" };
+            if (apiKey)
+                headers["Authorization"] = `Bearer ${apiKey}`;
+            if (baseUrl.includes("openrouter")) {
+                headers["HTTP-Referer"] = "https://martinloop.com";
+                headers["X-Title"] = "MartinLoop";
+            }
+            const requestBody = JSON.stringify({
+                model,
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: prompt }
+                ],
+                temperature: 0.2,
+                max_tokens: 8192
+            });
+            let lastError = "";
+            let succeeded = false;
+            for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), timeoutMs);
+                try {
+                    const res = await fetchFn(endpoint, {
+                        method: "POST",
+                        headers,
+                        body: requestBody,
+                        signal: controller.signal
+                    });
+                    const body = (await res.json());
+                    if (!res.ok || body.error) {
+                        const errMsg = body.error?.message ?? `HTTP ${res.status}`;
+                        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)));
+                            continue;
+                        }
+                        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);
+                    }
+                    succeeded = true;
+                    break;
                 }
-                responseText = body.choices?.[0]?.message?.content ?? "";
-                if (body.usage) {
-                    tokensIn = body.usage.prompt_tokens ?? tokensIn;
-                    tokensOut = body.usage.completion_tokens ?? 0;
+                catch (error) {
+                    const isAbort = error instanceof Error && error.name === "AbortError";
+                    if (isAbort || attempt === MAX_RETRIES - 1) {
+                        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" }
+                        };
+                    }
+                    // Transient network error — retry with backoff
+                    lastError = String(error);
+                    await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
                 }
-                else {
-                    tokensOut = Math.ceil(responseText.length / CHARS_PER_TOKEN);
+                finally {
+                    clearTimeout(timer);
                 }
             }
-            catch (error) {
-                const isAbort = error instanceof Error && error.name === "AbortError";
-                const message = isAbort ? `${model} request timed out after ${timeoutMs}ms` : String(error);
+            if (!succeeded) {
                 return {
                     status: "failed",
-                    summary: message,
+                    summary: `${model} API error after ${MAX_RETRIES} attempts: ${lastError}`,
                     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" }
+                    verification: { passed: false, summary: "API call failed after retries." },
+                    failure: { message: lastError, classHint: "infrastructure_error" }
                 };
             }
-            finally {
-                clearTimeout(timer);
-            }
             if (!responseText.trim()) {
                 return {
                     status: "failed",

package/dist/vendor/contracts/execution-policy.d.ts

@@ -59,4 +59,20 @@ export interface ExecutionPolicyCompileInput {
     config?: ExecutionPolicyConfigInput;
     request: ExecutionPolicyRequestInput;
 }
+export type RoutingMode = "direct" | "manager" | "adaptive" | "consensus";
+export interface RoutingPolicy {
+    enabled: boolean;
+    mode: RoutingMode;
+    /** Max percentage of total budget that can be spent before first code change. */
+    maxPreworkBudgetPct: number;
+    /** Hard dollar cap on pre-work spend. */
+    maxPreworkCostUsd: number;
+    /** Max model calls allowed for manager/router/planner before worker starts. */
+    maxManagerCalls: number;
+    /** Skip orchestration entirely if task confidence is above this threshold (0-1). */
+    skipOrchestrationIfConfidenceAbove: number;
+    /** Force direct execution for tasks classified as simple. */
+    requireDirectForSimpleTasks: boolean;
+}
+export declare const DEFAULT_ROUTING_POLICY: RoutingPolicy;
 export declare function cloneExecutionPolicy(policy: ExecutionPolicy): ExecutionPolicy;

package/dist/vendor/contracts/execution-policy.js

@@ -1,3 +1,12 @@
+export const DEFAULT_ROUTING_POLICY = {
+    enabled: true,
+    mode: "adaptive",
+    maxPreworkBudgetPct: 25,
+    maxPreworkCostUsd: 2.0,
+    maxManagerCalls: 2,
+    skipOrchestrationIfConfidenceAbove: 0.85,
+    requireDirectForSimpleTasks: true
+};
 export function cloneExecutionPolicy(policy) {
     return {
         configPath: policy.configPath,

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

@@ -1,6 +1,6 @@
 export type LoopStatus = "queued" | "running" | "verifying" | "completed" | "failed" | "exited";
 export type LoopLifecycleState = "created" | "running" | "verifying" | "completed" | "budget_exit" | "diminishing_returns" | "stuck_exit" | "human_escalation";
-export declare const FAILURE_CLASSES: readonly ["logic_error", "hallucination", "syntax_error", "type_error", "test_regression", "scope_creep", "no_progress", "repo_grounding_failure", "verification_failure", "environment_mismatch", "budget_pressure", "safety_leash_blocked"];
+export declare const FAILURE_CLASSES: readonly ["logic_error", "hallucination", "syntax_error", "type_error", "test_regression", "scope_creep", "no_progress", "repo_grounding_failure", "verification_failure", "environment_mismatch", "budget_pressure", "safety_leash_blocked", "sandbox_write_blocked"];
 export type FailureClass = (typeof FAILURE_CLASSES)[number];
 export type InterventionType = "compress_context" | "change_model" | "tighten_task" | "switch_adapter" | "run_verifier" | "escalate_human" | "stop_loop";
 export type LoopEventType = "run.started" | "attempt.started" | "attempt.completed" | "failure.classified" | "intervention.selected" | "verification.completed" | "budget.updated" | "run.completed";
@@ -92,6 +92,29 @@ export interface LoopArtifact {
     label: string;
     uri: string;
 }
+export type CallStage = "routing" | "planning" | "execution" | "verification" | "retry" | "rollback" | "receipt";
+export type AgentRole = "manager" | "router" | "planner" | "worker" | "verifier" | "reviewer" | "fixer" | "system";
+export interface FirstDelta {
+    detected: boolean;
+    timestampMs?: number;
+    filePath?: string;
+    changeType?: "create" | "modify" | "delete" | "patch_proposed";
+    /** Elapsed ms from run start to first meaningful workspace change. */
+    timeToFirstDeltaMs?: number;
+}
+export interface RoutingEconomics {
+    preworkCostUsd: number;
+    executionCostUsd: number;
+    verificationCostUsd: number;
+    retryCostUsd: number;
+    totalCostUsd: number;
+    preworkBurnPct: number;
+    timeToFirstDeltaMs?: number;
+    firstDelta?: FirstDelta;
+    costPerAcceptedChange?: number;
+    routeRecommendation?: "same_route" | "direct_worker" | "manager_required" | "consensus_required";
+    routeRecommendationReason?: string;
+}
 export interface LoopAttempt {
     attemptId: string;
     index: number;
@@ -104,6 +127,8 @@ export interface LoopAttempt {
     intervention?: InterventionType;
     /** Actionable diagnosis from failure classification, injected into the next attempt's prompt. */
     diagnosticHint?: string;
+    /** Which stage of the run lifecycle this attempt represents. */
+    callStage?: CallStage;
 }
 export interface LoopEvent {
     eventId: string;
@@ -130,6 +155,7 @@ export interface LoopRecord {
     updatedAt: string;
     receiptScope?: ReceiptScope;
     receiptIntegrity?: ReceiptIntegritySummary;
+    routingEconomics?: RoutingEconomics;
 }
 export interface LoopRecordDraft {
     loopId?: string;
@@ -376,7 +402,8 @@ export interface RollbackOutcomeArtifact {
 export { createGovernanceSnapshot } from "./governance.js";
 export type { DestructiveActionPolicy, GovernanceSnapshot, PolicyProfile, TelemetryDestination } from "./governance.js";
 export { cloneExecutionPolicy } from "./execution-policy.js";
-export type { ExecutionPolicy, ExecutionPolicyCompileInput, ExecutionPolicyConfigInput, ExecutionPolicyDefaults, ExecutionPolicyProvenanceEntry, ExecutionPolicyRequestInput } from "./execution-policy.js";
+export type { ExecutionPolicy, ExecutionPolicyCompileInput, ExecutionPolicyConfigInput, ExecutionPolicyDefaults, ExecutionPolicyProvenanceEntry, ExecutionPolicyRequestInput, RoutingPolicy, RoutingMode } from "./execution-policy.js";
+export { DEFAULT_ROUTING_POLICY } from "./execution-policy.js";
 export { cloneContextGraphSnapshot } from "./context-graph.js";
 export type { ContextGraphBuildOptions, ContextGraphEdge, ContextGraphHit, ContextGraphNode, ContextGraphNodeKind, ContextGraphSnapshot, ContextQuery } from "./context-graph.js";
 export { cloneIdentityAttestation, cloneIdentityClaims, cloneIdentityToken } from "./identity.js";

package/dist/vendor/contracts/index.js

@@ -11,6 +11,7 @@ export const FAILURE_CLASSES = [
     "environment_mismatch",
     "budget_pressure",
     "safety_leash_blocked",
+    "sandbox_write_blocked",
 ];
 export { MARTIN_ERROR_CATEGORIES } from "./operator.js";
 export const DEFAULT_BUDGET = {
@@ -218,6 +219,7 @@ function hasText(value) {
 }
 export { createGovernanceSnapshot } from "./governance.js";
 export { cloneExecutionPolicy } from "./execution-policy.js";
+export { DEFAULT_ROUTING_POLICY } from "./execution-policy.js";
 export { cloneContextGraphSnapshot } from "./context-graph.js";
 export { cloneIdentityAttestation, cloneIdentityClaims, cloneIdentityToken } from "./identity.js";
 export { cloneCircuitBreakDecision, cloneTrajectoryAssessment } from "./trajectory.js";