@meet-ai/cli 0.0.34 → 0.0.36

package/dist/index.js

@@ -1590,10 +1590,10 @@ function fixedBase64(bodyLength, padding) {
 function fixedBase64url(length) {
   return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
 }
-var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, extendedDuration, guid, uuid = (version) => {
-  if (!version)
+var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, extendedDuration, guid, uuid = (version2) => {
+  if (!version2)
     return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
-  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
 }, uuid4, uuid6, uuid7, email, html5Email, rfc5322Email, unicodeEmail, idnEmail, browserEmail, _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`, ipv4, ipv6, mac = (delimiter) => {
   const escapedDelim = escapeRegex(delimiter ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
@@ -2249,9 +2249,9 @@ class Doc {
 }
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/versions.js
-var version;
+var version2;
 var init_versions = __esm(() => {
-  version = {
+  version2 = {
     major: 4,
     minor: 3,
     patch: 6
@@ -2627,7 +2627,7 @@ var init_schemas = __esm(() => {
     inst ?? (inst = {});
     inst._zod.def = def;
     inst._zod.bag = inst._zod.bag || {};
-    inst._zod.version = version;
+    inst._zod.version = version2;
     const checks = [...inst._zod.def.checks ?? []];
     if (inst._zod.traits.has("$ZodCheck")) {
       checks.unshift(inst);
@@ -11912,7 +11912,7 @@ var init_json_schema = () => {};
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/index.js
 var exports_core2 = {};
 __export(exports_core2, {
-  version: () => version,
+  version: () => version2,
   util: () => exports_util,
   treeifyError: () => treeifyError,
   toJSONSchema: () => toJSONSchema,
@@ -14012,10 +14012,10 @@ function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
     return schema ? z.any() : z.never();
   }
-  const version2 = detectVersion(schema, params?.defaultTarget);
+  const version3 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
   const ctx = {
-    version: version2,
+    version: version3,
     defs,
     refs: new Map,
     processing: new Set,
@@ -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,18 +14553,14 @@ 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()
   });
 });
 
-// src/client.ts
-function wsLog(data) {
-  const json2 = JSON.stringify({ ...data, ts: new Date().toISOString() });
-  const isSuccess = data.event === "connected" || data.event === "reconnected" || data.event === "catchup";
-  console.error(isSuccess ? `\x1B[32m${json2}\x1B[0m` : json2);
-}
+// src/domain/adapters/HttpTransport.ts
 function isRetryable(error48) {
   if (error48 instanceof TypeError)
     return true;
@@ -14488,396 +14587,773 @@ 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;
 }
-function cleanupOldAttachments() {
+async function parseErrorMessage(res) {
   try {
-    const { readdirSync, statSync, unlinkSync } = __require("node:fs");
-    const now = Date.now();
-    for (const entry of readdirSync(ATTACHMENTS_DIR)) {
-      try {
-        const filePath = `${ATTACHMENTS_DIR}/${entry}`;
-        const mtime = statSync(filePath).mtimeMs;
-        if (now - mtime > MAX_AGE_MS) {
-          unlinkSync(filePath);
-        }
-      } catch {}
-    }
+    const err2 = await res.json();
+    const msg = err2.error;
+    if (typeof msg === "string")
+      return msg;
+    if (msg)
+      return JSON.stringify(msg);
   } catch {}
+  return `HTTP ${res.status}`;
 }
-function createClient(baseUrl, apiKey) {
-  function headers(extra) {
+
+class HttpTransport {
+  baseUrl;
+  apiKey;
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  headers(extra) {
     const h = { "Content-Type": "application/json", ...extra };
-    if (apiKey) {
-      h["Authorization"] = `Bearer ${apiKey}`;
+    if (this.apiKey) {
+      h["Authorization"] = `Bearer ${this.apiKey}`;
     }
     return h;
   }
-  return {
-    async createRoom(name) {
-      const res = await fetch(`${baseUrl}/api/rooms`, {
+  authHeaders() {
+    return this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : undefined;
+  }
+  buildUrl(path, query) {
+    const params = new URLSearchParams;
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value)
+          params.set(key, value);
+      }
+    }
+    const qs = params.toString();
+    return `${this.baseUrl}${path}${qs ? `?${qs}` : ""}`;
+  }
+  async postJson(path, body, opts) {
+    const doRequest = async () => {
+      const res = await fetch(this.buildUrl(path, opts?.query), {
         method: "POST",
-        headers: headers(),
-        body: JSON.stringify({ name })
+        headers: this.headers(),
+        body: body !== undefined ? JSON.stringify(body) : undefined
       });
-      if (!res.ok) {
-        const err2 = await res.json();
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
-      }
+      if (!res.ok)
+        throw new Error(await parseErrorMessage(res));
       return res.json();
-    },
-    async sendMessage(roomId, sender, content, color) {
-      return withRetry(async () => {
-        const res = await fetch(`${baseUrl}/api/rooms/${roomId}/messages`, {
-          method: "POST",
-          headers: headers(),
-          body: JSON.stringify({ sender, content, sender_type: "agent", ...color && { color } })
-        });
-        if (!res.ok) {
-          const err2 = await res.json().catch(() => ({}));
-          throw new Error(err2.error ?? `HTTP ${res.status}`);
-        }
-        return res.json();
+    };
+    return opts?.retry ? withRetry(doRequest, opts.retry) : doRequest();
+  }
+  async postText(path, body, opts) {
+    const doRequest = async () => {
+      const res = await fetch(this.buildUrl(path, opts?.query), {
+        method: "POST",
+        headers: this.headers(),
+        body: body !== undefined ? JSON.stringify(body) : undefined
       });
-    },
-    async getMessages(roomId, options) {
-      const params = new URLSearchParams;
-      if (options?.after)
-        params.set("after", options.after);
-      if (options?.exclude)
-        params.set("exclude", options.exclude);
-      if (options?.senderType)
-        params.set("sender_type", options.senderType);
-      const qs = params.toString();
-      const url2 = `${baseUrl}/api/rooms/${roomId}/messages${qs ? `?${qs}` : ""}`;
-      const res = await fetch(url2, {
-        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined
+      if (!res.ok)
+        throw new Error(await parseErrorMessage(res));
+      return res.text();
+    };
+    return opts?.retry ? withRetry(doRequest, opts.retry) : doRequest();
+  }
+  async getJson(path, opts) {
+    const doRequest = async () => {
+      const res = await fetch(this.buildUrl(path, opts?.query), {
+        headers: this.authHeaders()
       });
-      if (!res.ok) {
-        const err2 = await res.json();
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
-      }
+      if (!res.ok)
+        throw new Error(await parseErrorMessage(res));
       return res.json();
-    },
-    listen(roomId, options) {
-      const wsUrl = baseUrl.replace(/^http/, "ws");
-      const tokenParam = apiKey ? `?token=${apiKey}` : "";
-      let pingInterval = null;
-      let reconnectAttempt = 0;
-      const seen = new Set;
-      let lastSeenId = null;
-      function deliver(msg) {
-        if (seen.has(msg.id))
-          return;
-        seen.add(msg.id);
-        if (seen.size > 200) {
-          const first = seen.values().next().value;
-          seen.delete(first);
-        }
-        lastSeenId = msg.id;
-        if (options?.exclude && msg.sender === options.exclude)
-          return;
-        if (options?.senderType && msg.sender_type !== options.senderType)
-          return;
-        if (options?.onMessage) {
-          options.onMessage(msg);
-        } else {
-          console.log(JSON.stringify(msg));
-        }
+    };
+    return opts?.retry ? withRetry(doRequest, opts.retry) : doRequest();
+  }
+  async getRaw(path) {
+    const res = await fetch(this.buildUrl(path), {
+      headers: this.authHeaders()
+    });
+    if (!res.ok)
+      throw new Error(await parseErrorMessage(res));
+    return res;
+  }
+  async del(path) {
+    const res = await fetch(this.buildUrl(path), {
+      method: "DELETE",
+      headers: this.headers()
+    });
+    if (!res.ok)
+      throw new Error(await parseErrorMessage(res));
+  }
+}
+
+// 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() });
+  const isSuccess = data.event === "connected" || data.event === "reconnected" || data.event === "catchup";
+  console.error(isSuccess ? `\x1B[32m${json2}\x1B[0m` : json2);
+}
+
+class ConnectionAdapter {
+  transport;
+  baseUrl;
+  apiKey;
+  constructor(transport, baseUrl, apiKey) {
+    this.transport = transport;
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  listen(roomId, options) {
+    const wsUrl = this.baseUrl.replace(/^http/, "ws");
+    const wsHeaders = this.apiKey ? { headers: { Authorization: `Bearer ${this.apiKey}` } } : undefined;
+    let pingInterval = null;
+    let reconnectAttempt = 0;
+    const seen = new Set;
+    let lastSeenId = null;
+    const transport = this.transport;
+    function deliver(msg) {
+      if (seen.has(msg.id))
+        return;
+      seen.add(msg.id);
+      if (seen.size > 200) {
+        const first = seen.values().next().value;
+        seen.delete(first);
       }
-      function getReconnectDelay() {
-        const delay = Math.min(1000 * 2 ** Math.min(reconnectAttempt, 4), 15000);
-        reconnectAttempt++;
-        return delay + delay * 0.5 * Math.random();
+      lastSeenId = msg.id;
+      if (options?.exclude && msg.sender === options.exclude)
+        return;
+      if (options?.senderType && msg.sender_type !== options.senderType)
+        return;
+      if (options?.onMessage) {
+        options.onMessage(msg);
+      } else {
+        console.log(JSON.stringify(msg));
       }
-      const fetchMessages = this.getMessages.bind(this);
-      function connect() {
-        const ws = new WebSocket(`${wsUrl}/api/rooms/${roomId}/ws${tokenParam}`);
-        const connectTimeout = setTimeout(() => {
-          if (ws.readyState !== WebSocket.OPEN) {
-            wsLog({ event: "timeout", after_ms: 30000 });
-            try {
-              ws.close(4000, "connect timeout");
-            } catch {}
-            const delay = getReconnectDelay();
-            wsLog({ event: "reconnecting", attempt: reconnectAttempt, delay_ms: Math.round(delay) });
-            setTimeout(connect, delay);
-          }
-        }, 30000);
-        ws.onopen = async () => {
-          clearTimeout(connectTimeout);
-          const wasReconnect = reconnectAttempt > 0;
-          reconnectAttempt = 0;
-          wsLog({ event: wasReconnect ? "reconnected" : "connected" });
-          if (pingInterval)
-            clearInterval(pingInterval);
-          pingInterval = setInterval(() => {
-            if (ws.readyState === WebSocket.OPEN) {
-              ws.send(JSON.stringify({ type: "ping" }));
-            }
-          }, 30000);
-          if (lastSeenId) {
-            try {
-              const missed = await fetchMessages(roomId, { after: lastSeenId });
-              if (missed.length)
-                wsLog({ event: "catchup", count: missed.length });
-              for (const msg of missed)
-                deliver(msg);
-            } catch {}
-          }
-        };
-        ws.onmessage = (event) => {
-          const text = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
-          const data = JSON.parse(text);
-          if (data.type === "pong")
-            return;
-          if (data.type === "terminal_subscribe" || data.type === "terminal_unsubscribe") {
-            options?.onMessage?.(data);
-            return;
-          }
-          if (data.type === "terminal_data")
-            return;
-          deliver(data);
-        };
-        ws.onclose = (event) => {
-          clearTimeout(connectTimeout);
-          if (pingInterval)
-            clearInterval(pingInterval);
-          const code = event.code;
-          if (code === 1000) {
-            wsLog({ event: "closed", code: 1000 });
-            return;
-          }
-          const reason = code === 1006 ? "network drop" : code === 1012 ? "service restart" : code === 1013 ? "server back-off" : `code ${code}`;
+    }
+    function getReconnectDelay() {
+      const delay = Math.min(1000 * 2 ** Math.min(reconnectAttempt, 4), 15000);
+      reconnectAttempt++;
+      return delay + delay * 0.5 * Math.random();
+    }
+    function connect() {
+      const ws = new WebSocket(`${wsUrl}/api/rooms/${roomId}/ws`, wsHeaders);
+      const connectTimeout = setTimeout(() => {
+        if (ws.readyState !== WebSocket.OPEN) {
+          wsLog({ event: "timeout", after_ms: 30000 });
+          try {
+            ws.close(4000, "connect timeout");
+          } catch {}
           const delay = getReconnectDelay();
-          wsLog({ event: "disconnected", code, reason });
           wsLog({ event: "reconnecting", attempt: reconnectAttempt, delay_ms: Math.round(delay) });
           setTimeout(connect, delay);
-        };
-        ws.onerror = () => {};
-        return ws;
-      }
-      return connect();
-    },
-    async sendLog(roomId, sender, content, color, messageId) {
-      return withRetry(async () => {
-        const res = await fetch(`${baseUrl}/api/rooms/${roomId}/logs`, {
-          method: "POST",
-          headers: headers(),
-          body: JSON.stringify({
-            sender,
-            content,
-            ...color && { color },
-            ...messageId && { message_id: messageId }
-          })
-        });
-        if (!res.ok) {
-          const err2 = await res.json().catch(() => ({}));
-          throw new Error(err2.error ?? `HTTP ${res.status}`);
         }
-        return res.json();
-      });
-    },
-    async sendTeamInfo(roomId, payload) {
-      return withRetry(async () => {
-        const res = await fetch(`${baseUrl}/api/rooms/${roomId}/team-info`, {
-          method: "POST",
-          headers: headers(),
-          body: payload
-        });
-        if (!res.ok) {
-          const err2 = await res.json().catch(() => ({}));
-          const msg = err2.error;
-          throw new Error(typeof msg === "string" ? msg : msg ? JSON.stringify(msg) : `HTTP ${res.status}`);
-        }
-        return res.text();
-      });
-    },
-    async sendCommands(roomId, payload) {
-      return withRetry(async () => {
-        const res = await fetch(`${baseUrl}/api/rooms/${roomId}/commands`, {
-          method: "POST",
-          headers: headers(),
-          body: payload
-        });
-        if (!res.ok) {
-          const err2 = await res.json().catch(() => ({}));
-          const msg = err2.error;
-          throw new Error(typeof msg === "string" ? msg : msg ? JSON.stringify(msg) : `HTTP ${res.status}`);
+      }, 30000);
+      ws.onopen = async () => {
+        clearTimeout(connectTimeout);
+        const wasReconnect = reconnectAttempt > 0;
+        reconnectAttempt = 0;
+        wsLog({ event: wasReconnect ? "reconnected" : "connected" });
+        if (pingInterval)
+          clearInterval(pingInterval);
+        pingInterval = setInterval(() => {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({ type: "ping" }));
+          }
+        }, 30000);
+        if (lastSeenId) {
+          try {
+            const missed = await transport.getJson(`/api/rooms/${roomId}/messages`, { query: { after: lastSeenId } });
+            if (missed.length)
+              wsLog({ event: "catchup", count: missed.length });
+            for (const msg of missed)
+              deliver(msg);
+          } catch {}
         }
-        return res.text();
-      });
-    },
-    async sendTasks(roomId, payload) {
-      return withRetry(async () => {
-        const res = await fetch(`${baseUrl}/api/rooms/${roomId}/tasks`, {
-          method: "POST",
-          headers: headers(),
-          body: payload
-        });
-        if (!res.ok) {
-          const err2 = await res.json().catch(() => ({}));
-          throw new Error(err2.error ?? `HTTP ${res.status}`);
+      };
+      ws.onmessage = (event) => {
+        const text = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
+        const data = JSON.parse(text);
+        if (data.type === "pong")
+          return;
+        if (data.type === "terminal_subscribe" || data.type === "terminal_unsubscribe") {
+          options?.onMessage?.(data);
+          return;
         }
-        return res.text();
-      });
-    },
-    async getMessageAttachments(roomId, messageId) {
-      const res = await fetch(`${baseUrl}/api/rooms/${roomId}/messages/${messageId}/attachments`, {
-        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined
-      });
-      if (!res.ok) {
-        const err2 = await res.json().catch(() => ({}));
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
-      }
-      return res.json();
-    },
-    async downloadAttachment(attachmentId) {
-      cleanupOldAttachments();
-      const res = await fetch(`${baseUrl}/api/attachments/${attachmentId}`, {
-        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined
-      });
-      if (!res.ok) {
-        const err2 = await res.json().catch(() => ({}));
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
-      }
-      const { mkdirSync, writeFileSync } = await import("node:fs");
-      const dir = "/tmp/meet-ai-attachments";
-      mkdirSync(dir, { recursive: true });
-      const safeId = attachmentId.replace(/[^a-zA-Z0-9_-]/g, "") || "unknown";
-      const localPath = `${dir}/${safeId}.bin`;
-      const buffer = Buffer.from(await res.arrayBuffer());
-      writeFileSync(localPath, buffer);
-      return localPath;
-    },
-    listenLobby(options) {
-      const wsUrl = baseUrl.replace(/^http/, "ws");
-      const tokenParam = apiKey ? `?token=${apiKey}` : "";
-      let pingInterval = null;
-      let reconnectAttempt = 0;
-      let reconnectScheduled = false;
-      const log = options?.silent ? () => {} : wsLog;
-      function getReconnectDelay() {
-        const delay = Math.min(1000 * 2 ** Math.min(reconnectAttempt, 4), 15000);
-        reconnectAttempt++;
-        return delay + delay * 0.5 * Math.random();
-      }
-      function scheduleReconnect() {
-        if (reconnectScheduled)
+        if (data.type === "terminal_data")
           return;
-        reconnectScheduled = true;
+        deliver(data);
+      };
+      ws.onclose = (event) => {
+        clearTimeout(connectTimeout);
+        if (pingInterval)
+          clearInterval(pingInterval);
+        const code = event.code;
+        if (code === 1000) {
+          wsLog({ event: "closed", code: 1000 });
+          return;
+        }
+        const reason = code === 1006 ? "network drop" : code === 1012 ? "service restart" : code === 1013 ? "server back-off" : `code ${code}`;
         const delay = getReconnectDelay();
-        log({ event: "reconnecting", attempt: reconnectAttempt, delay_ms: Math.round(delay) });
-        setTimeout(() => {
-          reconnectScheduled = false;
-          connect();
-        }, delay);
-      }
-      function connect() {
-        const ws = new WebSocket(`${wsUrl}/api/lobby/ws${tokenParam}`);
-        const connectTimeout = setTimeout(() => {
-          if (ws.readyState !== WebSocket.OPEN) {
-            try {
-              ws.close(4000, "connect timeout");
-            } catch {}
-            scheduleReconnect();
-          }
-        }, 30000);
-        ws.onopen = () => {
-          clearTimeout(connectTimeout);
-          reconnectAttempt = 0;
-          log({ event: "lobby_connected" });
-          if (pingInterval)
-            clearInterval(pingInterval);
-          pingInterval = setInterval(() => {
-            if (ws.readyState === WebSocket.OPEN) {
-              ws.send(JSON.stringify({ type: "ping" }));
-            }
-          }, 30000);
-        };
-        ws.onmessage = (event) => {
-          const text = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
+        wsLog({ event: "disconnected", code, reason });
+        wsLog({ event: "reconnecting", attempt: reconnectAttempt, delay_ms: Math.round(delay) });
+        setTimeout(connect, delay);
+      };
+      ws.onerror = () => {};
+      return ws;
+    }
+    return connect();
+  }
+  listenLobby(options) {
+    const wsUrl = this.baseUrl.replace(/^http/, "ws");
+    const wsHeaders = this.apiKey ? { headers: { Authorization: `Bearer ${this.apiKey}` } } : undefined;
+    let pingInterval = null;
+    let reconnectAttempt = 0;
+    let reconnectScheduled = false;
+    const log = options?.silent ? () => {} : wsLog;
+    function getReconnectDelay() {
+      const delay = Math.min(1000 * 2 ** Math.min(reconnectAttempt, 4), 15000);
+      reconnectAttempt++;
+      return delay + delay * 0.5 * Math.random();
+    }
+    function scheduleReconnect() {
+      if (reconnectScheduled)
+        return;
+      reconnectScheduled = true;
+      const delay = getReconnectDelay();
+      log({ event: "reconnecting", attempt: reconnectAttempt, delay_ms: Math.round(delay) });
+      setTimeout(() => {
+        reconnectScheduled = false;
+        connect();
+      }, delay);
+    }
+    function connect() {
+      const ws = new WebSocket(`${wsUrl}/api/lobby/ws`, wsHeaders);
+      const connectTimeout = setTimeout(() => {
+        if (ws.readyState !== WebSocket.OPEN) {
           try {
-            const data = JSON.parse(text);
-            if (data.type === "pong")
-              return;
-            if (data.type === "room_created" && data.id && data.name) {
-              options?.onRoomCreated?.(data.id, data.name);
-            }
-            if (data.type === "spawn_request" && data.room_name) {
-              options?.onSpawnRequest?.(data.room_name);
-            }
+            ws.close(4000, "connect timeout");
           } catch {}
-        };
-        ws.onclose = (event) => {
-          clearTimeout(connectTimeout);
-          if (pingInterval)
-            clearInterval(pingInterval);
-          if (event.code === 1000)
-            return;
           scheduleReconnect();
-        };
-        ws.onerror = () => {};
-        return ws;
+        }
+      }, 30000);
+      ws.onopen = () => {
+        clearTimeout(connectTimeout);
+        reconnectAttempt = 0;
+        log({ event: "lobby_connected" });
+        if (pingInterval)
+          clearInterval(pingInterval);
+        pingInterval = setInterval(() => {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({ type: "ping" }));
+          }
+        }, 30000);
+      };
+      ws.onmessage = (event) => {
+        const text = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
+        try {
+          const data = JSON.parse(text);
+          if (data.type === "pong")
+            return;
+          if (data.type === "room_created" && data.id && data.name) {
+            options?.onRoomCreated?.(data.id, data.name);
+          }
+          if (data.type === "spawn_request" && 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 {}
+      };
+      ws.onclose = (event) => {
+        clearTimeout(connectTimeout);
+        if (pingInterval)
+          clearInterval(pingInterval);
+        if (event.code === 1000)
+          return;
+        scheduleReconnect();
+      };
+      ws.onerror = () => {};
+      return ws;
+    }
+    return connect();
+  }
+  async generateKey() {
+    return this.transport.postJson("/api/keys");
+  }
+}
+var init_ConnectionAdapter = __esm(() => {
+  init_coding_agents();
+});
+
+// src/domain/adapters/FileSystemAdapter.ts
+import {
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync3,
+  statSync as statSync2
+} from "node:fs";
+
+class FileSystemAdapter {
+  readFileSync(path, encoding) {
+    return readFileSync3(path, encoding);
+  }
+  writeFileSync(path, data, encoding) {
+    writeFileSync2(path, data, encoding);
+  }
+  mkdirSync(path, opts) {
+    mkdirSync2(path, opts);
+  }
+  existsSync(path) {
+    return existsSync3(path);
+  }
+  statSync(path) {
+    const stat = statSync2(path);
+    return { mtimeMs: stat.mtimeMs, size: stat.size };
+  }
+}
+var init_FileSystemAdapter = () => {};
+
+// src/domain/repositories/MessageRepository.ts
+class MessageRepository {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async send(roomId, sender, content, color) {
+    return this.transport.postJson(`/api/rooms/${roomId}/messages`, { sender, content, sender_type: "agent", ...color && { color } }, RETRY);
+  }
+  async list(roomId, opts) {
+    const query = {};
+    if (opts?.after)
+      query.after = opts.after;
+    if (opts?.exclude)
+      query.exclude = opts.exclude;
+    if (opts?.senderType)
+      query.sender_type = opts.senderType;
+    return this.transport.getJson(`/api/rooms/${roomId}/messages`, { query });
+  }
+  async sendLog(roomId, sender, content, opts) {
+    return this.transport.postJson(`/api/rooms/${roomId}/logs`, {
+      sender,
+      content,
+      ...opts?.color && { color: opts.color },
+      ...opts?.messageId && { message_id: opts.messageId }
+    }, RETRY);
+  }
+}
+var RETRY;
+var init_MessageRepository = __esm(() => {
+  RETRY = { retry: { maxRetries: 3, baseDelay: 1000 } };
+});
+
+// src/domain/repositories/RoomRepository.ts
+class RoomRepository {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async create(name) {
+    return this.transport.postJson("/api/rooms", { name });
+  }
+  async delete(roomId) {
+    return this.transport.del(`/api/rooms/${roomId}`);
+  }
+  async sendTeamInfo(roomId, payload) {
+    return this.transport.postText(`/api/rooms/${roomId}/team-info`, JSON.parse(payload), {
+      retry: RETRY2
+    });
+  }
+  async sendCommands(roomId, payload) {
+    return this.transport.postText(`/api/rooms/${roomId}/commands`, JSON.parse(payload), {
+      retry: RETRY2
+    });
+  }
+  async sendTasks(roomId, payload) {
+    return this.transport.postText(`/api/rooms/${roomId}/tasks`, JSON.parse(payload), {
+      retry: RETRY2
+    });
+  }
+  async sendTerminalData(roomId, data) {
+    try {
+      await this.transport.postJson(`/api/rooms/${roomId}/terminal`, { data });
+    } catch {}
+  }
+}
+var RETRY2;
+var init_RoomRepository = __esm(() => {
+  RETRY2 = { maxRetries: 3, baseDelay: 1000 };
+});
+
+// src/domain/repositories/AttachmentRepository.ts
+class AttachmentRepository {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async listForMessage(roomId, messageId) {
+    return this.transport.getJson(`/api/rooms/${roomId}/messages/${messageId}/attachments`);
+  }
+  async download(attachmentId) {
+    return this.transport.getRaw(`/api/attachments/${attachmentId}`);
+  }
+}
+
+// src/domain/usecases/SendMessage.ts
+class SendMessage {
+  messageRepository;
+  constructor(messageRepository) {
+    this.messageRepository = messageRepository;
+  }
+  async execute(roomId, sender, content, color) {
+    return this.messageRepository.send(roomId, sender, content, color);
+  }
+}
+
+// src/domain/usecases/CreateRoom.ts
+class CreateRoom {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(name) {
+    return this.roomRepository.create(name);
+  }
+}
+
+// src/domain/usecases/DeleteRoom.ts
+class DeleteRoom {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(roomId) {
+    return this.roomRepository.delete(roomId);
+  }
+}
+
+// src/domain/usecases/SendLog.ts
+class SendLog {
+  messageRepository;
+  constructor(messageRepository) {
+    this.messageRepository = messageRepository;
+  }
+  async execute(roomId, sender, content, opts) {
+    return this.messageRepository.sendLog(roomId, sender, content, opts);
+  }
+}
+
+// src/domain/usecases/SendTeamInfo.ts
+class SendTeamInfo {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(roomId, payload) {
+    return this.roomRepository.sendTeamInfo(roomId, payload);
+  }
+}
+
+// src/domain/usecases/SendCommands.ts
+class SendCommands {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(roomId, payload) {
+    return this.roomRepository.sendCommands(roomId, payload);
+  }
+}
+
+// src/domain/usecases/SendTasks.ts
+class SendTasks {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(roomId, payload) {
+    return this.roomRepository.sendTasks(roomId, payload);
+  }
+}
+
+// src/domain/usecases/SendTerminalData.ts
+class SendTerminalData {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(roomId, data) {
+    return this.roomRepository.sendTerminalData(roomId, data);
+  }
+}
+
+// src/domain/services/InboxRouter.ts
+import { dirname as dirname2 } from "node:path";
+
+class InboxRouter {
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  route(msg, opts) {
+    const entry = {
+      from: `meet-ai:${msg.sender}`,
+      text: msg.content,
+      timestamp: new Date().toISOString(),
+      read: false
+    };
+    if (opts.attachmentPaths?.length) {
+      entry.attachments = opts.attachmentPaths;
+    }
+    const members = this.getTeamMembers(opts.teamDir);
+    const targets = this.resolveInboxTargets(msg.content, members);
+    if (targets) {
+      for (const target of targets) {
+        this.appendToInbox(`${opts.inboxDir}/${target}.json`, entry);
+      }
+    } else if (opts.defaultInboxPath) {
+      this.appendToInbox(opts.defaultInboxPath, entry);
+    }
+  }
+  checkIdle(opts) {
+    const members = this.getTeamMembers(opts.teamDir);
+    const newlyIdle = this.checkIdleAgents(opts.inboxDir, members, opts.inbox, opts.notified);
+    for (const agent of newlyIdle) {
+      opts.notified.add(agent);
+      if (opts.defaultInboxPath) {
+        this.appendToInbox(opts.defaultInboxPath, {
+          from: "meet-ai:idle-check",
+          text: `${agent} idle for 5+ minutes`,
+          timestamp: new Date().toISOString(),
+          read: false
+        });
       }
-      return connect();
-    },
-    async generateKey() {
-      const res = await fetch(`${baseUrl}/api/keys`, {
-        method: "POST",
-        headers: headers()
-      });
-      if (!res.ok) {
-        const err2 = await res.json();
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
+    }
+  }
+  appendToInbox(path, entry) {
+    this.fs.mkdirSync(dirname2(path), { recursive: true });
+    let messages = [];
+    try {
+      messages = JSON.parse(this.fs.readFileSync(path, "utf-8"));
+    } catch {}
+    messages.push(entry);
+    this.fs.writeFileSync(path, JSON.stringify(messages, null, 2));
+  }
+  getTeamMembers(teamDir) {
+    try {
+      const config2 = JSON.parse(this.fs.readFileSync(`${teamDir}/config.json`, "utf-8"));
+      return new Set(config2.members?.map((m) => m.name) || []);
+    } catch {
+      return new Set;
+    }
+  }
+  resolveInboxTargets(content, members) {
+    const mentions = content.match(/@([\w-]+)/g);
+    if (!mentions)
+      return null;
+    const valid = [...new Set(mentions.map((m) => m.slice(1)))].filter((name) => members.has(name));
+    return valid.length > 0 ? valid : null;
+  }
+  checkIdleAgents(inboxDir, members, excludeAgent, notified, now = Date.now()) {
+    const newlyIdle = [];
+    for (const member of members) {
+      if (member === excludeAgent)
+        continue;
+      const inboxPath = `${inboxDir}/${member}.json`;
+      let mtime;
+      try {
+        mtime = this.fs.statSync(inboxPath).mtimeMs;
+      } catch {
+        continue;
       }
-      return res.json();
-    },
-    async deleteRoom(roomId) {
-      const res = await fetch(`${baseUrl}/api/rooms/${roomId}`, {
-        method: "DELETE",
-        headers: headers()
-      });
-      if (!res.ok) {
-        const err2 = await res.json().catch(() => ({}));
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
+      const idleMs = now - mtime;
+      if (idleMs >= IDLE_THRESHOLD_MS) {
+        if (!notified.has(member)) {
+          newlyIdle.push(member);
+        }
+      } else {
+        notified.delete(member);
       }
-    },
-    async sendTerminalData(roomId, data) {
-      try {
-        await fetch(`${baseUrl}/api/rooms/${roomId}/terminal`, {
-          method: "POST",
-          headers: headers(),
-          body: JSON.stringify({ data })
-        });
-      } catch {}
     }
-  };
+    return newlyIdle;
+  }
 }
-var ATTACHMENTS_DIR = "/tmp/meet-ai-attachments", MAX_AGE_MS;
-var init_client = __esm(() => {
-  MAX_AGE_MS = 5 * 60 * 1000;
+var IDLE_THRESHOLD_MS;
+var init_InboxRouter = __esm(() => {
+  IDLE_THRESHOLD_MS = 5 * 60 * 1000;
 });
 
-// src/lib/client-factory.ts
-var exports_client_factory = {};
-__export(exports_client_factory, {
+// src/domain/usecases/Listen.ts
+class Listen {
+  connectionAdapter;
+  messageRepository;
+  constructor(connectionAdapter, messageRepository) {
+    this.connectionAdapter = connectionAdapter;
+    this.messageRepository = messageRepository;
+  }
+  execute(roomId, opts) {
+    return this.connectionAdapter.listen(roomId, opts);
+  }
+}
+
+// src/domain/usecases/ListenLobby.ts
+class ListenLobby {
+  connectionAdapter;
+  constructor(connectionAdapter) {
+    this.connectionAdapter = connectionAdapter;
+  }
+  execute(opts) {
+    return this.connectionAdapter.listenLobby(opts);
+  }
+}
+
+// src/domain/usecases/Poll.ts
+class Poll {
+  messageRepository;
+  constructor(messageRepository) {
+    this.messageRepository = messageRepository;
+  }
+  async execute(roomId, opts) {
+    return this.messageRepository.list(roomId, opts);
+  }
+}
+
+// src/domain/usecases/GenerateKey.ts
+class GenerateKey {
+  connectionAdapter;
+  constructor(connectionAdapter) {
+    this.connectionAdapter = connectionAdapter;
+  }
+  async execute() {
+    return this.connectionAdapter.generateKey();
+  }
+}
+
+// src/domain/usecases/GetAttachments.ts
+class GetAttachments {
+  attachmentRepository;
+  constructor(attachmentRepository) {
+    this.attachmentRepository = attachmentRepository;
+  }
+  async execute(roomId, messageId) {
+    return this.attachmentRepository.listForMessage(roomId, messageId);
+  }
+}
+
+// src/domain/usecases/DownloadAttachment.ts
+class DownloadAttachment {
+  attachmentRepository;
+  constructor(attachmentRepository) {
+    this.attachmentRepository = attachmentRepository;
+  }
+  async execute(attachmentId) {
+    return this.attachmentRepository.download(attachmentId);
+  }
+}
+
+// src/domain/bootstrap.ts
+var exports_bootstrap = {};
+__export(exports_bootstrap, {
+  getContainer: () => getContainer,
   getClient: () => getClient
 });
+function cleanupOldAttachments() {
+  try {
+    const { readdirSync: readdirSync2, statSync: statSync3, unlinkSync } = __require("node:fs");
+    const now = Date.now();
+    for (const entry of readdirSync2(ATTACHMENTS_DIR)) {
+      try {
+        const filePath = `${ATTACHMENTS_DIR}/${entry}`;
+        const mtime = statSync3(filePath).mtimeMs;
+        if (now - mtime > MAX_AGE_MS) {
+          unlinkSync(filePath);
+        }
+      } catch {}
+    }
+  } catch {}
+}
+function createContainer() {
+  const config2 = getMeetAiConfig();
+  const transport = new HttpTransport(config2.url, config2.key);
+  const messageRepository = new MessageRepository(transport);
+  const roomRepository = new RoomRepository(transport);
+  const attachmentRepository = new AttachmentRepository(transport);
+  const connectionAdapter = new ConnectionAdapter(transport, config2.url, config2.key);
+  const fileSystem = new FileSystemAdapter;
+  const inboxRouter = new InboxRouter(fileSystem);
+  return {
+    sendMessage: new SendMessage(messageRepository),
+    createRoom: new CreateRoom(roomRepository),
+    deleteRoom: new DeleteRoom(roomRepository),
+    sendLog: new SendLog(messageRepository),
+    sendTeamInfo: new SendTeamInfo(roomRepository),
+    sendCommands: new SendCommands(roomRepository),
+    sendTasks: new SendTasks(roomRepository),
+    sendTerminalData: new SendTerminalData(roomRepository),
+    listen: new Listen(connectionAdapter, messageRepository),
+    listenLobby: new ListenLobby(connectionAdapter),
+    poll: new Poll(messageRepository),
+    generateKey: new GenerateKey(connectionAdapter),
+    getAttachments: new GetAttachments(attachmentRepository),
+    downloadAttachment: new DownloadAttachment(attachmentRepository),
+    inboxRouter
+  };
+}
+function getContainer() {
+  if (!container) {
+    container = createContainer();
+  }
+  return container;
+}
 function getClient() {
-  if (!_client) {
-    const config2 = getMeetAiConfig();
-    _client = createClient(config2.url, config2.key);
-  }
-  return _client;
+  const c = getContainer();
+  return {
+    createRoom: (name) => c.createRoom.execute(name),
+    sendMessage: (roomId, sender, content, color) => c.sendMessage.execute(roomId, sender, content, color),
+    getMessages: (roomId, options) => c.poll.execute(roomId, options),
+    listen: (roomId, options) => c.listen.execute(roomId, options),
+    sendLog: (roomId, sender, content, color, messageId) => c.sendLog.execute(roomId, sender, content, { color, messageId }),
+    sendTeamInfo: (roomId, payload) => c.sendTeamInfo.execute(roomId, payload),
+    sendCommands: (roomId, payload) => c.sendCommands.execute(roomId, payload),
+    sendTasks: (roomId, payload) => c.sendTasks.execute(roomId, payload),
+    getMessageAttachments: (roomId, messageId) => c.getAttachments.execute(roomId, messageId),
+    downloadAttachment: async (attachmentId) => {
+      cleanupOldAttachments();
+      const response = await c.downloadAttachment.execute(attachmentId);
+      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());
+      writeFileSync3(localPath, buffer);
+      return localPath;
+    },
+    listenLobby: (options) => c.listenLobby.execute(options),
+    generateKey: () => c.generateKey.execute(),
+    deleteRoom: (roomId) => c.deleteRoom.execute(roomId),
+    sendTerminalData: (roomId, data) => c.sendTerminalData.execute(roomId, data)
+  };
 }
-var _client = null;
-var init_client_factory = __esm(() => {
+var ATTACHMENTS_DIR = "/tmp/meet-ai-attachments", MAX_AGE_MS, container = null;
+var init_bootstrap = __esm(() => {
   init_config();
-  init_client();
+  init_ConnectionAdapter();
+  init_FileSystemAdapter();
+  init_MessageRepository();
+  init_RoomRepository();
+  init_InboxRouter();
+  MAX_AGE_MS = 5 * 60 * 1000;
 });
 
 // src/commands/create-room/schema.ts
@@ -14909,7 +15385,7 @@ __export(exports_command, {
 var command_default;
 var init_command = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase();
   init_output();
   command_default = defineCommand({
@@ -14964,7 +15440,7 @@ __export(exports_command2, {
 var command_default2;
 var init_command2 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase2();
   init_output();
   command_default2 = defineCommand({
@@ -15040,7 +15516,7 @@ __export(exports_command3, {
 var command_default3;
 var init_command3 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase3();
   init_output();
   command_default3 = defineCommand({
@@ -15123,7 +15599,7 @@ __export(exports_command4, {
 var command_default4;
 var init_command4 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase4();
   init_output();
   command_default4 = defineCommand({
@@ -15241,7 +15717,7 @@ __export(exports_command5, {
 var command_default5;
 var init_command5 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase5();
   init_output();
   command_default5 = defineCommand({
@@ -15288,78 +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
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync, statSync } from "node:fs";
-import { dirname } from "node:path";
-function appendToInbox(path, entry) {
-  mkdirSync(dirname(path), { recursive: true });
-  let messages = [];
-  try {
-    messages = JSON.parse(readFileSync2(path, "utf-8"));
-  } catch {}
-  messages.push(entry);
-  writeFileSync(path, JSON.stringify(messages, null, 2));
-}
-function getTeamMembers(teamDir) {
-  try {
-    const config2 = JSON.parse(readFileSync2(`${teamDir}/config.json`, "utf-8"));
-    return new Set(config2.members?.map((m) => m.name) || []);
-  } catch {
-    return new Set;
-  }
-}
-function resolveInboxTargets(content, members) {
-  const mentions = content.match(/@([\w-]+)/g);
-  if (!mentions)
-    return null;
-  const valid = [...new Set(mentions.map((m) => m.slice(1)))].filter((name) => members.has(name));
-  return valid.length > 0 ? valid : null;
-}
-function checkIdleAgents(inboxDir, members, excludeAgent, notified, now = Date.now()) {
-  const newlyIdle = [];
-  for (const member of members) {
-    if (member === excludeAgent)
-      continue;
-    const inboxPath = `${inboxDir}/${member}.json`;
-    let mtime;
-    try {
-      mtime = statSync(inboxPath).mtimeMs;
-    } catch {
-      continue;
-    }
-    const idleMs = now - mtime;
-    if (idleMs >= IDLE_THRESHOLD_MS) {
-      if (!notified.has(member)) {
-        newlyIdle.push(member);
-      }
-    } else {
-      notified.delete(member);
-    }
-  }
-  return newlyIdle;
-}
-var IDLE_CHECK_INTERVAL_MS = 60000, IDLE_THRESHOLD_MS;
-var init_inbox_router = __esm(() => {
-  IDLE_THRESHOLD_MS = 5 * 60 * 1000;
-});
-
 // src/lib/tmux-client.ts
 import { execFileSync, execFile as execFileCb } from "node:child_process";
 function validateSessionName(name) {
@@ -15367,10 +15793,10 @@ function validateSessionName(name) {
     throw new Error(`Invalid tmux session name: ${name}`);
   }
 }
-function parseVersion(version2) {
-  if (!version2)
+function parseVersion(version3) {
+  if (!version3)
     return [0, 0];
-  const match = version2.match(/(\d+)\.(\d+)/);
+  const match = version3.match(/(\d+)\.(\d+)/);
   if (!match)
     return [0, 0];
   return [Number(match[1]), Number(match[2])];
@@ -15390,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 {
@@ -15401,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,
@@ -15418,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"]);
@@ -15465,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 ?? "" };
@@ -15524,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(`
@@ -15535,7 +15956,7 @@ class TmuxClient {
         while (result.length > 0 && result[result.length - 1] === "") {
           result.pop();
         }
-        resolve2(result);
+        resolve3(result);
       });
     });
   }
@@ -15579,36 +16000,12 @@ var init_tmux_client = __esm(() => {
   SESSION_NAME_RE = /^[a-zA-Z0-9_-]+$/;
 });
 
-// src/commands/listen/usecase.ts
-function routeToInbox(msg, inboxDir, defaultInboxPath, teamDir, stdinPane, attachmentPaths) {
-  const entry = {
-    from: `meet-ai:${msg.sender}`,
-    text: msg.content,
-    timestamp: new Date().toISOString(),
-    read: false
-  };
-  if (attachmentPaths?.length) {
-    entry.attachments = attachmentPaths;
-  }
-  const members = getTeamMembers(teamDir);
-  const targets = resolveInboxTargets(msg.content, members);
-  if (targets) {
-    for (const target of targets) {
-      appendToInbox(`${inboxDir}/${target}.json`, entry);
-    }
-  } else if (stdinPane) {} else if (defaultInboxPath) {
-    appendToInbox(defaultInboxPath, entry);
-  }
-}
-function listen(client, input) {
-  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) {
@@ -15620,7 +16017,7 @@ function listen(client, input) {
           }
         });
       }
-      return;
+      return true;
     }
     if (msg.type === "terminal_subscribe") {
       const roomPrefix = roomId.slice(0, 8);
@@ -15673,50 +16070,76 @@ function listen(client, input) {
           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)
-          routeToInbox(msg, inboxDir, defaultInboxPath, teamDir, stdinPane, paths);
+        if (inboxDir && teamDir && inboxRouter) {
+          inboxRouter.route(msg, {
+            inboxDir,
+            defaultInboxPath,
+            teamDir,
+            attachmentPaths: paths
+          });
+        }
       });
-    } else {
-      console.log(JSON.stringify(msg));
-      if (inboxDir && teamDir)
-        routeToInbox(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 });
   let idleCheckTimeout = null;
   const idleNotified = new Set;
-  if (inboxDir && inbox && teamDir) {
+  if (inboxDir && inbox && teamDir && inboxRouter) {
     let scheduleIdleCheck = function() {
       idleCheckTimeout = setTimeout(() => {
-        const members = getTeamMembers(teamDir);
-        const newlyIdle = checkIdleAgents(inboxDir, members, inbox, idleNotified);
-        for (const agent of newlyIdle) {
-          idleNotified.add(agent);
-          if (defaultInboxPath) {
-            appendToInbox(defaultInboxPath, {
-              from: "meet-ai:idle-check",
-              text: `${agent} idle for 5+ minutes`,
-              timestamp: new Date().toISOString(),
-              read: false
-            });
-          }
-        }
+        inboxRouter.checkIdle({
+          inboxDir,
+          teamDir,
+          inbox,
+          defaultInboxPath: defaultInboxPath ?? null,
+          notified: idleNotified
+        });
         scheduleIdleCheck();
       }, IDLE_CHECK_INTERVAL_MS);
     };
@@ -15725,10 +16148,621 @@ function listen(client, input) {
   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");
     }
@@ -15739,10 +16773,11 @@ function listen(client, input) {
   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
@@ -15752,10 +16787,11 @@ __export(exports_command6, {
 });
 var command_default6;
 var init_command6 = __esm(() => {
-  init_dist();
-  init_client_factory();
-  init_usecase6();
+  init_bootstrap();
   init_output();
+  init_dist();
+  init_listen_claude();
+  init_listen_codex();
   command_default6 = defineCommand({
     meta: {
       name: "listen",
@@ -15786,24 +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();
-        listen(client, {
+        const container2 = getContainer();
+        const input = {
           roomId: args.roomId,
           exclude: args.exclude,
           senderType: args["sender-type"],
           team: args.team,
-          inbox: args.inbox,
-          stdinPane: args["stdin-pane"]
-        });
+          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);
@@ -15835,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();
 });
@@ -15848,8 +16884,8 @@ __export(exports_command7, {
 var command_default7;
 var init_command7 = __esm(() => {
   init_dist();
-  init_client_factory();
-  init_usecase7();
+  init_bootstrap();
+  init_usecase6();
   init_output();
   command_default7 = defineCommand({
     meta: {
@@ -15903,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();
 });
@@ -15916,8 +16952,8 @@ __export(exports_command8, {
 var command_default8;
 var init_command8 = __esm(() => {
   init_dist();
-  init_client_factory();
-  init_usecase8();
+  init_bootstrap();
+  init_usecase7();
   init_output();
   command_default8 = defineCommand({
     meta: {
@@ -15964,7 +17000,7 @@ async function downloadAttachment(client, input) {
   ok(localPath);
   return localPath;
 }
-var init_usecase9 = __esm(() => {
+var init_usecase8 = __esm(() => {
   init_schema9();
   init_output();
 });
@@ -15977,8 +17013,8 @@ __export(exports_command9, {
 var command_default9;
 var init_command9 = __esm(() => {
   init_dist();
-  init_client_factory();
-  init_usecase9();
+  init_bootstrap();
+  init_usecase8();
   init_output();
   command_default9 = defineCommand({
     meta: {
@@ -16020,7 +17056,7 @@ __export(exports_command10, {
 var command_default10;
 var init_command10 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_output();
   command_default10 = defineCommand({
     meta: {
@@ -16041,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
     });
@@ -16074,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) {
@@ -16082,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)
@@ -16094,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) {
@@ -16264,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;
@@ -16481,14 +17517,14 @@ var createProxy = (callback, path) => {
   }
   return req;
 }, []);
-var init_client2 = __esm(() => {
+var init_client = __esm(() => {
   init_cookie();
   init_utils();
 });
 
 // ../../node_modules/.bun/hono@4.11.8/node_modules/hono/dist/client/index.js
-var init_client3 = __esm(() => {
-  init_client2();
+var init_client2 = __esm(() => {
+  init_client();
   init_utils();
 });
 
@@ -16542,35 +17578,35 @@ async function sendLogEntry(client, roomId, summary, messageId) {
   } catch {}
 }
 var HOOK_COLOR = "#6b7280", HOOK_SENDER = "hook";
-var init_client4 = __esm(() => {
-  init_client3();
+var init_client3 = __esm(() => {
+  init_client2();
 });
 
 // src/lib/hooks/index.ts
 var init_hooks = __esm(() => {
   init_find_room();
   init_summarize();
-  init_client4();
+  init_client3();
 });
 
 // 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) {
@@ -16674,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();
 });
 
@@ -16686,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",
@@ -16851,8 +17887,8 @@ async function processPlanReview(rawInput, teamsDir) {
   }
 }
 var POLL_INTERVAL_MS = 2000, POLL_TIMEOUT_MS = 2592000000;
-var init_usecase11 = __esm(() => {
-  init_client4();
+var init_usecase10 = __esm(() => {
+  init_client3();
   init_find_room();
 });
 
@@ -16875,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}
@@ -16947,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;
 }
@@ -17047,8 +18083,8 @@ async function processQuestionReview(rawInput, teamsDir, opts) {
   }
 }
 var POLL_INTERVAL_MS2 = 2000, POLL_TIMEOUT_MS2 = 1800000;
-var init_usecase12 = __esm(() => {
-  init_client4();
+var init_usecase11 = __esm(() => {
+  init_client3();
   init_find_room();
 });
 
@@ -17060,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",
@@ -17139,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;
 }
@@ -17245,8 +18281,8 @@ async function processPermissionReview(rawInput, teamsDir, opts) {
   }
 }
 var POLL_INTERVAL_MS3 = 2000, POLL_TIMEOUT_MS3 = 1800000;
-var init_usecase13 = __esm(() => {
-  init_client4();
+var init_usecase12 = __esm(() => {
+  init_client3();
   init_find_room();
 });
 
@@ -17258,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",
@@ -17303,21 +18339,21 @@ var init_command15 = __esm(() => {
 });
 
 // src/commands/setup-hooks/usecase.ts
-import { existsSync as existsSync2 } 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 (!existsSync2(path)) {
+  if (!existsSync4(path)) {
     return {};
   }
   const raw = await readFile(path, "utf-8");
@@ -17399,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) {
@@ -17416,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) {
@@ -17426,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 = {
@@ -17485,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: {
@@ -17525,10 +18561,10 @@ var init_command16 = __esm(() => {
 });
 
 // src/commands/list-commands/usecase.ts
-import { existsSync as existsSync3 } 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)
@@ -17544,8 +18580,8 @@ function parseYamlFrontmatter(content) {
   };
 }
 async function readSkillsFromDir(baseDir, source, scope) {
-  const skillsDir = join3(baseDir, "skills");
-  if (!existsSync3(skillsDir))
+  const skillsDir = join4(baseDir, "skills");
+  if (!existsSync5(skillsDir))
     return [];
   let entries;
   try {
@@ -17555,8 +18591,8 @@ async function readSkillsFromDir(baseDir, source, scope) {
   }
   const results = [];
   for (const entry of entries) {
-    const skillFile = join3(skillsDir, entry, "SKILL.md");
-    if (!existsSync3(skillFile))
+    const skillFile = join4(skillsDir, entry, "SKILL.md");
+    if (!existsSync5(skillFile))
       continue;
     try {
       const content = await readFile2(skillFile, "utf-8");
@@ -17579,7 +18615,7 @@ async function readSkillsFromDir(baseDir, source, scope) {
   return results;
 }
 async function readCommandsFromDir(commandsDir, source, scope) {
-  if (!existsSync3(commandsDir))
+  if (!existsSync5(commandsDir))
     return [];
   const results = [];
   async function scanDir(dir) {
@@ -17590,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")) {
@@ -17617,7 +18653,7 @@ async function readCommandsFromDir(commandsDir, source, scope) {
   return results;
 }
 async function readSettings2(settingsPath) {
-  if (!existsSync3(settingsPath))
+  if (!existsSync5(settingsPath))
     return {};
   try {
     const raw = await readFile2(settingsPath, "utf-8");
@@ -17627,7 +18663,7 @@ async function readSettings2(settingsPath) {
   }
 }
 async function readInstalledPlugins(pluginsFile) {
-  if (!existsSync3(pluginsFile))
+  if (!existsSync5(pluginsFile))
     return {};
   try {
     const raw = await readFile2(pluginsFile, "utf-8");
@@ -17638,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;
@@ -17666,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);
@@ -17674,7 +18710,7 @@ async function listCommands(options) {
   }
   return results;
 }
-var init_usecase15 = () => {};
+var init_usecase14 = () => {};
 
 // src/commands/list-commands/command.ts
 var exports_command17 = {};
@@ -17684,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: {
@@ -17718,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();
 });
 
@@ -17731,8 +18767,8 @@ __export(exports_command18, {
 var command_default18;
 var init_command18 = __esm(() => {
   init_dist();
-  init_client_factory();
-  init_usecase16();
+  init_bootstrap();
+  init_usecase15();
   init_output();
   command_default18 = defineCommand({
     meta: {
@@ -18123,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) {
@@ -18138,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) {
@@ -18314,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);
@@ -18332,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);
@@ -18348,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);
         }
       };
     };
@@ -19135,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];
@@ -21339,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);
@@ -23849,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);
           }
         };
       }
@@ -23874,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() {
@@ -27010,11 +28046,11 @@ https://react.dev/link/unsafe-component-lifecycles`, _instance, newApiName, stat
     function updateHostContainer(current2, workInProgress2) {
       if (supportsPersistence && doesRequireClone(current2, workInProgress2)) {
         current2 = workInProgress2.stateNode;
-        var container = current2.containerInfo, newChildSet = createContainerChildSet();
+        var container2 = current2.containerInfo, newChildSet = createContainerChildSet();
         appendAllChildrenToContainer(newChildSet, workInProgress2, false, false);
         current2.pendingChildren = newChildSet;
         markUpdate(workInProgress2);
-        finalizeContainerChildren(container, newChildSet);
+        finalizeContainerChildren(container2, newChildSet);
       }
     }
     function updateHostComponent(current2, workInProgress2, type, newProps) {
@@ -30276,27 +31312,27 @@ Check the render method of \`` + fiberTag + "`.");
       parentComponent = emptyContextObject;
       return parentComponent;
     }
-    function updateContainerSync(element, container, parentComponent, callback) {
-      updateContainerImpl(container.current, 2, element, container, parentComponent, callback);
+    function updateContainerSync(element, container2, parentComponent, callback) {
+      updateContainerImpl(container2.current, 2, element, container2, parentComponent, callback);
       return 2;
     }
-    function updateContainerImpl(rootFiber, lane, element, container, parentComponent, callback) {
+    function updateContainerImpl(rootFiber, lane, element, container2, parentComponent, callback) {
       if (injectedHook && typeof injectedHook.onScheduleFiberRoot === "function")
         try {
-          injectedHook.onScheduleFiberRoot(rendererID, container, element);
+          injectedHook.onScheduleFiberRoot(rendererID, container2, element);
         } catch (err2) {
           hasLoggedError || (hasLoggedError = true, console.error("React instrumentation encountered an error: %o", err2));
         }
       parentComponent = getContextForSubtree(parentComponent);
-      container.context === null ? container.context = parentComponent : container.pendingContext = parentComponent;
+      container2.context === null ? container2.context = parentComponent : container2.pendingContext = parentComponent;
       isRendering && current !== null && !didWarnAboutNestedUpdates && (didWarnAboutNestedUpdates = true, console.error(`Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate.
 
 Check the render method of %s.`, getComponentNameFromFiber(current) || "Unknown"));
-      container = createUpdate(lane);
-      container.payload = { element };
+      container2 = createUpdate(lane);
+      container2.payload = { element };
       callback = callback === undefined ? null : callback;
-      callback !== null && (typeof callback !== "function" && console.error("Expected the last optional `callback` argument to be a function. Instead received: %s.", callback), container.callback = callback);
-      element = enqueueUpdate(rootFiber, container, lane);
+      callback !== null && (typeof callback !== "function" && console.error("Expected the last optional `callback` argument to be a function. Instead received: %s.", callback), container2.callback = callback);
+      element = enqueueUpdate(rootFiber, container2, lane);
       element !== null && (startUpdateTimerByLane(lane, "root.render()", null), scheduleUpdateOnFiber(element, rootFiber, lane), entangleTransitions(element, rootFiber, lane));
     }
     function markRetryLaneImpl(fiber, retryLane) {
@@ -32056,16 +33092,16 @@ No matching component was found for:
       }
       return null;
     };
-    exports2.getPublicRootInstance = function(container) {
-      container = container.current;
-      if (!container.child)
+    exports2.getPublicRootInstance = function(container2) {
+      container2 = container2.current;
+      if (!container2.child)
         return null;
-      switch (container.child.tag) {
+      switch (container2.child.tag) {
         case 27:
         case 5:
-          return getPublicInstance(container.child.stateNode);
+          return getPublicInstance(container2.child.stateNode);
         default:
-          return container.child.stateNode;
+          return container2.child.stateNode;
       }
     };
     exports2.injectIntoDevTools = function() {
@@ -32137,9 +33173,9 @@ No matching component was found for:
         return action(formData);
       });
     };
-    exports2.updateContainer = function(element, container, parentComponent, callback) {
-      var current2 = container.current, lane = requestUpdateLane(current2);
-      updateContainerImpl(current2, lane, element, container, parentComponent, callback);
+    exports2.updateContainer = function(element, container2, parentComponent, callback) {
+      var current2 = container2.current, lane = requestUpdateLane(current2);
+      updateContainerImpl(current2, lane, element, container2, parentComponent, callback);
       return lane;
     };
     exports2.updateContainerSync = updateContainerSync;
@@ -36562,7 +37598,7 @@ var require_websocket_server = __commonJS((exports, module) => {
       socket.on("error", socketOnError);
       const key = req.headers["sec-websocket-key"];
       const upgrade = req.headers.upgrade;
-      const version2 = +req.headers["sec-websocket-version"];
+      const version3 = +req.headers["sec-websocket-version"];
       if (req.method !== "GET") {
         const message = "Invalid HTTP method";
         abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
@@ -36578,7 +37614,7 @@ var require_websocket_server = __commonJS((exports, module) => {
         abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
         return;
       }
-      if (version2 !== 13 && version2 !== 8) {
+      if (version3 !== 13 && version3 !== 8) {
         const message = "Missing or invalid Sec-WebSocket-Version header";
         abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
           "Sec-WebSocket-Version": "13, 8"
@@ -36618,7 +37654,7 @@ var require_websocket_server = __commonJS((exports, module) => {
       }
       if (this.options.verifyClient) {
         const info2 = {
-          origin: req.headers[`${version2 === 8 ? "sec-websocket-origin" : "origin"}`],
+          origin: req.headers[`${version3 === 8 ? "sec-websocket-origin" : "origin"}`],
           secure: !!(req.socket.authorized || req.socket.encrypted),
           req
         };
@@ -39453,20 +40489,20 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return 0;
         };
-        var validate2 = function validate3(version2) {
-          return typeof version2 === "string" && /^[v\d]/.test(version2) && semver.test(version2);
+        var validate2 = function validate3(version3) {
+          return typeof version3 === "string" && /^[v\d]/.test(version3) && semver.test(version3);
         };
         var compare = function compare2(v1, v2, operator) {
           assertValidOperator(operator);
           var res = compareVersions(v1, v2);
           return operatorResMap[operator].includes(res);
         };
-        var satisfies = function satisfies2(version2, range) {
+        var satisfies = function satisfies2(version3, range) {
           var m = range.match(/^([<>=~^]+)/);
           var op = m ? m[1] : "=";
           if (op !== "^" && op !== "~")
-            return compare(version2, range, op);
-          var _validateAndParse = validateAndParse(version2), _validateAndParse2 = _slicedToArray(_validateAndParse, 5), v1 = _validateAndParse2[0], v2 = _validateAndParse2[1], v3 = _validateAndParse2[2], vp = _validateAndParse2[4];
+            return compare(version3, range, op);
+          var _validateAndParse = validateAndParse(version3), _validateAndParse2 = _slicedToArray(_validateAndParse, 5), v1 = _validateAndParse2[0], v2 = _validateAndParse2[1], v3 = _validateAndParse2[2], vp = _validateAndParse2[4];
           var _validateAndParse3 = validateAndParse(range), _validateAndParse4 = _slicedToArray(_validateAndParse3, 5), r1 = _validateAndParse4[0], r2 = _validateAndParse4[1], r3 = _validateAndParse4[2], rp = _validateAndParse4[4];
           var v = [v1, v2, v3];
           var r = [r1, r2 !== null && r2 !== undefined ? r2 : "x", r3 !== null && r3 !== undefined ? r3 : "x"];
@@ -39489,13 +40525,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           return true;
         };
         var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
-        var validateAndParse = function validateAndParse2(version2) {
-          if (typeof version2 !== "string") {
+        var validateAndParse = function validateAndParse2(version3) {
+          if (typeof version3 !== "string") {
             throw new TypeError("Invalid argument expected string");
           }
-          var match = version2.match(semver);
+          var match = version3.match(semver);
           if (!match) {
-            throw new Error("Invalid argument not valid semver ('".concat(version2, "' received)"));
+            throw new Error("Invalid argument not valid semver ('".concat(version3, "' received)"));
           }
           match.shift();
           return match;
@@ -41129,11 +42165,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           return obj;
         }
         var FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER = "999.9.9";
-        function hasAssignedBackend(version2) {
-          if (version2 == null || version2 === "") {
+        function hasAssignedBackend(version3) {
+          if (version3 == null || version3 === "") {
             return false;
           }
-          return gte(version2, FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER);
+          return gte(version3, FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER);
         }
         function cleanForBridge(data, isPathAllowed) {
           var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
@@ -41612,7 +42648,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         }
         var Overlay_assign = Object.assign;
         var OverlayRect = /* @__PURE__ */ function() {
-          function OverlayRect2(doc2, container) {
+          function OverlayRect2(doc2, container2) {
             Overlay_classCallCheck(this, OverlayRect2);
             this.node = doc2.createElement("div");
             this.border = doc2.createElement("div");
@@ -41630,7 +42666,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             this.node.appendChild(this.border);
             this.border.appendChild(this.padding);
             this.padding.appendChild(this.content);
-            container.appendChild(this.node);
+            container2.appendChild(this.node);
           }
           return Overlay_createClass(OverlayRect2, [{
             key: "remove",
@@ -41657,7 +42693,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }]);
         }();
         var OverlayTip = /* @__PURE__ */ function() {
-          function OverlayTip2(doc2, container) {
+          function OverlayTip2(doc2, container2) {
             Overlay_classCallCheck(this, OverlayTip2);
             this.tip = doc2.createElement("div");
             Overlay_assign(this.tip.style, {
@@ -41687,7 +42723,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               color: "#d7d7d7"
             });
             this.tip.style.zIndex = "10000000";
-            container.appendChild(this.tip);
+            container2.appendChild(this.tip);
           }
           return Overlay_createClass(OverlayTip2, [{
             key: "remove",
@@ -42789,9 +43825,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this2, "getBackendVersion", function() {
-              var version2 = "6.1.5-5d87cd2244";
-              if (version2) {
-                _this2._bridge.send("backendVersion", version2);
+              var version3 = "6.1.5-5d87cd2244";
+              if (version3) {
+                _this2._bridge.send("backendVersion", version3);
               }
             });
             agent_defineProperty(_this2, "getBridgeProtocol", function() {
@@ -45319,7 +46355,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         } : function() {
           return Date.now();
         };
-        function getInternalReactConstants(version2) {
+        function getInternalReactConstants(version3) {
           var ReactPriorityLevels = {
             ImmediatePriority: 99,
             UserBlockingPriority: 98,
@@ -45328,7 +46364,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             IdlePriority: 95,
             NoPriority: 90
           };
-          if (gt(version2, "17.0.2")) {
+          if (gt(version3, "17.0.2")) {
             ReactPriorityLevels = {
               ImmediatePriority: 1,
               UserBlockingPriority: 2,
@@ -45339,15 +46375,15 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             };
           }
           var StrictModeBits = 0;
-          if (gte(version2, "18.0.0-alpha")) {
+          if (gte(version3, "18.0.0-alpha")) {
             StrictModeBits = 24;
-          } else if (gte(version2, "16.9.0")) {
+          } else if (gte(version3, "16.9.0")) {
             StrictModeBits = 1;
-          } else if (gte(version2, "16.3.0")) {
+          } else if (gte(version3, "16.3.0")) {
             StrictModeBits = 2;
           }
           var ReactTypeOfWork = null;
-          if (gt(version2, "17.0.1")) {
+          if (gt(version3, "17.0.1")) {
             ReactTypeOfWork = {
               CacheComponent: 24,
               ClassComponent: 1,
@@ -45384,7 +46420,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               ViewTransitionComponent: 30,
               ActivityComponent: 31
             };
-          } else if (gte(version2, "17.0.0-alpha")) {
+          } else if (gte(version3, "17.0.0-alpha")) {
             ReactTypeOfWork = {
               CacheComponent: -1,
               ClassComponent: 1,
@@ -45421,7 +46457,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               ViewTransitionComponent: -1,
               ActivityComponent: -1
             };
-          } else if (gte(version2, "16.6.0-beta.0")) {
+          } else if (gte(version3, "16.6.0-beta.0")) {
             ReactTypeOfWork = {
               CacheComponent: -1,
               ClassComponent: 1,
@@ -45458,7 +46494,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               ViewTransitionComponent: -1,
               ActivityComponent: -1
             };
-          } else if (gte(version2, "16.4.3-alpha")) {
+          } else if (gte(version3, "16.4.3-alpha")) {
             ReactTypeOfWork = {
               CacheComponent: -1,
               ClassComponent: 2,
@@ -45744,8 +46780,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
         }
         function renderer_attach(hook, rendererID, renderer, global2, shouldStartProfilingNow, profilingSettings) {
-          var version2 = renderer.reconcilerVersion || renderer.version;
-          var _getInternalReactCons = getInternalReactConstants(version2), getDisplayNameForFiber = _getInternalReactCons.getDisplayNameForFiber, getTypeSymbol = _getInternalReactCons.getTypeSymbol, ReactPriorityLevels = _getInternalReactCons.ReactPriorityLevels, ReactTypeOfWork = _getInternalReactCons.ReactTypeOfWork, StrictModeBits = _getInternalReactCons.StrictModeBits;
+          var version3 = renderer.reconcilerVersion || renderer.version;
+          var _getInternalReactCons = getInternalReactConstants(version3), getDisplayNameForFiber = _getInternalReactCons.getDisplayNameForFiber, getTypeSymbol = _getInternalReactCons.getTypeSymbol, ReactPriorityLevels = _getInternalReactCons.ReactPriorityLevels, ReactTypeOfWork = _getInternalReactCons.ReactTypeOfWork, StrictModeBits = _getInternalReactCons.StrictModeBits;
           var { ActivityComponent, CacheComponent, ClassComponent, ContextConsumer, DehydratedSuspenseComponent, ForwardRef, Fragment, FunctionComponent, HostRoot, HostHoistable, HostSingleton, HostPortal, HostComponent, HostText, IncompleteClassComponent, IncompleteFunctionComponent, IndeterminateComponent, LegacyHiddenComponent, MemoComponent, OffscreenComponent, SimpleMemoComponent, SuspenseComponent, SuspenseListComponent, TracingMarkerComponent, Throw, ViewTransitionComponent } = ReactTypeOfWork;
           var { ImmediatePriority, UserBlockingPriority, NormalPriority, LowPriority, IdlePriority, NoPriority } = ReactPriorityLevels;
           var { getLaneLabelMap, injectProfilingHooks, overrideHookState, overrideHookStateDeletePath, overrideHookStateRenamePath, overrideProps, overridePropsDeletePath, overridePropsRenamePath, scheduleRefresh, setErrorHandler, setSuspenseHandler, scheduleUpdate, getCurrentFiber } = renderer;
@@ -45771,7 +46807,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               getLaneLabelMap,
               currentDispatcherRef: getDispatcherRef(renderer),
               workTagMap: ReactTypeOfWork,
-              reactVersion: version2
+              reactVersion: version3
             });
             injectProfilingHooks(response.profilingHooks);
             getTimelineData = response.getTimelineData;
@@ -49650,8 +50686,8 @@ The error thrown in the component is:
             getEnvironmentNames
           };
         }
-        function isMatchingRender(version2) {
-          return !hasAssignedBackend(version2);
+        function isMatchingRender(version3) {
+          return !hasAssignedBackend(version3);
         }
         function attachRenderer(hook, id, renderer, global2, shouldStartProfilingNow, profilingSettings) {
           if (!isMatchingRender(renderer.reconcilerVersion || renderer.version)) {
@@ -50665,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);
@@ -50798,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);
@@ -51504,10 +52540,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 3;
   }
   if ("TERM_PROGRAM" in env2) {
-    const version2 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    const version3 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env2.TERM_PROGRAM) {
       case "iTerm.app": {
-        return version2 >= 3 ? 3 : 2;
+        return version3 >= 3 ? 3 : 2;
       }
       case "Apple_Terminal": {
         return 2;
@@ -53554,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([]);
@@ -53826,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]);
@@ -54282,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) {
@@ -55119,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 {
@@ -55133,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();
@@ -55158,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;
@@ -55171,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,
@@ -55186,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)
@@ -55210,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}`);
@@ -55230,6 +56362,7 @@ class ProcessManager {
     this.teams.set(roomId, {
       roomId,
       roomName,
+      codingAgent: "claude",
       sessionName: this.sessionName(roomId),
       status: "error",
       exitCode: null,
@@ -55303,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,
@@ -55333,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();
@@ -55342,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",
@@ -55359,48 +56516,6 @@ var init_process_manager = __esm(() => {
   ];
 });
 
-// src/spawner.ts
-import { execSync } from "node:child_process";
-import { existsSync as existsSync5 } 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 && existsSync5(claudePath)) {
-      return claudePath;
-    }
-  } catch {}
-  const envPath = process.env.MEET_AI_CLAUDE_PATH;
-  if (envPath && existsSync5(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 (existsSync5(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());
@@ -56092,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) {
@@ -56119,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);
     }
@@ -56157,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);
 }
@@ -56305,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();
@@ -56315,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];
@@ -56330,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);
@@ -56451,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, {
@@ -56529,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: {
@@ -56555,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);
           }
         }
       });
@@ -56579,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;
@@ -56592,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()
@@ -56605,11 +57759,15 @@ var init_usecase17 = __esm(async () => {
 
 // src/index.ts
 init_dist();
+// package.json
+var version = "0.0.36";
+
+// src/index.ts
 init_output();
 var main = defineCommand({
   meta: {
     name: "meet-ai",
-    version: "0.0.34",
+    version,
     description: "CLI for meet-ai chat rooms — create rooms, send messages, and stream via WebSocket"
   },
   args: {
@@ -56640,9 +57798,9 @@ var main = defineCommand({
     if (hasSubcommand)
       return;
     try {
-      const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client_factory(), exports_client_factory));
+      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 });