@desplega.ai/agent-swarm 1.113.0 → 1.115.0

package/dist/cli-ceewqajw.js

@@ -1,1698 +0,0 @@
-import {
-  summarizeSession
-} from "./cli-6wscj9z0.js";
-import {
-  createSwarmEventHandler
-} from "./cli-07er7wrs.js";
-import {
-  resolveCodexPrompt
-} from "./cli-r94z9p1z.js";
-import {
-  readPkgVersion
-} from "./cli-d6n0thxw.js";
-import {
-  buildRatingsFromLlm,
-  fetchRetrievalsForTask,
-  postRatings
-} from "./cli-dcfyyh3t.js";
-import {
-  CodexOAuthRefreshError,
-  credentialsToAuthJson,
-  getValidCodexOAuth
-} from "./cli-tk9vyqzh.js";
-import {
-  SessionErrorTracker,
-  buildOtelTraceparentEnv
-} from "./cli-psrqtw2m.js";
-import {
-  CTX_MODE_NUDGE_EVERY
-} from "./cli-zm7njwzd.js";
-import {
-  CONTEXT_FORMULA,
-  clampContextPercent,
-  computeContextUsedUnified
-} from "./cli-tghre7g6.js";
-import {
-  applyReasoningEffort
-} from "./cli-tkmm5nf9.js";
-import {
-  getApiKey
-} from "./cli-f14fvzag.js";
-import {
-  init_secret_scrubber,
-  scrubSecrets
-} from "./cli-4j2mrzag.js";
-import {
-  __require
-} from "./cli-p9swy5t3.js";
-
-// src/providers/codex-adapter.ts
-import { existsSync as nodeExistsSync } from "node:fs";
-import os2 from "node:os";
-import { join as join2 } from "node:path";
-
-// node_modules/@openai/codex-sdk/dist/index.js
-import { promises as fs } from "fs";
-import os from "os";
-import path from "path";
-import { spawn } from "child_process";
-import { statSync } from "fs";
-import path2 from "path";
-import readline from "readline";
-import { createRequire } from "module";
-async function createOutputSchemaFile(schema) {
-  if (schema === undefined) {
-    return { cleanup: async () => {} };
-  }
-  if (!isJsonObject(schema)) {
-    throw new Error("outputSchema must be a plain JSON object");
-  }
-  const schemaDir = await fs.mkdtemp(path.join(os.tmpdir(), "codex-output-schema-"));
-  const schemaPath = path.join(schemaDir, "schema.json");
-  const cleanup = async () => {
-    try {
-      await fs.rm(schemaDir, { recursive: true, force: true });
-    } catch {}
-  };
-  try {
-    await fs.writeFile(schemaPath, JSON.stringify(schema), "utf8");
-    return { schemaPath, cleanup };
-  } catch (error) {
-    await cleanup();
-    throw error;
-  }
-}
-function isJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var Thread = class {
-  _exec;
-  _options;
-  _id;
-  _threadOptions;
-  get id() {
-    return this._id;
-  }
-  constructor(exec, options, threadOptions, id = null) {
-    this._exec = exec;
-    this._options = options;
-    this._id = id;
-    this._threadOptions = threadOptions;
-  }
-  async runStreamed(input, turnOptions = {}) {
-    return { events: this.runStreamedInternal(input, turnOptions) };
-  }
-  async* runStreamedInternal(input, turnOptions = {}) {
-    const { schemaPath, cleanup } = await createOutputSchemaFile(turnOptions.outputSchema);
-    const options = this._threadOptions;
-    const { prompt, images } = normalizeInput(input);
-    const generator = this._exec.run({
-      input: prompt,
-      baseUrl: this._options.baseUrl,
-      apiKey: this._options.apiKey,
-      threadId: this._id,
-      images,
-      model: options?.model,
-      sandboxMode: options?.sandboxMode,
-      workingDirectory: options?.workingDirectory,
-      skipGitRepoCheck: options?.skipGitRepoCheck,
-      outputSchemaFile: schemaPath,
-      modelReasoningEffort: options?.modelReasoningEffort,
-      signal: turnOptions.signal,
-      networkAccessEnabled: options?.networkAccessEnabled,
-      webSearchMode: options?.webSearchMode,
-      webSearchEnabled: options?.webSearchEnabled,
-      approvalPolicy: options?.approvalPolicy,
-      additionalDirectories: options?.additionalDirectories
-    });
-    try {
-      for await (const item of generator) {
-        let parsed;
-        try {
-          parsed = JSON.parse(item);
-        } catch (error) {
-          throw new Error(`Failed to parse item: ${item}`, { cause: error });
-        }
-        if (parsed.type === "thread.started") {
-          this._id = parsed.thread_id;
-        }
-        yield parsed;
-      }
-    } finally {
-      await cleanup();
-    }
-  }
-  async run(input, turnOptions = {}) {
-    const generator = this.runStreamedInternal(input, turnOptions);
-    const items = [];
-    let finalResponse = "";
-    let usage = null;
-    let turnFailure = null;
-    for await (const event of generator) {
-      if (event.type === "item.completed") {
-        if (event.item.type === "agent_message") {
-          finalResponse = event.item.text;
-        }
-        items.push(event.item);
-      } else if (event.type === "turn.completed") {
-        usage = event.usage;
-      } else if (event.type === "turn.failed") {
-        turnFailure = event.error;
-        break;
-      }
-    }
-    if (turnFailure) {
-      throw new Error(turnFailure.message);
-    }
-    return { items, finalResponse, usage };
-  }
-};
-function normalizeInput(input) {
-  if (typeof input === "string") {
-    return { prompt: input, images: [] };
-  }
-  const promptParts = [];
-  const images = [];
-  for (const item of input) {
-    if (item.type === "text") {
-      promptParts.push(item.text);
-    } else if (item.type === "local_image") {
-      images.push(item.path);
-    }
-  }
-  return { prompt: promptParts.join(`
-
-`), images };
-}
-var INTERNAL_ORIGINATOR_ENV = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE";
-var TYPESCRIPT_SDK_ORIGINATOR = "codex_sdk_ts";
-var CODEX_NPM_NAME = "@openai/codex";
-var PLATFORM_PACKAGE_BY_TARGET = {
-  "x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
-  "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
-  "x86_64-apple-darwin": "@openai/codex-darwin-x64",
-  "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
-  "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
-  "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64"
-};
-var moduleRequire = createRequire(import.meta.url);
-var CodexExec = class {
-  executablePath;
-  pathDirs;
-  envOverride;
-  configOverrides;
-  constructor(executablePath = null, env, configOverrides) {
-    if (executablePath) {
-      this.executablePath = executablePath;
-      this.pathDirs = [];
-    } else {
-      const resolved = findCodexPath();
-      this.executablePath = resolved.executablePath;
-      this.pathDirs = resolved.pathDirs;
-    }
-    this.envOverride = env;
-    this.configOverrides = configOverrides;
-  }
-  async* run(args) {
-    const commandArgs = ["exec", "--experimental-json"];
-    if (this.configOverrides) {
-      for (const override of serializeConfigOverrides(this.configOverrides)) {
-        commandArgs.push("--config", override);
-      }
-    }
-    if (args.baseUrl) {
-      commandArgs.push("--config", `openai_base_url=${toTomlValue(args.baseUrl, "openai_base_url")}`);
-    }
-    if (args.model) {
-      commandArgs.push("--model", args.model);
-    }
-    if (args.sandboxMode) {
-      commandArgs.push("--sandbox", args.sandboxMode);
-    }
-    if (args.workingDirectory) {
-      commandArgs.push("--cd", args.workingDirectory);
-    }
-    if (args.additionalDirectories?.length) {
-      for (const dir of args.additionalDirectories) {
-        commandArgs.push("--add-dir", dir);
-      }
-    }
-    if (args.skipGitRepoCheck) {
-      commandArgs.push("--skip-git-repo-check");
-    }
-    if (args.outputSchemaFile) {
-      commandArgs.push("--output-schema", args.outputSchemaFile);
-    }
-    if (args.modelReasoningEffort) {
-      commandArgs.push("--config", `model_reasoning_effort="${args.modelReasoningEffort}"`);
-    }
-    if (args.networkAccessEnabled !== undefined) {
-      commandArgs.push("--config", `sandbox_workspace_write.network_access=${args.networkAccessEnabled}`);
-    }
-    if (args.webSearchMode) {
-      commandArgs.push("--config", `web_search="${args.webSearchMode}"`);
-    } else if (args.webSearchEnabled === true) {
-      commandArgs.push("--config", `web_search="live"`);
-    } else if (args.webSearchEnabled === false) {
-      commandArgs.push("--config", `web_search="disabled"`);
-    }
-    if (args.approvalPolicy) {
-      commandArgs.push("--config", `approval_policy="${args.approvalPolicy}"`);
-    }
-    if (args.threadId) {
-      commandArgs.push("resume", args.threadId);
-    }
-    if (args.images?.length) {
-      for (const image of args.images) {
-        commandArgs.push("--image", image);
-      }
-    }
-    const env = {};
-    if (this.envOverride) {
-      Object.assign(env, this.envOverride);
-    } else {
-      for (const [key, value] of Object.entries(process.env)) {
-        if (value !== undefined) {
-          env[key] = value;
-        }
-      }
-    }
-    if (!env[INTERNAL_ORIGINATOR_ENV]) {
-      env[INTERNAL_ORIGINATOR_ENV] = TYPESCRIPT_SDK_ORIGINATOR;
-    }
-    if (args.apiKey) {
-      env.CODEX_API_KEY = args.apiKey;
-    }
-    if (this.pathDirs.length > 0) {
-      prependPathDirs(env, this.pathDirs);
-    }
-    const child = spawn(this.executablePath, commandArgs, {
-      env,
-      signal: args.signal
-    });
-    let spawnError = null;
-    child.once("error", (err) => spawnError = err);
-    if (!child.stdin) {
-      child.kill();
-      throw new Error("Child process has no stdin");
-    }
-    child.stdin.write(args.input);
-    child.stdin.end();
-    if (!child.stdout) {
-      child.kill();
-      throw new Error("Child process has no stdout");
-    }
-    const stderrChunks = [];
-    if (child.stderr) {
-      child.stderr.on("data", (data) => {
-        stderrChunks.push(data);
-      });
-    }
-    const exitPromise = new Promise((resolve) => {
-      child.once("exit", (code, signal) => {
-        resolve({ code, signal });
-      });
-    });
-    const rl = readline.createInterface({
-      input: child.stdout,
-      crlfDelay: Infinity
-    });
-    try {
-      for await (const line of rl) {
-        yield line;
-      }
-      if (spawnError)
-        throw spawnError;
-      const { code, signal } = await exitPromise;
-      if (code !== 0 || signal) {
-        const stderrBuffer = Buffer.concat(stderrChunks);
-        const detail = signal ? `signal ${signal}` : `code ${code ?? 1}`;
-        throw new Error(`Codex Exec exited with ${detail}: ${stderrBuffer.toString("utf8")}`);
-      }
-    } finally {
-      rl.close();
-      child.removeAllListeners();
-      try {
-        if (!child.killed)
-          child.kill();
-      } catch {}
-    }
-  }
-};
-function serializeConfigOverrides(configOverrides) {
-  const overrides = [];
-  flattenConfigOverrides(configOverrides, "", overrides);
-  return overrides;
-}
-function flattenConfigOverrides(value, prefix, overrides) {
-  if (!isPlainObject(value)) {
-    if (prefix) {
-      overrides.push(`${prefix}=${toTomlValue(value, prefix)}`);
-      return;
-    } else {
-      throw new Error("Codex config overrides must be a plain object");
-    }
-  }
-  const entries = Object.entries(value);
-  if (!prefix && entries.length === 0) {
-    return;
-  }
-  if (prefix && entries.length === 0) {
-    overrides.push(`${prefix}={}`);
-    return;
-  }
-  for (const [key, child] of entries) {
-    if (!key) {
-      throw new Error("Codex config override keys must be non-empty strings");
-    }
-    if (child === undefined) {
-      continue;
-    }
-    const path3 = prefix ? `${prefix}.${key}` : key;
-    if (isPlainObject(child)) {
-      flattenConfigOverrides(child, path3, overrides);
-    } else {
-      overrides.push(`${path3}=${toTomlValue(child, path3)}`);
-    }
-  }
-}
-function toTomlValue(value, path3) {
-  if (typeof value === "string") {
-    return JSON.stringify(value);
-  } else if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error(`Codex config override at ${path3} must be a finite number`);
-    }
-    return `${value}`;
-  } else if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  } else if (Array.isArray(value)) {
-    const rendered = value.map((item, index) => toTomlValue(item, `${path3}[${index}]`));
-    return `[${rendered.join(", ")}]`;
-  } else if (isPlainObject(value)) {
-    const parts = [];
-    for (const [key, child] of Object.entries(value)) {
-      if (!key) {
-        throw new Error("Codex config override keys must be non-empty strings");
-      }
-      if (child === undefined) {
-        continue;
-      }
-      parts.push(`${formatTomlKey(key)} = ${toTomlValue(child, `${path3}.${key}`)}`);
-    }
-    return `{${parts.join(", ")}}`;
-  } else if (value === null) {
-    throw new Error(`Codex config override at ${path3} cannot be null`);
-  } else {
-    const typeName = typeof value;
-    throw new Error(`Unsupported Codex config override value at ${path3}: ${typeName}`);
-  }
-}
-var TOML_BARE_KEY = /^[A-Za-z0-9_-]+$/;
-function formatTomlKey(key) {
-  return TOML_BARE_KEY.test(key) ? key : JSON.stringify(key);
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function findCodexPath() {
-  const { platform, arch } = process;
-  let targetTriple = null;
-  switch (platform) {
-    case "linux":
-    case "android":
-      switch (arch) {
-        case "x64":
-          targetTriple = "x86_64-unknown-linux-musl";
-          break;
-        case "arm64":
-          targetTriple = "aarch64-unknown-linux-musl";
-          break;
-        default:
-          break;
-      }
-      break;
-    case "darwin":
-      switch (arch) {
-        case "x64":
-          targetTriple = "x86_64-apple-darwin";
-          break;
-        case "arm64":
-          targetTriple = "aarch64-apple-darwin";
-          break;
-        default:
-          break;
-      }
-      break;
-    case "win32":
-      switch (arch) {
-        case "x64":
-          targetTriple = "x86_64-pc-windows-msvc";
-          break;
-        case "arm64":
-          targetTriple = "aarch64-pc-windows-msvc";
-          break;
-        default:
-          break;
-      }
-      break;
-    default:
-      break;
-  }
-  if (!targetTriple) {
-    throw new Error(`Unsupported platform: ${platform} (${arch})`);
-  }
-  const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
-  if (!platformPackage) {
-    throw new Error(`Unsupported target triple: ${targetTriple}`);
-  }
-  let vendorRoot;
-  try {
-    const codexPackageJsonPath = moduleRequire.resolve(`${CODEX_NPM_NAME}/package.json`);
-    const codexRequire = createRequire(codexPackageJsonPath);
-    const platformPackageJsonPath = codexRequire.resolve(`${platformPackage}/package.json`);
-    vendorRoot = path2.join(path2.dirname(platformPackageJsonPath), "vendor");
-  } catch {
-    throw new Error(`Unable to locate Codex CLI binaries. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`);
-  }
-  const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
-  const nativePackage = resolveNativePackage(vendorRoot, targetTriple, codexBinaryName);
-  if (!nativePackage) {
-    throw new Error(`Unable to locate Codex CLI binaries for ${targetTriple}. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`);
-  }
-  return nativePackage;
-}
-function resolveNativePackage(vendorRoot, targetTriple, codexBinaryName) {
-  const packageRoot = path2.join(vendorRoot, targetTriple);
-  const packageBinaryPath = path2.join(packageRoot, "bin", codexBinaryName);
-  if (isFile(packageBinaryPath) && isFile(path2.join(packageRoot, "codex-package.json"))) {
-    return {
-      executablePath: packageBinaryPath,
-      pathDirs: existingDirs(path2.join(packageRoot, "codex-path"))
-    };
-  }
-  const legacyBinaryPath = path2.join(packageRoot, "codex", codexBinaryName);
-  if (isFile(legacyBinaryPath)) {
-    return {
-      executablePath: legacyBinaryPath,
-      pathDirs: existingDirs(path2.join(packageRoot, "path"))
-    };
-  }
-  return null;
-}
-function existingDirs(...dirs) {
-  return dirs.filter(isDirectory);
-}
-function prependPathDirs(env, pathDirs, platform = process.platform) {
-  const pathKey = pathEnvKey(env, platform);
-  if (platform === "win32") {
-    for (const key of Object.keys(env)) {
-      if (key.toLowerCase() === "path" && key !== pathKey) {
-        delete env[key];
-      }
-    }
-  }
-  const existingEntries = (env[pathKey] ?? "").split(path2.delimiter).filter((entry) => entry.length > 0 && !pathDirs.includes(entry));
-  env[pathKey] = [...pathDirs, ...existingEntries].join(path2.delimiter);
-}
-function pathEnvKey(env, platform) {
-  if (platform !== "win32") {
-    return "PATH";
-  }
-  const matchingKeys = Object.keys(env).filter((key) => key.toLowerCase() === "path");
-  return matchingKeys.includes("Path") ? "Path" : matchingKeys.at(-1) ?? "PATH";
-}
-function isFile(filePath) {
-  try {
-    return statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function isDirectory(filePath) {
-  try {
-    return statSync(filePath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-var Codex = class {
-  exec;
-  options;
-  constructor(options = {}) {
-    const { codexPathOverride, env, config } = options;
-    this.exec = new CodexExec(codexPathOverride, env, config);
-    this.options = options;
-  }
-  startThread(options = {}) {
-    return new Thread(this.exec, this.options, options);
-  }
-  resumeThread(id, options = {}) {
-    return new Thread(this.exec, this.options, options, id);
-  }
-};
-
-// src/providers/codex-adapter.ts
-init_secret_scrubber();
-
-// src/providers/codex-agents-md.ts
-import { join } 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 NOOP_HANDLE = {
-  cleanup: async () => {}
-};
-async function writeCodexAgentsMd(cwd, systemPrompt) {
-  if (!cwd || !systemPrompt) {
-    return NOOP_HANDLE;
-  }
-  const agentsMdPath = join(cwd, "AGENTS.md");
-  const claudeMdPath = join(cwd, "CLAUDE.md");
-  const block = `${BLOCK_OPEN}
-${systemPrompt}
-${BLOCK_CLOSE}`;
-  const agentsMdFile = Bun.file(agentsMdPath);
-  const existingAgentsMdExists = await agentsMdFile.exists();
-  let createdFresh = false;
-  let newContent;
-  if (!existingAgentsMdExists) {
-    const claudeMdFile = Bun.file(claudeMdPath);
-    const claudeMdExists = await claudeMdFile.exists();
-    if (claudeMdExists) {
-      const claudeContent = await claudeMdFile.text();
-      newContent = `${block}
-
-${claudeContent}`;
-    } else {
-      newContent = `${block}
-`;
-    }
-    createdFresh = true;
-  } else {
-    const existingContent = await agentsMdFile.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-models.ts
-var CODEX_DEFAULT_MODEL = "gpt-5.4";
-var CLAUDE_SHORTNAMES = {
-  fable: "gpt-5.5",
-  opus: "gpt-5.4",
-  sonnet: "gpt-5.4",
-  haiku: "gpt-5.4-mini"
-};
-function resolveCodexModel(modelStr) {
-  if (!modelStr)
-    return CODEX_DEFAULT_MODEL;
-  const normalized = modelStr.toLowerCase();
-  return CLAUDE_SHORTNAMES[normalized] ?? normalized;
-}
-var CODEX_MODEL_CONTEXT_WINDOWS = {
-  "gpt-5.5": 1050000,
-  "gpt-5.4": 200000,
-  "gpt-5.4-mini": 200000,
-  "gpt-5.3-codex": 1e6,
-  "gpt-5.2-codex": 200000
-};
-function getCodexContextWindow(model) {
-  return CODEX_MODEL_CONTEXT_WINDOWS[model] ?? 200000;
-}
-var CODEX_MODEL_PRICING = {
-  "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
-  }
-};
-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-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 homedir = deps.homedir ?? os2.homedir.bind(os2);
-  const fs2 = deps.fs ?? {
-    readFile: (path3, encoding) => fsModule.readFile(path3, encoding),
-    mkdir: (path3, opts) => fsModule.mkdir(path3, opts),
-    writeFile: (path3, data, opts) => fsModule.writeFile(path3, data, opts)
-  };
-  const authJsonPath = join2(homedir(), ".codex", "auth.json");
-  const readAuthMode = async () => {
-    try {
-      const raw = await fs2.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 fs2.mkdir(join2(homedir(), ".codex"), { recursive: true, mode: 448 });
-        await fs2.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 = {};
-  mcpServers["agent-swarm"] = {
-    url: `${config.apiUrl}/mcp`,
-    http_headers: {
-      Authorization: `Bearer ${config.apiKey}`,
-      "X-Agent-ID": config.agentId,
-      "X-Source-Task-Id": config.taskId ?? ""
-    },
-    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
-  };
-}
-
-class CodexSession {
-  thread;
-  config;
-  agentsMdHandle;
-  resolvedModel;
-  contextWindow;
-  skillsDir;
-  summarizeDeps;
-  listeners = [];
-  eventQueue = [];
-  logFileHandle;
-  startedAt = Date.now();
-  completionPromise;
-  resolveCompletion;
-  abortController = null;
-  transcript = [];
-  abortRef = { current: null };
-  _sessionId;
-  numTurns = 0;
-  lastUsage = null;
-  aborted = false;
-  settled = false;
-  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(os2.homedir(), ".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((resolve) => {
-      this.resolveCompletion = resolve;
-    });
-    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;
-  }
-  async abort(reason) {
-    this.aborted = true;
-    this.abortController?.abort(reason ?? "cancelled");
-  }
-  emit(event) {
-    const scrubbed = event.type === "raw_log" || event.type === "raw_stderr" ? { ...event, content: scrubSecrets(event.content) } : 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;
-    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: undefined,
-      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 = readPkgVersion("@openai/codex-sdk");
-        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 "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 text = r.text ?? r.summary ?? "";
-            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.lastUsage = event.usage;
-        if (event.usage) {
-          const contextUsed = computeContextUsedUnified({
-            inputTokens: event.usage.input_tokens,
-            cacheReadTokens: 0,
-            cacheCreateTokens: 0,
-            outputTokens: event.usage.output_tokens
-          });
-          this.emit({
-            type: "context_usage",
-            contextUsedTokens: contextUsed,
-            contextTotalTokens: this.contextWindow,
-            contextPercent: clampContextPercent(contextUsed, this.contextWindow) ?? 0,
-            outputTokens: event.usage.output_tokens,
-            contextFormula: CONTEXT_FORMULA
-          });
-        }
-        break;
-      }
-      case "turn.failed": {
-        const { message } = this.formatTerminalError(event.error.message);
-        this.emit({ type: "error", message });
-        break;
-      }
-      case "error": {
-        const { message } = this.formatTerminalError(event.message);
-        this.emit({ type: "error", message });
-        break;
-      }
-    }
-  }
-  formatTerminalError(raw) {
-    const normalized = 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.abortRef.current = this.abortController;
-    let terminalError;
-    let sawTurnCompleted = false;
-    try {
-      const resolvedPrompt = await resolveCodexPrompt(this.config.prompt, this.skillsDir, (event) => this.emit(event));
-      this.transcript = [`User: ${resolvedPrompt}`];
-      const streamed = await this.thread.runStreamed(resolvedPrompt, {
-        signal: this.abortController.signal
-      });
-      try {
-        for await (const event of streamed.events) {
-          this.handleEvent(event);
-          if (event.type === "turn.completed") {
-            sawTurnCompleted = true;
-          }
-          if (event.type === "turn.failed" && !terminalError) {
-            terminalError = this.formatTerminalError(event.error.message);
-            this.errorTracker.processCodexUsageLimitMessage(event.error.message);
-          }
-          if (event.type === "error" && !terminalError) {
-            terminalError = this.formatTerminalError(event.message);
-            this.errorTracker.processCodexUsageLimitMessage(event.message);
-          }
-        }
-      } catch (err) {
-        if (this.aborted || err instanceof Error && err.name === "AbortError") {
-          const abortReason = typeof this.abortController?.signal.reason === "string" ? this.abortController.signal.reason : "cancelled";
-          const cost2 = this.buildCostData(this.lastUsage, true);
-          this.emit({ type: "result", cost: cost2, isError: true, errorCategory: "cancelled" });
-          this.settle({
-            exitCode: 130,
-            sessionId: this._sessionId,
-            cost: cost2,
-            isError: true,
-            failureReason: abortReason
-          });
-          return;
-        }
-        if (terminalError) {
-          const cost2 = this.buildCostData(this.lastUsage, 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;
-      }
-      const isError = Boolean(terminalError) || !sawTurnCompleted;
-      const cost = this.buildCostData(this.lastUsage, 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) {
-      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.lastUsage, 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");
-      }
-      this.abortRef.current = null;
-      try {
-        await this.logFileHandle.end();
-      } catch {}
-      await this.agentsMdHandle.cleanup();
-      const finalResult = this.pendingResult ?? {
-        exitCode: 1,
-        sessionId: this._sessionId,
-        cost: this.buildCostData(this.lastUsage, 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)
-      return;
-    if (transcriptStr.length <= 100)
-      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 memoryRaters = (process.env.MEMORY_RATERS ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-    const wantRatings = memoryRaters.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
-    });
-    if (!result)
-      return;
-    const summary = result.summary.trim();
-    if (summary.length <= 20 || summary.toLowerCase().includes("no significant learnings")) {
-      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)
-    };
-    const codexPathOverride = process.env.CODEX_PATH_OVERRIDE;
-    const codex = new Codex({
-      ...codexPathOverride ? { codexPathOverride } : {},
-      env,
-      config: mergedConfig
-    });
-    const threadOptions = {
-      workingDirectory: config.cwd,
-      skipGitRepoCheck: true,
-      sandboxMode: "danger-full-access",
-      approvalPolicy: "never",
-      model: resolvedModel
-    };
-    if (config.resumeSessionId) {
-      console.warn("[codex-adapter] resumeSessionId ignored — native resume is disabled by deprecation plan");
-    }
-    const thread = codex.startThread(threadOptions);
-    return new CodexSession(thread, config, agentsMdHandle, resolvedModel, preSessionEvents, opts.skillsDir, opts.summarizeDeps ?? {});
-  } 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;
-  constructor(config, skillsDir) {
-    const argv = resolveCodexRunnerArgv();
-    const payload = {
-      config,
-      skillsDir,
-      parentOtelEnv: buildOtelTraceparentEnv(config.env ?? process.env)
-    };
-    const apiKey = getApiKey();
-    this.proc = Bun.spawn(argv, {
-      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 } : {},
-        ...process.env.MEMORY_RATERS ? { MEMORY_RATERS: process.env.MEMORY_RATERS } : {}
-      },
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const stdin = this.proc.stdin;
-    stdin.write(JSON.stringify(payload));
-    stdin.end();
-    this.completionPromise = this.processStreams();
-  }
-  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() {
-    this.proc.kill("SIGTERM");
-  }
-  emit(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;
-      for await (const chunk of stdout) {
-        partial += new TextDecoder().decode(chunk);
-        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;
-          });
-        }
-      }
-      if (partial.trim()) {
-        this.handleLine(partial.trim(), (r) => {
-          result = r;
-        });
-        partial = "";
-      }
-    })();
-    const stderrPromise = (async () => {
-      const stderr = this.proc.stderr;
-      if (!stderr)
-        return;
-      for await (const chunk of stderr) {
-        const text = new TextDecoder().decode(chunk);
-        stderrTail = (stderrTail + text).slice(-2000);
-        this.emit({ type: "raw_stderr", content: text });
-      }
-    })();
-    await Promise.all([stdoutPromise, stderrPromise]);
-    const exitCode = await this.proc.exited;
-    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(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) {
-      setResult(msg.result);
-      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, hasLocalEnvironment: true };
-  skillsDir;
-  summarizeDeps;
-  bypassSubprocess;
-  constructor(opts = {}) {
-    this.skillsDir = opts.skillsDir;
-    this.summarizeDeps = opts.summarizeDeps ?? {};
-    this.bypassSubprocess = opts.bypassSubprocess ?? false;
-  }
-  async createSession(config) {
-    if (this.bypassSubprocess) {
-      return createInProcessCodexSession(config, {
-        skillsDir: this.skillsDir,
-        summarizeDeps: this.summarizeDeps
-      });
-    }
-    return new CodexSubprocessSession(config, this.skillsDir);
-  }
-  async canResume(_sessionId) {
-    return false;
-  }
-  formatCommand(commandName) {
-    return `/${commandName}`;
-  }
-}
-
-export { checkCodexCredentials, resolveCodexAuthMode, buildCodexConfig, CodexSession, createInProcessCodexSession, resolveCodexRunnerArgv, CodexAdapter };