@desplega.ai/agent-swarm 1.158.0 → 1.159.0

package/dist/cli-xgpf00sk.js

@@ -0,0 +1,2149 @@
+import {
+  createSwarmEventHandler
+} from "./cli-hsxj0yar.js";
+import {
+  resolveCodexPrompt
+} from "./cli-r94z9p1z.js";
+import {
+  readPkgVersion
+} from "./cli-2djtr51b.js";
+import {
+  buildOtelTraceparentEnv
+} from "./cli-q2j38vre.js";
+import {
+  summarizeSession
+} from "./cli-5f2hq128.js";
+import {
+  CTX_MODE_NUDGE_EVERY
+} from "./cli-zm7njwzd.js";
+import {
+  CONTEXT_FORMULA,
+  clampContextPercent,
+  computeContextUsedUnified
+} from "./cli-wd9hz40d.js";
+import {
+  SessionErrorTracker
+} from "./cli-npssxgaz.js";
+import {
+  applyReasoningEffort
+} from "./cli-ca2w7zv7.js";
+import {
+  buildRatingsFromLlm,
+  fetchRetrievalsForTask,
+  getMemoryRaterNames,
+  postRatings
+} from "./cli-cpvsaqsw.js";
+import {
+  swarmRuntimeInstanceId
+} from "./cli-re8z5p8p.js";
+import {
+  runtimeCatalogModel
+} from "./cli-m4excttz.js";
+import {
+  detachedProcessGroup,
+  registerProcessGroup,
+  terminateProcessGroup
+} from "./cli-y89t4nca.js";
+import {
+  getApiKey
+} from "./cli-f14fvzag.js";
+import {
+  CodexOAuthRefreshError,
+  credentialsToAuthJson,
+  getValidCodexOAuth
+} from "./cli-vhjwh6cz.js";
+import {
+  DEFAULT_MODEL_TIER_MAP,
+  init_types
+} from "./cli-e4xnc0qp.js";
+import {
+  init_src
+} from "./cli-7zttzetj.js";
+import {
+  init_package,
+  package_default
+} from "./cli-48527fpw.js";
+import {
+  init_secret_scrubber,
+  scrubSecrets
+} from "./cli-r2ap2czm.js";
+import {
+  __require
+} from "./cli-bc05qbss.js";
+
+// src/providers/codex-adapter.ts
+import { existsSync as nodeExistsSync } from "node:fs";
+import { join as join2 } from "node:path";
+init_secret_scrubber();
+
+// src/providers/codex-agents-md.ts
+import { lstat, mkdir, readlink, realpath, symlink, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+var BLOCK_OPEN = "<swarm_system_prompt>";
+var BLOCK_CLOSE = "</swarm_system_prompt>";
+var BLOCK_REGEX = /<swarm_system_prompt>[\s\S]*?<\/swarm_system_prompt>\n?/;
+var DEFAULT_STATE_DIR = join(homedir(), ".cache", "agent-swarm", "codex-agents-md");
+var NOOP_HANDLE = {
+  cleanup: async () => {}
+};
+async function readIfExists(path) {
+  const file = Bun.file(path);
+  return await file.exists() ? await file.text() : null;
+}
+function recordPathFor(stateDir, realCwd) {
+  const key = new Bun.CryptoHasher("sha256").update(realCwd).digest("hex");
+  return join(stateDir, `${key}.json`);
+}
+async function readRecord(recordPath, realCwd) {
+  try {
+    const record = JSON.parse(await Bun.file(recordPath).text());
+    if (record.cwd === realCwd && typeof record.linkTarget === "string") {
+      return { cwd: record.cwd, linkTarget: record.linkTarget };
+    }
+  } catch {}
+  return null;
+}
+async function inTreeTarget(realCwd, agentsMdPath, linkTarget) {
+  const target = await realpath(resolve(dirname(agentsMdPath), linkTarget)).catch(() => null);
+  const prefix = realCwd.endsWith(sep) ? realCwd : `${realCwd}${sep}`;
+  if (target === null || !target.startsWith(prefix)) {
+    return null;
+  }
+  const stat = await lstat(target).catch(() => null);
+  return stat?.isFile() ? target : null;
+}
+async function restoreSymlink(agentsMdPath, realCwd, linkTarget) {
+  const stat = await lstat(agentsMdPath).catch(() => null);
+  const current = stat?.isFile() ? await Bun.file(agentsMdPath).text() : null;
+  await unlink(agentsMdPath).catch(() => {});
+  await symlink(linkTarget, agentsMdPath);
+  if (current === null) {
+    return;
+  }
+  const target = await inTreeTarget(realCwd, agentsMdPath, linkTarget);
+  if (target === null) {
+    return;
+  }
+  const stripped = current.replace(BLOCK_REGEX, "");
+  if (stripped !== await Bun.file(target).text()) {
+    await Bun.write(target, stripped);
+  }
+}
+async function writeCodexAgentsMd(cwd, systemPrompt, options = {}) {
+  if (!cwd || !systemPrompt) {
+    return NOOP_HANDLE;
+  }
+  const agentsMdPath = join(cwd, "AGENTS.md");
+  const claudeMdPath = join(cwd, "CLAUDE.md");
+  const stateDir = options.stateDir ?? DEFAULT_STATE_DIR;
+  const realCwd = await realpath(cwd).catch(() => resolve(cwd));
+  const recordPath = recordPathFor(stateDir, realCwd);
+  const block = `${BLOCK_OPEN}
+${systemPrompt}
+${BLOCK_CLOSE}`;
+  let stat = await lstat(agentsMdPath).catch(() => null);
+  const record = await readRecord(recordPath, realCwd);
+  if (record) {
+    if (stat?.isFile() && BLOCK_REGEX.test(await Bun.file(agentsMdPath).text())) {
+      await restoreSymlink(agentsMdPath, realCwd, record.linkTarget);
+      stat = await lstat(agentsMdPath);
+    }
+    await unlink(recordPath).catch(() => {});
+  }
+  if (stat?.isSymbolicLink()) {
+    const linkTarget = await readlink(agentsMdPath);
+    const target = await inTreeTarget(realCwd, agentsMdPath, linkTarget);
+    const targetContent = target !== null ? await Bun.file(target).text() : "";
+    await mkdir(stateDir, { recursive: true });
+    await Bun.write(recordPath, JSON.stringify({ cwd: realCwd, linkTarget }));
+    await unlink(agentsMdPath);
+    await Bun.write(agentsMdPath, `${block}
+${targetContent.replace(BLOCK_REGEX, "")}`);
+    return {
+      async cleanup() {
+        try {
+          await restoreSymlink(agentsMdPath, realCwd, linkTarget);
+          await unlink(recordPath).catch(() => {});
+        } catch {}
+      }
+    };
+  }
+  let createdFresh = false;
+  let newContent;
+  if (!stat) {
+    const claudeContent = await readIfExists(claudeMdPath);
+    newContent = claudeContent !== null ? `${block}
+
+${claudeContent}` : `${block}
+`;
+    createdFresh = true;
+  } else {
+    const existingContent = await Bun.file(agentsMdPath).text();
+    if (BLOCK_REGEX.test(existingContent)) {
+      newContent = existingContent.replace(BLOCK_REGEX, `${block}
+`);
+    } else {
+      newContent = `${block}
+${existingContent}`;
+    }
+  }
+  await Bun.write(agentsMdPath, newContent);
+  return {
+    async cleanup() {
+      try {
+        if (createdFresh) {
+          await Bun.$`rm -f ${agentsMdPath}`.quiet().nothrow();
+          return;
+        }
+        const currentFile = Bun.file(agentsMdPath);
+        if (!await currentFile.exists()) {
+          return;
+        }
+        const currentContent = await currentFile.text();
+        const stripped = currentContent.replace(BLOCK_REGEX, "");
+        await Bun.write(agentsMdPath, stripped);
+      } catch {}
+    }
+  };
+}
+
+// src/providers/codex-app-server.ts
+init_package();
+init_secret_scrubber();
+var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+var CLOSE_GRACE_MS = 250;
+var EXIT_STREAM_DRAIN_MS = 100;
+var MAX_STDOUT_LINE_LENGTH = 16 * 1024 * 1024;
+var MAX_STDERR_LINE_LENGTH = 64 * 1024;
+var MAX_STDERR_TAIL_LENGTH = 16 * 1024;
+
+class CodexAppServerRpcError extends Error {
+  code;
+  data;
+  constructor(method, error) {
+    super(`Codex app-server ${method} failed (${error.code}): ${error.message}`);
+    this.name = "CodexAppServerRpcError";
+    this.code = error.code;
+    this.data = error.data;
+  }
+}
+
+class CodexAppServer {
+  proc;
+  pending = new Map;
+  notificationListeners = new Set;
+  closeListeners = new Set;
+  requestTimeoutMs;
+  onStderr;
+  ready;
+  stderrDone;
+  nextId = 0;
+  stderrTail = "";
+  initializedVersion;
+  terminalError;
+  closePromise;
+  constructor(options) {
+    this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    if (!Number.isFinite(this.requestTimeoutMs) || this.requestTimeoutMs <= 0) {
+      throw new Error("Codex app-server requestTimeoutMs must be a positive number");
+    }
+    this.onStderr = options.onStderr;
+    const codexPath = options.codexPath ?? resolveCodexPath(options.env.PATH);
+    const command = [codexPath, "app-server", "--listen", "stdio://"];
+    const env = Object.fromEntries(Object.entries(options.env).filter((entry) => entry[1] !== undefined));
+    this.proc = Bun.spawn(command, {
+      env,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    this.consumeStdout().catch((error) => this.fail(asError(error)));
+    this.stderrDone = this.consumeStderr().catch((error) => {
+      this.fail(asError(error));
+    });
+    this.proc.exited.then(async (exitCode) => {
+      await Promise.race([this.stderrDone, Bun.sleep(EXIT_STREAM_DRAIN_MS)]);
+      if (this.closePromise)
+        return;
+      const suffix = this.stderrTail ? `: ${this.stderrTail}` : "";
+      this.fail(new Error(`Codex app-server exited with code ${exitCode}${suffix}`));
+    });
+    this.ready = Promise.resolve().then(() => this.initialize());
+    this.ready.catch(() => {});
+  }
+  async request(method, params) {
+    await this.ready;
+    return this.requestRaw(method, params);
+  }
+  get version() {
+    return this.initializedVersion;
+  }
+  onNotification(listener) {
+    this.notificationListeners.add(listener);
+    return () => this.notificationListeners.delete(listener);
+  }
+  onClose(listener) {
+    if (this.terminalError) {
+      listener(this.terminalError);
+      return () => {};
+    }
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  }
+  close() {
+    if (this.closePromise)
+      return this.closePromise;
+    this.rejectPending(new Error("Codex app-server closed"));
+    this.closePromise = this.terminate();
+    return this.closePromise;
+  }
+  async initialize() {
+    const response = await this.requestRaw("initialize", {
+      clientInfo: {
+        name: "agent-swarm",
+        title: "Agent Swarm",
+        version: package_default.version
+      },
+      capabilities: {
+        experimentalApi: false,
+        requestAttestation: false
+      }
+    });
+    if (typeof response.userAgent === "string") {
+      this.initializedVersion = parseVersion(response.userAgent);
+    }
+    this.write({ method: "initialized" });
+  }
+  requestRaw(method, params) {
+    if (this.terminalError)
+      return Promise.reject(this.terminalError);
+    if (this.closePromise)
+      return Promise.reject(new Error("Codex app-server closed"));
+    const id = this.nextId++;
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Codex app-server ${method} timed out after ${this.requestTimeoutMs}ms`));
+      }, this.requestTimeoutMs);
+      this.pending.set(id, {
+        method,
+        resolve: resolve2,
+        reject,
+        timer
+      });
+      try {
+        this.write(params === undefined ? { method, id } : { method, id, params });
+      } catch (error) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(asError(error));
+      }
+    });
+  }
+  write(message) {
+    if (this.terminalError)
+      throw this.terminalError;
+    if (this.closePromise)
+      throw new Error("Codex app-server closed");
+    const stdin = this.proc.stdin;
+    stdin.write(`${JSON.stringify(message)}
+`);
+    stdin.flush();
+  }
+  async consumeStdout() {
+    await readLines(this.proc.stdout, MAX_STDOUT_LINE_LENGTH, (line) => this.handleLine(line));
+  }
+  async consumeStderr() {
+    await readLines(this.proc.stderr, MAX_STDERR_LINE_LENGTH, (line) => {
+      const scrubbed = scrubSecrets(line);
+      this.stderrTail = `${this.stderrTail}${this.stderrTail ? `
+` : ""}${scrubbed}`.slice(-MAX_STDERR_TAIL_LENGTH);
+      if (!this.onStderr)
+        return;
+      try {
+        this.onStderr(scrubbed);
+      } catch (error) {
+        console.error(`[codex-app-server] stderr listener failed: ${scrubSecrets(asError(error).message)}`);
+      }
+    });
+  }
+  handleLine(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch (error) {
+      throw new Error("Codex app-server emitted malformed JSON", {
+        cause: error
+      });
+    }
+    if (!isRecord(message)) {
+      throw new Error("Codex app-server emitted a non-object JSON message");
+    }
+    if (isRequestId(message.id)) {
+      if (typeof message.method === "string") {
+        this.rejectServerRequest(message.id, message.method);
+        return;
+      }
+      this.handleResponse(message.id, message);
+      return;
+    }
+    if (typeof message.method === "string") {
+      const notification = {
+        method: message.method,
+        ...Object.hasOwn(message, "params") ? { params: message.params } : {},
+        ...typeof message.emittedAtMs === "number" ? { emittedAtMs: message.emittedAtMs } : {}
+      };
+      for (const listener of this.notificationListeners) {
+        try {
+          listener(notification);
+        } catch (error) {
+          console.error(`[codex-app-server] notification listener failed: ${scrubSecrets(asError(error).message)}`);
+        }
+      }
+      return;
+    }
+    throw new Error("Codex app-server emitted an invalid protocol message");
+  }
+  handleResponse(id, message) {
+    const pending = this.pending.get(id);
+    if (!pending)
+      return;
+    this.pending.delete(id);
+    clearTimeout(pending.timer);
+    if (isRpcError(message.error)) {
+      pending.reject(new CodexAppServerRpcError(pending.method, message.error));
+      return;
+    }
+    if (Object.hasOwn(message, "result")) {
+      pending.resolve(message.result);
+      return;
+    }
+    pending.reject(new Error(`Codex app-server returned an invalid response for ${pending.method}`));
+  }
+  rejectServerRequest(id, method) {
+    this.write({
+      id,
+      error: {
+        code: -32601,
+        message: `Client does not support server request: ${method}`
+      }
+    });
+  }
+  fail(error) {
+    if (this.terminalError || this.closePromise)
+      return;
+    this.terminalError = error;
+    this.rejectPending(error);
+    this.closePromise = this.terminate();
+    for (const listener of this.closeListeners) {
+      try {
+        listener(error);
+      } catch (listenerError) {
+        console.error(`[codex-app-server] close listener failed: ${scrubSecrets(asError(listenerError).message)}`);
+      }
+    }
+    this.closeListeners.clear();
+  }
+  rejectPending(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+  async terminate() {
+    try {
+      this.proc.stdin.end();
+    } catch {}
+    try {
+      this.proc.kill("SIGTERM");
+    } catch {
+      return;
+    }
+    const exited = this.proc.exited.then(() => {
+      return;
+    });
+    await Promise.race([exited, Bun.sleep(CLOSE_GRACE_MS)]);
+    if (this.proc.exitCode === null) {
+      try {
+        this.proc.kill("SIGKILL");
+      } catch {
+        return;
+      }
+      await Promise.race([exited, Bun.sleep(CLOSE_GRACE_MS)]);
+    }
+  }
+}
+async function readLines(stream, maxLineLength, onLine) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      buffered += decoder.decode(value, { stream: !done });
+      let newline = buffered.indexOf(`
+`);
+      while (newline !== -1) {
+        const line = buffered.slice(0, newline).replace(/\r$/, "");
+        buffered = buffered.slice(newline + 1);
+        if (line.length > maxLineLength) {
+          throw new Error(`Codex app-server output line exceeded ${maxLineLength} characters`);
+        }
+        if (line)
+          onLine(line);
+        newline = buffered.indexOf(`
+`);
+      }
+      if (buffered.length > maxLineLength) {
+        throw new Error(`Codex app-server output line exceeded ${maxLineLength} characters`);
+      }
+      if (done)
+        break;
+    }
+    if (buffered) {
+      const line = buffered.replace(/\r$/, "");
+      if (line.length > maxLineLength) {
+        throw new Error(`Codex app-server output line exceeded ${maxLineLength} characters`);
+      }
+      onLine(line);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function resolveCodexPath(path) {
+  const fromPath = Bun.which("codex", { PATH: path ?? process.env.PATH });
+  if (fromPath)
+    return fromPath;
+  try {
+    return Bun.resolveSync("@openai/codex/bin/codex.js", import.meta.dir);
+  } catch {
+    return "codex";
+  }
+}
+function parseVersion(userAgent) {
+  return userAgent.match(/\b\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?\b/)?.[0];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRequestId(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function isRpcError(value) {
+  return isRecord(value) && typeof value.code === "number" && Number.isFinite(value.code) && typeof value.message === "string";
+}
+function asError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+
+// src/providers/codex-models.ts
+init_src();
+init_types();
+var CODEX_DEFAULT_MODEL = DEFAULT_MODEL_TIER_MAP.codex.regular;
+var CLAUDE_SHORTNAME_TIER = {
+  fable: "ultra",
+  opus: "smart",
+  sonnet: "regular",
+  haiku: "smol"
+};
+function resolveCodexModel(modelStr) {
+  if (!modelStr)
+    return CODEX_DEFAULT_MODEL;
+  const normalized = modelStr.toLowerCase();
+  const tier = CLAUDE_SHORTNAME_TIER[normalized];
+  return tier ? DEFAULT_MODEL_TIER_MAP.codex[tier] : normalized;
+}
+var UNKNOWN_CONTEXT_WINDOW = 200000;
+function getCodexContextWindow(model) {
+  const context = runtimeCatalogModel("openai", model)?.limit?.context;
+  return typeof context === "number" && context > 0 ? context : UNKNOWN_CONTEXT_WINDOW;
+}
+function getCodexModelPricing(model) {
+  const cost = runtimeCatalogModel("openai", model)?.cost;
+  if (typeof cost?.input !== "number" || typeof cost.output !== "number")
+    return;
+  return {
+    inputPerMillion: cost.input,
+    cachedInputPerMillion: typeof cost.cache_read === "number" ? cost.cache_read : cost.input / 10,
+    outputPerMillion: cost.output
+  };
+}
+var _warnedUnknownCodexModels = new Set;
+function computeCodexCostUsd(model, inputTokens, cachedInputTokens, outputTokens) {
+  const pricing = getCodexModelPricing(model);
+  if (!pricing) {
+    if (!_warnedUnknownCodexModels.has(model)) {
+      _warnedUnknownCodexModels.add(model);
+      console.warn(`[codex] unpriced model ${JSON.stringify(model)} — adapter cost will report $0; ` + "add it to the model catalog (refresh or overlay row). Server-side recompute will tag costSource='unpriced' if the pricing table has no rows.");
+    }
+    return 0;
+  }
+  const uncachedInput = Math.max(0, inputTokens - cachedInputTokens);
+  const inputCost = uncachedInput / 1e6 * pricing.inputPerMillion;
+  const cachedCost = cachedInputTokens / 1e6 * pricing.cachedInputPerMillion;
+  const outputCost = outputTokens / 1e6 * pricing.outputPerMillion;
+  return inputCost + cachedCost + outputCost;
+}
+
+// src/providers/codex-oauth/home.ts
+import os from "node:os";
+function codexUserHome() {
+  return process.env.HOME || os.homedir();
+}
+
+// src/providers/codex-swarm-events.ts
+function createCodexSwarmEventHandler(opts) {
+  return createSwarmEventHandler({
+    ...opts,
+    sessionIdFallbackPrefix: "codex"
+  });
+}
+
+// src/providers/codex-adapter.ts
+function checkCodexCredentials(env, opts = {}) {
+  const homeDir = opts.homeDir ?? env.HOME ?? "/root";
+  const existsSync = opts.fs?.existsSync ?? nodeExistsSync;
+  const authFile = `${homeDir}/.codex/auth.json`;
+  if (existsSync(authFile)) {
+    return { ready: true, missing: [], satisfiedBy: "file" };
+  }
+  if (env.OPENAI_API_KEY || env.CODEX_OAUTH) {
+    return {
+      ready: true,
+      missing: [],
+      satisfiedBy: "side-effect-pending",
+      hint: "Credential present in env; entrypoint will materialise ~/.codex/auth.json on next boot."
+    };
+  }
+  if (Object.keys(env).some((k) => /^codex_oauth_\d+$/.test(k))) {
+    return {
+      ready: true,
+      missing: [],
+      satisfiedBy: "side-effect-pending",
+      hint: "Codex OAuth credential pool configured; runner will materialise auth.json per-task."
+    };
+  }
+  return {
+    ready: false,
+    missing: ["OPENAI_API_KEY", "CODEX_OAUTH", authFile],
+    hint: "Set OPENAI_API_KEY (entrypoint runs `codex login --with-api-key`), or store CODEX_OAUTH in swarm_config, or place a pre-authenticated `~/.codex/auth.json` in the worker home."
+  };
+}
+async function resolveCodexAuthMode(config, emit, deps = {}) {
+  const fsModule = await import("node:fs/promises");
+  const homedir2 = deps.homedir ?? codexUserHome;
+  const fs = deps.fs ?? {
+    readFile: (path, encoding) => fsModule.readFile(path, encoding),
+    mkdir: (path, opts) => fsModule.mkdir(path, opts),
+    writeFile: (path, data, opts) => fsModule.writeFile(path, data, opts)
+  };
+  const authJsonPath = join2(homedir2(), ".codex", "auth.json");
+  const readAuthMode = async () => {
+    try {
+      const raw = await fs.readFile(authJsonPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return typeof parsed.auth_mode === "string" ? parsed.auth_mode : null;
+    } catch {
+      return null;
+    }
+  };
+  let currentMode = await readAuthMode();
+  const slot = config.codexSlot ?? 0;
+  const isPoolSlot = config.codexSlot !== undefined;
+  if (config.apiUrl && config.apiKey && (currentMode !== "chatgpt" || isPoolSlot)) {
+    let oauthCreds = null;
+    try {
+      oauthCreds = await getValidCodexOAuth(config.apiUrl, config.apiKey, slot);
+    } catch (err) {
+      if (isPoolSlot) {
+        throw new Error(buildPoolRevalidationFailureReason(err, slot));
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      emit({
+        type: "raw_stderr",
+        content: `[codex] OAuth revalidation failed (non-fatal, non-pool auth): ${message}
+`
+      });
+    }
+    if (!oauthCreds && isPoolSlot) {
+      throw new Error(`[auth-error] Codex pool slot ${slot} revalidation failed: no credentials found in config store — the slot may have just been quarantined; re-run codex-login for this slot if this persists.`);
+    }
+    if (oauthCreds) {
+      try {
+        const authJson = credentialsToAuthJson(oauthCreds, {
+          includeRefreshToken: !isPoolSlot
+        });
+        await fs.mkdir(join2(homedir2(), ".codex"), { recursive: true, mode: 448 });
+        await fs.writeFile(authJsonPath, JSON.stringify(authJson, null, 2), { mode: 384 });
+        const verb = currentMode === null ? "Restored" : currentMode === "chatgpt" ? "Revalidated" : "Upgraded api-key auth.json to";
+        emit({
+          type: "raw_stderr",
+          content: `[codex] ${verb} OAuth credentials from config store
+`
+        });
+        currentMode = "chatgpt";
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        emit({
+          type: "raw_stderr",
+          content: `[codex] Failed to write auth.json: ${message}
+`
+        });
+      }
+    }
+  }
+  return currentMode;
+}
+function buildPoolRevalidationFailureReason(err, slot) {
+  if (err instanceof CodexOAuthRefreshError) {
+    if (err.reason === "lock_timeout") {
+      return `[auth-error] Codex pool slot ${slot} [...${err.keySuffix}] revalidation failed: timed out waiting for the refresh lock — transient, will retry on next task.`;
+    }
+    return `[auth-error] Codex pool slot ${slot} [...${err.keySuffix}] revalidation failed: refresh rejected (${err.status ?? "unknown status"} ${err.body ?? ""}) — credential likely revoked; re-run codex-login for this slot.`;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return `[auth-error] Codex pool slot ${slot} revalidation failed: ${message}`;
+}
+async function buildCodexConfig(config, model, emit) {
+  const mcpServers = {};
+  const runtimeInstanceId = swarmRuntimeInstanceId();
+  mcpServers["agent-swarm"] = {
+    url: `${config.apiUrl}/mcp`,
+    http_headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      "X-Agent-ID": config.agentId,
+      "X-Source-Task-Id": config.taskId ?? "",
+      ...runtimeInstanceId ? { "X-Runtime-Instance-ID": runtimeInstanceId } : {}
+    },
+    enabled: true,
+    startup_timeout_sec: 30,
+    tool_timeout_sec: 120
+  };
+  if (config.apiUrl && config.apiKey && config.agentId) {
+    try {
+      const res = await fetch(`${config.apiUrl}/api/agents/${config.agentId}/mcp-servers?resolveSecrets=true`, {
+        headers: {
+          Authorization: `Bearer ${config.apiKey}`,
+          "X-Agent-ID": config.agentId
+        }
+      });
+      if (res.ok) {
+        const data = await res.json();
+        for (const srv of data.servers ?? []) {
+          if (!srv.isActive || !srv.isEnabled)
+            continue;
+          if (srv.transport === "stdio") {
+            if (!srv.command)
+              continue;
+            let parsedArgs = [];
+            try {
+              parsedArgs = srv.args ? JSON.parse(srv.args) : [];
+            } catch {}
+            mcpServers[srv.name] = {
+              command: srv.command,
+              args: parsedArgs,
+              env: srv.resolvedEnv ?? {},
+              enabled: true,
+              startup_timeout_sec: 30,
+              tool_timeout_sec: 120
+            };
+            continue;
+          }
+          if (srv.transport === "http") {
+            if (!srv.url)
+              continue;
+            let parsedHeaders = {};
+            try {
+              parsedHeaders = srv.headers ? JSON.parse(srv.headers) : {};
+            } catch {}
+            mcpServers[srv.name] = {
+              url: srv.url,
+              http_headers: { ...parsedHeaders, ...srv.resolvedHeaders ?? {} },
+              enabled: true,
+              startup_timeout_sec: 30,
+              tool_timeout_sec: 120
+            };
+            continue;
+          }
+          if (srv.transport === "sse") {
+            emit({
+              type: "raw_stderr",
+              content: `[codex] Skipping MCP server "${srv.name}": SSE transport is not yet supported by Codex (tracked in openai/codex#2129).
+`
+            });
+          }
+        }
+      } else {
+        emit({
+          type: "raw_stderr",
+          content: `[codex] Failed to fetch installed MCP servers: HTTP ${res.status}. Continuing with only the swarm MCP server.
+`
+        });
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      emit({
+        type: "raw_stderr",
+        content: `[codex] Failed to fetch installed MCP servers: ${message}. Continuing with only the swarm MCP server.
+`
+      });
+    }
+  }
+  if (process.env.CONTEXT_MODE_DISABLED !== "true") {
+    mcpServers["context-mode"] = {
+      command: "context-mode",
+      enabled: true,
+      startup_timeout_sec: 30,
+      tool_timeout_sec: 120
+    };
+  }
+  const reasoningApplication = applyReasoningEffort("codex", model, config.reasoningEffort);
+  const reasoningConfig = reasoningApplication.kind === "codex-config" ? reasoningApplication.config : {};
+  return {
+    model,
+    approval_policy: "never",
+    sandbox_mode: "danger-full-access",
+    skip_git_repo_check: true,
+    show_raw_agent_reasoning: false,
+    features: { apps: false, hooks: true, plugin_hooks: true },
+    mcp_servers: mcpServers,
+    ...reasoningConfig
+  };
+}
+function textInput(text) {
+  return [{ type: "text", text, text_elements: [] }];
+}
+function normalizeAppServerItem(raw) {
+  const id = typeof raw.id === "string" ? raw.id : "unknown";
+  switch (raw.type) {
+    case "agentMessage":
+      return { id, type: "agent_message", text: typeof raw.text === "string" ? raw.text : "" };
+    case "reasoning":
+      return {
+        id,
+        type: "reasoning",
+        summary: Array.isArray(raw.summary) ? raw.summary.filter((v) => typeof v === "string") : [],
+        content: Array.isArray(raw.content) ? raw.content.filter((v) => typeof v === "string") : []
+      };
+    case "plan":
+      return { id, type: "todo_list", items: typeof raw.text === "string" ? [raw.text] : [] };
+    case "commandExecution":
+      return {
+        id,
+        type: "command_execution",
+        command: typeof raw.command === "string" ? raw.command : "",
+        aggregated_output: typeof raw.aggregatedOutput === "string" ? raw.aggregatedOutput : null,
+        exit_code: typeof raw.exitCode === "number" ? raw.exitCode : null,
+        status: typeof raw.status === "string" ? raw.status : undefined
+      };
+    case "fileChange":
+      return {
+        id,
+        type: "file_change",
+        changes: Array.isArray(raw.changes) ? raw.changes.flatMap((change) => {
+          if (!change || typeof change !== "object")
+            return [];
+          const value = change;
+          const kindValue = value.kind;
+          const kind = typeof kindValue === "string" ? kindValue : kindValue && typeof kindValue === "object" ? kindValue.type : undefined;
+          return [
+            {
+              kind: typeof kind === "string" ? kind : "update",
+              path: typeof value.path === "string" ? value.path : ""
+            }
+          ];
+        }) : [],
+        status: typeof raw.status === "string" ? raw.status : undefined
+      };
+    case "mcpToolCall":
+      return {
+        id,
+        type: "mcp_tool_call",
+        server: typeof raw.server === "string" ? raw.server : "",
+        tool: typeof raw.tool === "string" ? raw.tool : "",
+        arguments: raw.arguments,
+        status: typeof raw.status === "string" ? raw.status : undefined,
+        result: raw.result,
+        error: raw.error
+      };
+    case "webSearch":
+      return { id, type: "web_search", query: typeof raw.query === "string" ? raw.query : "" };
+    default:
+      return {
+        id,
+        type: "unknown",
+        originalType: typeof raw.type === "string" ? raw.type : undefined,
+        value: raw
+      };
+  }
+}
+function normalizeUsage(raw) {
+  if (!raw || typeof raw !== "object")
+    return;
+  const value = raw;
+  return {
+    input_tokens: typeof value.inputTokens === "number" ? value.inputTokens : 0,
+    cached_input_tokens: typeof value.cachedInputTokens === "number" ? value.cachedInputTokens : 0,
+    cache_write_input_tokens: typeof value.cacheWriteInputTokens === "number" ? value.cacheWriteInputTokens : 0,
+    output_tokens: typeof value.outputTokens === "number" ? value.outputTokens : 0,
+    reasoning_output_tokens: typeof value.reasoningOutputTokens === "number" ? value.reasoningOutputTokens : 0
+  };
+}
+function subtractUsage(total, previous) {
+  return {
+    input_tokens: Math.max(0, total.input_tokens - (previous?.input_tokens ?? 0)),
+    cached_input_tokens: Math.max(0, total.cached_input_tokens - (previous?.cached_input_tokens ?? 0)),
+    cache_write_input_tokens: Math.max(0, total.cache_write_input_tokens - (previous?.cache_write_input_tokens ?? 0)),
+    output_tokens: Math.max(0, total.output_tokens - (previous?.output_tokens ?? 0)),
+    reasoning_output_tokens: Math.max(0, total.reasoning_output_tokens - (previous?.reasoning_output_tokens ?? 0))
+  };
+}
+
+class AppServerCodexThread {
+  client;
+  id;
+  get version() {
+    return this.client.version;
+  }
+  activeTurnId = null;
+  activePush = null;
+  activeFinish = null;
+  activeFail = null;
+  latestTotalUsage;
+  completedTotalUsage;
+  emittedThreadStart = false;
+  unsubscribe;
+  unsubscribeClose;
+  turnWaiters = [];
+  constructor(client, threadId) {
+    this.client = client;
+    this.id = threadId;
+    this.unsubscribe = client.onNotification((notification) => this.handleNotification(notification));
+    this.unsubscribeClose = client.onClose((error) => this.activeFail?.(error));
+  }
+  async runStreamed(input) {
+    if (this.activePush)
+      throw new Error("Codex turn already active");
+    const pending = [];
+    let wake = null;
+    let finished = false;
+    let failure = null;
+    const push = (event) => {
+      pending.push(event);
+      wake?.();
+      wake = null;
+    };
+    const finish = () => {
+      finished = true;
+      wake?.();
+      wake = null;
+    };
+    this.activePush = push;
+    this.activeFinish = finish;
+    this.activeFail = (error) => {
+      failure = error;
+      this.activePush = null;
+      this.activeFinish = null;
+      finish();
+    };
+    if (!this.emittedThreadStart) {
+      this.emittedThreadStart = true;
+      push({ type: "thread.started", thread_id: this.id });
+    }
+    try {
+      const response = await this.client.request("turn/start", {
+        threadId: this.id,
+        input: textInput(input)
+      });
+      if (!finished)
+        this.setActiveTurn(response.turn.id);
+    } catch (error) {
+      this.activePush = null;
+      this.activeFinish = null;
+      this.activeFail = null;
+      finish();
+      throw error;
+    }
+    const events = async function* () {
+      while (!finished || pending.length > 0) {
+        if (pending.length === 0) {
+          await new Promise((resolve2) => {
+            wake = resolve2;
+          });
+          continue;
+        }
+        yield pending.shift();
+      }
+      if (failure)
+        throw failure;
+    };
+    return { events: events() };
+  }
+  async steer(input) {
+    const turnId = this.activeTurnId ?? await new Promise((resolve2, reject) => this.turnWaiters.push({ resolve: resolve2, reject }));
+    await this.client.request("turn/steer", {
+      threadId: this.id,
+      expectedTurnId: turnId,
+      input: textInput(input)
+    });
+  }
+  async interrupt() {
+    if (!this.activeTurnId)
+      return;
+    await this.client.request("turn/interrupt", {
+      threadId: this.id,
+      turnId: this.activeTurnId
+    });
+  }
+  async close() {
+    for (const waiter of this.turnWaiters.splice(0)) {
+      waiter.reject(new Error("Codex session has completed"));
+    }
+    this.unsubscribe();
+    this.unsubscribeClose();
+    await this.client.close();
+  }
+  handleNotification(notification) {
+    const params = notification.params && typeof notification.params === "object" ? notification.params : {};
+    if (params.threadId !== undefined && params.threadId !== this.id)
+      return;
+    const push = this.activePush;
+    if (!push)
+      return;
+    switch (notification.method) {
+      case "turn/started": {
+        const turn = params.turn;
+        if (typeof turn?.id === "string")
+          this.setActiveTurn(turn.id);
+        push({ type: "turn.started", turn_id: this.activeTurnId ?? undefined });
+        break;
+      }
+      case "item/started":
+      case "item/completed": {
+        if (!params.item || typeof params.item !== "object")
+          break;
+        push({
+          type: notification.method === "item/started" ? "item.started" : "item.completed",
+          item: normalizeAppServerItem(params.item)
+        });
+        break;
+      }
+      case "item/agentMessage/delta":
+        if (typeof params.itemId === "string" && typeof params.delta === "string") {
+          push({ type: "message.delta", item_id: params.itemId, delta: params.delta });
+        }
+        break;
+      case "thread/tokenUsage/updated": {
+        const tokenUsage = params.tokenUsage;
+        this.latestTotalUsage = normalizeUsage(tokenUsage?.total);
+        break;
+      }
+      case "error": {
+        const error = params.error;
+        if (typeof error?.message === "string") {
+          push({
+            type: "error",
+            message: error.message,
+            willRetry: params.willRetry === true,
+            codexErrorInfo: typeof error.codexErrorInfo === "string" ? error.codexErrorInfo : null
+          });
+        }
+        break;
+      }
+      case "turn/completed": {
+        const turn = params.turn;
+        if (typeof turn?.id === "string" && this.activeTurnId && turn.id !== this.activeTurnId)
+          break;
+        const usage = this.latestTotalUsage ? subtractUsage(this.latestTotalUsage, this.completedTotalUsage) : undefined;
+        if (this.latestTotalUsage)
+          this.completedTotalUsage = this.latestTotalUsage;
+        if (turn?.status === "failed") {
+          push({
+            type: "turn.failed",
+            error: {
+              message: typeof turn.error?.message === "string" ? turn.error.message : "Codex turn failed",
+              codexErrorInfo: typeof turn.error?.codexErrorInfo === "string" ? turn.error.codexErrorInfo : null
+            },
+            usage
+          });
+        } else if (turn?.status === "interrupted") {
+          push({ type: "turn.interrupted", usage });
+        } else {
+          push({ type: "turn.completed", usage });
+        }
+        this.activeTurnId = null;
+        for (const waiter of this.turnWaiters.splice(0)) {
+          waiter.reject(new Error("Codex turn has completed"));
+        }
+        this.activePush = null;
+        this.activeFail = null;
+        this.activeFinish?.();
+        this.activeFinish = null;
+        break;
+      }
+    }
+  }
+  setActiveTurn(turnId) {
+    this.activeTurnId = turnId;
+    for (const waiter of this.turnWaiters.splice(0))
+      waiter.resolve(turnId);
+  }
+}
+
+class CodexSession {
+  thread;
+  config;
+  agentsMdHandle;
+  resolvedModel;
+  contextWindow;
+  skillsDir;
+  summarizeDeps;
+  listeners = [];
+  eventQueue = [];
+  logFileHandle;
+  startedAt = Date.now();
+  completionPromise;
+  resolveCompletion;
+  abortController = null;
+  abortReason = "cancelled";
+  queuedPrompts = [];
+  transcript = [];
+  abortRef = { current: null };
+  _sessionId;
+  numTurns = 0;
+  accumulatedUsage = null;
+  aborted = false;
+  settled = false;
+  acceptsSteering = true;
+  errorTracker = new SessionErrorTracker;
+  appliedReasoningEffort;
+  pendingResult = null;
+  constructor(thread, config, agentsMdHandle, resolvedModel, initialEvents = [], skillsDir, summarizeDeps = {}) {
+    this.thread = thread;
+    this.config = config;
+    this.agentsMdHandle = agentsMdHandle;
+    this.resolvedModel = resolvedModel;
+    this.contextWindow = getCodexContextWindow(resolvedModel);
+    this.skillsDir = skillsDir ?? process.env.CODEX_SKILLS_DIR ?? join2(codexUserHome(), ".codex", "skills");
+    this.summarizeDeps = summarizeDeps;
+    this.logFileHandle = Bun.file(config.logFile).writer();
+    const reasoningApplication = applyReasoningEffort("codex", resolvedModel, config.reasoningEffort);
+    this.appliedReasoningEffort = reasoningApplication.kind === "codex-config" ? config.reasoningEffort ?? null : null;
+    this.completionPromise = new Promise((resolve2) => {
+      this.resolveCompletion = resolve2;
+    });
+    if (config.taskId && config.apiUrl && config.apiKey) {
+      this.listeners.push(createCodexSwarmEventHandler({
+        apiUrl: config.apiUrl,
+        apiKey: config.apiKey,
+        agentId: config.agentId,
+        taskId: config.taskId,
+        abortRef: this.abortRef
+      }));
+    }
+    for (const event of initialEvents) {
+      this.emit(event);
+    }
+    this.runSession();
+  }
+  get sessionId() {
+    return this._sessionId ?? this.thread.id ?? undefined;
+  }
+  onEvent(listener) {
+    this.listeners.push(listener);
+    for (const event of this.eventQueue) {
+      listener(event);
+    }
+    this.eventQueue.length = 0;
+  }
+  async waitForCompletion() {
+    return this.completionPromise;
+  }
+  emitTransportStderr(line) {
+    this.emit({ type: "raw_stderr", content: `${line}
+` });
+  }
+  async abort(reason) {
+    if (this.aborted || this.settled)
+      return;
+    this.aborted = true;
+    this.abortReason = reason ?? "cancelled";
+    if (this.abortController) {
+      this.abortController.abort(this.abortReason);
+      return;
+    }
+    try {
+      await this.thread.interrupt();
+    } catch (error) {
+      this.emit({
+        type: "raw_stderr",
+        content: `[codex] Failed to interrupt turn: ${String(error)}
+`
+      });
+    }
+  }
+  async deliverSteering({ mode, text }) {
+    if (!this.acceptsSteering || this.settled || this.aborted) {
+      return { delivered: false, reason: "Codex session has completed" };
+    }
+    if (mode === "queue") {
+      return new Promise((resolve2) => this.queuedPrompts.push({ text, resolve: resolve2 }));
+    }
+    try {
+      await this.thread.steer(text);
+      return { delivered: true, mode: "steer" };
+    } catch (error) {
+      return { delivered: false, reason: scrubSecrets(String(error)) };
+    }
+  }
+  emit(event) {
+    const scrubbed = JSON.parse(scrubSecrets(JSON.stringify(event)));
+    try {
+      this.logFileHandle.write(`${JSON.stringify({ ...scrubbed, timestamp: new Date().toISOString() })}
+`);
+    } catch {}
+    if (this.listeners.length > 0) {
+      for (const listener of this.listeners) {
+        try {
+          listener(scrubbed);
+        } catch {}
+      }
+    } else {
+      this.eventQueue.push(scrubbed);
+    }
+  }
+  settle(result) {
+    if (this.settled)
+      return;
+    this.settled = true;
+    for (const queued of this.queuedPrompts.splice(0)) {
+      queued.resolve({
+        delivered: false,
+        reason: "Codex session ended before the queued turn started"
+      });
+    }
+    this.pendingResult = { ...result, appliedReasoningEffort: this.appliedReasoningEffort };
+  }
+  buildCostData(usage, isError) {
+    const inputTokens = usage?.input_tokens ?? 0;
+    const cachedInputTokens = usage?.cached_input_tokens ?? 0;
+    const outputTokens = usage?.output_tokens ?? 0;
+    const reasoningOutputTokens = usage?.reasoning_output_tokens ?? 0;
+    return {
+      sessionId: "",
+      taskId: this.config.taskId,
+      agentId: this.config.agentId,
+      totalCostUsd: computeCodexCostUsd(this.resolvedModel, inputTokens, cachedInputTokens, outputTokens),
+      inputTokens,
+      outputTokens,
+      reasoningOutputTokens,
+      cacheReadTokens: cachedInputTokens,
+      cacheWriteTokens: usage?.cache_write_input_tokens,
+      durationMs: Date.now() - this.startedAt,
+      numTurns: this.numTurns,
+      model: this.resolvedModel,
+      isError,
+      provider: "codex"
+    };
+  }
+  toolNameForItem(item) {
+    switch (item.type) {
+      case "command_execution":
+        return "bash";
+      case "file_change": {
+        const first = item.changes[0];
+        if (!first)
+          return "Edit";
+        return first.kind === "add" ? "Write" : first.kind === "delete" ? "Delete" : "Edit";
+      }
+      case "mcp_tool_call":
+        return item.tool;
+      case "web_search":
+        return "WebSearch";
+      default:
+        return item.type;
+    }
+  }
+  toolArgsForItem(item) {
+    switch (item.type) {
+      case "command_execution":
+        return { command: item.command };
+      case "file_change":
+        return { changes: item.changes };
+      case "mcp_tool_call": {
+        const mcpItem = item;
+        return { server: mcpItem.server, tool: mcpItem.tool, arguments: mcpItem.arguments };
+      }
+      case "web_search":
+        return { query: item.query };
+      default:
+        return {};
+    }
+  }
+  isToolItem(item) {
+    return item.type === "command_execution" || item.type === "file_change" || item.type === "mcp_tool_call" || item.type === "web_search";
+  }
+  shortenItemResult(item) {
+    switch (item.type) {
+      case "command_execution": {
+        const cmd = item;
+        const stdout = (cmd.aggregated_output ?? "").slice(0, 500);
+        return `exit=${cmd.exit_code ?? "?"} status=${cmd.status ?? "?"} stdout=${stdout}`;
+      }
+      case "file_change": {
+        const fc = item;
+        const summarised = (fc.changes ?? []).slice(0, 5).map((c) => `${c.kind}:${c.path}`).join(",");
+        return `changes=[${summarised}]`;
+      }
+      case "mcp_tool_call": {
+        const mcp = item;
+        return `server=${mcp.server} tool=${mcp.tool} status=${mcp.status ?? "?"}`;
+      }
+      case "web_search": {
+        const ws = item;
+        return `query=${(ws.query ?? "").slice(0, 200)}`;
+      }
+      default:
+        return JSON.stringify(item).slice(0, 500);
+    }
+  }
+  handleEvent(event) {
+    this.emit({ type: "raw_log", content: JSON.stringify(event) });
+    switch (event.type) {
+      case "thread.started": {
+        this._sessionId = event.thread_id;
+        const codexVersion = this.thread.version ?? readPkgVersion("@openai/codex");
+        this.emit({
+          type: "session_init",
+          sessionId: event.thread_id,
+          provider: "codex",
+          ...codexVersion ? { harnessVariantMeta: { version: codexVersion } } : {}
+        });
+        break;
+      }
+      case "turn.started": {
+        this.numTurns += 1;
+        break;
+      }
+      case "item.started": {
+        if (this.isToolItem(event.item)) {
+          this.emit({
+            type: "tool_start",
+            toolCallId: event.item.id,
+            toolName: this.toolNameForItem(event.item),
+            args: this.toolArgsForItem(event.item)
+          });
+          this.transcript.push(`Tool[${this.toolNameForItem(event.item)}] started: ${JSON.stringify(this.toolArgsForItem(event.item)).slice(0, 500)}`);
+        }
+        break;
+      }
+      case "item.updated": {
+        const updatedItem = event.item;
+        if (updatedItem.type === "agent_message") {
+          const msg = updatedItem;
+          if (msg.text) {
+            this.emit({
+              type: "custom",
+              name: "codex.message_delta",
+              data: { itemId: updatedItem.id, text: msg.text }
+            });
+          }
+        }
+        break;
+      }
+      case "message.delta": {
+        this.emit({
+          type: "custom",
+          name: "codex.message_delta",
+          data: { itemId: event.item_id, text: event.delta }
+        });
+        break;
+      }
+      case "item.completed": {
+        const { item } = event;
+        if (this.isToolItem(item)) {
+          this.emit({
+            type: "tool_end",
+            toolCallId: item.id,
+            toolName: this.toolNameForItem(item),
+            result: item
+          });
+          this.transcript.push(`Tool[${this.toolNameForItem(item)}] completed: ${this.shortenItemResult(item)}`);
+          break;
+        }
+        switch (item.type) {
+          case "agent_message": {
+            const msg = item;
+            if (msg.text) {
+              this.emit({ type: "message", role: "assistant", content: msg.text });
+              this.transcript.push(`Assistant: ${msg.text}`);
+            }
+            break;
+          }
+          case "reasoning": {
+            const r = item;
+            const summary = Array.isArray(r.summary) ? r.summary.join(`
+`) : r.summary;
+            const content = Array.isArray(r.content) ? r.content.join(`
+`) : undefined;
+            const text = r.text || summary || content || "";
+            if (text) {
+              this.emit({
+                type: "custom",
+                name: "codex.reasoning",
+                data: { itemId: r.id, text }
+              });
+            }
+            break;
+          }
+          case "todo_list": {
+            const todo = item;
+            this.emit({
+              type: "custom",
+              name: "codex.todo_list",
+              data: { itemId: todo.id, items: todo.items ?? [] }
+            });
+            break;
+          }
+          case "error": {
+            const errItem = item;
+            this.emit({
+              type: "error",
+              message: this.formatTerminalError(errItem.message).message
+            });
+            break;
+          }
+        }
+        break;
+      }
+      case "turn.completed": {
+        this.accountUsage(event.usage);
+        break;
+      }
+      case "turn.failed": {
+        this.accountUsage(event.usage);
+        const { message } = this.formatTerminalError(event.error.message, event.error.codexErrorInfo);
+        this.emit({ type: "error", message });
+        break;
+      }
+      case "turn.interrupted":
+        this.accountUsage(event.usage);
+        break;
+      case "error": {
+        const { message } = this.formatTerminalError(event.message, event.codexErrorInfo);
+        if (event.willRetry === true) {
+          this.emit({ type: "raw_stderr", content: `[codex] ${message} (retrying)
+` });
+        } else {
+          this.emit({ type: "error", message });
+        }
+        break;
+      }
+    }
+  }
+  accountUsage(usage) {
+    if (!usage)
+      return;
+    this.accumulatedUsage = this.accumulatedUsage ? {
+      input_tokens: this.accumulatedUsage.input_tokens + usage.input_tokens,
+      cached_input_tokens: this.accumulatedUsage.cached_input_tokens + usage.cached_input_tokens,
+      cache_write_input_tokens: this.accumulatedUsage.cache_write_input_tokens + usage.cache_write_input_tokens,
+      output_tokens: this.accumulatedUsage.output_tokens + usage.output_tokens,
+      reasoning_output_tokens: this.accumulatedUsage.reasoning_output_tokens + usage.reasoning_output_tokens
+    } : usage;
+    const contextUsed = computeContextUsedUnified({
+      inputTokens: usage.input_tokens,
+      cacheReadTokens: 0,
+      cacheCreateTokens: 0,
+      outputTokens: usage.output_tokens
+    });
+    this.emit({
+      type: "context_usage",
+      contextUsedTokens: contextUsed,
+      contextTotalTokens: this.contextWindow,
+      contextPercent: clampContextPercent(contextUsed, this.contextWindow) ?? 0,
+      outputTokens: usage.output_tokens,
+      contextFormula: CONTEXT_FORMULA
+    });
+  }
+  formatTerminalError(raw, codexErrorInfo) {
+    const normalized = `${codexErrorInfo ?? ""} ${raw}`.toLowerCase();
+    const overflowPatterns = [
+      "context length exceeded",
+      "maximum context length",
+      "too many tokens",
+      "input too long",
+      "request too large",
+      "context_length_exceeded",
+      "contextwindowexceeded"
+    ];
+    if (overflowPatterns.some((p) => normalized.includes(p))) {
+      return {
+        message: `[context-overflow] Codex turn exceeded the model's context window for ${this.resolvedModel} (${this.contextWindow.toLocaleString()} tokens). Codex does not auto-compact conversation history like Claude does — start a fresh task or split the work into smaller turns. Original error: ${raw}`,
+        category: "context_overflow"
+      };
+    }
+    const usageLimitPatterns = ["usage limit", "upgrade to pro", "usagelimitexceeded"];
+    if (usageLimitPatterns.some((p) => normalized.includes(p))) {
+      return {
+        message: `[usage-limit] Codex account quota exhausted — upgrade plan or wait for monthly reset. Original error: ${raw}`,
+        category: "usage_limit"
+      };
+    }
+    const rateLimitPatterns = [
+      "rate limit",
+      "rate_limit",
+      "ratelimit",
+      "too many requests",
+      "http 429",
+      " 429 "
+    ];
+    if (rateLimitPatterns.some((p) => normalized.includes(p))) {
+      return {
+        message: `[rate-limit] Codex API rate limit hit. Original error: ${raw}`,
+        category: "rate_limit"
+      };
+    }
+    const authPatterns = [
+      "unauthorized",
+      "http 401",
+      " 401 ",
+      "invalid api key",
+      "invalid_api_key",
+      "missing api key",
+      "no api key",
+      "authentication failed",
+      "failed to refresh token",
+      "invalid 'refresh_token'"
+    ];
+    if (authPatterns.some((p) => normalized.includes(p))) {
+      return {
+        message: `[auth-error] Codex authentication failed — check OPENAI_API_KEY or ChatGPT login. Original error: ${raw}`,
+        category: "authentication_failed"
+      };
+    }
+    return { message: raw };
+  }
+  async runSession() {
+    this.abortController = new AbortController;
+    this.abortController.signal.addEventListener("abort", () => {
+      this.aborted = true;
+      if (typeof this.abortController?.signal.reason === "string") {
+        this.abortReason = this.abortController.signal.reason;
+      }
+      this.thread.interrupt().catch((error) => {
+        this.emit({
+          type: "raw_stderr",
+          content: `[codex] Failed to interrupt turn: ${String(error)}
+`
+        });
+      });
+    }, { once: true });
+    this.abortRef.current = this.abortController;
+    let terminalError;
+    let sawTurnCompleted = false;
+    let sawTurnInterrupted = false;
+    try {
+      const resolvedPrompt = await resolveCodexPrompt(this.config.prompt, this.skillsDir, (event) => this.emit(event));
+      this.transcript = [`User: ${resolvedPrompt}`];
+      try {
+        let nextPrompt = resolvedPrompt;
+        let queuedPrompt;
+        while (nextPrompt !== undefined && !this.aborted && !terminalError && !sawTurnInterrupted) {
+          if (nextPrompt !== resolvedPrompt)
+            this.transcript.push(`User: ${nextPrompt}`);
+          const streamed = await this.thread.runStreamed(nextPrompt);
+          if (queuedPrompt) {
+            this.queuedPrompts.shift();
+            queuedPrompt.resolve({ delivered: true, mode: "queue" });
+          }
+          for await (const event of streamed.events) {
+            if (event.type === "turn.failed" || event.type === "turn.interrupted" || event.type === "error" && event.willRetry !== true) {
+              this.acceptsSteering = false;
+            }
+            this.handleEvent(event);
+            if (event.type === "turn.completed") {
+              sawTurnCompleted = true;
+            }
+            if (event.type === "turn.interrupted") {
+              sawTurnInterrupted = true;
+            }
+            if (event.type === "turn.failed" && !terminalError) {
+              terminalError = this.formatTerminalError(event.error.message, event.error.codexErrorInfo);
+              this.errorTracker.processCodexUsageLimitMessage(event.error.message);
+            }
+            if (event.type === "error" && event.willRetry !== true && !terminalError) {
+              terminalError = this.formatTerminalError(event.message, event.codexErrorInfo);
+              this.errorTracker.processCodexUsageLimitMessage(event.message);
+            }
+          }
+          queuedPrompt = this.queuedPrompts[0];
+          nextPrompt = queuedPrompt?.text;
+        }
+      } catch (err) {
+        this.acceptsSteering = false;
+        if (this.aborted || err instanceof Error && err.name === "AbortError") {
+          const cost2 = this.buildCostData(this.accumulatedUsage, true);
+          this.emit({ type: "result", cost: cost2, isError: true, errorCategory: "cancelled" });
+          this.settle({
+            exitCode: 130,
+            sessionId: this._sessionId,
+            cost: cost2,
+            isError: true,
+            failureReason: this.abortReason
+          });
+          return;
+        }
+        if (terminalError) {
+          const cost2 = this.buildCostData(this.accumulatedUsage, true);
+          this.emit({
+            type: "result",
+            cost: cost2,
+            isError: true,
+            errorCategory: terminalError.category ?? "turn_failed"
+          });
+          this.settle({
+            exitCode: 1,
+            sessionId: this._sessionId,
+            cost: cost2,
+            isError: true,
+            failureReason: terminalError.message,
+            rateLimitResetAt: this.errorTracker.getRateLimitResetAt(),
+            rateLimitWindows: this.errorTracker.getRateLimitWindows()
+          });
+          return;
+        }
+        throw err;
+      }
+      this.acceptsSteering = false;
+      if (this.aborted || sawTurnInterrupted) {
+        const cost2 = this.buildCostData(this.accumulatedUsage, true);
+        this.emit({ type: "result", cost: cost2, isError: true, errorCategory: "cancelled" });
+        this.settle({
+          exitCode: 130,
+          sessionId: this._sessionId,
+          cost: cost2,
+          isError: true,
+          failureReason: this.aborted ? this.abortReason : "Codex turn interrupted"
+        });
+        return;
+      }
+      const isError = Boolean(terminalError) || !sawTurnCompleted;
+      const cost = this.buildCostData(this.accumulatedUsage, isError);
+      this.emit({
+        type: "result",
+        cost,
+        isError,
+        errorCategory: terminalError ? terminalError.category ?? "turn_failed" : undefined
+      });
+      this.settle({
+        exitCode: isError ? 1 : 0,
+        sessionId: this._sessionId,
+        cost,
+        isError,
+        failureReason: terminalError?.message,
+        rateLimitResetAt: this.errorTracker.getRateLimitResetAt(),
+        rateLimitWindows: this.errorTracker.getRateLimitWindows()
+      });
+    } catch (err) {
+      this.acceptsSteering = false;
+      const message = err instanceof Error ? err.message : String(err);
+      this.emit({ type: "raw_stderr", content: `[codex] Error: ${message}
+` });
+      this.emit({ type: "error", message });
+      const cost = this.buildCostData(this.accumulatedUsage, true);
+      this.emit({ type: "result", cost, isError: true, errorCategory: "exception" });
+      this.settle({
+        exitCode: 1,
+        sessionId: this._sessionId,
+        cost,
+        isError: true,
+        failureReason: message,
+        rateLimitResetAt: this.errorTracker.getRateLimitResetAt(),
+        rateLimitWindows: this.errorTracker.getRateLimitWindows()
+      });
+    } finally {
+      const sessionWasAborted = this.aborted || this.abortController?.signal.aborted === true || this.pendingResult?.exitCode === 130;
+      if (process.env.SKIP_SESSION_SUMMARY !== "1" && !sessionWasAborted) {
+        try {
+          await this.summarizeAtEnd();
+        } catch (err) {
+          console.error("session_summary failed (codex):", err);
+        }
+      } else if (sessionWasAborted) {
+        console.debug("[codex] session aborted — skipping session_summary");
+      } else {
+        console.debug("session_summary skipped (codex): SKIP_SESSION_SUMMARY is set");
+      }
+      this.abortRef.current = null;
+      try {
+        await this.thread.close();
+      } catch (error) {
+        this.emit({
+          type: "raw_stderr",
+          content: `[codex] Failed to close app-server: ${String(error)}
+`
+        });
+      }
+      try {
+        await this.logFileHandle.end();
+      } catch {}
+      await this.agentsMdHandle.cleanup();
+      const finalResult = this.pendingResult ?? {
+        exitCode: 1,
+        sessionId: this._sessionId,
+        cost: this.buildCostData(this.accumulatedUsage, true),
+        isError: true,
+        failureReason: "session did not settle"
+      };
+      this.resolveCompletion(finalResult);
+    }
+  }
+  async summarizeAtEnd() {
+    const transcriptStr = this.transcript.join(`
+`).slice(-20000);
+    const { agentId, taskId, apiUrl, apiKey } = this.config;
+    if (!agentId || !taskId || !apiUrl || !apiKey) {
+      const missing = [
+        !agentId && "agent id",
+        !taskId && "task id",
+        !apiUrl && "API URL",
+        !apiKey && "API key"
+      ].filter(Boolean);
+      console.warn(`session_summary skipped (codex): missing ${missing.join(", ")}`);
+      return;
+    }
+    if (transcriptStr.length <= 100) {
+      console.warn(`session_summary skipped (codex): transcript too short (${transcriptStr.length} chars)`);
+      return;
+    }
+    const _runSummarize = this.summarizeDeps.runSummarize ?? summarizeSession;
+    const _fetchRetrievals = this.summarizeDeps.fetchRetrievalsForTask ?? fetchRetrievalsForTask;
+    const _postRatings = this.summarizeDeps.postRatings ?? postRatings;
+    const _buildRatings = this.summarizeDeps.buildRatingsFromLlm ?? buildRatingsFromLlm;
+    const wantRatings = getMemoryRaterNames().includes("llm");
+    const retrievals = wantRatings ? await _fetchRetrievals({ apiUrl, apiKey, agentId, taskId }).catch(() => []) : [];
+    const result = await _runSummarize({
+      harness: "codex",
+      transcript: transcriptStr,
+      retrievals,
+      taskContext: {
+        sourceTaskId: taskId,
+        agentId,
+        prompt: this.config.prompt
+      },
+      apiUrl,
+      apiKey,
+      env: this.config.env
+    });
+    if (!result) {
+      console.warn("session_summary skipped (codex): summarizer returned no result");
+      return;
+    }
+    const summary = result.summary.trim();
+    if (summary.length <= 20 || summary.toLowerCase().includes("no significant learnings")) {
+      console.debug(`session_summary skipped (codex): summary failed quality gate (${summary.length} chars)`);
+      return;
+    }
+    const indexResp = await fetch(`${apiUrl}/api/memory/index`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        "X-Agent-ID": agentId
+      },
+      body: JSON.stringify({
+        scope: "agent",
+        source: "session_summary",
+        sourceTaskId: taskId,
+        content: summary,
+        name: "session-summary",
+        agentId
+      })
+    });
+    if (!indexResp.ok) {
+      const text = await indexResp.text().catch(() => "");
+      console.error("session_summary: /api/memory/index POST failed (codex):", indexResp.status, text);
+      return;
+    }
+    if (wantRatings && result.ratings && result.ratings.length > 0) {
+      const ratingEvents = _buildRatings(result.ratings, retrievals);
+      if (ratingEvents.length > 0) {
+        await _postRatings({
+          apiUrl,
+          apiKey,
+          agentId,
+          taskId,
+          events: ratingEvents
+        }).catch((err) => console.error("session_summary: postRatings failed (codex):", err));
+      }
+    }
+  }
+}
+async function createInProcessCodexSession(config, opts = {}) {
+  const agentsMdHandle = await writeCodexAgentsMd(config.cwd, config.systemPrompt);
+  try {
+    const resolvedModel = resolveCodexModel(config.model);
+    const preSessionEvents = [];
+    const bufferedEmit = (event) => {
+      preSessionEvents.push(event);
+    };
+    const mergedConfig = await buildCodexConfig(config, resolvedModel, bufferedEmit);
+    const authMode = await resolveCodexAuthMode(config, bufferedEmit);
+    const env = {
+      PATH: process.env.PATH ?? "",
+      HOME: process.env.HOME ?? "",
+      ...authMode !== "chatgpt" && process.env.OPENAI_API_KEY ? { OPENAI_API_KEY: process.env.OPENAI_API_KEY } : {},
+      ...process.env.NODE_EXTRA_CA_CERTS ? { NODE_EXTRA_CA_CERTS: process.env.NODE_EXTRA_CA_CERTS } : {},
+      CONTEXT_MODE_EXTERNAL_MCP_NUDGE_EVERY: CTX_MODE_NUDGE_EVERY,
+      ...config.env ?? {},
+      ...buildOtelTraceparentEnv(config.env ?? process.env),
+      SWARM_CODEX_APP_SERVER: "1"
+    };
+    if (authMode === "chatgpt")
+      delete env.OPENAI_API_KEY;
+    const codexPathOverride = process.env.CODEX_PATH_OVERRIDE;
+    if (config.resumeSessionId) {
+      console.warn("[codex-adapter] resumeSessionId ignored — native resume is disabled by deprecation plan");
+    }
+    let thread;
+    let liveSession;
+    if (opts.threadFactory) {
+      thread = await opts.threadFactory({
+        config,
+        resolvedModel,
+        env,
+        codexConfig: mergedConfig
+      });
+    } else {
+      const appServerFactory = opts.appServerFactory ?? ((options) => new CodexAppServer(options));
+      const client = appServerFactory({
+        ...codexPathOverride ? { codexPath: codexPathOverride } : {},
+        env,
+        onStderr: (line) => {
+          if (liveSession)
+            liveSession.emitTransportStderr(line);
+          else
+            bufferedEmit({ type: "raw_stderr", content: `${line}
+` });
+        }
+      });
+      try {
+        const response = await client.request("thread/start", {
+          model: resolvedModel,
+          cwd: config.cwd,
+          approvalPolicy: "never",
+          sandbox: "danger-full-access",
+          config: mergedConfig,
+          ephemeral: true
+        });
+        thread = new AppServerCodexThread(client, response.thread.id);
+      } catch (error) {
+        await client.close();
+        throw error;
+      }
+    }
+    const session = new CodexSession(thread, config, agentsMdHandle, resolvedModel, preSessionEvents, opts.skillsDir, opts.summarizeDeps ?? {});
+    liveSession = session;
+    return session;
+  } catch (err) {
+    await agentsMdHandle.cleanup();
+    throw err;
+  }
+}
+function resolveCodexRunnerArgv() {
+  const override = process.env.AGENT_SWARM_CODEX_RUNNER_ARGV;
+  if (override) {
+    try {
+      const parsed = JSON.parse(override);
+      if (Array.isArray(parsed) && parsed.every((s) => typeof s === "string")) {
+        return parsed;
+      }
+    } catch {}
+  }
+  const execPath = process.execPath;
+  const scriptArg = process.argv[1];
+  if (scriptArg && /\.(t|j)sx?$/.test(scriptArg)) {
+    return [execPath, scriptArg, "codex-session-runner"];
+  }
+  return [execPath, "codex-session-runner"];
+}
+
+class CodexSubprocessSession {
+  proc;
+  listeners = [];
+  eventQueue = [];
+  completionPromise;
+  _sessionId;
+  finished = false;
+  nextControlId = 0;
+  pendingSteering = new Map;
+  constructor(config, skillsDir) {
+    const argv = resolveCodexRunnerArgv();
+    const payload = {
+      config,
+      skillsDir,
+      parentOtelEnv: buildOtelTraceparentEnv(config.env ?? process.env)
+    };
+    const apiKey = getApiKey();
+    this.proc = registerProcessGroup(Bun.spawn(argv, {
+      detached: detachedProcessGroup,
+      env: {
+        PATH: process.env.PATH ?? "",
+        HOME: process.env.HOME ?? "",
+        ...process.env.NODE_EXTRA_CA_CERTS ? { NODE_EXTRA_CA_CERTS: process.env.NODE_EXTRA_CA_CERTS } : {},
+        ...process.env.MCP_BASE_URL ? { MCP_BASE_URL: process.env.MCP_BASE_URL } : {},
+        ...apiKey ? { AGENT_SWARM_API_KEY: apiKey, API_KEY: apiKey } : {},
+        ...process.env.OPENAI_API_KEY ? { OPENAI_API_KEY: process.env.OPENAI_API_KEY } : {},
+        ...process.env.OPENROUTER_API_KEY ? { OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY } : {},
+        ...process.env.ANTHROPIC_API_KEY ? { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY } : {},
+        ...process.env.CODEX_PATH_OVERRIDE ? { CODEX_PATH_OVERRIDE: process.env.CODEX_PATH_OVERRIDE } : {},
+        ...process.env.CODEX_SKILLS_DIR ? { CODEX_SKILLS_DIR: process.env.CODEX_SKILLS_DIR } : {},
+        CONTEXT_MODE_EXTERNAL_MCP_NUDGE_EVERY: CTX_MODE_NUDGE_EVERY,
+        ...process.env.SKIP_SESSION_SUMMARY ? { SKIP_SESSION_SUMMARY: process.env.SKIP_SESSION_SUMMARY } : {},
+        MEMORY_RATERS: getMemoryRaterNames().join(",")
+      },
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe"
+    }));
+    const stdin = this.proc.stdin;
+    stdin.write(`${JSON.stringify(payload)}
+`);
+    this.completionPromise = this.processStreams().finally(() => this.finishSteering());
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  onEvent(listener) {
+    this.listeners.push(listener);
+    for (const event of this.eventQueue) {
+      listener(event);
+    }
+    this.eventQueue.length = 0;
+  }
+  async waitForCompletion() {
+    return this.completionPromise;
+  }
+  async abort(reason) {
+    if (this.finished)
+      return;
+    try {
+      this.writeControl({ kind: "abort", reason });
+      let timer;
+      try {
+        await Promise.race([
+          this.completionPromise,
+          new Promise((resolve2) => {
+            timer = setTimeout(resolve2, 2000);
+          })
+        ]);
+      } finally {
+        clearTimeout(timer);
+      }
+    } finally {
+      if (!this.finished)
+        await terminateProcessGroup(this.proc.pid);
+    }
+  }
+  async deliverSteering(delivery) {
+    if (this.finished)
+      return { delivered: false, reason: "Codex session has completed" };
+    const id = ++this.nextControlId;
+    return new Promise((resolve2) => {
+      const timer = delivery.mode === "queue" ? undefined : setTimeout(() => {
+        this.pendingSteering.delete(id);
+        resolve2({ delivered: false, reason: "Codex steering request timed out" });
+      }, 35000);
+      this.pendingSteering.set(id, { resolve: resolve2, timer });
+      try {
+        this.writeControl({ kind: "steer", id, delivery });
+      } catch (error) {
+        clearTimeout(timer);
+        this.pendingSteering.delete(id);
+        resolve2({ delivered: false, reason: scrubSecrets(String(error)) });
+      }
+    });
+  }
+  writeControl(command) {
+    this.proc.stdin.write(`${JSON.stringify(command)}
+`);
+  }
+  finishSteering() {
+    this.finished = true;
+    for (const { resolve: resolve2, timer } of this.pendingSteering.values()) {
+      clearTimeout(timer);
+      resolve2({ delivered: false, reason: "Codex session has completed" });
+    }
+    this.pendingSteering.clear();
+  }
+  emit(event) {
+    event = JSON.parse(scrubSecrets(JSON.stringify(event)));
+    if (event.type === "session_init" && event.sessionId) {
+      this._sessionId = event.sessionId;
+    }
+    if (this.listeners.length > 0) {
+      for (const listener of this.listeners) {
+        try {
+          listener(event);
+        } catch {}
+      }
+    } else {
+      this.eventQueue.push(event);
+    }
+  }
+  async processStreams() {
+    let result = null;
+    let partial = "";
+    let stderrTail = "";
+    const stdoutPromise = (async () => {
+      const stdout = this.proc.stdout;
+      if (!stdout)
+        return;
+      const decoder = new TextDecoder;
+      for await (const chunk of stdout) {
+        partial += decoder.decode(chunk, { stream: true });
+        const parts = partial.split(`
+`);
+        partial = parts.pop() ?? "";
+        for (const line of parts) {
+          const trimmed = line.trim();
+          if (!trimmed)
+            continue;
+          this.handleLine(trimmed, (r) => {
+            result = r;
+          });
+        }
+      }
+      partial += decoder.decode();
+      if (partial.trim()) {
+        this.handleLine(partial.trim(), (r) => {
+          result = r;
+        });
+        partial = "";
+      }
+    })();
+    const stderrPromise = (async () => {
+      const stderr = this.proc.stderr;
+      if (!stderr)
+        return;
+      const decoder = new TextDecoder;
+      let pending = "";
+      const emitStderr = (line) => {
+        const text = scrubSecrets(line);
+        stderrTail = (stderrTail + text).slice(-2000);
+        this.emit({ type: "raw_stderr", content: text });
+      };
+      for await (const chunk of stderr) {
+        pending += decoder.decode(chunk, { stream: true });
+        let newline = pending.indexOf(`
+`);
+        while (newline !== -1) {
+          emitStderr(pending.slice(0, newline + 1));
+          pending = pending.slice(newline + 1);
+          newline = pending.indexOf(`
+`);
+        }
+      }
+      pending += decoder.decode();
+      if (pending)
+        emitStderr(pending);
+    })();
+    await Promise.all([stdoutPromise, stderrPromise]);
+    const exitCode = await this.proc.exited;
+    this.finishSteering();
+    await terminateProcessGroup(this.proc.pid);
+    if (result) {
+      return result;
+    }
+    const stderrHint = stderrTail.trim() ? `: stderr: ${stderrTail.trim().slice(-500)}` : "";
+    return {
+      exitCode: exitCode ?? 1,
+      sessionId: this._sessionId,
+      isError: true,
+      failureReason: `codex subprocess exited (code=${exitCode ?? "?"}) without a structured result${stderrHint}`
+    };
+  }
+  handleLine(line, setResult) {
+    let msg;
+    try {
+      msg = JSON.parse(scrubSecrets(line));
+    } catch {
+      this.emit({ type: "raw_stderr", content: `${line}
+` });
+      return;
+    }
+    if (msg.kind === "event" && msg.event) {
+      this.emit(msg.event);
+      return;
+    }
+    if (msg.kind === "result" && msg.result) {
+      this.finishSteering();
+      setResult(msg.result);
+      return;
+    }
+    if (msg.kind === "steering-result" && msg.id !== undefined && msg.delivery) {
+      const pending = this.pendingSteering.get(msg.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingSteering.delete(msg.id);
+        pending.resolve(msg.delivery);
+      }
+      return;
+    }
+    if (msg.kind === "error" && msg.message) {
+      this.emit({ type: "error", message: msg.message });
+      setResult({
+        exitCode: 1,
+        sessionId: this._sessionId,
+        isError: true,
+        failureReason: msg.message
+      });
+      return;
+    }
+  }
+}
+
+class CodexAdapter {
+  name = "codex";
+  traits = {
+    hasMcp: true,
+    nativeSkillDiscovery: false,
+    hasLocalEnvironment: true,
+    steerModes: ["steer", "queue"]
+  };
+  skillsDir;
+  summarizeDeps;
+  appServerFactory;
+  threadFactory;
+  bypassSubprocess;
+  constructor(opts = {}) {
+    this.skillsDir = opts.skillsDir;
+    this.summarizeDeps = opts.summarizeDeps ?? {};
+    this.bypassSubprocess = opts.bypassSubprocess ?? false;
+    this.appServerFactory = opts.appServerFactory;
+    this.threadFactory = opts.threadFactory;
+  }
+  async createSession(config) {
+    if (this.bypassSubprocess) {
+      return createInProcessCodexSession(config, {
+        skillsDir: this.skillsDir,
+        summarizeDeps: this.summarizeDeps,
+        appServerFactory: this.appServerFactory,
+        threadFactory: this.threadFactory
+      });
+    }
+    return new CodexSubprocessSession(config, this.skillsDir);
+  }
+  async canResume(_sessionId) {
+    return false;
+  }
+  formatCommand(commandName) {
+    return `/${commandName}`;
+  }
+}
+
+export { codexUserHome, checkCodexCredentials, resolveCodexAuthMode, buildCodexConfig, CodexSession, createInProcessCodexSession, resolveCodexRunnerArgv, CodexAdapter };