@martinloop/mcp 0.5.3 → 0.5.5

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

@@ -1,7 +1,8 @@
 import { spawnSync } from "node:child_process";
+import { type AgentExecutionIntent } from "../contracts/index.js";
 export type CodexFlagScope = "global" | "exec";
 export type CodexPromptTransport = "stdin-dash" | "argv";
-export type CodexWriteStrategy = "sandbox+approval" | "sandbox" | "automation" | "approval" | "default";
+export type CodexWriteStrategy = "sandbox+approval" | "automation";
 export interface CodexCapabilityFlag {
     flag: string;
     scope: CodexFlagScope;
@@ -11,7 +12,14 @@ export interface CodexSandboxCapability extends CodexCapabilityFlag {
 }
 export interface CodexApprovalCapability extends CodexCapabilityFlag {
     semantics: "approval-policy" | "automation-mode";
-    value?: string;
+    values?: string[];
+}
+export interface CodexAutonomyResolution {
+    binaryPath: string;
+    intent: AgentExecutionIntent;
+    strategy: "automation" | "sandbox+approval";
+    sandboxValue?: "workspace-write";
+    approvalValue?: string;
 }
 export interface CodexCapabilityProfile {
     binaryPath: string;
@@ -32,7 +40,6 @@ export interface CodexCapabilityProfile {
     userConfigIsolation?: CodexCapabilityFlag;
     promptTransport: CodexPromptTransport;
     promptTransports?: CodexPromptTransport[];
-    selectedWriteStrategy?: CodexWriteStrategy;
 }
 export interface CodexExecArgsOptions {
     command?: string;
@@ -45,6 +52,7 @@ export interface CodexExecArgsOptions {
     capabilityProfile?: CodexCapabilityProfile;
     promptTransport?: CodexPromptTransport;
     writeStrategy?: CodexWriteStrategy;
+    autonomyResolution?: CodexAutonomyResolution;
 }
 type SpawnSyncLike = typeof spawnSync;
 export declare function clearCodexCapabilityCacheForTests(): void;
@@ -55,6 +63,7 @@ export declare function probeCodexCapabilities(binaryPath: string, options?: {
     cache?: boolean;
 }): CodexCapabilityProfile;
 export declare function codexWriteStrategies(profile: CodexCapabilityProfile): CodexWriteStrategy[];
+export declare function resolveCodexAutonomyCandidates(profile: CodexCapabilityProfile, intent?: AgentExecutionIntent): CodexAutonomyResolution[];
 export declare function buildCodexExecArgs(options: CodexExecArgsOptions): string[];
 export declare function buildCodexStdin(profile: CodexCapabilityProfile, prompt: string, transport?: CodexPromptTransport): string | undefined;
 export {};

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

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { extname } from "node:path";
 import { createSpawnPlan, resolveNpmShimScript } from "./cli-bridge.js";
+import { DEFAULT_AGENT_EXECUTION_INTENT } from "../contracts/index.js";
 const capabilityCache = new Map();
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
@@ -26,6 +27,23 @@ function flagContext(help, flag) {
         return "";
     return lines.slice(Math.max(0, index - 1), Math.min(lines.length, index + 3)).join("\n");
 }
+function parseAdvertisedValues(help, flag) {
+    const flagIndex = help.indexOf(flag);
+    if (flagIndex < 0)
+        return [];
+    const tail = help.slice(flagIndex);
+    const nextFlagOffset = tail.slice(flag.length).search(/\n\s*-/u);
+    const scoped = nextFlagOffset < 0
+        ? tail
+        : tail.slice(0, flag.length + nextFlagOffset);
+    const match = scoped.match(/possible values:\s*([^\]\n]+)/iu);
+    if (!match?.[1])
+        return [];
+    return match[1]
+        .split(",")
+        .map((value) => value.trim().replace(/[\].]$/u, ""))
+        .filter(Boolean);
+}
 function buildInjectedSpawnPlan(binaryPath, args, platform) {
     if (platform !== "win32")
         return { command: binaryPath, args };
@@ -121,8 +139,9 @@ export function probeCodexCapabilities(binaryPath, options = {}) {
     const approvalHelp = approvalFlag
         ? `${flagContext(globalHelp, approvalFlag.flag)}\n${flagContext(execHelp, approvalFlag.flag)}`
         : "";
-    const approvalPolicy = approvalFlag && /\bnever\b/iu.test(approvalHelp)
-        ? { ...approvalFlag, semantics: "approval-policy", value: "never" }
+    const approvalValues = approvalFlag ? parseAdvertisedValues(approvalHelp, approvalFlag.flag) : [];
+    const approvalPolicy = approvalFlag
+        ? { ...approvalFlag, semantics: "approval-policy", values: approvalValues }
         : undefined;
     const colorFlag = locateFlag(globalHelp, execHelp, ["--color"]);
     const colorHelp = colorFlag
@@ -174,42 +193,51 @@ function pushCapabilityArg(globalArgs, execArgs, capability, ...values) {
     (capability.scope === "global" ? globalArgs : execArgs).push(capability.flag, ...values);
 }
 export function codexWriteStrategies(profile) {
-    const strategies = [];
-    const hasWorkspaceWrite = profile.sandbox?.values.includes("workspace-write") === true;
-    if (hasWorkspaceWrite && profile.approvalPolicy?.value === "never")
-        strategies.push("sandbox+approval");
-    if (hasWorkspaceWrite)
-        strategies.push("sandbox");
-    if (profile.automation)
-        strategies.push("automation");
-    if (profile.approvalPolicy?.value === "never")
-        strategies.push("approval");
-    strategies.push("default");
-    return [...new Set(strategies)];
+    return resolveCodexAutonomyCandidates(profile).map((candidate) => candidate.strategy);
+}
+export function resolveCodexAutonomyCandidates(profile, intent = DEFAULT_AGENT_EXECUTION_INTENT) {
+    const candidates = [];
+    if (profile.automation) {
+        candidates.push({
+            binaryPath: profile.binaryPath,
+            intent,
+            strategy: "automation"
+        });
+    }
+    return candidates;
 }
 export function buildCodexExecArgs(options) {
     const profile = options.capabilityProfile ?? probeCodexCapabilities(options.command ?? "codex");
     if (!profile.supportsExec) {
         throw new Error(`Resolved Codex binary ${profile.binaryPath} does not advertise a usable exec subcommand.`);
     }
+    const resolution = options.autonomyResolution;
+    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]
+        .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.");
+    }
     const globalArgs = [];
     const execArgs = [];
     const requestedSandbox = options.sandbox ?? "workspace-write";
-    const strategy = options.writeStrategy ?? profile.selectedWriteStrategy ?? codexWriteStrategies(profile)[0] ?? "default";
+    const strategy = resolution?.strategy ?? options.writeStrategy;
     const promptTransport = options.promptTransport ?? profile.promptTransport;
     if (profile.userConfigIsolation)
         pushCapabilityArg(globalArgs, execArgs, profile.userConfigIsolation);
     if (profile.cwd)
         pushCapabilityArg(globalArgs, execArgs, profile.cwd, options.workingDirectory);
     if (requestedSandbox === "workspace-write") {
-        if ((strategy === "sandbox" || strategy === "sandbox+approval") && profile.sandbox?.values.includes("workspace-write")) {
+        if (strategy === "sandbox+approval" && profile.sandbox?.values.includes("workspace-write")) {
             pushCapabilityArg(globalArgs, execArgs, profile.sandbox, "workspace-write");
         }
         if (strategy === "automation" && profile.automation) {
             pushCapabilityArg(globalArgs, execArgs, profile.automation);
         }
-        if ((strategy === "approval" || strategy === "sandbox+approval") && profile.approvalPolicy?.value) {
-            pushCapabilityArg(globalArgs, execArgs, profile.approvalPolicy, profile.approvalPolicy.value);
+        if (strategy === "sandbox+approval" && profile.approvalPolicy && resolution?.approvalValue) {
+            pushCapabilityArg(globalArgs, execArgs, profile.approvalPolicy, resolution.approvalValue);
         }
     }
     else {

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

@@ -1,5 +1,5 @@
 import { type CodexCliAdapterOptions as LegacyCodexCliAdapterOptions } from "./claude-cli.js";
-import { type CodexCapabilityProfile } from "./codex-launcher.js";
+import { type CodexAutonomyResolution, type CodexCapabilityProfile } from "./codex-launcher.js";
 export interface CodexCliAdapterOptions extends Omit<LegacyCodexCliAdapterOptions, "command"> {
     /** Exact resolved executable selected by the Codex launch probe. */
     command?: string;
@@ -9,6 +9,7 @@ export interface CodexCliAdapterOptions extends Omit<LegacyCodexCliAdapterOption
      * for the process lifetime. Exposed for deterministic integrations/tests.
      */
     capabilityProfile?: CodexCapabilityProfile;
+    autonomyResolution?: CodexAutonomyResolution;
 }
 /**
  * Capability-driven Codex CLI adapter.

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

@@ -24,8 +24,15 @@ function createCodexSpawnRouter(input) {
  */
 export function createCodexCliAdapter(options = {}) {
     const workingDirectory = options.workingDirectory ?? process.cwd();
-    const selectedBinary = options.command ?? "codex";
+    const selectedBinary = options.command ?? options.capabilityProfile?.binaryPath ?? "codex";
     const capabilityProfile = options.capabilityProfile ?? probeCodexCapabilities(selectedBinary);
+    const autonomyResolution = options.autonomyResolution;
+    if (capabilityProfile.binaryPath !== selectedBinary) {
+        throw new Error("Codex exact binary capability profile mismatch.");
+    }
+    if (autonomyResolution && autonomyResolution.binaryPath !== selectedBinary) {
+        throw new Error("Codex exact binary autonomy resolution mismatch.");
+    }
     const sandbox = options.sandbox ?? "workspace-write";
     const extraArgs = options.extraArgs ?? [];
     const launchModel = options.model;
@@ -44,6 +51,8 @@ export function createCodexCliAdapter(options = {}) {
         label: options.label ?? "Codex CLI adapter",
         workingDirectory,
         timeoutMs: options.timeoutMs,
+        agentExecutionIntent: options.agentExecutionIntent,
+        providerExecutionTimeoutMs: options.providerExecutionTimeoutMs,
         verifyTimeoutMs: options.verifyTimeoutMs,
         supportsJsonOutput: false,
         spawnImpl,
@@ -55,7 +64,8 @@ export function createCodexCliAdapter(options = {}) {
             extraArgs,
             mode: "prompt",
             prompt,
-            capabilityProfile
+            capabilityProfile,
+            ...(autonomyResolution ? { autonomyResolution } : {})
         }),
         stdinBuilder: (prompt) => buildCodexStdin(capabilityProfile, prompt)
     });

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

@@ -1,5 +1,5 @@
 import { spawnSync } from "node:child_process";
-import { type CodexCapabilityProfile, type CodexPromptTransport, type CodexWriteStrategy } from "./codex-capabilities.js";
+import { type CodexAutonomyResolution, type CodexCapabilityProfile, type CodexPromptTransport, type CodexWriteStrategy } from "./codex-capabilities.js";
 export interface CliCommandAvailability {
     command: string;
     available: boolean;
@@ -37,6 +37,7 @@ export interface CodexProbeCandidateResult {
     nativeDependencyPackage?: string;
     capabilityProfile?: CodexCapabilityProfile;
     writeStrategy?: CodexWriteStrategy;
+    autonomyResolution?: CodexAutonomyResolution;
     promptTransport?: CodexPromptTransport;
 }
 export interface CodexLaunchProbeResult {
@@ -48,6 +49,7 @@ export interface CodexLaunchProbeResult {
     args: string[];
     capabilityProfile?: CodexCapabilityProfile;
     writeStrategy?: CodexWriteStrategy;
+    autonomyResolution?: CodexAutonomyResolution;
     promptTransport?: CodexPromptTransport;
     exitCode?: number;
     stdout?: string;
@@ -100,5 +102,6 @@ export declare function probeCodexLaunch(input: {
     platform?: NodeJS.Platform;
     spawnSyncImpl?: SpawnSyncLike;
     model?: string;
+    providerExecutionTimeoutMs?: number;
 }): CodexLaunchProbeResult;
 export {};

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

@@ -1,8 +1,10 @@
 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 { tmpdir } from "node:os";
+import { normalizeProviderExecutionTimeoutMs } from "../contracts/index.js";
 import { createSpawnPlan, resolveNpmShimScript } from "./cli-bridge.js";
-import { buildCodexExecArgs, buildCodexStdin, cacheCodexCapabilityProfile, codexWriteStrategies, probeCodexCapabilities } from "./codex-capabilities.js";
+import { buildCodexExecArgs, buildCodexStdin, cacheCodexCapabilityProfile, probeCodexCapabilities, resolveCodexAutonomyCandidates } from "./codex-capabilities.js";
 const launchProbeCache = new Map();
 export function probeFilesystemWriteCapability(directory) {
     try {
@@ -304,12 +306,15 @@ function buildInjectedSpawnPlan(binaryPath, args, platform) {
     }
     return { command: binaryPath, args, invocationMode: "direct" };
 }
-function buildMarkerPrompt(marker) {
+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.",
-        "Use the shell command executor exactly once.",
+        "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."
@@ -372,6 +377,7 @@ 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,
@@ -425,13 +431,15 @@ export function probeCodexLaunch(input) {
             continue;
         }
         const transports = profile.promptTransports?.length ? profile.promptTransports : [profile.promptTransport];
-        const strategies = codexWriteStrategies(profile);
+        const resolutions = resolveCodexAutonomyCandidates(profile);
         let candidateSummary = "No advertised Codex invocation strategy proved writable execution.";
-        for (const strategy of strategies) {
+        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);
-                const prompt = buildMarkerPrompt(marker);
+                const outsideRoot = mkdtempSync(join(tmpdir(), "martin-codex-outside-probe-"));
+                const outsideMarkerPath = join(outsideRoot, ".martin-codex-outside-probe.tmp");
+                const prompt = buildMarkerPrompt(marker, outsideMarkerPath);
                 let args;
                 try {
                     args = buildCodexExecArgs({
@@ -443,10 +451,12 @@ export function probeCodexLaunch(input) {
                         prompt,
                         capabilityProfile: profile,
                         promptTransport: transport,
-                        writeStrategy: strategy
+                        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;
@@ -459,11 +469,14 @@ export function probeCodexLaunch(input) {
                     cwd: input.workingDirectory,
                     encoding: "utf8",
                     stdio: [stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
-                    ...(stdin !== undefined ? { input: stdin } : {})
+                    ...(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 {
@@ -472,9 +485,10 @@ export function probeCodexLaunch(input) {
                     catch {
                         // best effort cleanup
                     }
+                    rmSync(outsideRoot, { recursive: true, force: true });
                 }
-                if (!result.error && result.status === 0 && markerVerified) {
-                    const negotiated = cacheCodexCapabilityProfile({ ...profile, selectedWriteStrategy: strategy, promptTransport: transport }, platform);
+                if (!result.error && result.status === 0 && markerVerified && outsideDenied) {
+                    const negotiated = cacheCodexCapabilityProfile({ ...profile, promptTransport: transport }, platform);
                     selected = {
                         candidate: {
                             ...candidate,
@@ -482,7 +496,7 @@ export function probeCodexLaunch(input) {
                         },
                         profile: negotiated,
                         args,
-                        strategy,
+                        resolution,
                         transport,
                         ...(result.status === null ? {} : { exitCode: result.status }),
                         stdout: result.stdout ?? "",
@@ -495,9 +509,10 @@ export function probeCodexLaunch(input) {
                         nativeInstallValid: true,
                         sandboxCompatible: true,
                         launchReady: true,
-                        summary: `Codex capability negotiation passed with ${strategy} / ${transport}.`,
+                        summary: `Codex capability negotiation passed with ${resolution.strategy} / ${transport}.`,
                         capabilityProfile: negotiated,
-                        writeStrategy: strategy,
+                        writeStrategy: resolution.strategy,
+                        autonomyResolution: resolution,
                         promptTransport: transport
                     });
                     break candidateLoop;
@@ -507,7 +522,9 @@ export function probeCodexLaunch(input) {
                     ? `Codex launch probe failed: ${result.error.message}`
                     : result.status !== 0
                         ? `Codex launch probe exited non-zero: ${(result.stderr ?? result.stdout ?? "").trim() || String(result.status)}`
-                        : `Codex ${strategy} / ${transport} invocation did not prove workspace writes.`;
+                        : !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,
@@ -534,13 +551,14 @@ export function probeCodexLaunch(input) {
     if (selected) {
         const result = {
             ok: true,
-            summary: `Codex capability-driven workspace-write probe passed using ${selected.strategy} / ${selected.transport}.`,
+            summary: `Codex capability-driven workspace-write 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,
             args: selected.args,
             capabilityProfile: selected.profile,
-            writeStrategy: selected.strategy,
+            writeStrategy: selected.resolution.strategy,
+            autonomyResolution: selected.resolution,
             promptTransport: selected.transport,
             ...(selected.exitCode === undefined ? {} : { exitCode: selected.exitCode }),
             ...(selected.stdout === undefined ? {} : { stdout: selected.stdout }),

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

@@ -6,5 +6,5 @@ import { type CodexExecArgsOptions } from "./codex-capabilities.js";
  * builder without restoring any hard-coded flag assumption.
  */
 export declare function buildCodexExecArgs(options: CodexExecArgsOptions): string[];
-export { buildCodexStdin, cacheCodexCapabilityProfile, clearCodexCapabilityCacheForTests, codexWriteStrategies, probeCodexCapabilities, type CodexApprovalCapability, type CodexCapabilityFlag, type CodexCapabilityProfile, type CodexExecArgsOptions, type CodexFlagScope, type CodexPromptTransport, type CodexSandboxCapability, type CodexWriteStrategy } from "./codex-capabilities.js";
+export { buildCodexStdin, cacheCodexCapabilityProfile, clearCodexCapabilityCacheForTests, codexWriteStrategies, probeCodexCapabilities, resolveCodexAutonomyCandidates, type CodexAutonomyResolution, type CodexApprovalCapability, type CodexCapabilityFlag, type CodexCapabilityProfile, type CodexExecArgsOptions, type CodexFlagScope, type CodexPromptTransport, type CodexSandboxCapability, type CodexWriteStrategy } from "./codex-capabilities.js";
 export { checkCodexSandboxPreflight, detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, probeFilesystemWriteCapability, resolveCliCommandAvailability, type CliCommandAvailability, type CodexHostDiagnosis, type CodexHostPlatform, type CodexInstallKind, type CodexInvocationMode, type CodexLaunchProbeResult, type CodexProbeCandidateResult, type CodexSandboxPreflightOk, type CodexSandboxPreflightOutcome, type CodexSandboxPreflightReadOnly } from "./codex-host.js";

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

@@ -18,5 +18,5 @@ export function buildCodexExecArgs(options) {
         capabilityProfile: normalizedProfile
     });
 }
-export { buildCodexStdin, cacheCodexCapabilityProfile, clearCodexCapabilityCacheForTests, codexWriteStrategies, probeCodexCapabilities } from "./codex-capabilities.js";
+export { buildCodexStdin, cacheCodexCapabilityProfile, clearCodexCapabilityCacheForTests, codexWriteStrategies, probeCodexCapabilities, resolveCodexAutonomyCandidates } from "./codex-capabilities.js";
 export { checkCodexSandboxPreflight, detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, probeFilesystemWriteCapability, resolveCliCommandAvailability } from "./codex-host.js";

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

@@ -3,5 +3,6 @@ export { createAgentCliAdapter, createClaudeCliAdapter, createGeminiCliAdapter,
 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 { buildCodexExecArgs, buildCodexStdin, clearCodexCapabilityCacheForTests, detectCodexHostPlatform, diagnoseCodexHost, probeCodexCapabilities, probeCodexLaunch, resolveCliCommandAvailability, type CliCommandAvailability, type CodexApprovalCapability, 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";
+/** @internal Test-only compatibility export. Public package builders strip this surface. */
+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";

package/dist/vendor/adapters/index.js

@@ -3,5 +3,6 @@ export { createAgentCliAdapter, createClaudeCliAdapter, createGeminiCliAdapter }
 export { createCodexCliAdapter } from "./codex-cli.js";
 export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig } from "./openai-compatible.js";
 export { createVerifierOnlyAdapter } from "./verifier-only.js";
+/** @internal Test-only compatibility export. Public package builders strip this surface. */
 export { buildCodexExecArgs, buildCodexStdin, clearCodexCapabilityCacheForTests, detectCodexHostPlatform, diagnoseCodexHost, probeCodexCapabilities, probeCodexLaunch, resolveCliCommandAvailability, checkCodexSandboxPreflight, probeFilesystemWriteCapability } from "./codex-launcher.js";
 export { createSpawnPlan } from "./cli-bridge.js";

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

@@ -0,0 +1,9 @@
+export declare const DEFAULT_AGENT_EXECUTION_INTENT: "governed-autonomous";
+export type AgentExecutionIntent = typeof DEFAULT_AGENT_EXECUTION_INTENT;
+/** Provider-neutral safety boundary every governed-autonomous adapter must honor. */
+export declare const GOVERNED_AUTONOMOUS_BOUNDARY: {
+    readonly interaction: "non-interactive";
+    readonly writeScope: "workspace-only";
+};
+export declare const DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS = 300000;
+export declare function normalizeProviderExecutionTimeoutMs(value: number | undefined): number;

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

@@ -0,0 +1,14 @@
+export const DEFAULT_AGENT_EXECUTION_INTENT = "governed-autonomous";
+/** Provider-neutral safety boundary every governed-autonomous adapter must honor. */
+export const GOVERNED_AUTONOMOUS_BOUNDARY = {
+    interaction: "non-interactive",
+    writeScope: "workspace-only"
+};
+export const DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS = 300_000;
+export function normalizeProviderExecutionTimeoutMs(value) {
+    const resolved = value ?? DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS;
+    if (!Number.isFinite(resolved) || resolved <= 0) {
+        throw new Error("providerExecutionTimeoutMs must be a positive finite number.");
+    }
+    return resolved;
+}

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

@@ -8,6 +8,9 @@
  * portfolio snapshots and routing economics.
  */
 import type { TerminationEnvelopeV1 } from "./exits.js";
+import type { AgentExecutionIntent } from "./agent-execution.js";
+export { DEFAULT_AGENT_EXECUTION_INTENT, DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS, GOVERNED_AUTONOMOUS_BOUNDARY, normalizeProviderExecutionTimeoutMs } from "./agent-execution.js";
+export type { AgentExecutionIntent } from "./agent-execution.js";
 export type LoopStatus = "queued" | "running" | "verifying" | "completed" | "failed" | "exited";
 export type LoopLifecycleState = "created" | "running" | "verifying" | "completed" | "budget_exit" | "diminishing_returns" | "stuck_exit" | "human_escalation" | "wall_clock" | "error_threshold" | "external_event";
 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"];
@@ -27,6 +30,10 @@ export interface LoopTask {
     executionProfile?: ExecutionProfile;
     allowedNetworkDomains?: string[];
     approvalPolicy?: ApprovalPolicy;
+    /** Provider-neutral execution posture. Defaults to governed autonomous execution. */
+    agentExecutionIntent?: AgentExecutionIntent;
+    /** Hard wall-clock limit for one provider coding process. */
+    providerExecutionTimeoutMs?: number;
     /** Glob patterns for files the agent is allowed to modify. Empty = no restriction. */
     allowedPaths?: string[];
     /** Glob patterns for files the agent must never modify. */
@@ -103,6 +110,8 @@ export interface ReceiptScope {
     writableRoot?: string;
     /** How the effective sandbox was determined. */
     capabilitySource?: "probe" | "configured" | "unknown";
+    agentExecutionIntent?: AgentExecutionIntent;
+    providerExecutionTimeoutMs?: number;
     /** Enforced demo changes (DEMO.md-only enforcement output). */
     demoChangedFiles?: string[];
 }

package/dist/vendor/contracts/index.js

@@ -7,6 +7,7 @@
  * creating and managing loop records, handling events, validating batches, and tracking
  * portfolio snapshots and routing economics.
  */
+export { DEFAULT_AGENT_EXECUTION_INTENT, DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS, GOVERNED_AUTONOMOUS_BOUNDARY, normalizeProviderExecutionTimeoutMs } from "./agent-execution.js";
 export const FAILURE_CLASSES = [
     "logic_error",
     "hallucination",

package/dist/vendor/core/grounding.js

@@ -196,7 +196,14 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
     const indexedPaths = new Set(index.files.map((file) => file.path));
     const indexedSymbols = new Set(index.files.flatMap((file) => file.symbols.map((symbol) => symbol.toLowerCase())));
     const referencedFiles = new Set();
+    const addedFiles = new Set();
     const diffFilePattern = /^(?:---|\+\+\+)\s+[ab]\/(.+)$/gm;
+    const addedFilePattern = /^---\s+\/dev\/null\r?\n\+\+\+\s+b\/(.+)$/gm;
+    for (const match of diff.matchAll(addedFilePattern)) {
+        const filePath = match[1]?.trim();
+        if (filePath)
+            addedFiles.add(filePath);
+    }
     for (const match of diff.matchAll(diffFilePattern)) {
         const filePath = match[1]?.trim();
         if (filePath && filePath !== "/dev/null") {
@@ -204,7 +211,7 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
         }
     }
     for (const filePath of referencedFiles) {
-        if (indexedPaths.has(filePath)) {
+        if (indexedPaths.has(filePath) || addedFiles.has(filePath)) {
             resolvedFiles.push(filePath);
         }
         else {
@@ -227,7 +234,7 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
     }
     const addedLinePattern = /^\+(?!\+\+)(.+)$/gm;
     const importPattern = /(?:import|require)\s*(?:.*\s+from\s+)?['"]([^'"]+)['"]/g;
-    const identifierPattern = /\b([A-Za-z_][A-Za-z0-9_]{2,})\b/g;
+    const callableIdentifierPattern = /(?<!\.)\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
     const symbolKeywords = new Set([
         "const",
         "let",
@@ -244,10 +251,33 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
         "true",
         "false",
         "null",
-        "undefined"
+        "undefined",
+        "if",
+        "for",
+        "while",
+        "switch",
+        "catch",
+        "typeof"
     ]);
-    for (const lineMatch of diff.matchAll(addedLinePattern)) {
-        const line = lineMatch[1] ?? "";
+    const addedLines = [...diff.matchAll(addedLinePattern)].map((match) => match[1] ?? "");
+    const declaredSymbols = new Set();
+    const declarationPattern = /\b(?:function|class|interface|type|enum|const|let|var)\s+([A-Za-z_][A-Za-z0-9_]*)/g;
+    for (const line of addedLines) {
+        for (const declarationMatch of line.matchAll(declarationPattern)) {
+            const symbol = declarationMatch[1];
+            if (symbol)
+                declaredSymbols.add(symbol.toLowerCase());
+        }
+        if (/^\s*import\b/u.test(line)) {
+            const importClause = line.match(/^\s*import\s+(.+?)\s+from\s+['"]/u)?.[1] ?? "";
+            for (const importSymbol of importClause.matchAll(/\b(?:as\s+)?([A-Za-z_][A-Za-z0-9_]*)\b/g)) {
+                const symbol = importSymbol[1];
+                if (symbol && symbol !== "as")
+                    declaredSymbols.add(symbol.toLowerCase());
+            }
+        }
+    }
+    for (const line of addedLines) {
         for (const importMatch of line.matchAll(importPattern)) {
             const reference = importMatch[1] ?? "";
             if (!reference.startsWith(".") && !reference.startsWith("/")) {
@@ -259,6 +289,9 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
             const hasMatch = index.files.some((file) => {
                 const withoutExt = file.path.replace(/\.(js|ts|tsx|jsx)$/, "");
                 return withoutExt.endsWith(normalized) || withoutExt.includes(normalized);
+            }) || [...addedFiles].some((filePath) => {
+                const withoutExt = filePath.replace(/\.(js|ts|tsx|jsx)$/, "");
+                return withoutExt.endsWith(normalized) || withoutExt.includes(normalized);
             });
             if (!hasMatch) {
                 violations.push({
@@ -268,13 +301,15 @@ export function scanPatchForGroundingViolations(diff, index, options = {}) {
                 });
             }
         }
-        for (const symbolMatch of line.matchAll(identifierPattern)) {
+        for (const symbolMatch of line.matchAll(callableIdentifierPattern)) {
             const symbol = symbolMatch[1];
             if (!symbol)
                 continue;
             if (symbolKeywords.has(symbol))
                 continue;
-            if (symbol.toUpperCase() === symbol)
+            if (/^[A-Z]/u.test(symbol))
+                continue;
+            if (declaredSymbols.has(symbol.toLowerCase()))
                 continue;
             if (indexedSymbols.has(symbol.toLowerCase()))
                 continue;

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

@@ -1,4 +1,4 @@
-import { type ApprovalPolicy, type ContextHandoffReceipt, type CostProvenance, type ExecutionProfile, type FailureClass, type InterventionType, type LoopArtifact, type LoopAttempt, type LoopBudget, type ProviderUsageSettlement, type MutationMode, type LoopRecord, type LoopTask, type ReceiptScope } from "../contracts/index.js";
+import { type ApprovalPolicy, type AgentExecutionIntent, type ContextHandoffReceipt, type CostProvenance, type ExecutionProfile, type FailureClass, type InterventionType, type LoopArtifact, type LoopAttempt, type LoopBudget, type ProviderUsageSettlement, type MutationMode, type LoopRecord, type LoopTask, type ReceiptScope } from "../contracts/index.js";
 import { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, type ExitDecision } from "./policy.js";
 import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLeash, redactSecretsFromText, resolveExecutionProfile, evaluateVerificationLeash } from "./leash.js";
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
@@ -7,7 +7,8 @@ import { type RunStore } from "./persistence/index.js";
 import { type ExitPolicyOverrides } from "./exits.js";
 import { type ExitSignalSource } from "./exit-signal.js";
 import { type VerifierExecutionBinding } from "./verified-handoff.js";
-export type { ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, MutationMode, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase, CallStage, AgentRole, FirstDelta, RoutingEconomics } from "../contracts/index.js";
+export type { AgentExecutionIntent, ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, MutationMode, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase, CallStage, AgentRole, FirstDelta, RoutingEconomics } from "../contracts/index.js";
+export { DEFAULT_AGENT_EXECUTION_INTENT, DEFAULT_PROVIDER_EXECUTION_TIMEOUT_MS, GOVERNED_AUTONOMOUS_BOUNDARY, normalizeProviderExecutionTimeoutMs } from "../contracts/index.js";
 export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary };
 export type { BudgetPreflightDecision, BudgetPreflightInput, CostGovernorState, EvidenceVectorInput, EvaluatedPatchDecision, ExitDecision, FailureAssessment, PatchDecisionInput, RecoveryDecision, RecoveryRecipe } from "./policy.js";
 export type { ResolvedExecutionProfile, SafetyLeashDecision, SafetyViolation } from "./leash.js";
@@ -69,6 +70,8 @@ export interface MartinAdapterRequest {
         executionProfile?: ExecutionProfile;
         allowedNetworkDomains?: string[];
         approvalPolicy?: ApprovalPolicy;
+        agentExecutionIntent?: AgentExecutionIntent;
+        providerExecutionTimeoutMs?: number;
         focus: string;
         remainingBudgetUsd: number;
         remainingIterations: number;