@opengeni/runtime 4.6.0 → 4.7.0-canary.37090756480001

package/dist/{chunk-D5DPVA2C.js → chunk-R25L27T3.js}

@@ -55,6 +55,7 @@ import {
   assertShellEnvironmentName,
   deserializeHostPathGrantRedactionMetadata,
   deserializeManifest,
+  external_exports,
   getRecordedExposedPortEndpoint,
   getRunStateSessionTrustedConfig,
   isDir,
@@ -113,6 +114,50 @@ var ProviderCommandStartOutcomeUnknownError = class extends Error {
     this.name = "ProviderCommandStartOutcomeUnknownError";
   }
 };
+var ProviderCommandInputOutcomeUnknownError = class extends Error {
+  constructor(command, byteOffset, byteLength2, cause) {
+    super(
+      "Provider command stdin outcome is unknown; the input was not resent. Do not resend stdin; inspect the original command with empty input.",
+      { cause }
+    );
+    this.command = command;
+    this.byteOffset = byteOffset;
+    this.byteLength = byteLength2;
+    this.name = "ProviderCommandInputOutcomeUnknownError";
+  }
+};
+var ProviderCommandObservationUnavailableError = class extends Error {
+  constructor(command, cause, readRetryAllowed = true) {
+    super("Provider command observation unavailable; do not replay the invocation", { cause });
+    this.command = command;
+    this.readRetryAllowed = readRetryAllowed;
+    this.name = "ProviderCommandObservationUnavailableError";
+  }
+};
+function isProviderCommandObservationUnavailableError(error) {
+  const pending = [error];
+  const seen = /* @__PURE__ */ new Set();
+  for (let count = 0; pending.length && count < 32; count++) {
+    const current = pending.pop();
+    if (!current || typeof current !== "object" || seen.has(current)) continue;
+    seen.add(current);
+    if (current instanceof ProviderCommandObservationUnavailableError) return true;
+    try {
+      for (const key of ["cause", "error"]) {
+        const property = Object.getOwnPropertyDescriptor(current, key);
+        if (property && "value" in property) pending.push(property.value);
+      }
+      const errors = Object.getOwnPropertyDescriptor(current, "errors");
+      if (errors && "value" in errors && Array.isArray(errors.value) && errors.value.length <= 16)
+        for (let index = 0; index < errors.value.length; index++) {
+          const item = Object.getOwnPropertyDescriptor(errors.value, String(index));
+          if (item && "value" in item) pending.push(item.value);
+        }
+    } catch {
+    }
+  }
+  return false;
+}
 var admission = new AsyncLocalStorage();
 var pendingSupervision = new AsyncLocalStorage();
 function withPendingCommandSupervision(state, fn) {
@@ -152,6 +197,878 @@ function admittedProviderCommandHandle() {
 // src/sandbox/index.ts
 import { collectSandboxEnvironment, parseExposedPorts } from "@opengeni/config";
 
+// src/sandbox/providers/modal-command-raw-page.ts
+import { isDeepStrictEqual } from "util";
+import { ModalRouterProviderCommand as ModalRouterProviderCommand2 } from "@opengeni/contracts";
+
+// src/sandbox/providers/modal-legacy-command-control.ts
+import { posix } from "path";
+import { ModalClient } from "modal";
+
+// src/sandbox/providers/modal-command-start-errors.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { ModalRouterProviderCommand } from "@opengeni/contracts";
+var boundaryBrand = Symbol.for("opengeni.modal.command-start.boundary.v1");
+var invocationBrand = Symbol.for("opengeni.modal.command-start.invocation.v1");
+var contextBrand = Symbol.for("opengeni.modal.command-start.context.v1");
+var startSignal = new AsyncLocalStorage2();
+function withModalCommandStartSignal(signal, operation) {
+  signal.throwIfAborted();
+  return startSignal.run(signal, operation);
+}
+function installModalCommandStartContext(modal) {
+  if (Object.getOwnPropertyDescriptor(modal, contextBrand)) return;
+  Object.defineProperty(modal, contextBrand, { value: () => startSignal.getStore() });
+}
+function modalCommandStartOwnData(value, key) {
+  const property = Object.getOwnPropertyDescriptor(value, key);
+  return property && "value" in property ? property.value : void 0;
+}
+function modalCommandStartHasOwnAccessor(value, key) {
+  const property = Object.getOwnPropertyDescriptor(value, key);
+  return !!property && !("value" in property);
+}
+function getModalCommandStartInvocation(error) {
+  const pending = [{ value: error, depth: 0 }];
+  const seen = /* @__PURE__ */ new WeakSet();
+  let result = null;
+  let inspected = 0;
+  while (pending.length) {
+    if (++inspected > 64) return null;
+    const { value, depth } = pending.shift();
+    if (!value || typeof value !== "object" || seen.has(value)) continue;
+    if (depth > 8) return null;
+    seen.add(value);
+    try {
+      if (["cause", "error", "errors"].some((key) => modalCommandStartHasOwnAccessor(value, key)))
+        return null;
+      if (hasModalCommandStartBoundary(value, "outcome-unknown")) {
+        const descriptor = modalCommandStartOwnData(value, invocationBrand);
+        if (!descriptor || typeof descriptor !== "object" || !Object.isFrozen(descriptor))
+          return null;
+        const sandboxId = modalCommandStartOwnData(descriptor, "sandboxId");
+        const taskId = modalCommandStartOwnData(descriptor, "taskId");
+        const execId = modalCommandStartOwnData(descriptor, "execId");
+        const observe = modalCommandStartOwnData(descriptor, "observe");
+        const ptyProperty = Object.getOwnPropertyDescriptor(descriptor, "pty");
+        if (ptyProperty && (!("value" in ptyProperty) || typeof ptyProperty.value !== "boolean"))
+          return null;
+        if (typeof sandboxId !== "string" || !sandboxId || typeof taskId !== "string" || !taskId || typeof execId !== "string" || !execId || typeof observe !== "function")
+          return null;
+        if (result && result !== descriptor) return null;
+        result = descriptor;
+      }
+      const nested = [
+        modalCommandStartOwnData(value, "cause"),
+        modalCommandStartOwnData(value, "error")
+      ].filter((child) => child !== void 0);
+      const errors = modalCommandStartOwnData(value, "errors");
+      if (errors !== void 0) {
+        if (!Array.isArray(errors)) return null;
+        const length = modalCommandStartOwnData(errors, "length");
+        if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 1 || length > 32)
+          return null;
+        for (let index = 0; index < length; index++) {
+          const property = Object.getOwnPropertyDescriptor(errors, String(index));
+          if (!property || !("value" in property) || !property.value || typeof property.value !== "object")
+            return null;
+          nested.push(property.value);
+        }
+      }
+      if (depth === 8 && nested.length) return null;
+      for (const child of nested) pending.push({ value: child, depth: depth + 1 });
+    } catch {
+      return null;
+    }
+  }
+  return result;
+}
+function modalCommandStartRetainedError(error) {
+  if (error instanceof ProviderCommandStartOutcomeUnknownError) return error;
+  const invocation = getModalCommandStartInvocation(error);
+  if (!invocation) return error;
+  const cursor = () => ({ byteOffset: 0, utf8Remainder: "", eof: false, exitCode: null });
+  const command = ModalRouterProviderCommand.safeParse({
+    kind: "modal-router-v1",
+    sandboxId: invocation.sandboxId,
+    taskId: invocation.taskId,
+    execId: invocation.execId,
+    ...invocation.pty === void 0 ? {} : { pty: invocation.pty },
+    streams: { stdout: cursor(), stderr: cursor() }
+  });
+  return command.success ? new ProviderCommandStartOutcomeUnknownError(command.data, error) : error;
+}
+function hasModalCommandStartOutcomeUnknownBoundary(error) {
+  const pending = [{ value: error, depth: 0 }];
+  const seen = /* @__PURE__ */ new WeakSet();
+  for (let inspected = 0; pending.length && inspected < 64; inspected++) {
+    const { value, depth } = pending.shift();
+    if (!value || typeof value !== "object" || seen.has(value)) continue;
+    seen.add(value);
+    if (hasModalCommandStartBoundary(value, "outcome-unknown")) return true;
+    if (depth >= 8) continue;
+    try {
+      for (const key of ["cause", "error"]) {
+        const nested = modalCommandStartOwnData(value, key);
+        if (nested !== void 0) pending.push({ value: nested, depth: depth + 1 });
+      }
+      const errors = modalCommandStartOwnData(value, "errors");
+      if (Array.isArray(errors))
+        for (let index = 0; index < Math.min(errors.length, 32); index++)
+          pending.push({
+            value: modalCommandStartOwnData(errors, String(index)),
+            depth: depth + 1
+          });
+    } catch {
+    }
+  }
+  return false;
+}
+function modalCommandStartCleanupIsSafe(error) {
+  const pending = [{ value: error, depth: 0 }];
+  const seen = /* @__PURE__ */ new WeakSet();
+  let inspected = 0;
+  while (pending.length) {
+    if (++inspected > 64) return false;
+    const { value, depth } = pending.shift();
+    if (!value || typeof value !== "object" && typeof value !== "function") continue;
+    if (seen.has(value)) continue;
+    if (depth > 8) return false;
+    seen.add(value);
+    try {
+      if (value instanceof ProviderCommandStartOutcomeUnknownError || hasModalCommandStartBoundary(value, "outcome-unknown") || [boundaryBrand, "cause", "error", "errors"].some(
+        (key) => modalCommandStartHasOwnAccessor(value, key)
+      ))
+        return false;
+      const nested = [
+        modalCommandStartOwnData(value, "cause"),
+        modalCommandStartOwnData(value, "error")
+      ].filter((child) => child !== void 0 && child !== null);
+      const errors = modalCommandStartOwnData(value, "errors");
+      if (errors !== void 0) {
+        if (!Array.isArray(errors)) return false;
+        const length = modalCommandStartOwnData(errors, "length");
+        if (typeof length !== "number" || !Number.isSafeInteger(length) || length > 32)
+          return false;
+        for (let index = 0; index < length; index++) {
+          const property = Object.getOwnPropertyDescriptor(errors, String(index));
+          if (!property || !("value" in property) || !property.value || typeof property.value !== "object" && typeof property.value !== "function")
+            return false;
+          nested.push(property.value);
+        }
+      }
+      if (depth === 8 && nested.length) return false;
+      for (const child of nested) pending.push({ value: child, depth: depth + 1 });
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function installModalCommandStartRetention(session) {
+  for (const name of [
+    "execCommand",
+    "applyManifest",
+    "materializeEntry",
+    "hydrateWorkspace",
+    "persistWorkspace",
+    "runDirectCommand",
+    "runAsCommandRunner"
+  ]) {
+    const operation = Reflect.get(session, name);
+    if (typeof operation !== "function") continue;
+    Reflect.set(session, name, async function(...args) {
+      try {
+        return await operation.apply(session, args);
+      } catch (error) {
+        throw modalCommandStartRetainedError(error);
+      }
+    });
+  }
+}
+function hasModalCommandStartBoundary(error, kind) {
+  if (!error || typeof error !== "object") return false;
+  try {
+    const property = Object.getOwnPropertyDescriptor(error, boundaryBrand);
+    return property?.value === kind && property.writable === false && property.configurable === false;
+  } 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/providers/modal-legacy-command-control.ts
+import { status as status2 } from "@grpc/grpc-js";
+
+// src/sandbox/providers/modal-command-router-wire.ts
+import { Client, Metadata, credentials, status } from "@grpc/grpc-js";
+import protobuf from "protobufjs";
+var modalRouterWire = protobuf.parse(`syntax = "proto3";
+message Identity { string task_id = 1; string exec_id = 2; }
+message Pty {
+  bool enabled = 1; uint32 winsz_rows = 2; uint32 winsz_cols = 3;
+  string env_term = 4; string env_colorterm = 5; string env_term_program = 6;
+  int32 pty_type = 7; bool no_terminate_on_idle_stdin = 8;
+}
+message Start {
+  string task_id = 1; string exec_id = 2; repeated string command_args = 3;
+  int32 stdout_config = 4; int32 stderr_config = 5;
+  optional uint32 timeout_secs = 6; optional string workdir = 7;
+  repeated string secret_ids = 8; optional Pty pty_info = 9;
+  bool runtime_debug = 10; string container_id = 11; map<string,string> env = 12;
+}
+message Read {
+  string task_id = 1; string exec_id = 2; uint64 offset = 3; int32 file_descriptor = 4;
+}
+message Data { bytes data = 1; }
+message Poll { optional int32 code = 1; optional int32 signal = 2; }
+message Write {
+  string task_id = 1; string exec_id = 2; uint64 offset = 3; bytes data = 4; bool eof = 5;
+}
+message Empty {}
+`).root;
+var prefix = "/modal.task_command_router.TaskCommandRouter/";
+var MODAL_ROUTER_READ_PAGE_BYTES = 1024 * 1024;
+var maxWireBytes = 4 * 1024 * 1024;
+var ModalCommandStartRejectedError = class extends ProviderCommandStartRejectedError {
+  constructor(code, cause) {
+    super(cause);
+    this.code = code;
+    this.name = "ModalCommandStartRejectedError";
+  }
+};
+var ModalCommandStartPreDispatchUnavailableError = class _ModalCommandStartPreDispatchUnavailableError extends Error {
+  constructor(cause) {
+    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) => {
+      let settled = false;
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        signal?.removeEventListener("abort", abort);
+        if (signal?.aborted) reject(signal.reason);
+        else if (error) reject(new _ModalCommandStartPreDispatchUnavailableError(error));
+        else resolve7();
+      };
+      const abort = () => finish();
+      signal?.addEventListener("abort", abort, { once: true });
+      client.waitForReady(Date.now() + 5e3, finish);
+      if (signal?.aborted) abort();
+    });
+  }
+};
+var ModalCommandStartNotDispatchedError = class extends Error {
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : "Modal command Start was never dispatched", {
+      cause
+    });
+    this.name = "ModalCommandStartNotDispatchedError";
+  }
+};
+function prepareStartRequest(request) {
+  const { taskId, execId, commandArgs, workdir, env, ptyInfo } = request;
+  if (!taskId || !execId || !Array.isArray(commandArgs) || !commandArgs.length || typeof workdir !== "string" || !env || typeof env !== "object" || Array.isArray(env))
+    throw new Error("Invalid Modal command Start request");
+  const snapshot = {
+    taskId,
+    execId,
+    commandArgs: [...commandArgs],
+    workdir,
+    env: { ...env },
+    ...ptyInfo ? {
+      ptyInfo: {
+        enabled: ptyInfo.enabled,
+        winszRows: ptyInfo.winszRows,
+        winszCols: ptyInfo.winszCols,
+        envTerm: ptyInfo.envTerm,
+        ptyType: ptyInfo.ptyType,
+        noTerminateOnIdleStdin: ptyInfo.noTerminateOnIdleStdin
+      }
+    } : {},
+    stdoutConfig: 1,
+    stderrConfig: 1
+  };
+  if (modalRouterWire.lookupType("Start").verify(snapshot))
+    throw new Error("Invalid Modal command Start request");
+  if (encode("Start", snapshot).length > maxWireBytes)
+    throw new Error("Modal command Start request exceeds the wire limit");
+  Object.freeze(snapshot.commandArgs);
+  Object.freeze(snapshot.env);
+  if (snapshot.ptyInfo) Object.freeze(snapshot.ptyInfo);
+  return Object.freeze(snapshot);
+}
+function encode(type, value) {
+  const codec = modalRouterWire.lookupType(type);
+  return Buffer.from(codec.encode(codec.fromObject(value)).finish());
+}
+var ModalCommandRouterWire = class {
+  client;
+  metadata;
+  #preparedStarts = /* @__PURE__ */ new WeakMap();
+  closed = false;
+  constructor(access, trustedRoots) {
+    const url = new URL(access.url);
+    if (url.protocol !== "https:" || url.username || url.password || !access.jwt)
+      throw new Error("Modal command router requires authenticated TLS");
+    this.client = new Client(
+      `${url.hostname}:${url.port || "443"}`,
+      credentials.createSsl(trustedRoots),
+      {
+        "grpc.max_receive_message_length": maxWireBytes,
+        "grpc.max_send_message_length": maxWireBytes,
+        "grpc.enable_retries": 0,
+        // The HTTP/2 default 64 KiB window caps one read at 64 KiB per round
+        // trip. Two pages lets stdout and stderr each fill a page in one trip
+        // while bounding bytes discarded when a full read cancels its stream.
+        "grpc-node.flow_control_window": 2 * MODAL_ROUTER_READ_PAGE_BYTES
+      }
+    );
+    this.metadata = new Metadata();
+    this.metadata.set("authorization", `Bearer ${access.jwt}`);
+  }
+  close() {
+    this.closed = true;
+    this.client.close();
+  }
+  async unary(method, requestType, responseType, request, signal) {
+    signal?.throwIfAborted();
+    if (this.closed) throw new Error("Modal command router is closed");
+    return await new Promise((resolve7, reject) => {
+      const call = this.client.makeUnaryRequest(
+        prefix + method,
+        (value) => encode(requestType, value),
+        (bytes) => modalRouterWire.lookupType(responseType).decode(bytes),
+        request,
+        this.metadata,
+        { deadline: Date.now() + 3e4 },
+        (error, result) => {
+          signal?.removeEventListener("abort", abort);
+          if (signal?.aborted) reject(signal.reason);
+          else if (error) reject(error);
+          else if (result) resolve7(result);
+          else reject(new Error("Modal command router returned no response"));
+        }
+      );
+      const abort = () => call.cancel();
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) abort();
+    });
+  }
+  /** Read-only transport preparation. It sends neither Start nor stdin and
+   * does not invoke a caller's dispatch/admission callback. Prevalidation is not
+   * wire proof: gRPC still serializes at RPC invocation after dispatch begins. */
+  async prepareStart(request, signal) {
+    try {
+      signal?.throwIfAborted();
+      if (this.closed) throw new Error("Modal command router is closed");
+      const snapshot = prepareStartRequest(request);
+      await ModalCommandStartPreDispatchUnavailableError.ensureReady(this.client, signal);
+      signal?.throwIfAborted();
+      if (this.closed) throw new Error("Modal command router is closed");
+      const prepared = Object.freeze({
+        taskId: snapshot.taskId,
+        execId: snapshot.execId
+      });
+      this.#preparedStarts.set(prepared, { request: snapshot, spent: false });
+      return prepared;
+    } catch (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);
+    }
+  }
+  /** No readiness, route lookup or retry here. Consume the authentic local
+   * handle synchronously before RPC, including when cancellation/closure wins.
+   * Once spent it never resets, even if no acknowledgement was received. */
+  async dispatchPreparedStart(prepared, signal) {
+    const entry = this.#preparedStarts.get(prepared);
+    if (!entry || entry.spent)
+      throw new Error("Invalid or consumed Modal prepared Start handle");
+    entry.spent = true;
+    try {
+      signal?.throwIfAborted();
+      if (this.closed) throw new Error("Modal command router is closed");
+    } catch (error) {
+      throw new ModalCommandStartNotDispatchedError(error);
+    }
+    const request = entry.request;
+    try {
+      await this.unary("TaskExecStart", "Start", "Empty", request, signal);
+    } catch (error) {
+      const code = error?.code;
+      if (typeof code === "number" && [
+        status.INVALID_ARGUMENT,
+        status.NOT_FOUND,
+        status.PERMISSION_DENIED,
+        status.UNAUTHENTICATED,
+        status.UNIMPLEMENTED
+      ].includes(code))
+        throw new ModalCommandStartRejectedError(code, error);
+      throw new ModalCommandStartOutcomeUnknownError(request.taskId, request.execId, error);
+    }
+  }
+  async start(request, signal) {
+    const prepared = await this.prepareStart(request, signal);
+    await this.dispatchPreparedStart(prepared, signal);
+  }
+  async write(identity, offset, data, signal) {
+    if (!Number.isSafeInteger(offset) || offset < 0)
+      throw new Error("Invalid Modal stdin byte offset");
+    await this.unary(
+      "TaskExecStdinWrite",
+      "Write",
+      "Empty",
+      { ...identity, offset, data, eof: false },
+      signal
+    );
+  }
+  async poll(identity, signal) {
+    const value = await this.unary("TaskExecPoll", "Identity", "Poll", identity, signal);
+    const decoded = modalRouterWire.lookupType("Poll").toObject(value);
+    if (decoded.code !== void 0) return decoded.code;
+    if (decoded.signal !== void 0) return 128 + decoded.signal;
+    return null;
+  }
+  async read(identity, stream, offset, waitMs, signal) {
+    signal?.throwIfAborted();
+    if (this.closed) throw new Error("Modal command router is closed");
+    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isFinite(waitMs) || waitMs < 0 || waitMs > 5e4)
+      throw new Error("Invalid Modal output read bounds");
+    const chunks = [];
+    let length = 0;
+    let limited = false;
+    return await new Promise((resolve7, reject) => {
+      const call = this.client.makeServerStreamRequest(
+        prefix + "TaskExecStdioRead",
+        (value) => encode("Read", value),
+        (bytes) => modalRouterWire.lookupType("Data").decode(bytes),
+        { ...identity, offset, fileDescriptor: stream === "stdout" ? 0 : 1 },
+        this.metadata,
+        { deadline: Date.now() + Math.max(1, waitMs) }
+      );
+      const abort = () => call.cancel();
+      const finish = (eof, error) => {
+        signal?.removeEventListener("abort", abort);
+        if (signal?.aborted) reject(signal.reason);
+        else if (error) reject(error);
+        else resolve7({ bytes: Buffer.concat(chunks, length), eof });
+      };
+      call.on("data", (value) => {
+        if (limited) return;
+        const part = Buffer.from(value.data).subarray(0, MODAL_ROUTER_READ_PAGE_BYTES - length);
+        if (part.length) {
+          chunks.push(part);
+          length += part.length;
+        }
+        if (length === MODAL_ROUTER_READ_PAGE_BYTES) {
+          limited = true;
+          call.cancel();
+        }
+      });
+      call.once("error", (error) => {
+        if (limited && error.code === status.CANCELLED || error.code === status.DEADLINE_EXCEEDED)
+          finish(false);
+        else finish(false, error);
+      });
+      call.once("end", () => finish(!limited));
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) abort();
+    });
+  }
+};
+
+// src/sandbox/providers/modal-legacy-command-control.ts
+import { ModalLegacyProviderCommand } from "@opengeni/contracts";
+
+// src/sandbox/providers/modal-command-argv.ts
+function modalCommandArgv(args) {
+  const command = [
+    args.shell ?? "/bin/sh",
+    args.shell && (args.login ?? true) ? "-lc" : "-c",
+    args.cmd
+  ];
+  if (!args.runAs) return command;
+  return [
+    "/bin/sh",
+    "-c",
+    `user=$1; shift; if [ "$(id -u)" = "$user" ] || [ "$(id -un 2>/dev/null)" = "$user" ]; then exec "$@"; elif [ "$(id -u)" = 0 ]; then exec su -s /bin/sh -c 'exec "$@"' -- "$user" sh "$@"; else exec sudo -n -u "$user" -- "$@"; fi`,
+    "opengeni-run-as",
+    args.runAs,
+    ...command
+  ];
+}
+
+// src/sandbox/providers/modal-legacy-command-control.ts
+var modalCommandAbortMiddleware = async function* (call, options) {
+  options.signal?.throwIfAborted();
+  return yield* call.next(call.request, options);
+};
+var ModalClientBase = ModalClient;
+var ModalCommandClient = class extends ModalClientBase {
+  retryMiddleware() {
+    return modalCommandAbortMiddleware;
+  }
+};
+var controlClients = /* @__PURE__ */ new WeakMap();
+function commandControlPlane(client) {
+  if (!client.profile) return client.cpClient;
+  if (typeof Reflect.get(ModalClient.prototype, "retryMiddleware") !== "function")
+    throw new Error("Verified Modal command cancellation contract is unavailable");
+  let controlled = controlClients.get(client);
+  if (!controlled) {
+    const profile = client.profile;
+    if (!profile.tokenId || !profile.tokenSecret)
+      throw new Error("Modal command control requires its original authenticated profile");
+    controlled = new ModalCommandClient({
+      tokenId: profile.tokenId,
+      tokenSecret: profile.tokenSecret,
+      endpoint: profile.serverUrl,
+      environment: profile.environment ?? "",
+      ...profile.maxThrottleWaitSecs !== void 0 ? { maxThrottleWaitSecs: profile.maxThrottleWaitSecs } : {},
+      ...client.logger ? { logger: client.logger } : {}
+    });
+    controlClients.set(client, controlled);
+  }
+  return controlled.cpClient;
+}
+function decodePage(prior, input, terminal) {
+  const bytes = Buffer.concat([Buffer.from(prior, "base64"), ...input]);
+  let boundary = bytes.length;
+  if (!terminal) {
+    for (let start = Math.max(0, bytes.length - 3); start < bytes.length; start++) {
+      const first = bytes[start];
+      const width = first >= 194 && first <= 223 ? 2 : first >= 224 && first <= 239 ? 3 : first >= 240 && first <= 244 ? 4 : 0;
+      if (!width || bytes.length - start >= width) continue;
+      const suffix = bytes.subarray(start + 1);
+      if (!suffix.every((byte) => byte >= 128 && byte <= 191)) continue;
+      const second = suffix[0];
+      if (second !== void 0 && (first === 224 && second < 160 || first === 237 && second > 159 || first === 240 && second < 144 || first === 244 && second > 143))
+        continue;
+      boundary = start;
+      break;
+    }
+  }
+  return {
+    text: bytes.subarray(0, boundary).toString("utf8"),
+    remainder: bytes.subarray(boundary).toString("base64")
+  };
+}
+var ModalCommandControl = class _ModalCommandControl {
+  constructor(client, sandboxIdentity, root, environment = {}) {
+    this.client = client;
+    this.sandboxIdentity = sandboxIdentity;
+    this.root = root;
+    this.environment = environment;
+  }
+  static forSandbox(client, sandboxId, root, environment = {}) {
+    if (client.version() !== "0.9.0")
+      throw new Error("Modal command control requires the verified 0.9.0 SDK contract");
+    return new _ModalCommandControl(commandControlPlane(client), sandboxId, root, environment);
+  }
+  get sandboxId() {
+    return typeof this.sandboxIdentity === "function" ? this.sandboxIdentity() : this.sandboxIdentity;
+  }
+  async start(args, signal) {
+    signal?.throwIfAborted();
+    const workdir = posix.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 sandboxId = this.sandboxId;
+    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");
+    let command = modalCommandArgv(args);
+    const environment = typeof this.environment === "function" ? this.environment() : this.environment;
+    if (Object.keys(environment).length) {
+      command = [
+        "/usr/bin/env",
+        "--",
+        ...Object.entries(environment).map(([key, value]) => `${key}=${value}`),
+        ...command
+      ];
+    }
+    const result = await this.client.containerExec(
+      {
+        taskId: task.taskId,
+        command,
+        terminateContainerOnExit: false,
+        runtimeDebug: false,
+        stdoutOutput: 2,
+        stderrOutput: 2,
+        timeoutSecs: 0,
+        workdir,
+        secretIds: [],
+        ...args.tty ? {
+          ptyInfo: {
+            enabled: true,
+            winszRows: 24,
+            winszCols: 80,
+            envTerm: "xterm",
+            envColorterm: "",
+            envTermProgram: "",
+            ptyType: 1,
+            noTerminateOnIdleStdin: true
+          }
+        } : {}
+      },
+      { retries: 0, ...signal ? { signal } : {} }
+    ).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,
+      taskId: task.taskId,
+      execId: result.execId,
+      ...args.tty ? { pty: true } : {},
+      streams: {
+        stdout: { batchIndex: 0, utf8Remainder: "", exitCode: null },
+        stderr: { batchIndex: 0, utf8Remainder: "", exitCode: null }
+      }
+    };
+  }
+  async read(command, yieldTimeMs, signal) {
+    return this.readOutput(command, yieldTimeMs, signal);
+  }
+  /** Fixed internal probes own their cancellation controller and must drain
+   * both reads before relinquishing the surrounding provider-operation gate.
+   * Retained-command readers keep their existing signal/receipt contract.
+   */
+  async readProbe(command, yieldTimeMs, cancellation) {
+    return this.readOutput(
+      command,
+      yieldTimeMs,
+      cancellation.signal,
+      (error) => cancellation.abort(error)
+    );
+  }
+  async readOutput(command, yieldTimeMs, signal, cancelSiblings) {
+    signal?.throwIfAborted();
+    this.assertIdentity(command);
+    const next = structuredClone(command);
+    let failure;
+    const reads = ["stdout", "stderr"].map(async (stream) => {
+      const cursor = command.streams[stream];
+      if (cursor.exitCode !== null) return null;
+      const descriptor = stream === "stdout" ? 1 : 2;
+      for await (const batch of this.client.containerExecGetOutput(
+        {
+          execId: command.execId,
+          timeout: Math.max(0, yieldTimeMs) / 1e3,
+          lastBatchIndex: cursor.batchIndex,
+          fileDescriptor: descriptor,
+          getRawBytes: true
+        },
+        signal ? { signal } : void 0
+      )) {
+        if (batch.batchIndex <= cursor.batchIndex) continue;
+        if (!Number.isSafeInteger(batch.batchIndex))
+          throw new Error("Invalid Modal output cursor");
+        const terminal = batch.exitCode !== void 0;
+        if (terminal && !Number.isSafeInteger(batch.exitCode))
+          throw new Error("Invalid Modal exit status");
+        const decoded = decodePage(
+          cursor.utf8Remainder,
+          batch.items.filter((item) => item.fileDescriptor === descriptor).map((item) => item.messageBytes),
+          terminal
+        );
+        next.streams[stream] = {
+          batchIndex: batch.batchIndex,
+          utf8Remainder: decoded.remainder,
+          exitCode: terminal ? batch.exitCode : null
+        };
+        return {
+          stream,
+          chunkId: `modal:${command.execId}:${stream}:${cursor.batchIndex}:${batch.batchIndex}`,
+          text: decoded.text
+        };
+      }
+      return null;
+    }).map(
+      (read) => !cancelSiblings ? read : read.catch((error) => {
+        failure ??= { error };
+        cancelSiblings(error);
+        throw error;
+      })
+    );
+    const pages = cancelSiblings ? await Promise.allSettled(reads).then((results) => {
+      if (failure) throw failure.error;
+      return results.map((result) => {
+        if (result.status === "rejected") throw result.reason;
+        return result.value;
+      });
+    }) : await Promise.all(reads);
+    const stdoutExit = next.streams.stdout.exitCode;
+    const stderrExit = next.streams.stderr.exitCode;
+    if (stdoutExit !== null && stderrExit !== null && stdoutExit !== stderrExit)
+      throw new Error("Modal output streams disagree about command exit status");
+    return {
+      command: next,
+      streamFidelity: command.pty ? "merged" : "separate",
+      chunks: pages.filter((page) => page !== null),
+      exitCode: stdoutExit !== null && stderrExit !== null ? stdoutExit : null
+    };
+  }
+  async write(command, chars, messageIndex) {
+    this.assertIdentity(command);
+    if (!chars) return;
+    if (!Number.isSafeInteger(messageIndex) || messageIndex < 1)
+      throw new Error("Modal stdin requires a protected monotonic message index");
+    await this.client.containerExecPutInput(
+      {
+        execId: command.execId,
+        input: { message: Buffer.from(chars), messageIndex, eof: false }
+      },
+      { retries: 0 }
+    );
+  }
+  assertIdentity(command) {
+    ModalLegacyProviderCommand.parse(command);
+    if (command.kind !== "modal-control-v1" || command.sandboxId !== this.sandboxId || !command.taskId || !command.execId)
+      throw new Error("Modal command locator does not match the original sandbox");
+  }
+};
+
+// src/sandbox/providers/modal-command-raw-page.ts
+var RawStream = external_exports.object({
+  bytes: external_exports.instanceof(Uint8Array).transform((bytes) => bytes).refine(
+    (bytes) => bytes.byteLength <= MODAL_ROUTER_READ_PAGE_BYTES,
+    "Raw page exceeded its bound"
+  ),
+  eof: external_exports.boolean()
+}).strict();
+var RawExit = external_exports.discriminatedUnion("source", [
+  external_exports.object({ source: external_exports.literal("router_poll"), code: external_exports.number().int().nullable() }).strict(),
+  external_exports.object({ source: external_exports.literal("retained_terminal"), code: external_exports.number().int() }).strict()
+]);
+var RawPage = external_exports.object({
+  protocol: external_exports.literal("modal-router-raw-page-v1"),
+  expected: ModalRouterProviderCommand2,
+  command: ModalRouterProviderCommand2,
+  streams: external_exports.object({ stdout: RawStream, stderr: RawStream }).strict(),
+  exit: RawExit
+}).strict();
+function project(expected, streams, exit) {
+  const command = structuredClone(expected);
+  const chunks = [];
+  for (const stream of ["stdout", "stderr"]) {
+    const old = expected.streams[stream];
+    const page = streams[stream];
+    const decoded = decodePage(old.utf8Remainder, [page.bytes], page.eof);
+    const byteOffset = old.byteOffset + page.bytes.byteLength;
+    if (!Number.isSafeInteger(byteOffset)) throw new Error("Modal output offset exhausted");
+    command.streams[stream] = {
+      byteOffset,
+      utf8Remainder: decoded.remainder,
+      eof: page.eof,
+      exitCode: page.eof ? exit.code : null
+    };
+    if (decoded.text)
+      chunks.push({
+        stream,
+        chunkId: `modal-router:${expected.execId}:${stream}:${old.byteOffset}:${byteOffset}:${page.eof ? 1 : 0}`,
+        text: decoded.text
+      });
+  }
+  return {
+    command,
+    expected: structuredClone(expected),
+    chunks,
+    exitCode: command.streams.stdout.eof && command.streams.stderr.eof ? exit.code : null,
+    providerExited: exit.code !== null,
+    streamFidelity: expected.pty ? "merged" : "separate"
+  };
+}
+function collectModalRawOutputPage(command, streams, exit) {
+  const expected = structuredClone(command);
+  const captured = {
+    stdout: { bytes: Buffer.from(streams.stdout.bytes), eof: streams.stdout.eof },
+    stderr: { bytes: Buffer.from(streams.stderr.bytes), eof: streams.stderr.eof }
+  };
+  const output = project(expected, captured, exit);
+  return {
+    raw: {
+      protocol: "modal-router-raw-page-v1",
+      expected,
+      command: structuredClone(output.command),
+      streams: captured,
+      exit: { ...exit }
+    },
+    output
+  };
+}
+function reduceModalRawOutputPage(input, current) {
+  const page = RawPage.parse(input);
+  const expected = ModalRouterProviderCommand2.parse(current);
+  if (!isDeepStrictEqual(page.expected, expected))
+    throw new Error("Raw page does not match the current native cursor");
+  for (const stream of ["stdout", "stderr"]) {
+    const old = expected.streams[stream];
+    const raw = page.streams[stream];
+    const remainder = Buffer.from(old.utf8Remainder, "base64");
+    if (remainder.toString("base64") !== old.utf8Remainder || remainder.length > 3 || remainder.length > old.byteOffset || old.eof && remainder.length !== 0)
+      throw new Error("Raw page has an invalid saved UTF-8 remainder");
+    if (old.eof && (!raw.eof || raw.bytes.byteLength !== 0))
+      throw new Error("Raw page reopened or advanced a completed stream");
+    if (old.exitCode !== null && page.exit.code !== old.exitCode)
+      throw new Error("Raw page rewrote captured terminal evidence");
+  }
+  if (page.exit.source === "retained_terminal" && (!expected.streams.stdout.eof || !expected.streams.stderr.eof || expected.streams.stdout.exitCode !== page.exit.code || expected.streams.stderr.exitCode !== page.exit.code))
+    throw new Error("Raw page has no matching retained terminal evidence");
+  const output = project(expected, page.streams, page.exit);
+  if (!isDeepStrictEqual(page.command, output.command))
+    throw new Error("Raw page cursor delta or remainder does not match its bytes");
+  return output;
+}
+
 // src/sandbox/host-archive-spool.ts
 import { createHash as createHash2 } from "crypto";
 import { constants as constants2 } from "fs";
@@ -9138,7 +10055,7 @@ import { dirname as dirname3, join as join5, relative as relative3, sep as sep3
 
 // ../../node_modules/.bun/@openai+agents-core@0.14.3+933c5e7db4cd33c2/node_modules/@openai/agents-core/dist/sandbox/sandboxes/shared/localSnapshotPaths.mjs
 import { homedir, tmpdir as tmpdir3 } from "os";
-import { posix, win32 } from "path";
+import { posix as posix2, win32 } from "path";
 function isAbsoluteWindowsPath(value) {
   const root = win32.parse(value).root;
   return win32.isAbsolute(value) && root.length > 1;
@@ -9150,14 +10067,14 @@ function defaultLocalSnapshotBaseDir() {
   }
   const home = homedir();
   if (process.platform === "darwin" && home) {
-    return posix.join(home, "Library", "Application Support", "openai-agents-js", "sandbox-snapshots");
+    return posix2.join(home, "Library", "Application Support", "openai-agents-js", "sandbox-snapshots");
   }
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA?.trim();
     return win32.join(localAppData && isAbsoluteWindowsPath(localAppData) ? localAppData : home ? win32.join(home, "AppData", "Local") : tmpdir3(), "openai-agents-js", "sandbox-snapshots");
   }
   const stateHome = process.env.XDG_STATE_HOME?.trim();
-  return posix.join(stateHome && posix.isAbsolute(stateHome) ? stateHome : home ? posix.join(home, ".local", "state") : tmpdir3(), "openai-agents-js", "sandbox-snapshots");
+  return posix2.join(stateHome && posix2.isAbsolute(stateHome) ? stateHome : home ? posix2.join(home, ".local", "state") : tmpdir3(), "openai-agents-js", "sandbox-snapshots");
 }
 
 // ../../node_modules/.bun/@openai+agents-core@0.14.3+933c5e7db4cd33c2/node_modules/@openai/agents-core/dist/sandbox/sandboxes/shared/localSnapshots.mjs
@@ -15452,7 +16369,19 @@ function createActiveProcess(process2) {
     droppedStderrChars: 0,
     done: false,
     exitCode: null,
-    donePromise: Promise.resolve()
+    donePromise: Promise.resolve(),
+    failed: false
+  };
+  let notifyFailure;
+  activeProcess.failurePromise = new Promise((resolve7) => {
+    notifyFailure = resolve7;
+  });
+  const errors = [];
+  const recordFailure = (error) => {
+    errors.push(error);
+    activeProcess.failed = true;
+    activeProcess.waitError = errors.length === 1 ? error : new AggregateError([...errors], "Modal process observation failed.");
+    notifyFailure();
   };
   const stdoutPump = startTextStreamPump(process2.stdout, (chunk) => {
     appendActiveProcessOutput2(activeProcess, chunk, "stdout");
@@ -15460,19 +16389,19 @@ function createActiveProcess(process2) {
   const stderrPump = startTextStreamPump(process2.stderr, (chunk) => {
     appendActiveProcessOutput2(activeProcess, chunk, "stderr");
   });
+  const stdoutDone = stdoutPump.promise.catch(recordFailure);
+  const stderrDone = stderrPump.promise.catch(recordFailure);
   activeProcess.stopOutputPumps = async () => {
     await Promise.allSettled([stdoutPump.cancel(), stderrPump.cancel()]);
   };
   activeProcess.donePromise = (async () => {
     try {
       activeProcess.exitCode = await process2.wait();
-      await Promise.allSettled([stdoutPump.promise, stderrPump.promise]);
     } catch (error) {
-      activeProcess.waitError = error;
-      await Promise.allSettled([stdoutPump.promise, stderrPump.promise]);
-    } finally {
-      activeProcess.done = true;
+      recordFailure(error);
     }
+    await Promise.all([stdoutDone, stderrDone]);
+    activeProcess.done = true;
   })();
   return activeProcess;
 }
@@ -15528,6 +16457,7 @@ async function waitForProcessOrTimeout2(activeProcess, timeoutMs) {
   try {
     await Promise.race([
       activeProcess.donePromise,
+      activeProcess.failurePromise,
       new Promise((resolve7) => {
         timeout = setTimeout(resolve7, timeoutMs);
         unrefTimer(timeout);
@@ -15538,13 +16468,13 @@ async function waitForProcessOrTimeout2(activeProcess, timeoutMs) {
       clearTimeout(timeout);
     }
   }
-  if (activeProcess.waitError) {
+  if (activeProcess.failed) {
     await activeProcess.stopOutputPumps?.();
-    throw new SandboxProviderError("ModalSandboxClient failed to wait for process completion.", {
+    throw Object.assign(new SandboxProviderError("ModalSandboxClient failed to wait for process completion.", {
       provider: "modal",
       operation: "wait process",
       cause: modalErrorMessage(activeProcess.waitError)
-    });
+    }), { cause: activeProcess.waitError });
   }
 }
 function modalErrorMessage(error) {
@@ -15889,661 +16819,213 @@ function writeFilesPrelude(input) {
     input.sha256Function,
     `og_fail() { printf '%s' "$1"; exit "$2"; }`,
     `root=$(opengeni_realpath_existing ${shellQuote3(input.root)}) || og_fail __OPENGENI_FS_NOT_FOUND__ 66`,
-    `og_confined() { case "$1" in "$root"|"\${root%/}/"*) return 0 ;; *) return 1 ;; esac; }`,
-    // A directory on the path is never a symbolic link and always resolves
-    // beneath the workspace root. A missing one returns 1 for the caller.
-    [
-      "og_dir() {",
-      `[ ! -L "$2" ] || og_fail "__OPENGENI_FS_SYMLINK__D$1__" 68`,
-      `[ -e "$2" ] || return 1`,
-      `[ -d "$2" ] || og_fail "__OPENGENI_FS_NOT_DIR__D$1__" 69`,
-      `og_t=$(opengeni_realpath_existing "$2") || og_fail "__OPENGENI_FS_NOT_FOUND__D$1__" 66`,
-      `og_confined "$og_t" || og_fail "__OPENGENI_FS_ESCAPE__D$1__" 67`,
-      "}"
-    ].join("\n"),
-    // 0: the exact bytes already exist. 1: missing. Anything else fails.
-    [
-      "og_file() {",
-      `if [ -L "$2" ]; then og_fail "__OPENGENI_FS_CONFLICT__F$1__" 65; fi`,
-      `[ -e "$2" ] || return 1`,
-      `[ -f "$2" ] || og_fail "__OPENGENI_FS_CONFLICT__F$1__" 65`,
-      `og_n=$(wc -c < "$2") || og_fail "__OPENGENI_FS_CONFLICT__F$1__" 65`,
-      `[ "$((og_n))" = "$3" ] || og_fail "__OPENGENI_FS_CONFLICT__F$1__" 65`,
-      `og_h=$(opengeni_sha256_file "$2") || og_fail "__OPENGENI_FS_UNVERIFIED__F$1__" 65`,
-      `[ "$og_h" = "$4" ] || og_fail "__OPENGENI_FS_CONFLICT__F$1__" 65`,
-      "}"
-    ].join("\n"),
-    [
-      "og_mk() {",
-      `mkdir -- "$2" 2>/dev/null || og_fail "__OPENGENI_FS_WRITE_FAILED__D$1__" 70`,
-      `printf '__OGF_D__%s__' "$1"`,
-      `og_dir "$1" "$2" || og_fail "__OPENGENI_FS_NOT_FOUND__D$1__" 66`,
-      "}"
-    ].join("\n"),
-    // noclobber opens a missing path with O_EXCL, so a file that appeared
-    // since the check (including a dangling symlink) is never replaced. A
-    // failed open exits 1 and leaves the path alone. Once the open succeeded
-    // the file is this call's own, so a failed or short write (a full disk,
-    // for example) removes it; otherwise a repeat would find a truncated file
-    // and report a conflict instead of finishing the write.
-    [
-      "og_put() {",
-      `( set -C; { printf '%s' "$4" | base64 -d || exit 72; } > "$2" ) 2>/dev/null`,
-      "og_s=$?",
-      `[ "$og_s" != 72 ] || { rm -f -- "$2"; og_fail "__OPENGENI_FS_WRITE_FAILED__F$1__" 71; }`,
-      `[ "$og_s" = 0 ] || og_fail "__OPENGENI_FS_WRITE_FAILED__F$1__" 71`,
-      `og_n=$(wc -c < "$2") && [ "$((og_n))" = "$3" ] || { rm -f -- "$2"; og_fail "__OPENGENI_FS_WRITE_FAILED__F$1__" 71; }`,
-      `printf '__OGF_W__%s__' "$1"`,
-      "}"
-    ].join("\n")
-  ];
-}
-function directoryCheckFragment(directory) {
-  return `og_dir ${directory.index} ${shellQuote3(directory.providerPath)} || :`;
-}
-function fileCheckFragment(file, mode) {
-  const check = `og_file ${file.index} ${shellQuote3(file.providerPath)} ${file.sizeBytes} ${file.sha256}`;
-  const missing = mode === "check" ? `printf '__OGF_M__%s__' ${file.index}` : `og_m${file.index}=1`;
-  return `if ${check}; then printf '__OGF_S__%s__' ${file.index}; else ${missing}; fi`;
-}
-function directoryCreateFragment(directory) {
-  const path = shellQuote3(directory.providerPath);
-  return `og_dir ${directory.index} ${path} || og_mk ${directory.index} ${path}`;
-}
-function filePutFragment(file) {
-  if (file.base64 === void 0) throw new Error("write mode requires file content");
-  return `[ -z "\${og_m${file.index}:-}" ] || og_put ${file.index} ${shellQuote3(file.providerPath)} ${file.sizeBytes} ${shellQuote3(file.base64)}`;
-}
-function writeFilesScript(input) {
-  const lines = [...input.prelude];
-  for (const directory of input.directories) lines.push(directoryCheckFragment(directory));
-  for (const file of input.files) lines.push(fileCheckFragment(file, input.mode));
-  if (input.mode === "write") {
-    for (const directory of input.directories) lines.push(directoryCreateFragment(directory));
-    for (const file of input.files) lines.push(filePutFragment(file));
-  }
-  lines.push(`printf '%s' ${BATCH_OK}`);
-  return lines.join("\n");
-}
-function parseWriteFilesOutput(stdout) {
-  const output = {
-    complete: stdout.includes(BATCH_OK),
-    same: [],
-    missing: [],
-    written: [],
-    createdDirectories: [],
-    failure: null
-  };
-  for (const match of stdout.matchAll(/__OGF_([SMWD])__(\d+)__/g)) {
-    const index = Number(match[2]);
-    if (match[1] === "S") output.same.push(index);
-    else if (match[1] === "M") output.missing.push(index);
-    else if (match[1] === "W") output.written.push(index);
-    else output.createdDirectories.push(index);
-  }
-  const failure = /__OPENGENI_FS_(CONFLICT|UNVERIFIED|SYMLINK|NOT_DIR|NOT_FOUND|ESCAPE|WRITE_FAILED)__(?:([DF])(\d+)__)?/.exec(
-    stdout
-  );
-  if (failure) {
-    output.failure = {
-      code: failure[1],
-      target: failure[2] ? { kind: failure[2] === "D" ? "directory" : "file", index: Number(failure[3]) } : null
-    };
-  }
-  return output;
-}
-
-// src/sandbox/exec-banner.ts
-var typedHandleLossSessions = /* @__PURE__ */ new WeakSet();
-function markTypedExecHandleLoss(session) {
-  typedHandleLossSessions.add(session);
-}
-function hasTypedExecHandleLoss(session, providerSessionId) {
-  if (!session) return false;
-  if (typedHandleLossSessions.has(session)) return true;
-  const routed = session;
-  return providerSessionId !== void 0 && routed.retainedProcessHasTypedHandleLoss?.(providerSessionId) === true;
-}
-var EXEC_BANNER_HEADER_MAX_CHARS = 16 * 1024;
-var OUTPUT_DELIMITER = /\r?\nOutput:\r?\n/u;
-var SDK_METADATA_LINE = /^(?:Chunk ID:|Wall time:|Original token count:|Output:|Process (?:running with session ID|exited with code))/mu;
-var RUNNING_LINE = /^Process running with session ID (\d+)$/u;
-var EXITED_LINE = /^Process exited with code (-?\d+)$/u;
-var PROCESS_STATUS_PREFIX = /^Process (?:running with session ID|exited with code)/u;
-function parseExecResponseBanner(raw) {
-  const delimiter = OUTPUT_DELIMITER.exec(raw);
-  if (!delimiter) {
-    return SDK_METADATA_LINE.test(raw) ? { kind: "invalid" } : { kind: "absent" };
-  }
-  if (delimiter.index > EXEC_BANNER_HEADER_MAX_CHARS) return { kind: "invalid" };
-  const header = raw.slice(0, delimiter.index);
-  const status4 = [];
-  for (const line of header.split(/\r?\n/u)) {
-    const running = RUNNING_LINE.exec(line);
-    if (running) {
-      status4.push({ kind: "running", value: running[1] });
-      continue;
-    }
-    const exited = EXITED_LINE.exec(line);
-    if (exited) {
-      status4.push({ kind: "exited", value: exited[1] });
-      continue;
-    }
-    if (PROCESS_STATUS_PREFIX.test(line)) return { kind: "invalid" };
-  }
-  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") {
-    return value >= 0 ? { kind: "running", sessionId: value } : { kind: "invalid" };
-  }
-  return { kind: "exited", exitCode: value };
-}
-function parseExecBannerSessionId(raw) {
-  const banner = parseExecResponseBanner(raw);
-  return banner.kind === "running" ? banner.sessionId : null;
-}
-function parseExecBannerExitCode(raw) {
-  const banner = parseExecResponseBanner(raw);
-  return banner.kind === "exited" ? banner.exitCode : null;
-}
-function isExecSessionLostBanner(out, execSessionId, source) {
-  if (source && typedHandleLossSessions.has(source)) return false;
-  if (!out || !Number.isSafeInteger(execSessionId) || execSessionId < 0) return false;
-  const delimiter = OUTPUT_DELIMITER.exec(out);
-  if (delimiter && delimiter.index > EXEC_BANNER_HEADER_MAX_CHARS) return false;
-  if (delimiter && parseExecResponseBanner(out).kind !== "exited") return false;
-  const candidate = delimiter ? out.slice(delimiter.index + delimiter[0].length) : out;
-  const match = candidate.match(/^(?:write_stdin failed: )?session not found: (\d+)$/);
-  if (!match || match[0] !== candidate) return false;
-  return match[1] === String(execSessionId);
-}
-
-// src/sandbox/op-correlation.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var storage = new AsyncLocalStorage2();
-function sanitizeOpIdToken(raw) {
-  return raw.replace(/[^A-Za-z0-9_-]/g, (c) => `_${c.charCodeAt(0).toString(16)}_`);
-}
-function runWithToolCallCorrelation(callId, fn, options = {}) {
-  return storage.run(
-    {
-      callId: sanitizeOpIdToken(callId),
-      ordinal: 0,
-      ...options.onDurableOpOwnershipTransferStarted ? { onDurableOpOwnershipTransferStarted: options.onDurableOpOwnershipTransferStarted } : {},
-      ...options.onDurableOpOwnershipTransferred ? { onDurableOpOwnershipTransferred: options.onDurableOpOwnershipTransferred } : {}
-    },
-    fn
-  );
-}
-function nextDurableOpId() {
-  const context = storage.getStore();
-  if (!context) {
-    return null;
-  }
-  const ordinal = context.ordinal;
-  context.ordinal += 1;
-  return `${context.callId}:${ordinal}`;
-}
-function notifyDurableOpOwnershipTransferStarted(opId) {
-  storage.getStore()?.onDurableOpOwnershipTransferStarted?.(opId);
-}
-function notifyDurableOpOwnershipTransferred(opId) {
-  storage.getStore()?.onDurableOpOwnershipTransferred?.(opId);
-}
-
-// src/sandbox/routing/routing-session.ts
-import { SandboxFilesystemNotFoundError } from "modal";
-
-// src/sandbox/providers/modal-command-router-wire.ts
-import { Client, Metadata, credentials, status } from "@grpc/grpc-js";
-import protobuf from "protobufjs";
-
-// src/sandbox/providers/modal-command-start-errors.ts
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
-import { ModalRouterProviderCommand } from "@opengeni/contracts";
-var boundaryBrand = Symbol.for("opengeni.modal.command-start.boundary.v1");
-var invocationBrand = Symbol.for("opengeni.modal.command-start.invocation.v1");
-var contextBrand = Symbol.for("opengeni.modal.command-start.context.v1");
-var startSignal = new AsyncLocalStorage3();
-function withModalCommandStartSignal(signal, operation) {
-  signal.throwIfAborted();
-  return startSignal.run(signal, operation);
-}
-function installModalCommandStartContext(modal) {
-  if (Object.getOwnPropertyDescriptor(modal, contextBrand)) return;
-  Object.defineProperty(modal, contextBrand, { value: () => startSignal.getStore() });
-}
-function modalCommandStartOwnData(value, key) {
-  const property = Object.getOwnPropertyDescriptor(value, key);
-  return property && "value" in property ? property.value : void 0;
-}
-function modalCommandStartHasOwnAccessor(value, key) {
-  const property = Object.getOwnPropertyDescriptor(value, key);
-  return !!property && !("value" in property);
-}
-function getModalCommandStartInvocation(error) {
-  const pending = [{ value: error, depth: 0 }];
-  const seen = /* @__PURE__ */ new WeakSet();
-  let result = null;
-  let inspected = 0;
-  while (pending.length) {
-    if (++inspected > 64) return null;
-    const { value, depth } = pending.shift();
-    if (!value || typeof value !== "object" || seen.has(value)) continue;
-    if (depth > 8) return null;
-    seen.add(value);
-    try {
-      if (["cause", "error", "errors"].some((key) => modalCommandStartHasOwnAccessor(value, key)))
-        return null;
-      if (hasModalCommandStartBoundary(value, "outcome-unknown")) {
-        const descriptor = modalCommandStartOwnData(value, invocationBrand);
-        if (!descriptor || typeof descriptor !== "object" || !Object.isFrozen(descriptor))
-          return null;
-        const sandboxId = modalCommandStartOwnData(descriptor, "sandboxId");
-        const taskId = modalCommandStartOwnData(descriptor, "taskId");
-        const execId = modalCommandStartOwnData(descriptor, "execId");
-        const observe = modalCommandStartOwnData(descriptor, "observe");
-        const ptyProperty = Object.getOwnPropertyDescriptor(descriptor, "pty");
-        if (ptyProperty && (!("value" in ptyProperty) || typeof ptyProperty.value !== "boolean"))
-          return null;
-        if (typeof sandboxId !== "string" || !sandboxId || typeof taskId !== "string" || !taskId || typeof execId !== "string" || !execId || typeof observe !== "function")
-          return null;
-        if (result && result !== descriptor) return null;
-        result = descriptor;
-      }
-      const nested = [
-        modalCommandStartOwnData(value, "cause"),
-        modalCommandStartOwnData(value, "error")
-      ].filter((child) => child !== void 0);
-      const errors = modalCommandStartOwnData(value, "errors");
-      if (errors !== void 0) {
-        if (!Array.isArray(errors)) return null;
-        const length = modalCommandStartOwnData(errors, "length");
-        if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 1 || length > 32)
-          return null;
-        for (let index = 0; index < length; index++) {
-          const property = Object.getOwnPropertyDescriptor(errors, String(index));
-          if (!property || !("value" in property) || !property.value || typeof property.value !== "object")
-            return null;
-          nested.push(property.value);
-        }
-      }
-      if (depth === 8 && nested.length) return null;
-      for (const child of nested) pending.push({ value: child, depth: depth + 1 });
-    } catch {
-      return null;
-    }
-  }
-  return result;
-}
-function modalCommandStartRetainedError(error) {
-  if (error instanceof ProviderCommandStartOutcomeUnknownError) return error;
-  const invocation = getModalCommandStartInvocation(error);
-  if (!invocation) return error;
-  const cursor = () => ({ byteOffset: 0, utf8Remainder: "", eof: false, exitCode: null });
-  const command = ModalRouterProviderCommand.safeParse({
-    kind: "modal-router-v1",
-    sandboxId: invocation.sandboxId,
-    taskId: invocation.taskId,
-    execId: invocation.execId,
-    ...invocation.pty === void 0 ? {} : { pty: invocation.pty },
-    streams: { stdout: cursor(), stderr: cursor() }
-  });
-  return command.success ? new ProviderCommandStartOutcomeUnknownError(command.data, error) : error;
-}
-function hasModalCommandStartOutcomeUnknownBoundary(error) {
-  const pending = [{ value: error, depth: 0 }];
-  const seen = /* @__PURE__ */ new WeakSet();
-  for (let inspected = 0; pending.length && inspected < 64; inspected++) {
-    const { value, depth } = pending.shift();
-    if (!value || typeof value !== "object" || seen.has(value)) continue;
-    seen.add(value);
-    if (hasModalCommandStartBoundary(value, "outcome-unknown")) return true;
-    if (depth >= 8) continue;
-    try {
-      for (const key of ["cause", "error"]) {
-        const nested = modalCommandStartOwnData(value, key);
-        if (nested !== void 0) pending.push({ value: nested, depth: depth + 1 });
-      }
-      const errors = modalCommandStartOwnData(value, "errors");
-      if (Array.isArray(errors))
-        for (let index = 0; index < Math.min(errors.length, 32); index++)
-          pending.push({
-            value: modalCommandStartOwnData(errors, String(index)),
-            depth: depth + 1
-          });
-    } catch {
-    }
-  }
-  return false;
-}
-function modalCommandStartCleanupIsSafe(error) {
-  const pending = [{ value: error, depth: 0 }];
-  const seen = /* @__PURE__ */ new WeakSet();
-  let inspected = 0;
-  while (pending.length) {
-    if (++inspected > 64) return false;
-    const { value, depth } = pending.shift();
-    if (!value || typeof value !== "object" && typeof value !== "function") continue;
-    if (seen.has(value)) continue;
-    if (depth > 8) return false;
-    seen.add(value);
-    try {
-      if (value instanceof ProviderCommandStartOutcomeUnknownError || hasModalCommandStartBoundary(value, "outcome-unknown") || [boundaryBrand, "cause", "error", "errors"].some(
-        (key) => modalCommandStartHasOwnAccessor(value, key)
-      ))
-        return false;
-      const nested = [
-        modalCommandStartOwnData(value, "cause"),
-        modalCommandStartOwnData(value, "error")
-      ].filter((child) => child !== void 0 && child !== null);
-      const errors = modalCommandStartOwnData(value, "errors");
-      if (errors !== void 0) {
-        if (!Array.isArray(errors)) return false;
-        const length = modalCommandStartOwnData(errors, "length");
-        if (typeof length !== "number" || !Number.isSafeInteger(length) || length > 32)
-          return false;
-        for (let index = 0; index < length; index++) {
-          const property = Object.getOwnPropertyDescriptor(errors, String(index));
-          if (!property || !("value" in property) || !property.value || typeof property.value !== "object" && typeof property.value !== "function")
-            return false;
-          nested.push(property.value);
-        }
-      }
-      if (depth === 8 && nested.length) return false;
-      for (const child of nested) pending.push({ value: child, depth: depth + 1 });
-    } catch {
-      return false;
-    }
-  }
-  return true;
-}
-function installModalCommandStartRetention(session) {
-  for (const name of [
-    "execCommand",
-    "applyManifest",
-    "materializeEntry",
-    "hydrateWorkspace",
-    "persistWorkspace",
-    "runDirectCommand",
-    "runAsCommandRunner"
-  ]) {
-    const operation = Reflect.get(session, name);
-    if (typeof operation !== "function") continue;
-    Reflect.set(session, name, async function(...args) {
-      try {
-        return await operation.apply(session, args);
-      } catch (error) {
-        throw modalCommandStartRetainedError(error);
-      }
-    });
-  }
-}
-function hasModalCommandStartBoundary(error, kind) {
-  if (!error || typeof error !== "object") return false;
-  try {
-    const property = Object.getOwnPropertyDescriptor(error, boundaryBrand);
-    return property?.value === kind && property.writable === false && property.configurable === false;
-  } catch {
-    return false;
-  }
+    `og_confined() { case "$1" in "$root"|"\${root%/}/"*) return 0 ;; *) return 1 ;; esac; }`,
+    // A directory on the path is never a symbolic link and always resolves
+    // beneath the workspace root. A missing one returns 1 for the caller.
+    [
+      "og_dir() {",
+      `[ ! -L "$2" ] || og_fail "__OPENGENI_FS_SYMLINK__D$1__" 68`,
+      `[ -e "$2" ] || return 1`,
+      `[ -d "$2" ] || og_fail "__OPENGENI_FS_NOT_DIR__D$1__" 69`,
+      `og_t=$(opengeni_realpath_existing "$2") || og_fail "__OPENGENI_FS_NOT_FOUND__D$1__" 66`,
+      `og_confined "$og_t" || og_fail "__OPENGENI_FS_ESCAPE__D$1__" 67`,
+      "}"
+    ].join("\n"),
+    // 0: the exact bytes already exist. 1: missing. Anything else fails.
+    [
+      "og_file() {",
+      `if [ -L "$2" ]; then og_fail "__OPENGENI_FS_CONFLICT__F$1__" 65; fi`,
+      `[ -e "$2" ] || return 1`,
+      `[ -f "$2" ] || og_fail "__OPENGENI_FS_CONFLICT__F$1__" 65`,
+      `og_n=$(wc -c < "$2") || og_fail "__OPENGENI_FS_CONFLICT__F$1__" 65`,
+      `[ "$((og_n))" = "$3" ] || og_fail "__OPENGENI_FS_CONFLICT__F$1__" 65`,
+      `og_h=$(opengeni_sha256_file "$2") || og_fail "__OPENGENI_FS_UNVERIFIED__F$1__" 65`,
+      `[ "$og_h" = "$4" ] || og_fail "__OPENGENI_FS_CONFLICT__F$1__" 65`,
+      "}"
+    ].join("\n"),
+    [
+      "og_mk() {",
+      `mkdir -- "$2" 2>/dev/null || og_fail "__OPENGENI_FS_WRITE_FAILED__D$1__" 70`,
+      `printf '__OGF_D__%s__' "$1"`,
+      `og_dir "$1" "$2" || og_fail "__OPENGENI_FS_NOT_FOUND__D$1__" 66`,
+      "}"
+    ].join("\n"),
+    // noclobber opens a missing path with O_EXCL, so a file that appeared
+    // since the check (including a dangling symlink) is never replaced. A
+    // failed open exits 1 and leaves the path alone. Once the open succeeded
+    // the file is this call's own, so a failed or short write (a full disk,
+    // for example) removes it; otherwise a repeat would find a truncated file
+    // and report a conflict instead of finishing the write.
+    [
+      "og_put() {",
+      `( set -C; { printf '%s' "$4" | base64 -d || exit 72; } > "$2" ) 2>/dev/null`,
+      "og_s=$?",
+      `[ "$og_s" != 72 ] || { rm -f -- "$2"; og_fail "__OPENGENI_FS_WRITE_FAILED__F$1__" 71; }`,
+      `[ "$og_s" = 0 ] || og_fail "__OPENGENI_FS_WRITE_FAILED__F$1__" 71`,
+      `og_n=$(wc -c < "$2") && [ "$((og_n))" = "$3" ] || { rm -f -- "$2"; og_fail "__OPENGENI_FS_WRITE_FAILED__F$1__" 71; }`,
+      `printf '__OGF_W__%s__' "$1"`,
+      "}"
+    ].join("\n")
+  ];
 }
-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/providers/modal-command-router-wire.ts
-var modalRouterWire = protobuf.parse(`syntax = "proto3";
-message Identity { string task_id = 1; string exec_id = 2; }
-message Pty {
-  bool enabled = 1; uint32 winsz_rows = 2; uint32 winsz_cols = 3;
-  string env_term = 4; string env_colorterm = 5; string env_term_program = 6;
-  int32 pty_type = 7; bool no_terminate_on_idle_stdin = 8;
+function directoryCheckFragment(directory) {
+  return `og_dir ${directory.index} ${shellQuote3(directory.providerPath)} || :`;
 }
-message Start {
-  string task_id = 1; string exec_id = 2; repeated string command_args = 3;
-  int32 stdout_config = 4; int32 stderr_config = 5;
-  optional uint32 timeout_secs = 6; optional string workdir = 7;
-  repeated string secret_ids = 8; optional Pty pty_info = 9;
-  bool runtime_debug = 10; string container_id = 11; map<string,string> env = 12;
+function fileCheckFragment(file, mode) {
+  const check = `og_file ${file.index} ${shellQuote3(file.providerPath)} ${file.sizeBytes} ${file.sha256}`;
+  const missing = mode === "check" ? `printf '__OGF_M__%s__' ${file.index}` : `og_m${file.index}=1`;
+  return `if ${check}; then printf '__OGF_S__%s__' ${file.index}; else ${missing}; fi`;
 }
-message Read {
-  string task_id = 1; string exec_id = 2; uint64 offset = 3; int32 file_descriptor = 4;
+function directoryCreateFragment(directory) {
+  const path = shellQuote3(directory.providerPath);
+  return `og_dir ${directory.index} ${path} || og_mk ${directory.index} ${path}`;
 }
-message Data { bytes data = 1; }
-message Poll { optional int32 code = 1; optional int32 signal = 2; }
-message Write {
-  string task_id = 1; string exec_id = 2; uint64 offset = 3; bytes data = 4; bool eof = 5;
+function filePutFragment(file) {
+  if (file.base64 === void 0) throw new Error("write mode requires file content");
+  return `[ -z "\${og_m${file.index}:-}" ] || og_put ${file.index} ${shellQuote3(file.providerPath)} ${file.sizeBytes} ${shellQuote3(file.base64)}`;
 }
-message Empty {}
-`).root;
-var prefix = "/modal.task_command_router.TaskCommandRouter/";
-var MODAL_ROUTER_READ_PAGE_BYTES = 1024 * 1024;
-var maxWireBytes = 4 * 1024 * 1024;
-var ModalCommandStartRejectedError = class extends ProviderCommandStartRejectedError {
-  constructor(code, cause) {
-    super(cause);
-    this.code = code;
-    this.name = "ModalCommandStartRejectedError";
-  }
-};
-var ModalCommandStartPreDispatchUnavailableError = class _ModalCommandStartPreDispatchUnavailableError extends Error {
-  constructor(cause) {
-    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) => {
-      let settled = false;
-      const finish = (error) => {
-        if (settled) return;
-        settled = true;
-        signal?.removeEventListener("abort", abort);
-        if (signal?.aborted) reject(signal.reason);
-        else if (error) reject(new _ModalCommandStartPreDispatchUnavailableError(error));
-        else resolve7();
-      };
-      const abort = () => finish();
-      signal?.addEventListener("abort", abort, { once: true });
-      client.waitForReady(Date.now() + 5e3, finish);
-      if (signal?.aborted) abort();
-    });
-  }
-};
-var ModalCommandStartNotDispatchedError = class extends Error {
-  constructor(cause) {
-    super(cause instanceof Error ? cause.message : "Modal command Start was never dispatched", {
-      cause
-    });
-    this.name = "ModalCommandStartNotDispatchedError";
+function writeFilesScript(input) {
+  const lines = [...input.prelude];
+  for (const directory of input.directories) lines.push(directoryCheckFragment(directory));
+  for (const file of input.files) lines.push(fileCheckFragment(file, input.mode));
+  if (input.mode === "write") {
+    for (const directory of input.directories) lines.push(directoryCreateFragment(directory));
+    for (const file of input.files) lines.push(filePutFragment(file));
   }
-};
-function encode(type, value) {
-  const codec = modalRouterWire.lookupType(type);
-  return Buffer.from(codec.encode(codec.fromObject(value)).finish());
+  lines.push(`printf '%s' ${BATCH_OK}`);
+  return lines.join("\n");
 }
-var ModalCommandRouterWire = class {
-  client;
-  metadata;
-  closed = false;
-  constructor(access, trustedRoots) {
-    const url = new URL(access.url);
-    if (url.protocol !== "https:" || url.username || url.password || !access.jwt)
-      throw new Error("Modal command router requires authenticated TLS");
-    this.client = new Client(
-      `${url.hostname}:${url.port || "443"}`,
-      credentials.createSsl(trustedRoots),
-      {
-        "grpc.max_receive_message_length": maxWireBytes,
-        "grpc.max_send_message_length": maxWireBytes,
-        "grpc.enable_retries": 0,
-        // The HTTP/2 default 64 KiB window caps one read at 64 KiB per round
-        // trip. Two pages lets stdout and stderr each fill a page in one trip
-        // while bounding bytes discarded when a full read cancels its stream.
-        "grpc-node.flow_control_window": 2 * MODAL_ROUTER_READ_PAGE_BYTES
-      }
-    );
-    this.metadata = new Metadata();
-    this.metadata.set("authorization", `Bearer ${access.jwt}`);
+function parseWriteFilesOutput(stdout) {
+  const output = {
+    complete: stdout.includes(BATCH_OK),
+    same: [],
+    missing: [],
+    written: [],
+    createdDirectories: [],
+    failure: null
+  };
+  for (const match of stdout.matchAll(/__OGF_([SMWD])__(\d+)__/g)) {
+    const index = Number(match[2]);
+    if (match[1] === "S") output.same.push(index);
+    else if (match[1] === "M") output.missing.push(index);
+    else if (match[1] === "W") output.written.push(index);
+    else output.createdDirectories.push(index);
   }
-  close() {
-    this.closed = true;
-    this.client.close();
+  const failure = /__OPENGENI_FS_(CONFLICT|UNVERIFIED|SYMLINK|NOT_DIR|NOT_FOUND|ESCAPE|WRITE_FAILED)__(?:([DF])(\d+)__)?/.exec(
+    stdout
+  );
+  if (failure) {
+    output.failure = {
+      code: failure[1],
+      target: failure[2] ? { kind: failure[2] === "D" ? "directory" : "file", index: Number(failure[3]) } : null
+    };
   }
-  async unary(method, requestType, responseType, request, signal) {
-    signal?.throwIfAborted();
-    if (this.closed) throw new Error("Modal command router is closed");
-    return await new Promise((resolve7, reject) => {
-      const call = this.client.makeUnaryRequest(
-        prefix + method,
-        (value) => encode(requestType, value),
-        (bytes) => modalRouterWire.lookupType(responseType).decode(bytes),
-        request,
-        this.metadata,
-        { deadline: Date.now() + 3e4 },
-        (error, result) => {
-          signal?.removeEventListener("abort", abort);
-          if (signal?.aborted) reject(signal.reason);
-          else if (error) reject(error);
-          else if (result) resolve7(result);
-          else reject(new Error("Modal command router returned no response"));
-        }
-      );
-      const abort = () => call.cancel();
-      signal?.addEventListener("abort", abort, { once: true });
-      if (signal?.aborted) abort();
-    });
+  return output;
+}
+
+// src/sandbox/exec-banner.ts
+var typedHandleLossSessions = /* @__PURE__ */ new WeakSet();
+function markTypedExecHandleLoss(session) {
+  typedHandleLossSessions.add(session);
+}
+function hasTypedExecHandleLoss(session, providerSessionId) {
+  if (!session) return false;
+  if (typedHandleLossSessions.has(session)) return true;
+  const routed = session;
+  return providerSessionId !== void 0 && routed.retainedProcessHasTypedHandleLoss?.(providerSessionId) === true;
+}
+var EXEC_BANNER_HEADER_MAX_CHARS = 16 * 1024;
+var OUTPUT_DELIMITER = /\r?\nOutput:\r?\n/u;
+var SDK_METADATA_LINE = /^(?:Chunk ID:|Wall time:|Original token count:|Output:|Process (?:running with session ID|exited with code))/mu;
+var RUNNING_LINE = /^Process running with session ID (\d+)$/u;
+var EXITED_LINE = /^Process exited with code (-?\d+)$/u;
+var PROCESS_STATUS_PREFIX = /^Process (?:running with session ID|exited with code)/u;
+function parseExecResponseBanner(raw) {
+  const delimiter = OUTPUT_DELIMITER.exec(raw);
+  if (!delimiter) {
+    return SDK_METADATA_LINE.test(raw) ? { kind: "invalid" } : { kind: "absent" };
   }
-  async start(request, signal) {
-    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 ModalCommandStartNotDispatchedError(
-          new Error("Modal command router is closed", { cause: error })
-        );
-      if (error instanceof ModalCommandStartPreDispatchUnavailableError) throw error;
-      throw new ModalCommandStartNotDispatchedError(error);
+  if (delimiter.index > EXEC_BANNER_HEADER_MAX_CHARS) return { kind: "invalid" };
+  const header = raw.slice(0, delimiter.index);
+  const status4 = [];
+  for (const line of header.split(/\r?\n/u)) {
+    const running = RUNNING_LINE.exec(line);
+    if (running) {
+      status4.push({ kind: "running", value: running[1] });
+      continue;
     }
-    try {
-      await this.unary(
-        "TaskExecStart",
-        "Start",
-        "Empty",
-        {
-          ...request,
-          stdoutConfig: 1,
-          stderrConfig: 1
-        },
-        signal
-      );
-    } catch (error) {
-      const code = error?.code;
-      if (typeof code === "number" && [
-        status.INVALID_ARGUMENT,
-        status.NOT_FOUND,
-        status.PERMISSION_DENIED,
-        status.UNAUTHENTICATED,
-        status.UNIMPLEMENTED
-      ].includes(code))
-        throw new ModalCommandStartRejectedError(code, error);
-      throw new ModalCommandStartOutcomeUnknownError(request.taskId, request.execId, error);
+    const exited = EXITED_LINE.exec(line);
+    if (exited) {
+      status4.push({ kind: "exited", value: exited[1] });
+      continue;
     }
+    if (PROCESS_STATUS_PREFIX.test(line)) return { kind: "invalid" };
   }
-  async write(identity, offset, data, signal) {
-    if (!Number.isSafeInteger(offset) || offset < 0)
-      throw new Error("Invalid Modal stdin byte offset");
-    await this.unary(
-      "TaskExecStdinWrite",
-      "Write",
-      "Empty",
-      { ...identity, offset, data, eof: false },
-      signal
-    );
+  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") {
+    return value >= 0 ? { kind: "running", sessionId: value } : { kind: "invalid" };
   }
-  async poll(identity, signal) {
-    const value = await this.unary("TaskExecPoll", "Identity", "Poll", identity, signal);
-    const decoded = modalRouterWire.lookupType("Poll").toObject(value);
-    if (decoded.code !== void 0) return decoded.code;
-    if (decoded.signal !== void 0) return 128 + decoded.signal;
+  return { kind: "exited", exitCode: value };
+}
+function parseExecBannerSessionId(raw) {
+  const banner = parseExecResponseBanner(raw);
+  return banner.kind === "running" ? banner.sessionId : null;
+}
+function parseExecBannerExitCode(raw) {
+  const banner = parseExecResponseBanner(raw);
+  return banner.kind === "exited" ? banner.exitCode : null;
+}
+function isExecSessionLostBanner(out, execSessionId, source) {
+  if (source && typedHandleLossSessions.has(source)) return false;
+  if (!out || !Number.isSafeInteger(execSessionId) || execSessionId < 0) return false;
+  const delimiter = OUTPUT_DELIMITER.exec(out);
+  if (delimiter && delimiter.index > EXEC_BANNER_HEADER_MAX_CHARS) return false;
+  if (delimiter && parseExecResponseBanner(out).kind !== "exited") return false;
+  const candidate = delimiter ? out.slice(delimiter.index + delimiter[0].length) : out;
+  const match = candidate.match(/^(?:write_stdin failed: )?session not found: (\d+)$/);
+  if (!match || match[0] !== candidate) return false;
+  return match[1] === String(execSessionId);
+}
+
+// src/sandbox/op-correlation.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+var storage = new AsyncLocalStorage3();
+function sanitizeOpIdToken(raw) {
+  return raw.replace(/[^A-Za-z0-9_-]/g, (c) => `_${c.charCodeAt(0).toString(16)}_`);
+}
+function runWithToolCallCorrelation(callId, fn, options = {}) {
+  return storage.run(
+    {
+      callId: sanitizeOpIdToken(callId),
+      ordinal: 0,
+      ...options.onDurableOpOwnershipTransferStarted ? { onDurableOpOwnershipTransferStarted: options.onDurableOpOwnershipTransferStarted } : {},
+      ...options.onDurableOpOwnershipTransferred ? { onDurableOpOwnershipTransferred: options.onDurableOpOwnershipTransferred } : {}
+    },
+    fn
+  );
+}
+function nextDurableOpId() {
+  const context = storage.getStore();
+  if (!context) {
     return null;
   }
-  async read(identity, stream, offset, waitMs, signal) {
-    signal?.throwIfAborted();
-    if (this.closed) throw new Error("Modal command router is closed");
-    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isFinite(waitMs) || waitMs < 0 || waitMs > 5e4)
-      throw new Error("Invalid Modal output read bounds");
-    const chunks = [];
-    let length = 0;
-    let limited = false;
-    return await new Promise((resolve7, reject) => {
-      const call = this.client.makeServerStreamRequest(
-        prefix + "TaskExecStdioRead",
-        (value) => encode("Read", value),
-        (bytes) => modalRouterWire.lookupType("Data").decode(bytes),
-        { ...identity, offset, fileDescriptor: stream === "stdout" ? 0 : 1 },
-        this.metadata,
-        { deadline: Date.now() + Math.max(1, waitMs) }
-      );
-      const abort = () => call.cancel();
-      const finish = (eof, error) => {
-        signal?.removeEventListener("abort", abort);
-        if (signal?.aborted) reject(signal.reason);
-        else if (error) reject(error);
-        else resolve7({ bytes: Buffer.concat(chunks, length), eof });
-      };
-      call.on("data", (value) => {
-        if (limited) return;
-        const part = Buffer.from(value.data).subarray(0, MODAL_ROUTER_READ_PAGE_BYTES - length);
-        if (part.length) {
-          chunks.push(part);
-          length += part.length;
-        }
-        if (length === MODAL_ROUTER_READ_PAGE_BYTES) {
-          limited = true;
-          call.cancel();
-        }
-      });
-      call.once("error", (error) => {
-        if (limited && error.code === status.CANCELLED || error.code === status.DEADLINE_EXCEEDED)
-          finish(false);
-        else finish(false, error);
-      });
-      call.once("end", () => finish(!limited));
-      signal?.addEventListener("abort", abort, { once: true });
-      if (signal?.aborted) abort();
-    });
-  }
-};
+  const ordinal = context.ordinal;
+  context.ordinal += 1;
+  return `${context.callId}:${ordinal}`;
+}
+function notifyDurableOpOwnershipTransferStarted(opId) {
+  storage.getStore()?.onDurableOpOwnershipTransferStarted?.(opId);
+}
+function notifyDurableOpOwnershipTransferred(opId) {
+  storage.getStore()?.onDurableOpOwnershipTransferred?.(opId);
+}
 
 // src/sandbox/routing/routing-session.ts
-import { isDeepStrictEqual } from "util";
+import { SandboxFilesystemNotFoundError } from "modal";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 
 // src/sandbox/materialization-verification-error.ts
 var EXPLANATIONS = {
@@ -17615,6 +18097,11 @@ var RoutingSandboxSession = class {
         () => write.call(record.backend.session, args)
       );
     } catch (error) {
+      let inputUnknown = false;
+      try {
+        inputUnknown = error instanceof ProviderCommandInputOutcomeUnknownError;
+      } catch {
+      }
       if (this.deps.afterProcessMutation) {
         const pending = {
           op,
@@ -17629,11 +18116,21 @@ var RoutingSandboxSession = class {
           record.pendingMutationSettlement = pending;
           throw new RoutingMutationOutcomeUnknownError(
             op,
-            `Retained-process stdin rejected at the provider but lost durable settlement; it was not replayed`,
-            { cause: settlementError }
+            inputUnknown ? "Retained-process stdin acknowledgement and durable settlement unavailable; input may have been accepted. Do not resend stdin." : "Retained-process stdin rejected at the provider but lost durable settlement; it was not replayed",
+            inputUnknown ? {
+              cause: new AggregateError([error, settlementError]),
+              retainedProcess: record.process
+            } : { cause: settlementError }
           );
         }
       }
+      if (inputUnknown) {
+        throw new RoutingMutationOutcomeUnknownError(
+          op,
+          "Provider stdin acknowledgement unavailable; input may have been accepted and was not resent. Do not resend stdin.",
+          { cause: error, retainedProcess: record.process }
+        );
+      }
       throw error;
     }
     if (this.deps.afterProcessMutation) {
@@ -17993,7 +18490,7 @@ var RoutingSandboxSession = class {
                           { retainedProcess: process2 }
                         );
                       const persisted = await this.deps.providerCommandPersistence(process2).load();
-                      if (!persisted || !isDeepStrictEqual(persisted, command))
+                      if (!persisted || !isDeepStrictEqual2(persisted, command))
                         throw new Error(
                           "Supervised launch reservation did not retain the exact invocation"
                         );
@@ -18362,7 +18859,13 @@ var RoutingSandboxSession = class {
   async writeStdin(args) {
     const providerSessionId = providerSessionIdFromArgs(args);
     if (providerSessionId !== null && this.retainedProcesses.has(providerSessionId)) {
-      return await this.dispatchProcessMutation(args);
+      try {
+        return await this.dispatchProcessMutation(args);
+      } catch (error) {
+        if (isRoutingMutationOutcomeUnknownError(error))
+          return renderRoutingMutationOutcomeUnknownToolResult(error);
+        throw error;
+      }
     }
     return this.dispatch("writeStdin", true, async (s) => {
       if (!s.writeStdin) {
@@ -18383,6 +18886,18 @@ var RoutingSandboxSession = class {
   hasRetainedProcess(providerSessionId) {
     return positiveProviderSessionId(providerSessionId) !== null && this.retainedProcesses.has(providerSessionId);
   }
+  /** A reaper may have settled the command while a local capture/control receipt
+   * remained pending. Cleanup may consume that same durable proof without
+   * replaying a provider operation or accepting pending output into the model. */
+  async reconcileRetainedProcess(providerSessionId) {
+    const record = this.retainedProcesses.get(providerSessionId);
+    if (!record || !this.deps.isProcessSettled) return false;
+    if (!await this.deps.isProcessSettled({ backend: record.backend, process: record.process }))
+      return false;
+    if (this.retainedProcesses.get(providerSessionId) !== record) return false;
+    this.retainedProcesses.delete(providerSessionId);
+    return true;
+  }
   /** Local, Docker, and OpenSandbox process ids address an in-memory table on one worker
    * session object. They are not valid durable locators for the independently
    * scheduled reaper, so their yielded handles stay turn-owned until terminal
@@ -18583,40 +19098,15 @@ var RoutingSandboxSession = class {
   async writePlacementPrivate(args) {
     const input = placementPrivateWrite(args);
     return this.dispatch("writePlacementPrivate", false, async (session, backend) => {
-      if (session.writePlacementPrivate) return await session.writePlacementPrivate(input);
-      if (session.writeFile) return await session.writeFile(input);
-      return await streamPlacementPrivateFile(session, input, backend.kind);
+      return await writePlacementPrivateOnBackend(session, input, backend.kind);
     });
   }
   /** Delete only an OpenGeni placement-private staging file. This narrow
    * control operation cannot be repurposed into a generic mutation bypass. */
   async deletePlacementPrivate(path, runAs) {
     const privatePath = placementPrivatePath(path);
-    await this.dispatch("deletePlacementPrivate", false, async (session) => {
-      if (session.deletePlacementPrivate) {
-        await session.deletePlacementPrivate(privatePath, runAs);
-        return;
-      }
-      const args = {
-        cmd: `rm -f ${shellSingleQuote(privatePath)}`,
-        ...runAs ? { runAs } : {}
-      };
-      if (session.exec) {
-        const result = await session.exec(args);
-        if (result && typeof result === "object" && typeof result.exitCode === "number" && result.exitCode !== 0) {
-          throw new Error("placement-private cleanup failed");
-        }
-        return;
-      }
-      if (session.execCommand) {
-        const result = await session.execCommand(args);
-        const exitCode = parseExecBannerExitCode(result);
-        if (exitCode !== null && exitCode !== 0) {
-          throw new Error("placement-private cleanup failed");
-        }
-        return;
-      }
-      throw new RoutingUnsupportedError("deletePlacementPrivate", this.cached?.kind ?? "unknown");
+    await this.dispatch("deletePlacementPrivate", false, async (session, backend) => {
+      await deletePlacementPrivateOnBackend(session, privatePath, runAs, backend.kind);
     });
   }
   /** Keep private download authority and its consuming import on one exact
@@ -18625,7 +19115,7 @@ var RoutingSandboxSession = class {
   async importWorkspaceFileOnResolvedBackend(input) {
     return await this.dispatch("importWorkspaceFile", true, async (session, backend) => {
       const channel = new SandboxChannelAService({
-        session,
+        session: withPlacementPrivateControl(session, backend.kind),
         workspaceRoot: input.workspaceRoot,
         ...backend.kind === "selfhosted" ? { providerPathMode: "workspace-relative" } : {},
         revision: input.revision,
@@ -18641,7 +19131,7 @@ var RoutingSandboxSession = class {
   async importWorkspaceFilesOnResolvedBackend(input) {
     return await this.dispatch("importWorkspaceFiles", true, async (session, backend) => {
       const channel = new SandboxChannelAService({
-        session,
+        session: withPlacementPrivateControl(session, backend.kind),
         workspaceRoot: input.workspaceRoot,
         ...backend.kind === "selfhosted" ? { providerPathMode: "workspace-relative" } : {},
         revision: input.revision,
@@ -18875,8 +19365,59 @@ function placementPrivateWrite(value) {
     ...typeof input.runAs === "string" ? { runAs: input.runAs } : {}
   };
 }
+function withPlacementPrivateControl(session, backendKind) {
+  return new Proxy(session, {
+    get(target, property) {
+      if (property === "writePlacementPrivate") {
+        return async (args) => await writePlacementPrivateOnBackend(target, placementPrivateWrite(args), backendKind);
+      }
+      if (property === "deletePlacementPrivate") {
+        return async (path, runAs) => await deletePlacementPrivateOnBackend(
+          target,
+          placementPrivatePath(path),
+          runAs,
+          backendKind
+        );
+      }
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+async function writePlacementPrivateOnBackend(session, input, backendKind) {
+  if (session.writePlacementPrivate) return await session.writePlacementPrivate(input);
+  if (session.writeFile) return await session.writeFile(input);
+  return await streamPlacementPrivateFile(session, input, backendKind);
+}
+async function deletePlacementPrivateOnBackend(session, privatePath, runAs, backendKind) {
+  if (session.deletePlacementPrivate) {
+    await session.deletePlacementPrivate(privatePath, runAs);
+    return;
+  }
+  const args = {
+    cmd: `rm -f ${shellSingleQuote(privatePath)}`,
+    ...runAs ? { runAs } : {}
+  };
+  if (session.exec) {
+    const result = await session.exec(args);
+    if (result && typeof result === "object" && typeof result.exitCode === "number" && result.exitCode !== 0) {
+      throw new Error("placement-private cleanup failed");
+    }
+    return;
+  }
+  if (session.execCommand) {
+    const result = await session.execCommand(args);
+    const exitCode = parseExecBannerExitCode(result);
+    if (exitCode !== null && exitCode !== 0) {
+      throw new Error("placement-private cleanup failed");
+    }
+    return;
+  }
+  throw new RoutingUnsupportedError("deletePlacementPrivate", backendKind);
+}
 async function streamPlacementPrivateFile(session, input, backendKind) {
-  if (!session.exec || !session.writeStdin) {
+  const exec = session.exec?.bind(session) ?? session.execCommand?.bind(session);
+  if (!exec || !session.writeStdin) {
     throw new RoutingUnsupportedError("writePlacementPrivate", backendKind);
   }
   const bytes = typeof input.content === "string" ? Buffer.from(input.content) : input.content;
@@ -18887,7 +19428,7 @@ async function streamPlacementPrivateFile(session, input, backendKind) {
     ...input.createParents ? [`install -d -m 0700 -- ${shellSingleQuote(parent)}`] : []
   ];
   if (bytes.byteLength === 0) {
-    const result = await session.exec({
+    const result = await exec({
       cmd: [
         ...prelude,
         `: > ${shellSingleQuote(input.path)}`,
@@ -18914,7 +19455,7 @@ async function streamPlacementPrivateFile(session, input, backendKind) {
     `chmod 0600 -- ${shellSingleQuote(input.path)}`,
     `printf %s ${shellSingleQuote(marker)}`
   ].join("; ");
-  const started = await session.exec({
+  const started = await exec({
     cmd: command,
     ...input.runAs ? { runAs: input.runAs } : {},
     yieldTimeMs: 250,
@@ -19179,8 +19720,14 @@ function cancellableShellCommand(command, markerPath) {
     'case "$__opengeni_outer_pid:$__opengeni_outer_pgid" in *[!0-9:]*|*:|:*) exit 125 ;; esac',
     'if [ "$__opengeni_outer_pid" != "$__opengeni_outer_pgid" ]; then',
     '  __opengeni_setsid="$(command -v setsid 2>/dev/null)"',
-    '  [ -n "$__opengeni_setsid" ] || exit 125',
-    `  exec "$__opengeni_setsid" /bin/sh -c ${singleQuote(groupLeaderCommand)}`,
+    '  if [ -n "$__opengeni_setsid" ]; then',
+    `    exec "$__opengeni_setsid" /bin/sh -c ${singleQuote(groupLeaderCommand)}`,
+    "  fi",
+    // macOS has setsid(2), but no setsid executable. The parent is proven
+    // not to be a group leader, so the same process can safely start a session.
+    '  __opengeni_python="$(command -v python3 2>/dev/null)"',
+    '  [ -n "$__opengeni_python" ] || exit 125',
+    `  exec "$__opengeni_python" -c ${singleQuote('import os,sys; os.setsid(); os.execv("/bin/sh", ["/bin/sh", "-c", sys.argv[1]])')} ${singleQuote(groupLeaderCommand)}`,
     "fi",
     groupLeaderCommand
   ].join("\n");
@@ -19282,6 +19829,12 @@ function retainedProcessSession(session, providerSessionId) {
   return session?.hasRetainedProcess?.(providerSessionId) === true ? session : null;
 }
 function renderDirectToolFault(error, retainedProcessSessionId) {
+  if (error instanceof ProviderCommandInputOutcomeUnknownError) {
+    return `Command input acknowledgement unavailable${retainedProcessSessionId === void 0 ? "" : ` for session ID ${retainedProcessSessionId}`}. The input may have been accepted; its outcome is unknown and it was not resent. Do not resend stdin. Inspect the existing command with write_stdin using empty chars.`;
+  }
+  if (isProviderCommandObservationUnavailableError(error)) {
+    return `Command observation unavailable${retainedProcessSessionId === void 0 ? "" : ` for session ID ${retainedProcessSessionId}`}. Outcome unknown; the original invocation remains retained. Do not replay the command or resend stdin; observe the existing command.`;
+  }
   try {
     const terminal = error;
     if (retainedProcessSessionId !== void 0 && Number.isSafeInteger(retainedProcessSessionId) && terminal.name === "SandboxRetainedProcessTerminalError" && terminal.code === "process_fenced") {
@@ -19353,6 +19906,7 @@ function wrapComputer(computer, track) {
 }
 var TurnToolCancellationControllerImpl = class {
   cancelled = false;
+  observationCancellation = new AbortController();
   reason;
   inFlight = /* @__PURE__ */ new Set();
   shellSessions = /* @__PURE__ */ new Map();
@@ -19375,6 +19929,7 @@ var TurnToolCancellationControllerImpl = class {
     if (!this.cancelled) {
       this.cancelled = true;
       this.reason = reason;
+      this.observationCancellation.abort(cancellationError(reason));
       this.signal?.removeEventListener("abort", this.onAbort);
     }
     void this.ensureDrain().catch(() => void 0);
@@ -19422,6 +19977,7 @@ var TurnToolCancellationControllerImpl = class {
         }
         const directArgs = {
           sessionId: parsed.session_id,
+          signal: this.observationCancellation.signal,
           ...typeof parsed.chars === "string" ? { chars: parsed.chars } : {},
           ...typeof parsed.yield_time_ms === "number" ? { yieldTimeMs: parsed.yield_time_ms } : {},
           ...typeof parsed.max_output_tokens === "number" ? { maxOutputTokens: parsed.max_output_tokens } : {}
@@ -19808,6 +20364,7 @@ var TurnToolCancellationControllerImpl = class {
           const directProcessSession = sessionId === null ? null : retainedProcessSession(cancellationSession, sessionId);
           const typedHandleLoss = sessionId !== null && (hasTypedExecHandleLoss(cancellationSession, sessionId) || this.shellSessions.get(sessionId)?.typedHandleLoss === true);
           let output;
+          let initialObservationFailure;
           if (sessionId !== null && directProcessSession?.writeStdinForProcessMutation) {
             try {
               output = await directProcessSession.writeStdinForProcessMutation({
@@ -19817,7 +20374,10 @@ var TurnToolCancellationControllerImpl = class {
                 ...typeof parsed?.max_output_tokens === "number" ? { maxOutputTokens: parsed.max_output_tokens } : {}
               });
             } catch (error) {
-              return renderDirectToolFault(error, sessionId);
+              if (!(error instanceof ProviderCommandObservationUnavailableError))
+                return renderDirectToolFault(error, sessionId);
+              initialObservationFailure = error;
+              output = "";
             }
           } else {
             output = await tool.invoke(runContext, cappedInput, details);
@@ -19863,6 +20423,7 @@ var TurnToolCancellationControllerImpl = class {
           return state && typeof output === "string" ? await this.awaitModelFacingShellResult({
             state,
             initialOutput: output,
+            ...initialObservationFailure ? { initialObservationFailure } : {},
             startedAt,
             waitMs: modelWaitMs(parsed?.yield_time_ms),
             maxOutputTokens: typeof parsed?.max_output_tokens === "number" ? parsed.max_output_tokens : 2e4
@@ -19887,11 +20448,13 @@ var TurnToolCancellationControllerImpl = class {
       this.shellSessions.delete(state.sessionId);
       return input.initialOutput;
     }
-    if (parseExecBannerSessionId(input.initialOutput) !== state.sessionId) {
+    if (!input.initialObservationFailure && parseExecBannerSessionId(input.initialOutput) !== state.sessionId) {
       return input.initialOutput;
     }
     let output = appendBoundedOutput3("", execOutput(input.initialOutput), maxOutputTokens);
+    let observationFailure = input.initialObservationFailure ?? null;
     for (; ; ) {
+      if (observationFailure?.readRetryAllowed === false) break;
       if (performance.now() - startedAt >= waitMs) break;
       if (this.cancelled) throw cancellationError(this.reason);
       if (!state.writeInvoke && !state.processSession?.writeStdinForProcessRead && !state.processSession?.writeStdinForProcessControl) {
@@ -19903,21 +20466,33 @@ var TurnToolCancellationControllerImpl = class {
       if (remainingMs <= 0) break;
       const yieldTimeMs = Math.min(TURN_PROVIDER_YIELD_SLICE_MS, Math.ceil(remainingMs));
       const read = state.processSession?.writeStdinForProcessRead ?? state.processSession?.writeStdinForProcessControl;
-      const next = read ? await read.call(state.processSession, {
-        sessionId: state.sessionId,
-        chars: "",
-        yieldTimeMs,
-        maxOutputTokens
-      }) : await state.writeInvoke(
-        state.runContext,
-        JSON.stringify({
-          session_id: state.sessionId,
+      let next;
+      try {
+        next = read ? await read.call(state.processSession, {
+          sessionId: state.sessionId,
           chars: "",
-          yield_time_ms: yieldTimeMs,
-          max_output_tokens: maxOutputTokens
-        }),
-        void 0
-      );
+          yieldTimeMs,
+          maxOutputTokens,
+          signal: this.observationCancellation.signal
+        }) : await state.writeInvoke(
+          state.runContext,
+          JSON.stringify({
+            session_id: state.sessionId,
+            chars: "",
+            yield_time_ms: yieldTimeMs,
+            max_output_tokens: maxOutputTokens
+          }),
+          void 0
+        );
+      } catch (error) {
+        if (this.cancelled) throw cancellationError(this.reason);
+        if (!(error instanceof ProviderCommandObservationUnavailableError)) throw error;
+        observationFailure = error;
+        if (!error.readRetryAllowed) break;
+        await delay(Math.min(SHELL_POLL_MS, Math.max(0, waitMs - (performance.now() - startedAt))));
+        continue;
+      }
+      observationFailure = null;
       if (this.cancelled) throw cancellationError(this.reason);
       if (typeof next !== "string")
         throw new Error("Retained command read returned no provider status");
@@ -19937,6 +20512,13 @@ var TurnToolCancellationControllerImpl = class {
       }
       await delay(Math.min(SHELL_POLL_MS, Math.max(0, remainingMs)));
     }
+    if (observationFailure) {
+      const commandId = state.processSession?.retainedProcessIdentity?.(state.sessionId)?.id;
+      return `${renderDirectToolFault(observationFailure, state.sessionId)}${commandId ? `
+Command ID: ${commandId}` : ""}
+Output:
+${output}`;
+    }
     if (!canAdoptInBackground) {
       return `${runningCommandBanner(state.sessionId, output)}
 This process is turn-scoped; it will stop when this turn ends or is interrupted.
@@ -20017,7 +20599,13 @@ This process is turn-scoped; it will stop when this turn ends or is interrupted.
     return promise;
   }
   ensureDrain() {
-    this.drainPromise ??= this.drain();
+    if (!this.drainPromise) {
+      const drain = this.drain();
+      this.drainPromise = drain;
+      void drain.catch(() => {
+        if (this.drainPromise === drain) this.drainPromise = null;
+      });
+    }
     return this.drainPromise;
   }
   async drain() {
@@ -20160,8 +20748,43 @@ This process is turn-scoped; it will stop when this turn ends or is interrupted.
     });
     return state.cancellation;
   }
+  async reconcileSettledShellSession(state) {
+    try {
+      if (await state.processSession?.reconcileRetainedProcess?.(state.sessionId)) {
+        this.shellSessions.delete(state.sessionId);
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+  async awaitShellControl(state, operation) {
+    if (!state.processSession?.reconcileRetainedProcess)
+      return { reconciled: false, value: await operation };
+    const observed = operation.then(
+      (value) => ({ kind: "resolved", value }),
+      (error) => ({ kind: "rejected", error })
+    );
+    while (true) {
+      const result = await Promise.race([
+        observed,
+        delay(SHELL_POLL_MS).then(() => ({ kind: "pending" }))
+      ]);
+      if (result.kind === "resolved") return { reconciled: false, value: result.value };
+      if (result.kind === "rejected") throw result.error;
+      if (await this.reconcileSettledShellSession(state)) return { reconciled: true };
+    }
+  }
   async cancelShellSessionOnce(state) {
-    if (await state.processSession?.cancelSupervisedCommand?.(state.sessionId, "explicit_stop")) {
+    if (await this.reconcileSettledShellSession(state)) return;
+    const nativeCancellation = await this.awaitShellControl(
+      state,
+      Promise.resolve(
+        state.processSession?.cancelSupervisedCommand?.(state.sessionId, "explicit_stop")
+      )
+    );
+    if (nativeCancellation.reconciled) return;
+    if (nativeCancellation.value) {
       while (state.processSession?.hasRetainedProcess?.(state.sessionId) === true) {
         if (await this.rawWrite(state, "", SHELL_POLL_MS)) {
           await this.forgetShellSessionAfterExactSettlement(state);
@@ -20183,12 +20806,17 @@ This process is turn-scoped; it will stop when this turn ends or is interrupted.
     }
     if (state.token && state.processSession?.execCommandForProcessControl && state.processSession.writeStdinForProcessControl) {
       while (state.processSession.hasRetainedProcess?.(state.sessionId) === true) {
+        if (await this.reconcileSettledShellSession(state)) return;
         try {
-          const output = await state.processSession.execCommandForProcessControl(
-            state.sessionId,
-            shellHelperArgs(retainedShellCancellationCommand(state))
+          const control = await this.awaitShellControl(
+            state,
+            state.processSession.execCommandForProcessControl(
+              state.sessionId,
+              shellHelperArgs(retainedShellCancellationCommand(state))
+            )
           );
-          const exitCode = parseExecBannerExitCode(output);
+          if (control.reconciled) return;
+          const exitCode = parseExecBannerExitCode(control.value);
           if (exitCode === 0 || exitCode === RETAINED_SHELL_MARKER_PENDING_EXIT_CODE) {
             await this.forgetShellSessionAfterExactSettlement(state);
             return;
@@ -20251,23 +20879,29 @@ This process is turn-scoped; it will stop when this turn ends or is interrupted.
     this.shellSessions.delete(state.sessionId);
   }
   async rawWrite(state, chars, yieldTimeMs) {
+    if (await this.reconcileSettledShellSession(state)) return true;
     if (!state.writeInvoke && !state.processSession?.writeStdinForProcessControl) return false;
     try {
-      const output = state.processSession?.writeStdinForProcessControl ? await state.processSession.writeStdinForProcessControl({
-        sessionId: state.sessionId,
-        chars,
-        yieldTimeMs,
-        maxOutputTokens: 128
-      }) : await state.writeInvoke(
-        state.runContext,
-        JSON.stringify({
-          session_id: state.sessionId,
+      const control = await this.awaitShellControl(
+        state,
+        state.processSession?.writeStdinForProcessControl ? state.processSession.writeStdinForProcessControl({
+          sessionId: state.sessionId,
           chars,
-          yield_time_ms: yieldTimeMs,
-          max_output_tokens: 128
-        }),
-        void 0
+          yieldTimeMs,
+          maxOutputTokens: 128
+        }) : state.writeInvoke(
+          state.runContext,
+          JSON.stringify({
+            session_id: state.sessionId,
+            chars,
+            yield_time_ms: yieldTimeMs,
+            max_output_tokens: 128
+          }),
+          void 0
+        )
       );
+      if (control.reconciled) return true;
+      const output = control.value;
       if (typeof output !== "string") return false;
       if (!state.typedHandleLoss && isExecSessionLostBanner(output, state.sessionId)) return true;
       if (parseExecBannerSessionId(output) === state.sessionId) return false;
@@ -23471,9 +24105,180 @@ function parseUnifiedPatch(patch) {
 
 // src/sandbox/providers/modal-command-session.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
+
+// src/sandbox/provider-errors.ts
+var GRPC_TRANSIENT = /* @__PURE__ */ new Set([1, 2, 4, 13, 14]);
+var TRANSIENT_CODES = /* @__PURE__ */ new Set([
+  "1",
+  "2",
+  "4",
+  "13",
+  "14",
+  "CANCELLED",
+  "UNKNOWN",
+  "DEADLINE_EXCEEDED",
+  "INTERNAL",
+  "UNAVAILABLE",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EAI_AGAIN",
+  "ENOTFOUND"
+]);
+var NOT_FOUND_CODES = /* @__PURE__ */ new Set(["404", "NOT_FOUND", "RESOURCE_NOT_FOUND", "SANDBOX_NOT_FOUND"]);
+var SAFE_CODE = /^[A-Z0-9._:-]{1,64}$/;
+var UNREADABLE_ERROR_SIGNAL = Symbol("unreadable-error-signal");
+function safeRead(record, key) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(record, key);
+    return descriptor ? "value" in descriptor ? descriptor.value : UNREADABLE_ERROR_SIGNAL : void 0;
+  } catch {
+    return UNREADABLE_ERROR_SIGNAL;
+  }
+}
+function collectSignals(value) {
+  const out = { numbers: [], codes: [], messages: [], incomplete: false };
+  const seen = /* @__PURE__ */ new Set();
+  const read = (record, key) => {
+    const signal = safeRead(record, key);
+    if (signal !== UNREADABLE_ERROR_SIGNAL) return signal;
+    out.incomplete = true;
+    return void 0;
+  };
+  const visit = (current, depth) => {
+    if (current === null || current === void 0) return;
+    if (depth > 6 || seen.size >= 64) {
+      out.incomplete = true;
+      return;
+    }
+    if (typeof current === "string") {
+      if (current.length <= 512) out.messages.push(current);
+      return;
+    }
+    if (typeof current !== "object" || seen.has(current)) return;
+    seen.add(current);
+    for (const key of [
+      "status",
+      "statusCode",
+      "httpStatus",
+      "httpStatusCode",
+      "responseStatus",
+      "errorCode",
+      "code"
+    ]) {
+      const signal = read(current, key);
+      if (typeof signal === "number" && Number.isFinite(signal)) out.numbers.push(signal);
+      if (typeof signal === "string") {
+        const code = signal.trim().toUpperCase();
+        if (SAFE_CODE.test(code)) out.codes.push(code);
+      }
+    }
+    for (const key of ["name", "message", "details", "cause"]) {
+      const signal = read(current, key);
+      if (typeof signal === "string" && signal.length <= 512) out.messages.push(signal);
+      else visit(signal, depth + 1);
+    }
+    visit(read(current, "response"), depth + 1);
+    visit(read(current, "error"), depth + 1);
+    const errors = read(current, "errors");
+    if (errors !== void 0) {
+      if (!Array.isArray(errors) || !errors.length || errors.length > 16) out.incomplete = true;
+      else
+        for (let index = 0; index < errors.length; index++) {
+          const nested = read(errors, String(index));
+          if (!nested || typeof nested !== "object") out.incomplete = true;
+          visit(nested, depth + 1);
+        }
+    }
+  };
+  visit(value, 0);
+  return out;
+}
+function safeDiagnostic(signals) {
+  const code = signals.codes.find(Boolean);
+  const numeric = signals.numbers.find((value) => Number.isFinite(value));
+  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((status4) => GRPC_TRANSIENT.has(status4));
+}
+function hasModalTerminalSandboxMessage(signals) {
+  return signals.messages.some(
+    (message) => /^Modal sandbox [A-Za-z0-9_-]+ is no longer running\.$/.test(message) || /^Modal sandbox [A-Za-z0-9_-]+ not found \(has been terminated\)$/.test(message)
+  );
+}
+function hasUnixLocalTerminalWorkspaceMessage(signals) {
+  return signals.messages.includes(
+    "UnixLocal sandbox workspace is unavailable and no local snapshot could be restored."
+  );
+}
+function hasDockerTerminalWorkspaceMessage(signals) {
+  return signals.messages.includes(
+    "Docker sandbox resources are unavailable and no local snapshot could be restored."
+  );
+}
+function hasCloudflareTerminalSandboxMessage(signals) {
+  return signals.messages.some(
+    (message) => /^Cloudflare sandbox [A-Za-z0-9._:-]+ is no longer running\.$/.test(message)
+  );
+}
+function classifyProviderSandboxFailure(backendId, error) {
+  if (backendId === "selfhosted" || !error) {
+    return { kind: "other", diagnostic: "selfhosted-or-empty" };
+  }
+  const signals = collectSignals(error);
+  const diagnostic = safeDiagnostic(signals) || "unclassified_provider_failure";
+  if (hasTransientSignal(signals)) {
+    return { kind: "transient_transport", diagnostic };
+  }
+  if (signals.incomplete) return { kind: "other", diagnostic };
+  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)) {
+    return {
+      kind: "not_found",
+      diagnostic: diagnostic === "unclassified_provider_failure" ? "modal_terminal_message" : `${diagnostic} modal_terminal_message`
+    };
+  }
+  if (backendId === "cloudflare" && hasCloudflareTerminalSandboxMessage(signals)) {
+    return {
+      kind: "not_found",
+      diagnostic: diagnostic === "unclassified_provider_failure" ? "cloudflare_terminal_message" : `${diagnostic} cloudflare_terminal_message`
+    };
+  }
+  if ((backendId === "local" || backendId === "unix_local") && hasUnixLocalTerminalWorkspaceMessage(signals)) {
+    return {
+      kind: "not_found",
+      diagnostic: diagnostic === "unclassified_provider_failure" ? "unix_local_workspace_missing" : `${diagnostic} unix_local_workspace_missing`
+    };
+  }
+  if (backendId === "docker" && hasDockerTerminalWorkspaceMessage(signals)) {
+    return {
+      kind: "not_found",
+      diagnostic: diagnostic === "unclassified_provider_failure" ? "docker_resources_missing" : `${diagnostic} docker_resources_missing`
+    };
+  }
+  return { kind: "other", diagnostic };
+}
+function isProviderSandboxNotFoundError2(backendId, error) {
+  return classifyProviderSandboxFailure(backendId, error).kind === "not_found";
+}
+function isProviderSandboxGoneDuringRoutedOperation(backendId, error) {
+  if (backendId === "selfhosted" || !error) return false;
+  const signals = collectSignals(error);
+  if (hasTransientSignal(signals) || signals.incomplete) return false;
+  if (signals.codes.includes("SANDBOX_NOT_FOUND")) return true;
+  return backendId === "modal" && hasModalTerminalSandboxMessage(signals);
+}
+function isProviderSandboxTransientError(backendId, error) {
+  return classifyProviderSandboxFailure(backendId, error).kind === "transient_transport";
+}
 
 // src/sandbox/providers/modal-materialization-verification.ts
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
+import { setTimeout as delay2 } from "timers/promises";
 var MARKER = "__OPENGENI_MATERIALIZED_PATH_VISIBLE__";
 var OUTPUT_LIMIT = 16 * 1024;
 async function verifyModalMaterializedPath(control, path, workdir, pending, observationTimeoutMs = 3e4) {
@@ -23482,6 +24287,7 @@ async function verifyModalMaterializedPath(control, path, workdir, pending, obse
   const cancellation = new AbortController();
   const deadlineReason = new Error("Materialization visibility observation deadline exceeded");
   let providerCommand;
+  let startUnknown;
   let stdout = "";
   let stderr = "";
   const diagnostic = (reason, exitCode = null) => ({
@@ -23506,13 +24312,46 @@ async function verifyModalMaterializedPath(control, path, workdir, pending, obse
   timer.unref();
   pending.add(cancellation);
   try {
-    providerCommand = await control.start(
-      { cmd: command, workdir, shell: "sh", login: false, tty: false },
-      cancellation.signal
-    );
+    try {
+      providerCommand = await control.start(
+        { cmd: command, workdir, shell: "sh", login: false, tty: false },
+        cancellation.signal
+      );
+    } catch (error) {
+      if (!(error instanceof ProviderCommandStartOutcomeUnknownError)) throw error;
+      providerCommand = structuredClone(error.command);
+      startUnknown = error;
+    }
     for (; ; ) {
       cancellation.signal.throwIfAborted();
-      const page = await control.readProbe(providerCommand, 1e3, cancellation);
+      let page;
+      try {
+        page = await control.readProbe(providerCommand, 1e3, cancellation);
+      } catch (error) {
+        cancellation.signal.throwIfAborted();
+        if (!(error instanceof ProviderCommandObservationUnavailableError) || !error.readRetryAllowed) {
+          if (!startUnknown) throw error;
+          throw new ProviderCommandObservationUnavailableError(
+            structuredClone(providerCommand),
+            new AggregateError(
+              [startUnknown, error],
+              "Original visibility Start and observation remain uncertain"
+            ),
+            false
+          );
+        }
+        if (!isDeepStrictEqual3(error.command, providerCommand))
+          throw new SandboxMaterializationVerificationError(diagnostic("invalid_response"), {
+            cause: error
+          });
+        try {
+          await delay2(100, void 0, { signal: cancellation.signal });
+        } catch (interrupted) {
+          cancellation.signal.throwIfAborted();
+          throw interrupted;
+        }
+        continue;
+      }
       cancellation.signal.throwIfAborted();
       if (page.command.sandboxId !== providerCommand.sandboxId || page.command.taskId !== providerCommand.taskId || page.command.execId !== providerCommand.execId) {
         throw new SandboxMaterializationVerificationError(diagnostic("invalid_response"));
@@ -23544,7 +24383,15 @@ async function verifyModalMaterializedPath(control, path, workdir, pending, obse
           ...diagnostic("command_pending"),
           causeMessage: "Observation deadline exceeded; provider process completion is unconfirmed"
         },
-        { cause: error }
+        {
+          cause: providerCommand ? new ProviderCommandObservationUnavailableError(
+            providerCommand,
+            startUnknown ? new AggregateError(
+              [startUnknown, error],
+              "Original visibility Start and observation deadline remain uncertain"
+            ) : error
+          ) : error
+        }
       );
     }
     if (!(error instanceof SandboxMaterializationVerificationError)) {
@@ -23563,7 +24410,7 @@ async function verifyModalMaterializedPath(control, path, workdir, pending, obse
 
 // src/sandbox/providers/modal-command-session.ts
 function sameExecution(a, b) {
-  return a.kind === b.kind && a.sandboxId === b.sandboxId && a.taskId === b.taskId && a.execId === b.execId && isDeepStrictEqual2(
+  return a.kind === b.kind && a.sandboxId === b.sandboxId && a.taskId === b.taskId && a.execId === b.execId && isDeepStrictEqual4(
     "supervision" in a ? a.supervision : void 0,
     "supervision" in b ? b.supervision : void 0
   ) && Boolean(a.pty) === Boolean(b.pty);
@@ -23782,7 +24629,7 @@ function installModalCommandSession(session, control) {
   session.captureCommandOutput = async (result) => {
     const receipt = receipts.get(result);
     if (!receipt || receipt.page.command.kind !== "modal-router-v1") return false;
-    if (receipt.page.command.supervision && !receipt.page.expected && receipt.page.exitCode === null && receipt.page.chunks.length === 0) {
+    if (!receipt.page.expected && receipt.page.exitCode === null && receipt.page.chunks.length === 0) {
       receipts.delete(result);
       return true;
     }
@@ -23840,9 +24687,23 @@ function installModalCommandSession(session, control) {
       if (!retained || !sameExecution(entry.command, retained))
         throw new Error("Original Modal command identity is unavailable");
       const index = await entry.persistence.reserveInput(Buffer.byteLength(args.chars));
-      await control.write(retained, args.chars, index);
+      try {
+        await control.write(retained, args.chars, index);
+      } catch (error) {
+        if (retained.kind === "modal-router-v1" && // Contain supported transport graphs, including mixed failures. This
+        // grants no read/write retry permission; the locator and byte range
+        // come only from the retained command and its one input reservation.
+        classifyProviderSandboxFailure("modal", error).kind === "transient_transport")
+          throw new ProviderCommandInputOutcomeUnknownError(
+            retained,
+            index,
+            Buffer.byteLength(args.chars),
+            error
+          );
+        throw error;
+      }
     }
-    return read(args.sessionId, entry, args.yieldTimeMs ?? 250, args.maxOutputTokens);
+    return read(args.sessionId, entry, args.yieldTimeMs ?? 250, args.maxOutputTokens, args.signal);
   };
 }
 
@@ -23850,274 +24711,88 @@ function installModalCommandSession(session, control) {
 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 { setTimeout as delay3 } from "timers/promises";
 import {
   SandboxProviderCommand,
-  CommandSupervisionReceipt
+  CommandSupervisionReceipt,
+  ModalRouterProviderCommand as ModalRouterProviderCommand3
 } from "@opengeni/contracts";
 
-// 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();
-  return yield* call.next(call.request, options);
-};
-var ModalClientBase = ModalClient;
-var ModalCommandClient = class extends ModalClientBase {
-  retryMiddleware() {
-    return modalCommandAbortMiddleware;
-  }
-};
-var controlClients = /* @__PURE__ */ new WeakMap();
-function commandControlPlane(client) {
-  if (!client.profile) return client.cpClient;
-  if (typeof Reflect.get(ModalClient.prototype, "retryMiddleware") !== "function")
-    throw new Error("Verified Modal command cancellation contract is unavailable");
-  let controlled = controlClients.get(client);
-  if (!controlled) {
-    const profile = client.profile;
-    if (!profile.tokenId || !profile.tokenSecret)
-      throw new Error("Modal command control requires its original authenticated profile");
-    controlled = new ModalCommandClient({
-      tokenId: profile.tokenId,
-      tokenSecret: profile.tokenSecret,
-      endpoint: profile.serverUrl,
-      environment: profile.environment ?? "",
-      ...profile.maxThrottleWaitSecs !== void 0 ? { maxThrottleWaitSecs: profile.maxThrottleWaitSecs } : {},
-      ...client.logger ? { logger: client.logger } : {}
-    });
-    controlClients.set(client, controlled);
-  }
-  return controlled.cpClient;
-}
-function decodePage(prior, input, terminal) {
-  const bytes = Buffer.concat([Buffer.from(prior, "base64"), ...input]);
-  let boundary = bytes.length;
-  if (!terminal) {
-    for (let start = Math.max(0, bytes.length - 3); start < bytes.length; start++) {
-      const first = bytes[start];
-      const width = first >= 194 && first <= 223 ? 2 : first >= 224 && first <= 239 ? 3 : first >= 240 && first <= 244 ? 4 : 0;
-      if (!width || bytes.length - start >= width) continue;
-      const suffix = bytes.subarray(start + 1);
-      if (!suffix.every((byte) => byte >= 128 && byte <= 191)) continue;
-      const second = suffix[0];
-      if (second !== void 0 && (first === 224 && second < 160 || first === 237 && second > 159 || first === 240 && second < 144 || first === 244 && second > 143))
-        continue;
-      boundary = start;
-      break;
-    }
-  }
-  return {
-    text: bytes.subarray(0, boundary).toString("utf8"),
-    remainder: bytes.subarray(boundary).toString("base64")
+// src/sandbox/providers/modal-command-observation-errors.ts
+function isModalCommandObservationTransportError(error) {
+  const seen = /* @__PURE__ */ new Map();
+  let nodes = 0;
+  const own = (value, key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor && !("value" in descriptor)) throw new Error("Unreadable provider error graph");
+    return descriptor && "value" in descriptor ? descriptor.value : void 0;
   };
-}
-var ModalCommandControl = class _ModalCommandControl {
-  constructor(client, sandboxIdentity, root, environment = {}) {
-    this.client = client;
-    this.sandboxIdentity = sandboxIdentity;
-    this.root = root;
-    this.environment = environment;
-  }
-  static forSandbox(client, sandboxId, root, environment = {}) {
-    if (client.version() !== "0.9.0")
-      throw new Error("Modal command control requires the verified 0.9.0 SDK contract");
-    return new _ModalCommandControl(commandControlPlane(client), sandboxId, root, environment);
-  }
-  get sandboxId() {
-    return typeof this.sandboxIdentity === "function" ? this.sandboxIdentity() : this.sandboxIdentity;
-  }
-  async start(args, signal) {
-    signal?.throwIfAborted();
-    const workdir = posix2.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 sandboxId = this.sandboxId;
-    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");
-    const login = args.shell ? args.login ?? true : false;
-    let command = [args.shell ?? "/bin/sh", login ? "-lc" : "-c", args.cmd];
-    if (args.runAs) {
-      const user = shellQuote(args.runAs);
-      const invocation = command.map(shellQuote).join(" ");
-      const script = `if [ "$(id -u)" = ${user} ] || [ "$(id -un 2>/dev/null)" = ${user} ]; then exec ${invocation}; elif [ "$(id -u)" = 0 ]; then exec su -s /bin/sh ${user} -c ${shellQuote(`exec ${invocation}`)}; else exec sudo -n -u ${user} -- ${invocation}; fi`;
-      command = ["/bin/sh", "-c", script];
-    }
-    const environment = typeof this.environment === "function" ? this.environment() : this.environment;
-    if (Object.keys(environment).length) {
-      command = [
-        "/usr/bin/env",
-        "--",
-        ...Object.entries(environment).map(([key, value]) => `${key}=${value}`),
-        ...command
-      ];
-    }
-    const result = await this.client.containerExec(
-      {
-        taskId: task.taskId,
-        command,
-        terminateContainerOnExit: false,
-        runtimeDebug: false,
-        stdoutOutput: 2,
-        stderrOutput: 2,
-        timeoutSecs: 0,
-        workdir,
-        secretIds: [],
-        ...args.tty ? {
-          ptyInfo: {
-            enabled: true,
-            winszRows: 24,
-            winszCols: 80,
-            envTerm: "xterm",
-            envColorterm: "",
-            envTermProgram: "",
-            ptyType: 1,
-            noTerminateOnIdleStdin: true
-          }
-        } : {}
-      },
-      { retries: 0, ...signal ? { signal } : {} }
-    ).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")
+  const visit = (value, depth) => {
+    if (!value || typeof value !== "object" || depth > 6 || ++nodes > 32) return false;
+    if (seen.has(value)) return seen.get(value);
+    seen.set(value, false);
+    try {
+      const code = own(value, "code");
+      const nested = [own(value, "cause"), own(value, "error")].filter(
+        (item) => item !== void 0
       );
-    return {
-      kind: "modal-control-v1",
-      sandboxId,
-      taskId: task.taskId,
-      execId: result.execId,
-      ...args.tty ? { pty: true } : {},
-      streams: {
-        stdout: { batchIndex: 0, utf8Remainder: "", exitCode: null },
-        stderr: { batchIndex: 0, utf8Remainder: "", exitCode: null }
+      const errors = own(value, "errors");
+      if (errors !== void 0) {
+        if (!Array.isArray(errors) || !errors.length || errors.length > 16) return false;
+        for (let index = 0; index < errors.length; index++) nested.push(own(errors, String(index)));
       }
-    };
-  }
-  async read(command, yieldTimeMs, signal) {
-    return this.readOutput(command, yieldTimeMs, signal);
-  }
-  /** Fixed internal probes own their cancellation controller and must drain
-   * both reads before relinquishing the surrounding provider-operation gate.
-   * Retained-command readers keep their existing signal/receipt contract.
-   */
-  async readProbe(command, yieldTimeMs, cancellation) {
-    return this.readOutput(
-      command,
-      yieldTimeMs,
-      cancellation.signal,
-      (error) => cancellation.abort(error)
-    );
-  }
-  async readOutput(command, yieldTimeMs, signal, cancelSiblings) {
-    signal?.throwIfAborted();
-    this.assertIdentity(command);
-    const next = structuredClone(command);
-    let failure;
-    const reads = ["stdout", "stderr"].map(async (stream) => {
-      const cursor = command.streams[stream];
-      if (cursor.exitCode !== null) return null;
-      const descriptor = stream === "stdout" ? 1 : 2;
-      for await (const batch of this.client.containerExecGetOutput(
-        {
-          execId: command.execId,
-          timeout: Math.max(0, yieldTimeMs) / 1e3,
-          lastBatchIndex: cursor.batchIndex,
-          fileDescriptor: descriptor,
-          getRawBytes: true
-        },
-        signal ? { signal } : void 0
-      )) {
-        if (batch.batchIndex <= cursor.batchIndex) continue;
-        if (!Number.isSafeInteger(batch.batchIndex))
-          throw new Error("Invalid Modal output cursor");
-        const terminal = batch.exitCode !== void 0;
-        if (terminal && !Number.isSafeInteger(batch.exitCode))
-          throw new Error("Invalid Modal exit status");
-        const decoded = decodePage(
-          cursor.utf8Remainder,
-          batch.items.filter((item) => item.fileDescriptor === descriptor).map((item) => item.messageBytes),
-          terminal
-        );
-        next.streams[stream] = {
-          batchIndex: batch.batchIndex,
-          utf8Remainder: decoded.remainder,
-          exitCode: terminal ? batch.exitCode : null
-        };
-        return {
-          stream,
-          chunkId: `modal:${command.execId}:${stream}:${cursor.batchIndex}:${batch.batchIndex}`,
-          text: decoded.text
-        };
+      if (code !== void 0) {
+        const normalized = typeof code === "string" ? code.trim().toUpperCase() : code;
+        if (![
+          1,
+          2,
+          4,
+          13,
+          14,
+          "1",
+          "2",
+          "4",
+          "13",
+          "14",
+          "CANCELLED",
+          "UNKNOWN",
+          "DEADLINE_EXCEEDED",
+          "INTERNAL",
+          "UNAVAILABLE",
+          "ECONNRESET",
+          "ECONNREFUSED",
+          "ETIMEDOUT",
+          "EAI_AGAIN",
+          "ENOTFOUND"
+        ].includes(normalized))
+          return false;
+        const result2 = nested.length === 0 || nested.every((item) => visit(item, depth + 1));
+        seen.set(value, result2);
+        return result2;
       }
-      return null;
-    }).map(
-      (read) => !cancelSiblings ? read : read.catch((error) => {
-        failure ??= { error };
-        cancelSiblings(error);
-        throw error;
-      })
-    );
-    const pages = cancelSiblings ? await Promise.allSettled(reads).then((results) => {
-      if (failure) throw failure.error;
-      return results.map((result) => {
-        if (result.status === "rejected") throw result.reason;
-        return result.value;
-      });
-    }) : await Promise.all(reads);
-    const stdoutExit = next.streams.stdout.exitCode;
-    const stderrExit = next.streams.stderr.exitCode;
-    if (stdoutExit !== null && stderrExit !== null && stdoutExit !== stderrExit)
-      throw new Error("Modal output streams disagree about command exit status");
-    return {
-      command: next,
-      streamFidelity: command.pty ? "merged" : "separate",
-      chunks: pages.filter((page) => page !== null),
-      exitCode: stdoutExit !== null && stderrExit !== null ? stdoutExit : null
-    };
-  }
-  async write(command, chars, messageIndex) {
-    this.assertIdentity(command);
-    if (!chars) return;
-    if (!Number.isSafeInteger(messageIndex) || messageIndex < 1)
-      throw new Error("Modal stdin requires a protected monotonic message index");
-    await this.client.containerExecPutInput(
-      {
-        execId: command.execId,
-        input: { message: Buffer.from(chars), messageIndex, eof: false }
-      },
-      { retries: 0 }
-    );
-  }
-  assertIdentity(command) {
-    ModalLegacyProviderCommand.parse(command);
-    if (command.kind !== "modal-control-v1" || command.sandboxId !== this.sandboxId || !command.taskId || !command.execId)
-      throw new Error("Modal command locator does not match the original sandbox");
-  }
-};
+      const result = nested.length > 0 && nested.every((item) => visit(item, depth + 1));
+      seen.set(value, result);
+      return result;
+    } catch {
+      return false;
+    }
+  };
+  return visit(error, 0);
+}
 
 // src/sandbox/providers/modal-command-control.ts
+function awaitRouterAccess(pending, signal) {
+  if (!signal) return pending;
+  signal.throwIfAborted();
+  return new Promise((resolve7, reject) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    void pending.then(resolve7, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
 var ModalCommandControl2 = class _ModalCommandControl {
   constructor(client, sandboxIdentity, root, environment) {
     this.sandboxIdentity = sandboxIdentity;
@@ -24127,6 +24802,8 @@ var ModalCommandControl2 = class _ModalCommandControl {
     this.legacy = ModalCommandControl.forSandbox(client, sandboxIdentity, root, environment);
   }
   routers = /* @__PURE__ */ new Map();
+  routerLookups = /* @__PURE__ */ new Map();
+  controlHelpers = /* @__PURE__ */ new Map();
   client;
   legacy;
   closed = false;
@@ -24144,10 +24821,15 @@ var ModalCommandControl2 = class _ModalCommandControl {
     let pending = this.routers.get(taskId);
     const reused = Boolean(pending);
     if (!pending) {
+      const lookup2 = {
+        controller: new AbortController(),
+        waiters: 0,
+        settled: false
+      };
       pending = (async () => {
-        const access = await this.client.taskGetCommandRouterAccess(
-          { taskId },
-          signal ? { signal } : void 0
+        const access = await awaitRouterAccess(
+          this.client.taskGetCommandRouterAccess({ taskId }, { signal: lookup2.controller.signal }),
+          lookup2.controller.signal
         );
         let refreshAt = Date.now() + 6e4;
         try {
@@ -24161,15 +24843,33 @@ var ModalCommandControl2 = class _ModalCommandControl {
         return { router: new ModalCommandRouterWire(access), users: 0, refreshAt };
       })();
       this.routers.set(taskId, pending);
-      void pending.catch(() => {
+      this.routerLookups.set(pending, lookup2);
+      const settled = () => {
+        lookup2.settled = true;
+        this.routerLookups.delete(pending);
+      };
+      void pending.then(settled, () => {
+        settled();
         if (this.routers.get(taskId) === pending) this.routers.delete(taskId);
       });
     }
-    const entry = await pending;
+    const lookup = this.routerLookups.get(pending);
+    if (lookup) lookup.waiters++;
+    let entry;
+    try {
+      entry = await awaitRouterAccess(pending, signal);
+    } finally {
+      if (lookup && --lookup.waiters === 0 && !lookup.settled) {
+        if (this.routers.get(taskId) === pending) this.routers.delete(taskId);
+        lookup.controller.abort(new Error("Modal router access has no remaining waiters"));
+      }
+    }
     if (reused && !entry.users && Date.now() > entry.refreshAt) {
-      clearTimeout(entry.idle);
-      entry.router.close();
-      this.routers.delete(taskId);
+      if (this.routers.get(taskId) === pending) {
+        this.routers.delete(taskId);
+        clearTimeout(entry.idle);
+        entry.router.close();
+      }
       return await this.withRouter(taskId, signal, run2);
     }
     clearTimeout(entry.idle);
@@ -24192,6 +24892,8 @@ var ModalCommandControl2 = class _ModalCommandControl {
   }
   async close() {
     this.closed = true;
+    for (const lookup of this.routerLookups.values())
+      lookup.controller.abort(new Error("Modal command control is closed"));
     const entries = await Promise.allSettled(this.routers.values());
     this.routers.clear();
     for (const entry of entries)
@@ -24240,19 +24942,7 @@ var ModalCommandControl2 = class _ModalCommandControl {
       nonce: randomBytes(32).toString("hex"),
       controlPath: `/tmp/opengeni-supervision/${invocationId}.sock`
     } : void 0;
-    let commandArgs = [
-      args.shell ?? "/bin/sh",
-      args.shell && (args.login ?? true) ? "-lc" : "-c",
-      args.cmd
-    ];
-    if (args.runAs) {
-      const user = shellQuote(args.runAs), invocation = commandArgs.map(shellQuote).join(" ");
-      commandArgs = [
-        "/bin/sh",
-        "-c",
-        `if [ "$(id -u)" = ${user} ] || [ "$(id -un 2>/dev/null)" = ${user} ]; then exec ${invocation}; elif [ "$(id -u)" = 0 ]; then exec su -s /bin/sh ${user} -c ${shellQuote(`exec ${invocation}`)}; else exec sudo -n -u ${user} -- ${invocation}; fi`
-      ];
-    }
+    let commandArgs = modalCommandArgv(args);
     const env = typeof this.environment === "function" ? this.environment() : this.environment;
     if (supervision)
       commandArgs = [
@@ -24325,28 +25015,50 @@ var ModalCommandControl2 = class _ModalCommandControl {
     if (!task.taskId || task.taskResult) throw new Error("Modal command task is unavailable");
     await this.withStartRouter(task.taskId, signal, async (router) => {
       const identity = { taskId: task.taskId, execId: randomUUID6() };
-      await router.start(
-        {
+      const observation = {
+        command: {
+          kind: "modal-router-v1",
+          sandboxId,
           ...identity,
-          commandArgs: ["/usr/local/bin/opengeni-command-supervisor", "capabilities"],
-          workdir: "/tmp",
-          env: {}
+          streams: {
+            stdout: { byteOffset: 0, utf8Remainder: "", eof: false, exitCode: null },
+            stderr: { byteOffset: 0, utf8Remainder: "", eof: false, exitCode: null }
+          }
         },
-        signal
-      );
-      let offset = 0;
-      let output = "";
-      let eof = false;
-      let exit = null;
-      while (!eof || exit === null) {
-        signal.throwIfAborted();
-        const page = await router.read(identity, "stdout", offset, 250, signal);
-        offset += page.bytes.length;
-        if (offset > 128) throw new Error("Modal supervision capability response exceeds bound");
-        output += page.bytes.toString("utf8");
-        eof = page.eof;
-        exit = await router.poll(identity, signal);
+        output: ""
+      };
+      let startUnknown;
+      try {
+        await router.start(
+          {
+            ...identity,
+            commandArgs: ["/usr/local/bin/opengeni-command-supervisor", "capabilities"],
+            workdir: "/tmp",
+            env: {}
+          },
+          signal
+        );
+      } catch (error) {
+        if (!(error instanceof ModalCommandStartOutcomeUnknownError)) throw error;
+        if (error.taskId !== identity.taskId || error.execId !== identity.execId) throw error;
+        startUnknown = error;
+      }
+      let result;
+      try {
+        result = await this.readControlOutput(identity, 128, signal, observation);
+      } catch (error) {
+        if (!startUnknown) throw error;
+        throw new ProviderCommandObservationUnavailableError(
+          structuredClone(observation.command),
+          new AggregateError(
+            [startUnknown, error],
+            "Original capability Start and observation remain uncertain"
+          ),
+          error instanceof ProviderCommandObservationUnavailableError && error.readRetryAllowed
+        );
       }
+      signal.throwIfAborted();
+      const { output, exit } = result;
       if (exit !== 0 || output !== "native-subreaper-v1")
         throw new Error(
           "Exact Modal instance lacks compatible native supervision; command not admitted"
@@ -24373,7 +25085,7 @@ var ModalCommandControl2 = class _ModalCommandControl {
     const transientObservation = (error) => [status3.UNAVAILABLE, status3.DEADLINE_EXCEEDED].includes(
       error?.code ?? -1
     );
-    const pause = () => delay2(100, void 0, { signal });
+    const pause = () => delay3(100, void 0, { signal });
     return await this.withStartRouter(task.taskId, signal, async (router) => {
       for (; ; ) {
         signal.throwIfAborted();
@@ -24426,45 +25138,92 @@ var ModalCommandControl2 = class _ModalCommandControl {
     const descriptor = command.supervision;
     if (!descriptor || command.sandboxId !== this.sandboxId)
       throw new Error("Supervised command identity is unavailable");
-    const identity = { taskId: command.taskId, execId: randomUUID6() };
-    const signal = AbortSignal.timeout(5e3);
-    return await this.withStartRouter(command.taskId, signal, async (router) => {
-      await router.start(
-        {
-          ...identity,
-          commandArgs: [
-            "/usr/local/bin/opengeni-command-supervisor",
-            "control",
-            "--invocation",
-            descriptor.invocationId,
-            "--nonce",
-            descriptor.nonce,
-            "--socket",
-            descriptor.controlPath,
-            "--action",
-            action,
-            ...receiptId ? ["--receipt", receiptId] : []
-          ],
-          workdir: "/tmp",
-          env: {}
-        },
-        signal
-      );
-      const buffers = [];
-      let offset = 0;
-      let eof = false;
-      let exit = null;
-      while (!eof || exit === null) {
-        signal.throwIfAborted();
-        const page = await router.read(identity, "stdout", offset, 250, signal);
-        offset += page.bytes.length;
-        if (offset > 4096) throw new Error("Supervisor control response exceeds its bound");
-        buffers.push(page.bytes);
-        eof = page.eof;
-        exit = await router.poll(identity, signal);
+    const key = JSON.stringify([
+      command.sandboxId,
+      command.taskId,
+      command.execId,
+      descriptor.invocationId,
+      descriptor.nonce,
+      descriptor.controlPath,
+      action,
+      receiptId ?? null
+    ]);
+    let helper = this.controlHelpers.get(key);
+    if (!helper) {
+      helper = {
+        startPending: true,
+        output: "",
+        command: {
+          kind: "modal-router-v1",
+          sandboxId: command.sandboxId,
+          taskId: command.taskId,
+          execId: randomUUID6(),
+          streams: {
+            stdout: { byteOffset: 0, utf8Remainder: "", eof: false, exitCode: null },
+            stderr: { byteOffset: 0, utf8Remainder: "", eof: false, exitCode: null }
+          }
+        }
+      };
+      this.controlHelpers.set(key, helper);
+    }
+    const observation = helper;
+    const run2 = async () => {
+      const signal = AbortSignal.timeout(5e3);
+      if (observation.startPending) {
+        try {
+          await this.withStartRouter(command.taskId, signal, async (router) => {
+            observation.startPending = false;
+            await router.start(
+              {
+                taskId: observation.command.taskId,
+                execId: observation.command.execId,
+                commandArgs: [
+                  "/usr/local/bin/opengeni-command-supervisor",
+                  "control",
+                  "--invocation",
+                  descriptor.invocationId,
+                  "--nonce",
+                  descriptor.nonce,
+                  "--socket",
+                  descriptor.controlPath,
+                  "--action",
+                  action,
+                  ...receiptId ? ["--receipt", receiptId] : []
+                ],
+                workdir: "/tmp",
+                env: {}
+              },
+              signal
+            );
+          });
+        } catch (error) {
+          if (observation.startPending || error instanceof ModalCommandStartNotDispatchedError || error instanceof ModalCommandStartRejectedError || error instanceof ModalCommandStartPreDispatchUnavailableError) {
+            this.controlHelpers.delete(key);
+            throw error;
+          }
+          observation.startUnknown = error;
+          throw error;
+        }
+      }
+      let response;
+      try {
+        response = await this.readControlOutput(observation.command, 4096, signal, observation);
+      } catch (error) {
+        if (observation.startUnknown !== void 0 && error instanceof ProviderCommandObservationUnavailableError)
+          throw new ProviderCommandObservationUnavailableError(
+            error.command,
+            new AggregateError(
+              [observation.startUnknown, error],
+              "Original helper Start and observation remain uncertain"
+            ),
+            error.readRetryAllowed
+          );
+        throw error;
       }
+      const { output, exit } = response;
+      this.controlHelpers.delete(key);
       if (exit !== 0) throw new Error("Supervisor control is unavailable");
-      const result = JSON.parse(Buffer.concat(buffers).toString("utf8"));
+      const result = JSON.parse(output);
       if (!result || !["idle", "running", "quiescent"].includes(result.state))
         throw new Error("Invalid supervisor control response");
       if (result.receipt !== void 0) {
@@ -24475,27 +25234,169 @@ var ModalCommandControl2 = class _ModalCommandControl {
       if (result.state === "quiescent" !== Boolean(result.receipt))
         throw new Error("Supervisor quiescence response lacks its receipt");
       return result;
-    });
+    };
+    observation.inFlight ??= run2().finally(() => {
+      delete observation.inFlight;
+    });
+    return await observation.inFlight;
+  }
+  /** These fixed helpers already started once. Observe only their original
+   * invocation within the caller's existing five-second budget. */
+  async readControlOutput(identity, limit, signal, observation) {
+    const state = observation ?? {
+      command: {
+        kind: "modal-router-v1",
+        sandboxId: this.sandboxId,
+        ...identity,
+        streams: {
+          stdout: { byteOffset: 0, utf8Remainder: "", eof: false, exitCode: null },
+          stderr: { byteOffset: 0, utf8Remainder: "", eof: false, exitCode: null }
+        }
+      },
+      output: ""
+    };
+    for (; ; ) {
+      try {
+        signal.throwIfAborted();
+        const page = await this.read(state.command, 250, signal);
+        state.command = page.command;
+        if (state.command.streams.stdout.byteOffset + state.command.streams.stderr.byteOffset > limit)
+          throw new Error("Supervisor control response exceeds its bound");
+        state.output += page.chunks.filter((chunk) => chunk.stream === "stdout").map((chunk) => chunk.text).join("");
+        if (page.exitCode !== null) return { output: state.output, exit: page.exitCode };
+      } catch (error) {
+        if (signal.aborted)
+          throw new ProviderCommandObservationUnavailableError(
+            structuredClone(state.command),
+            error
+          );
+        if (!(error instanceof ProviderCommandObservationUnavailableError) || !error.readRetryAllowed)
+          throw error;
+      }
+      try {
+        await delay3(100, void 0, { signal });
+      } catch (error) {
+        throw new ProviderCommandObservationUnavailableError(structuredClone(state.command), error);
+      }
+    }
   }
   async read(command, waitMs, signal) {
     SandboxProviderCommand.parse(command);
     if (command.sandboxId !== this.sandboxId)
       throw new Error("Modal command does not belong to this sandbox");
     if (command.kind === "modal-control-v1") return await this.legacy.read(command, waitMs, signal);
-    const next = structuredClone(command);
+    return (await this.readNative(command, waitMs, signal)).output;
+  }
+  /** Native capture plumbing only. Raw bytes are acquired by the same joined
+   * read/poll path as read(); no legacy locator or new command is admitted. */
+  async readRaw(command, waitMs, signal) {
+    return (await this.readNative(command, waitMs, signal)).raw;
+  }
+  async readNative(input, waitMs, signal) {
+    const command = structuredClone(ModalRouterProviderCommand3.parse(input));
+    if (command.sandboxId !== this.sandboxId)
+      throw new Error("Modal command does not belong to this sandbox");
+    if (!Number.isFinite(waitMs) || waitMs < 0 || waitMs > 5e4)
+      throw new Error("Invalid Modal output read bounds");
+    signal?.throwIfAborted();
+    const stdout = command.streams.stdout;
+    const stderr = command.streams.stderr;
+    if (stdout.eof && stderr.eof && stdout.utf8Remainder === "" && stderr.utf8Remainder === "" && stdout.exitCode !== null && stdout.exitCode === stderr.exitCode) {
+      return collectModalRawOutputPage(
+        command,
+        {
+          stdout: { bytes: Buffer.alloc(0), eof: true },
+          stderr: { bytes: Buffer.alloc(0), eof: true }
+        },
+        { source: "retained_terminal", code: stdout.exitCode }
+      );
+    }
+    const budget = new AbortController();
+    const abort = () => budget.abort(signal?.reason);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    const deadline = performance.now() + Math.max(1, waitMs);
+    const timeout = setTimeout(
+      () => budget.abort(new Error("Modal command read budget exhausted")),
+      Math.max(1, waitMs) + 5e3
+    );
+    let lastError;
+    try {
+      for (let attempt = 0; attempt < 5; attempt++) {
+        signal?.throwIfAborted();
+        if (attempt > 0 && performance.now() >= deadline) break;
+        try {
+          return await this.readRouterPage(
+            command,
+            Math.min(Math.max(1, waitMs), Math.max(1, deadline - performance.now())),
+            budget.signal,
+            deadline
+          );
+        } catch (error) {
+          signal?.throwIfAborted();
+          if (!budget.signal.aborted && !isModalCommandObservationTransportError(error)) {
+            if (classifyProviderSandboxFailure("modal", error).kind === "transient_transport")
+              throw new ProviderCommandObservationUnavailableError(
+                structuredClone(command),
+                error,
+                false
+              );
+            throw error;
+          }
+          lastError = error;
+          if (budget.signal.aborted || performance.now() >= deadline || attempt === 4) break;
+          try {
+            await delay3(Math.min(100, Math.max(1, deadline - performance.now())), void 0, {
+              signal: budget.signal
+            });
+          } catch {
+            signal?.throwIfAborted();
+            break;
+          }
+        }
+      }
+      throw new ProviderCommandObservationUnavailableError(structuredClone(command), lastError);
+    } finally {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", abort);
+    }
+  }
+  async readRouterPage(command, waitMs, signal, deadline) {
     const cancellation = new AbortController();
-    const abort = () => cancellation.abort(signal?.reason);
+    const lookupCancellation = new AbortController();
+    const abort = () => {
+      cancellation.abort(signal.reason);
+      lookupCancellation.abort(signal.reason);
+    };
     signal?.addEventListener("abort", abort, { once: true });
     if (signal?.aborted) abort();
+    const lookupTimeout = setTimeout(
+      () => lookupCancellation.abort(
+        new ProviderCommandObservationUnavailableError(
+          structuredClone(command),
+          new Error("Modal command read access budget exhausted")
+        )
+      ),
+      Math.max(1, deadline - performance.now())
+    );
     try {
-      return await this.withRouter(command.taskId, cancellation.signal, async (router) => {
+      return await this.withRouter(command.taskId, lookupCancellation.signal, async (router) => {
+        clearTimeout(lookupTimeout);
+        lookupCancellation.signal.throwIfAborted();
+        signal.throwIfAborted();
+        if (performance.now() >= deadline)
+          throw new ProviderCommandObservationUnavailableError(
+            structuredClone(command),
+            new Error("Modal command read budget exhausted")
+          );
+        const remainingWait = Math.max(1, Math.min(waitMs, deadline - performance.now()));
         const operations = [
           ...["stdout", "stderr"].map(
             async (stream) => command.streams[stream].eof ? { bytes: Buffer.alloc(0), eof: true } : await router.read(
               command,
               stream,
               command.streams[stream].byteOffset,
-              waitMs,
+              remainingWait,
               cancellation.signal
             )
           ),
@@ -24510,42 +25411,18 @@ var ModalCommandControl2 = class _ModalCommandControl {
           )
         );
         const failed = results.find((result) => result.status === "rejected");
-        if (failed?.status === "rejected") throw failed.reason;
+        if (failed?.status === "rejected") throw cancellation.signal.reason ?? failed.reason;
         const stdout = results[0].value;
         const stderr = results[1].value;
         const exit = results[2].value;
-        const chunks = [];
-        for (const [stream, page] of [
-          ["stdout", stdout],
-          ["stderr", stderr]
-        ]) {
-          const old = command.streams[stream];
-          const decoded = decodePage(old.utf8Remainder, [page.bytes], page.eof);
-          const byteOffset = old.byteOffset + page.bytes.length;
-          if (!Number.isSafeInteger(byteOffset)) throw new Error("Modal output offset exhausted");
-          next.streams[stream] = {
-            byteOffset,
-            utf8Remainder: decoded.remainder,
-            eof: page.eof,
-            exitCode: page.eof ? exit : null
-          };
-          if (decoded.text)
-            chunks.push({
-              stream,
-              chunkId: `modal-router:${command.execId}:${stream}:${old.byteOffset}:${byteOffset}:${page.eof ? 1 : 0}`,
-              text: decoded.text
-            });
-        }
-        return {
-          command: next,
-          expected: structuredClone(command),
-          chunks,
-          exitCode: next.streams.stdout.eof && next.streams.stderr.eof ? exit : null,
-          providerExited: exit !== null,
-          streamFidelity: command.pty ? "merged" : "separate"
-        };
+        return collectModalRawOutputPage(
+          command,
+          { stdout, stderr },
+          { source: "router_poll", code: exit }
+        );
       });
     } finally {
+      clearTimeout(lookupTimeout);
       signal?.removeEventListener("abort", abort);
     }
   }
@@ -26241,7 +27118,7 @@ function commandForArgs(args) {
   if (!requestedShell) return args.cmd;
   return `${shellQuote(requestedShell)}${args.login === false ? "" : " -l"} -c ${shellQuote(args.cmd)}`;
 }
-function delay3(ms) {
+function delay4(ms) {
   return new Promise((resolve7) => setTimeout(resolve7, Math.max(0, ms)));
 }
 function consumeProcessOutput(process2) {
@@ -26600,7 +27477,7 @@ var OpenSandboxSession = class {
         }
       } catch {
       }
-      await delay3(DEFAULT_WRITE_STDIN_YIELD_TIME_MS3);
+      await delay4(DEFAULT_WRITE_STDIN_YIELD_TIME_MS3);
     }
   }
   async execToCompletion(args) {
@@ -26641,7 +27518,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 })),
-      delay3(yieldTimeMs).then(() => ({ done: false }))
+      delay4(yieldTimeMs).then(() => ({ done: false }))
     ]);
     const consumed = consumeProcessOutput(process2);
     const output = truncateOutput(consumed.output, args.maxOutputTokens);
@@ -26753,7 +27630,7 @@ var OpenSandboxSession = class {
     }
     const outcome = await Promise.race([
       process2.completed.then((value) => ({ done: true, value })),
-      delay3(args.yieldTimeMs ?? DEFAULT_WRITE_STDIN_YIELD_TIME_MS3).then(() => ({
+      delay4(args.yieldTimeMs ?? DEFAULT_WRITE_STDIN_YIELD_TIME_MS3).then(() => ({
         done: false
       }))
     ]);
@@ -33536,147 +34413,6 @@ function negotiateCapabilities(ctx) {
   };
 }
 
-// src/sandbox/provider-errors.ts
-var GRPC_TRANSIENT = /* @__PURE__ */ new Set([1, 2, 4, 13, 14]);
-var TRANSIENT_CODES = /* @__PURE__ */ new Set([
-  "CANCELLED",
-  "UNKNOWN",
-  "DEADLINE_EXCEEDED",
-  "INTERNAL",
-  "UNAVAILABLE",
-  "ECONNRESET",
-  "ECONNREFUSED",
-  "ETIMEDOUT",
-  "EAI_AGAIN",
-  "ENOTFOUND"
-]);
-var NOT_FOUND_CODES = /* @__PURE__ */ new Set(["404", "NOT_FOUND", "RESOURCE_NOT_FOUND", "SANDBOX_NOT_FOUND"]);
-var SAFE_CODE = /^[A-Z0-9._:-]{1,64}$/;
-function safeRead(record, key) {
-  try {
-    return Reflect.get(record, key);
-  } catch {
-    return void 0;
-  }
-}
-function collectSignals(value) {
-  const out = { numbers: [], codes: [], messages: [] };
-  const seen = /* @__PURE__ */ new Set();
-  const visit = (current, depth) => {
-    if (depth > 3 || current === null || current === void 0) return;
-    if (typeof current === "string") {
-      if (current.length <= 512) out.messages.push(current);
-      return;
-    }
-    if (typeof current !== "object" || seen.has(current)) return;
-    seen.add(current);
-    for (const key of [
-      "status",
-      "statusCode",
-      "httpStatus",
-      "httpStatusCode",
-      "responseStatus",
-      "errorCode",
-      "code"
-    ]) {
-      const signal = safeRead(current, key);
-      if (typeof signal === "number" && Number.isFinite(signal)) out.numbers.push(signal);
-      if (typeof signal === "string") {
-        const code = signal.trim().toUpperCase();
-        if (SAFE_CODE.test(code)) out.codes.push(code);
-      }
-    }
-    for (const key of ["name", "message", "details", "cause"]) {
-      const signal = safeRead(current, key);
-      if (typeof signal === "string" && signal.length <= 512) out.messages.push(signal);
-      else visit(signal, depth + 1);
-    }
-    visit(safeRead(current, "response"), depth + 1);
-    visit(safeRead(current, "error"), depth + 1);
-  };
-  visit(value, 0);
-  return out;
-}
-function safeDiagnostic(signals) {
-  const code = signals.codes.find(Boolean);
-  const numeric = signals.numbers.find((value) => Number.isFinite(value));
-  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((status4) => GRPC_TRANSIENT.has(status4));
-}
-function hasModalTerminalSandboxMessage(signals) {
-  return signals.messages.some(
-    (message) => /^Modal sandbox [A-Za-z0-9_-]+ is no longer running\.$/.test(message) || /^Modal sandbox [A-Za-z0-9_-]+ not found \(has been terminated\)$/.test(message)
-  );
-}
-function hasUnixLocalTerminalWorkspaceMessage(signals) {
-  return signals.messages.includes(
-    "UnixLocal sandbox workspace is unavailable and no local snapshot could be restored."
-  );
-}
-function hasDockerTerminalWorkspaceMessage(signals) {
-  return signals.messages.includes(
-    "Docker sandbox resources are unavailable and no local snapshot could be restored."
-  );
-}
-function hasCloudflareTerminalSandboxMessage(signals) {
-  return signals.messages.some(
-    (message) => /^Cloudflare sandbox [A-Za-z0-9._:-]+ is no longer running\.$/.test(message)
-  );
-}
-function classifyProviderSandboxFailure(backendId, error) {
-  if (backendId === "selfhosted" || !error) {
-    return { kind: "other", diagnostic: "selfhosted-or-empty" };
-  }
-  const signals = collectSignals(error);
-  const diagnostic = safeDiagnostic(signals) || "unclassified_provider_failure";
-  if (hasTransientSignal(signals)) {
-    return { kind: "transient_transport", diagnostic };
-  }
-  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)) {
-    return {
-      kind: "not_found",
-      diagnostic: diagnostic === "unclassified_provider_failure" ? "modal_terminal_message" : `${diagnostic} modal_terminal_message`
-    };
-  }
-  if (backendId === "cloudflare" && hasCloudflareTerminalSandboxMessage(signals)) {
-    return {
-      kind: "not_found",
-      diagnostic: diagnostic === "unclassified_provider_failure" ? "cloudflare_terminal_message" : `${diagnostic} cloudflare_terminal_message`
-    };
-  }
-  if ((backendId === "local" || backendId === "unix_local") && hasUnixLocalTerminalWorkspaceMessage(signals)) {
-    return {
-      kind: "not_found",
-      diagnostic: diagnostic === "unclassified_provider_failure" ? "unix_local_workspace_missing" : `${diagnostic} unix_local_workspace_missing`
-    };
-  }
-  if (backendId === "docker" && hasDockerTerminalWorkspaceMessage(signals)) {
-    return {
-      kind: "not_found",
-      diagnostic: diagnostic === "unclassified_provider_failure" ? "docker_resources_missing" : `${diagnostic} docker_resources_missing`
-    };
-  }
-  return { kind: "other", diagnostic };
-}
-function isProviderSandboxNotFoundError2(backendId, error) {
-  return classifyProviderSandboxFailure(backendId, error).kind === "not_found";
-}
-function isProviderSandboxGoneDuringRoutedOperation(backendId, error) {
-  if (backendId === "selfhosted" || !error) return false;
-  const signals = collectSignals(error);
-  if (hasTransientSignal(signals)) return false;
-  if (signals.codes.includes("SANDBOX_NOT_FOUND")) return true;
-  return backendId === "modal" && hasModalTerminalSandboxMessage(signals);
-}
-function isProviderSandboxTransientError(backendId, error) {
-  return classifyProviderSandboxFailure(backendId, error).kind === "transient_transport";
-}
-
 // src/protocol-json.ts
 var MAX_PROTOCOL_JSON_DEPTH = 512;
 var UnsupportedProtocolJsonValueError = class extends TypeError {
@@ -37172,7 +37908,7 @@ var MAX_CREDENTIAL_FILES = 64;
 var MAX_CREDENTIAL_FILE_BYTES = 1024 * 1024;
 var MAX_TOTAL_MATERIAL_BYTES = 4 * 1024 * 1024;
 var MAX_AUTH_NEEDED_NOTICES = 32;
-var WRITE_CHUNK_BYTES = 24 * 1024;
+var WRITE_CHUNK_BYTES = 1536;
 var COMMAND_OK_MARKER = "__OPENGENI_RUN_CREDENTIAL_COMMAND_OK__";
 var AUTH_NEEDED_REASONS = /* @__PURE__ */ new Set([
   "missing_connection",
@@ -37536,23 +38272,43 @@ env -u BASH_ENV bash --noprofile --norc -c ${shellQuote8(marked)}`,
     throw new Error("run credential materialization command failed");
   }
 }
-async function writeCredentialFile(session, path, content, commandRunner) {
-  await runCredentialCommand(session, `: > ${shellQuote8(path)}`, commandRunner);
+async function writeCredentialFile(session, directory, relativePath, content, commandRunner) {
+  await runCredentialCommand(
+    session,
+    credentialFileCommand(directory, relativePath, ': > "$_opengeni_credential_path"'),
+    commandRunner
+  );
   const encoded = base64(content);
   for (let offset = 0; offset < encoded.length; offset += WRITE_CHUNK_BYTES) {
     const chunk = encoded.slice(offset, offset + WRITE_CHUNK_BYTES);
     await runCredentialCommand(
       session,
-      `printf %s ${shellQuote8(chunk)} | ${portableBase64DecodeCommand()} >> ${shellQuote8(path)}`,
+      credentialFileCommand(
+        directory,
+        relativePath,
+        `printf %s ${shellQuote8(chunk)} | ${portableBase64DecodeCommand()} >> "$_opengeni_credential_path"`
+      ),
       commandRunner
     );
   }
   await runCredentialCommand(
     session,
-    `[ "$(wc -c < ${shellQuote8(path)} | tr -d '[:space:]')" = ${shellQuote8(String(byteLength(content)))} ]`,
+    credentialFileCommand(
+      directory,
+      relativePath,
+      `[ "$(wc -c < "$_opengeni_credential_path" | tr -d '[:space:]')" = ${shellQuote8(String(byteLength(content)))} ]`
+    ),
     commandRunner
   );
 }
+function credentialFileCommand(directory, relativePath, command) {
+  const escapedPath = [...Buffer.from(relativePath, "utf8")].map((byte) => `\\x${byte.toString(16).padStart(2, "0")}`).join("");
+  return [
+    `printf -v _opengeni_credential_path %b ${shellQuote8(escapedPath)}`,
+    `_opengeni_credential_path=${shellQuote8(directory)}/"$_opengeni_credential_path"`,
+    command
+  ].join("\n");
+}
 async function materializeRunCredentials(session, material, options) {
   const root = runCredentialRoot(options.sessionId);
   const attemptId = assertPathIdentity(options.attemptId, "attemptId");
@@ -37591,7 +38347,8 @@ async function materializeRunCredentials(session, material, options) {
   ];
   await writeCredentialFile(
     session,
-    `${stage}/env`,
+    stage,
+    "env",
     environmentLines.length > 0 ? `${environmentLines.join("\n")}
 ` : "",
     options.commandRunner
@@ -37602,33 +38359,45 @@ async function materializeRunCredentials(session, material, options) {
     options.commandRunner
   );
   for (const file of material.files) {
-    const target = `${stage}/files/${file.path}`;
-    const parent = target.slice(0, target.lastIndexOf("/"));
-    await runCredentialCommand(session, `mkdir -p -- ${shellQuote8(parent)}`, options.commandRunner);
-    await writeCredentialFile(session, target, file.content, options.commandRunner);
+    const directory = `${stage}/files`;
+    await runCredentialCommand(
+      session,
+      credentialFileCommand(directory, file.path, 'mkdir -p -- "${_opengeni_credential_path%/*}"'),
+      options.commandRunner
+    );
+    await writeCredentialFile(session, directory, file.path, file.content, options.commandRunner);
     await runCredentialCommand(
       session,
-      `chmod -- ${shellQuote8(file.mode ?? "0600")} ${shellQuote8(target)}`,
+      credentialFileCommand(
+        directory,
+        file.path,
+        `chmod -- ${shellQuote8(file.mode ?? "0600")} "$_opengeni_credential_path"`
+      ),
       options.commandRunner
     );
   }
   await runCredentialCommand(
     session,
     [
+      // Bind validated identifiers once rather than repeatedly expanding long
+      // paths through cancellation and SDK run-as shell quoting.
+      `_opengeni_credential_root=${shellQuote8(root)}`,
+      `_opengeni_credential_version_name=${shellQuote8(versionName)}`,
+      `_opengeni_credential_prefix=${shellQuote8(prefix2)}`,
       ...pointerLockAcquireCommands(root),
-      `previous=$(cat -- ${shellQuote8(`${root}/current`)} 2>/dev/null || :)`,
-      `mv -- ${shellQuote8(stage)} ${shellQuote8(version)}`,
-      `printf '%s\\n' ${shellQuote8(versionName)} > ${shellQuote8(`${root}/.next`)}`,
-      `mv -f -- ${shellQuote8(`${root}/.next`)} ${shellQuote8(`${root}/current`)}`,
+      'previous=$(cat -- "$_opengeni_credential_root/current" 2>/dev/null || :)',
+      'mv -- "$_opengeni_credential_root/versions/.stage-$_opengeni_credential_version_name" "$_opengeni_credential_root/versions/$_opengeni_credential_version_name"',
+      `printf '%s\\n' "$_opengeni_credential_version_name" > "$_opengeni_credential_root/.next"`,
+      'mv -f -- "$_opengeni_credential_root/.next" "$_opengeni_credential_root/current"',
       ...options.prunePreviousGenerations ? [
-        `find ${shellQuote8(`${root}/versions`)} -mindepth 1 -maxdepth 1 ! -name ${shellQuote8(versionName)} -exec rm -rf -- {} +`
+        'find "$_opengeni_credential_root/versions" -mindepth 1 -maxdepth 1 ! -name "$_opengeni_credential_version_name" -exec rm -rf -- {} +'
       ] : options.pruneOtherAttempts ? [
-        `find ${shellQuote8(`${root}/versions`)} -mindepth 1 -maxdepth 1 ! -name ${shellQuote8(`${attemptId}-${options.executionGeneration}-*`)} -exec rm -rf -- {} +`
+        'find "$_opengeni_credential_root/versions" -mindepth 1 -maxdepth 1 ! -name "${_opengeni_credential_prefix}*" -exec rm -rf -- {} +'
       ] : options.pruneSupersededGenerations ? [
-        `for candidate in ${shellQuote8(`${root}/versions`)}/${prefix2}*; do`,
+        'for candidate in "$_opengeni_credential_root/versions/$_opengeni_credential_prefix"*; do',
         `  [ -e "$candidate" ] || continue`,
         `  name=\${candidate##*/}`,
-        `  [ "$name" = ${shellQuote8(versionName)} ] || [ "$name" = "$previous" ] || rm -rf -- "$candidate"`,
+        '  [ "$name" = "$_opengeni_credential_version_name" ] || [ "$name" = "$previous" ] || rm -rf -- "$candidate"',
         "done"
       ] : [],
       ...pointerLockReleaseCommands()
@@ -40379,6 +41148,8 @@ export {
   UnsupportedProtocolJsonValueError,
   normalizeProtocolJsonValue,
   ProviderCommandStartOutcomeUnknownError,
+  ProviderCommandObservationUnavailableError,
+  isProviderCommandObservationUnavailableError,
   withModalCommandStartSignal,
   getModalCommandStartInvocation,
   parseExecBannerSessionId,
@@ -40443,6 +41214,7 @@ export {
   renderRoutingMutationOutcomeUnknownToolResult,
   RoutingSandboxSession,
   ModalCloudBucketMountStrategy,
+  reduceModalRawOutputPage,
   captureWorkspaceArchiveForStorage,
   disposeWorkspaceArchive,
   WorkspaceArchiveIntegrityError,
@@ -40460,6 +41232,10 @@ export {
   CAPABILITY_DESCRIPTORS,
   DESKTOP_STREAM_PORT,
   assertDescriptorRegistryInvariants,
+  classifyProviderSandboxFailure,
+  isProviderSandboxNotFoundError2 as isProviderSandboxNotFoundError,
+  isProviderSandboxGoneDuringRoutedOperation,
+  isProviderSandboxTransientError,
   modalSandboxAttributionEnvironment,
   modalSandboxAttributionTags,
   isModalTaskExecStartPreDispatchUnavailableError,
@@ -40533,10 +41309,6 @@ export {
   backendSupportsOs,
   desktopCapableBackend,
   negotiateCapabilities,
-  classifyProviderSandboxFailure,
-  isProviderSandboxNotFoundError2 as isProviderSandboxNotFoundError,
-  isProviderSandboxGoneDuringRoutedOperation,
-  isProviderSandboxTransientError,
   sandboxCommandExitCode,
   sandboxCommandOutput,
   sandboxCommandStdout,
@@ -40647,4 +41419,4 @@ export {
   collectSandboxEnvironment2 as collectSandboxEnvironment,
   parseExposedPorts2 as parseExposedPorts
 };
-//# sourceMappingURL=chunk-D5DPVA2C.js.map
+//# sourceMappingURL=chunk-R25L27T3.js.map