@spotpatch/bridge 0.1.0 → 0.2.0

package/dist/index.js

@@ -542,11 +542,11 @@ function createSpotPatchBridgeClient(cwd = process.cwd()) {
 }
 
 // src/cli-runner.ts
-import path6 from "path";
+import path9 from "path";
 import {
-  ERROR_CODES as ERROR_CODES10,
-  EXTERNAL_HANDOFF_LIMITS as EXTERNAL_HANDOFF_LIMITS9,
-  SpotPatchError as SpotPatchError10
+  ERROR_CODES as ERROR_CODES11,
+  EXTERNAL_HANDOFF_LIMITS as EXTERNAL_HANDOFF_LIMITS10,
+  SpotPatchError as SpotPatchError11
 } from "@spotpatch/shared";
 
 // src/active/claude/channel-adapter.ts
@@ -802,7 +802,7 @@ import { z as z3 } from "zod";
 // package.json
 var package_default = {
   name: "@spotpatch/bridge",
-  version: "0.1.0",
+  version: "0.2.0",
   description: "Local MCP inbox and explicit active Agent connectors for SpotPatch handoffs.",
   license: "MIT",
   repository: {
@@ -853,6 +853,7 @@ var package_default = {
   },
   dependencies: {
     "@modelcontextprotocol/server": "2.0.0",
+    "@spotpatch/agent": "workspace:^",
     "@spotpatch/shared": "workspace:^",
     zod: "4.4.3"
   },
@@ -1836,15 +1837,19 @@ async function applyBridgeSetupPlan(plan) {
 
 // src/active/codex/errors.ts
 var CODEX_ADAPTER_ERROR_CODES = Object.freeze({
+  AUTH_REQUIRED: "CODEX_AUTH_REQUIRED",
   BUSY: "CODEX_ADAPTER_BUSY",
   CLOSED: "CODEX_ADAPTER_CLOSED",
+  CONFIG_ISOLATION_UNSUPPORTED: "CODEX_CONFIG_ISOLATION_UNSUPPORTED",
   EXECUTABLE_NOT_FOUND: "CODEX_EXECUTABLE_NOT_FOUND",
   EXECUTABLE_UNTRUSTED: "CODEX_EXECUTABLE_UNTRUSTED",
   MCP_NOT_READY: "CODEX_MCP_NOT_READY",
+  MODEL_UNAVAILABLE: "CODEX_MODEL_UNAVAILABLE",
   PROCESS_EXITED: "CODEX_PROCESS_EXITED",
   PROTOCOL: "CODEX_APP_SERVER_PROTOCOL_ERROR",
   REQUEST_FAILED: "CODEX_APP_SERVER_REQUEST_FAILED",
   REQUEST_TIMEOUT: "CODEX_APP_SERVER_REQUEST_TIMEOUT",
+  THREAD_CLEANUP_INCOMPLETE: "CODEX_THREAD_CLEANUP_INCOMPLETE",
   UNSUPPORTED_VERSION: "CODEX_UNSUPPORTED_VERSION",
   WORKSPACE_WRITE_REQUIRED: "CODEX_WORKSPACE_WRITE_REQUIRED"
 });
@@ -1862,9 +1867,14 @@ import { constants as fsConstants } from "fs";
 import { access, realpath as realpath3, stat } from "fs/promises";
 import path4 from "path";
 import { spawn } from "child_process";
-var SUPPORTED_CODEX_VERSION = "0.149.0";
 var VERSION_OUTPUT_LIMIT_BYTES = 8 * 1024;
 var VERSION_PROBE_TIMEOUT_MS = 5e3;
+function supportedVersion(value) {
+  const match = /^codex-cli (0)\.(149)\.(\d+)$/u.exec(value);
+  if (match === null) return void 0;
+  const patchVersion = Number(match[3]);
+  return Number.isSafeInteger(patchVersion) ? `0.149.${String(patchVersion)}` : void 0;
+}
 function isWithin(root, candidate) {
   const relative = path4.relative(root, candidate);
   return relative === "" || !relative.startsWith(`..${path4.sep}`) && relative !== "..";
@@ -1955,24 +1965,24 @@ async function readCodexVersion(executable) {
   });
 }
 async function resolveCodexExecutable(projectRoot, options = {}) {
-  const canonicalRoot = await realpath3(projectRoot);
-  if (!(await stat(canonicalRoot)).isDirectory()) {
+  const canonicalRoot2 = await realpath3(projectRoot);
+  if (!(await stat(canonicalRoot2)).isDirectory()) {
     throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.EXECUTABLE_UNTRUSTED);
   }
   const executable = await findOnTrustedPath(
     options.pathValue ?? process.env.PATH ?? ""
   );
-  if (isWithin(canonicalRoot, executable)) {
+  if (isWithin(canonicalRoot2, executable)) {
     throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.EXECUTABLE_UNTRUSTED);
   }
   const output = await readCodexVersion(executable);
-  const expectedOutput = `codex-cli ${SUPPORTED_CODEX_VERSION}`;
-  if (output !== expectedOutput) {
+  const version = supportedVersion(output);
+  if (version === void 0) {
     throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.UNSUPPORTED_VERSION);
   }
   return Object.freeze({
     path: executable,
-    version: SUPPORTED_CODEX_VERSION
+    version
   });
 }
 
@@ -2844,178 +2854,1173 @@ async function connectCodexAppServer(options) {
   return CodexAppServerAdapter.connect(options);
 }
 
-// src/cli-runner.ts
-function optionValue(arguments_, name) {
-  const index = arguments_.indexOf(name);
-  if (index === -1) return void 0;
-  const value = arguments_[index + 1];
-  if (value === void 0 || value.startsWith("--")) {
-    throw new SpotPatchError10(ERROR_CODES10.INVALID_REQUEST);
+// src/active/codex/managed-adapter.ts
+import { spawn as spawn3 } from "child_process";
+import { realpath as realpath7, stat as stat3 } from "fs/promises";
+import path8 from "path";
+import {
+  ERROR_CODES as ERROR_CODES10,
+  EXTERNAL_HANDOFF_LIMITS as EXTERNAL_HANDOFF_LIMITS9,
+  SpotPatchError as SpotPatchError10
+} from "@spotpatch/shared";
+
+// src/active/codex/managed-runtime.ts
+import { randomBytes as randomBytes4 } from "crypto";
+import { lstat as lstat4, readlink, realpath as realpath6, rename as rename3, rm as rm2, symlink } from "fs/promises";
+import os2 from "os";
+import path7 from "path";
+
+// src/supervisor/private-store.ts
+import { randomBytes as randomBytes3 } from "crypto";
+import { lstat as lstat3, mkdir as mkdir2, open as open3, readFile, realpath as realpath5, rename as rename2, rm } from "fs/promises";
+import os from "os";
+import path6 from "path";
+function defaultConfigBase() {
+  if (process.platform === "darwin") {
+    return path6.join(os.homedir(), "Library", "Application Support", "SpotPatch");
   }
-  return value;
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA;
+    return path6.join(
+      localAppData !== void 0 && path6.isAbsolute(localAppData) ? localAppData : os.homedir(),
+      "SpotPatch"
+    );
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  return path6.join(
+    xdgConfig !== void 0 && path6.isAbsolute(xdgConfig) ? xdgConfig : path6.join(os.homedir(), ".config"),
+    "spotpatch"
+  );
 }
-function allowedArguments(arguments_, booleanOptions, valueOptions) {
-  const allowed = /* @__PURE__ */ new Set([...booleanOptions, ...valueOptions]);
-  const seen = /* @__PURE__ */ new Set();
-  for (let index = 0; index < arguments_.length; index += 1) {
-    const argument = arguments_[index];
-    if (argument === void 0 || !allowed.has(argument) || seen.has(argument)) {
-      throw new SpotPatchError10(ERROR_CODES10.INVALID_REQUEST);
+function permissionsArePrivate(mode) {
+  return process.platform === "win32" || (mode & 63) === 0;
+}
+function isOwnedByCurrentUser(uid) {
+  const currentUid = process.getuid?.();
+  return currentUid === void 0 || uid === currentUid;
+}
+async function ensurePrivateDirectory(directory) {
+  await mkdir2(directory, { recursive: true, mode: 448 });
+  const metadata = await lstat3(directory);
+  if (!metadata.isDirectory() || metadata.isSymbolicLink() || !permissionsArePrivate(metadata.mode) || !isOwnedByCurrentUser(metadata.uid)) {
+    throw new Error("SpotPatch private storage directory is not private.");
+  }
+}
+async function resolvePrivateConfigBase(configuredBase) {
+  const configBase = path6.resolve(configuredBase ?? defaultConfigBase());
+  await ensurePrivateDirectory(configBase);
+  return realpath5(configBase);
+}
+async function readPrivateJson(filePath, maximumBytes) {
+  const metadata = await lstat3(filePath).catch((error) => {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return void 0;
     }
-    seen.add(argument);
-    if (valueOptions.includes(argument)) {
-      const value = arguments_[index + 1];
-      if (value === void 0 || value.startsWith("--")) {
-        throw new SpotPatchError10(ERROR_CODES10.INVALID_REQUEST);
-      }
-      index += 1;
+    throw error;
+  });
+  if (metadata === void 0) return void 0;
+  if (!metadata.isFile() || metadata.isSymbolicLink() || !permissionsArePrivate(metadata.mode) || !isOwnedByCurrentUser(metadata.uid) || metadata.size > maximumBytes) {
+    throw new Error("SpotPatch private storage file is not private or bounded.");
+  }
+  return JSON.parse(await readFile(filePath, "utf8"));
+}
+async function writePrivateJsonAtomic(filePath, temporaryPrefix, value) {
+  const directory = path6.dirname(filePath);
+  await ensurePrivateDirectory(directory);
+  const temporaryPath = path6.join(
+    directory,
+    `.${temporaryPrefix}-${randomBytes3(12).toString("hex")}.tmp`
+  );
+  try {
+    const handle = await open3(temporaryPath, "wx", 384);
+    try {
+      await handle.writeFile(`${JSON.stringify(value)}
+`, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
     }
+    await rename2(temporaryPath, filePath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
   }
 }
-function exitCode(error) {
-  if (error instanceof CodexAdapterError) {
-    if (error.code === CODEX_ADAPTER_ERROR_CODES.EXECUTABLE_UNTRUSTED) return 7;
-    if (error.code === CODEX_ADAPTER_ERROR_CODES.MCP_NOT_READY || error.code === CODEX_ADAPTER_ERROR_CODES.PROTOCOL || error.code === CODEX_ADAPTER_ERROR_CODES.UNSUPPORTED_VERSION) {
-      return 6;
+
+// src/active/codex/managed-runtime.ts
+var AUTH_FILE_NAME = "auth.json";
+var MAXIMUM_AUTH_FILE_BYTES = 1024 * 1024;
+var RUNTIME_KEY_PATTERN = /^[a-f0-9]{64}$/u;
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+function permissionsArePrivate2(mode) {
+  return process.platform === "win32" || (mode & 63) === 0;
+}
+function isOwnedByCurrentUser2(uid) {
+  const currentUid = process.getuid?.();
+  return currentUid === void 0 || uid === currentUid;
+}
+function validateRuntimeKey(runtimeKey) {
+  if (!RUNTIME_KEY_PATTERN.test(runtimeKey)) {
+    throw new TypeError("The managed Codex runtime key is invalid.");
+  }
+}
+function isWithin2(root, candidate) {
+  const relative = path7.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path7.sep}`) && relative !== "..";
+}
+async function canonicalProspectivePath(candidate) {
+  let existing = path7.resolve(candidate);
+  const missingSegments = [];
+  for (; ; ) {
+    const metadata = await lstat4(existing).catch((error) => {
+      if (isMissingPathError(error)) return void 0;
+      throw error;
+    });
+    if (metadata !== void 0) {
+      return path7.join(await realpath6(existing), ...missingSegments.reverse());
     }
-    if (error.code === CODEX_ADAPTER_ERROR_CODES.BUSY || error.code === CODEX_ADAPTER_ERROR_CODES.CLOSED || error.code === CODEX_ADAPTER_ERROR_CODES.EXECUTABLE_NOT_FOUND || error.code === CODEX_ADAPTER_ERROR_CODES.PROCESS_EXITED || error.code === CODEX_ADAPTER_ERROR_CODES.REQUEST_TIMEOUT) {
-      return 8;
+    const parent = path7.dirname(existing);
+    if (parent === existing) throw new Error("No existing path ancestor was found.");
+    missingSegments.push(path7.basename(existing));
+    existing = parent;
+  }
+}
+async function resolveSourceAuthFile(environment) {
+  const configuredHome = environment.CODEX_HOME;
+  const sourceHome = configuredHome ?? path7.join(os2.homedir(), ".codex");
+  if (!path7.isAbsolute(sourceHome)) {
+    throw new Error("CODEX_HOME must be absolute for managed isolation.");
+  }
+  const authFile = path7.join(sourceHome, AUTH_FILE_NAME);
+  const metadata = await lstat4(authFile).catch((error) => {
+    if (isMissingPathError(error)) return void 0;
+    throw error;
+  });
+  if (metadata === void 0) return void 0;
+  if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > MAXIMUM_AUTH_FILE_BYTES || !permissionsArePrivate2(metadata.mode) || !isOwnedByCurrentUser2(metadata.uid)) {
+    throw new Error("The Codex authentication file is not private and bounded.");
+  }
+  return realpath6(authFile);
+}
+async function replaceAuthLink(runtimeHome, sourceAuthFile) {
+  const authLink = path7.join(runtimeHome, AUTH_FILE_NAME);
+  const existing = await lstat4(authLink).catch((error) => {
+    if (isMissingPathError(error)) return void 0;
+    throw error;
+  });
+  if (sourceAuthFile === void 0) {
+    if (existing === void 0) return;
+    if (!existing.isSymbolicLink() || !isOwnedByCurrentUser2(existing.uid)) {
+      throw new Error("The managed Codex authentication entry is not owned.");
     }
-    return 1;
+    await rm2(authLink);
+    return;
   }
-  if (!(error instanceof SpotPatchError10)) return 1;
-  if (error.code === ERROR_CODES10.INVALID_REQUEST) return 2;
-  if (error.code === ERROR_CODES10.SESSION_NOT_FOUND) return 3;
-  if (error.code === ERROR_CODES10.HANDOFF_NOT_FOUND || error.code === ERROR_CODES10.HANDOFF_EXPIRED) {
-    return 4;
+  if (existing !== void 0) {
+    if (!existing.isSymbolicLink() || !isOwnedByCurrentUser2(existing.uid)) {
+      throw new Error("The managed Codex authentication entry is not owned.");
+    }
+    if (await readlink(authLink) === sourceAuthFile) return;
   }
-  if (error.code === ERROR_CODES10.SESSION_AMBIGUOUS) return 5;
-  if (error.code === ERROR_CODES10.BRIDGE_PROTOCOL_MISMATCH) return 6;
-  if (error.code === ERROR_CODES10.BRIDGE_UNAUTHORIZED) return 7;
-  if (error.code === ERROR_CODES10.SESSION_CLOSED || error.code === ERROR_CODES10.EXTERNAL_HANDOFF_UNAVAILABLE) {
-    return 8;
+  const temporaryLink = path7.join(
+    runtimeHome,
+    `.auth-${randomBytes4(12).toString("hex")}.tmp`
+  );
+  try {
+    await symlink(sourceAuthFile, temporaryLink, "file");
+    await rename3(temporaryLink, authLink);
+  } finally {
+    await rm2(temporaryLink, { force: true }).catch(() => void 0);
   }
-  return 1;
 }
-function writeJson(stdout, command, data) {
-  stdout.write(`${JSON.stringify({ schemaVersion: 1, command, data })}
-`);
+async function resolveRuntimeHome(options) {
+  validateRuntimeKey(options.runtimeKey);
+  if (options.runtimeBase !== void 0 && options.excludedRoot !== void 0 && isWithin2(
+    await realpath6(options.excludedRoot),
+    await canonicalProspectivePath(options.runtimeBase)
+  )) {
+    throw new Error("The managed Codex runtime cannot be stored in the project.");
+  }
+  const configBase = await resolvePrivateConfigBase(options.runtimeBase);
+  const configuredRuntimeRoot = path7.join(
+    configBase,
+    "external-agent-runtime",
+    "codex"
+  );
+  if (options.excludedRoot !== void 0 && isWithin2(await realpath6(options.excludedRoot), configuredRuntimeRoot)) {
+    throw new Error("The managed Codex runtime cannot be stored in the project.");
+  }
+  await ensurePrivateDirectory(configuredRuntimeRoot);
+  const runtimeRoot = await realpath6(configuredRuntimeRoot);
+  const runtimeHome = path7.join(runtimeRoot, options.runtimeKey);
+  await ensurePrivateDirectory(runtimeHome);
+  return realpath6(runtimeHome);
 }
-function usage(stderr) {
-  stderr.write(
-    "Usage: spotpatch-bridge <sessions|current|wait|ack|mcp|channel|connect|setup> [options]\n"
+async function prepareManagedCodexRuntimeHome(options) {
+  const sourceAuthFile = await resolveSourceAuthFile(
+    options.environment ?? process.env
+  );
+  const runtimeHome = await resolveRuntimeHome(options);
+  await replaceAuthLink(runtimeHome, sourceAuthFile);
+  return runtimeHome;
+}
+async function removeManagedCodexRuntimeHome(options) {
+  validateRuntimeKey(options.runtimeKey);
+  const configBase = await resolvePrivateConfigBase(options.runtimeBase);
+  const configuredRuntimeRoot = path7.join(
+    configBase,
+    "external-agent-runtime",
+    "codex"
+  );
+  const runtimeRootMetadata = await lstat4(configuredRuntimeRoot).catch(
+    (error) => {
+      if (isMissingPathError(error)) return void 0;
+      throw error;
+    }
   );
+  if (runtimeRootMetadata === void 0) return;
+  if (!runtimeRootMetadata.isDirectory() || runtimeRootMetadata.isSymbolicLink() || !permissionsArePrivate2(runtimeRootMetadata.mode) || !isOwnedByCurrentUser2(runtimeRootMetadata.uid)) {
+    throw new Error("The managed Codex runtime root is not private.");
+  }
+  const runtimeRoot = await realpath6(configuredRuntimeRoot);
+  const runtimeHome = path7.join(runtimeRoot, options.runtimeKey);
+  const runtimeMetadata = await lstat4(runtimeHome).catch((error) => {
+    if (isMissingPathError(error)) return void 0;
+    throw error;
+  });
+  if (runtimeMetadata === void 0) return;
+  if (!runtimeMetadata.isDirectory() || runtimeMetadata.isSymbolicLink() || !permissionsArePrivate2(runtimeMetadata.mode) || !isOwnedByCurrentUser2(runtimeMetadata.uid)) {
+    throw new Error("The managed Codex runtime is not owned.");
+  }
+  await rm2(runtimeHome, { recursive: true, force: true });
+}
+
+// src/active/codex/managed-adapter.ts
+var CLIENT_NAME2 = "spotpatch";
+var CLIENT_TITLE2 = "SpotPatch";
+var MANAGED_PERMISSION_PROFILE = "spotpatch-managed";
+var DEFAULT_PROCESS_SHUTDOWN_TIMEOUT_MS2 = 2e3;
+var MAXIMUM_MODEL_PAGES = 8;
+var MAXIMUM_MCP_STATUS_PAGES2 = 8;
+var MANAGED_SHELL_ENVIRONMENT_NAMES = Object.freeze([
+  "LANG",
+  "LC_ALL",
+  "NODE_ENV",
+  "NO_COLOR",
+  "PATH",
+  "PATHEXT",
+  "SSL_CERT_DIR",
+  "SSL_CERT_FILE",
+  "SYSTEMROOT",
+  "TEMP",
+  "TMP",
+  "TMPDIR"
+]);
+var MANAGED_SHELL_ENVIRONMENT_FILTERS = Object.freeze(
+  Object.fromEntries(
+    MANAGED_SHELL_ENVIRONMENT_NAMES.map((name) => [name, "include"])
+  )
+);
+var MANAGED_SHELL_ENVIRONMENT_POLICY = Object.freeze({
+  inherit: "all",
+  ignore_default_excludes: false,
+  filters: MANAGED_SHELL_ENVIRONMENT_FILTERS
+});
+var MANAGED_SHELL_ENVIRONMENT_POLICY_TOML = `{ inherit="all", ignore_default_excludes=false, filters={ ${MANAGED_SHELL_ENVIRONMENT_NAMES.map(
+  (name) => `${name}="include"`
+).join(", ")} } }`;
+var MANAGED_CODEX_CONFIG_OVERRIDES = Object.freeze([
+  "agents.enabled=false",
+  "features.apps=false",
+  "features.hooks=false",
+  "features.plugins=false",
+  "features.remote_plugin=false",
+  'web_search="disabled"',
+  "mcp_servers={}",
+  `shell_environment_policy=${MANAGED_SHELL_ENVIRONMENT_POLICY_TOML}`
+]);
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys2(value, keys) {
+  const actual = Object.keys(value);
+  return actual.length === keys.length && keys.every((key) => key in value);
 }
 function abortError4() {
-  const error = new Error("The SpotPatch command was interrupted.");
+  const error = new Error("The managed Codex operation was aborted.");
   error.name = "AbortError";
   return error;
 }
-function abortableOperation(operation, signal) {
-  if (signal.aborted) return Promise.reject(abortError4());
-  return new Promise((resolve, reject) => {
-    const finish = () => {
-      signal.removeEventListener("abort", abort);
-    };
-    const abort = () => {
-      finish();
-      reject(abortError4());
-    };
-    signal.addEventListener("abort", abort, { once: true });
-    void operation.then(
-      (value) => {
-        finish();
-        resolve(value);
-      },
-      (error) => {
-        finish();
-        reject(
-          error instanceof Error ? error : new Error("The SpotPatch operation failed.", { cause: error })
-        );
-      }
-    );
-  });
+function managedFailureReason(error, fallback) {
+  if (error instanceof CodexAdapterError) {
+    if (error.code === CODEX_ADAPTER_ERROR_CODES.CONFIG_ISOLATION_UNSUPPORTED) {
+      return "config-isolation";
+    }
+    if (error.code === CODEX_ADAPTER_ERROR_CODES.PROTOCOL || error.code === CODEX_ADAPTER_ERROR_CODES.REQUEST_FAILED) {
+      return "protocol";
+    }
+    return fallback;
+  }
+  if (!(error instanceof SpotPatchError10)) return fallback;
+  switch (error.code) {
+    case ERROR_CODES10.AGENT_LIMIT_EXCEEDED:
+      return "change-limit";
+    case ERROR_CODES10.PATCH_REJECTED:
+    case ERROR_CODES10.HANDOFF_VALIDATION_FAILED:
+      return "scope";
+    case ERROR_CODES10.VALIDATION_FAILED:
+      return "validation";
+    case ERROR_CODES10.APPLY_CONFLICT:
+      return "workspace-conflict";
+    case ERROR_CODES10.WORKTREE_CONFLICTED:
+    case ERROR_CODES10.WORKTREE_DIRTY:
+    case ERROR_CODES10.WORKTREE_LOCAL_CHANGES_TOO_LARGE:
+    case ERROR_CODES10.WORKTREE_LOCAL_CHANGES_UNSUPPORTED:
+    case ERROR_CODES10.WORKTREE_NOT_REPOSITORY:
+    case ERROR_CODES10.WORKTREE_OPERATION_IN_PROGRESS:
+    case ERROR_CODES10.WORKTREE_UNTRACKED_UNSUPPORTED:
+      return "snapshot";
+    default:
+      return fallback;
+  }
 }
-function processSignalScope(onInterrupt) {
-  let interrupted = false;
-  const interrupt = () => {
-    if (interrupted) return;
-    interrupted = true;
-    onInterrupt();
+function throwIfAborted3(signal) {
+  if (signal?.aborted === true) throw abortError4();
+}
+function signalProcessTree2(child, signal) {
+  if (process.platform !== "win32" && child.pid !== void 0) {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  child.kill(signal);
+}
+function managedEnvironment(codexHome) {
+  const names = [
+    "CODEX_ACCESS_TOKEN",
+    "CODEX_API_KEY",
+    "OPENAI_API_KEY",
+    "PATH",
+    "PATHEXT",
+    "SYSTEMROOT",
+    "TMPDIR",
+    "TMP",
+    "TEMP",
+    "LANG",
+    "LC_ALL",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "ALL_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "all_proxy"
+  ];
+  const environment = {
+    CODEX_HOME: codexHome,
+    HOME: codexHome,
+    NO_COLOR: "1",
+    NODE_ENV: process.env.NODE_ENV ?? "development",
+    USERPROFILE: codexHome
   };
-  process.once("SIGINT", interrupt);
-  process.once("SIGTERM", interrupt);
+  for (const name of names) {
+    const value = process.env[name];
+    if (value !== void 0) environment[name] = value;
+  }
+  const loopback = "localhost,127.0.0.1,::1";
+  const existing = process.env.NO_PROXY ?? process.env.no_proxy;
+  environment.NO_PROXY = existing === void 0 ? loopback : `${loopback},${existing}`;
+  environment.no_proxy = environment.NO_PROXY;
+  return environment;
+}
+function managedThreadConfig() {
   return Object.freeze({
-    interrupted: () => interrupted,
-    remove() {
-      process.removeListener("SIGINT", interrupt);
-      process.removeListener("SIGTERM", interrupt);
-    }
+    agents: Object.freeze({ enabled: false }),
+    default_permissions: MANAGED_PERMISSION_PROFILE,
+    features: Object.freeze({
+      apps: false,
+      hooks: false,
+      plugins: false,
+      remote_plugin: false
+    }),
+    mcp_servers: Object.freeze({}),
+    permissions: Object.freeze({
+      [MANAGED_PERMISSION_PROFILE]: Object.freeze({
+        filesystem: Object.freeze({
+          ":root": "deny",
+          ":minimal": "read",
+          ":workspace_roots": Object.freeze({ ".": "write" })
+        }),
+        network: Object.freeze({ enabled: false })
+      })
+    }),
+    shell_environment_policy: MANAGED_SHELL_ENVIRONMENT_POLICY,
+    web_search: "disabled"
   });
 }
-async function runClaudeChannel(cwd, sessionId) {
-  let close;
-  const signals = processSignalScope(() => {
-    void close?.();
+function verifyInitializeResponse2(value, codexHome) {
+  if (!isRecord3(value) || typeof value.userAgent !== "string" || value.codexHome !== codexHome || typeof value.platformFamily !== "string" || typeof value.platformOs !== "string") {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+  }
+}
+function parseAuthReadiness(value) {
+  if (!isRecord3(value) || !hasOnlyKeys2(value, ["account", "requiresOpenaiAuth"]) || typeof value.requiresOpenaiAuth !== "boolean" || value.account !== null && !isRecord3(value.account)) {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+  }
+  if (value.account !== null) return "authenticated";
+  return value.requiresOpenaiAuth ? "signed-out" : "auth-not-required";
+}
+function parseModelPage(value) {
+  if (!isRecord3(value) || !Array.isArray(value.data) || value.nextCursor !== null && typeof value.nextCursor !== "string") {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+  }
+  const models = value.data.map((item) => {
+    if (!isRecord3(item) || typeof item.model !== "string" || item.model.length === 0 || typeof item.isDefault !== "boolean") {
+      throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+    }
+    return Object.freeze({ model: item.model, isDefault: item.isDefault });
   });
-  try {
-    const exactSessionId = await resolveExactProjectSessionId(cwd, sessionId);
-    const handle = await serveClaudeChannelMcp({ cwd, sessionId: exactSessionId });
-    close = handle.close;
-    if (signals.interrupted()) await handle.close();
-    await handle.done;
-    return signals.interrupted() ? 130 : 0;
-  } finally {
-    signals.remove();
-    await close?.().catch(() => void 0);
+  return Object.freeze({ models: Object.freeze(models), nextCursor: value.nextCursor });
+}
+function verifyConfigRequirements(value) {
+  if (!isRecord3(value) || !hasOnlyKeys2(value, ["requirements"])) {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+  }
+  if (value.requirements === null) return;
+  if (!isRecord3(value.requirements)) {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+  }
+  const approvals = value.requirements.allowedApprovalPolicies;
+  const sandboxes = value.requirements.allowedSandboxModes;
+  const permissionProfiles = value.requirements.allowedPermissionProfiles;
+  if (Array.isArray(approvals) && !approvals.includes("never") || permissionProfiles !== null && (!isRecord3(permissionProfiles) || permissionProfiles[MANAGED_PERMISSION_PROFILE] !== true) || permissionProfiles === null && Array.isArray(sandboxes) && !sandboxes.includes("workspaceWrite")) {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
   }
 }
-function writeCodexConnectorEvent(event, stderr) {
-  if (event.type === "ready") {
-    stderr.write(
-      "[spotpatch:bridge] Codex connected and ready for SpotPatch requests.\n"
-    );
-    return;
+function parseThreadStartResponse2(value, root) {
+  if (!isRecord3(value) || !isRecord3(value.thread) || typeof value.thread.id !== "string" || value.thread.ephemeral !== false || value.thread.cwd !== root || value.cwd !== root || value.approvalPolicy !== "never" || !Array.isArray(value.runtimeWorkspaceRoots) || value.runtimeWorkspaceRoots.length !== 1 || value.runtimeWorkspaceRoots[0] !== root || !isRecord3(value.activePermissionProfile) || value.activePermissionProfile.id !== MANAGED_PERMISSION_PROFILE) {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
   }
-  const revision = String(event.revision);
-  switch (event.phase) {
-    case "dispatching":
-      stderr.write(
-        `[spotpatch:bridge] SpotPatch is preparing revision ${revision} for Codex.
-`
-      );
-      return;
-    case "working":
-      stderr.write(`[spotpatch:bridge] Codex started revision ${revision}.
-`);
-      return;
-    case "completed":
-      stderr.write(
-        `[spotpatch:bridge] Codex turn ended for revision ${revision}; review the workspace. Ready for the next request.
-`
-      );
-      return;
-    case "failed":
-      stderr.write(
-        `[spotpatch:bridge] Revision ${revision} failed before a verified Codex turn completed; review the connector output and workspace. Ready for the next request.
-`
-      );
-      return;
-    case "delivery-unknown":
-      stderr.write(
-        `[spotpatch:bridge] Codex delivery for revision ${revision} is unknown; the connector will stop.
-`
-      );
-      return;
-    case "dispatched":
-      stderr.write(`[spotpatch:bridge] Codex accepted revision ${revision}.
-`);
-      return;
+  return value.thread.id;
+}
+function parseTurn2(value) {
+  if (!isRecord3(value) || typeof value.id !== "string") {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+  }
+  if (value.status !== "inProgress" && value.status !== "completed" && value.status !== "failed" && value.status !== "interrupted") {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
   }
+  return Object.freeze({ id: value.id, status: value.status });
 }
-async function runCodexConnector(adapterKind, cwd, stderr, sessionId) {
-  const pumpController = new AbortController();
-  const startupController = new AbortController();
+function parseTurnEvent2(method, params) {
+  if (method !== "turn/started" && method !== "turn/completed") return void 0;
+  if (!isRecord3(params) || typeof params.threadId !== "string") {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+  }
+  const turn = parseTurn2(params.turn);
+  if (method === "turn/started" && turn.status !== "inProgress" || method === "turn/completed" && turn.status === "inProgress") {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+  }
+  return Object.freeze({
+    kind: method === "turn/started" ? "started" : "completed",
+    status: turn.status,
+    threadId: params.threadId,
+    turnId: turn.id
+  });
+}
+async function canonicalRoot(root) {
+  const canonical = await realpath7(root);
+  if (!(await stat3(canonical)).isDirectory()) {
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.EXECUTABLE_UNTRUSTED);
+  }
+  return canonical;
+}
+var ManagedCodexAppServerAdapter = class _ManagedCodexAppServerAdapter {
+  kind = "codex-app-server";
+  #child;
+  #client;
+  #cleanupJournal;
+  #execution;
+  #onEvent;
+  #processShutdownTimeoutMs;
+  #terminalTimeoutMs;
+  #active;
+  #closed = false;
+  #closePromise;
+  #fatalError;
+  constructor(child, client, options) {
+    this.#child = child;
+    this.#client = client;
+    this.#cleanupJournal = options.cleanupJournal;
+    this.#execution = options.execution;
+    this.#onEvent = options.onEvent;
+    this.#processShutdownTimeoutMs = options.processShutdownTimeoutMs ?? DEFAULT_PROCESS_SHUTDOWN_TIMEOUT_MS2;
+    this.#terminalTimeoutMs = options.terminalTimeoutMs ?? EXTERNAL_HANDOFF_LIMITS9.activeDispatchTimeoutMs;
+  }
+  static async connect(options) {
+    throwIfAborted3(options.signal);
+    const projectRoot = await canonicalRoot(options.projectRoot);
+    const executable = await resolveCodexExecutable(projectRoot, {
+      ...options.pathValue === void 0 ? {} : { pathValue: options.pathValue }
+    });
+    let codexHome;
+    try {
+      codexHome = await prepareManagedCodexRuntimeHome({
+        excludedRoot: projectRoot,
+        ...options.privateRuntimeBase === void 0 ? {} : { runtimeBase: options.privateRuntimeBase },
+        runtimeKey: options.runtimeKey
+      });
+    } catch (error) {
+      throw new CodexAdapterError(
+        CODEX_ADAPTER_ERROR_CODES.CONFIG_ISOLATION_UNSUPPORTED,
+        error
+      );
+    }
+    const args = MANAGED_CODEX_CONFIG_OVERRIDES.flatMap((value) => ["-c", value]);
+    args.push("app-server");
+    const child = spawn3(executable.path, args, {
+      cwd: path8.dirname(executable.path),
+      detached: process.platform !== "win32",
+      env: managedEnvironment(codexHome),
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const state = {};
+    let earlyFatal;
+    const client = new CodexJsonlClient(child, {
+      ...options.maximumLineBytes === void 0 ? {} : { maximumLineBytes: options.maximumLineBytes },
+      ...options.maximumStderrBytes === void 0 ? {} : { maximumStderrBytes: options.maximumStderrBytes },
+      ...options.requestTimeoutMs === void 0 ? {} : { requestTimeoutMs: options.requestTimeoutMs },
+      onFatal(error) {
+        if (state.adapter === void 0) earlyFatal = error;
+        else state.adapter.#handleFatal(error);
+      },
+      onNotification(method, params) {
+        if (state.adapter !== void 0) {
+          state.adapter.#handleNotification(method, params);
+        }
+      }
+    });
+    const adapter = new _ManagedCodexAppServerAdapter(child, client, options);
+    state.adapter = adapter;
+    if (earlyFatal !== void 0) adapter.#handleFatal(earlyFatal);
+    const abort = () => {
+      void adapter.close().catch(() => void 0);
+    };
+    options.signal.addEventListener("abort", abort, { once: true });
+    try {
+      const initialized = await adapter.#request("initialize", {
+        clientInfo: {
+          name: CLIENT_NAME2,
+          title: CLIENT_TITLE2,
+          version: package_default.version
+        },
+        capabilities: { experimentalApi: true, requestAttestation: false }
+      });
+      verifyInitializeResponse2(initialized, codexHome);
+      client.notify("initialized");
+      const account = parseAuthReadiness(
+        await adapter.#request("account/read", { refreshToken: false })
+      );
+      if (account === "signed-out") {
+        throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.AUTH_REQUIRED);
+      }
+      const requestedModel = await adapter.#readDefaultModel();
+      verifyConfigRequirements(await adapter.#request("configRequirements/read", {}));
+      await adapter.#recoverThreadCleanup();
+      throwIfAborted3(options.signal);
+      return Object.freeze({
+        adapter,
+        authReadiness: account,
+        requestedModel,
+        effectiveModel: requestedModel
+      });
+    } catch (error) {
+      await adapter.close();
+      throwIfAborted3(options.signal);
+      throw error;
+    } finally {
+      options.signal.removeEventListener("abort", abort);
+    }
+  }
+  diagnostics() {
+    return this.#client.diagnostics();
+  }
+  async deliver(handoff, lifecycle, signal) {
+    if (this.#active !== void 0) {
+      throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.BUSY);
+    }
+    if (this.#closed) {
+      throw this.#fatalError ?? new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.CLOSED);
+    }
+    this.#onEvent({ type: "phase", revision: handoff.revision, phase: "preparing" });
+    let task;
+    try {
+      task = await this.#execution.prepare(
+        { annotation: handoff.annotation, revision: handoff.revision },
+        signal
+      );
+    } catch (error) {
+      this.#onEvent({
+        type: "failure",
+        revision: handoff.revision,
+        reason: managedFailureReason(error, "snapshot")
+      });
+      await lifecycle.report("failed");
+      return;
+    }
+    let threadId;
+    try {
+      const thread = await this.#request("thread/start", {
+        cwd: task.workspaceRoot,
+        runtimeWorkspaceRoots: [task.workspaceRoot],
+        approvalPolicy: "never",
+        permissions: MANAGED_PERMISSION_PROFILE,
+        config: managedThreadConfig(),
+        ephemeral: false
+      });
+      threadId = parseThreadStartResponse2(thread, task.workspaceRoot);
+      try {
+        await this.#cleanupJournal.add(threadId);
+      } catch (error) {
+        await this.#deleteThread(threadId).catch(() => void 0);
+        throw new CodexAdapterError(
+          CODEX_ADAPTER_ERROR_CODES.THREAD_CLEANUP_INCOMPLETE,
+          error
+        );
+      }
+      await this.#assertNoHooks(task.workspaceRoot);
+      await this.#assertNoMcpServers(threadId);
+      await this.#runTurn(handoff, task, threadId, lifecycle, signal);
+    } catch (error) {
+      if (signal.aborted) throw abortError4();
+      if (error instanceof ActiveDeliveryUnknownError) throw error;
+      this.#onEvent({
+        type: "failure",
+        revision: handoff.revision,
+        reason: managedFailureReason(error, "apply")
+      });
+      await lifecycle.report("failed").catch(() => void 0);
+    } finally {
+      if (threadId !== void 0 && this.#threadCleanupAvailable()) {
+        try {
+          await this.#deleteThread(threadId);
+          await this.#cleanupJournal.remove(threadId);
+        } catch {
+          this.#onEvent({
+            type: "cleanup-warning",
+            revision: handoff.revision
+          });
+        }
+      }
+    }
+  }
+  close() {
+    this.#closePromise ??= this.#closeResources();
+    return this.#closePromise;
+  }
+  async #readDefaultModel() {
+    let cursor = null;
+    const seen = /* @__PURE__ */ new Set();
+    let first;
+    for (let page = 0; page < MAXIMUM_MODEL_PAGES; page += 1) {
+      const value = parseModelPage(
+        await this.#request("model/list", {
+          cursor,
+          limit: 100,
+          includeHidden: false
+        })
+      );
+      first ??= value.models[0]?.model;
+      const selected = value.models.find((model) => model.isDefault)?.model;
+      if (selected !== void 0) return selected;
+      if (value.nextCursor === null || seen.has(value.nextCursor)) break;
+      seen.add(value.nextCursor);
+      cursor = value.nextCursor;
+    }
+    if (first === void 0) {
+      throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.MODEL_UNAVAILABLE);
+    }
+    return first;
+  }
+  async #assertNoMcpServers(threadId) {
+    let cursor = null;
+    const seen = /* @__PURE__ */ new Set();
+    for (let page = 0; page < MAXIMUM_MCP_STATUS_PAGES2; page += 1) {
+      const value = await this.#request("mcpServerStatus/list", {
+        cursor,
+        limit: 100,
+        detail: "toolsAndAuthOnly",
+        threadId
+      });
+      if (!isRecord3(value) || !Array.isArray(value.data) || value.nextCursor !== null && value.nextCursor !== void 0 && typeof value.nextCursor !== "string") {
+        throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+      }
+      if (value.data.length > 0) {
+        throw new CodexAdapterError(
+          CODEX_ADAPTER_ERROR_CODES.CONFIG_ISOLATION_UNSUPPORTED
+        );
+      }
+      const nextCursor = value.nextCursor ?? null;
+      if (nextCursor === null || seen.has(nextCursor)) return;
+      seen.add(nextCursor);
+      cursor = nextCursor;
+    }
+    throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+  }
+  async #assertNoHooks(workspaceRoot) {
+    const value = await this.#request("hooks/list", { cwds: [workspaceRoot] });
+    if (!isRecord3(value) || !Array.isArray(value.data) || value.data.length !== 1) {
+      throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+    }
+    const [entry] = value.data;
+    if (!isRecord3(entry) || entry.cwd !== workspaceRoot || !Array.isArray(entry.hooks) || !Array.isArray(entry.warnings) || !Array.isArray(entry.errors)) {
+      throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+    }
+    if (entry.hooks.length > 0 || entry.warnings.length > 0 || entry.errors.length > 0) {
+      throw new CodexAdapterError(
+        CODEX_ADAPTER_ERROR_CODES.CONFIG_ISOLATION_UNSUPPORTED
+      );
+    }
+  }
+  async #recoverThreadCleanup() {
+    try {
+      for (const entry of await this.#cleanupJournal.list()) {
+        await this.#deleteThread(entry.threadId);
+        await this.#cleanupJournal.remove(entry.threadId);
+      }
+    } catch (error) {
+      throw new CodexAdapterError(
+        CODEX_ADAPTER_ERROR_CODES.THREAD_CLEANUP_INCOMPLETE,
+        error
+      );
+    }
+  }
+  async #runTurn(handoff, task, threadId, lifecycle, signal) {
+    let resolveTerminal;
+    let rejectTerminal;
+    const terminal = new Promise((resolve, reject) => {
+      resolveTerminal = resolve;
+      rejectTerminal = reject;
+    });
+    const active = {
+      events: [],
+      handoff,
+      lifecycle,
+      reject: (error) => rejectTerminal?.(error),
+      resolve: () => resolveTerminal?.(),
+      signal,
+      task,
+      terminal,
+      threadId,
+      finalized: false,
+      processing: Promise.resolve(),
+      started: false,
+      timeout: void 0,
+      terminalEvent: void 0,
+      turnId: void 0,
+      written: false
+    };
+    this.#active = active;
+    const abort = () => {
+      void this.#interruptAndFail(active, threadId);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      const value = await this.#client.request(
+        "turn/start",
+        {
+          threadId,
+          input: [{ type: "text", text: task.prompt, text_elements: [] }],
+          cwd: task.workspaceRoot,
+          approvalPolicy: "never"
+        },
+        () => {
+          active.written = true;
+        }
+      );
+      if (!isRecord3(value) || !hasOnlyKeys2(value, ["turn"])) {
+        throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+      }
+      const turn = parseTurn2(value.turn);
+      if (turn.status !== "inProgress") {
+        throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+      }
+      active.turnId = turn.id;
+      await lifecycle.report("dispatched");
+      active.timeout = setTimeout(() => {
+        void this.#finishUnknown(active);
+      }, this.#terminalTimeoutMs);
+      active.timeout.unref();
+      this.#schedule(active);
+      await terminal;
+    } catch (error) {
+      const explicitlyRejected = error instanceof CodexAdapterError && error.code === CODEX_ADAPTER_ERROR_CODES.REQUEST_FAILED;
+      if (!active.finalized) {
+        if (explicitlyRejected) {
+          this.#onEvent({
+            type: "failure",
+            revision: handoff.revision,
+            reason: "protocol"
+          });
+          await this.#finishFailed(active);
+        } else if (active.written) {
+          await this.#finishUnknown(active);
+        } else {
+          await this.#finishFailed(active);
+        }
+      }
+      await terminal;
+      if (error instanceof ActiveDeliveryUnknownError) throw error;
+    } finally {
+      signal.removeEventListener("abort", abort);
+      this.#cleanup(active);
+    }
+  }
+  #handleNotification(method, params) {
+    let event;
+    try {
+      event = parseTurnEvent2(method, params);
+    } catch {
+      const active2 = this.#active;
+      if (active2 !== void 0) void this.#finishUnknown(active2);
+      this.#client.close();
+      return;
+    }
+    if (event === void 0) return;
+    const active = this.#active;
+    if (active === void 0 || active.finalized || event.threadId !== active.threadId) {
+      return;
+    }
+    active.events.push(event);
+    this.#schedule(active);
+  }
+  #schedule(active) {
+    if (active.turnId === void 0 || active.finalized) return;
+    active.processing = active.processing.then(async () => {
+      while (active.events.length > 0 && !active.finalized) {
+        const event = active.events.shift();
+        if (event?.threadId !== active.threadId || event.turnId !== active.turnId) {
+          continue;
+        }
+        if (event.kind === "started") {
+          if (!active.started) {
+            active.started = true;
+            this.#onEvent({
+              type: "phase",
+              revision: active.handoff.revision,
+              phase: "running"
+            });
+            await active.lifecycle.report("working");
+          }
+          const terminalEvent = active.terminalEvent;
+          active.terminalEvent = void 0;
+          if (terminalEvent !== void 0) {
+            if (terminalEvent.status === "completed") {
+              await this.#finishCompleted(active);
+            } else {
+              await this.#finishFailed(active);
+            }
+          }
+          continue;
+        }
+        if (!active.started) {
+          active.terminalEvent = event;
+          continue;
+        }
+        if (event.status === "completed") await this.#finishCompleted(active);
+        else await this.#finishFailed(active);
+      }
+    }).catch(async () => this.#finishUnknown(active));
+  }
+  async #finishCompleted(active) {
+    if (active.finalized) return;
+    active.finalized = true;
+    try {
+      this.#onEvent({
+        type: "phase",
+        revision: active.handoff.revision,
+        phase: "auditing"
+      });
+      const result = await this.#execution.auditAndApply(
+        active.task,
+        active.signal,
+        (phase) => {
+          this.#onEvent({
+            type: "phase",
+            revision: active.handoff.revision,
+            phase
+          });
+        }
+      );
+      this.#onEvent({ type: "result", result });
+      await active.lifecycle.report("completed");
+      active.resolve();
+    } catch (error) {
+      this.#onEvent({
+        type: "failure",
+        revision: active.handoff.revision,
+        reason: managedFailureReason(error, "apply")
+      });
+      active.finalized = false;
+      await this.#finishFailed(active);
+    }
+  }
+  async #finishFailed(active) {
+    if (active.finalized) return;
+    active.finalized = true;
+    try {
+      await active.lifecycle.report("failed");
+    } finally {
+      active.resolve();
+    }
+  }
+  async #finishUnknown(active) {
+    if (active.finalized) return;
+    active.finalized = true;
+    await active.lifecycle.report("delivery-unknown").catch(() => void 0);
+    active.reject(new ActiveDeliveryUnknownError());
+  }
+  async #interruptAndFail(active, threadId) {
+    if (active.turnId !== void 0 && !this.#closed) {
+      await this.#client.request("turn/interrupt", { threadId, turnId: active.turnId }).catch(() => void 0);
+    }
+    await this.#finishFailed(active);
+  }
+  async #deleteThread(threadId) {
+    const value = await this.#request("thread/delete", { threadId });
+    if (!isRecord3(value) || Object.keys(value).length !== 0) {
+      throw new CodexAdapterError(CODEX_ADAPTER_ERROR_CODES.PROTOCOL);
+    }
+  }
+  async #request(method, params) {
+    this.#throwIfFatal();
+    const value = await this.#client.request(method, params).catch((error) => {
+      this.#throwIfFatal();
+      throw error;
+    });
+    this.#throwIfFatal();
+    return value;
+  }
+  #throwIfFatal() {
+    if (this.#fatalError !== void 0) throw this.#fatalError;
+  }
+  #threadCleanupAvailable() {
+    return !this.#closed;
+  }
+  #handleFatal(error) {
+    this.#fatalError = error;
+    this.#closed = true;
+    if (this.#active !== void 0) void this.#finishUnknown(this.#active);
+  }
+  #cleanup(active) {
+    if (active.timeout !== void 0) clearTimeout(active.timeout);
+    if (this.#active === active) this.#active = void 0;
+  }
+  async #closeResources() {
+    this.#closed = true;
+    if (this.#active !== void 0) await this.#finishUnknown(this.#active);
+    this.#client.close();
+    signalProcessTree2(this.#child, "SIGTERM");
+    await new Promise((resolve) => {
+      let settled = false;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        this.#child.removeListener("exit", finish);
+        signalProcessTree2(this.#child, "SIGKILL");
+        resolve();
+      };
+      const timeout = setTimeout(finish, this.#processShutdownTimeoutMs);
+      timeout.unref();
+      this.#child.once("exit", finish);
+      if (this.#child.exitCode !== null || this.#child.signalCode !== null) finish();
+    });
+  }
+};
+async function connectManagedCodexAppServer(options) {
+  return ManagedCodexAppServerAdapter.connect(options);
+}
+
+// src/cli-runner.ts
+function optionValue(arguments_, name) {
+  const index = arguments_.indexOf(name);
+  if (index === -1) return void 0;
+  const value = arguments_[index + 1];
+  if (value === void 0 || value.startsWith("--")) {
+    throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+  }
+  return value;
+}
+function allowedArguments(arguments_, booleanOptions, valueOptions) {
+  const allowed = /* @__PURE__ */ new Set([...booleanOptions, ...valueOptions]);
+  const seen = /* @__PURE__ */ new Set();
+  for (let index = 0; index < arguments_.length; index += 1) {
+    const argument = arguments_[index];
+    if (argument === void 0 || !allowed.has(argument) || seen.has(argument)) {
+      throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+    }
+    seen.add(argument);
+    if (valueOptions.includes(argument)) {
+      const value = arguments_[index + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
+      }
+      index += 1;
+    }
+  }
+}
+function exitCode(error) {
+  if (error instanceof CodexAdapterError) {
+    if (error.code === CODEX_ADAPTER_ERROR_CODES.EXECUTABLE_UNTRUSTED) return 7;
+    if (error.code === CODEX_ADAPTER_ERROR_CODES.MCP_NOT_READY || error.code === CODEX_ADAPTER_ERROR_CODES.PROTOCOL || error.code === CODEX_ADAPTER_ERROR_CODES.UNSUPPORTED_VERSION) {
+      return 6;
+    }
+    if (error.code === CODEX_ADAPTER_ERROR_CODES.BUSY || error.code === CODEX_ADAPTER_ERROR_CODES.CLOSED || error.code === CODEX_ADAPTER_ERROR_CODES.EXECUTABLE_NOT_FOUND || error.code === CODEX_ADAPTER_ERROR_CODES.PROCESS_EXITED || error.code === CODEX_ADAPTER_ERROR_CODES.REQUEST_TIMEOUT) {
+      return 8;
+    }
+    return 1;
+  }
+  if (!(error instanceof SpotPatchError11)) return 1;
+  if (error.code === ERROR_CODES11.INVALID_REQUEST) return 2;
+  if (error.code === ERROR_CODES11.SESSION_NOT_FOUND) return 3;
+  if (error.code === ERROR_CODES11.HANDOFF_NOT_FOUND || error.code === ERROR_CODES11.HANDOFF_EXPIRED) {
+    return 4;
+  }
+  if (error.code === ERROR_CODES11.SESSION_AMBIGUOUS) return 5;
+  if (error.code === ERROR_CODES11.BRIDGE_PROTOCOL_MISMATCH) return 6;
+  if (error.code === ERROR_CODES11.BRIDGE_UNAUTHORIZED) return 7;
+  if (error.code === ERROR_CODES11.SESSION_CLOSED || error.code === ERROR_CODES11.EXTERNAL_HANDOFF_UNAVAILABLE) {
+    return 8;
+  }
+  return 1;
+}
+function writeJson(stdout, command, data) {
+  stdout.write(`${JSON.stringify({ schemaVersion: 1, command, data })}
+`);
+}
+function usage(stderr) {
+  stderr.write(
+    "Usage: spotpatch-bridge <sessions|current|wait|ack|mcp|channel|connect|setup> [options]\n"
+  );
+}
+function abortError5() {
+  const error = new Error("The SpotPatch command was interrupted.");
+  error.name = "AbortError";
+  return error;
+}
+function abortableOperation(operation, signal) {
+  if (signal.aborted) return Promise.reject(abortError5());
+  return new Promise((resolve, reject) => {
+    const finish = () => {
+      signal.removeEventListener("abort", abort);
+    };
+    const abort = () => {
+      finish();
+      reject(abortError5());
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    void operation.then(
+      (value) => {
+        finish();
+        resolve(value);
+      },
+      (error) => {
+        finish();
+        reject(
+          error instanceof Error ? error : new Error("The SpotPatch operation failed.", { cause: error })
+        );
+      }
+    );
+  });
+}
+function processSignalScope(onInterrupt) {
+  let interrupted = false;
+  const interrupt = () => {
+    if (interrupted) return;
+    interrupted = true;
+    onInterrupt();
+  };
+  process.once("SIGINT", interrupt);
+  process.once("SIGTERM", interrupt);
+  return Object.freeze({
+    interrupted: () => interrupted,
+    remove() {
+      process.removeListener("SIGINT", interrupt);
+      process.removeListener("SIGTERM", interrupt);
+    }
+  });
+}
+async function runClaudeChannel(cwd, sessionId) {
+  let close;
+  const signals = processSignalScope(() => {
+    void close?.();
+  });
+  try {
+    const exactSessionId = await resolveExactProjectSessionId(cwd, sessionId);
+    const handle = await serveClaudeChannelMcp({ cwd, sessionId: exactSessionId });
+    close = handle.close;
+    if (signals.interrupted()) await handle.close();
+    await handle.done;
+    return signals.interrupted() ? 130 : 0;
+  } finally {
+    signals.remove();
+    await close?.().catch(() => void 0);
+  }
+}
+function writeCodexConnectorEvent(event, stderr) {
+  if (event.type === "ready") {
+    stderr.write(
+      "[spotpatch:bridge] Codex connected and ready for SpotPatch requests.\n"
+    );
+    return;
+  }
+  const revision = String(event.revision);
+  switch (event.phase) {
+    case "dispatching":
+      stderr.write(
+        `[spotpatch:bridge] SpotPatch is preparing revision ${revision} for Codex.
+`
+      );
+      return;
+    case "working":
+      stderr.write(`[spotpatch:bridge] Codex started revision ${revision}.
+`);
+      return;
+    case "completed":
+      stderr.write(
+        `[spotpatch:bridge] Codex turn ended for revision ${revision}; review the workspace. Ready for the next request.
+`
+      );
+      return;
+    case "failed":
+      stderr.write(
+        `[spotpatch:bridge] Revision ${revision} failed before a verified Codex turn completed; review the connector output and workspace. Ready for the next request.
+`
+      );
+      return;
+    case "delivery-unknown":
+      stderr.write(
+        `[spotpatch:bridge] Codex delivery for revision ${revision} is unknown; the connector will stop.
+`
+      );
+      return;
+    case "dispatched":
+      stderr.write(`[spotpatch:bridge] Codex accepted revision ${revision}.
+`);
+      return;
+  }
+}
+async function runCodexConnector(adapterKind, cwd, stderr, sessionId) {
+  const pumpController = new AbortController();
+  const startupController = new AbortController();
   let fatalError;
   const signals = processSignalScope(() => {
     startupController.abort("cli-interrupted");
@@ -3082,7 +4087,7 @@ async function runSpotPatchBridgeCli(arguments_, options = {}) {
     }
     if (command === "channel") {
       if (rest[0] !== "claude") {
-        throw new SpotPatchError10(ERROR_CODES10.INVALID_REQUEST);
+        throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
       }
       const channelArguments = rest.slice(1);
       allowedArguments(channelArguments, [], ["--session"]);
@@ -3090,12 +4095,12 @@ async function runSpotPatchBridgeCli(arguments_, options = {}) {
     }
     if (command === "connect") {
       if (rest[0] !== "codex") {
-        throw new SpotPatchError10(ERROR_CODES10.INVALID_REQUEST);
+        throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
       }
       const connectorArguments2 = rest.slice(1);
       allowedArguments(connectorArguments2, ["--allow-workspace-write"], ["--session"]);
       if (!connectorArguments2.includes("--allow-workspace-write")) {
-        throw new SpotPatchError10(ERROR_CODES10.INVALID_REQUEST);
+        throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
       }
       return await runCodexConnector(
         adapter,
@@ -3110,12 +4115,12 @@ async function runSpotPatchBridgeCli(arguments_, options = {}) {
       const mode = optionValue(rest, "--mode") ?? "inbox";
       const scope = optionValue(rest, "--scope") ?? "project";
       if (scope !== "project" || mode !== "inbox" && mode !== "active" || mode === "active" && client2 !== "claude" || client2 !== "claude" && client2 !== "cursor" && client2 !== "codex") {
-        throw new SpotPatchError10(ERROR_CODES10.INVALID_REQUEST);
+        throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
       }
       const plan = createBridgeSetupPlan(client2, adapter, cwd, mode);
       const write = rest.includes("--write");
       const result = write ? await applyBridgeSetupPlan(plan) : "dry-run";
-      const displayPath = path6.relative(cwd, plan.path).split(path6.sep).join("/");
+      const displayPath = path9.relative(cwd, plan.path).split(path9.sep).join("/");
       const backup = result === "updated" ? `Backup: ${displayPath}.spotpatch.bak
 ` : "";
       stdout.write(
@@ -3156,8 +4161,8 @@ ${backup}${plan.content}`
       allowedArguments(rest, ["--json"], ["--session", "--after", "--timeout"]);
       const timeoutText = optionValue(rest, "--timeout");
       const timeout = timeoutText === void 0 ? void 0 : Number(timeoutText);
-      if (timeout !== void 0 && (!Number.isSafeInteger(timeout) || timeout <= 0 || timeout > EXTERNAL_HANDOFF_LIMITS9.maximumWaitMs)) {
-        throw new SpotPatchError10(ERROR_CODES10.INVALID_REQUEST);
+      if (timeout !== void 0 && (!Number.isSafeInteger(timeout) || timeout <= 0 || timeout > EXTERNAL_HANDOFF_LIMITS10.maximumWaitMs)) {
+        throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
       }
       const controller = new AbortController();
       const abort = () => {
@@ -3187,7 +4192,7 @@ ${backup}${plan.content}`
     if (command === "ack") {
       allowedArguments(rest, ["--json"], ["--session", "--cursor"]);
       const cursor = optionValue(rest, "--cursor");
-      if (cursor === void 0) throw new SpotPatchError10(ERROR_CODES10.INVALID_REQUEST);
+      if (cursor === void 0) throw new SpotPatchError11(ERROR_CODES11.INVALID_REQUEST);
       const summary = await client.ack(cursor, optionValue(rest, "--session"));
       const result = { outcome: "acknowledged", summary };
       if (json) writeJson(stdout, command, result);
@@ -3201,10 +4206,10 @@ ${backup}${plan.content}`
     usage(stderr);
     return 2;
   } catch (error) {
-    const code = error instanceof SpotPatchError10 || error instanceof CodexAdapterError ? error.code : ERROR_CODES10.INTERNAL_ERROR;
+    const code = error instanceof SpotPatchError11 || error instanceof CodexAdapterError ? error.code : ERROR_CODES11.INTERNAL_ERROR;
     stderr.write(`[spotpatch:bridge] ${code}
 `);
-    if (command === "connect" && (code === ERROR_CODES10.SESSION_NOT_FOUND || code === ERROR_CODES10.SESSION_CLOSED)) {
+    if (command === "connect" && (code === ERROR_CODES11.SESSION_NOT_FOUND || code === ERROR_CODES11.SESSION_CLOSED)) {
       stderr.write(
         "[spotpatch:bridge] The SpotPatch development session ended or changed. Keep the dev server running, then rerun the same connect command.\n"
       );
@@ -3212,9 +4217,724 @@ ${backup}${plan.content}`
     return exitCode(error);
   }
 }
+
+// src/supervisor/supervisor.ts
+import { createInterface } from "readline/promises";
+import {
+  ERROR_CODES as ERROR_CODES12,
+  EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION,
+  EXTERNAL_AGENT_MANAGED_PROFILE as EXTERNAL_AGENT_MANAGED_PROFILE2,
+  SpotPatchError as SpotPatchError12,
+  externalAgentControlStatusSchema,
+  externalAgentManagedResultSchema
+} from "@spotpatch/shared";
+import {
+  createManagedExecutionRunner
+} from "@spotpatch/agent";
+
+// src/supervisor/grant-store.ts
+import { rm as rm3 } from "fs/promises";
+import path10 from "path";
+import { EXTERNAL_AGENT_MANAGED_PROFILE } from "@spotpatch/shared";
+import { computeExternalHandoffProjectKey as computeExternalHandoffProjectKey2 } from "@spotpatch/shared/external-agent-node";
+import { z as z4 } from "zod";
+var GRANT_SCHEMA_VERSION = 1;
+var GRANT_POLICY_VERSION = 1;
+var grantSchema = z4.strictObject({
+  schemaVersion: z4.literal(GRANT_SCHEMA_VERSION),
+  projectKey: z4.string().regex(/^[a-f0-9]{64}$/u),
+  adapterKind: z4.literal("codex"),
+  profile: z4.literal(EXTERNAL_AGENT_MANAGED_PROFILE),
+  policyVersion: z4.literal(GRANT_POLICY_VERSION),
+  createdAt: z4.iso.datetime(),
+  lastUsedAt: z4.iso.datetime()
+});
+async function readSecureGrant(filePath) {
+  return readPrivateJson(filePath, 4096);
+}
+async function writeAtomicGrant(filePath, value) {
+  await writePrivateJsonAtomic(filePath, "grant", value);
+}
+async function createManagedGrantStore(options) {
+  const projectKey = await computeExternalHandoffProjectKey2(options.root);
+  const canonicalBase = await resolvePrivateConfigBase(options.configBase);
+  const directory = path10.join(canonicalBase, "external-agent-grants");
+  await ensurePrivateDirectory(directory);
+  const filePath = path10.join(directory, `${projectKey}.json`);
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const record2 = (createdAt) => Object.freeze({
+    schemaVersion: GRANT_SCHEMA_VERSION,
+    projectKey,
+    adapterKind: "codex",
+    profile: EXTERNAL_AGENT_MANAGED_PROFILE,
+    policyVersion: GRANT_POLICY_VERSION,
+    createdAt,
+    lastUsedAt: now().toISOString()
+  });
+  return Object.freeze({
+    projectKey,
+    async read() {
+      try {
+        const value = await readSecureGrant(filePath);
+        if (value === void 0) return "missing";
+        const parsed = grantSchema.safeParse(value);
+        return parsed.success && parsed.data.projectKey === projectKey ? "valid" : "invalid";
+      } catch {
+        return "invalid";
+      }
+    },
+    async grant() {
+      const timestamp = now().toISOString();
+      await writeAtomicGrant(filePath, record2(timestamp));
+    },
+    async touch() {
+      const value = await readSecureGrant(filePath);
+      const parsed = grantSchema.safeParse(value);
+      if (!parsed.success || parsed.data.projectKey !== projectKey) {
+        throw new Error("Managed grant is invalid.");
+      }
+      await writeAtomicGrant(filePath, record2(parsed.data.createdAt));
+    },
+    async revoke() {
+      await rm3(filePath, { force: true });
+    }
+  });
+}
+
+// src/supervisor/thread-cleanup-journal.ts
+import { rm as rm4 } from "fs/promises";
+import path11 from "path";
+import { computeExternalHandoffProjectKey as computeExternalHandoffProjectKey3 } from "@spotpatch/shared/external-agent-node";
+import { z as z5 } from "zod";
+var CLEANUP_JOURNAL_SCHEMA_VERSION = 1;
+var MAXIMUM_THREAD_RECORDS = 32;
+var MAXIMUM_JOURNAL_BYTES = 16 * 1024;
+function hasOnlyPrintableCharacters(value) {
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code < 32 || code === 127) return false;
+  }
+  return true;
+}
+var threadIdSchema = z5.string().min(1).max(256).refine(hasOnlyPrintableCharacters);
+var journalSchema = z5.strictObject({
+  schemaVersion: z5.literal(CLEANUP_JOURNAL_SCHEMA_VERSION),
+  projectKey: z5.string().regex(/^[a-f0-9]{64}$/u),
+  threads: z5.array(
+    z5.strictObject({
+      threadId: threadIdSchema,
+      createdAt: z5.iso.datetime()
+    })
+  ).max(MAXIMUM_THREAD_RECORDS)
+});
+async function createManagedThreadCleanupJournal(options) {
+  const projectKey = await computeExternalHandoffProjectKey3(options.root);
+  const canonicalBase = await resolvePrivateConfigBase(options.configBase);
+  const directory = path11.join(canonicalBase, "external-agent-cleanup");
+  await ensurePrivateDirectory(directory);
+  const filePath = path11.join(directory, `${projectKey}.json`);
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  let operationTail = Promise.resolve();
+  const readEntries = async () => {
+    const value = await readPrivateJson(filePath, MAXIMUM_JOURNAL_BYTES);
+    if (value === void 0) return Object.freeze([]);
+    const parsed = journalSchema.safeParse(value);
+    if (!parsed.success || parsed.data.projectKey !== projectKey) {
+      throw new Error("Managed thread cleanup journal is invalid.");
+    }
+    return Object.freeze(
+      parsed.data.threads.map((entry) => Object.freeze({ ...entry }))
+    );
+  };
+  const writeEntries = async (entries) => {
+    if (entries.length === 0) {
+      await rm4(filePath, { force: true });
+      return;
+    }
+    await writePrivateJsonAtomic(filePath, "cleanup", {
+      schemaVersion: CLEANUP_JOURNAL_SCHEMA_VERSION,
+      projectKey,
+      threads: entries
+    });
+  };
+  const serialize = (operation) => {
+    const result = operationTail.then(operation, operation);
+    operationTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  };
+  return Object.freeze({
+    list: () => serialize(readEntries),
+    add(threadId) {
+      return serialize(async () => {
+        const parsedThreadId = threadIdSchema.parse(threadId);
+        const entries = await readEntries();
+        if (entries.some((entry) => entry.threadId === parsedThreadId)) return;
+        if (entries.length >= MAXIMUM_THREAD_RECORDS) {
+          throw new Error("Managed thread cleanup journal is full.");
+        }
+        await writeEntries([
+          ...entries,
+          Object.freeze({
+            threadId: parsedThreadId,
+            createdAt: now().toISOString()
+          })
+        ]);
+      });
+    },
+    remove(threadId) {
+      return serialize(async () => {
+        const parsedThreadId = threadIdSchema.parse(threadId);
+        const entries = await readEntries();
+        await writeEntries(
+          entries.filter((entry) => entry.threadId !== parsedThreadId)
+        );
+      });
+    }
+  });
+}
+
+// src/supervisor/supervisor.ts
+var MAXIMUM_IDEMPOTENCY_RECORDS = 64;
+var MAXIMUM_RESULT_RECORDS = 16;
+function managedError(code, stage, recoverability, action) {
+  return Object.freeze({ code, stage, recoverability, action });
+}
+function classifyConnectionError(error) {
+  if (error instanceof SpotPatchError12) {
+    if (error.code === ERROR_CODES12.WORKTREE_NOT_REPOSITORY) {
+      return managedError(
+        "MANAGED_GIT_REQUIRED",
+        "snapshot",
+        "reconfigure",
+        "use-inbox"
+      );
+    }
+    if (error.code === ERROR_CODES12.WORKTREE_DIRTY || error.code === ERROR_CODES12.WORKTREE_CONFLICTED || error.code === ERROR_CODES12.WORKTREE_OPERATION_IN_PROGRESS) {
+      return managedError(
+        "MANAGED_SNAPSHOT_FAILED",
+        "snapshot",
+        "user-action",
+        "review-workspace-conflict"
+      );
+    }
+  }
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    if (error.code === "CODEX_EXECUTABLE_NOT_FOUND") {
+      return managedError(
+        "AGENT_BINARY_NOT_FOUND",
+        "binary",
+        "user-action",
+        "install-agent"
+      );
+    }
+    if (error.code === "CODEX_EXECUTABLE_UNTRUSTED") {
+      return managedError(
+        "AGENT_BINARY_UNTRUSTED",
+        "binary",
+        "reconfigure",
+        "use-inbox"
+      );
+    }
+    if (error.code === "CODEX_UNSUPPORTED_VERSION") {
+      return managedError(
+        "AGENT_VERSION_UNSUPPORTED",
+        "protocol",
+        "user-action",
+        "use-supported-version"
+      );
+    }
+    if (error.code === "CODEX_AUTH_REQUIRED") {
+      return managedError("AGENT_AUTH_REQUIRED", "auth", "user-action", "sign-in");
+    }
+    if (error.code === "CODEX_MODEL_UNAVAILABLE") {
+      return managedError(
+        "AGENT_MODEL_UNAVAILABLE",
+        "model",
+        "user-action",
+        "choose-available-model"
+      );
+    }
+    if (error.code === "CODEX_CONFIG_ISOLATION_UNSUPPORTED") {
+      return managedError(
+        "CODEX_CONFIG_ISOLATION_UNSUPPORTED",
+        "protocol",
+        "reconfigure",
+        "use-inbox"
+      );
+    }
+    if (error.code === "CODEX_APP_SERVER_PROTOCOL_ERROR") {
+      return managedError(
+        "AGENT_PROTOCOL_INCOMPATIBLE",
+        "protocol",
+        "reconfigure",
+        "use-supported-version"
+      );
+    }
+    if (error.code === "CODEX_THREAD_CLEANUP_INCOMPLETE") {
+      return managedError(
+        "MANAGED_CLEANUP_INCOMPLETE",
+        "cleanup",
+        "user-action",
+        "inspect-cleanup-warning"
+      );
+    }
+  }
+  return managedError("APP_SERVER_HANDSHAKE_FAILED", "handshake", "retry", "retry");
+}
+function managedExecutionError(reason) {
+  switch (reason) {
+    case "config-isolation":
+      return managedError(
+        "CODEX_CONFIG_ISOLATION_UNSUPPORTED",
+        "protocol",
+        "reconfigure",
+        "use-inbox"
+      );
+    case "protocol":
+      return managedError(
+        "AGENT_PROTOCOL_INCOMPATIBLE",
+        "protocol",
+        "reconfigure",
+        "use-supported-version"
+      );
+    case "snapshot":
+      return managedError(
+        "MANAGED_SNAPSHOT_FAILED",
+        "snapshot",
+        "user-action",
+        "review-workspace-conflict"
+      );
+    case "scope":
+      return managedError(
+        "MANAGED_SCOPE_VIOLATION",
+        "audit",
+        "reconfigure",
+        "use-inbox"
+      );
+    case "change-limit":
+      return managedError(
+        "MANAGED_CHANGE_LIMIT_EXCEEDED",
+        "audit",
+        "reconfigure",
+        "use-inbox"
+      );
+    case "validation":
+      return managedError(
+        "MANAGED_VALIDATION_FAILED",
+        "validation",
+        "user-action",
+        "review-candidate-diff"
+      );
+    case "workspace-conflict":
+      return managedError(
+        "MANAGED_WORKSPACE_CONFLICT",
+        "apply",
+        "user-action",
+        "review-workspace-conflict"
+      );
+    case "apply":
+      return managedError(
+        "MANAGED_APPLY_FAILED",
+        "apply",
+        "user-action",
+        "review-candidate-diff"
+      );
+  }
+}
+async function defaultTerminalConfirmation(projectLabel) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  const reader = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    process.stdout.write(
+      [
+        "\nSpotPatch managed Agent access request",
+        `Project: ${projectLabel}`,
+        "Adapter: Codex",
+        `Profile: ${EXTERNAL_AGENT_MANAGED_PROFILE2}`,
+        "Codex may write only an independent temporary snapshot. SpotPatch audits, validates, and applies eligible changes.",
+        "You can revoke this grant from the SpotPatch panel."
+      ].join("\n") + "\n"
+    );
+    const answer = (await reader.question('Type "yes" to grant access: ')).trim().toLowerCase();
+    return answer === "yes";
+  } finally {
+    reader.close();
+  }
+}
+function requestFingerprint(value) {
+  return JSON.stringify(value);
+}
+function taskStatus(revision, phase, current) {
+  return Object.freeze({
+    revision,
+    deliveryStatus: current?.deliveryStatus ?? "queued",
+    executionStatus: current?.executionStatus ?? "not-observable",
+    managedPhase: phase,
+    ...current?.validationOutcome === void 0 ? {} : { validationOutcome: current.validationOutcome },
+    files: [...current?.files ?? []],
+    checks: [...current?.checks ?? []],
+    timings: current?.timings ?? Object.freeze({}),
+    ...current?.resultExpiresAt === void 0 ? {} : { resultExpiresAt: current.resultExpiresAt }
+  });
+}
+async function createExternalAgentSupervisor(options) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const grantStore = await createManagedGrantStore({
+    root: options.root,
+    ...options.configBase === void 0 ? {} : { configBase: options.configBase },
+    now
+  });
+  const cleanupJournal = await createManagedThreadCleanupJournal({
+    root: options.root,
+    ...options.configBase === void 0 ? {} : { configBase: options.configBase },
+    now
+  });
+  const listeners = /* @__PURE__ */ new Set();
+  const idempotency = /* @__PURE__ */ new Map();
+  const results = /* @__PURE__ */ new Map();
+  let connection;
+  let disposed = false;
+  let operationTail = Promise.resolve();
+  let status = externalAgentControlStatusSchema.parse({
+    schemaVersion: EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION,
+    sequence: 0,
+    mode: "inbox",
+    adapter: {
+      kind: "codex",
+      maturity: "experimental",
+      availability: "unavailable"
+    },
+    connectionState: "disconnected",
+    authReadiness: "unknown",
+    grantState: await grantStore.read(),
+    updatedAt: now().toISOString()
+  });
+  const publish = (update) => {
+    status = externalAgentControlStatusSchema.parse({
+      ...status,
+      ...update,
+      schemaVersion: EXTERNAL_AGENT_CONTROL_SCHEMA_VERSION,
+      sequence: status.sequence + 1,
+      updatedAt: now().toISOString()
+    });
+    for (const listener of listeners) {
+      try {
+        listener(status);
+      } catch {
+      }
+    }
+    return status;
+  };
+  const rememberResult = (result) => {
+    const managedResult = externalAgentManagedResultSchema.parse({
+      revision: result.revision,
+      diff: result.diff,
+      files: result.files,
+      checks: result.checks,
+      timings: result.timings,
+      validationOutcome: result.validationOutcome,
+      expiresAt: result.expiresAt
+    });
+    results.set(result.revision, managedResult);
+    while (results.size > MAXIMUM_RESULT_RECORDS) {
+      const oldest = results.keys().next().value;
+      if (oldest === void 0) break;
+      results.delete(oldest);
+    }
+    publish({
+      task: Object.freeze({
+        revision: result.revision,
+        deliveryStatus: "accepted",
+        executionStatus: "terminal-succeeded",
+        managedPhase: result.applied ? "completed" : "review-required",
+        validationOutcome: result.validationOutcome,
+        files: [...result.files],
+        checks: [...result.checks],
+        timings: result.timings,
+        resultExpiresAt: result.expiresAt
+      })
+    });
+  };
+  const stopConnection = async () => {
+    const active = connection;
+    connection = void 0;
+    if (active === void 0) return;
+    active.controller.abort("supervisor-disconnect");
+    await active.pump.close().catch(() => void 0);
+    await active.run.catch(() => void 0);
+    await active.execution.dispose().catch(() => void 0);
+  };
+  const connectInternal = async (allowPrompt) => {
+    if (disposed) throw new SpotPatchError12(ERROR_CODES12.SESSION_CLOSED);
+    if (connection !== void 0) return status;
+    if (process.platform === "win32") {
+      return publish({
+        mode: "inbox",
+        connectionState: "degraded",
+        error: managedError(
+          "MANAGED_PLATFORM_UNSUPPORTED",
+          "integration",
+          "none",
+          "use-inbox"
+        )
+      });
+    }
+    publish({ connectionState: "diagnosing", error: void 0 });
+    let grantState = await grantStore.read();
+    if (grantState === "invalid") {
+      return publish({
+        grantState,
+        connectionState: "error",
+        error: managedError(
+          "MANAGED_GRANT_INVALID",
+          "integration",
+          "user-action",
+          "confirm-managed-access"
+        )
+      });
+    }
+    if (grantState === "missing") {
+      publish({ grantState, connectionState: "awaiting-consent", mode: "inbox" });
+      if (!allowPrompt) return status;
+      const confirmed = await (options.confirmManagedAccess ?? defaultTerminalConfirmation)(options.projectLabel ?? grantStore.projectKey.slice(0, 12));
+      if (!confirmed) return status;
+      await grantStore.grant();
+      grantState = "valid";
+      publish({ grantState });
+    }
+    publish({ connectionState: "connecting", mode: "inbox", error: void 0 });
+    const controller = new AbortController();
+    const execution = createManagedExecutionRunner({
+      root: options.root,
+      ...options.checks === void 0 ? {} : { checks: options.checks },
+      ...options.limits === void 0 ? {} : { limits: options.limits }
+    });
+    try {
+      const adapterConnection = await (options.connectManagedAdapter ?? connectManagedCodexAppServer)({
+        bridgeAdapter: options.bridgeAdapter,
+        execution,
+        cleanupJournal,
+        onEvent(event) {
+          if (event.type === "cleanup-warning") {
+            const current2 = status.task?.revision === event.revision ? status.task : void 0;
+            publish({
+              mode: "inbox",
+              connectionState: "degraded",
+              task: taskStatus(event.revision, "cleanup-warning", current2),
+              error: managedError(
+                "MANAGED_CLEANUP_INCOMPLETE",
+                "cleanup",
+                "user-action",
+                "inspect-cleanup-warning"
+              )
+            });
+            controller.abort("managed-cleanup-incomplete");
+            return;
+          }
+          if (event.type === "failure") {
+            const current2 = status.task?.revision === event.revision ? status.task : void 0;
+            const fatal = event.reason === "config-isolation" || event.reason === "protocol";
+            publish({
+              ...fatal ? { mode: "inbox", connectionState: "degraded" } : {},
+              task: taskStatus(event.revision, "failed", current2),
+              error: managedExecutionError(event.reason)
+            });
+            if (fatal) controller.abort("managed-config-isolation-unsupported");
+            return;
+          }
+          if (event.type === "result") {
+            rememberResult(event.result);
+            return;
+          }
+          const current = status.task?.revision === event.revision ? status.task : void 0;
+          publish({
+            task: taskStatus(event.revision, event.phase, current)
+          });
+        },
+        projectRoot: options.root,
+        ...options.configBase === void 0 ? {} : { privateRuntimeBase: options.configBase },
+        runtimeKey: grantStore.projectKey,
+        sessionId: options.sessionId,
+        signal: controller.signal
+      });
+      await grantStore.touch();
+      const pump = createActiveEventPump({
+        adapter: adapterConnection.adapter,
+        client: createSpotPatchBridgeClient(options.root),
+        sessionId: options.sessionId,
+        onEvent(event) {
+          if (event.type === "ready") {
+            publish({ connectionState: "ready", mode: "managed", error: void 0 });
+            return;
+          }
+          const current = status.task?.revision === event.revision ? status.task : void 0;
+          const task = taskStatus(
+            event.revision,
+            event.phase === "working" ? "running" : event.phase === "completed" ? current?.managedPhase ?? "completed" : event.phase === "failed" || event.phase === "delivery-unknown" ? "failed" : current?.managedPhase ?? "preparing",
+            current
+          );
+          publish({
+            connectionState: event.phase === "completed" || event.phase === "failed" ? "ready" : "busy",
+            task: Object.freeze({
+              ...task,
+              deliveryStatus: event.phase === "dispatching" ? "dispatching" : event.phase === "delivery-unknown" ? "unknown" : "accepted",
+              executionStatus: event.phase === "working" ? "started" : event.phase === "completed" ? "terminal-succeeded" : event.phase === "failed" ? "terminal-failed" : event.phase === "delivery-unknown" ? "unknown" : task.executionStatus
+            })
+          });
+        }
+      });
+      const run = pump.run(controller.signal).catch((error) => {
+        if (!controller.signal.aborted && !disposed) {
+          publish({
+            mode: "inbox",
+            connectionState: "degraded",
+            error: classifyConnectionError(error)
+          });
+        }
+      }).finally(async () => {
+        if (connection?.controller === controller) connection = void 0;
+        await execution.dispose().catch(() => void 0);
+      });
+      const activeConnection = {
+        controller,
+        execution,
+        pump,
+        run
+      };
+      connection = activeConnection;
+      publish({
+        adapter: {
+          kind: "codex",
+          maturity: "experimental",
+          availability: "available"
+        },
+        authReadiness: adapterConnection.authReadiness,
+        ...adapterConnection.requestedModel === void 0 ? {} : { requestedModel: adapterConnection.requestedModel },
+        ...adapterConnection.effectiveModel === void 0 ? {} : { effectiveModel: adapterConnection.effectiveModel }
+      });
+      return status;
+    } catch (error) {
+      controller.abort("supervisor-connect-failed");
+      await execution.dispose().catch(() => void 0);
+      const classified = classifyConnectionError(error);
+      return publish({
+        mode: "inbox",
+        connectionState: "degraded",
+        ...classified.code === "AGENT_AUTH_REQUIRED" ? { authReadiness: "signed-out" } : {},
+        error: classified
+      });
+    }
+  };
+  const serialize = (operation) => {
+    const result = operationTail.then(operation, operation);
+    operationTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  };
+  const idempotent = (requestId, fingerprint, operation) => {
+    const prior = idempotency.get(requestId);
+    if (prior !== void 0) {
+      if (prior.fingerprint !== fingerprint) {
+        return Promise.reject(new SpotPatchError12(ERROR_CODES12.INVALID_REQUEST));
+      }
+      return prior.result;
+    }
+    const result = serialize(operation);
+    idempotency.set(requestId, { fingerprint, result });
+    while (idempotency.size > MAXIMUM_IDEMPOTENCY_RECORDS) {
+      const oldest = idempotency.keys().next().value;
+      if (oldest === void 0) break;
+      idempotency.delete(oldest);
+    }
+    return result;
+  };
+  const supervisor = Object.freeze({
+    getStatus: () => status,
+    connect(request, signal) {
+      return idempotent(request.requestId, requestFingerprint(request), async () => {
+        if (signal.aborted) throw new SpotPatchError12(ERROR_CODES12.AGENT_CANCELLED);
+        return connectInternal(true);
+      });
+    },
+    disconnect(request) {
+      return idempotent(request.requestId, requestFingerprint(request), async () => {
+        publish({ connectionState: "disconnecting" });
+        await stopConnection();
+        if (request.revokeGrant) {
+          await removeManagedCodexRuntimeHome({
+            ...options.configBase === void 0 ? {} : { runtimeBase: options.configBase },
+            runtimeKey: grantStore.projectKey
+          });
+          await grantStore.revoke();
+        }
+        return publish({
+          mode: "inbox",
+          connectionState: "disconnected",
+          grantState: await grantStore.read(),
+          authReadiness: "unknown",
+          requestedModel: void 0,
+          effectiveModel: void 0,
+          error: void 0
+        });
+      });
+    },
+    cancel(request) {
+      return idempotent(request.requestId, requestFingerprint(request), async () => {
+        if (status.task?.revision !== request.revision) {
+          throw new SpotPatchError12(ERROR_CODES12.HANDOFF_NOT_FOUND);
+        }
+        await stopConnection();
+        return publish({
+          mode: "inbox",
+          connectionState: "disconnected",
+          task: Object.freeze({
+            ...taskStatus(request.revision, "cancelled", status.task),
+            executionStatus: "interrupted"
+          })
+        });
+      });
+    },
+    getResult(revision) {
+      const result = results.get(revision);
+      if (result === void 0) return void 0;
+      if (Date.parse(result.expiresAt) <= now().getTime()) {
+        results.delete(revision);
+        return void 0;
+      }
+      return result;
+    },
+    subscribe(listener) {
+      if (disposed) return () => void 0;
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      listeners.clear();
+      await serialize(stopConnection);
+      idempotency.clear();
+      results.clear();
+    }
+  });
+  if (status.grantState === "valid") {
+    void serialize(async () => {
+      await connectInternal(false);
+    });
+  }
+  return supervisor;
+}
 export {
+  ManagedCodexAppServerAdapter,
   applyBridgeSetupPlan,
+  connectManagedCodexAppServer,
   createBridgeSetupPlan,
+  createExternalAgentSupervisor,
   createSpotPatchBridgeClient,
   createSpotPatchMcpServer,
   runSpotPatchBridgeCli,