@meet-ai/cli 0.0.35 → 0.0.36

package/dist/index.js

@@ -14390,6 +14390,100 @@ var init_zod = __esm(() => {
   init_external();
 });
 
+// src/lib/codex.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+function getCodexHome(options) {
+  if (options?.codexHome)
+    return options.codexHome;
+  if (options?.env?.CODEX_HOME)
+    return options.env.CODEX_HOME;
+  if (process.env.CODEX_HOME)
+    return process.env.CODEX_HOME;
+  if (process.env.MEET_AI_CODEX_STATE_DIR)
+    return process.env.MEET_AI_CODEX_STATE_DIR;
+  return join(homedir(), ".codex");
+}
+function getCodexConfigPaths(options) {
+  const home = getCodexHome(options);
+  return [
+    resolve(".codex/config.json"),
+    resolve(".codex/config.toml"),
+    join(home, "config.json"),
+    join(home, "config.toml")
+  ];
+}
+function parseCodexTomlEnv(path) {
+  if (!existsSync(path))
+    return null;
+  const env = {};
+  let inEnvSection = false;
+  for (const line of readFileSync(path, "utf-8").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      inEnvSection = trimmed === "[env]";
+      continue;
+    }
+    if (!inEnvSection)
+      continue;
+    const match = trimmed.match(/^([A-Z0-9_]+)\s*=\s*"([^"]*)"$/);
+    if (!match)
+      continue;
+    env[match[1]] = match[2];
+  }
+  return Object.keys(env).length > 0 ? env : null;
+}
+function readCodexConfigEnv(options) {
+  for (const path of getCodexConfigPaths(options)) {
+    if (!existsSync(path))
+      continue;
+    if (path.endsWith(".json")) {
+      try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (parsed.env && Object.keys(parsed.env).length > 0) {
+          return parsed.env;
+        }
+      } catch {
+        continue;
+      }
+      continue;
+    }
+    const env = parseCodexTomlEnv(path);
+    if (env)
+      return env;
+  }
+  return null;
+}
+function getInboxPath(sessionId, options) {
+  return join(getCodexHome(options), "meet-ai", "inbox", `${sessionId}.json`);
+}
+function appendCodexInboxEntry(sessionId, entry, options) {
+  const path = getInboxPath(sessionId, options);
+  mkdirSync(dirname(path), { recursive: true });
+  let entries = [];
+  try {
+    entries = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    entries = [];
+  }
+  entries.push(entry);
+  writeFileSync(path, `${JSON.stringify(entries, null, 2)}
+`);
+  return path;
+}
+var init_codex = () => {};
+
+// src/runtime.ts
+function getMeetAiRuntime(env = process.env) {
+  const raw = env.MEET_AI_RUNTIME?.trim().toLowerCase();
+  if (raw === "codex")
+    return "codex";
+  return "claude";
+}
+
 // src/config.ts
 var exports_config = {};
 __export(exports_config, {
@@ -14397,15 +14491,15 @@ __export(exports_config, {
   getMeetAiConfig: () => getMeetAiConfig,
   configSchema: () => configSchema
 });
-import { readFileSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { homedir } from "node:os";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
 function loadSettingsFromPath(path) {
   try {
-    if (!existsSync(path)) {
+    if (!existsSync2(path)) {
       return null;
     }
-    const content = readFileSync(path, "utf-8");
+    const content = readFileSync2(path, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -14418,7 +14512,16 @@ function resolveRawConfig(opts) {
       key: process.env.MEET_AI_KEY
     };
   }
-  const projectSettingsPath = opts?.projectSettingsPath ?? resolve("./.claude/settings.json");
+  if (getMeetAiRuntime() === "codex") {
+    const codexEnv = readCodexConfigEnv({ codexHome: opts?.codexHome });
+    if (codexEnv?.MEET_AI_URL) {
+      return {
+        url: codexEnv.MEET_AI_URL,
+        key: codexEnv.MEET_AI_KEY
+      };
+    }
+  }
+  const projectSettingsPath = opts?.projectSettingsPath ?? resolve2("./.claude/settings.json");
   const projectSettings = loadSettingsFromPath(projectSettingsPath);
   if (projectSettings?.env?.MEET_AI_URL) {
     return {
@@ -14426,7 +14529,7 @@ function resolveRawConfig(opts) {
       key: projectSettings.env.MEET_AI_KEY
     };
   }
-  const userSettingsPath = join(opts?.homeDir ?? homedir(), ".claude/settings.json");
+  const userSettingsPath = join2(opts?.homeDir ?? homedir2(), ".claude/settings.json");
   const userSettings = loadSettingsFromPath(userSettingsPath);
   if (userSettings?.env?.MEET_AI_URL) {
     return {
@@ -14450,6 +14553,7 @@ function getMeetAiConfig(opts) {
 var configSchema;
 var init_config = __esm(() => {
   init_zod();
+  init_codex();
   configSchema = exports_external.object({
     url: exports_external.string().url("MEET_AI_URL must be a valid URL"),
     key: exports_external.string().optional()
@@ -14483,7 +14587,7 @@ async function withRetry(fn, options) {
         delay_ms: delay,
         error: lastError.message
       }));
-      await new Promise((resolve2) => setTimeout(resolve2, delay));
+      await new Promise((resolve3) => setTimeout(resolve3, delay));
     }
   }
   throw lastError;
@@ -14583,6 +14687,18 @@ class HttpTransport {
   }
 }
 
+// src/coding-agents.ts
+function isCodingAgentId(value) {
+  return CODING_AGENT_DEFINITIONS.some((agent) => agent.id === value);
+}
+var CODING_AGENT_DEFINITIONS;
+var init_coding_agents = __esm(() => {
+  CODING_AGENT_DEFINITIONS = [
+    { id: "claude", label: "Claude Code" },
+    { id: "codex", label: "Codex" }
+  ];
+});
+
 // src/domain/adapters/ConnectionAdapter.ts
 function wsLog(data) {
   const json2 = JSON.stringify({ ...data, ts: new Date().toISOString() });
@@ -14754,7 +14870,8 @@ class ConnectionAdapter {
             options?.onRoomCreated?.(data.id, data.name);
           }
           if (data.type === "spawn_request" && data.room_name) {
-            options?.onSpawnRequest?.(data.room_name);
+            const codingAgent = typeof data.coding_agent === "string" && isCodingAgentId(data.coding_agent) ? data.coding_agent : "claude";
+            options?.onSpawnRequest?.({ roomName: data.room_name, codingAgent });
           }
         } catch {}
       };
@@ -14775,31 +14892,34 @@ class ConnectionAdapter {
     return this.transport.postJson("/api/keys");
   }
 }
+var init_ConnectionAdapter = __esm(() => {
+  init_coding_agents();
+});
 
 // src/domain/adapters/FileSystemAdapter.ts
 import {
-  readFileSync as readFileSync2,
-  writeFileSync,
-  mkdirSync,
-  existsSync as existsSync2,
-  statSync
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync3,
+  statSync as statSync2
 } from "node:fs";
 
 class FileSystemAdapter {
   readFileSync(path, encoding) {
-    return readFileSync2(path, encoding);
+    return readFileSync3(path, encoding);
   }
   writeFileSync(path, data, encoding) {
-    writeFileSync(path, data, encoding);
+    writeFileSync2(path, data, encoding);
   }
   mkdirSync(path, opts) {
-    mkdirSync(path, opts);
+    mkdirSync2(path, opts);
   }
   existsSync(path) {
-    return existsSync2(path);
+    return existsSync3(path);
   }
   statSync(path) {
-    const stat = statSync(path);
+    const stat = statSync2(path);
     return { mtimeMs: stat.mtimeMs, size: stat.size };
   }
 }
@@ -14979,7 +15099,7 @@ class SendTerminalData {
 }
 
 // src/domain/services/InboxRouter.ts
-import { dirname } from "node:path";
+import { dirname as dirname2 } from "node:path";
 
 class InboxRouter {
   fs;
@@ -15002,7 +15122,7 @@ class InboxRouter {
       for (const target of targets) {
         this.appendToInbox(`${opts.inboxDir}/${target}.json`, entry);
       }
-    } else if (opts.stdinPane) {} else if (opts.defaultInboxPath) {
+    } else if (opts.defaultInboxPath) {
       this.appendToInbox(opts.defaultInboxPath, entry);
     }
   }
@@ -15022,7 +15142,7 @@ class InboxRouter {
     }
   }
   appendToInbox(path, entry) {
-    this.fs.mkdirSync(dirname(path), { recursive: true });
+    this.fs.mkdirSync(dirname2(path), { recursive: true });
     let messages = [];
     try {
       messages = JSON.parse(this.fs.readFileSync(path, "utf-8"));
@@ -15150,12 +15270,12 @@ __export(exports_bootstrap, {
 });
 function cleanupOldAttachments() {
   try {
-    const { readdirSync, statSync: statSync2, unlinkSync } = __require("node:fs");
+    const { readdirSync: readdirSync2, statSync: statSync3, unlinkSync } = __require("node:fs");
     const now = Date.now();
-    for (const entry of readdirSync(ATTACHMENTS_DIR)) {
+    for (const entry of readdirSync2(ATTACHMENTS_DIR)) {
       try {
         const filePath = `${ATTACHMENTS_DIR}/${entry}`;
-        const mtime = statSync2(filePath).mtimeMs;
+        const mtime = statSync3(filePath).mtimeMs;
         if (now - mtime > MAX_AGE_MS) {
           unlinkSync(filePath);
         }
@@ -15211,12 +15331,12 @@ function getClient() {
     downloadAttachment: async (attachmentId) => {
       cleanupOldAttachments();
       const response = await c.downloadAttachment.execute(attachmentId);
-      const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("node:fs");
-      mkdirSync2(ATTACHMENTS_DIR, { recursive: true });
+      const { mkdirSync: mkdirSync3, writeFileSync: writeFileSync3 } = await import("node:fs");
+      mkdirSync3(ATTACHMENTS_DIR, { recursive: true });
       const safeId = attachmentId.replace(/[^a-zA-Z0-9_-]/g, "") || "unknown";
       const localPath = `${ATTACHMENTS_DIR}/${safeId}.bin`;
       const buffer = Buffer.from(await response.arrayBuffer());
-      writeFileSync2(localPath, buffer);
+      writeFileSync3(localPath, buffer);
       return localPath;
     },
     listenLobby: (options) => c.listenLobby.execute(options),
@@ -15228,6 +15348,7 @@ function getClient() {
 var ATTACHMENTS_DIR = "/tmp/meet-ai-attachments", MAX_AGE_MS, container = null;
 var init_bootstrap = __esm(() => {
   init_config();
+  init_ConnectionAdapter();
   init_FileSystemAdapter();
   init_MessageRepository();
   init_RoomRepository();
@@ -15643,29 +15764,28 @@ var init_command5 = __esm(() => {
   });
 });
 
+// src/inbox-router.ts
+var IDLE_CHECK_INTERVAL_MS = 60000, IDLE_THRESHOLD_MS2;
+var init_inbox_router = __esm(() => {
+  IDLE_THRESHOLD_MS2 = 5 * 60 * 1000;
+});
+
 // src/commands/listen/schema.ts
 var ListenInput;
 var init_schema6 = __esm(() => {
   init_zod();
   ListenInput = exports_external.object({
-    roomId: exports_external.string().min(1, "Room ID is required").regex(/^[a-zA-Z0-9_-]+$/, "Room ID must contain only alphanumeric characters, hyphens, and underscores"),
+    roomId: exports_external.uuid({ error: "Room ID must be a valid uuid" }),
     exclude: exports_external.string().optional(),
     senderType: exports_external.string().optional(),
     team: exports_external.string().optional(),
-    inbox: exports_external.string().optional(),
-    stdinPane: exports_external.string().optional()
+    inbox: exports_external.string().optional()
   }).refine((data) => !(data.inbox && !data.team), {
     message: "--inbox requires --team",
     path: ["inbox"]
   });
 });
 
-// src/inbox-router.ts
-var IDLE_CHECK_INTERVAL_MS = 60000, IDLE_THRESHOLD_MS2;
-var init_inbox_router = __esm(() => {
-  IDLE_THRESHOLD_MS2 = 5 * 60 * 1000;
-});
-
 // src/lib/tmux-client.ts
 import { execFileSync, execFile as execFileCb } from "node:child_process";
 function validateSessionName(name) {
@@ -15696,6 +15816,9 @@ class TmuxClient {
         timeout: 5000,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
+      if (!result) {
+        return { available: false, version: null, error: "tmux returned an empty version string" };
+      }
       return { available: true, version: result };
     } catch (error48) {
       return {
@@ -15707,11 +15830,7 @@ class TmuxClient {
   }
   newSession(name, commandArgs, env) {
     validateSessionName(name);
-    if (env) {
-      for (const [key, value] of Object.entries(env)) {
-        this.exec(["-L", this.server, "set-environment", "-g", key, value]);
-      }
-    }
+    const envArgs = env ? ["env", ...Object.entries(env).map(([key, value]) => `${key}=${value}`)] : [];
     const args = [
       "-L",
       this.server,
@@ -15724,14 +15843,10 @@ class TmuxClient {
       "-y",
       "40",
       "--",
+      ...envArgs,
       ...commandArgs
     ];
     const result = this.exec(args);
-    if (env) {
-      for (const key of Object.keys(env)) {
-        this.exec(["-L", this.server, "set-environment", "-g", "-u", key]);
-      }
-    }
     if (!result.ok)
       return result;
     this.exec(["-L", this.server, "set-option", "-t", name, "remain-on-exit", "on"]);
@@ -15771,13 +15886,13 @@ class TmuxClient {
       "-F",
       "#{pane_id}\t#{session_name}\t#{pane_title}\t#{pane_current_command}"
     ];
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       execFileCb("tmux", args, { encoding: "utf8", timeout: 5000 }, (error48, stdout) => {
         if (error48) {
-          resolve2([]);
+          resolve3([]);
           return;
         }
-        resolve2(stdout.trim().split(`
+        resolve3(stdout.trim().split(`
 `).filter((line) => line.trim()).map((line) => {
           const [paneId, sessionName, title, command] = line.split("\t");
           return { paneId: paneId ?? "", sessionName: sessionName ?? "", title: title ?? "", command: command ?? "" };
@@ -15830,10 +15945,10 @@ class TmuxClient {
     if (lines > 0) {
       args.push("-S", `-${lines}`);
     }
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       execFileCb("tmux", args, { encoding: "utf8", timeout: 5000 }, (error48, stdout) => {
         if (error48) {
-          resolve2([]);
+          resolve3([]);
           return;
         }
         const result = stdout.split(`
@@ -15841,7 +15956,7 @@ class TmuxClient {
         while (result.length > 0 && result[result.length - 1] === "") {
           result.pop();
         }
-        resolve2(result);
+        resolve3(result);
       });
     });
   }
@@ -15885,16 +16000,12 @@ var init_tmux_client = __esm(() => {
   SESSION_NAME_RE = /^[a-zA-Z0-9_-]+$/;
 });
 
-// src/commands/listen/usecase.ts
-function listen(client, input, inboxRouter) {
-  const parsed = ListenInput.parse(input);
-  const { roomId, exclude, senderType, team, inbox, stdinPane } = parsed;
-  const inboxDir = team ? `${process.env.HOME}/.claude/teams/${team}/inboxes` : null;
-  const defaultInboxPath = inboxDir && inbox ? `${inboxDir}/${inbox}.json` : null;
-  const teamDir = team ? `${process.env.HOME}/.claude/teams/${team}` : null;
+// src/commands/listen/shared.ts
+function createTerminalControlHandler(input) {
+  const { client, roomId, teamDir } = input;
   const tmuxClient = new TmuxClient({ server: "meet-ai", scrollback: 50000 });
   let terminalInterval = null;
-  const onMessage = (msg) => {
+  function handle(msg) {
     if (msg.type === "terminal_resize") {
       const cols = msg.cols;
       if (typeof cols === "number" && cols > 0) {
@@ -15906,7 +16017,7 @@ function listen(client, input, inboxRouter) {
           }
         });
       }
-      return;
+      return true;
     }
     if (msg.type === "terminal_subscribe") {
       const roomPrefix = roomId.slice(0, 8);
@@ -15959,29 +16070,61 @@ function listen(client, input, inboxRouter) {
           await client.sendTerminalData(roomId, payload);
         } catch {}
       }, TERMINAL_POLL_MS);
-      return;
+      return true;
     }
     if (msg.type === "terminal_unsubscribe") {
       if (terminalInterval) {
         clearInterval(terminalInterval);
         terminalInterval = null;
       }
-      return;
+      return true;
     }
     if (msg.type === "terminal_data") {
-      return;
+      return true;
+    }
+    return false;
+  }
+  function shutdown() {
+    if (terminalInterval) {
+      clearInterval(terminalInterval);
+      terminalInterval = null;
     }
-    if (msg.id && msg.room_id && msg.attachment_count > 0) {
+  }
+  return { handle, shutdown };
+}
+var init_shared = __esm(() => {
+  init_tmux_client();
+});
+
+// src/commands/listen/listen-claude.ts
+function listenClaude(client, input, inboxRouter) {
+  const parsed = ListenInput.parse(input);
+  const { roomId, exclude, senderType, team, inbox } = parsed;
+  const inboxDir = team ? `${process.env.HOME}/.claude/teams/${team}/inboxes` : null;
+  const defaultInboxPath = inboxDir && inbox ? `${inboxDir}/${inbox}.json` : null;
+  const teamDir = team ? `${process.env.HOME}/.claude/teams/${team}` : undefined;
+  const terminal = createTerminalControlHandler({ client, roomId, teamDir, inboxRouter });
+  const onMessage = (msg) => {
+    if (terminal.handle(msg))
+      return;
+    if (msg.id && msg.room_id && (msg.attachment_count ?? 0) > 0) {
       downloadMessageAttachments(client, msg.room_id, msg.id).then((paths) => {
         const output = paths.length ? { ...msg, attachments: paths } : msg;
         console.log(JSON.stringify(output));
-        if (inboxDir && teamDir && inboxRouter)
-          inboxRouter.route(msg, { inboxDir, defaultInboxPath, teamDir, stdinPane, attachmentPaths: paths });
+        if (inboxDir && teamDir && inboxRouter) {
+          inboxRouter.route(msg, {
+            inboxDir,
+            defaultInboxPath,
+            teamDir,
+            attachmentPaths: paths
+          });
+        }
       });
-    } else {
-      console.log(JSON.stringify(msg));
-      if (inboxDir && teamDir && inboxRouter)
-        inboxRouter.route(msg, { inboxDir, defaultInboxPath, teamDir, stdinPane });
+      return;
+    }
+    console.log(JSON.stringify(msg));
+    if (inboxDir && teamDir && inboxRouter) {
+      inboxRouter.route(msg, { inboxDir, defaultInboxPath, teamDir });
     }
   };
   const ws = client.listen(roomId, { exclude, senderType, onMessage });
@@ -15990,7 +16133,13 @@ function listen(client, input, inboxRouter) {
   if (inboxDir && inbox && teamDir && inboxRouter) {
     let scheduleIdleCheck = function() {
       idleCheckTimeout = setTimeout(() => {
-        inboxRouter.checkIdle({ inboxDir, teamDir, inbox, defaultInboxPath, notified: idleNotified });
+        inboxRouter.checkIdle({
+          inboxDir,
+          teamDir,
+          inbox,
+          defaultInboxPath: defaultInboxPath ?? null,
+          notified: idleNotified
+        });
         scheduleIdleCheck();
       }, IDLE_CHECK_INTERVAL_MS);
     };
@@ -15999,10 +16148,621 @@ function listen(client, input, inboxRouter) {
   function shutdown() {
     if (idleCheckTimeout)
       clearTimeout(idleCheckTimeout);
-    if (terminalInterval) {
-      clearInterval(terminalInterval);
-      terminalInterval = null;
+    terminal.shutdown();
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.close(1000, "client shutdown");
+    }
+    process.exit(0);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("SIGHUP", shutdown);
+  return ws;
+}
+var init_listen_claude = __esm(() => {
+  init_inbox_router();
+  init_schema6();
+  init_shared();
+});
+
+// src/lib/codex-app-server.ts
+import {
+  spawn
+} from "node:child_process";
+import { stderr } from "node:process";
+import { createInterface } from "node:readline";
+function isObject2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isJsonRpcResponse(value) {
+  return isObject2(value) && "id" in value && (("result" in value) || ("error" in value));
+}
+function isJsonRpcServerRequest(value) {
+  return isObject2(value) && typeof value.method === "string" && "id" in value && !("result" in value) && !("error" in value);
+}
+function isJsonRpcNotification(value) {
+  return isObject2(value) && typeof value.method === "string" && !("id" in value);
+}
+function toErrorMessage(error48) {
+  if (error48 instanceof Error)
+    return error48.message;
+  return String(error48);
+}
+function formatRoomMessageForCodex(input) {
+  const lines = [
+    `New message from meet-ai sender "${input.sender}" at ${input.timestamp ?? new Date().toISOString()}:`,
+    "",
+    input.content
+  ];
+  if (input.attachments?.length) {
+    lines.push("", `Attachments: ${input.attachments.join(", ")}`);
+  }
+  return lines.join(`
+`);
+}
+function maybeActiveTurnId(thread) {
+  if (!thread || !Array.isArray(thread.turns))
+    return null;
+  for (let index = thread.turns.length - 1;index >= 0; index -= 1) {
+    const turn = thread.turns[index];
+    if (turn?.status === "inProgress" && typeof turn.id === "string") {
+      return turn.id;
+    }
+  }
+  return null;
+}
+function isSteerPreconditionError(error48) {
+  if (!isObject2(error48))
+    return false;
+  const message = typeof error48.message === "string" ? error48.message.toLowerCase() : "";
+  return message.includes("expected") || message.includes("active turn") || message.includes("precondition");
+}
+function isAgentMessageDeltaNotification(params) {
+  return isObject2(params) && typeof params.threadId === "string" && typeof params.turnId === "string" && typeof params.itemId === "string" && typeof params.delta === "string";
+}
+function extractAgentMessageDelta(params) {
+  if (!isAgentMessageDeltaNotification(params)) {
+    return { itemId: null, turnId: null, text: null };
+  }
+  return {
+    itemId: params.itemId,
+    turnId: params.turnId,
+    text: params.delta
+  };
+}
+function isItemCompletedNotification(params) {
+  return isObject2(params) && typeof params.threadId === "string" && typeof params.turnId === "string" && isObject2(params.item) && typeof params.item.type === "string" && typeof params.item.id === "string";
+}
+function extractCompletedAgentMessage(params) {
+  if (!isItemCompletedNotification(params))
+    return null;
+  if (params.item.type !== "agentMessage")
+    return null;
+  return {
+    itemId: params.item.id,
+    turnId: params.turnId,
+    text: params.item.text
+  };
+}
+function isThreadStartedNotification(params) {
+  return isObject2(params) && isObject2(params.thread) && typeof params.thread.id === "string";
+}
+function isTurnStartedNotification(params) {
+  return isObject2(params) && typeof params.threadId === "string" && isObject2(params.turn) && typeof params.turn.id === "string";
+}
+function isTurnCompletedNotification(params) {
+  return isObject2(params) && typeof params.threadId === "string" && isObject2(params.turn) && typeof params.turn.id === "string";
+}
+
+class CodexAppServerBridge {
+  threadId;
+  cwd;
+  codexBin;
+  clientName;
+  clientTitle;
+  clientVersion;
+  experimentalApi;
+  env;
+  spawnFn;
+  stderrStream;
+  child = null;
+  stdoutReader = null;
+  readyPromise = null;
+  pendingRequests = new Map;
+  nextRequestId = 1;
+  activeTurnId = null;
+  injectionQueue = Promise.resolve();
+  eventHandler = null;
+  constructor(options) {
+    this.threadId = options.threadId ?? null;
+    this.cwd = options.cwd;
+    this.codexBin = options.codexBin ?? options.env?.MEET_AI_CODEX_PATH ?? process.env.MEET_AI_CODEX_PATH ?? "codex";
+    this.clientName = options.clientName ?? "meet_ai";
+    this.clientTitle = options.clientTitle ?? "meet-ai CLI";
+    this.clientVersion = options.clientVersion ?? "0.0.0";
+    this.experimentalApi = options.experimentalApi ?? false;
+    this.env = options.env ?? process.env;
+    this.spawnFn = options.spawnFn ?? spawn;
+    this.stderrStream = options.stderr ?? stderr;
+  }
+  async start() {
+    if (!this.readyPromise) {
+      this.readyPromise = this.startInternal().catch((error48) => {
+        this.readyPromise = null;
+        throw error48;
+      });
+    }
+    return this.readyPromise;
+  }
+  async injectText(input) {
+    const text = formatRoomMessageForCodex(input);
+    return this.injectPrompt(text);
+  }
+  async injectPrompt(text) {
+    return this.enqueue(async () => {
+      await this.start();
+      const payload = [{ type: "text", text, text_elements: [] }];
+      const threadId = this.threadId;
+      if (!threadId) {
+        throw new Error("Codex app-server bridge does not have an active thread");
+      }
+      if (this.activeTurnId) {
+        try {
+          const result2 = await this.request("turn/steer", {
+            threadId,
+            input: payload,
+            expectedTurnId: this.activeTurnId
+          });
+          this.activeTurnId = result2.turnId;
+          return { mode: "steer", threadId, turnId: result2.turnId };
+        } catch (error48) {
+          if (!isSteerPreconditionError(error48))
+            throw error48;
+          this.activeTurnId = null;
+        }
+      }
+      const result = await this.request("turn/start", {
+        threadId,
+        input: payload
+      });
+      this.activeTurnId = result.turn.id;
+      return { mode: "start", threadId, turnId: result.turn.id };
+    });
+  }
+  getThreadId() {
+    return this.threadId;
+  }
+  async close() {
+    this.readyPromise = null;
+    this.activeTurnId = null;
+    if (this.stdoutReader) {
+      this.stdoutReader.close();
+      this.stdoutReader = null;
+    }
+    const child = this.child;
+    this.child = null;
+    if (!child)
+      return;
+    for (const pending of this.pendingRequests.values()) {
+      pending.reject(new Error("Codex app-server bridge closed"));
+    }
+    this.pendingRequests.clear();
+    child.kill();
+  }
+  setEventHandler(handler) {
+    this.eventHandler = handler;
+  }
+  enqueue(fn) {
+    const next = this.injectionQueue.then(fn, fn);
+    this.injectionQueue = next.catch(() => {
+      return;
+    });
+    return next;
+  }
+  async startInternal() {
+    const child = this.spawnFn(this.codexBin, [
+      "app-server",
+      "--enable",
+      "multi_agent",
+      "--enable",
+      "memories",
+      "--enable",
+      "realtime_conversation",
+      "-c",
+      'sandbox_mode="workspace-write"',
+      "-c",
+      "sandbox_workspace_write.network_access=true",
+      "-c",
+      'web_search="live"',
+      "--listen",
+      "stdio://"
+    ], {
+      cwd: this.cwd,
+      env: this.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    this.stdoutReader = createInterface({ input: child.stdout });
+    this.stdoutReader.on("line", (line) => {
+      this.handleLine(line);
+    });
+    child.stderr.on("data", (chunk) => {
+      this.stderrStream.write(chunk);
+    });
+    child.on("exit", (_code, signal) => {
+      const reason = new Error(`codex app-server exited${signal ? ` with signal ${signal}` : ""}`);
+      for (const pending of this.pendingRequests.values()) {
+        pending.reject(reason);
+      }
+      this.pendingRequests.clear();
+      this.child = null;
+      this.stdoutReader = null;
+      this.readyPromise = null;
+    });
+    await this.request("initialize", {
+      clientInfo: {
+        name: this.clientName,
+        title: this.clientTitle,
+        version: this.clientVersion
+      },
+      capabilities: {
+        experimentalApi: this.experimentalApi
+      }
+    });
+    this.notify("initialized");
+    if (this.threadId) {
+      const resumeParams = {
+        threadId: this.threadId,
+        persistExtendedHistory: this.experimentalApi
+      };
+      try {
+        const resumeResult = await this.request("thread/resume", resumeParams);
+        this.threadId = typeof resumeResult.thread?.id === "string" ? resumeResult.thread.id : this.threadId;
+        this.activeTurnId = maybeActiveTurnId(resumeResult.thread);
+        return;
+      } catch {
+        this.stderrStream.write(`meet-ai: codex app-server could not resume thread ${this.threadId}, starting fresh
+`);
+        this.threadId = null;
+        this.activeTurnId = null;
+      }
+    }
+    const startResult = await this.request("thread/start", {
+      cwd: this.cwd,
+      experimentalRawEvents: false,
+      persistExtendedHistory: this.experimentalApi
+    });
+    this.threadId = typeof startResult.thread?.id === "string" ? startResult.thread.id : null;
+    this.activeTurnId = maybeActiveTurnId(startResult.thread);
+  }
+  async handleLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return;
+    let message;
+    try {
+      message = JSON.parse(trimmed);
+    } catch {
+      this.stderrStream.write(`meet-ai: failed to parse codex app-server line: ${trimmed}
+`);
+      return;
+    }
+    if (isJsonRpcResponse(message)) {
+      const pending = this.pendingRequests.get(message.id);
+      if (!pending)
+        return;
+      this.pendingRequests.delete(message.id);
+      if (message.error) {
+        pending.reject(new Error(message.error.message ?? "Unknown app-server error"));
+        return;
+      }
+      pending.resolve(message.result);
+      return;
+    }
+    if (isJsonRpcServerRequest(message)) {
+      this.respondToServerRequest(message);
+      return;
+    }
+    if (isJsonRpcNotification(message)) {
+      this.handleNotification(message);
+    }
+  }
+  handleNotification(message) {
+    if (message.method === "thread/started") {
+      if (isThreadStartedNotification(message.params))
+        this.threadId = message.params.thread.id;
+      return;
+    }
+    if (message.method === "turn/started") {
+      if (isTurnStartedNotification(message.params) && message.params.threadId === this.threadId) {
+        this.activeTurnId = message.params.turn.id;
+      }
+      return;
+    }
+    if (message.method === "turn/completed") {
+      if (isTurnCompletedNotification(message.params) && message.params.threadId === this.threadId && message.params.turn.id === this.activeTurnId) {
+        this.activeTurnId = null;
+      }
+      this.emitEvent({
+        type: "turn_completed",
+        turnId: isTurnCompletedNotification(message.params) ? message.params.turn.id : null
+      });
+      return;
+    }
+    if (message.method === "item/agentMessage/delta") {
+      const event = extractAgentMessageDelta(message.params);
+      if (event.text) {
+        this.emitEvent({
+          type: "agent_message_delta",
+          itemId: event.itemId,
+          turnId: event.turnId,
+          text: event.text
+        });
+      }
+      return;
+    }
+    if (message.method === "item/completed") {
+      const event = extractCompletedAgentMessage(message.params);
+      if (event?.text) {
+        this.emitEvent({
+          type: "agent_message_completed",
+          itemId: event.itemId,
+          turnId: event.turnId,
+          text: event.text
+        });
+      }
+    }
+  }
+  emitEvent(event) {
+    if (!this.eventHandler)
+      return;
+    try {
+      this.eventHandler(event);
+    } catch (error48) {
+      this.stderrStream.write(`meet-ai: codex app-server event handler failed: ${toErrorMessage(error48)}
+`);
+    }
+  }
+  respondToServerRequest(message) {
+    switch (message.method) {
+      case "item/commandExecution/requestApproval": {
+        this.stderrStream.write(`meet-ai: auto-resolving unsupported codex app-server request ${message.method}
+`);
+        this.writeMessage({ id: message.id, result: { decision: "decline" } });
+        return;
+      }
+      case "item/fileChange/requestApproval": {
+        this.stderrStream.write(`meet-ai: auto-resolving unsupported codex app-server request ${message.method}
+`);
+        this.writeMessage({ id: message.id, result: { decision: "decline" } });
+        return;
+      }
+      case "item/tool/requestUserInput": {
+        this.stderrStream.write(`meet-ai: auto-resolving unsupported codex app-server request ${message.method}
+`);
+        this.writeMessage({ id: message.id, result: { answers: {} } });
+        return;
+      }
+      case "mcpServer/elicitation/request": {
+        this.stderrStream.write(`meet-ai: auto-resolving unsupported codex app-server request ${message.method}
+`);
+        this.writeMessage({ id: message.id, result: { action: "cancel", content: null } });
+        return;
+      }
+      case "applyPatchApproval": {
+        this.stderrStream.write(`meet-ai: auto-resolving unsupported codex app-server request ${message.method}
+`);
+        this.writeMessage({ id: message.id, result: { decision: "denied" } });
+        return;
+      }
+      case "execCommandApproval": {
+        this.stderrStream.write(`meet-ai: auto-resolving unsupported codex app-server request ${message.method}
+`);
+        this.writeMessage({ id: message.id, result: { decision: "denied" } });
+        return;
+      }
+      default: {
+        this.stderrStream.write(`meet-ai: rejecting unsupported codex app-server request ${message.method}
+`);
+        this.writeMessage({
+          id: message.id,
+          error: {
+            message: `meet-ai app-server bridge does not support ${message.method}`
+          }
+        });
+      }
+    }
+  }
+  notify(method, params) {
+    this.writeMessage(params === undefined ? { method } : { method, params });
+  }
+  request(method, params) {
+    const id = this.nextRequestId++;
+    return new Promise((resolve3, reject) => {
+      this.pendingRequests.set(id, { resolve: resolve3, reject });
+      try {
+        this.writeMessage(params === undefined ? { method, id } : { method, id, params });
+      } catch (error48) {
+        this.pendingRequests.delete(id);
+        reject(error48);
+      }
+    });
+  }
+  writeMessage(message) {
+    const child = this.child;
+    if (!child) {
+      throw new Error("Codex app-server bridge is not connected");
+    }
+    child.stdin.write(`${JSON.stringify(message)}
+`);
+  }
+}
+function createCodexAppServerBridge(options) {
+  return new CodexAppServerBridge(options);
+}
+function describeCodexAppServerError(error48) {
+  return `meet-ai: failed to inject message into Codex via app-server: ${toErrorMessage(error48)}`;
+}
+var init_codex_app_server = () => {};
+
+// src/commands/listen/listen-codex.ts
+function formatCodexListenOutput(msg) {
+  const lines = [
+    `[meet-ai] ${msg.sender} ${msg.created_at ?? new Date().toISOString()}`,
+    msg.content
+  ];
+  if (msg.attachments?.length) {
+    lines.push(`attachments: ${msg.attachments.join(", ")}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function formatCodexInjectionOutput(result) {
+  return `[meet-ai->codex] ${result.mode} ${result.turnId}
+`;
+}
+function isTruthyEnv(value) {
+  if (!value)
+    return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function normalizeFinalText(value) {
+  return value.replace(/\r\n/g, `
+`).trim();
+}
+function makeMessageKey(event) {
+  return event.itemId ?? event.turnId ?? "unknown";
+}
+function listenCodex(client, input, codexBridgeOverride) {
+  const parsed = ListenInput.parse(input);
+  const { roomId, exclude, senderType, team, inbox } = parsed;
+  let shutdownStarted = false;
+  if (team || inbox) {
+    const flags = [team ? "--team" : null, inbox ? "--inbox" : null].filter(Boolean).join(", ");
+    throw new Error(`Codex listen does not support Claude inbox routing flags (${flags}). Run meet-ai listen without Claude-specific routing options.`);
+  }
+  const terminal = createTerminalControlHandler({ client, roomId });
+  const codexBridge = codexBridgeOverride ?? createCodexAppServerBridge({
+    threadId: null,
+    cwd: process.cwd(),
+    experimentalApi: isTruthyEnv(process.env.MEET_AI_CODEX_APP_SERVER_EXPERIMENTAL)
+  });
+  const bootstrapPrompt = process.env.MEET_AI_CODEX_BOOTSTRAP_PROMPT?.trim();
+  const codexSender = process.env.MEET_AI_AGENT_NAME?.trim() || "codex";
+  const messageState = new Map;
+  let publishQueue = Promise.resolve();
+  const enqueuePublish = (task) => {
+    publishQueue = publishQueue.then(task, task).catch((error48) => {
+      console.error(`meet-ai: failed to publish Codex output to room: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    });
+  };
+  const publishBufferedMessage = (key) => {
+    const state = messageState.get(key);
+    const text = normalizeFinalText(state?.text ?? "");
+    if (!state || state.sent || state.sending || !text)
+      return;
+    state.sending = true;
+    enqueuePublish(async () => {
+      try {
+        await client.sendMessage(roomId, codexSender, text);
+        state.sent = true;
+      } finally {
+        state.sending = false;
+      }
+    });
+  };
+  const mergeEventText = (event) => {
+    const key = makeMessageKey(event);
+    const nextText = event.text.replace(/\r\n/g, `
+`);
+    if (!nextText)
+      return;
+    const existing = messageState.get(key);
+    if (!existing) {
+      messageState.set(key, { turnId: event.turnId, text: nextText, sent: false, sending: false });
+      return;
+    }
+    existing.turnId = event.turnId ?? existing.turnId;
+    if (event.type === "agent_message_completed") {
+      existing.text = nextText;
+      return;
+    }
+    existing.text += nextText;
+  };
+  codexBridge.setEventHandler((event) => {
+    if (event.type === "agent_message_delta" || event.type === "agent_message_completed") {
+      mergeEventText(event);
+      if (event.type === "agent_message_completed") {
+        publishBufferedMessage(makeMessageKey(event));
+      }
+      return;
+    }
+    if (event.type === "turn_completed") {
+      for (const [key, state] of messageState.entries()) {
+        if (state.turnId === event.turnId || !event.turnId && !state.sent) {
+          publishBufferedMessage(key);
+        }
+      }
+    }
+  });
+  const injectMessage = (message) => {
+    codexBridge.injectText({
+      sender: message.sender,
+      content: message.content,
+      timestamp: new Date().toISOString(),
+      attachments: message.attachments
+    }).then((result) => {
+      appendCodexInboxEntry(result.threadId, {
+        from: `meet-ai:${message.sender}`,
+        text: message.content,
+        timestamp: new Date().toISOString(),
+        read: false,
+        ...message.attachments?.length ? { attachments: message.attachments } : {}
+      });
+      console.log(formatCodexInjectionOutput(result));
+    }).catch((error48) => {
+      console.error(describeCodexAppServerError(error48));
+    });
+  };
+  const onMessage = (msg) => {
+    if (terminal.handle(msg))
+      return;
+    if (msg.id && msg.room_id && (msg.attachment_count ?? 0) > 0) {
+      downloadMessageAttachments(client, msg.room_id, msg.id).then((paths) => {
+        const output = paths.length ? { ...msg, attachments: paths } : msg;
+        console.log(formatCodexListenOutput(output));
+        injectMessage({
+          sender: msg.sender,
+          content: msg.content,
+          attachments: paths
+        });
+      });
+      return;
     }
+    console.log(formatCodexListenOutput(msg));
+    injectMessage({
+      sender: msg.sender,
+      content: msg.content
+    });
+  };
+  const ws = client.listen(roomId, { exclude, senderType, onMessage });
+  if (bootstrapPrompt) {
+    const bootstrapRequest = codexBridge.injectPrompt(bootstrapPrompt);
+    bootstrapRequest.then((result) => {
+      console.log(formatCodexInjectionOutput(result));
+    }).catch((error48) => {
+      console.error(describeCodexAppServerError(error48));
+    });
+  }
+  function shutdown() {
+    if (shutdownStarted)
+      return;
+    shutdownStarted = true;
+    terminal.shutdown();
+    codexBridge.setEventHandler(null);
+    codexBridge.close();
     if (ws.readyState === WebSocket.OPEN) {
       ws.close(1000, "client shutdown");
     }
@@ -16013,10 +16773,11 @@ function listen(client, input, inboxRouter) {
   process.on("SIGHUP", shutdown);
   return ws;
 }
-var init_usecase6 = __esm(() => {
+var init_listen_codex = __esm(() => {
+  init_codex();
+  init_codex_app_server();
   init_schema6();
-  init_inbox_router();
-  init_tmux_client();
+  init_shared();
 });
 
 // src/commands/listen/command.ts
@@ -16026,10 +16787,11 @@ __export(exports_command6, {
 });
 var command_default6;
 var init_command6 = __esm(() => {
-  init_dist();
   init_bootstrap();
-  init_usecase6();
   init_output();
+  init_dist();
+  init_listen_claude();
+  init_listen_codex();
   command_default6 = defineCommand({
     meta: {
       name: "listen",
@@ -16060,25 +16822,24 @@ var init_command6 = __esm(() => {
         type: "string",
         alias: "i",
         description: "Inbox name for routing (requires --team)"
-      },
-      "stdin-pane": {
-        type: "string",
-        alias: "s",
-        description: "tmux pane ID to inject non-@mention messages into via send-keys"
       }
     },
     run({ args }) {
       try {
         const client = getClient();
         const container2 = getContainer();
-        listen(client, {
+        const input = {
           roomId: args.roomId,
           exclude: args.exclude,
           senderType: args["sender-type"],
           team: args.team,
-          inbox: args.inbox,
-          stdinPane: args["stdin-pane"]
-        }, container2.inboxRouter);
+          inbox: args.inbox
+        };
+        if (getMeetAiRuntime() === "codex") {
+          listenCodex(client, input);
+          return;
+        }
+        listenClaude(client, input, container2.inboxRouter);
       } catch (error48) {
         err(error48 instanceof Error ? error48.message : String(error48));
         process.exit(1);
@@ -16110,7 +16871,7 @@ async function sendTeamInfo(client, input) {
   await client.sendTeamInfo(parsed.roomId, parsed.payload);
   ok("Team info sent");
 }
-var init_usecase7 = __esm(() => {
+var init_usecase6 = __esm(() => {
   init_schema7();
   init_output();
 });
@@ -16124,7 +16885,7 @@ var command_default7;
 var init_command7 = __esm(() => {
   init_dist();
   init_bootstrap();
-  init_usecase7();
+  init_usecase6();
   init_output();
   command_default7 = defineCommand({
     meta: {
@@ -16178,7 +16939,7 @@ async function sendTasks(client, input) {
   await client.sendTasks(parsed.roomId, parsed.payload);
   ok("Tasks info sent");
 }
-var init_usecase8 = __esm(() => {
+var init_usecase7 = __esm(() => {
   init_schema8();
   init_output();
 });
@@ -16192,7 +16953,7 @@ var command_default8;
 var init_command8 = __esm(() => {
   init_dist();
   init_bootstrap();
-  init_usecase8();
+  init_usecase7();
   init_output();
   command_default8 = defineCommand({
     meta: {
@@ -16239,7 +17000,7 @@ async function downloadAttachment(client, input) {
   ok(localPath);
   return localPath;
 }
-var init_usecase9 = __esm(() => {
+var init_usecase8 = __esm(() => {
   init_schema9();
   init_output();
 });
@@ -16253,7 +17014,7 @@ var command_default9;
 var init_command9 = __esm(() => {
   init_dist();
   init_bootstrap();
-  init_usecase9();
+  init_usecase8();
   init_output();
   command_default9 = defineCommand({
     meta: {
@@ -16316,12 +17077,12 @@ var init_command10 = __esm(() => {
 });
 
 // src/lib/hooks/find-room.ts
-import { readdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2, createReadStream } from "node:fs";
-import { join as join2 } from "node:path";
-import { createInterface } from "node:readline";
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3, createReadStream } from "node:fs";
+import { join as join3 } from "node:path";
+import { createInterface as createInterface2 } from "node:readline";
 async function extractTeamName(transcriptPath) {
   try {
-    const rl = createInterface({
+    const rl = createInterface2({
       input: createReadStream(transcriptPath, "utf-8"),
       crlfDelay: Infinity
     });
@@ -16349,7 +17110,7 @@ function registerSession(filePath, data, sessionId) {
   }
   data.session_ids = ids;
   try {
-    writeFileSync2(filePath, JSON.stringify(data));
+    writeFileSync3(filePath, JSON.stringify(data));
   } catch {}
 }
 async function findRoom(sessionId, teamsDir, transcriptPath) {
@@ -16357,9 +17118,9 @@ async function findRoom(sessionId, teamsDir, transcriptPath) {
   if (transcriptPath) {
     const teamName = await extractTeamName(transcriptPath);
     if (teamName) {
-      const filePath = join2(dir, teamName, "meet-ai.json");
+      const filePath = join3(dir, teamName, "meet-ai.json");
       try {
-        const raw = readFileSync3(filePath, "utf-8");
+        const raw = readFileSync4(filePath, "utf-8");
         const data = JSON.parse(raw);
         registerSession(filePath, data, sessionId);
         if (data.room_id)
@@ -16369,14 +17130,14 @@ async function findRoom(sessionId, teamsDir, transcriptPath) {
   }
   let entries;
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync2(dir);
   } catch {
     return null;
   }
   for (const entry of entries) {
-    const filePath = join2(dir, entry, "meet-ai.json");
+    const filePath = join3(dir, entry, "meet-ai.json");
     try {
-      const raw = readFileSync3(filePath, "utf-8");
+      const raw = readFileSync4(filePath, "utf-8");
       const data = JSON.parse(raw);
       const knownIds = data.session_ids ?? [data.session_id];
       if (knownIds.includes(sessionId) || data.session_id === sessionId) {
@@ -16539,17 +17300,17 @@ var init_cookie = __esm(() => {
 var init_fetch_result_please = () => {};
 
 // ../../node_modules/.bun/hono@4.11.8/node_modules/hono/dist/client/utils.js
-function isObject2(item) {
+function isObject3(item) {
   return typeof item === "object" && item !== null && !Array.isArray(item);
 }
 function deepMerge(target, source) {
-  if (!isObject2(target) && !isObject2(source)) {
+  if (!isObject3(target) && !isObject3(source)) {
     return source;
   }
   const merged = { ...target };
   for (const key in source) {
     const value = source[key];
-    if (isObject2(merged[key]) && isObject2(value)) {
+    if (isObject3(merged[key]) && isObject3(value)) {
       merged[key] = deepMerge(merged[key], value);
     } else {
       merged[key] = value;
@@ -16829,23 +17590,23 @@ var init_hooks = __esm(() => {
 });
 
 // src/commands/hook/log-tool-use/usecase.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, statSync as statSync2, rmSync } from "node:fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, statSync as statSync3, rmSync } from "node:fs";
 function getOrCreateParentId(sessionId) {
   const path = `/tmp/meet-ai-hook-${sessionId}.msgid`;
   try {
-    const mtime = statSync2(path).mtimeMs;
+    const mtime = statSync3(path).mtimeMs;
     if (Date.now() - mtime > PARENT_MSG_TTL_SEC * 1000) {
       rmSync(path, { force: true });
       return null;
     }
-    return readFileSync4(path, "utf-8").trim() || null;
+    return readFileSync5(path, "utf-8").trim() || null;
   } catch {
     return null;
   }
 }
 function saveParentId(sessionId, msgId) {
   try {
-    writeFileSync3(`/tmp/meet-ai-hook-${sessionId}.msgid`, msgId);
+    writeFileSync4(`/tmp/meet-ai-hook-${sessionId}.msgid`, msgId);
   } catch {}
 }
 async function processHookInput(rawInput, teamsDir) {
@@ -16949,7 +17710,7 @@ async function processHookInput(rawInput, teamsDir) {
   return "sent";
 }
 var PARENT_MSG_TTL_SEC = 120;
-var init_usecase10 = __esm(() => {
+var init_usecase9 = __esm(() => {
   init_hooks();
 });
 
@@ -16961,7 +17722,7 @@ __export(exports_command11, {
 var command_default11;
 var init_command11 = __esm(() => {
   init_dist();
-  init_usecase10();
+  init_usecase9();
   command_default11 = defineCommand({
     meta: {
       name: "log-tool-use",
@@ -17126,7 +17887,7 @@ async function processPlanReview(rawInput, teamsDir) {
   }
 }
 var POLL_INTERVAL_MS = 2000, POLL_TIMEOUT_MS = 2592000000;
-var init_usecase11 = __esm(() => {
+var init_usecase10 = __esm(() => {
   init_client3();
   init_find_room();
 });
@@ -17150,7 +17911,7 @@ var init_command12 = __esm(() => {
         for await (const chunk of process.stdin) {
           input += chunk;
         }
-        const { processPlanReview: processPlanReview2 } = await Promise.resolve().then(() => (init_usecase11(), exports_usecase));
+        const { processPlanReview: processPlanReview2 } = await Promise.resolve().then(() => (init_usecase10(), exports_usecase));
         await processPlanReview2(input);
       } catch (error48) {
         process.stderr.write(`[plan-review] fatal: ${error48}
@@ -17222,7 +17983,7 @@ async function pollForAnswer(client, roomId, reviewId, pollInterval = POLL_INTER
       process.stderr.write(`[question-review] poll error: ${error48}
 `);
     }
-    await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+    await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
   }
   return null;
 }
@@ -17322,7 +18083,7 @@ async function processQuestionReview(rawInput, teamsDir, opts) {
   }
 }
 var POLL_INTERVAL_MS2 = 2000, POLL_TIMEOUT_MS2 = 1800000;
-var init_usecase12 = __esm(() => {
+var init_usecase11 = __esm(() => {
   init_client3();
   init_find_room();
 });
@@ -17335,7 +18096,7 @@ __export(exports_command13, {
 var command_default13;
 var init_command13 = __esm(() => {
   init_dist();
-  init_usecase12();
+  init_usecase11();
   command_default13 = defineCommand({
     meta: {
       name: "question-review",
@@ -17414,7 +18175,7 @@ async function pollForDecision2(client, roomId, reviewId, pollInterval = POLL_IN
       process.stderr.write(`[permission-review] poll error: ${error48}
 `);
     }
-    await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+    await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
   }
   return null;
 }
@@ -17520,7 +18281,7 @@ async function processPermissionReview(rawInput, teamsDir, opts) {
   }
 }
 var POLL_INTERVAL_MS3 = 2000, POLL_TIMEOUT_MS3 = 1800000;
-var init_usecase13 = __esm(() => {
+var init_usecase12 = __esm(() => {
   init_client3();
   init_find_room();
 });
@@ -17533,7 +18294,7 @@ __export(exports_command14, {
 var command_default14;
 var init_command14 = __esm(() => {
   init_dist();
-  init_usecase13();
+  init_usecase12();
   command_default14 = defineCommand({
     meta: {
       name: "permission-review",
@@ -17578,21 +18339,21 @@ var init_command15 = __esm(() => {
 });
 
 // src/commands/setup-hooks/usecase.ts
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { resolve as resolve2, dirname as dirname2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { resolve as resolve3, dirname as dirname3 } from "node:path";
 function isMeetAiHook(entry) {
   return entry.hooks?.some((h) => typeof h.command === "string" && h.command.startsWith("meet-ai hook ")) ?? false;
 }
 function getSettingsPath(project) {
   if (project) {
-    return resolve2(process.cwd(), ".claude", "settings.json");
+    return resolve3(process.cwd(), ".claude", "settings.json");
   }
-  return resolve2(homedir2(), ".claude", "settings.json");
+  return resolve3(homedir3(), ".claude", "settings.json");
 }
 async function readSettings(path) {
-  if (!existsSync3(path)) {
+  if (!existsSync4(path)) {
     return {};
   }
   const raw = await readFile(path, "utf-8");
@@ -17674,7 +18435,7 @@ async function setupHooks(options) {
     if (Object.keys(cleaned).length === 0) {
       delete updated.hooks;
     }
-    await mkdir(dirname2(settingsPath), { recursive: true });
+    await mkdir(dirname3(settingsPath), { recursive: true });
     await writeFile(settingsPath, `${JSON.stringify(updated, null, 2)}
 `);
     for (const r of removed) {
@@ -17691,7 +18452,7 @@ async function setupHooks(options) {
       return;
     }
     const updated = { ...settings, hooks: merged };
-    await mkdir(dirname2(settingsPath), { recursive: true });
+    await mkdir(dirname3(settingsPath), { recursive: true });
     await writeFile(settingsPath, `${JSON.stringify(updated, null, 2)}
 `);
     for (const a of added) {
@@ -17701,7 +18462,7 @@ async function setupHooks(options) {
   }
 }
 var import_picocolors2, MEET_AI_HOOKS;
-var init_usecase14 = __esm(() => {
+var init_usecase13 = __esm(() => {
   init_output();
   import_picocolors2 = __toESM(require_picocolors(), 1);
   MEET_AI_HOOKS = {
@@ -17760,7 +18521,7 @@ __export(exports_command16, {
 var command_default16;
 var init_command16 = __esm(() => {
   init_dist();
-  init_usecase14();
+  init_usecase13();
   init_output();
   command_default16 = defineCommand({
     meta: {
@@ -17800,10 +18561,10 @@ var init_command16 = __esm(() => {
 });
 
 // src/commands/list-commands/usecase.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { readFile as readFile2, readdir } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { join as join3, resolve as resolve3 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join4, resolve as resolve4 } from "node:path";
 function parseYamlFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match)
@@ -17819,8 +18580,8 @@ function parseYamlFrontmatter(content) {
   };
 }
 async function readSkillsFromDir(baseDir, source, scope) {
-  const skillsDir = join3(baseDir, "skills");
-  if (!existsSync4(skillsDir))
+  const skillsDir = join4(baseDir, "skills");
+  if (!existsSync5(skillsDir))
     return [];
   let entries;
   try {
@@ -17830,8 +18591,8 @@ async function readSkillsFromDir(baseDir, source, scope) {
   }
   const results = [];
   for (const entry of entries) {
-    const skillFile = join3(skillsDir, entry, "SKILL.md");
-    if (!existsSync4(skillFile))
+    const skillFile = join4(skillsDir, entry, "SKILL.md");
+    if (!existsSync5(skillFile))
       continue;
     try {
       const content = await readFile2(skillFile, "utf-8");
@@ -17854,7 +18615,7 @@ async function readSkillsFromDir(baseDir, source, scope) {
   return results;
 }
 async function readCommandsFromDir(commandsDir, source, scope) {
-  if (!existsSync4(commandsDir))
+  if (!existsSync5(commandsDir))
     return [];
   const results = [];
   async function scanDir(dir) {
@@ -17865,7 +18626,7 @@ async function readCommandsFromDir(commandsDir, source, scope) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = join3(dir, entry.name);
+      const fullPath = join4(dir, entry.name);
       if (entry.isDirectory()) {
         await scanDir(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -17892,7 +18653,7 @@ async function readCommandsFromDir(commandsDir, source, scope) {
   return results;
 }
 async function readSettings2(settingsPath) {
-  if (!existsSync4(settingsPath))
+  if (!existsSync5(settingsPath))
     return {};
   try {
     const raw = await readFile2(settingsPath, "utf-8");
@@ -17902,7 +18663,7 @@ async function readSettings2(settingsPath) {
   }
 }
 async function readInstalledPlugins(pluginsFile) {
-  if (!existsSync4(pluginsFile))
+  if (!existsSync5(pluginsFile))
     return {};
   try {
     const raw = await readFile2(pluginsFile, "utf-8");
@@ -17913,17 +18674,17 @@ async function readInstalledPlugins(pluginsFile) {
   }
 }
 async function listCommands(options) {
-  const projectPath = resolve3(options.projectPath ?? process.cwd());
-  const userClaudeDir = options._userClaudeDir ?? join3(homedir3(), ".claude");
-  const pluginsFile = options._pluginsFile ?? join3(homedir3(), ".claude", "plugins", "installed_plugins.json");
+  const projectPath = resolve4(options.projectPath ?? process.cwd());
+  const userClaudeDir = options._userClaudeDir ?? join4(homedir4(), ".claude");
+  const pluginsFile = options._pluginsFile ?? join4(homedir4(), ".claude", "plugins", "installed_plugins.json");
   const results = [];
   const userSkills = await readSkillsFromDir(userClaudeDir, "standalone", "user");
   results.push(...userSkills);
-  const projectClaudeDir = join3(projectPath, ".claude");
+  const projectClaudeDir = join4(projectPath, ".claude");
   const projectSkills = await readSkillsFromDir(projectClaudeDir, "standalone", "project");
   results.push(...projectSkills);
-  const userSettings = await readSettings2(join3(userClaudeDir, "settings.json"));
-  const projectSettings = await readSettings2(join3(projectClaudeDir, "settings.json"));
+  const userSettings = await readSettings2(join4(userClaudeDir, "settings.json"));
+  const projectSettings = await readSettings2(join4(projectClaudeDir, "settings.json"));
   const userEnabled = userSettings.enabledPlugins ?? {};
   const projectEnabled = projectSettings.enabledPlugins ?? {};
   const enabledPlugins = new Map;
@@ -17941,7 +18702,7 @@ async function listCommands(options) {
         continue;
       const { installPath } = installations[0];
       const source = `plugin:${scopeName}`;
-      const pluginCommands = await readCommandsFromDir(join3(installPath, "commands"), source, pluginScope);
+      const pluginCommands = await readCommandsFromDir(join4(installPath, "commands"), source, pluginScope);
       results.push(...pluginCommands);
       const pluginSkills = await readSkillsFromDir(installPath, source, pluginScope);
       results.push(...pluginSkills);
@@ -17949,7 +18710,7 @@ async function listCommands(options) {
   }
   return results;
 }
-var init_usecase15 = () => {};
+var init_usecase14 = () => {};
 
 // src/commands/list-commands/command.ts
 var exports_command17 = {};
@@ -17959,7 +18720,7 @@ __export(exports_command17, {
 var command_default17;
 var init_command17 = __esm(() => {
   init_dist();
-  init_usecase15();
+  init_usecase14();
   init_output();
   command_default17 = defineCommand({
     meta: {
@@ -17993,8 +18754,8 @@ async function sendCommands(client, input) {
   await client.sendCommands(input.roomId, payload);
   ok("Commands sent");
 }
-var init_usecase16 = __esm(() => {
-  init_usecase15();
+var init_usecase15 = __esm(() => {
+  init_usecase14();
   init_output();
 });
 
@@ -18007,7 +18768,7 @@ var command_default18;
 var init_command18 = __esm(() => {
   init_dist();
   init_bootstrap();
-  init_usecase16();
+  init_usecase15();
   init_output();
   command_default18 = defineCommand({
     meta: {
@@ -18398,14 +19159,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue, resolve4, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve5, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve4, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve5, reject);
             });
             return;
           } catch (error48) {
@@ -18413,7 +19174,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve4(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve5(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -18589,14 +19350,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve4, reject) {
+          then: function(resolve5, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve4, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve5, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -18607,7 +19368,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve4(returnValue);
+                resolve5(returnValue);
             }, function(error48) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
@@ -18623,11 +19384,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve4, reject) {
+        then: function(resolve5, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve4, reject);
-          })) : resolve4(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve5, reject);
+          })) : resolve5(returnValue$jscomp$0);
         }
       };
     };
@@ -19410,14 +20171,14 @@ var require_signal_exit = __commonJS((exports, module) => {
 import { PassThrough } from "node:stream";
 var consoleMethods, originalMethods, patchConsole = (callback) => {
   const stdout = new PassThrough;
-  const stderr = new PassThrough;
+  const stderr2 = new PassThrough;
   stdout.write = (data) => {
     callback("stdout", data);
   };
-  stderr.write = (data) => {
+  stderr2.write = (data) => {
     callback("stderr", data);
   };
-  const internalConsole = new console.Console(stdout, stderr);
+  const internalConsole = new console.Console(stdout, stderr2);
   for (const method of consoleMethods) {
     originalMethods[method] = console[method];
     console[method] = internalConsole[method];
@@ -21614,12 +22375,12 @@ import { execFileSync as execFileSync2 } from "node:child_process";
 import fs from "node:fs";
 import tty from "node:tty";
 function terminalSize() {
-  const { env: env2, stdout, stderr } = process4;
+  const { env: env2, stdout, stderr: stderr2 } = process4;
   if (stdout?.columns && stdout?.rows) {
     return create(stdout.columns, stdout.rows);
   }
-  if (stderr?.columns && stderr?.rows) {
-    return create(stderr.columns, stderr.rows);
+  if (stderr2?.columns && stderr2?.rows) {
+    return create(stderr2.columns, stderr2.rows);
   }
   if (env2.COLUMNS && env2.LINES) {
     return create(env2.COLUMNS, env2.LINES);
@@ -24124,8 +24885,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve4) {
-            entangledListeners.push(resolve4);
+          then: function(resolve5) {
+            entangledListeners.push(resolve5);
           }
         };
       }
@@ -24149,8 +24910,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve4) {
-          listeners.push(resolve4);
+        then: function(resolve5) {
+          listeners.push(resolve5);
         }
       };
       thenable.then(function() {
@@ -50940,7 +51701,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           ws.onmessage = handleMessage;
           ws.onopen = function() {
             bridge = new src_bridge({
-              listen: function listen2(fn) {
+              listen: function listen(fn) {
                 messageListeners.push(fn);
                 return function() {
                   var index = messageListeners.indexOf(fn);
@@ -51073,7 +51834,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             return;
           }
           var wall = {
-            listen: function listen2(fn) {
+            listen: function listen(fn) {
               onSubscribe(fn);
               return function() {
                 onUnsubscribe(fn);
@@ -53829,7 +54590,7 @@ var init_ErrorBoundary = __esm(() => {
 // ../../node_modules/.bun/ink@6.8.0+b7580ee3b5d80903/node_modules/ink/build/components/App.js
 import { EventEmitter as EventEmitter2 } from "node:events";
 import process12 from "node:process";
-function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, exitOnCtrlC, onExit, setCursorPosition }) {
+function App({ children, stdin, stdout, stderr: stderr2, writeToStdout, writeToStderr, exitOnCtrlC, onExit, setCursorPosition }) {
   const [isFocusEnabled, setIsFocusEnabled] = import_react14.useState(true);
   const [activeFocusId, setActiveFocusId] = import_react14.useState(undefined);
   const [, setFocusables] = import_react14.useState([]);
@@ -54101,9 +54862,9 @@ Read about how to prevent this error on https://github.com/vadimdemedes/ink/#isr
     write: writeToStdout
   }), [stdout, writeToStdout]);
   const stderrContextValue = import_react14.useMemo(() => ({
-    stderr,
+    stderr: stderr2,
     write: writeToStderr
-  }), [stderr, writeToStderr]);
+  }), [stderr2, writeToStderr]);
   const cursorContextValue = import_react14.useMemo(() => ({
     setCursorPosition
   }), [setCursorPosition]);
@@ -54557,8 +55318,8 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve4, reject) => {
-      this.resolveExitPromise = resolve4;
+    this.exitPromise ||= new Promise((resolve5, reject) => {
+      this.resolveExitPromise = resolve5;
       this.rejectExitPromise = reject;
     });
     if (!this.beforeExitHandler) {
@@ -55394,13 +56155,88 @@ var init_build2 = __esm(async () => {
   ]);
 });
 
+// src/spawner.ts
+import { execSync } from "node:child_process";
+import { existsSync as existsSync7 } from "node:fs";
+import { homedir as homedir5, platform as platform2 } from "node:os";
+import { join as join5 } from "node:path";
+function findBinary(binaryName, envVarName, commonPaths) {
+  try {
+    const command = platform2() === "win32" ? `where ${binaryName}` : `which ${binaryName}`;
+    const result = execSync(command, { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+    const binaryPath = result.split(`
+`)[0].trim();
+    if (binaryPath && existsSync7(binaryPath)) {
+      return binaryPath;
+    }
+  } catch {}
+  const envPath = process.env[envVarName];
+  if (envPath && existsSync7(envPath)) {
+    return envPath;
+  }
+  for (const path of commonPaths) {
+    if (existsSync7(path)) {
+      return path;
+    }
+  }
+  throw new Error(`${binaryName} is not installed`);
+}
+function findClaudeCli() {
+  const home = homedir5();
+  try {
+    return findBinary("claude", "MEET_AI_CLAUDE_PATH", [
+      join5(home, ".bun", "bin", "claude"),
+      "/opt/homebrew/bin/claude",
+      "/usr/local/bin/claude",
+      join5(home, ".local", "bin", "claude")
+    ]);
+  } catch {
+    throw new Error(`
+Claude Code is not installed
+
+Please install Claude Code:
+  bun add -g @anthropic-ai/claude-code
+
+Or set MEET_AI_CLAUDE_PATH to the Claude Code CLI path.
+      `.trim());
+  }
+}
+function findCodexCli() {
+  const home = homedir5();
+  try {
+    return findBinary("codex", "MEET_AI_CODEX_PATH", [
+      join5(home, ".bun", "bin", "codex"),
+      "/opt/homebrew/bin/codex",
+      "/usr/local/bin/codex",
+      join5(home, ".local", "bin", "codex")
+    ]);
+  } catch {
+    throw new Error(`
+Codex CLI is not installed
+
+Please install Codex:
+  npm install -g @openai/codex
+
+Or set MEET_AI_CODEX_PATH to the Codex CLI path.
+      `.trim());
+  }
+}
+var init_spawner = () => {};
+
 // src/lib/process-manager.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync4, renameSync, lstatSync } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync8, lstatSync, mkdirSync as mkdirSync3, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { fileURLToPath } from "node:url";
+import { join as join6 } from "node:path";
+function getRegistryDir() {
+  return join6(process.env.HOME ?? homedir6(), ".meet-ai");
+}
+function getRegistryPath() {
+  return join6(getRegistryDir(), "sessions.json");
+}
 function readRegistry() {
   try {
-    const data = readFileSync6(REGISTRY_PATH, "utf8");
+    const data = readFileSync7(getRegistryPath(), "utf8");
     const parsed = exports_external.array(SessionEntrySchema).safeParse(JSON.parse(data));
     return parsed.success ? parsed.data : [];
   } catch {
@@ -55408,17 +56244,18 @@ function readRegistry() {
   }
 }
 function writeRegistry(entries) {
-  mkdirSync2(REGISTRY_DIR, { recursive: true, mode: 448 });
+  const registryDir = getRegistryDir();
+  mkdirSync3(registryDir, { recursive: true, mode: 448 });
   try {
-    const stat = lstatSync(REGISTRY_DIR);
+    const stat = lstatSync(registryDir);
     if (!stat.isDirectory())
       return;
   } catch {
     return;
   }
-  const tmpPath = join4(REGISTRY_DIR, `sessions.${process.pid}.${Date.now()}.tmp`);
-  writeFileSync4(tmpPath, JSON.stringify(entries, null, 2), { mode: 384 });
-  renameSync(tmpPath, REGISTRY_PATH);
+  const tmpPath = join6(registryDir, `sessions.${process.pid}.${Date.now()}.tmp`);
+  writeFileSync5(tmpPath, JSON.stringify(entries, null, 2), { mode: 384 });
+  renameSync(tmpPath, getRegistryPath());
 }
 function addToRegistry(entry) {
   const entries = readRegistry();
@@ -55433,6 +56270,17 @@ function removeFromRegistry(sessionName) {
   const entries = readRegistry().filter((e) => e.sessionName !== sessionName);
   writeRegistry(entries);
 }
+function resolveSelfCliCommand() {
+  const sourceEntry = fileURLToPath(new URL("../index.ts", import.meta.url));
+  if (existsSync8(sourceEntry) && typeof Bun !== "undefined") {
+    return [process.execPath, "run", sourceEntry];
+  }
+  const builtEntry = fileURLToPath(new URL("../index.js", import.meta.url));
+  if (existsSync8(builtEntry)) {
+    return [process.execPath, builtEntry];
+  }
+  return ["meet-ai"];
+}
 
 class ProcessManager {
   teams = new Map;
@@ -55446,11 +56294,12 @@ class ProcessManager {
   sessionName(roomId) {
     return `mai-${roomId}`;
   }
-  spawn(roomId, roomName) {
+  spawn(roomId, roomName, codingAgent = "claude") {
     const sessionName = this.sessionName(roomId);
     const team = {
       roomId,
       roomName,
+      codingAgent,
       sessionName,
       status: "starting",
       exitCode: null,
@@ -55461,22 +56310,24 @@ class ProcessManager {
     this.spawned++;
     if (this.opts.dryRun)
       return team;
-    const fullPrompt = [
-      `ROOM_ID: ${roomId}`,
-      "",
-      "You are a team lead. IMMEDIATELY:",
-      "1. Start agent-team to start accepting commands from Meet AI",
-      "2. Connect to the meet-ai room using the /meet-ai skill",
-      "3. Just send a welcome message to the room, do not perform any work yet."
-    ].join(`
+    const fullPrompt = [`ROOM_ID: ${roomId}`, "", ...this.buildPromptLines(codingAgent)].join(`
 `);
-    const claudeArgs = [
-      "--dangerously-skip-permissions",
-      "--model",
-      this.opts.model ?? "opus",
-      fullPrompt
-    ];
-    const sessionEnv = { DISABLE_AUTOUPDATER: "1" };
+    const agentBinary = this.opts.agentBinaries[codingAgent];
+    if (!agentBinary) {
+      team.status = "error";
+      team.lines.push(`[error] No CLI binary configured for coding agent: ${codingAgent}`);
+      this.opts.onStatusChange?.(roomId, "error");
+      return team;
+    }
+    const commandArgs = codingAgent === "codex" ? this.buildCodexListenCommandArgs(roomId) : [agentBinary, ...this.buildClaudeCommandArgs(fullPrompt)];
+    const sessionEnv = {
+      DISABLE_AUTOUPDATER: "1",
+      MEET_AI_RUNTIME: codingAgent
+    };
+    if (codingAgent === "codex") {
+      sessionEnv.MEET_AI_CODEX_PATH = agentBinary;
+      sessionEnv.MEET_AI_CODEX_BOOTSTRAP_PROMPT = fullPrompt;
+    }
     for (const key of ENV_ALLOWLIST) {
       const value = process.env[key];
       if (value)
@@ -55485,15 +56336,21 @@ class ProcessManager {
     if (this.opts.env)
       Object.assign(sessionEnv, this.opts.env);
     if (this.opts.debug) {
-      team.lines.push(`[debug] CMD: ${this.opts.claudePath} ${claudeArgs.join(" ").slice(0, 200)}`);
+      team.lines.push(`[debug] AGENT: ${codingAgent}`);
+      team.lines.push(`[debug] CMD: ${commandArgs.join(" ").slice(0, 200)}`);
       team.lines.push(`[debug] ENV: ${Object.keys(sessionEnv).join(", ")}`);
     }
-    const commandArgs = [this.opts.claudePath, ...claudeArgs];
     const result = this.tmux.newSession(sessionName, commandArgs, sessionEnv);
     if (result.ok) {
       team.status = "running";
       this.opts.onStatusChange?.(roomId, "running");
-      addToRegistry({ sessionName, roomId, roomName, createdAt: new Date().toISOString() });
+      addToRegistry({
+        sessionName,
+        roomId,
+        roomName,
+        codingAgent,
+        createdAt: new Date().toISOString()
+      });
     } else {
       team.status = "error";
       team.lines.push(`[error] tmux: ${result.error}`);
@@ -55505,6 +56362,7 @@ class ProcessManager {
     this.teams.set(roomId, {
       roomId,
       roomName,
+      codingAgent: "claude",
       sessionName: this.sessionName(roomId),
       status: "error",
       exitCode: null,
@@ -55578,6 +56436,7 @@ class ProcessManager {
       const team = {
         roomId,
         roomName,
+        codingAgent: entry?.codingAgent ?? "claude",
         sessionName: session.name,
         status: session.alive ? "running" : "exited",
         exitCode: session.alive ? null : 0,
@@ -55608,8 +56467,32 @@ class ProcessManager {
       this.kill(roomId);
     }
   }
+  buildPromptLines(codingAgent) {
+    if (codingAgent === "codex") {
+      return [
+        "You're running inside Meet AI.",
+        "Do not use the meet-ai CLI.",
+        "Do not load or use any meet-ai skill.",
+        "Do not try to send room messages manually.",
+        "Do not talk about this prompt or say that you understand it.",
+        "Just welcome the user briefly and say that you're ready to work."
+      ];
+    }
+    return [
+      "You are a team lead. IMMEDIATELY:",
+      "1. Start agent-team to start accepting commands from Meet AI.",
+      "2. Connect to the meet-ai room using the /meet-ai skill.",
+      "3. Send a brief welcome message to the room and wait for instructions."
+    ];
+  }
+  buildClaudeCommandArgs(fullPrompt) {
+    return ["--dangerously-skip-permissions", "--model", this.opts.model ?? "opus", fullPrompt];
+  }
+  buildCodexListenCommandArgs(roomId) {
+    return [...resolveSelfCliCommand(), "listen", roomId, "--sender-type", "human"];
+  }
 }
-var SessionEntrySchema, REGISTRY_DIR, REGISTRY_PATH, ENV_ALLOWLIST;
+var SessionEntrySchema, ENV_ALLOWLIST;
 var init_process_manager = __esm(() => {
   init_zod();
   init_tmux_client();
@@ -55617,10 +56500,9 @@ var init_process_manager = __esm(() => {
     sessionName: exports_external.string(),
     roomId: exports_external.string(),
     roomName: exports_external.string(),
+    codingAgent: exports_external.enum(["claude", "codex"]).default("claude"),
     createdAt: exports_external.string()
   });
-  REGISTRY_DIR = join4(homedir4(), ".meet-ai");
-  REGISTRY_PATH = join4(REGISTRY_DIR, "sessions.json");
   ENV_ALLOWLIST = [
     "HOME",
     "USER",
@@ -55634,48 +56516,6 @@ var init_process_manager = __esm(() => {
   ];
 });
 
-// src/spawner.ts
-import { execSync } from "node:child_process";
-import { existsSync as existsSync6 } from "node:fs";
-import { homedir as homedir5, platform as platform2 } from "node:os";
-import { join as join5 } from "node:path";
-function findClaudeCli() {
-  try {
-    const command = platform2() === "win32" ? "where claude" : "which claude";
-    const result = execSync(command, { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
-    const claudePath = result.split(`
-`)[0].trim();
-    if (claudePath && existsSync6(claudePath)) {
-      return claudePath;
-    }
-  } catch {}
-  const envPath = process.env.MEET_AI_CLAUDE_PATH;
-  if (envPath && existsSync6(envPath)) {
-    return envPath;
-  }
-  const home = homedir5();
-  const commonPaths = [
-    join5(home, ".bun", "bin", "claude"),
-    "/opt/homebrew/bin/claude",
-    "/usr/local/bin/claude",
-    join5(home, ".local", "bin", "claude")
-  ];
-  for (const path of commonPaths) {
-    if (existsSync6(path)) {
-      return path;
-    }
-  }
-  throw new Error(`
-Claude Code is not installed
-
-Please install Claude Code:
-  bun add -g @anthropic-ai/claude-code
-
-Or set MEET_AI_CLAUDE_PATH to the Claude Code CLI path.
-    `.trim());
-}
-var init_spawner = () => {};
-
 // ../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react-jsx-dev-runtime.development.js
 var require_react_jsx_dev_runtime_development = __commonJS((exports) => {
   var React11 = __toESM(require_react());
@@ -56367,16 +57207,25 @@ var init_dashboard = __esm(async () => {
 });
 
 // src/tui/spawn-dialog.tsx
-function SpawnDialog({ onSubmit, onCancel }) {
+function SpawnDialog({ codingAgents, onSubmit, onCancel }) {
   const [roomName, setRoomName] = import_react29.useState("");
   const [cursor, setCursor] = import_react29.useState(0);
+  const [selectedAgentIndex, setSelectedAgentIndex] = import_react29.useState(0);
   use_input_default((input, key) => {
     if (key.escape) {
       onCancel();
       return;
     }
     if (key.return && roomName.trim()) {
-      onSubmit(roomName.trim());
+      onSubmit(roomName.trim(), codingAgents[selectedAgentIndex]?.id ?? "claude");
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedAgentIndex((current) => Math.max(0, current - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedAgentIndex((current) => Math.min(codingAgents.length - 1, current + 1));
       return;
     }
     if (key.leftArrow) {
@@ -56394,7 +57243,7 @@ function SpawnDialog({ onSubmit, onCancel }) {
       }
       return;
     }
-    if (input && !key.ctrl && !key.meta && !key.upArrow && !key.downArrow) {
+    if (input && !key.ctrl && !key.meta) {
       setRoomName((v) => v.slice(0, cursor) + input + v.slice(cursor));
       setCursor((c) => c + input.length);
     }
@@ -56432,7 +57281,21 @@ function SpawnDialog({ onSubmit, onCancel }) {
             children: after
           }, undefined, false, undefined, this)
         ]
-      }, undefined, true, undefined, this)
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
+        children: [
+          "Agent:",
+          " ",
+          /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
+            color: "yellow",
+            children: codingAgents[selectedAgentIndex]?.label ?? "Claude Code"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
+        dimColor: true,
+        children: "Use ←/→ to edit the room name, ↑/↓ to choose the coding agent, Enter to spawn."
+      }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
 }
@@ -56580,7 +57443,7 @@ var init_status_bar = __esm(async () => {
 });
 
 // src/tui/app.tsx
-function AppInner({ processManager, client, onAttach, onDetach }) {
+function AppInner({ processManager, client, codingAgents, onAttach, onDetach }) {
   const { exit } = use_app_default();
   const { stdout } = use_stdout_default();
   const { setRawMode } = use_stdin_default();
@@ -56590,7 +57453,7 @@ function AppInner({ processManager, client, onAttach, onDetach }) {
   const [killTargetId, setKillTargetId] = import_react30.useState(null);
   const [, setRenderTick] = import_react30.useState(0);
   const terminalHeight = stdout?.rows ?? 24;
-  const bottomHeight = showSpawn ? 4 : killTargetId ? 1 : 1;
+  const bottomHeight = showSpawn ? 6 : killTargetId ? 1 : 1;
   const dashboardHeight = terminalHeight - bottomHeight;
   const focusedRoomRef = import_react30.useRef(null);
   const focusedTeam = teams[focusedIndex];
@@ -56605,10 +57468,10 @@ function AppInner({ processManager, client, onAttach, onDetach }) {
       return [...current];
     });
   }, [processManager]);
-  const handleSpawn = import_react30.useCallback(async (roomName) => {
+  const handleSpawn = import_react30.useCallback(async (roomName, codingAgent) => {
     try {
       const room = await client.createRoom(roomName);
-      processManager.spawn(room.id, roomName);
+      processManager.spawn(room.id, roomName, codingAgent);
       refreshTeams();
     } catch (error48) {
       const msg = error48 instanceof Error ? error48.message : String(error48);
@@ -56726,9 +57589,10 @@ function AppInner({ processManager, client, onAttach, onDetach }) {
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this) : showSpawn ? /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(SpawnDialog, {
-        onSubmit: (name) => {
+        codingAgents: [...codingAgents],
+        onSubmit: (roomName, codingAgent) => {
           setShowSpawn(false);
-          handleSpawn(name);
+          handleSpawn(roomName, codingAgent);
         },
         onCancel: () => setShowSpawn(false)
       }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(StatusBar, {
@@ -56804,9 +57668,21 @@ async function startDashboard(client, config2, options) {
     console.error(`tmux >= 3.2 required, found ${check3.version}`);
     process.exit(1);
   }
-  const claudePath = findClaudeCli();
+  const agentBinaries = {};
+  try {
+    agentBinaries.claude = findClaudeCli();
+  } catch {}
+  try {
+    agentBinaries.codex = findCodexCli();
+  } catch {}
+  const availableCodingAgents = CODING_AGENT_DEFINITIONS.filter((agent) => Boolean(agentBinaries[agent.id]));
+  if (availableCodingAgents.length === 0) {
+    console.error("No supported coding agent CLI was found.");
+    console.error("Install Claude Code or Codex, or set MEET_AI_CLAUDE_PATH / MEET_AI_CODEX_PATH.");
+    process.exit(1);
+  }
   const processManager = new ProcessManager({
-    claudePath,
+    agentBinaries,
     debug: options?.debug,
     tmux,
     env: {
@@ -56830,15 +57706,16 @@ async function startDashboard(client, config2, options) {
     try {
       lobbyWs = client.listenLobby({
         silent: true,
-        onSpawnRequest: async (roomName) => {
-          if (pendingSpawns.has(roomName))
+        onSpawnRequest: async ({ roomName, codingAgent }) => {
+          const key = `${roomName}:${codingAgent}`;
+          if (pendingSpawns.has(key))
             return;
-          pendingSpawns.add(roomName);
+          pendingSpawns.add(key);
           try {
             const room = await client.createRoom(roomName);
-            processManager.spawn(room.id, roomName);
+            processManager.spawn(room.id, roomName, codingAgent);
           } finally {
-            pendingSpawns.delete(roomName);
+            pendingSpawns.delete(key);
           }
         }
       });
@@ -56854,6 +57731,7 @@ async function startDashboard(client, config2, options) {
   const element = import_react31.default.createElement(App2, {
     processManager,
     client,
+    codingAgents: availableCodingAgents,
     onAttach: () => {
       lobbyWs?.close();
       lobbyWs = null;
@@ -56867,10 +57745,11 @@ async function startDashboard(client, config2, options) {
   cleanup();
 }
 var import_react31;
-var init_usecase17 = __esm(async () => {
+var init_usecase16 = __esm(async () => {
+  init_coding_agents();
+  init_spawner();
   init_process_manager();
   init_tmux_client();
-  init_spawner();
   await __promiseAll([
     init_build2(),
     init_app()
@@ -56881,7 +57760,7 @@ var init_usecase17 = __esm(async () => {
 // src/index.ts
 init_dist();
 // package.json
-var version = "0.0.35";
+var version = "0.0.36";
 
 // src/index.ts
 init_output();
@@ -56921,7 +57800,7 @@ var main = defineCommand({
     try {
       const { getClient: getClient2 } = await Promise.resolve().then(() => (init_bootstrap(), exports_bootstrap));
       const { getMeetAiConfig: getMeetAiConfig2 } = await Promise.resolve().then(() => (init_config(), exports_config));
-      const { startDashboard: startDashboard2 } = await init_usecase17().then(() => exports_usecase2);
+      const { startDashboard: startDashboard2 } = await init_usecase16().then(() => exports_usecase2);
       const client = getClient2();
       const config2 = getMeetAiConfig2();
       await startDashboard2(client, config2, { debug: args.debug });