@opengeni/runtime 4.3.0 → 4.4.0-canary.36927100590001

package/dist/{chunk-JUFVYQCY.js → chunk-VDXKKMMD.js}

@@ -396,9 +396,9 @@ function stdoutFromExecResult(value) {
 function execFailureDiagnostic(value) {
   if (!value || typeof value !== "object") return "result=unstructured";
   const result = value;
-  const status2 = typeof result.exitCode === "number" ? `exitCode=${result.exitCode}` : typeof result.status === "number" ? `status=${result.status}` : "exitCode=unknown";
+  const status4 = typeof result.exitCode === "number" ? `exitCode=${result.exitCode}` : typeof result.status === "number" ? `status=${result.status}` : "exitCode=unknown";
   const stderr = typeof result.stderr === "string" ? result.stderr.replace(/\s+/g, " ").trim().slice(0, 240) : "";
-  return stderr.length > 0 ? `${status2}, stderr=${stderr}` : status2;
+  return stderr.length > 0 ? `${status4}, stderr=${stderr}` : status4;
 }
 function isTransientRootDirectoryFingerprintRace(value) {
   if (!value || typeof value !== "object") return false;
@@ -1822,12 +1822,12 @@ async function persistRemoteWorkspaceTar(args) {
     if (error instanceof SandboxArchiveError) {
       throw error;
     }
-    throw new SandboxArchiveError(`${args.providerName} failed to persist the workspace archive.`, {
+    throw Object.assign(new SandboxArchiveError(`${args.providerName} failed to persist the workspace archive.`, {
       provider: args.providerName,
       root,
       archivePath,
       cause: error instanceof Error ? error.message : String(error)
-    });
+    }), { cause: error });
   } finally {
     await args.io.runCommand(`rm -f -- ${shellQuote(archivePath)}`).catch(() => {
     });
@@ -1869,12 +1869,12 @@ async function hydrateRemoteWorkspaceTar(args) {
     if (error instanceof SandboxArchiveError) {
       throw error;
     }
-    throw new SandboxArchiveError(`${args.providerName} failed to hydrate the workspace archive.`, {
+    throw Object.assign(new SandboxArchiveError(`${args.providerName} failed to hydrate the workspace archive.`, {
       provider: args.providerName,
       root,
       archivePath,
       cause: error instanceof Error ? error.message : String(error)
-    });
+    }), { cause: error });
   } finally {
     await args.io.runCommand(`rm -f -- ${shellQuote(archivePath)}`).catch(() => {
     });
@@ -2751,7 +2751,7 @@ async function closeRemoteSessionOnManifestError(providerName, session, manifest
   try {
     await session.close();
   } catch (closeError) {
-    throw new UserError(`Failed to apply a ${providerName} sandbox manifest and close the sandbox. Manifest error: ${providerErrorMessage(manifestError)} Close error: ${providerErrorMessage(closeError)}`);
+    throw Object.assign(new UserError(`Failed to apply a ${providerName} sandbox manifest and close the sandbox. Manifest error: ${providerErrorMessage(manifestError)} Close error: ${providerErrorMessage(closeError)}`), { cause: new AggregateError([manifestError, closeError], "Sandbox manifest application and close both failed") });
   }
   throw manifestError;
 }
@@ -2780,14 +2780,14 @@ async function withProviderError(providerName, provider, operation, fn, context
     }
     const cause = providerErrorMessage(error);
     const retryable = providerErrorRetryability(error);
-    throw new SandboxProviderError(`${providerName} failed to ${operation}${cause ? `: ${cause}` : ""}`, {
+    throw Object.assign(new SandboxProviderError(`${providerName} failed to ${operation}${cause ? `: ${cause}` : ""}`, {
       provider,
       operation,
       ...context,
       ...providerErrorDetails(error),
       retryable,
       cause
-    });
+    }), { cause: error });
   }
 }
 function isProviderSandboxNotFoundError(error) {
@@ -2887,9 +2887,9 @@ function readProviderErrorRetryability(value, seen, depth) {
   if (typed !== null) {
     return typed;
   }
-  const status2 = readProviderStatus(value);
-  if (status2 !== void 0) {
-    const retryable = retryabilityForHttpStatus(status2);
+  const status4 = readProviderStatus(value);
+  if (status4 !== void 0) {
+    const retryable = retryabilityForHttpStatus(status4);
     if (retryable !== null) {
       return retryable;
     }
@@ -2948,21 +2948,21 @@ function retryabilityForErrorType(value) {
 }
 function readProviderStatus(value) {
   for (const key of ["status", "statusCode", "httpStatus", "httpStatusCode"]) {
-    const status2 = value[key];
-    if (typeof status2 === "number" && Number.isInteger(status2)) {
-      return status2;
+    const status4 = value[key];
+    if (typeof status4 === "number" && Number.isInteger(status4)) {
+      return status4;
     }
-    if (typeof status2 === "string" && /^\d+$/u.test(status2)) {
-      return Number(status2);
+    if (typeof status4 === "string" && /^\d+$/u.test(status4)) {
+      return Number(status4);
     }
   }
   return void 0;
 }
-function retryabilityForHttpStatus(status2) {
-  if ([408, 425, 429, 500, 502, 503, 504].includes(status2)) {
+function retryabilityForHttpStatus(status4) {
+  if ([408, 425, 429, 500, 502, 503, 504].includes(status4)) {
     return true;
   }
-  if ([400, 401, 403, 404, 409, 422].includes(status2)) {
+  if ([400, 401, 403, 404, 409, 422].includes(status4)) {
     return false;
   }
   return null;
@@ -5689,8 +5689,8 @@ function generateBlaxelSandboxName() {
   return `openai-agents-${Math.random().toString(16).slice(2, 10)}`;
 }
 function isBlaxelSandboxNonResumable(sandbox) {
-  const status2 = sandbox.status?.trim().toUpperCase();
-  return status2 ? BLAXEL_NON_RESUMABLE_SANDBOX_STATUSES.has(status2) : false;
+  const status4 = sandbox.status?.trim().toUpperCase();
+  return status4 ? BLAXEL_NON_RESUMABLE_SANDBOX_STATUSES.has(status4) : false;
 }
 function assertBlaxelSandboxReusable(sandbox, sandboxName) {
   if (!isBlaxelSandboxNonResumable(sandbox)) {
@@ -7216,11 +7216,11 @@ async function cloudflareProviderHttpErrorWithBody(operation, response, context
     ...cause ? { cause } : {}
   });
 }
-function cloudflareRetryabilityForStatus(status2) {
-  if (status2 === 500 || status2 === 503) {
+function cloudflareRetryabilityForStatus(status4) {
+  if (status4 === 500 || status4 === 503) {
     return true;
   }
-  if (status2 === 400) {
+  if (status4 === 400) {
     return false;
   }
   return null;
@@ -14339,9 +14339,9 @@ var ModalSandboxSession = class {
             stderr += chunk;
           });
           try {
-            const status2 = await process2.wait();
+            const status4 = await process2.wait();
             await stderrPump.promise;
-            return { status: status2, stderr };
+            return { status: status4, stderr };
           } catch (error) {
             await stderrPump.cancel();
             throw error;
@@ -15966,22 +15966,22 @@ function parseExecResponseBanner(raw) {
   }
   if (delimiter.index > EXEC_BANNER_HEADER_MAX_CHARS) return { kind: "invalid" };
   const header = raw.slice(0, delimiter.index);
-  const status2 = [];
+  const status4 = [];
   for (const line of header.split(/\r?\n/u)) {
     const running = RUNNING_LINE.exec(line);
     if (running) {
-      status2.push({ kind: "running", value: running[1] });
+      status4.push({ kind: "running", value: running[1] });
       continue;
     }
     const exited = EXITED_LINE.exec(line);
     if (exited) {
-      status2.push({ kind: "exited", value: exited[1] });
+      status4.push({ kind: "exited", value: exited[1] });
       continue;
     }
     if (PROCESS_STATUS_PREFIX.test(line)) return { kind: "invalid" };
   }
-  if (status2.length !== 1) return { kind: "invalid" };
-  const terminal = status2[0];
+  if (status4.length !== 1) return { kind: "invalid" };
+  const terminal = status4[0];
   const value = Number(terminal.value);
   if (!Number.isSafeInteger(value)) return { kind: "invalid" };
   if (terminal.kind === "running") {
@@ -16049,6 +16049,26 @@ import { SandboxFilesystemNotFoundError } from "modal";
 import { Client, Metadata, credentials, status } from "@grpc/grpc-js";
 import protobuf from "protobufjs";
 
+// src/sandbox/providers/modal-command-start-errors.ts
+var boundaryBrand = Symbol.for("opengeni.modal.command-start.boundary.v1");
+function hasModalCommandStartBoundary(error, kind) {
+  if (!error || typeof error !== "object") return false;
+  try {
+    return Object.getOwnPropertyDescriptor(error, boundaryBrand)?.value === kind;
+  } catch {
+    return false;
+  }
+}
+var ModalCommandStartOutcomeUnknownError = class extends Error {
+  constructor(taskId, execId, cause) {
+    super("Modal command Start outcome unknown; do not replay this invocation", { cause });
+    this.taskId = taskId;
+    this.execId = execId;
+    this.name = "CommandStartOutcomeUnknownError";
+    Object.defineProperty(this, boundaryBrand, { value: "outcome-unknown" });
+  }
+};
+
 // src/sandbox/provider-command-session.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 var ProviderCommandStartRejectedError = class extends Error {
@@ -16057,6 +16077,13 @@ var ProviderCommandStartRejectedError = class extends Error {
     this.name = "ProviderCommandStartRejectedError";
   }
 };
+var ProviderCommandStartOutcomeUnknownError = class extends Error {
+  constructor(command, cause) {
+    super("Provider command Start outcome is unknown; the invocation was not replayed", { cause });
+    this.command = command;
+    this.name = "ProviderCommandStartOutcomeUnknownError";
+  }
+};
 var admission = new AsyncLocalStorage2();
 var pendingSupervision = new AsyncLocalStorage2();
 function withPendingCommandSupervision(state, fn) {
@@ -16133,6 +16160,20 @@ var ModalCommandStartPreDispatchUnavailableError = class _ModalCommandStartPreDi
     super("Modal command router was not ready before Start dispatch", { cause });
     this.name = "ModalCommandStartPreDispatchUnavailableError";
   }
+  /** The supplied operation must contain only read-only preparation, never
+   * Start itself. Its transport failure therefore proves non-dispatch. */
+  static async beforeDispatch(operation, signal) {
+    signal?.throwIfAborted();
+    try {
+      return await operation();
+    } catch (error) {
+      signal?.throwIfAborted();
+      const code = error?.code;
+      if (error instanceof Error && (code === status.UNAVAILABLE || code === status.DEADLINE_EXCEEDED))
+        throw new _ModalCommandStartPreDispatchUnavailableError(error);
+      throw error;
+    }
+  }
   static async ensureReady(client, signal) {
     signal?.throwIfAborted();
     await new Promise((resolve7, reject) => {
@@ -16152,6 +16193,14 @@ var ModalCommandStartPreDispatchUnavailableError = class _ModalCommandStartPreDi
     });
   }
 };
+var ModalCommandStartNotDispatchedError = class extends Error {
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : "Modal command Start was never dispatched", {
+      cause
+    });
+    this.name = "ModalCommandStartNotDispatchedError";
+  }
+};
 function encode(type, value) {
   const codec = modalRouterWire.lookupType(type);
   return Buffer.from(codec.encode(codec.fromObject(value)).finish());
@@ -16209,12 +16258,18 @@ var ModalCommandRouterWire = class {
     });
   }
   async start(request, signal) {
-    if (this.closed) throw new Error("Modal command router is closed");
     try {
+      if (this.closed) throw new Error("Modal command router is closed");
       await ModalCommandStartPreDispatchUnavailableError.ensureReady(this.client, signal);
+      signal?.throwIfAborted();
+      if (this.closed) throw new Error("Modal command router is closed");
     } catch (error) {
-      if (this.closed) throw new Error("Modal command router is closed", { cause: error });
-      throw error;
+      if (this.closed)
+        throw new ModalCommandStartNotDispatchedError(
+          new Error("Modal command router is closed", { cause: error })
+        );
+      if (error instanceof ModalCommandStartPreDispatchUnavailableError) throw error;
+      throw new ModalCommandStartNotDispatchedError(error);
     }
     try {
       await this.unary(
@@ -16238,7 +16293,7 @@ var ModalCommandRouterWire = class {
         status.UNIMPLEMENTED
       ].includes(code))
         throw new ModalCommandStartRejectedError(code, error);
-      throw error;
+      throw new ModalCommandStartOutcomeUnknownError(request.taskId, request.execId, error);
     }
   }
   async write(identity, offset, data, signal) {
@@ -16881,6 +16936,10 @@ var RoutingRetainedProcessNotFoundError = class extends Error {
   name = "RoutingRetainedProcessNotFoundError";
   retryable = false;
 };
+function renderRoutingMutationOutcomeUnknownToolResult(error) {
+  const locator = error.retainedProcess ? ` Inspect the exact invocation with write_stdin using session_id ${error.retainedProcess.providerSessionId} and empty chars.` : " Inspect state before deciding how to proceed.";
+  return `Sandbox operation outcome unknown; the operation was not replayed. Do not blindly retry the command.${locator} Error: ${error}`;
+}
 function isFenceError(error) {
   if (!error || typeof error !== "object") {
     return false;
@@ -17249,7 +17308,8 @@ var RoutingSandboxSession = class {
         { cause: error }
       );
     }
-    await this.captureRetainedOutput(record, formatExecResult(pending.result));
+    if (pending.result !== void 0)
+      await this.captureRetainedOutput(record, formatExecResult(pending.result));
   }
   confirmDurableRejectedPromotion(record, result) {
     if (result.status !== "retained_process_durable_output_rejected" || result.retainedProcess.id !== record.process.id || result.retainedProcess.providerSessionId !== record.process.providerSessionId) {
@@ -17788,8 +17848,43 @@ var RoutingSandboxSession = class {
           );
         }
       } catch (error) {
+        if (!reservedProcess && error instanceof ProviderCommandStartOutcomeUnknownError && mutatesWorkspace && this.deps.afterMutation) {
+          const handle = this.deps.providerCommandHandle?.(admission2);
+          if (!handle) throw error;
+          const process2 = {
+            id: crypto.randomUUID(),
+            providerSessionId: handle,
+            providerCommand: error.command
+          };
+          const record = this.registerRetainedProcess(process2, backend);
+          const settlement = {
+            op,
+            backend,
+            admission: admission2,
+            outcome: "outcome_unknown",
+            retainedProcess: process2
+          };
+          record.pendingParentPromotion = settlement;
+          try {
+            const rejected = await this.deps.afterMutation(settlement);
+            if (rejected) this.confirmDurableRejectedPromotion(record, rejected);
+            else record.durable = true;
+            record.pendingParentPromotion = null;
+          } catch (cause) {
+            throw new RoutingMutationOutcomeUnknownError(
+              op,
+              "Command Start outcome is unknown and exact invocation promotion remains unresolved; it was not replayed",
+              { cause: new AggregateError([error, cause]), retainedProcess: process2 }
+            );
+          }
+          throw new RoutingMutationOutcomeUnknownError(
+            op,
+            "Command Start outcome is unknown; its exact invocation is retained and was not replayed",
+            { cause: error, retainedProcess: process2 }
+          );
+        }
         if (reservedProcess) {
-          if ((error instanceof ProviderCommandStartRejectedError || error instanceof ModalCommandStartPreDispatchUnavailableError) && reservedProcess.providerCommand?.kind === "modal-router-v1") {
+          if ((error instanceof ProviderCommandStartRejectedError || error instanceof ModalCommandStartNotDispatchedError || error instanceof ModalCommandStartPreDispatchUnavailableError) && reservedProcess.providerCommand?.kind === "modal-router-v1") {
             const persistence = this.deps.providerCommandPersistence?.(reservedProcess);
             if (persistence?.rejectSupervisedLaunch) {
               try {
@@ -18549,20 +18644,20 @@ async function assertProviderCanSeeMaterializedPath(session, path) {
       causeMessage: cause instanceof Error ? cause.message : String(cause)
     });
   }
-  const status2 = parseExecResponseBanner(output);
+  const status4 = parseExecResponseBanner(output);
   const markerPresent = stripExecBanner(output).includes(MATERIALIZED_PATH_MARKER);
-  if (markerPresent && (status2.kind === "absent" || status2.kind === "exited" && status2.exitCode === 0)) {
+  if (markerPresent && (status4.kind === "absent" || status4.kind === "exited" && status4.exitCode === 0)) {
     return;
   }
-  const reason = status2.kind === "running" ? "command_pending" : status2.kind === "exited" && status2.exitCode === 1 ? "path_not_visible" : status2.kind === "exited" && status2.exitCode !== 0 ? "command_failed" : "invalid_response";
+  const reason = status4.kind === "running" ? "command_pending" : status4.kind === "exited" && status4.exitCode === 1 ? "path_not_visible" : status4.kind === "exited" && status4.exitCode !== 0 ? "command_failed" : "invalid_response";
   throw new SandboxMaterializationVerificationError({
     reason,
     path,
     workdir: args.workdir,
     command,
     output,
-    exitCode: status2.kind === "exited" ? status2.exitCode : null,
-    providerSessionId: status2.kind === "running" ? status2.sessionId : null
+    exitCode: status4.kind === "exited" ? status4.exitCode : null,
+    providerSessionId: status4.kind === "running" ? status4.sessionId : null
   });
 }
 function providerManifestRoot(session) {
@@ -19022,6 +19117,8 @@ Output:
     }
   } catch {
   }
+  if (error instanceof RoutingMutationOutcomeUnknownError)
+    return renderRoutingMutationOutcomeUnknownToolResult(error);
   const details = error instanceof Error ? error.toString() : String(error);
   return `An error occurred while running the tool. Please try again. Error: ${details}`;
 }
@@ -19475,6 +19572,8 @@ var TurnToolCancellationControllerImpl = class {
               });
             }
             pendingStart?.settle();
+            if (error instanceof RoutingMutationOutcomeUnknownError)
+              return renderRoutingMutationOutcomeUnknownToolResult(error);
             throw error;
           } finally {
             remoteExec?.settle();
@@ -21656,19 +21755,19 @@ var SandboxChannelAService = class {
   }
   async gitStatus(req) {
     const repo = assertSafeRelPathOrRoot(req.path, this.workspaceRoot);
-    const status2 = await this.readConfinedCommandBytes(
+    const status4 = await this.readConfinedCommandBytes(
       repo,
       `if [ "$(git rev-parse --is-inside-work-tree 2>/dev/null)" = true ]; then printf '${GIT_STATUS_REPO_FRAME}\\0'; git status --porcelain=v2 --branch -z; else printf '${GIT_STATUS_REPO_FRAME}not-repo\\0'; fi`,
       GIT_METADATA_MAX_BYTES
     );
-    if (status2.truncated) {
+    if (status4.truncated) {
       throw new ChannelAUnavailableError(
         "Workspace Git metadata exceeded the safe capture limit. Retry with a narrower path."
       );
     }
     const repoFrame = Buffer.from(`${GIT_STATUS_REPO_FRAME}${NUL}`);
     const notRepoFrame = Buffer.from(`${GIT_STATUS_REPO_FRAME}not-repo${NUL}`);
-    if (status2.bytes.equals(notRepoFrame)) {
+    if (status4.bytes.equals(notRepoFrame)) {
       return {
         isRepo: false,
         head: null,
@@ -21681,13 +21780,13 @@ var SandboxChannelAService = class {
         revision: this.revision
       };
     }
-    if (!status2.bytes.subarray(0, repoFrame.byteLength).equals(repoFrame)) {
+    if (!status4.bytes.subarray(0, repoFrame.byteLength).equals(repoFrame)) {
       throw new ChannelAUnavailableError(
         "Workspace Git data is temporarily unavailable. Retry the operation."
       );
     }
     return {
-      ...parsePorcelainV2(decodeGitMetadataUtf8(status2.bytes.subarray(repoFrame.byteLength))),
+      ...parsePorcelainV2(decodeGitMetadataUtf8(status4.bytes.subarray(repoFrame.byteLength))),
       revision: this.revision
     };
   }
@@ -22072,11 +22171,11 @@ var SandboxChannelAService = class {
       });
       const statusLine = stdout.split("\n").find((line) => line.startsWith(REPOSITORY_DISCOVERY_STATUS_PREFIX));
       const embeddedStatus = statusLine ? Number.parseInt(statusLine.slice(REPOSITORY_DISCOVERY_STATUS_PREFIX.length), 10) : null;
-      const status2 = Number.isInteger(embeddedStatus) ? embeddedStatus : null;
-      if (status2 === 124) {
+      const status4 = Number.isInteger(embeddedStatus) ? embeddedStatus : null;
+      if (status4 === 124) {
         return { repos: [], complete: false, degradedReason: "command_timed_out" };
       }
-      if (status2 !== 0) {
+      if (status4 !== 0) {
         return { repos: [], complete: false, degradedReason: "command_failed" };
       }
       const lines = stdout.split("\n").map((l) => l.trim()).filter((line) => Boolean(line) && !line.startsWith(REPOSITORY_DISCOVERY_STATUS_PREFIX));
@@ -22645,13 +22744,13 @@ var SandboxChannelAService = class {
    *  worker agent-turn side after FS-mutating tools). */
   async emitGitChanged(repoPath, reason) {
     try {
-      const status2 = await this.gitStatus({ path: repoPath });
+      const status4 = await this.gitStatus({ path: repoPath });
       const payload = {
-        head: status2.head,
-        dirty: status2.files.length > 0,
-        ahead: status2.ahead,
-        behind: status2.behind,
-        changedFileCount: status2.files.length,
+        head: status4.head,
+        dirty: status4.files.length > 0,
+        ahead: status4.ahead,
+        behind: status4.behind,
+        changedFileCount: status4.files.length,
         reason,
         revision: this.revision,
         leaseEpoch: this.leaseEpoch
@@ -23142,14 +23241,14 @@ function splitUnifiedPatchFiles(patch) {
 function parseUnifiedPatch(patch) {
   const lines = patch.split("\n");
   const hunks = [];
-  let status2 = "modified";
+  let status4 = "modified";
   let current = null;
   let oldNo = 0;
   let newNo = 0;
   for (const line of lines) {
-    if (line.startsWith("new file mode")) status2 = "added";
-    else if (line.startsWith("deleted file mode")) status2 = "deleted";
-    else if (line.startsWith("rename from") || line.startsWith("rename to")) status2 = "renamed";
+    if (line.startsWith("new file mode")) status4 = "added";
+    else if (line.startsWith("deleted file mode")) status4 = "deleted";
+    else if (line.startsWith("rename from") || line.startsWith("rename to")) status4 = "renamed";
     if (line.startsWith("@@")) {
       const m = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/);
       if (m) {
@@ -23187,7 +23286,7 @@ function parseUnifiedPatch(patch) {
       newNo++;
     }
   }
-  return { hunks, status: status2 };
+  return { hunks, status: status4 };
 }
 
 // src/sandbox/providers/modal-command-session.ts
@@ -23295,6 +23394,24 @@ function installModalCommandSession(session, control) {
   const originalWrite = session.writeStdin?.bind(session);
   const cancelLegacyStart = session.cancelPendingExecCommand?.bind(session);
   const pendingStarts = /* @__PURE__ */ new Set();
+  if (control.verifyExecReadiness) {
+    const verify = control.verifyExecReadiness.bind(control);
+    session.verifyExecReadiness = async (signal) => {
+      const cancellation = new AbortController();
+      const abort = () => cancellation.abort(signal.reason);
+      signal.addEventListener("abort", abort, { once: true });
+      if (signal.aborted) abort();
+      pendingStarts.add(cancellation);
+      try {
+        const exit = await verify(cancellation.signal);
+        cancellation.signal.throwIfAborted();
+        return exit;
+      } finally {
+        signal.removeEventListener("abort", abort);
+        pendingStarts.delete(cancellation);
+      }
+    };
+  }
   session.verifyCommandSupervisionCapability = async () => {
     if (!control.verifySupervisionCapability)
       throw new Error("Modal instance lacks supervised command capability verification");
@@ -23429,6 +23546,16 @@ function installModalCommandSession(session, control) {
           exitCode: null
         });
       }
+    } catch (error) {
+      if (error instanceof ProviderCommandStartOutcomeUnknownError) {
+        const entry = entries.get(handle);
+        if (entry && !sameExecution(entry.command, error.command))
+          throw new Error("Reserved Modal command changed during failed dispatch", {
+            cause: error
+          });
+        entries.set(handle, entry ?? { command: error.command });
+      }
+      throw error;
     } finally {
       pendingStarts.delete(cancellation);
     }
@@ -23542,6 +23669,8 @@ function installModalCommandSession(session, control) {
 // src/sandbox/providers/modal-command-control.ts
 import { randomUUID as randomUUID6, randomBytes } from "crypto";
 import { posix as posix3 } from "path";
+import { status as status3 } from "@grpc/grpc-js";
+import { setTimeout as delay2 } from "timers/promises";
 import {
   SandboxProviderCommand,
   CommandSupervisionReceipt
@@ -23550,6 +23679,7 @@ import {
 // src/sandbox/providers/modal-legacy-command-control.ts
 import { posix as posix2 } from "path";
 import { ModalClient } from "modal";
+import { status as status2 } from "@grpc/grpc-js";
 import { ModalLegacyProviderCommand } from "@opengeni/contracts";
 var modalCommandAbortMiddleware = async function* (call, options) {
   options.signal?.throwIfAborted();
@@ -23626,7 +23756,10 @@ var ModalCommandControl = class _ModalCommandControl {
     if (workdir !== this.root && !workdir.startsWith(`${this.root.replace(/\/$/u, "")}/`))
       throw new Error("Command workdir is outside the sandbox workspace");
     const sandboxId = this.sandboxId;
-    const task = await this.client.sandboxGetTaskId({ sandboxId }, signal ? { signal } : void 0);
+    const task = await ModalCommandStartPreDispatchUnavailableError.beforeDispatch(
+      () => this.client.sandboxGetTaskId({ sandboxId }, signal ? { signal } : void 0),
+      signal
+    );
     if (!task.taskId || task.taskResult) throw new Error("Modal command task is unavailable");
     if (sandboxId !== this.sandboxId)
       throw new Error("Modal sandbox changed during command preparation");
@@ -23672,8 +23805,24 @@ var ModalCommandControl = class _ModalCommandControl {
         } : {}
       },
       { retries: 0, ...signal ? { signal } : {} }
-    );
-    if (!result.execId) throw new Error("Modal command start returned no execution identity");
+    ).catch((error) => {
+      const code = error?.code;
+      if (typeof code === "number" && [
+        status2.INVALID_ARGUMENT,
+        status2.NOT_FOUND,
+        status2.PERMISSION_DENIED,
+        status2.UNAUTHENTICATED,
+        status2.UNIMPLEMENTED
+      ].includes(code))
+        throw new ProviderCommandStartRejectedError(error);
+      throw new ModalCommandStartOutcomeUnknownError(task.taskId, "", error);
+    });
+    if (!result.execId)
+      throw new ModalCommandStartOutcomeUnknownError(
+        task.taskId,
+        "",
+        new Error("Modal command start returned no execution identity")
+      );
     return {
       kind: "modal-control-v1",
       sandboxId,
@@ -23871,6 +24020,22 @@ var ModalCommandControl2 = class _ModalCommandControl {
         entry.value.router.close();
       }
   }
+  /** Access lookup may retry safely, but once the callback enters the Start
+   * boundary only the wire's own dispatch proof can authorize recovery. */
+  async withStartRouter(taskId, signal, run2) {
+    let entered = false;
+    try {
+      return await this.withRouter(taskId, signal, async (router) => {
+        entered = true;
+        return await run2(router);
+      });
+    } catch (error) {
+      if (entered) throw error;
+      return await ModalCommandStartPreDispatchUnavailableError.beforeDispatch(async () => {
+        throw error;
+      }, signal);
+    }
+  }
   async start(args, signal) {
     signal?.throwIfAborted();
     const supervised = admittedCommandSupervisionReady() && !args.tty && !args.runAs;
@@ -23879,7 +24044,10 @@ var ModalCommandControl2 = class _ModalCommandControl {
     const workdir = posix3.resolve(this.root, args.workdir ?? this.root);
     if (workdir !== this.root && !workdir.startsWith(`${this.root.replace(/\/$/u, "")}/`))
       throw new Error("Command workdir is outside the sandbox workspace");
-    const task = await this.client.sandboxGetTaskId({ sandboxId }, signal ? { signal } : void 0);
+    const task = await ModalCommandStartPreDispatchUnavailableError.beforeDispatch(
+      () => this.client.sandboxGetTaskId({ sandboxId }, signal ? { signal } : void 0),
+      signal
+    );
     if (!task.taskId || task.taskResult) throw new Error("Modal command task is unavailable");
     const taskId = task.taskId;
     if (this.sandboxId !== sandboxId)
@@ -23932,11 +24100,11 @@ var ModalCommandControl2 = class _ModalCommandControl {
       }
     };
     if (supervision) await reserveSupervisedLaunch(command);
+    let startAttempted = false;
     try {
-      await this.withRouter(
-        taskId,
-        signal,
-        (router) => router.start(
+      await this.withStartRouter(taskId, signal, async (router) => {
+        startAttempted = true;
+        await router.start(
           {
             taskId,
             execId,
@@ -23955,11 +24123,12 @@ var ModalCommandControl2 = class _ModalCommandControl {
             } : {}
           },
           signal
-        )
-      );
+        );
+      });
     } catch (error) {
-      if (!supervision || error instanceof ModalCommandStartRejectedError || error instanceof ModalCommandStartPreDispatchUnavailableError)
+      if (!startAttempted || error instanceof ModalCommandStartNotDispatchedError || error instanceof ModalCommandStartRejectedError || error instanceof ModalCommandStartPreDispatchUnavailableError)
         throw error;
+      throw new ProviderCommandStartOutcomeUnknownError(command, error);
     }
     return command;
   }
@@ -23969,9 +24138,12 @@ var ModalCommandControl2 = class _ModalCommandControl {
   async verifySupervisionCapability() {
     const sandboxId = this.sandboxId;
     const signal = AbortSignal.timeout(5e3);
-    const task = await this.client.sandboxGetTaskId({ sandboxId }, { signal });
+    const task = await ModalCommandStartPreDispatchUnavailableError.beforeDispatch(
+      () => this.client.sandboxGetTaskId({ sandboxId }, { signal }),
+      signal
+    );
     if (!task.taskId || task.taskResult) throw new Error("Modal command task is unavailable");
-    await this.withRouter(task.taskId, signal, async (router) => {
+    await this.withStartRouter(task.taskId, signal, async (router) => {
       const identity = { taskId: task.taskId, execId: randomUUID6() };
       await router.start(
         {
@@ -24004,6 +24176,69 @@ var ModalCommandControl2 = class _ModalCommandControl {
       throw new Error("Modal instance changed during supervision capability verification");
     return { sandboxId, taskId: task.taskId };
   }
+  /** Fixed provider readiness probe. No shell, user environment, admission or
+   * SDK Start retries. Once Start may have been sent, only observe that exact
+   * invocation; DNS-shaped server replies never authorize another Start. */
+  async verifyExecReadiness(signal) {
+    signal.throwIfAborted();
+    const sandboxId = this.sandboxId;
+    const task = await ModalCommandStartPreDispatchUnavailableError.beforeDispatch(
+      () => this.client.sandboxGetTaskId({ sandboxId }, { signal }),
+      signal
+    );
+    if (!task.taskId || task.taskResult) throw new Error("Modal command task is unavailable");
+    if (sandboxId !== this.sandboxId)
+      throw new Error("Modal sandbox changed during readiness preparation");
+    const identity = { taskId: task.taskId, execId: randomUUID6() };
+    const transientObservation = (error) => [status3.UNAVAILABLE, status3.DEADLINE_EXCEEDED].includes(
+      error?.code ?? -1
+    );
+    const pause = () => delay2(100, void 0, { signal });
+    return await this.withStartRouter(task.taskId, signal, async (router) => {
+      for (; ; ) {
+        signal.throwIfAborted();
+        try {
+          await router.start(
+            { ...identity, commandArgs: ["/bin/true"], workdir: "/tmp", env: {} },
+            signal
+          );
+          break;
+        } catch (error) {
+          signal.throwIfAborted();
+          if (error instanceof ModalCommandStartPreDispatchUnavailableError) {
+            await pause();
+            continue;
+          }
+          if (error instanceof ModalCommandStartRejectedError || error instanceof ModalCommandStartNotDispatchedError)
+            throw error;
+          break;
+        }
+      }
+      const streams = {
+        stdout: { offset: 0, eof: false },
+        stderr: { offset: 0, eof: false }
+      };
+      for (; ; ) {
+        signal.throwIfAborted();
+        try {
+          for (const stream of ["stdout", "stderr"]) {
+            const cursor = streams[stream];
+            if (cursor.eof) continue;
+            const page = await router.read(identity, stream, cursor.offset, 1e3, signal);
+            cursor.offset += page.bytes.length;
+            cursor.eof = page.eof;
+          }
+          const exit = await router.poll(identity, signal);
+          signal.throwIfAborted();
+          if (exit !== null && streams.stdout.eof && streams.stderr.eof) return exit;
+        } catch (error) {
+          signal.throwIfAborted();
+          if (!transientObservation(error)) throw error;
+        }
+        await pause();
+      }
+    });
+  }
   /** Separate authenticated provider execution of the installed control helper.
    * User command streams are never inspected for control evidence. */
   async supervisionControl(command, action, receiptId) {
@@ -24013,7 +24248,7 @@ var ModalCommandControl2 = class _ModalCommandControl {
       throw new Error("Supervised command identity is unavailable");
     const identity = { taskId: command.taskId, execId: randomUUID6() };
     const signal = AbortSignal.timeout(5e3);
-    return await this.withRouter(command.taskId, signal, async (router) => {
+    return await this.withStartRouter(command.taskId, signal, async (router) => {
       await router.start(
         {
           ...identity,
@@ -24559,8 +24794,8 @@ var MODAL_TASK_EXEC_START_ERROR_MAX_NODES = 64;
 var MODAL_TASK_EXEC_START_ERROR_MAX_AGGREGATE_ERRORS = 32;
 function modalHttpStatus(value) {
   if (typeof value !== "number" && typeof value !== "string") return null;
-  const status2 = Number(value);
-  return Number.isInteger(status2) && status2 >= 100 && status2 <= 599 ? status2 : null;
+  const status4 = Number(value);
+  return Number.isInteger(status4) && status4 >= 100 && status4 <= 599 ? status4 : null;
 }
 function hasContradictoryModalHttpStatus(record) {
   const values = [record.status, record.statusCode, record.httpStatus, record.httpStatusCode];
@@ -24593,8 +24828,10 @@ function isModalTaskExecStartPreDispatchUnavailableError(error) {
     try {
       const record = current.value;
       if (isRoutingMutationOutcomeUnknownError(current.value)) return false;
+      if (hasModalCommandStartBoundary(current.value, "outcome-unknown")) return false;
+      if (current.value instanceof ModalCommandStartNotDispatchedError) return false;
       if (hasContradictoryModalHttpStatus(record)) return false;
-      if (current.value instanceof ModalCommandStartPreDispatchUnavailableError) {
+      if (current.value instanceof ModalCommandStartPreDispatchUnavailableError || hasModalCommandStartBoundary(current.value, "pre-dispatch-unavailable")) {
         matchingLeaves += 1;
         continue;
       }
@@ -24621,6 +24858,30 @@ function isModalTaskExecStartPreDispatchUnavailableError(error) {
   }
   return matchingLeaves > 0;
 }
+function isModalCommandStartOutcomeUnknownError(error) {
+  const pending = [{ depth: 0, value: error }];
+  const seen = /* @__PURE__ */ new WeakSet();
+  for (let inspected = 0; pending.length && inspected < MODAL_TASK_EXEC_START_ERROR_MAX_NODES; inspected++) {
+    const { depth, value } = pending.shift();
+    if (!value || typeof value !== "object" || seen.has(value)) continue;
+    seen.add(value);
+    if (hasModalCommandStartBoundary(value, "outcome-unknown")) return true;
+    if (depth >= MODAL_TASK_EXEC_START_ERROR_MAX_DEPTH) continue;
+    try {
+      const record = value;
+      for (const key of ["cause", "error"])
+        if (record[key] !== void 0) pending.push({ depth: depth + 1, value: record[key] });
+      if (Array.isArray(record.errors))
+        for (const nested of record.errors.slice(
+          0,
+          MODAL_TASK_EXEC_START_ERROR_MAX_AGGREGATE_ERRORS
+        ))
+          pending.push({ depth: depth + 1, value: nested });
+    } catch {
+    }
+  }
+  return false;
+}
 function isModalExecAlreadyCompletedError(error) {
   if (!error || typeof error !== "object") return false;
   const record = error;
@@ -25807,7 +26068,7 @@ function commandForArgs(args) {
   if (!requestedShell) return args.cmd;
   return `${shellQuote(requestedShell)}${args.login === false ? "" : " -l"} -c ${shellQuote(args.cmd)}`;
 }
-function delay2(ms) {
+function delay3(ms) {
   return new Promise((resolve7) => setTimeout(resolve7, Math.max(0, ms)));
 }
 function consumeProcessOutput(process2) {
@@ -26150,23 +26411,23 @@ var OpenSandboxSession = class {
     const provider = await this.ensureStarted();
     while (true) {
       try {
-        const status2 = await provider.commands.getCommandStatus(executionId);
-        if (status2.running === false) {
-          if (status2.error) {
-            process2.events.push({ stream: "stderr", text: `${status2.error}
+        const status4 = await provider.commands.getCommandStatus(executionId);
+        if (status4.running === false) {
+          if (status4.error) {
+            process2.events.push({ stream: "stderr", text: `${status4.error}
 ` });
           }
           process2.settled = true;
           process2.transportUncertain = false;
           this.processesByOpId.delete(process2.opId);
           return {
-            exitCode: status2.exitCode ?? 1,
-            ...status2.error ? { error: status2.error } : {}
+            exitCode: status4.exitCode ?? 1,
+            ...status4.error ? { error: status4.error } : {}
           };
         }
       } catch {
       }
-      await delay2(DEFAULT_WRITE_STDIN_YIELD_TIME_MS3);
+      await delay3(DEFAULT_WRITE_STDIN_YIELD_TIME_MS3);
     }
   }
   async execToCompletion(args) {
@@ -26207,7 +26468,7 @@ var OpenSandboxSession = class {
     const yieldTimeMs = requestedYieldMs >= DEFAULT_EXEC_YIELD_TIME_MS3 ? requestedYieldMs + COMMAND_API_SETTLE_GRACE_MS : requestedYieldMs;
     const outcome = await Promise.race([
       process2.completed.then((value) => ({ done: true, value })),
-      delay2(yieldTimeMs).then(() => ({ done: false }))
+      delay3(yieldTimeMs).then(() => ({ done: false }))
     ]);
     const consumed = consumeProcessOutput(process2);
     const output = truncateOutput(consumed.output, args.maxOutputTokens);
@@ -26292,14 +26553,14 @@ var OpenSandboxSession = class {
         );
       }
       const provider = await this.ensureStarted();
-      const status2 = await provider.commands.getCommandStatus(executionId);
-      if (status2.error) {
-        process2.events.push({ stream: "stderr", text: `${status2.error}
+      const status4 = await provider.commands.getCommandStatus(executionId);
+      if (status4.error) {
+        process2.events.push({ stream: "stderr", text: `${status4.error}
 ` });
       }
       const consumed2 = consumeProcessOutput(process2);
       const output2 = truncateOutput(consumed2.output, args.maxOutputTokens);
-      if (status2.running !== false) {
+      if (status4.running !== false) {
         return formatExecResponse({
           output: output2.text,
           wallTimeSeconds: elapsedSeconds(startedAt),
@@ -26313,13 +26574,13 @@ var OpenSandboxSession = class {
       return formatExecResponse({
         output: output2.text,
         wallTimeSeconds: elapsedSeconds(startedAt),
-        exitCode: status2.exitCode ?? 1,
+        exitCode: status4.exitCode ?? 1,
         ...output2.originalTokenCount !== void 0 ? { originalTokenCount: output2.originalTokenCount } : {}
       });
     }
     const outcome = await Promise.race([
       process2.completed.then((value) => ({ done: true, value })),
-      delay2(args.yieldTimeMs ?? DEFAULT_WRITE_STDIN_YIELD_TIME_MS3).then(() => ({
+      delay3(args.yieldTimeMs ?? DEFAULT_WRITE_STDIN_YIELD_TIME_MS3).then(() => ({
         done: false
       }))
     ]);
@@ -28073,8 +28334,8 @@ function isRunloopConflictError(error) {
   if (!isRecord(error)) {
     return false;
   }
-  const status2 = error.status ?? error.statusCode;
-  if (status2 === 409 || status2 === "409") {
+  const status4 = error.status ?? error.statusCode;
+  if (status4 === 409 || status4 === "409") {
     return true;
   }
   const code = error.code;
@@ -29058,12 +29319,12 @@ var OpConsumer = class {
         if (result.$case !== "opStart") {
           throw protocolError(`op-stream start: unexpected result ${result.$case}`);
         }
-        const status2 = result.opStart.status;
+        const status4 = result.opStart.status;
         if (!result.opStart.accepted) {
-          throw this.refusedStart(status2);
+          throw this.refusedStart(status4);
         }
-        if (status2?.state === OpState2.OP_STATE_LOST) {
-          throw lostToControlError(status2);
+        if (status4?.state === OpState2.OP_STATE_LOST) {
+          throw lostToControlError(status4);
         }
         return drainingRetries + blipRetries;
       } catch (error) {
@@ -29095,8 +29356,8 @@ var OpConsumer = class {
       }
     }
   }
-  refusedStart(status2) {
-    if (status2?.exit?.cancelled) {
+  refusedStart(status4) {
+    if (status4?.exit?.cancelled) {
       return new SelfhostedControlError({
         message: "The command was cancelled before the machine admitted it.",
         code: ErrorCode3.ERROR_CODE_TIMEOUT,
@@ -29105,8 +29366,8 @@ var OpConsumer = class {
         detail: { cancelled: "true" }
       });
     }
-    if (status2?.state === OpState2.OP_STATE_LOST) {
-      return lostToControlError(status2);
+    if (status4?.state === OpState2.OP_STATE_LOST) {
+      return lostToControlError(status4);
     }
     return protocolError("op-stream start: the runner refused the op without a typed reason");
   }
@@ -29342,12 +29603,12 @@ var OpConsumer = class {
       if (result.$case !== "opStatus") {
         throw protocolError(`op-stream query: unexpected result ${result.$case}`);
       }
-      const status2 = result.opStatus;
-      if (status2.state === OpState2.OP_STATE_LOST) {
-        reject(lostToControlError(status2));
+      const status4 = result.opStatus;
+      if (status4.state === OpState2.OP_STATE_LOST) {
+        reject(lostToControlError(status4));
         return;
       }
-      if (BigInt(status2.nextSeq) > this.lastApplied + 1n) {
+      if (BigInt(status4.nextSeq) > this.lastApplied + 1n) {
         this.requestAttachHeal();
       }
     } catch (error) {
@@ -29415,14 +29676,14 @@ function protocolError(message) {
     retryable: false
   });
 }
-function lostToControlError(status2) {
-  const reason = status2.lostReason === OpLostReason.OP_LOST_REASON_EVICTED ? "its retained result was evicted before collection" : status2.lostReason === OpLostReason.OP_LOST_REASON_AGENT_RESTARTED ? "the machine agent restarted and the op did not survive" : "the runner reported it lost";
+function lostToControlError(status4) {
+  const reason = status4.lostReason === OpLostReason.OP_LOST_REASON_EVICTED ? "its retained result was evicted before collection" : status4.lostReason === OpLostReason.OP_LOST_REASON_AGENT_RESTARTED ? "the machine agent restarted and the op did not survive" : "the runner reported it lost";
   return new SelfhostedControlError({
     message: `The command's result is no longer available on the machine (${reason}). Check whether its effects already took place before re-running it.`,
     code: ErrorCode3.ERROR_CODE_STREAM,
     reason: null,
     retryable: false,
-    detail: { lost_reason: String(status2.lostReason) }
+    detail: { lost_reason: String(status4.lostReason) }
   });
 }
 function runnerFailureToControlError(exit) {
@@ -32561,7 +32822,7 @@ async function runWithLegacyVercelAuthenticationFallback(state, credentials2, op
 }
 function isVercelUnauthorizedError(error) {
   const details = providerErrorDetails(error);
-  return [details.status, details.httpStatus, details.responseStatus].some((status2) => status2 === 401 || status2 === "401");
+  return [details.status, details.httpStatus, details.responseStatus].some((status4) => status4 === 401 || status4 === "401");
 }
 function applyVercelAuthentication(state, authentication) {
   applyVercelCredentials(state, authentication.credentials);
@@ -33169,7 +33430,7 @@ function safeDiagnostic(signals) {
   return [code ? `code=${code}` : "", numeric !== void 0 ? `status=${numeric}` : ""].filter(Boolean).join(" ");
 }
 function hasTransientSignal(signals) {
-  return signals.codes.some((code) => TRANSIENT_CODES.has(code)) || signals.numbers.some((status2) => GRPC_TRANSIENT.has(status2));
+  return signals.codes.some((code) => TRANSIENT_CODES.has(code)) || signals.numbers.some((status4) => GRPC_TRANSIENT.has(status4));
 }
 function hasModalTerminalSandboxMessage(signals) {
   return signals.messages.some(
@@ -33200,7 +33461,7 @@ function classifyProviderSandboxFailure(backendId, error) {
   if (hasTransientSignal(signals)) {
     return { kind: "transient_transport", diagnostic };
   }
-  if (signals.numbers.some((status2) => status2 === 404) || signals.codes.some((code) => NOT_FOUND_CODES.has(code))) {
+  if (signals.numbers.some((status4) => status4 === 404) || signals.codes.some((code) => NOT_FOUND_CODES.has(code))) {
     return { kind: "not_found", diagnostic };
   }
   if (backendId === "modal" && hasModalTerminalSandboxMessage(signals)) {
@@ -33872,10 +34133,10 @@ async function cleanupDisplayStackProcess(session, pending, deadline) {
       deadline
     );
     const output = execResultOutput(result);
-    const status2 = /OPENGENI_DISPLAY_CLEANUP status=(stopped|absent|alive|invalid)/u.exec(
+    const status4 = /OPENGENI_DISPLAY_CLEANUP status=(stopped|absent|alive|invalid)/u.exec(
       output
     )?.[1];
-    return status2 === "stopped";
+    return status4 === "stopped";
   } catch {
     return false;
   }
@@ -33906,13 +34167,13 @@ function telemetryReporter(options, started, now = monotonicNow) {
   const context = options.telemetryContext;
   const sink = options.onTelemetry ?? (context ? (event) => console.info(`[display-stack] ${JSON.stringify(event)}`) : void 0);
   const emittedSandboxStages = /* @__PURE__ */ new Set();
-  const emit = (stage, status2, fields = {}) => {
+  const emit = (stage, status4, fields = {}) => {
     if (!sink) return;
     const event = {
       type: "display_stack.stage",
       requestId: id,
       stage,
-      status: status2,
+      status: status4,
       elapsedMs: fields.elapsedMs ?? now() - started,
       source: fields.source ?? "host",
       classification: fields.classification ?? "unknown",
@@ -34461,9 +34722,9 @@ var ComputerFrameEvidenceMismatchError = class extends BrowserControlProtocolErr
   }
 };
 var BrowserControlRequestError = class extends Error {
-  constructor(status2, error) {
+  constructor(status4, error) {
     super(error.message);
-    this.status = status2;
+    this.status = status4;
     this.error = error;
     this.retryable = error.retryable;
   }
@@ -35013,7 +35274,7 @@ var BrowserControlClient = class {
           `browser controller transport failed (curl exit ${curlExit})`
         );
       }
-      const status2 = parseHttpStatus(await readText(this.session, statusPath, 32, timeoutMs));
+      const status4 = parseHttpStatus(await readText(this.session, statusPath, 32, timeoutMs));
       const responseText = await readText(
         this.session,
         responsePath,
@@ -35023,7 +35284,7 @@ var BrowserControlClient = class {
       if (Buffer.byteLength(responseText) > BROWSER_CONTROL_MAX_JSON_BYTES) {
         throw new BrowserControlProtocolError("browser controller response is too large");
       }
-      return parseEnvelope(responseText, status2);
+      return parseEnvelope(responseText, status4);
     } catch (error) {
       if (error instanceof BrowserControlRequestError || error instanceof BrowserControlProtocolError || error instanceof RangeError) {
         throw error;
@@ -35130,15 +35391,15 @@ var BrowserControlClient = class {
           `browser controller transport failed (curl exit ${curlExit})`
         );
       }
-      const status2 = parseHttpStatus(await readText(this.session, statusPath, 32, timeoutMs));
-      if (status2 < 200 || status2 >= 300) {
+      const status4 = parseHttpStatus(await readText(this.session, statusPath, 32, timeoutMs));
+      if (status4 < 200 || status4 >= 300) {
         const responseText = await readText(
           this.session,
           responsePath,
           BROWSER_CONTROL_MAX_JSON_BYTES + 1,
           timeoutMs
         );
-        parseEnvelope(responseText, status2);
+        parseEnvelope(responseText, status4);
         throw new BrowserControlProtocolError("browser controller image response is invalid");
       }
       const headers = parseCurlResponseHeaders(
@@ -35940,12 +36201,12 @@ function looksLikeBrowserControlEnvelope(body) {
     return false;
   }
 }
-function rejectProviderGatewayResponse(body, status2) {
-  if ([502, 503, 504].includes(status2) && !looksLikeBrowserControlEnvelope(body)) {
-    throw new BrowserControlTransportError(`browser controller returned HTTP ${status2}`);
+function rejectProviderGatewayResponse(body, status4) {
+  if ([502, 503, 504].includes(status4) && !looksLikeBrowserControlEnvelope(body)) {
+    throw new BrowserControlTransportError(`browser controller returned HTTP ${status4}`);
   }
 }
-function parseEnvelope(body, status2) {
+function parseEnvelope(body, status4) {
   let value;
   try {
     value = JSON.parse(body);
@@ -35955,10 +36216,10 @@ function parseEnvelope(body, status2) {
   if (!isRecord3(value) || value.protocolVersion !== BROWSER_CONTROL_PROTOCOL_VERSION) {
     throw new BrowserControlProtocolError("browser controller protocol version is invalid");
   }
-  if (value.ok === true && status2 >= 200 && status2 < 300 && "data" in value) return value.data;
-  if (value.ok === false && status2 >= 400 && status2 <= 599) {
+  if (value.ok === true && status4 >= 200 && status4 < 300 && "data" in value) return value.data;
+  if (value.ok === false && status4 >= 400 && status4 <= 599) {
     const parsed = InteractionError.safeParse(value.error);
-    if (parsed.success) throw new BrowserControlRequestError(status2, parsed.data);
+    if (parsed.success) throw new BrowserControlRequestError(status4, parsed.data);
   }
   throw new BrowserControlProtocolError("browser controller response envelope is invalid");
 }
@@ -36718,11 +36979,11 @@ function parseUnsignedInteger(value, label) {
   return parsed;
 }
 function parseHttpStatus(value) {
-  const status2 = parseUnsignedInteger(value, "HTTP status");
-  if (status2 < 100 || status2 > 599) {
+  const status4 = parseUnsignedInteger(value, "HTTP status");
+  if (status4 < 100 || status4 > 599) {
     throw new BrowserControlProtocolError("HTTP status is invalid");
   }
-  return status2;
+  return status4;
 }
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -37447,32 +37708,29 @@ for (const name of ['package.json', 'ogtool', 'client.mjs']) {
   } catch (error) {
     installationFailure = { error };
   }
-  let cleanupFailure;
   try {
     await editor.deleteFile({ type: "delete_file", path: stage });
-  } catch (editorFailure) {
+  } catch {
     try {
       const cleanup = await run2(
         `node -e ${quote(`require('node:fs').rmSync(${JSON.stringify(stage)}, {force: true})`)}`
       );
       if (sandboxCommandExitCode(cleanup) !== 0) {
-        throw new Error("Staging file removal failed", { cause: editorFailure });
+        throw new Error("Staging file removal failed");
+      }
+    } catch {
+      try {
+        console.warn(
+          "Managed Codemode client staging cleanup failed; installation result preserved",
+          {
+            stageFile: posix5.basename(stage),
+            installation: installationFailure ? "failed" : "verified"
+          }
+        );
+      } catch {
       }
-    } catch (commandFailure2) {
-      cleanupFailure = new AggregateError(
-        [editorFailure, commandFailure2],
-        "Both cleanup paths failed",
-        { cause: commandFailure2 }
-      );
     }
   }
-  if (cleanupFailure) {
-    throw new AggregateError(
-      installationFailure ? [installationFailure.error, cleanupFailure] : [cleanupFailure],
-      "Managed Codemode client staging cleanup failed; restore sandbox file ingress/command execution before retrying",
-      { cause: installationFailure?.error ?? cleanupFailure }
-    );
-  }
   if (installationFailure) throw installationFailure.error;
 }
 function managedCodemodeClientEnvironment(directory) {
@@ -37598,6 +37856,7 @@ async function mintSandboxCodemodeToken(settings, scope, authority, nowMs = Date
     turnId: authority.turnId,
     attemptId: authority.attemptId,
     executionGeneration: authority.executionGeneration,
+    ...authority.credentialRestriction ? { credentialRestriction: authority.credentialRestriction } : {},
     principalKind: "agent_attempt",
     exp: expiresAtSeconds
   });
@@ -38547,18 +38806,18 @@ function errorResponse2(requestId2, code, message) {
     result: void 0
   };
 }
-function startResponse(requestId2, status2, accepted = true) {
+function startResponse(requestId2, status4, accepted = true) {
   return {
     requestId: requestId2,
     error: void 0,
-    result: { $case: "opStart", opStart: { accepted, status: status2 } }
+    result: { $case: "opStart", opStart: { accepted, status: status4 } }
   };
 }
-function statusOnly(requestId2, status2) {
+function statusOnly(requestId2, status4) {
   return {
     requestId: requestId2,
     error: void 0,
-    result: { $case: "opStatus", opStatus: status2 }
+    result: { $case: "opStatus", opStatus: status4 }
   };
 }
 function lostStatus(opId) {
@@ -39085,11 +39344,13 @@ function sandboxExecProbeSessionId(result) {
   }
   return null;
 }
-async function verifySandboxExecReadiness(established, timeoutMs = MODAL_EXEC_READINESS_TIMEOUT_MS) {
+async function verifySandboxExecReadiness(established, timeoutMs = MODAL_EXEC_READINESS_TIMEOUT_MS, signal) {
+  signal?.throwIfAborted();
   if (established.backendId !== "modal" && established.backendId !== "opensandbox") return;
   const session = established.session;
   const run2 = session.exec ?? session.execCommand;
-  if (!run2) {
+  const nativeModalProbe = established.backendId === "modal" ? session.verifyExecReadiness : void 0;
+  if (!run2 && !nativeModalProbe) {
     throw new SandboxExecReadinessError(
       established.backendId,
       "exec_probe_unavailable",
@@ -39107,21 +39368,50 @@ async function verifySandboxExecReadiness(established, timeoutMs = MODAL_EXEC_RE
   );
   const deadline = Date.now() + timeoutMs;
   const withinDeadline = async (operation) => {
+    signal?.throwIfAborted();
     const remainingMs = deadline - Date.now();
     if (remainingMs <= 0) throw timeoutError();
     let timer;
+    let abort;
     try {
-      return await Promise.race([
-        operation(),
-        new Promise((_, reject) => {
-          timer = setTimeout(() => reject(timeoutError()), remainingMs);
-          if (timer && "unref" in timer && typeof timer.unref === "function") timer.unref();
-        })
-      ]);
+      const interrupted = new Promise((_, reject) => {
+        abort = () => reject(signal?.reason);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted) abort();
+        timer = setTimeout(() => reject(timeoutError()), remainingMs);
+        if (timer && "unref" in timer && typeof timer.unref === "function") timer.unref();
+      });
+      const result2 = await Promise.race([operation(), interrupted]);
+      signal?.throwIfAborted();
+      return result2;
     } finally {
       if (timer) clearTimeout(timer);
+      if (abort) signal?.removeEventListener("abort", abort);
     }
   };
+  if (nativeModalProbe) {
+    const cancellation = new AbortController();
+    const abort = () => cancellation.abort(signal?.reason);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    try {
+      const exitCode = await withinDeadline(
+        () => nativeModalProbe.call(session, cancellation.signal)
+      );
+      if (exitCode !== 0)
+        throw new SandboxExecReadinessError(
+          established.backendId,
+          "exec_probe_failed",
+          timeoutMs,
+          exitCode,
+          established.instanceId
+        );
+      return;
+    } finally {
+      signal?.removeEventListener("abort", abort);
+      cancellation.abort(new Error("Sandbox readiness observation finished"));
+    }
+  }
   const execProbe = () => withinDeadline(
     () => run2.call(session, {
       cmd: "true",
@@ -39974,6 +40264,7 @@ export {
   RoutingMutationOutcomeUnknownError,
   isRoutingMutationOutcomeUnknownError,
   RoutingRetainedProcessNotFoundError,
+  renderRoutingMutationOutcomeUnknownToolResult,
   RoutingSandboxSession,
   ModalCloudBucketMountStrategy,
   captureWorkspaceArchiveForStorage,
@@ -39996,6 +40287,7 @@ export {
   modalSandboxAttributionEnvironment,
   modalSandboxAttributionTags,
   isModalTaskExecStartPreDispatchUnavailableError,
+  isModalCommandStartOutcomeUnknownError,
   ensureModalRegistryImage,
   resolveModalCheckpointProviderBindingForSession,
   modalSessionMatchesCheckpointProviderBinding,
@@ -40179,4 +40471,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-JUFVYQCY.js.map
+//# sourceMappingURL=chunk-VDXKKMMD.js.map