@desplega.ai/agent-swarm 1.158.0 → 1.159.0

package/dist/{cli-20cj37vt.js → cli-m4excttz.js}

@@ -1,533 +1,3 @@
-import {
-  resolveCodexPrompt
-} from "./cli-r94z9p1z.js";
-import {
-  createSwarmEventHandler
-} from "./cli-hsxj0yar.js";
-import {
-  readPkgVersion
-} from "./cli-2djtr51b.js";
-import {
-  buildOtelTraceparentEnv
-} from "./cli-q2j38vre.js";
-import {
-  CTX_MODE_NUDGE_EVERY
-} from "./cli-zm7njwzd.js";
-import {
-  summarizeSession
-} from "./cli-cw9zck8j.js";
-import {
-  CONTEXT_FORMULA,
-  clampContextPercent,
-  computeContextUsedUnified
-} from "./cli-0xjkj1j7.js";
-import {
-  SessionErrorTracker
-} from "./cli-npssxgaz.js";
-import {
-  applyReasoningEffort
-} from "./cli-h967nb6r.js";
-import {
-  buildRatingsFromLlm,
-  fetchRetrievalsForTask,
-  getMemoryRaterNames,
-  postRatings
-} from "./cli-tt9k8r35.js";
-import {
-  CodexOAuthRefreshError,
-  credentialsToAuthJson,
-  getValidCodexOAuth
-} from "./cli-vhjwh6cz.js";
-import {
-  swarmRuntimeInstanceId
-} from "./cli-re8z5p8p.js";
-import {
-  detachedProcessGroup,
-  registerProcessGroup,
-  terminateProcessGroup
-} from "./cli-y89t4nca.js";
-import {
-  getApiKey
-} from "./cli-f14fvzag.js";
-import {
-  init_package,
-  package_default
-} from "./cli-c07r9a2m.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/be/modelsdev-cache.json
 var modelsdev_cache_default = {
   subconscious: {
@@ -287635,6 +287105,88 @@ var modelsdev_cache_default = {
           cache_read: 2.5
         }
       },
+      "gpt-6.1-sol": {
+        id: "gpt-6.1-sol",
+        name: "GPT-6.1 Sol",
+        description: "Near-Astra performance for complex work at a lower cost",
+        family: "gpt-sol",
+        attachment: true,
+        reasoning: true,
+        reasoning_options: [
+          {
+            type: "effort",
+            values: [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max"
+            ]
+          }
+        ],
+        tool_call: true,
+        structured_output: true,
+        temperature: false,
+        knowledge: "2026-04-30",
+        release_date: "2026-09-29",
+        last_updated: "2026-09-29",
+        modalities: {
+          input: [
+            "text",
+            "image"
+          ],
+          output: [
+            "text"
+          ]
+        },
+        open_weights: false,
+        limit: {
+          context: 1050000,
+          input: 922000,
+          output: 128000
+        },
+        experimental: {
+          modes: {
+            fast: {
+              cost: {
+                input: 4,
+                output: 20,
+                cache_read: 0.2,
+                cache_write: 5
+              },
+              provider: {
+                body: {
+                  service_tier: "priority"
+                }
+              }
+            }
+          }
+        },
+        cost: {
+          input: 2,
+          output: 10,
+          cache_read: 0.1,
+          cache_write: 2.5,
+          tiers: [
+            {
+              input: 4,
+              output: 15,
+              cache_read: 0.2,
+              cache_write: 5,
+              tier: {
+                type: "context",
+                size: 272000
+              }
+            }
+          ],
+          context_over_200k: {
+            input: 4,
+            output: 15,
+            cache_read: 0.2,
+            cache_write: 5
+          }
+        }
+      },
       "gpt-6-sol": {
         id: "gpt-6-sol",
         name: "GPT-6 Sol",
@@ -333863,1699 +333415,67 @@ var modelsdev_cache_default = {
   }
 };
 
-// src/providers/codex-models.ts
-var CODEX_MODELS = [
-  "gpt-6-astra",
-  "gpt-6-sol",
-  "gpt-6-luna",
-  "gpt-5.6-sol",
-  "gpt-5.6-terra",
-  "gpt-5.6-luna",
-  "gpt-5.5",
-  "gpt-5.4",
-  "gpt-5.4-mini",
-  "gpt-5.3-codex",
-  "gpt-5.2-codex"
-];
-var CODEX_DEFAULT_MODEL = "gpt-5.6-terra";
-var CLAUDE_SHORTNAMES = {
-  fable: "gpt-5.6-sol",
-  opus: "gpt-5.6-sol",
-  sonnet: "gpt-5.6-terra",
-  haiku: "gpt-5.6-luna"
-};
-function resolveCodexModel(modelStr) {
-  if (!modelStr)
-    return CODEX_DEFAULT_MODEL;
-  const normalized = modelStr.toLowerCase();
-  return CLAUDE_SHORTNAMES[normalized] ?? normalized;
-}
-var MODELSDEV_OPENAI_MODELS = modelsdev_cache_default.openai?.models ?? {};
-var FALLBACK_CODEX_MODEL_CONTEXT_WINDOWS = {
-  "gpt-6-astra": 1050000,
-  "gpt-6-sol": 1050000,
-  "gpt-6-luna": 1050000,
-  "gpt-5.6-sol": 1050000,
-  "gpt-5.6-terra": 1050000,
-  "gpt-5.6-luna": 1050000,
-  "gpt-5.5": 1050000,
-  "gpt-5.4": 1050000,
-  "gpt-5.4-mini": 400000,
-  "gpt-5.3-codex": 400000,
-  "gpt-5.2-codex": 200000
-};
-var CODEX_MODEL_CONTEXT_WINDOWS = Object.fromEntries(CODEX_MODELS.map((model) => [
-  model,
-  MODELSDEV_OPENAI_MODELS[model]?.limit?.context ?? FALLBACK_CODEX_MODEL_CONTEXT_WINDOWS[model]
-]));
-function getCodexContextWindow(model) {
-  return CODEX_MODEL_CONTEXT_WINDOWS[model] ?? 200000;
-}
-var FALLBACK_CODEX_MODEL_PRICING = {
-  "gpt-6-astra": {
-    inputPerMillion: 10,
-    cachedInputPerMillion: 1,
-    outputPerMillion: 50
-  },
-  "gpt-6-sol": {
-    inputPerMillion: 2,
-    cachedInputPerMillion: 0.2,
-    outputPerMillion: 10
-  },
-  "gpt-6-luna": {
-    inputPerMillion: 0.1,
-    cachedInputPerMillion: 0.01,
-    outputPerMillion: 0.5
-  },
-  "gpt-5.6-sol": {
-    inputPerMillion: 4,
-    cachedInputPerMillion: 0.4,
-    outputPerMillion: 20
-  },
-  "gpt-5.6-terra": {
-    inputPerMillion: 2,
-    cachedInputPerMillion: 0.2,
-    outputPerMillion: 12
-  },
-  "gpt-5.6-luna": {
-    inputPerMillion: 0.2,
-    cachedInputPerMillion: 0.02,
-    outputPerMillion: 1.2
-  },
-  "gpt-5.5": {
-    inputPerMillion: 5,
-    cachedInputPerMillion: 0.5,
-    outputPerMillion: 30
-  },
-  "gpt-5.4": {
-    inputPerMillion: 2.5,
-    cachedInputPerMillion: 0.25,
-    outputPerMillion: 15
-  },
-  "gpt-5.4-mini": {
-    inputPerMillion: 0.75,
-    cachedInputPerMillion: 0.075,
-    outputPerMillion: 4.5
-  },
-  "gpt-5.3-codex": {
-    inputPerMillion: 1.75,
-    cachedInputPerMillion: 0.175,
-    outputPerMillion: 14
-  },
-  "gpt-5.2-codex": {
-    inputPerMillion: 1.75,
-    cachedInputPerMillion: 0.175,
-    outputPerMillion: 14
-  }
-};
-function getModelsDevCodexPricing(model) {
-  const cost = MODELSDEV_OPENAI_MODELS[model]?.cost;
-  if (typeof cost?.input !== "number" || typeof cost.cache_read !== "number" || typeof cost.output !== "number") {
-    return;
-  }
-  return {
-    inputPerMillion: cost.input,
-    cachedInputPerMillion: cost.cache_read,
-    outputPerMillion: cost.output
-  };
-}
-var CODEX_MODEL_PRICING = Object.fromEntries(CODEX_MODELS.map((model) => [
-  model,
-  getModelsDevCodexPricing(model) ?? FALLBACK_CODEX_MODEL_PRICING[model]
-]));
-var _warnedUnknownCodexModels = new Set;
-function computeCodexCostUsd(model, inputTokens, cachedInputTokens, outputTokens) {
-  const pricing = CODEX_MODEL_PRICING[model];
-  if (!pricing) {
-    if (!_warnedUnknownCodexModels.has(model)) {
-      _warnedUnknownCodexModels.add(model);
-      console.warn(`[codex] unpriced model ${JSON.stringify(model)} — adapter cost will report $0; ` + "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: { hooks: true, plugin_hooks: true },
-    mcp_servers: mcpServers,
-    ...reasoningConfig
-  };
+// src/utils/runtime-model-catalog.ts
+var SNAPSHOT = modelsdev_cache_default;
+var RUNTIME_CATALOG_TTL_MS = 10 * 60000;
+var FETCH_TIMEOUT_MS = 5000;
+var live = null;
+var liveAt = 0;
+var liveSource = null;
+var mergedSections = new Map;
+var inFlight = null;
+function setRuntimeModelCatalog(providers, at = Date.now(), source = "live") {
+  live = providers;
+  liveAt = at;
+  liveSource = source;
+  mergedSections.clear();
 }
-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 runtimeCatalogSection(provider) {
+  const cached = mergedSections.get(provider);
+  if (cached)
+    return cached;
+  const merged = {
+    ...SNAPSHOT[provider]?.models ?? {},
+    ...live?.[provider]?.models ?? {}
   };
+  mergedSections.set(provider, merged);
+  return merged;
 }
-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))
-  };
+function runtimeCatalogModel(provider, modelId) {
+  return runtimeCatalogSection(provider)[modelId];
 }
-
-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 });
-    }
+async function refreshRuntimeModelCatalog(opts) {
+  const maxAge = opts.maxAgeMs ?? RUNTIME_CATALOG_TTL_MS;
+  if (live && Date.now() - liveAt < maxAge)
+    return true;
+  if (inFlight)
+    return inFlight;
+  const doFetch = opts.fetchImpl ?? fetch;
+  inFlight = (async () => {
     try {
-      const response = await this.client.request("turn/start", {
-        threadId: this.id,
-        input: textInput(input)
+      const headers = {};
+      if (opts.apiKey)
+        headers.Authorization = `Bearer ${opts.apiKey}`;
+      if (opts.agentId)
+        headers["X-Agent-ID"] = opts.agentId;
+      const res = await doFetch(`${opts.apiUrl}/api/models-catalog`, {
+        headers,
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
       });
-      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));
+      if (!res.ok)
+        return false;
+      const body = await res.json();
+      if (!body || typeof body.providers !== "object" || body.providers === null)
+        return false;
+      setRuntimeModelCatalog(body.providers, Date.now(), body.source ?? "live");
+      return true;
     } 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 false;
+    } finally {
+      inFlight = null;
     }
-    return new CodexSubprocessSession(config, this.skillsDir);
-  }
-  async canResume(_sessionId) {
-    return false;
-  }
-  formatCommand(commandName) {
-    return `/${commandName}`;
-  }
+  })();
+  return inFlight;
 }
 
-export { codexUserHome, checkCodexCredentials, resolveCodexAuthMode, buildCodexConfig, CodexSession, createInProcessCodexSession, resolveCodexRunnerArgv, CodexAdapter };
+export { setRuntimeModelCatalog, runtimeCatalogSection, runtimeCatalogModel, refreshRuntimeModelCatalog };