@autohq/cli 0.1.225 → 0.1.227

package/dist/agent-bridge.js

@@ -43,7 +43,7 @@ var require_XMLHttpRequest = __commonJS({
     "use strict";
     var fs = __require("fs");
     var Url = __require("url");
-    var spawn = __require("child_process").spawn;
+    var spawn2 = __require("child_process").spawn;
     module.exports = XMLHttpRequest3;
     XMLHttpRequest3.XMLHttpRequest = XMLHttpRequest3;
     function XMLHttpRequest3(opts) {
@@ -339,7 +339,7 @@ var require_XMLHttpRequest = __commonJS({
           var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
           fs.writeFileSync(syncFile, "", "utf8");
           var execString = "var http = require('http'), https = require('https'), fs = require('fs');var doRequest = http" + (ssl ? "s" : "") + ".request;var options = " + JSON.stringify(options) + ";var responseText = '';var responseData = Buffer.alloc(0);var req = doRequest(options, function(response) {response.on('data', function(chunk) {  var data = Buffer.from(chunk);  responseText += data.toString('utf8');  responseData = Buffer.concat([responseData, data]);});response.on('end', function() {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText, data: responseData.toString('base64')}}), 'utf8');fs.unlinkSync('" + syncFile + "');});response.on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});}).on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
-          var syncProc = spawn(process.argv[0], ["-e", execString]);
+          var syncProc = spawn2(process.argv[0], ["-e", execString]);
           var statusText;
           while (fs.existsSync(syncFile)) {
           }
@@ -19545,6 +19545,9 @@ var AgentBridgeClaudeConfigSchema = AgentBridgeHarnessBaseConfigSchema;
 var AgentBridgeHarnessConfigSchema = external_exports.discriminatedUnion("kind", [
   AgentBridgeHarnessBaseConfigSchema.extend({
     kind: external_exports.literal("claude-code")
+  }),
+  AgentBridgeHarnessBaseConfigSchema.extend({
+    kind: external_exports.literal("codex")
   })
 ]);
 var RuntimeBridgeBootstrapPlaintextSchema = external_exports.object({
@@ -23319,7 +23322,7 @@ Object.assign(lookup, {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.225",
+  version: "0.1.227",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"
@@ -24597,12 +24600,12 @@ function parseClaudeCodeStreamRecord(parsed) {
   }
   const isError = record2.is_error === true || record2.subtype === "error";
   const sdkErrorMessage = record2.errors?.map((error51) => error51.trim()).filter(Boolean).join("\n");
-  const errorMessage2 = isError ? record2.error ?? record2.result ?? (sdkErrorMessage || void 0) ?? "claude-code reported an error" : void 0;
+  const errorMessage4 = isError ? record2.error ?? record2.result ?? (sdkErrorMessage || void 0) ?? "claude-code reported an error" : void 0;
   return {
     projections: [],
     result: {
       isError,
-      errorMessage: errorMessage2
+      errorMessage: errorMessage4
     }
   };
 }
@@ -24816,6 +24819,250 @@ var CodexFrameSchema = external_exports.object({
   result: external_exports.unknown().optional(),
   error: external_exports.object({ message: external_exports.string().optional() }).passthrough().optional()
 }).passthrough();
+function parseCodexServerFrame(raw) {
+  const frame = CodexFrameSchema.parse(raw);
+  if (frame.method === void 0 && frame.id !== void 0) {
+    return {
+      kind: "response",
+      id: frame.id,
+      ...frame.result !== void 0 ? { result: toJsonValue(frame.result) } : {},
+      ...frame.error?.message ? { error: frame.error.message } : {}
+    };
+  }
+  if (frame.method === void 0) {
+    return { kind: "ignored" };
+  }
+  if (frame.id !== void 0) {
+    return classifyServerRequest(frame.method, frame.id, frame.params);
+  }
+  const notification = parseNotification(frame.method, frame.params);
+  return notification ? { kind: "notification", notification } : { kind: "ignored" };
+}
+function projectCodexItem(input) {
+  const { item, phase } = input;
+  switch (item.type) {
+    case "agentMessage":
+      return phase === "completed" && item.text.length > 0 ? [
+        {
+          role: "assistant",
+          kind: "message",
+          messageId: item.id,
+          content: textContent2(item.text)
+        }
+      ] : [];
+    case "commandExecution":
+      return toolProjection({
+        phase,
+        itemId: item.id,
+        name: "shell",
+        input: {
+          command: item.command,
+          ...item.cwd ? { cwd: item.cwd } : {}
+        },
+        output: item.aggregatedOutput ?? "",
+        isError: isFailedStatus(item.status) || (item.exitCode ?? 0) !== 0
+      });
+    case "fileChange":
+      return toolProjection({
+        phase,
+        itemId: item.id,
+        name: "apply_patch",
+        input: { changes: toJsonValue(item.changes) },
+        output: { status: item.status ?? "unknown" },
+        isError: isFailedStatus(item.status)
+      });
+    case "mcpToolCall":
+      return toolProjection({
+        phase,
+        itemId: item.id,
+        name: `${item.server}.${item.tool}`,
+        input: toJsonValue(item.arguments),
+        output: item.error ? { error: item.error.message } : toJsonValue(item.result),
+        isError: isFailedStatus(item.status) || item.error != null
+      });
+    default:
+      return [];
+  }
+}
+function projectCodexApproval(request) {
+  const subject = request.type === "commandExecution" ? `run the command: ${request.command ?? "(unknown command)"}` : "apply file changes";
+  const question = {
+    question: request.reason ? `Codex requests approval to ${subject}. ${request.reason}` : `Codex requests approval to ${subject}.`,
+    header: "Approval",
+    options: [
+      { label: APPROVE_OPTION_LABEL, description: "Allow this action." },
+      { label: DECLINE_OPTION_LABEL, description: "Reject this action." }
+    ],
+    multiSelect: false
+  };
+  return {
+    role: "assistant",
+    kind: "question",
+    content: {
+      parts: [
+        { type: "question", toolCallId: request.itemId, questions: [question] }
+      ]
+    }
+  };
+}
+var APPROVE_OPTION_LABEL = "Approve";
+var DECLINE_OPTION_LABEL = "Decline";
+function codexApprovalDecision(input) {
+  const values = [...Object.values(input.answers), input.response ?? ""];
+  const approved = values.some(
+    (value2) => value2.trim().toLowerCase() === APPROVE_OPTION_LABEL.toLowerCase()
+  );
+  return approved ? "accept" : "decline";
+}
+function parseNotification(method, params) {
+  switch (method) {
+    case "thread/started": {
+      const parsed = external_exports.object({ thread: external_exports.object({ id: external_exports.string() }).passthrough() }).passthrough().safeParse(params);
+      return parsed.success ? { type: "threadStarted", threadId: parsed.data.thread.id } : null;
+    }
+    case "turn/started": {
+      const parsed = CodexTurnEnvelopeSchema.safeParse(params);
+      return parsed.success ? {
+        type: "turnStarted",
+        threadId: parsed.data.threadId,
+        turnId: parsed.data.turn.id
+      } : null;
+    }
+    case "turn/completed": {
+      const parsed = CodexTurnEnvelopeSchema.safeParse(params);
+      return parsed.success ? {
+        type: "turnCompleted",
+        threadId: parsed.data.threadId,
+        turnId: parsed.data.turn.id,
+        status: parsed.data.turn.status,
+        ...parsed.data.turn.error?.message ? { errorMessage: parsed.data.turn.error.message } : {}
+      } : null;
+    }
+    case "item/started":
+    case "item/completed": {
+      const parsed = CodexItemEnvelopeSchema.safeParse(params);
+      if (!parsed.success || parsed.data.item === null) {
+        return null;
+      }
+      return {
+        type: method === "item/started" ? "itemStarted" : "itemCompleted",
+        threadId: parsed.data.threadId,
+        turnId: parsed.data.turnId,
+        item: parsed.data.item
+      };
+    }
+    case "item/agentMessage/delta": {
+      const parsed = external_exports.object({ itemId: external_exports.string(), delta: external_exports.string() }).passthrough().safeParse(params);
+      return parsed.success ? {
+        type: "agentMessageDelta",
+        itemId: parsed.data.itemId,
+        delta: parsed.data.delta
+      } : null;
+    }
+    case "error": {
+      const parsed = external_exports.object({
+        error: external_exports.object({ message: external_exports.string() }).passthrough(),
+        willRetry: external_exports.boolean().default(false),
+        threadId: external_exports.string().default("")
+      }).passthrough().safeParse(params);
+      return parsed.success ? {
+        type: "error",
+        threadId: parsed.data.threadId,
+        willRetry: parsed.data.willRetry,
+        message: parsed.data.error.message
+      } : null;
+    }
+    default:
+      return null;
+  }
+}
+function classifyServerRequest(method, requestId, params) {
+  if (method === "mcpServer/elicitation/request") {
+    const parsed = external_exports.object({ serverName: external_exports.string().default("") }).passthrough().safeParse(params);
+    return {
+      kind: "elicitation",
+      requestId,
+      serverName: parsed.success ? parsed.data.serverName : ""
+    };
+  }
+  const approval = parseApprovalRequest(method, requestId, params);
+  if (approval) {
+    return { kind: "serverRequest", request: approval };
+  }
+  return { kind: "unsupportedRequest", requestId, method };
+}
+function parseApprovalRequest(method, requestId, params) {
+  const base = external_exports.object({
+    itemId: external_exports.string(),
+    reason: external_exports.string().nullish(),
+    command: external_exports.string().nullish()
+  }).passthrough();
+  switch (method) {
+    case "item/commandExecution/requestApproval": {
+      const parsed = base.safeParse(params);
+      return parsed.success ? {
+        type: "commandExecution",
+        requestId,
+        itemId: parsed.data.itemId,
+        ...parsed.data.reason ? { reason: parsed.data.reason } : {},
+        ...parsed.data.command ? { command: parsed.data.command } : {}
+      } : null;
+    }
+    case "item/fileChange/requestApproval": {
+      const parsed = base.safeParse(params);
+      return parsed.success ? {
+        type: "fileChange",
+        requestId,
+        itemId: parsed.data.itemId,
+        ...parsed.data.reason ? { reason: parsed.data.reason } : {}
+      } : null;
+    }
+    default:
+      return null;
+  }
+}
+function toolProjection(input) {
+  if (input.phase === "started") {
+    return [
+      {
+        role: "assistant",
+        kind: "tool_call",
+        content: {
+          parts: [
+            {
+              type: "tool_call",
+              toolCallId: input.itemId,
+              name: input.name,
+              input: input.input
+            }
+          ]
+        }
+      }
+    ];
+  }
+  return [
+    {
+      role: "tool",
+      kind: "tool_result",
+      content: {
+        parts: [
+          {
+            type: "tool_result",
+            toolUseId: input.itemId,
+            output: input.output,
+            isError: input.isError
+          }
+        ]
+      }
+    }
+  ];
+}
+function textContent2(text) {
+  return { parts: [{ type: "text", text }] };
+}
+function isFailedStatus(status) {
+  return status === "failed" || status === "declined";
+}
 
 // ../../packages/schemas/src/resources.ts
 var ResourceNameSchema = external_exports.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_.-]+$/);
@@ -48466,6 +48713,981 @@ function commandLogContext(delivery, fields = {}) {
   };
 }
 
+// src/commands/agent-bridge/harness/codex/projector.ts
+var CodexProjector = class {
+  project(notification) {
+    switch (notification.type) {
+      case "agentMessageDelta":
+        return [
+          {
+            type: "delta",
+            delta: {
+              messageId: notification.itemId,
+              partId: "0",
+              role: "assistant",
+              kind: "message",
+              delta: { type: "text", text: notification.delta }
+            }
+          }
+        ];
+      case "itemStarted":
+        return entryProjections(
+          projectCodexItem({ item: notification.item, phase: "started" })
+        );
+      case "itemCompleted":
+        return entryProjections(
+          projectCodexItem({ item: notification.item, phase: "completed" })
+        );
+      case "turnCompleted":
+        return [turnCompletionEntry(notification)];
+      case "error":
+        return [errorEntry(notification)];
+      default:
+        return [];
+    }
+  }
+  // An approval parks the turn on operator input, so the question entry also
+  // marks the delivered turn as waiting for input.
+  projectApproval(request) {
+    return {
+      type: "entry",
+      entry: {
+        ...projectCodexApproval(request),
+        turnStatus: "waiting_for_input"
+      }
+    };
+  }
+  // Surfaces a session-level failure (e.g. the app-server process dying) as a
+  // durable failed status entry rather than only a diagnostic log line.
+  projectSessionFailure(message) {
+    return {
+      type: "entry",
+      entry: {
+        role: "system",
+        kind: "status",
+        status: "failed",
+        turnStatus: "failed",
+        content: {
+          parts: [{ type: "text", text: `codex failed: ${message}` }]
+        }
+      }
+    };
+  }
+};
+function entryProjections(projections) {
+  return projections.map((projection) => ({
+    type: "entry",
+    entry: projection
+  }));
+}
+function turnCompletionEntry(notification) {
+  if (notification.status === "failed") {
+    const detail = notification.errorMessage ?? "unknown error";
+    return statusEntry({
+      text: `codex turn failed: ${detail}`,
+      status: "failed",
+      turnStatus: "failed"
+    });
+  }
+  const text = notification.status === "interrupted" ? "codex turn interrupted" : "codex turn completed";
+  return statusEntry({
+    text,
+    status: "completed",
+    turnStatus: "completed"
+  });
+}
+function errorEntry(notification) {
+  if (notification.willRetry) {
+    return statusEntry({
+      text: `codex retrying after error: ${notification.message}`,
+      status: "completed"
+    });
+  }
+  return statusEntry({
+    text: `codex error: ${notification.message}`,
+    status: "failed",
+    turnStatus: "failed"
+  });
+}
+function statusEntry(input) {
+  return {
+    type: "entry",
+    entry: {
+      role: "system",
+      kind: "status",
+      status: input.status,
+      ...input.turnStatus ? { turnStatus: input.turnStatus } : {},
+      content: { parts: [{ type: "text", text: input.text }] }
+    }
+  };
+}
+
+// src/commands/agent-bridge/harness/codex/resume-store.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var AGENT_BRIDGE_RUNTIME_DIR2 = "/tmp/auto-bridge-runtime";
+var CODEX_THREAD_RESUME_PATH = `${AGENT_BRIDGE_RUNTIME_DIR2}/codex-thread-id`;
+function fileCodexThreadResumeStore(path2 = CODEX_THREAD_RESUME_PATH) {
+  return {
+    read(sessionId) {
+      if (!existsSync3(path2)) {
+        return null;
+      }
+      const record2 = parseResumeRecord2(readFileSync3(path2, "utf8"));
+      if (!record2 || record2.sessionId !== sessionId) {
+        return null;
+      }
+      return record2.threadId;
+    },
+    write(record2) {
+      mkdirSync3(dirname2(path2), { recursive: true });
+      writeFileSync2(path2, `${JSON.stringify(record2)}
+`, "utf8");
+    }
+  };
+}
+function parseResumeRecord2(raw) {
+  try {
+    const value2 = JSON.parse(raw);
+    if (value2 !== null && typeof value2 === "object" && "sessionId" in value2 && "threadId" in value2 && typeof value2.sessionId === "string" && typeof value2.threadId === "string" && value2.threadId.length > 0) {
+      return { sessionId: value2.sessionId, threadId: value2.threadId };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/agent-bridge/harness/codex/session.ts
+import { spawn } from "child_process";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join2 } from "path";
+
+// src/commands/agent-bridge/harness/codex/options.ts
+import { join } from "path";
+var CODEX_EXECUTABLE_PATH = "codex";
+var CODEX_DEFAULT_MODEL = "gpt-5.3-codex";
+var CODEX_HTTP_PROVIDER_ID = "openai-responses-http";
+var CODEX_OPENAI_BASE_URL = "https://api.openai.com/v1";
+var CODEX_API_KEY_ENV = "OPENAI_API_KEY";
+var CODEX_RUNTIME_PROCESS_ENV_KEYS = ["PATH", "HOME"];
+function codexLaunchOptions(config2) {
+  return {
+    command: codexExecutablePath(),
+    // `--listen stdio://` is the default, but pin it so a config/feature change
+    // cannot silently move the transport off the stdin/stdout the client drives.
+    args: ["app-server", "--listen", "stdio://"],
+    env: codexProcessEnv(config2.env),
+    // Codex reads config/auth/rollout state from its standard home; the caller
+    // writes the rendered config.toml there.
+    codexHome: codexHomeDir(),
+    configToml: renderCodexConfigToml(config2)
+  };
+}
+function codexThreadParams(config2) {
+  return {
+    ...config2.cwd ? { cwd: config2.cwd } : {},
+    ...config2.systemPromptAppend ? { developerInstructions: config2.systemPromptAppend } : {}
+  };
+}
+function renderCodexConfigToml(config2) {
+  const lines = [];
+  lines.push(`model = ${tomlString(CODEX_DEFAULT_MODEL)}`);
+  lines.push(`model_provider = ${tomlString(CODEX_HTTP_PROVIDER_ID)}`);
+  lines.push("");
+  lines.push(`[model_providers.${CODEX_HTTP_PROVIDER_ID}]`);
+  lines.push('name = "OpenAI"');
+  lines.push(`base_url = ${tomlString(CODEX_OPENAI_BASE_URL)}`);
+  lines.push('wire_api = "responses"');
+  lines.push(`env_key = ${tomlString(CODEX_API_KEY_ENV)}`);
+  lines.push("supports_websockets = false");
+  for (const [name, server] of Object.entries(config2.mcpServers ?? {})) {
+    lines.push("");
+    lines.push(`[mcp_servers.${tomlKey(name)}]`);
+    lines.push(`url = ${tomlString(server.url)}`);
+    if (server.headers && Object.keys(server.headers).length > 0) {
+      lines.push(`http_headers = ${tomlInlineTable(server.headers)}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function codexProcessEnv(env) {
+  const selected = {};
+  for (const key of CODEX_RUNTIME_PROCESS_ENV_KEYS) {
+    const value2 = process.env[key];
+    if (value2 !== void 0) {
+      selected[key] = value2;
+    }
+  }
+  return {
+    ...selected,
+    ...env
+  };
+}
+function codexHomeDir() {
+  const home = process.env.HOME;
+  if (!home) {
+    throw new Error("codex launch requires HOME to locate the ~/.codex home");
+  }
+  return join(home, ".codex");
+}
+function codexExecutablePath() {
+  if (process.env.AUTO_AGENT_BRIDGE_TEST_CODEX_COMMAND === "1" && process.env.AUTO_CODEX_COMMAND?.trim()) {
+    return process.env.AUTO_CODEX_COMMAND.trim();
+  }
+  return CODEX_EXECUTABLE_PATH;
+}
+function tomlInlineTable(values) {
+  const entries = Object.entries(values).map(
+    ([key, value2]) => `${tomlKey(key)} = ${tomlString(value2)}`
+  );
+  return `{ ${entries.join(", ")} }`;
+}
+function tomlKey(key) {
+  return /^[A-Za-z0-9_-]+$/.test(key) ? key : tomlString(key);
+}
+function tomlString(value2) {
+  return `"${value2.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+// src/commands/agent-bridge/harness/codex/session.ts
+var CODEX_REQUEST_TIMEOUT_MS = 3e4;
+var CODEX_ITEM_SETTLE_TIMEOUT_MS = 1e4;
+var CODEX_TOOL_ITEM_TYPES = /* @__PURE__ */ new Set([
+  "commandExecution",
+  "fileChange",
+  "mcpToolCall"
+]);
+function startCodexAgentBridgeSession(input) {
+  return new CodexAgentBridgeSessionImpl(input);
+}
+var codexAgentBridgeRuntime = {
+  start: startCodexAgentBridgeSession
+};
+var CodexAgentBridgeSessionImpl = class {
+  input;
+  proc = null;
+  startup = null;
+  closed = false;
+  nextRequestId = 1;
+  pending = /* @__PURE__ */ new Map();
+  stdoutBuffer = "";
+  threadId = null;
+  activeTurnId = null;
+  // Tool-like items started but not yet completed in the active turn. A non-empty
+  // set means an interrupt/steer would race an unsettled item (FRA-3049 analog).
+  pendingToolItemIds = /* @__PURE__ */ new Set();
+  settlementWaiters = /* @__PURE__ */ new Set();
+  // Messages held in "deferred" mode while a turn is in flight; flushed as a
+  // fresh turn once the active turn completes.
+  deferredMessages = [];
+  constructor(input) {
+    this.input = input;
+  }
+  async prepare() {
+    await this.ensureStarted();
+  }
+  async sendMessage(message, options) {
+    await this.ensureStarted();
+    const threadId = this.requireThreadId();
+    const mode = options?.mode ?? "interrupt";
+    if (this.activeTurnId === null) {
+      await this.startTurn(threadId, message);
+      return;
+    }
+    if (mode === "deferred") {
+      this.deferredMessages.push(message);
+      this.input.writeOutput?.("agent_bridge_codex_message_deferred");
+      return;
+    }
+    await this.injectIntoActiveTurn(threadId, message);
+  }
+  resolveApproval(resolution) {
+    this.writeFrame({
+      jsonrpc: "2.0",
+      id: resolution.requestId,
+      result: { decision: resolution.decision }
+    });
+    this.input.writeOutput?.(
+      `agent_bridge_codex_approval_resolved decision=${resolution.decision}`
+    );
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    if (this.threadId && this.activeTurnId) {
+      this.writeFrame({
+        jsonrpc: "2.0",
+        id: this.allocRequestId(),
+        method: "turn/interrupt",
+        params: { threadId: this.threadId, turnId: this.activeTurnId }
+      });
+    }
+    this.activeTurnId = null;
+    this.pendingToolItemIds.clear();
+    this.resolveSettlement();
+    this.rejectAllPending(new Error("Codex session is closed"));
+    if (this.deferredMessages.length > 0) {
+      this.input.writeOutput?.(
+        `agent_bridge_codex_deferred_dropped count=${this.deferredMessages.length} reason=session_closed`
+      );
+      this.deferredMessages.length = 0;
+    }
+    this.proc?.kill("SIGTERM");
+    this.proc = null;
+  }
+  // ---------------------------------------------------------------------------
+  // Startup
+  // ---------------------------------------------------------------------------
+  ensureStarted() {
+    if (this.startup) {
+      return this.startup;
+    }
+    this.startup = this.start().catch((error51) => {
+      this.startup = null;
+      this.close();
+      throw error51;
+    });
+    return this.startup;
+  }
+  async start() {
+    const options = codexLaunchOptions(this.input.codex);
+    mkdirSync4(options.codexHome, { recursive: true });
+    writeFileSync3(join2(options.codexHome, "config.toml"), options.configToml);
+    const startedAt = Date.now();
+    this.input.writeOutput?.(
+      `agent_bridge_codex_startup_started codex_home=${options.codexHome}`
+    );
+    const proc = spawn(options.command, options.args, {
+      env: options.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.proc = proc;
+    proc.stdout.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => this.onStdout(chunk));
+    proc.stderr.setEncoding("utf8");
+    proc.stderr.on(
+      "data",
+      (chunk) => this.input.writeOutput?.(`agent_bridge_codex_stderr ${chunk.trimEnd()}`)
+    );
+    proc.on("exit", (code) => this.onProcessExit(code));
+    proc.on("error", (error51) => void this.input.onError(error51));
+    await this.request("initialize", {
+      clientInfo: {
+        name: "auto-agent-bridge",
+        title: "Auto",
+        version: "1"
+      },
+      capabilities: null
+    });
+    this.notify("initialized");
+    await this.openThread();
+    this.input.writeOutput?.(
+      `agent_bridge_codex_startup_ready duration_ms=${Date.now() - startedAt} thread_id=${this.threadId ?? ""}`
+    );
+  }
+  // Resume the stored thread when present, falling back to a fresh thread if the
+  // resume is rejected (e.g. the rollout was pruned). A fresh thread carries the
+  // neutral thread params (cwd + the agent identity as developerInstructions).
+  async openThread() {
+    if (this.input.resumeThreadId) {
+      try {
+        const resumed = await this.request("thread/resume", {
+          threadId: this.input.resumeThreadId
+        });
+        this.adoptThreadId(resumed);
+        return;
+      } catch (error51) {
+        this.input.writeOutput?.(
+          `agent_bridge_codex_resume_fallback thread_id=${this.input.resumeThreadId} error=${errorMessage2(error51)}`
+        );
+      }
+    }
+    const started = await this.request(
+      "thread/start",
+      codexThreadParams(this.input.codex)
+    );
+    this.adoptThreadId(started);
+  }
+  adoptThreadId(result) {
+    const threadId = threadIdFromResult(result);
+    if (!threadId) {
+      throw new Error("Codex thread response did not include a thread id");
+    }
+    this.threadId = threadId;
+    this.input.onThreadId(threadId);
+  }
+  // ---------------------------------------------------------------------------
+  // Turn delivery
+  // ---------------------------------------------------------------------------
+  async startTurn(threadId, message) {
+    await this.request("turn/start", {
+      threadId,
+      input: [userTextInput(message)]
+    });
+  }
+  // Inject a message into the active turn. Prefers `turn/steer` (codex folds the
+  // input into the running turn and owns transcript consistency); falls back to a
+  // hard `turn/interrupt` + fresh `turn/start` when the turn cannot be steered.
+  async injectIntoActiveTurn(threadId, message) {
+    await this.awaitItemSettlement();
+    const expectedTurnId = this.activeTurnId;
+    if (expectedTurnId === null) {
+      await this.startTurn(threadId, message);
+      return;
+    }
+    try {
+      await this.request("turn/steer", {
+        threadId,
+        input: [userTextInput(message)],
+        expectedTurnId
+      });
+      this.input.writeOutput?.("agent_bridge_codex_steered");
+      return;
+    } catch (error51) {
+      this.input.writeOutput?.(
+        `agent_bridge_codex_steer_failed error=${errorMessage2(error51)}`
+      );
+    }
+    if (this.activeTurnId) {
+      await this.interruptActiveTurn(threadId, this.activeTurnId);
+    }
+    await this.startTurn(threadId, message);
+  }
+  async interruptActiveTurn(threadId, turnId) {
+    try {
+      await this.request("turn/interrupt", { threadId, turnId });
+      this.input.writeOutput?.("agent_bridge_codex_interrupted");
+    } catch (error51) {
+      this.input.writeOutput?.(
+        `agent_bridge_codex_interrupt_failed error=${errorMessage2(error51)}`
+      );
+    }
+  }
+  flushDeferredMessages() {
+    if (this.deferredMessages.length === 0 || this.threadId === null) {
+      return;
+    }
+    const pending = this.deferredMessages.splice(0);
+    this.input.writeOutput?.(
+      `agent_bridge_codex_deferred_flush count=${pending.length}`
+    );
+    void (async () => {
+      for (const message of pending) {
+        try {
+          await this.sendMessage(message, { mode: "interrupt" });
+        } catch (error51) {
+          void this.input.onError(error51);
+        }
+      }
+    })();
+  }
+  // ---------------------------------------------------------------------------
+  // Item settlement
+  // ---------------------------------------------------------------------------
+  awaitItemSettlement() {
+    if (this.pendingToolItemIds.size === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      let done = false;
+      const finish = () => {
+        if (done) {
+          return;
+        }
+        done = true;
+        clearTimeout(timer);
+        this.settlementWaiters.delete(waiter);
+        resolve();
+      };
+      const waiter = () => finish();
+      const timer = setTimeout(finish, CODEX_ITEM_SETTLE_TIMEOUT_MS);
+      timer.unref?.();
+      this.settlementWaiters.add(waiter);
+    });
+  }
+  resolveSettlement() {
+    if (this.settlementWaiters.size === 0) {
+      return;
+    }
+    const waiters = [...this.settlementWaiters];
+    this.settlementWaiters.clear();
+    for (const waiter of waiters) {
+      waiter();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Incoming frame handling
+  // ---------------------------------------------------------------------------
+  onStdout(chunk) {
+    this.stdoutBuffer += chunk;
+    let newline = this.stdoutBuffer.indexOf("\n");
+    while (newline >= 0) {
+      const line = this.stdoutBuffer.slice(0, newline).trim();
+      this.stdoutBuffer = this.stdoutBuffer.slice(newline + 1);
+      if (line) {
+        this.handleFrame(line);
+      }
+      newline = this.stdoutBuffer.indexOf("\n");
+    }
+  }
+  handleFrame(line) {
+    let message;
+    try {
+      message = parseCodexServerFrame(JSON.parse(line));
+    } catch (error51) {
+      this.input.writeOutput?.(
+        `agent_bridge_codex_parse_failed error=${errorMessage2(error51)}`
+      );
+      return;
+    }
+    switch (message.kind) {
+      case "response":
+        this.settleResponse(message.id, message.result, message.error);
+        return;
+      case "notification":
+        this.trackNotification(message.notification);
+        void this.input.onNotification(message.notification);
+        return;
+      case "serverRequest":
+        void this.input.onServerRequest(message.request);
+        return;
+      case "elicitation":
+        this.writeFrame({
+          jsonrpc: "2.0",
+          id: message.requestId,
+          result: { action: "accept", content: {}, _meta: null }
+        });
+        this.input.writeOutput?.(
+          `agent_bridge_codex_elicitation_accepted server=${message.serverName}`
+        );
+        return;
+      case "unsupportedRequest":
+        this.writeFrame({
+          jsonrpc: "2.0",
+          id: message.requestId,
+          error: { code: -32601, message: "Unsupported by Auto bridge" }
+        });
+        this.input.writeOutput?.(
+          `agent_bridge_codex_unsupported_request method=${message.method}`
+        );
+        return;
+      case "ignored":
+        return;
+    }
+  }
+  // Track turn/item lifecycle so steer/interrupt target the live turn and gate on
+  // tool-item settlement.
+  trackNotification(notification) {
+    switch (notification.type) {
+      case "turnStarted":
+        this.activeTurnId = notification.turnId;
+        return;
+      case "turnCompleted":
+        if (notification.turnId === this.activeTurnId) {
+          this.activeTurnId = null;
+        }
+        this.pendingToolItemIds.clear();
+        this.resolveSettlement();
+        this.flushDeferredMessages();
+        return;
+      case "itemStarted":
+        if (CODEX_TOOL_ITEM_TYPES.has(notification.item.type)) {
+          this.pendingToolItemIds.add(notification.item.id);
+        }
+        return;
+      case "itemCompleted":
+        this.pendingToolItemIds.delete(notification.item.id);
+        if (this.pendingToolItemIds.size === 0) {
+          this.resolveSettlement();
+        }
+        return;
+      default:
+        return;
+    }
+  }
+  onProcessExit(code) {
+    this.rejectAllPending(
+      new Error(`Codex app-server exited (code ${code ?? "unknown"})`)
+    );
+    this.activeTurnId = null;
+    this.pendingToolItemIds.clear();
+    this.resolveSettlement();
+    this.input.writeOutput?.(`agent_bridge_codex_exited code=${code ?? ""}`);
+    if (!this.closed) {
+      this.closed = true;
+      this.input.onExit();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // JSON-RPC transport
+  // ---------------------------------------------------------------------------
+  request(method, params) {
+    const id = this.allocRequestId();
+    const frame = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      const timer = setTimeout(() => {
+        if (this.pending.delete(id)) {
+          reject(new Error(`Codex request timed out: ${method}`));
+        }
+      }, CODEX_REQUEST_TIMEOUT_MS);
+      timer.unref?.();
+      this.writeFrame(frame);
+    });
+  }
+  settleResponse(id, result, error51) {
+    if (typeof id !== "number") {
+      return;
+    }
+    const pending = this.pending.get(id);
+    if (!pending) {
+      return;
+    }
+    this.pending.delete(id);
+    if (error51 !== void 0) {
+      pending.reject(new Error(error51));
+      return;
+    }
+    pending.resolve(result);
+  }
+  rejectAllPending(error51) {
+    const pending = [...this.pending.values()];
+    this.pending.clear();
+    for (const request of pending) {
+      request.reject(error51);
+    }
+  }
+  notify(method, params) {
+    this.writeFrame({
+      jsonrpc: "2.0",
+      method,
+      ...params !== void 0 ? { params } : {}
+    });
+  }
+  writeFrame(frame) {
+    const proc = this.proc;
+    if (!proc || proc.stdin.destroyed) {
+      return;
+    }
+    proc.stdin.write(`${JSON.stringify(frame)}
+`);
+  }
+  allocRequestId() {
+    const id = this.nextRequestId;
+    this.nextRequestId += 1;
+    return id;
+  }
+  requireThreadId() {
+    if (this.threadId === null) {
+      throw new Error("Codex session has no active thread");
+    }
+    return this.threadId;
+  }
+};
+function userTextInput(text) {
+  return { type: "text", text, text_elements: [] };
+}
+function threadIdFromResult(result) {
+  if (result === null || typeof result !== "object") {
+    return null;
+  }
+  const thread = result.thread;
+  if (thread === null || typeof thread !== "object") {
+    return null;
+  }
+  const id = thread.id;
+  return typeof id === "string" && id.length > 0 ? id : null;
+}
+function errorMessage2(error51) {
+  return error51 instanceof Error ? error51.message : String(error51);
+}
+
+// src/commands/agent-bridge/harness/codex/index.ts
+function createCodexCommandHandler(input) {
+  return new CodexCommandHandler({
+    ...input,
+    sessionResume: input.sessionResume ?? fileCodexThreadResumeStore()
+  });
+}
+var CodexCommandHandler = class {
+  constructor(input) {
+    this.input = input;
+    this.outputBuffer = new AgentBridgeOutputBuffer(input);
+  }
+  input;
+  context = null;
+  session = null;
+  injectedCommands = /* @__PURE__ */ new Set();
+  // itemId -> JSON-RPC request id of the parked approval request, so an `answer`
+  // command keyed by toolCallId (= itemId) can resolve the right server request.
+  pendingApprovals = /* @__PURE__ */ new Map();
+  outputBuffer;
+  projector = new CodexProjector();
+  // ---------------------------------------------------------------------------
+  // Lifecycle (public API)
+  // ---------------------------------------------------------------------------
+  setContext(nextContext) {
+    this.context = RuntimeBridgeConnectedPayloadSchema.parse(nextContext);
+  }
+  async replayPendingOutputs() {
+    await this.outputBuffer.replayPendingOutputs();
+  }
+  async prepare() {
+    await this.ensureSession().prepare();
+  }
+  shutdown() {
+    this.session?.close();
+    this.session = null;
+    this.pendingApprovals.clear();
+  }
+  async handleCommand(rawDelivery) {
+    const delivery = RuntimeBridgeCommandDeliverySchema.parse(rawDelivery);
+    const socketId = this.input.socketId?.();
+    const activeContext = this.context;
+    if (!activeContext || delivery.sessionId !== activeContext.sessionId || delivery.runtimeId !== activeContext.runtimeId || delivery.bridgeLeaseId !== activeContext.bridgeLeaseId) {
+      return commandAck({ delivery, socketId, status: "stale_lease" });
+    }
+    if (this.injectedCommands.has(delivery.commandId)) {
+      return commandAck({ delivery, socketId, status: "duplicate" });
+    }
+    if (delivery.kind === "answer") {
+      return this.handleAnswerCommand(delivery, activeContext, socketId);
+    }
+    if (delivery.kind === "stop") {
+      this.injectedCommands.add(delivery.commandId);
+      this.shutdown();
+      return commandAck({ delivery, socketId, status: "injected" });
+    }
+    if (delivery.kind !== "message") {
+      return commandAck({
+        delivery,
+        socketId,
+        status: "failed",
+        error: `Unsupported command kind: ${delivery.kind}`
+      });
+    }
+    const message = deliveryMessage2(delivery);
+    if (message === null) {
+      return commandAck({
+        delivery,
+        socketId,
+        status: "failed",
+        error: "Message command payload must include a string message"
+      });
+    }
+    this.injectedCommands.add(delivery.commandId);
+    try {
+      await this.emitUserMessageEntry(
+        activeContext,
+        delivery.commandId,
+        message
+      );
+      await this.ensureSession().sendMessage(message, {
+        mode: deliveryMode2(delivery)
+      });
+    } catch (error51) {
+      this.injectedCommands.delete(delivery.commandId);
+      return commandAck({
+        delivery,
+        socketId,
+        status: "failed",
+        error: errorMessage3(error51)
+      });
+    }
+    return commandAck({ delivery, socketId, status: "injected" });
+  }
+  // ---------------------------------------------------------------------------
+  // Answering parked approvals
+  // ---------------------------------------------------------------------------
+  async handleAnswerCommand(delivery, activeContext, socketId) {
+    const payload = RuntimeBridgeAnswerCommandPayloadSchema.safeParse(
+      delivery.payload
+    );
+    if (!payload.success) {
+      return commandAck({
+        delivery,
+        socketId,
+        status: "failed",
+        error: "Answer command payload must include toolCallId and answers"
+      });
+    }
+    this.injectedCommands.add(delivery.commandId);
+    const requestId = this.pendingApprovals.get(payload.data.toolCallId);
+    try {
+      if (requestId !== void 0) {
+        this.pendingApprovals.delete(payload.data.toolCallId);
+        const decision = codexApprovalDecision({
+          answers: payload.data.answers,
+          ...payload.data.response ? { response: payload.data.response } : {}
+        });
+        this.ensureSession().resolveApproval({ requestId, decision });
+        this.input.writeOutput?.(
+          `agent_bridge_codex_question_answered tool_use_id=${payload.data.toolCallId} decision=${decision}`
+        );
+      } else {
+        const message = answerFallbackMessage2(payload.data);
+        await this.emitUserMessageEntry(
+          activeContext,
+          delivery.commandId,
+          message
+        );
+        await this.ensureSession().sendMessage(message);
+      }
+    } catch (error51) {
+      this.injectedCommands.delete(delivery.commandId);
+      return commandAck({
+        delivery,
+        socketId,
+        status: "failed",
+        error: errorMessage3(error51)
+      });
+    }
+    return commandAck({ delivery, socketId, status: "injected" });
+  }
+  // ---------------------------------------------------------------------------
+  // Session callbacks
+  // ---------------------------------------------------------------------------
+  async emitUserMessageEntry(activeContext, commandId, message) {
+    await this.emit(activeContext, {
+      type: "entry",
+      entry: {
+        messageId: commandId,
+        role: "user",
+        kind: "message",
+        status: "completed",
+        content: { parts: [{ type: "text", text: message }] }
+      }
+    });
+  }
+  async handleNotification(notification) {
+    const activeContext = this.context;
+    if (!activeContext) {
+      return;
+    }
+    for (const projection of this.projector.project(notification)) {
+      await this.emit(activeContext, projection);
+    }
+  }
+  async handleServerRequest(request) {
+    const activeContext = this.context;
+    if (!activeContext) {
+      return;
+    }
+    this.pendingApprovals.set(request.itemId, request.requestId);
+    this.input.writeOutput?.(
+      `agent_bridge_codex_question_pending tool_use_id=${request.itemId}`
+    );
+    await this.emit(activeContext, this.projector.projectApproval(request));
+  }
+  async handleSessionError(error51) {
+    this.input.writeOutput?.(
+      `agent_bridge_codex_session_failed error=${errorMessage3(error51)}`
+    );
+    const activeContext = this.context;
+    if (!activeContext) {
+      return;
+    }
+    await this.emit(
+      activeContext,
+      this.projector.projectSessionFailure(errorMessage3(error51))
+    );
+  }
+  async emit(activeContext, projection) {
+    try {
+      await this.outputBuffer.emitProjection(activeContext, projection);
+    } catch (error51) {
+      this.input.writeOutput?.(
+        `agent_bridge_output_emit_failed error=${errorMessage3(error51)}`
+      );
+    }
+  }
+  ensureSession() {
+    if (this.session) {
+      return this.session;
+    }
+    const resumeThreadId = this.storedResumeThreadId();
+    const session = codexAgentBridgeRuntime.start({
+      codex: this.input.codex,
+      ...resumeThreadId ? { resumeThreadId } : {},
+      onNotification: (notification) => this.handleNotification(notification),
+      onServerRequest: (request) => this.handleServerRequest(request),
+      onThreadId: (threadId) => this.persistThreadId(threadId),
+      onError: (error51) => this.handleSessionError(error51),
+      onExit: () => {
+        if (this.session === session) {
+          this.session = null;
+        }
+        this.input.writeOutput?.("agent_bridge_codex_session_exited");
+      },
+      ...this.input.writeOutput ? { writeOutput: this.input.writeOutput } : {}
+    });
+    this.session = session;
+    return session;
+  }
+  storedResumeThreadId() {
+    const store = this.input.sessionResume;
+    const activeContext = this.context;
+    if (!store || !activeContext) {
+      return void 0;
+    }
+    try {
+      return store.read(activeContext.sessionId) ?? void 0;
+    } catch (error51) {
+      this.input.writeOutput?.(
+        `agent_bridge_codex_thread_read_failed error=${errorMessage3(error51)}`
+      );
+      return void 0;
+    }
+  }
+  persistThreadId(threadId) {
+    const store = this.input.sessionResume;
+    const activeContext = this.context;
+    if (!store || !activeContext) {
+      return;
+    }
+    try {
+      store.write({ sessionId: activeContext.sessionId, threadId });
+    } catch (error51) {
+      this.input.writeOutput?.(
+        `agent_bridge_codex_thread_persist_failed error=${errorMessage3(error51)}`
+      );
+    }
+  }
+};
+function answerFallbackMessage2(answer) {
+  const lines = Object.entries(answer.answers).map(
+    ([question, value2]) => `- ${question}: ${value2}`
+  );
+  if (answer.response) {
+    lines.push(`The user also responded: ${answer.response}`);
+  }
+  return ["The user answered your questions:", ...lines].join("\n");
+}
+function deliveryMessage2(delivery) {
+  const payload = delivery.payload;
+  if (payload && typeof payload === "object" && "message" in payload && typeof payload.message === "string") {
+    return payload.message;
+  }
+  return null;
+}
+function deliveryMode2(delivery) {
+  const payload = delivery.payload;
+  if (payload && typeof payload === "object" && "deliveryMode" in payload) {
+    const parsed = MessageDeliveryModeSchema.safeParse(payload.deliveryMode);
+    if (parsed.success) {
+      return parsed.data;
+    }
+  }
+  return "interrupt";
+}
+function errorMessage3(error51) {
+  return error51 instanceof Error ? error51.message : String(error51);
+}
+
 // src/commands/agent-bridge/harness/index.ts
 async function runAgentBridgeHarness(options) {
   await runAgentBridgeSocket({
@@ -48491,6 +49713,14 @@ function createHarnessCommandHandler(input) {
         sessionResume: fileClaudeSessionResumeStore()
       });
     }
+    case "codex": {
+      const { kind, ...codex } = config2;
+      return createCodexCommandHandler({
+        ...base,
+        codex,
+        sessionResume: fileCodexThreadResumeStore()
+      });
+    }
   }
 }
 function resolveHarnessConfig(bootstrap) {