@autohq/cli 0.1.224 → 0.1.226

package/dist/index.js

@@ -15261,6 +15261,7 @@ var init_auth = __esm({
       "github:mcp",
       "github:credentials",
       "mcp:connection",
+      "runtime-logs:write",
       "projects:admin",
       "org:admin"
     ]);
@@ -15965,12 +15966,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 errorMessage4 = isError ? record2.error ?? record2.result ?? (sdkErrorMessage || void 0) ?? "claude-code reported an error" : void 0;
+  const errorMessage6 = isError ? record2.error ?? record2.result ?? (sdkErrorMessage || void 0) ?? "claude-code reported an error" : void 0;
   return {
     projections: [],
     result: {
       isError,
-      errorMessage: errorMessage4
+      errorMessage: errorMessage6
     }
   };
 }
@@ -16199,7 +16200,249 @@ var init_claude_code = __esm({
 });
 
 // ../../packages/schemas/src/codex.ts
-var CodexRequestIdSchema, CodexTurnStatusSchema, CodexUserMessageItemSchema, CodexAgentMessageItemSchema, CodexReasoningItemSchema, CodexCommandExecutionItemSchema, CodexFileChangeItemSchema, CodexMcpToolCallItemSchema, CodexItemSchema, OptionalCodexItemSchema, CodexItemEnvelopeSchema, CodexTurnEnvelopeSchema, CodexFrameSchema;
+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] }
+      ]
+    }
+  };
+}
+function codexApprovalDecision(input) {
+  const values = [...Object.values(input.answers), input.response ?? ""];
+  const approved = values.some(
+    (value) => value.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";
+}
+var CodexRequestIdSchema, CodexTurnStatusSchema, CodexUserMessageItemSchema, CodexAgentMessageItemSchema, CodexReasoningItemSchema, CodexCommandExecutionItemSchema, CodexFileChangeItemSchema, CodexMcpToolCallItemSchema, CodexItemSchema, OptionalCodexItemSchema, CodexItemEnvelopeSchema, CodexTurnEnvelopeSchema, CodexFrameSchema, APPROVE_OPTION_LABEL, DECLINE_OPTION_LABEL;
 var init_codex = __esm({
   "../../packages/schemas/src/codex.ts"() {
     "use strict";
@@ -16280,6 +16523,8 @@ var init_codex = __esm({
       result: external_exports.unknown().optional(),
       error: external_exports.object({ message: external_exports.string().optional() }).passthrough().optional()
     }).passthrough();
+    APPROVE_OPTION_LABEL = "Approve";
+    DECLINE_OPTION_LABEL = "Decline";
   }
 });
 
@@ -19112,21 +19357,6 @@ var init_setup = __esm({
   }
 });
 
-// ../../packages/schemas/src/e2b-webhook.ts
-var E2bLifecycleWebhookEventSchema;
-var init_e2b_webhook = __esm({
-  "../../packages/schemas/src/e2b-webhook.ts"() {
-    "use strict";
-    init_zod();
-    E2bLifecycleWebhookEventSchema = external_exports.object({
-      type: external_exports.string().min(1),
-      sandbox_id: external_exports.string().min(1),
-      sandbox_execution_id: external_exports.string().optional(),
-      timestamp: external_exports.string().optional()
-    }).passthrough();
-  }
-});
-
 // ../../packages/schemas/src/runtime-log.ts
 function parseRuntimeLogLevel(value) {
   const parsed = RuntimeLogLevelSchema.safeParse(value?.trim());
@@ -19135,16 +19365,28 @@ function parseRuntimeLogLevel(value) {
 function runtimeLogLevelEnabled(configured, lineLevel) {
   return LEVEL_SEVERITY[lineLevel] >= LEVEL_SEVERITY[configured];
 }
-var RUNTIME_LOG_LEVELS, RuntimeLogLevelSchema, DEFAULT_RUNTIME_LOG_LEVEL, SANDBOX_RUNTIME_LOG_DIR, SANDBOX_RUNTIME_LOG_PATH, LEVEL_SEVERITY;
+var RUNTIME_LOG_LEVELS, RuntimeLogLevelSchema, RUNTIME_LOG_INGEST_URL_ENV, RUNTIME_LOG_INGEST_TOKEN_ENV, DEFAULT_RUNTIME_LOG_LEVEL, SANDBOX_RUNTIME_LOG_DIR, SANDBOX_RUNTIME_LOG_PATH, RuntimeLogIngestLineSchema, RuntimeLogIngestRequestSchema, LEVEL_SEVERITY;
 var init_runtime_log = __esm({
   "../../packages/schemas/src/runtime-log.ts"() {
     "use strict";
     init_zod();
     RUNTIME_LOG_LEVELS = ["debug", "info", "warn", "error"];
     RuntimeLogLevelSchema = external_exports.enum(RUNTIME_LOG_LEVELS);
+    RUNTIME_LOG_INGEST_URL_ENV = "AUTO_RUNTIME_LOG_INGEST_URL";
+    RUNTIME_LOG_INGEST_TOKEN_ENV = "AUTO_RUNTIME_LOG_INGEST_TOKEN";
     DEFAULT_RUNTIME_LOG_LEVEL = "info";
     SANDBOX_RUNTIME_LOG_DIR = "/home/user/.auto-runtime";
     SANDBOX_RUNTIME_LOG_PATH = `${SANDBOX_RUNTIME_LOG_DIR}/agent-bridge.log`;
+    RuntimeLogIngestLineSchema = external_exports.object({
+      logSeq: external_exports.number().int().positive(),
+      timestamp: external_exports.string().datetime(),
+      level: RuntimeLogLevelSchema,
+      component: external_exports.string().trim().min(1),
+      message: external_exports.string()
+    }).passthrough();
+    RuntimeLogIngestRequestSchema = external_exports.object({
+      lines: external_exports.array(RuntimeLogIngestLineSchema).min(1).max(100)
+    }).strict();
     LEVEL_SEVERITY = {
       debug: 10,
       info: 20,
@@ -19303,7 +19545,6 @@ var init_src = __esm({
     init_secrets();
     init_session_commands();
     init_setup();
-    init_e2b_webhook();
     init_runtime_log();
     init_runtime_log_tailer();
     init_runtimes();
@@ -21997,7 +22238,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.224",
+      version: "0.1.226",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -22061,13 +22302,13 @@ var init_version = __esm({
 });
 
 // src/commands/agents/authoring.ts
-import { readFileSync as readFileSync3, readdirSync as readdirSync2, statSync } from "fs";
+import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync } from "fs";
 import {
   basename as basename2,
-  dirname as dirname4,
+  dirname as dirname5,
   extname,
   isAbsolute,
-  join as join3,
+  join as join5,
   resolve
 } from "path";
 import { parseAllDocuments as parseYamlDocuments, stringify } from "yaml";
@@ -22119,8 +22360,8 @@ function renderAgentExplain(result) {
   return lines.join("\n");
 }
 function readLocalAgentAuthoringStatuses(input) {
-  const agentsDirectory = join3(
-    input?.directory ?? join3(process.cwd(), ".auto"),
+  const agentsDirectory = join5(
+    input?.directory ?? join5(process.cwd(), ".auto"),
     "agents"
   );
   const paths = agentAuthoringFiles(agentsDirectory);
@@ -22159,7 +22400,7 @@ function agentAuthoringFiles(directory) {
   }
   const files = [];
   for (const entry of entries) {
-    const path2 = join3(directory, entry.name);
+    const path2 = join5(directory, entry.name);
     if (entry.isDirectory()) {
       files.push(...agentAuthoringFiles(path2));
       continue;
@@ -22179,12 +22420,12 @@ function resolveAgentAuthoringPath(input) {
   if (isAgentFile(candidate)) {
     return candidate;
   }
-  const agentsDirectory = join3(
-    input.directory ?? join3(process.cwd(), ".auto"),
+  const agentsDirectory = join5(
+    input.directory ?? join5(process.cwd(), ".auto"),
     "agents"
   );
   for (const extension of AGENT_FILE_EXTENSIONS) {
-    const path2 = join3(agentsDirectory, `${input.agent}${extension}`);
+    const path2 = join5(agentsDirectory, `${input.agent}${extension}`);
     if (isAgentFile(path2)) {
       return path2;
     }
@@ -22242,7 +22483,7 @@ function readSingleDocument(path2) {
   return documents[0];
 }
 function readDocuments(path2) {
-  const source = readFileSync3(path2, "utf8");
+  const source = readFileSync4(path2, "utf8");
   const documents = parseYamlDocuments(source);
   const parseError = documents.flatMap((document) => document.errors).at(0);
   if (parseError) {
@@ -22267,7 +22508,7 @@ function resolveImportPath(importPath, importerPath) {
   if (isAbsolute(importPath) || /^[A-Za-z]+:\/\//.test(importPath)) {
     throw new Error(`Agent import must be a relative path: ${importPath}`);
   }
-  const resolved = resolve(dirname4(importerPath), importPath);
+  const resolved = resolve(dirname5(importerPath), importPath);
   if (!isAgentFile(resolved)) {
     throw new Error(
       `Agent import not found: ${importPath} from ${importerPath}`
@@ -22442,7 +22683,7 @@ function resolveFileBackedString(value, input) {
       `Invalid agent authoring file ${input.path}: ${input.field}.file must be a relative path`
     );
   }
-  return readFileSync3(resolve(dirname4(input.path), filePath), "utf8");
+  return readFileSync4(resolve(dirname5(input.path), filePath), "utf8");
 }
 function removalDirectives(document, path2) {
   const raw = isRecord(document.remove) ? document.remove : {};
@@ -24022,18 +24263,18 @@ var init_project_apply_files2 = __esm({
 
 // src/commands/apply/files.ts
 import {
-  existsSync as existsSync3,
-  readFileSync as readFileSync4,
+  existsSync as existsSync4,
+  readFileSync as readFileSync5,
   readdirSync as readdirSync3,
   realpathSync,
   statSync as statSync2
 } from "fs";
 import {
   basename as basename3,
-  dirname as dirname5,
+  dirname as dirname6,
   extname as extname3,
   isAbsolute as isAbsolute2,
-  join as join5,
+  join as join7,
   relative,
   resolve as resolve2
 } from "path";
@@ -24062,7 +24303,7 @@ function readProjectApplyBundleInput(options) {
       }
     };
   }
-  const directory = resolve2(options.directory ?? join5(process.cwd(), ".auto"));
+  const directory = resolve2(options.directory ?? join7(process.cwd(), ".auto"));
   const projectRoot = applyProjectRoot(directory);
   const files = sourceFiles(directory, projectRoot);
   const resourceRoot = sourcePathRelative(projectRoot, directory);
@@ -24093,7 +24334,7 @@ function sourceFiles(root, projectRoot) {
     return [];
   }
   return entries.flatMap((entry) => {
-    const path2 = join5(root, entry.name);
+    const path2 = join7(root, entry.name);
     if (entry.isDirectory()) {
       return sourceFiles(path2, projectRoot);
     }
@@ -24106,7 +24347,7 @@ function sourceFiles(root, projectRoot) {
 function sourceFile(path2, projectRoot) {
   return {
     path: sourcePathRelative(projectRoot, path2),
-    contentBase64: readFileSync4(path2).toString("base64")
+    contentBase64: readFileSync5(path2).toString("base64")
   };
 }
 function applyBundle(files) {
@@ -24140,24 +24381,24 @@ function filesystemAssetReader(projectRoot) {
     });
     return {
       path: path2,
-      bytes: readFileSync4(path2)
+      bytes: readFileSync5(path2)
     };
   };
 }
 function applyProjectRoot(directory) {
   const resolved = resolve2(directory);
-  return basename3(resolved) === ".auto" ? dirname5(resolved) : resolved;
+  return basename3(resolved) === ".auto" ? dirname6(resolved) : resolved;
 }
 function applyFileProjectRoot(file2) {
-  let dir = dirname5(resolve2(file2));
+  let dir = dirname6(resolve2(file2));
   while (true) {
     if (basename3(dir) === ".auto") {
-      return dirname5(dir);
+      return dirname6(dir);
     }
     if (directoryHasAutoRoot(dir)) {
       return dir;
     }
-    const parent = dirname5(dir);
+    const parent = dirname6(dir);
     if (parent === dir) {
       return process.cwd();
     }
@@ -24166,11 +24407,11 @@ function applyFileProjectRoot(file2) {
 }
 function applyFileSourceRoot(file2, projectRoot) {
   const autoRoot = resolve2(projectRoot, ".auto");
-  return file2 === autoRoot || isInside(file2, autoRoot) ? autoRoot : dirname5(file2);
+  return file2 === autoRoot || isInside(file2, autoRoot) ? autoRoot : dirname6(file2);
 }
 function directoryHasAutoRoot(directory) {
   const autoRoot = resolve2(directory, ".auto");
-  if (!existsSync3(autoRoot)) {
+  if (!existsSync4(autoRoot)) {
     return false;
   }
   return statSync2(autoRoot).isDirectory();
@@ -24761,16 +25002,16 @@ var init_resources3 = __esm({
 });
 
 // src/commands/edit/actions.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import {
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync5,
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync6
 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 import { parseAllDocuments as parseYamlDocuments3, stringify as stringify4 } from "yaml";
 async function editResource(input) {
   const reference = parseProjectResourceReference(input.resource);
@@ -24790,15 +25031,15 @@ async function editResource(input) {
   const document = editableAgentFacade(current);
   const source = `${stringify4(document).trimEnd()}
 `;
-  const tempRoot = mkdtempSync2(join6(tmpdir2(), "auto-edit-"));
-  const agentsDir = join6(tempRoot, ".auto", "agents");
-  mkdirSync3(agentsDir, { recursive: true });
-  const filePath = join6(agentsDir, `${reference.name}.yaml`);
-  writeFileSync4(filePath, source, "utf8");
+  const tempRoot = mkdtempSync2(join8(tmpdir2(), "auto-edit-"));
+  const agentsDir = join8(tempRoot, ".auto", "agents");
+  mkdirSync5(agentsDir, { recursive: true });
+  const filePath = join8(agentsDir, `${reference.name}.yaml`);
+  writeFileSync6(filePath, source, "utf8");
   let removeTempFile = false;
   try {
     await runEditor(editor, filePath);
-    const editedSource = readFileSync5(filePath, "utf8");
+    const editedSource = readFileSync6(filePath, "utf8");
     if (editedSource === source) {
       input.writeOutput("No changes; skipped apply.");
       removeTempFile = true;
@@ -24841,7 +25082,7 @@ function resolveEditor(input) {
 }
 async function runEditor(editor, filePath) {
   await new Promise((resolve4, reject) => {
-    const child = spawn2(editor, [filePath], {
+    const child = spawn3(editor, [filePath], {
       shell: true,
       stdio: "inherit"
     });
@@ -24864,7 +25105,7 @@ async function runEditor(editor, filePath) {
   });
 }
 function assertEditedResourceIdentity(filePath, expected) {
-  const source = readFileSync5(filePath, "utf8");
+  const source = readFileSync6(filePath, "utf8");
   let parsedDocuments;
   try {
     parsedDocuments = parseYamlDocuments3(source);
@@ -27986,7 +28227,7 @@ function SessionsView({
     visibleSessions.map((session, vi) => {
       const i = scrollOffset + vi;
       const title = sessionDisplayTitle(session);
-      const err = session.status === "failed" ? errorMessage2(session) : null;
+      const err = session.status === "failed" ? errorMessage4(session) : null;
       const isSelected = i === safeIndex;
       const isMarked = selectedSessionIds.has(session.id);
       return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
@@ -28124,7 +28365,7 @@ function truncateToWidth(value, width) {
 function agentNameForRun(session) {
   return session.snapshot.metadata.name;
 }
-function errorMessage2(session) {
+function errorMessage4(session) {
   if (session.error == null) return null;
   if (typeof session.error === "string") return session.error;
   const msg = readField(session.error, "message");
@@ -29546,7 +29787,7 @@ function HomeView({ apiUrl, notice, returnToAgent }) {
   if (inspectedResource) {
     sectionTitle = `Inspect ${inspectedResource.kind}/${inspectedResource.name}`;
   }
-  const runError = errorMessage3(triggerSession.error) ?? errorMessage3(archiveSessions.error) ?? errorMessage3(unarchiveSessions.error) ?? errorMessage3(stopSessions.error);
+  const runError = errorMessage5(triggerSession.error) ?? errorMessage5(archiveSessions.error) ?? errorMessage5(unarchiveSessions.error) ?? errorMessage5(stopSessions.error);
   const isRunMutationPending = triggerSession.isPending || archiveSessions.isPending || unarchiveSessions.isPending || stopSessions.isPending;
   const isConnectionMutationPending = startConnection.isPending || allowConnection.isPending || removeConnection.isPending || createGithubSyncBinding.isPending;
   const serviceAccountStatus = createServiceAccount2.error instanceof Error ? createServiceAccount2.error.message : rotateServiceAccount2.error instanceof Error ? rotateServiceAccount2.error.message : removeServiceAccount2.error instanceof Error ? removeServiceAccount2.error.message : serviceAccountNotice;
@@ -29959,7 +30200,7 @@ function runActionTargetLabel(sessionIds, markedRunCount) {
 function pluralizeRunCount(count) {
   return `${count} ${count === 1 ? "session" : "sessions"}`;
 }
-function errorMessage3(error51) {
+function errorMessage5(error51) {
   if (error51 instanceof Error) return error51.message;
   return error51 ? String(error51) : null;
 }
@@ -30280,8 +30521,8 @@ __export(launcher_exports, {
   launch: () => launch
 });
 import { spawnSync } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import { dirname as dirname6, resolve as resolve3 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { dirname as dirname7, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 import {
   QueryClient,
@@ -30458,7 +30699,7 @@ function resolveSplashVersion() {
   return resolveLatestReleaseVersionFromCheckout() ?? cliVersion;
 }
 function resolveLatestReleaseVersionFromCheckout() {
-  const repoRoot = findRepoRoot(dirname6(fileURLToPath(import.meta.url)));
+  const repoRoot = findRepoRoot(dirname7(fileURLToPath(import.meta.url)));
   if (!repoRoot) {
     return null;
   }
@@ -30475,10 +30716,10 @@ function resolveLatestReleaseVersionFromCheckout() {
 function findRepoRoot(startDirectory) {
   let directory = startDirectory;
   while (true) {
-    if (existsSync5(resolve3(directory, ".git")) && existsSync5(resolve3(directory, "apps/cli/package.json"))) {
+    if (existsSync6(resolve3(directory, ".git")) && existsSync6(resolve3(directory, "apps/cli/package.json"))) {
       return directory;
     }
-    const parent = dirname6(directory);
+    const parent = dirname7(directory);
     if (parent === directory) {
       return null;
     }
@@ -31479,6 +31720,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({
@@ -33600,112 +33844,1184 @@ function commandLogContext(delivery, fields = {}) {
   };
 }
 
-// src/commands/agent-bridge/harness/index.ts
-async function runAgentBridgeHarness(options) {
-  await runAgentBridgeSocket({
-    ...options,
-    createHandler: createHarnessCommandHandler
+// src/commands/agent-bridge/harness/codex/index.ts
+init_src();
+
+// src/commands/agent-bridge/harness/codex/projector.ts
+init_src();
+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 createHarnessCommandHandler(input) {
-  const config2 = resolveHarnessConfig(input.bootstrap);
-  const base = {
-    emitOutput: input.emitOutput,
-    ...input.outputSeqStart !== void 0 ? { outputSeqStart: input.outputSeqStart } : {},
-    ...input.runtimeLogger ? { runtimeLogger: input.runtimeLogger } : {},
-    socketId: input.socketId,
-    ...input.writeOutput ? { writeOutput: input.writeOutput } : {}
+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 }] }
+    }
   };
-  switch (config2.kind) {
-    case "claude-code": {
-      const { kind, ...claude } = config2;
-      return createClaudeCodeCommandHandler({
-        ...base,
-        claude,
-        sessionResume: fileClaudeSessionResumeStore()
-      });
+}
+
+// src/commands/agent-bridge/harness/codex/resume-store.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4 } 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 (!existsSync2(path2)) {
+        return null;
+      }
+      const record2 = parseResumeRecord2(readFileSync3(path2, "utf8"));
+      if (!record2 || record2.sessionId !== sessionId) {
+        return null;
+      }
+      return record2.threadId;
+    },
+    write(record2) {
+      mkdirSync3(dirname4(path2), { recursive: true });
+      writeFileSync3(path2, `${JSON.stringify(record2)}
+`, "utf8");
     }
-  }
+  };
 }
-function resolveHarnessConfig(bootstrap) {
-  return bootstrap.harness ?? { kind: "claude-code", ...bootstrap.claude };
+function parseResumeRecord2(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (value !== null && typeof value === "object" && "sessionId" in value && "threadId" in value && typeof value.sessionId === "string" && typeof value.threadId === "string" && value.threadId.length > 0) {
+      return { sessionId: value.sessionId, threadId: value.threadId };
+    }
+    return null;
+  } catch {
+    return null;
+  }
 }
 
-// src/commands/agent-bridge/runtime-log.ts
+// src/commands/agent-bridge/harness/codex/session.ts
 init_src();
-var RUNTIME_LOG_COMPONENT = "runtime-cli";
-function createRuntimeLogger(env = process.env) {
-  const level = parseRuntimeLogLevel(env.AUTO_RUNTIME_LOG_LEVEL);
-  const emit = (lineLevel) => {
-    return (message, context) => {
-      if (!runtimeLogLevelEnabled(level, lineLevel)) {
-        return;
-      }
-      writeRuntimeLogLine(lineLevel, message, context);
-    };
+import { spawn as spawn2 } from "child_process";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/commands/agent-bridge/harness/codex/options.ts
+import { join as join3 } 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 {
-    level,
-    debug: emit("debug"),
-    info: emit("info"),
-    warn: emit("warn"),
-    error: emit("error")
+    ...config2.cwd ? { cwd: config2.cwd } : {},
+    ...config2.systemPromptAppend ? { developerInstructions: config2.systemPromptAppend } : {}
   };
 }
-function writeRuntimeLogLine(level, message, context) {
-  const payload = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    level,
-    component: RUNTIME_LOG_COMPONENT,
-    message,
-    ...context ?? {}
+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 value = process.env[key];
+    if (value !== void 0) {
+      selected[key] = value;
+    }
+  }
+  return {
+    ...selected,
+    ...env
   };
-  process.stderr.write(`${JSON.stringify(payload, replaceErrors)}
-`);
 }
-function replaceErrors(_key, value) {
-  if (value instanceof Error) {
-    return { name: value.name, message: value.message, stack: value.stack };
+function codexHomeDir() {
+  const home = process.env.HOME;
+  if (!home) {
+    throw new Error("codex launch requires HOME to locate the ~/.codex home");
   }
-  return value;
+  return join3(home, ".codex");
 }
-
-// src/commands/agent-bridge/entrypoint.ts
-async function runAgentBridgeProcess(input) {
-  const runAgentBridge = input.runAgentBridge ?? runAgentBridgeHarness;
-  const log = createRuntimeLogger(input.env);
-  log.info("agent bridge process starting", {
-    bridge_url_host: bridgeUrlHost(input.env.AUTO_BRIDGE_URL),
-    log_level: log.level
-  });
-  try {
-    await runAgentBridge({
-      ...agentBridgeOptionsFromEnv(input),
-      runtimeLogger: log,
-      onBootstrap: createGitCredentialRelayStarter(input.writeOutput, log)
-    });
-  } catch (error51) {
-    log.error("agent bridge process failed", { error: error51 });
-    throw error51;
+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 agentBridgeOptionsFromEnv(input) {
-  return {
-    bridgeUrl: requiredEnv(input.env, "AUTO_BRIDGE_URL"),
-    token: requiredEnv(input.env, "AGENT_BRIDGE_TOKEN"),
-    writeOutput: input.writeOutput
-  };
+function tomlInlineTable(values) {
+  const entries = Object.entries(values).map(
+    ([key, value]) => `${tomlKey(key)} = ${tomlString(value)}`
+  );
+  return `{ ${entries.join(", ")} }`;
 }
-function createGitCredentialRelayStarter(writeOutput, log) {
-  let relay;
-  let startup;
-  return async (bootstrap) => {
-    const gitCredentials = bootstrap.gitCredentials;
-    if (!gitCredentials) {
-      return;
-    }
-    if (relay) {
-      relay.update(gitCredentials);
+function tomlKey(key) {
+  return /^[A-Za-z0-9_-]+$/.test(key) ? key : tomlString(key);
+}
+function tomlString(value) {
+  return `"${value.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 });
+    writeFileSync4(join4(options.codexHome, "config.toml"), options.configToml);
+    const startedAt = Date.now();
+    this.input.writeOutput?.(
+      `agent_bridge_codex_startup_started codex_home=${options.codexHome}`
+    );
+    const proc = spawn2(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((resolve4) => {
+      let done = false;
+      const finish = () => {
+        if (done) {
+          return;
+        }
+        done = true;
+        clearTimeout(timer);
+        this.settlementWaiters.delete(waiter);
+        resolve4();
+      };
+      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((resolve4, reject) => {
+      this.pending.set(id, { resolve: resolve4, 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, value]) => `- ${question}: ${value}`
+  );
+  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({
+    ...options,
+    createHandler: createHarnessCommandHandler
+  });
+}
+function createHarnessCommandHandler(input) {
+  const config2 = resolveHarnessConfig(input.bootstrap);
+  const base = {
+    emitOutput: input.emitOutput,
+    ...input.outputSeqStart !== void 0 ? { outputSeqStart: input.outputSeqStart } : {},
+    ...input.runtimeLogger ? { runtimeLogger: input.runtimeLogger } : {},
+    socketId: input.socketId,
+    ...input.writeOutput ? { writeOutput: input.writeOutput } : {}
+  };
+  switch (config2.kind) {
+    case "claude-code": {
+      const { kind, ...claude } = config2;
+      return createClaudeCodeCommandHandler({
+        ...base,
+        claude,
+        sessionResume: fileClaudeSessionResumeStore()
+      });
+    }
+    case "codex": {
+      const { kind, ...codex } = config2;
+      return createCodexCommandHandler({
+        ...base,
+        codex,
+        sessionResume: fileCodexThreadResumeStore()
+      });
+    }
+  }
+}
+function resolveHarnessConfig(bootstrap) {
+  return bootstrap.harness ?? { kind: "claude-code", ...bootstrap.claude };
+}
+
+// src/commands/agent-bridge/runtime-log.ts
+init_src();
+var RUNTIME_LOG_COMPONENT = "runtime-cli";
+var INGEST_BATCH_SIZE = 50;
+var INGEST_FLUSH_DELAY_MS = 1e3;
+var INGEST_MAX_QUEUED_LINES = 1e3;
+function createRuntimeLogger(env = process.env) {
+  const level = parseRuntimeLogLevel(env.AUTO_RUNTIME_LOG_LEVEL);
+  const ingest = createRuntimeLogIngest(env);
+  let nextLogSeq = 1;
+  const emit = (lineLevel) => {
+    return (message, context) => {
+      if (!runtimeLogLevelEnabled(level, lineLevel)) {
+        return;
+      }
+      const line = runtimeLogLine({
+        context,
+        level: lineLevel,
+        logSeq: nextLogSeq,
+        message
+      });
+      nextLogSeq += 1;
+      writeRuntimeLogLine(line);
+      ingest?.enqueue(line);
+    };
+  };
+  return {
+    level,
+    debug: emit("debug"),
+    info: emit("info"),
+    warn: emit("warn"),
+    error: emit("error")
+  };
+}
+function runtimeLogLine(input) {
+  return {
+    ...input.context ?? {},
+    logSeq: input.logSeq,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level: input.level,
+    component: RUNTIME_LOG_COMPONENT,
+    message: input.message
+  };
+}
+function writeRuntimeLogLine(payload) {
+  process.stderr.write(`${JSON.stringify(payload, replaceErrors)}
+`);
+}
+function createRuntimeLogIngest(env) {
+  const url2 = env[RUNTIME_LOG_INGEST_URL_ENV]?.trim();
+  const token2 = env[RUNTIME_LOG_INGEST_TOKEN_ENV]?.trim();
+  if (!url2 || !token2) {
+    return void 0;
+  }
+  const queue = [];
+  let flushTimer;
+  let inFlight = false;
+  const scheduleFlush = () => {
+    if (flushTimer || inFlight) {
+      return;
+    }
+    flushTimer = setTimeout(() => {
+      flushTimer = void 0;
+      void flush();
+    }, INGEST_FLUSH_DELAY_MS);
+    flushTimer.unref?.();
+  };
+  const flush = async () => {
+    if (inFlight || queue.length === 0) {
+      return;
+    }
+    inFlight = true;
+    const batch = queue.splice(0, INGEST_BATCH_SIZE);
+    try {
+      const response = await fetch(url2, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${token2}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ lines: batch }, replaceErrors)
+      });
+      if (!response.ok) {
+        if (shouldRetryIngestResponse(response)) {
+          requeue(batch);
+        }
+      }
+    } catch {
+      requeue(batch);
+    } finally {
+      inFlight = false;
+      if (queue.length > 0) {
+        scheduleFlush();
+      }
+    }
+  };
+  const requeue = (batch) => {
+    queue.unshift(...batch);
+    trimQueue();
+  };
+  const trimQueue = () => {
+    if (queue.length > INGEST_MAX_QUEUED_LINES) {
+      queue.splice(0, queue.length - INGEST_MAX_QUEUED_LINES);
+    }
+  };
+  return {
+    enqueue(line) {
+      queue.push(line);
+      trimQueue();
+      scheduleFlush();
+    }
+  };
+}
+function shouldRetryIngestResponse(response) {
+  return response.status === 429 || response.status >= 500;
+}
+function replaceErrors(_key, value) {
+  if (value instanceof Error) {
+    return { name: value.name, message: value.message, stack: value.stack };
+  }
+  return value;
+}
+
+// src/commands/agent-bridge/entrypoint.ts
+async function runAgentBridgeProcess(input) {
+  const runAgentBridge = input.runAgentBridge ?? runAgentBridgeHarness;
+  const log = createRuntimeLogger(input.env);
+  log.info("agent bridge process starting", {
+    bridge_url_host: bridgeUrlHost(input.env.AUTO_BRIDGE_URL),
+    log_level: log.level
+  });
+  try {
+    await runAgentBridge({
+      ...agentBridgeOptionsFromEnv(input),
+      runtimeLogger: log,
+      onBootstrap: createGitCredentialRelayStarter(input.writeOutput, log)
+    });
+  } catch (error51) {
+    log.error("agent bridge process failed", { error: error51 });
+    throw error51;
+  }
+}
+function agentBridgeOptionsFromEnv(input) {
+  return {
+    bridgeUrl: requiredEnv(input.env, "AUTO_BRIDGE_URL"),
+    token: requiredEnv(input.env, "AGENT_BRIDGE_TOKEN"),
+    writeOutput: input.writeOutput
+  };
+}
+function createGitCredentialRelayStarter(writeOutput, log) {
+  let relay;
+  let startup;
+  return async (bootstrap) => {
+    const gitCredentials = bootstrap.gitCredentials;
+    if (!gitCredentials) {
+      return;
+    }
+    if (relay) {
+      relay.update(gitCredentials);
       return;
     }
     if (startup) {
@@ -33825,9 +35141,9 @@ function statusAgents(input) {
 // src/commands/agents/connect.ts
 init_resources2();
 init_browser();
-import { existsSync as existsSync2, mkdtempSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3, mkdtempSync, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir3, tmpdir } from "os";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 
 // src/lib/stdio/secret.ts
 async function questionSecret(context, prompt) {
@@ -34018,7 +35334,7 @@ async function promptForIconUploads(input, options) {
   }
 }
 function stagedLocationLabel(stagedPath) {
-  return stagedPath.startsWith(`${join4(homedir3(), "Downloads")}/`) ? "Downloads" : "the printed path";
+  return stagedPath.startsWith(`${join6(homedir3(), "Downloads")}/`) ? "Downloads" : "the printed path";
 }
 async function stageAvatarImage(input) {
   try {
@@ -34030,10 +35346,10 @@ async function stageAvatarImage(input) {
     }
     const contentType = response.headers.get("content-type") ?? "";
     const extension = contentType.includes("jpeg") ? ".jpg" : ".png";
-    const downloads = join4(homedir3(), "Downloads");
-    const directory = existsSync2(downloads) ? downloads : mkdtempSync(join4(tmpdir(), "auto-avatar-"));
-    const path2 = join4(directory, `${input.agent}-avatar${extension}`);
-    writeFileSync3(path2, Buffer.from(await response.arrayBuffer()));
+    const downloads = join6(homedir3(), "Downloads");
+    const directory = existsSync3(downloads) ? downloads : mkdtempSync(join6(tmpdir(), "auto-avatar-"));
+    const path2 = join6(directory, `${input.agent}-avatar${extension}`);
+    writeFileSync5(path2, Buffer.from(await response.arrayBuffer()));
     return path2;
   } catch {
     return void 0;
@@ -35497,19 +36813,19 @@ init_src();
 // src/commands/logs/actions.ts
 import {
   closeSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   openSync,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   readSync,
   statSync as statSync3
 } from "fs";
 var DEFAULT_POLL_INTERVAL_MS = 1e3;
 async function tailRuntimeLog(input) {
-  if (!existsSync4(input.path)) {
+  if (!existsSync5(input.path)) {
     input.writeError(`No runtime log at ${input.path}`);
     return;
   }
-  const content = readFileSync6(input.path, "utf8");
+  const content = readFileSync7(input.path, "utf8");
   for (const line of selectLastLines(content, input.lines)) {
     input.writeOutput(line);
   }