@gorlitzer-labs/apiary 1.13.3

package/dist/cli/index.js

@@ -0,0 +1,2432 @@
+#!/usr/bin/env node
+import {
+  join
+} from "../chunk-ED6ROH6B.js";
+import {
+  deliverInvite,
+  sameApiaryServer
+} from "../chunk-CFY6Z6Q6.js";
+import {
+  checkForUpdate,
+  printUpdateNotice
+} from "../chunk-5V7QLCGB.js";
+import {
+  agentEmoji,
+  clearAgentSession,
+  isAgentAlive,
+  listAgentSessions,
+  listRoomSessions,
+  resetTerminal,
+  resolveBindAddress,
+  saveAgentSession,
+  serve,
+  tmuxAttach,
+  tmuxAvailable,
+  tmuxCapturePane,
+  tmuxCreateSession,
+  tmuxInjectPaste,
+  tmuxInjectText,
+  tmuxKillSession,
+  tmuxPaneIsShell,
+  tmuxSendCommand,
+  tmuxSendEnter,
+  tmuxSendKey,
+  tmuxSessionExists
+} from "../chunk-CZHO4DBN.js";
+import "../chunk-PEB6HEFT.js";
+import {
+  buildRuntimeMcpOptions
+} from "../chunk-TPNFOQA7.js";
+import {
+  EventProcessor,
+  RUNTIME_TOOL_NAMES,
+  SseMultiplexer,
+  createRuntimeMcpServer,
+  parseEngagementMode,
+  shouldReportActivity
+} from "../chunk-ZEFRNAX6.js";
+import {
+  buildShareUrl
+} from "../chunk-AYQJIAR5.js";
+import {
+  randomName
+} from "../chunk-D7DXZQWT.js";
+import {
+  contentPartsToString
+} from "../chunk-QL66XSDB.js";
+import "../chunk-BZ4VDWC2.js";
+
+// src/cli/claude/run.ts
+import { writeFileSync as writeFileSync2, mkdtempSync, mkdirSync, rmSync, chmodSync, existsSync as existsSync3, readFileSync as readFileSync2, readdirSync as readdirSync2, realpathSync, renameSync as renameSync2 } from "fs";
+import { join as join4 } from "path";
+import { tmpdir, homedir as homedir3 } from "os";
+
+// src/cli/composer.ts
+var PROMPT_MARKER = /^\s*[›❯>]\s?/;
+function composerBlock(lines) {
+  const tail = lines.slice(-25);
+  let start = -1;
+  for (let i = tail.length - 1; i >= 0; i--) {
+    if (PROMPT_MARKER.test(tail[i])) {
+      start = i;
+      break;
+    }
+  }
+  if (start === -1) return "";
+  return tail.slice(start).join(" ");
+}
+function submissionProbe(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 40);
+}
+function composerStillHolds(lines, text) {
+  const probe = submissionProbe(text);
+  if (probe.length < 8) return false;
+  const composer = composerBlock(lines).replace(/\s+/g, " ");
+  return composer.includes(probe);
+}
+
+// src/cli/claude/tmux-bridge.ts
+var SPINNER_CHARS = "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F";
+var BUSY_PATTERNS = [
+  // "← 1 agent" / "← 3 agents"
+  /←\s*\d+\s+agents?\b/
+];
+var DIALOG_PATTERNS = [
+  "Enter to select",
+  "to navigate",
+  "Esc to cancel",
+  "Ready to code?",
+  "Review your answers",
+  "ctrl+g to edit in"
+];
+var PERMISSION_PATTERNS = [
+  "(Y)",
+  "Allow ",
+  "Deny ",
+  "approve",
+  "Yes / No",
+  // Current Claude Code wording, captured from a live prompt. Without these a
+  // permission dialog reads as idle and the bridge pastes a room event into
+  // it, answering on the agent's behalf.
+  "Do you want to proceed?",
+  "don't ask again",
+  // The folder-trust modal, which no flag skips.
+  "Yes, I trust this folder"
+];
+var BLOCKING_PATTERNS = [
+  "Do you want to proceed?",
+  "don't ask again",
+  "Yes, I trust this folder",
+  "Ready to code?",
+  "Enter to select",
+  /❯\s*1\.\s*Yes/,
+  /\(y\s*\/\s*n\)/i,
+  // The arrow glyphs claude renders beside it. Bare "to navigate" is prose.
+  /[↑↓⬆⬇]\s*(?:[↑↓⬆⬇]\s*)?to navigate/
+];
+function matchesAny(text, patterns) {
+  const haystack = text.toLowerCase();
+  for (const pattern of patterns) {
+    if (typeof pattern === "string") {
+      if (haystack.includes(pattern.toLowerCase())) return true;
+    } else if (pattern.test(text)) {
+      return true;
+    }
+  }
+  return false;
+}
+function defaultUndeliveredWarning(text) {
+  const preview = text.replace(/\s+/g, " ").slice(0, 80);
+  process.stderr.write(`apiary: message NOT delivered to the agent \u2014 still in its composer: ${preview}
+`);
+}
+var TmuxBridge = class _TmuxBridge {
+  session;
+  queue = [];
+  pollTimer = null;
+  pollIntervalMs;
+  keystrokeDelayMs;
+  onUndelivered;
+  stopped = false;
+  blockedCount = 0;
+  static BLOCKED_THRESHOLD = 150;
+  // ~30s at 200ms poll — force inject if stuck
+  constructor(session, opts) {
+    this.session = session;
+    this.pollIntervalMs = opts?.pollIntervalMs ?? 200;
+    this.keystrokeDelayMs = opts?.keystrokeDelayMs ?? 50;
+    this.onUndelivered = opts?.onUndelivered ?? defaultUndeliveredWarning;
+  }
+  /**
+   * Delivery callback — drop-in replacement for the raw tmuxDeliver lambda.
+   * Pass `bridge.deliver.bind(bridge)` to EventProcessor.run().
+   */
+  async deliver(parts, opts) {
+    const text = contentPartsToString(parts);
+    if (!text.trim()) return;
+    this.inject(text, opts?.dedupe === true);
+  }
+  /**
+   * Detect the current TUI state by reading the screen.
+   * Exported for testing — the heuristic logic is in detectStateFromLines().
+   */
+  detectState() {
+    if (tmuxPaneIsShell(this.session)) return "absent";
+    const lines = this.captureScreen();
+    return detectStateFromLines(lines);
+  }
+  /**
+   * State to REPORT to the room, as opposed to the state used to decide
+   * whether it is safe to type. Same screen, stricter about claiming a human
+   * is needed — see detectReportedStateFromLines.
+   */
+  detectReportedState() {
+    if (tmuxPaneIsShell(this.session)) return "absent";
+    return detectReportedStateFromLines(this.captureScreen());
+  }
+  /**
+   * Extract claude's live status label from the pane (the "Sautéed for 12s",
+   * "Compacting conversation… 23%" lines under the prompt). Returns null when
+   * the agent is idle / no status visible.
+   *
+   * The room TUI calls this through the agent runtime's poll loop to surface
+   * "is the agent actually working or stuck?" without making the user attach
+   * to each tmux pane.
+   */
+  getActivityLabel() {
+    return extractActivityLabel(this.captureScreen());
+  }
+  /**
+   * Try to inject text, choosing strategy based on TUI state.
+   * If the state is unsafe, queues the text and starts polling.
+   *
+   * Text is flattened to a single line before injection to avoid triggering
+   * Claude Code's paste detection. When multi-line text arrives via
+   * `send-keys -l`, Claude Code detects it as a paste and collapses it into
+   * "[Pasted text #1 +N lines]" which may not reliably submit with Enter.
+   */
+  inject(text, dedupe) {
+    const flat = text.replace(/\n/g, " ");
+    const state = this.detectState();
+    switch (state) {
+      case "idle":
+        this.injectIdle(flat);
+        break;
+      case "typing":
+        this.injectWhileTyping(flat);
+        break;
+      default:
+        this.enqueue(flat, dedupe);
+        break;
+    }
+  }
+  /** Capture the screen via tmux capture-pane. */
+  captureScreen() {
+    return tmuxCapturePane(this.session);
+  }
+  /**
+   * Inject into an idle prompt: type text + Enter, then check it went.
+   *
+   * This used to fire a second Enter unconditionally as a "safety net" against
+   * Claude Code's paste detection swallowing the first. That is a guess in both
+   * directions: it cannot tell whether the first Enter worked, and it cannot
+   * tell whether the second one did either. Reading the composer back answers
+   * the question instead, and only sends the second Enter when it is needed.
+   */
+  injectIdle(text) {
+    tmuxInjectText(this.session, text);
+    tmuxSendEnter(this.session);
+    this.confirmSubmitted(text);
+  }
+  /**
+   * Check the message left the composer, and press Enter once more if it did not.
+   *
+   * A submitted message moves into the transcript; one still in the composer was
+   * never sent. If it is still there after the retry, the room is told rather
+   * than left to read the agent's silence as a choice.
+   */
+  confirmSubmitted(text) {
+    this.sleep(80);
+    if (!composerStillHolds(this.captureScreen(), text)) return;
+    tmuxSendEnter(this.session);
+    this.sleep(120);
+    if (!composerStillHolds(this.captureScreen(), text)) return;
+    this.onUndelivered(text);
+  }
+  /**
+   * Inject while the user is typing:
+   * 1. Ctrl+U — cut line to kill ring
+   * 2. Inject our text + Enter
+   * 3. Ctrl+Y — paste the user's text back
+   */
+  injectWhileTyping(text) {
+    tmuxSendKey(this.session, "C-u");
+    this.sleep(this.keystrokeDelayMs);
+    tmuxInjectText(this.session, text);
+    tmuxSendEnter(this.session);
+    this.confirmSubmitted(text);
+    this.sleep(this.keystrokeDelayMs);
+    tmuxSendKey(this.session, "C-y");
+  }
+  /** Add to queue and start polling if not already. */
+  enqueue(text, dedupe) {
+    if (dedupe && this.queue.includes(text)) return;
+    this.queue.push(text);
+    this.startPolling();
+  }
+  /** Start the polling timer to drain queued events. */
+  startPolling() {
+    if (this.pollTimer || this.stopped) return;
+    this.pollTimer = setInterval(() => this.drainQueue(), this.pollIntervalMs);
+  }
+  /** Stop the polling timer. */
+  stopPolling() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  /**
+   * Try to drain one queued event if the state is safe.
+   *
+   * Drains one event at a time rather than batching all into one multi-line
+   * string — multi-line text triggers Claude Code's paste detection which
+   * collapses it into "[Pasted text #1 +N lines]".
+   *
+   * After injecting one event, the poll continues. The next cycle re-checks
+   * state: if Claude is busy (streaming), remaining events wait. If idle,
+   * the next event is injected. Events are already flattened in inject().
+   */
+  drainQueue() {
+    if (this.queue.length === 0) {
+      this.stopPolling();
+      this.blockedCount = 0;
+      return;
+    }
+    const state = this.detectState();
+    if (state === "idle" || state === "typing") {
+      this.blockedCount = 0;
+      const text = this.queue.shift();
+      if (state === "idle") {
+        this.injectIdle(text);
+      } else {
+        this.injectWhileTyping(text);
+      }
+      if (this.queue.length === 0) {
+        this.stopPolling();
+      }
+    } else {
+      this.blockedCount++;
+      if (this.blockedCount >= _TmuxBridge.BLOCKED_THRESHOLD) {
+        this.blockedCount = 0;
+        const text = this.queue.shift();
+        this.injectIdle(text);
+        if (this.queue.length === 0) this.stopPolling();
+      }
+    }
+  }
+  /** Cleanup. */
+  stop() {
+    this.stopped = true;
+    this.stopPolling();
+    this.queue.length = 0;
+  }
+  /** Synchronous sleep — only used for tiny keystroke delays. */
+  sleep(ms) {
+    if (ms <= 0) return;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  }
+};
+var ACTIVITY_LIVE = /([A-Za-zÀ-ÿ]+…\s*\([^)\n]*\))/;
+var ACTIVITY_COOK = /([A-Za-zÀ-ÿ]+ed\s+for\s+\d+s)/;
+var ACTIVITY_PROG = /((?:Compacting|Thinking|Loading|Connecting)[^()]*?(?:\s+\d+%)?)(?=\s*[(\n]|\s*$)/;
+function extractActivityLabel(lines) {
+  if (lines.length === 0) return null;
+  let best = null;
+  for (const line of lines.slice(-25)) {
+    const m = line.match(ACTIVITY_PROG) ?? line.match(ACTIVITY_COOK) ?? line.match(ACTIVITY_LIVE);
+    if (m) best = m[1].trim();
+  }
+  return best;
+}
+function detectStateFromLines(lines, opts) {
+  if (lines.length === 0) return "unknown";
+  const tail = lines.slice(-30);
+  const tailText = tail.join("\n");
+  if (opts?.ignorePrompts !== true) {
+    for (const pattern of DIALOG_PATTERNS) {
+      if (tailText.includes(pattern)) return "dialog";
+    }
+    for (const pattern of PERMISSION_PATTERNS) {
+      if (tailText.includes(pattern)) return "permission";
+    }
+  }
+  const lastFew = tail.slice(-5).join("");
+  for (const ch of SPINNER_CHARS) {
+    if (lastFew.includes(ch)) return "streaming";
+  }
+  for (const pattern of BUSY_PATTERNS) {
+    if (pattern.test(tailText)) return "streaming";
+  }
+  const promptChar = /^[❯›](\s|$)/;
+  const footerChar = /^[❯›]{2}\s/;
+  const separatorLine = /^[─━─\-]{10,}/;
+  for (let i = tail.length - 1; i >= 0; i--) {
+    const line = tail[i].trimStart();
+    if (footerChar.test(line)) {
+      for (let j = i - 1; j >= 0; j--) {
+        const above = tail[j].trimStart();
+        if (promptChar.test(above)) {
+          const content = above.replace(/^[❯›]\s*/, "").trim();
+          return content.length === 0 ? "idle" : "typing";
+        }
+      }
+      break;
+    }
+  }
+  for (let i = tail.length - 1; i >= 0; i--) {
+    const line = tail[i].trimStart();
+    if (promptChar.test(line)) {
+      const above = i > 0 ? tail[i - 1].trimStart() : "";
+      const below = i < tail.length - 1 ? tail[i + 1].trimStart() : "";
+      if (separatorLine.test(above) || separatorLine.test(below)) {
+        const content = line.replace(/^[❯›]\s*/, "").trim();
+        return content.length === 0 ? "idle" : "typing";
+      }
+    }
+  }
+  return "unknown";
+}
+function detectReportedStateFromLines(lines) {
+  const loose = detectStateFromLines(lines);
+  if (loose !== "dialog" && loose !== "permission") return loose;
+  if (matchesAny(lines.slice(-30).join("\n"), BLOCKING_PATTERNS)) return loose;
+  return detectStateFromLines(lines, { ignorePrompts: true });
+}
+
+// src/cli/runtime-setup.ts
+async function setupAgentRuntime(options) {
+  const agentName = options.name ?? randomName();
+  const authority = options.authority ?? (options.admin ? "admin" : void 0);
+  const pendingUrls = options.joinUrls ?? [];
+  const joinResults = [];
+  const sseMux = new SseMultiplexer();
+  const processor = new EventProcessor("", agentName, {
+    defaultMode: options.mode ?? "everyone"
+  });
+  const mcpServer = await createRuntimeMcpServer(
+    buildRuntimeMcpOptions({
+      processor,
+      sseMux,
+      joinResults,
+      agentName,
+      authority,
+      onRoomJoined: options.onRoomJoined
+    })
+  );
+  const wrappedSource = {
+    [Symbol.asyncIterator]() {
+      const inner = sseMux[Symbol.asyncIterator]();
+      return {
+        async next() {
+          const result = await inner.next();
+          if (!result.done) {
+            const { roomId, event } = result.value;
+            const jr = joinResults.find((j) => j.roomId === roomId);
+            if (jr) {
+              if (event.type === "ParticipantJoined") {
+                jr.dataSource.addParticipant(event.participant);
+              } else if (event.type === "ParticipantLeft") {
+                jr.dataSource.removeParticipant(event.participant_id);
+              }
+            }
+          }
+          return result;
+        }
+      };
+    }
+  };
+  async function cleanup() {
+    await processor.stop();
+    sseMux.close();
+    await mcpServer.stop();
+    for (const jr of joinResults) {
+      try {
+        await fetch(`${jr.serverUrl}/disconnect`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ token: jr.sessionToken })
+        });
+      } catch {
+      }
+    }
+  }
+  let initialParts;
+  if (pendingUrls.length > 0) {
+    if (pendingUrls.length === 1) {
+      initialParts = [{ type: "text", text: `Use join_room("${pendingUrls[0]}") to connect.` }];
+    } else {
+      const lines = pendingUrls.map((u) => `  join_room("${u}")`);
+      initialParts = [{ type: "text", text: `Rooms to join:
+${lines.join("\n")}` }];
+    }
+  }
+  return {
+    agentName,
+    joinResults,
+    initialParts,
+    processor,
+    sseMux,
+    mcpServer,
+    wrappedSource,
+    cleanup
+  };
+}
+
+// src/cli/agent-state.ts
+function codexStateToActivity(state) {
+  switch (state) {
+    case "absent":
+      return "blocked";
+    case "approval":
+    case "blocked":
+      return "blocked";
+    case "streaming":
+      return "working";
+    case "idle":
+    case "typing":
+      return "idle";
+    case "unknown":
+    default:
+      return void 0;
+  }
+}
+function claudeStateToActivity(state) {
+  switch (state) {
+    case "absent":
+      return "blocked";
+    case "permission":
+    case "dialog":
+      return "blocked";
+    case "streaming":
+      return "working";
+    case "idle":
+    case "typing":
+      return "idle";
+    case "unknown":
+    default:
+      return void 0;
+  }
+}
+
+// src/cli/approvals.ts
+var APPROVALS_ENV = "APIARY_AGENT_APPROVALS";
+function wantsUnattendedAgents(env = process.env) {
+  return env[APPROVALS_ENV]?.trim().toLowerCase() !== "ask";
+}
+
+// src/cli/claude/trust.ts
+import { existsSync, readFileSync, renameSync, writeFileSync, unlinkSync } from "fs";
+import { join as join2, resolve } from "path";
+import { homedir } from "os";
+function claudeConfigPath(home = homedir()) {
+  return join2(home, ".claude.json");
+}
+function preAcceptClaudeTrust(cwd, opts) {
+  if (opts?.enabled === false) return "skipped";
+  const path = opts?.configPath ?? claudeConfigPath();
+  const key = resolve(cwd);
+  if (!existsSync(path)) return "no-config";
+  let parsed;
+  let raw;
+  try {
+    raw = readFileSync(path, "utf-8");
+    parsed = JSON.parse(raw);
+  } catch {
+    return "failed";
+  }
+  if (typeof parsed !== "object" || parsed === null) return "failed";
+  const projects = parsed.projects ?? {};
+  if (typeof projects !== "object" || projects === null) return "failed";
+  const existing = projects[key];
+  if (existing && existing.hasTrustDialogAccepted === true) return "already-trusted";
+  projects[key] = { ...existing ?? {}, hasTrustDialogAccepted: true };
+  parsed.projects = projects;
+  const tmp = `${path}.apiary-${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify(parsed, null, 2), { mode: 384 });
+    renameSync(tmp, path);
+    return "trusted";
+  } catch {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    return "failed";
+  }
+}
+
+// src/cli/claude/jsonl-stats.ts
+import { readdirSync, statSync, existsSync as existsSync2, openSync, readSync, closeSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+function cwdToProjectDir(cwd) {
+  return cwd.replace(/[/.]/g, "-");
+}
+function findLatestJsonl(cwd) {
+  const projectsDir = join3(homedir2(), ".claude", "projects", cwdToProjectDir(cwd));
+  if (!existsSync2(projectsDir)) return null;
+  let newest = null;
+  for (const f of readdirSync(projectsDir)) {
+    if (!f.endsWith(".jsonl")) continue;
+    const p = join3(projectsDir, f);
+    try {
+      const st = statSync(p);
+      if (!newest || st.mtimeMs > newest.mtime) newest = { path: p, mtime: st.mtimeMs };
+    } catch {
+    }
+  }
+  return newest?.path ?? null;
+}
+var tailStates = /* @__PURE__ */ new Map();
+function freshState(path) {
+  return {
+    path,
+    offset: 0,
+    totals: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0 },
+    lastTurnContextTokens: 0,
+    lastModel: "",
+    carry: ""
+  };
+}
+function readAgentMetrics(cwd) {
+  const path = findLatestJsonl(cwd);
+  if (!path) return null;
+  let state = tailStates.get(cwd);
+  if (state && state.path !== path) state = void 0;
+  if (!state) {
+    state = freshState(path);
+    tailStates.set(cwd, state);
+  }
+  let size;
+  try {
+    size = statSync(path).size;
+  } catch {
+    return null;
+  }
+  if (size < state.offset) {
+    state = freshState(path);
+    tailStates.set(cwd, state);
+  }
+  if (size === state.offset && state.lastModel === "") return null;
+  if (size === state.offset) return snapshot(state);
+  const chunkLen = size - state.offset;
+  const buf = Buffer.alloc(chunkLen);
+  let fd;
+  try {
+    fd = openSync(path, "r");
+  } catch {
+    return snapshot(state);
+  }
+  try {
+    readSync(fd, buf, 0, chunkLen, state.offset);
+  } finally {
+    closeSync(fd);
+  }
+  state.offset = size;
+  const text = state.carry + buf.toString("utf-8");
+  const newlineEnd = text.lastIndexOf("\n");
+  const completeLines = newlineEnd >= 0 ? text.slice(0, newlineEnd) : "";
+  state.carry = newlineEnd >= 0 ? text.slice(newlineEnd + 1) : text;
+  for (const line of completeLines.split("\n")) {
+    consumeLine(state, line);
+  }
+  return snapshot(state);
+}
+function snapshot(s) {
+  return {
+    ...s.totals,
+    lastTurnContextTokens: s.lastTurnContextTokens,
+    lastModel: s.lastModel
+  };
+}
+function consumeLine(state, line) {
+  if (!line.trim()) return;
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const msg = event.message;
+  if (!msg || typeof msg !== "object") return;
+  const usage = msg.usage;
+  if (!usage) return;
+  const inp = Number(usage.input_tokens) || 0;
+  const out = Number(usage.output_tokens) || 0;
+  const cr = Number(usage.cache_read_input_tokens) || 0;
+  const cw = Number(usage.cache_creation_input_tokens) || 0;
+  state.totals.inputTokens += inp;
+  state.totals.outputTokens += out;
+  state.totals.cacheReadTokens += cr;
+  state.totals.cacheCreateTokens += cw;
+  if (typeof msg.model === "string") state.lastModel = msg.model;
+  state.lastTurnContextTokens = inp + cr + cw;
+}
+
+// src/cli/claude/run.ts
+var SKIP_PERMISSIONS_FLAG = "--dangerously-skip-permissions";
+var SESSION_DIR = join4(homedir3(), ".apiary", "sessions");
+function sessionFilePath(name) {
+  return join4(SESSION_DIR, `claude_${name}.json`);
+}
+function saveSession(session) {
+  const dir = SESSION_DIR;
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync2(sessionFilePath(session.agentName), JSON.stringify(session, null, 2));
+}
+function clearSession(name) {
+  const path = sessionFilePath(name);
+  try {
+    rmSync(path);
+  } catch {
+  }
+}
+function pretrustCwd(cwd) {
+  try {
+    const path = join4(homedir3(), ".claude.json");
+    if (!existsSync3(path)) return;
+    const real = realpathSync(cwd);
+    const raw = readFileSync2(path, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data !== "object" || data === null) return;
+    const projects = data.projects ??= {};
+    const entry = projects[real] ??= {};
+    const needsWrite = entry.hasTrustDialogAccepted !== true || entry.hasCompletedProjectOnboarding !== true || !(typeof entry.projectOnboardingSeenCount === "number" && entry.projectOnboardingSeenCount >= 1);
+    if (!needsWrite) return;
+    entry.hasTrustDialogAccepted = true;
+    entry.hasCompletedProjectOnboarding = true;
+    if (!(typeof entry.projectOnboardingSeenCount === "number" && entry.projectOnboardingSeenCount >= 1)) {
+      entry.projectOnboardingSeenCount = 1;
+    }
+    const tmpPath = `${path}.apiary-${process.pid}.tmp`;
+    writeFileSync2(tmpPath, JSON.stringify(data, null, 2));
+    renameSync2(tmpPath, path);
+  } catch {
+  }
+}
+function listClaudeSessions() {
+  if (!existsSync3(SESSION_DIR)) return [];
+  const files = readdirSync2(SESSION_DIR);
+  const sessions = [];
+  for (const f of files) {
+    if (!f.startsWith("claude_") || !f.endsWith(".json")) continue;
+    try {
+      const s = JSON.parse(readFileSync2(join4(SESSION_DIR, f), "utf-8"));
+      sessions.push(s);
+    } catch {
+    }
+  }
+  return sessions;
+}
+var MCP_STDIO_BRIDGE = [
+  "#!/usr/bin/env node",
+  '"use strict";',
+  'const { createInterface } = require("readline");',
+  "const url = `http://127.0.0.1:${process.argv[2]}/mcp`;",
+  "const rl = createInterface({ input: process.stdin });",
+  "(async () => {",
+  "  for await (const line of rl) {",
+  "    if (!line.trim()) continue;",
+  "    try {",
+  "      const res = await fetch(url, {",
+  '        method: "POST",',
+  '        headers: { "Content-Type": "application/json", Accept: "application/json, text/event-stream" },',
+  "        body: line,",
+  "      });",
+  "      if (res.status === 202) continue;",
+  "      const body = await res.text();",
+  '      for (const bl of body.split("\\n")) {',
+  "        const m = bl.match(/^data: (.+)/);",
+  '        if (m) process.stdout.write(m[1] + "\\n");',
+  "      }",
+  "    } catch {",
+  "      process.exit(1);",
+  "    }",
+  "  }",
+  "})();"
+].join("\n");
+async function runClaude(options) {
+  if (options.headless) {
+    const setup2 = await setupAgentRuntime(options);
+    const deliver = async (parts) => {
+      const text = contentPartsToString(parts);
+      if (text.trim()) process.stdout.write(text + "\n");
+    };
+    const eventLoopPromise2 = setup2.processor.run(deliver, setup2.wrappedSource, setup2.initialParts).catch(() => {
+    });
+    process.stderr.write(`MCP server: ${setup2.mcpServer.url}
+`);
+    await new Promise((resolve3) => {
+      process.on("SIGINT", resolve3);
+      process.on("SIGTERM", resolve3);
+    });
+    await setup2.cleanup();
+    await eventLoopPromise2;
+    return;
+  }
+  if (!tmuxAvailable()) {
+    console.error("Error: tmux is required but not found. Install it with: brew install tmux");
+    process.exit(1);
+  }
+  if (options.resume) {
+    return resumeClaude(options);
+  }
+  const setup = await setupAgentRuntime({ ...options, joinUrls: void 0 });
+  const tmpDir = mkdtempSync(join4(tmpdir(), "apiary_agent_"));
+  const bridgePath = join4(tmpDir, "mcp-bridge.cjs");
+  writeFileSync2(bridgePath, MCP_STDIO_BRIDGE);
+  chmodSync(bridgePath, 493);
+  const mcpPort = new URL(setup.mcpServer.url).port;
+  const mcpConfigPath = join4(tmpDir, "mcp.json");
+  const mcpConfig = {
+    mcpServers: {
+      apiary: {
+        type: "stdio",
+        command: process.execPath,
+        args: [bridgePath, mcpPort]
+      }
+    }
+  };
+  writeFileSync2(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+  const tmuxSession = `apiary_${setup.agentName}`;
+  if (tmuxSessionExists(tmuxSession)) {
+    tmuxKillSession(tmuxSession);
+  }
+  const home = homedir3();
+  const cwdFull = process.cwd();
+  const cwdShort = cwdFull.startsWith(home) ? "~" + cwdFull.slice(home.length) : cwdFull;
+  const tabTitle = `${agentEmoji(setup.agentName)} ${setup.agentName} \xB7 ${cwdShort}`;
+  console.log("Launching Claude Code...");
+  tmuxCreateSession(tmuxSession, tabTitle);
+  pretrustCwd(process.cwd());
+  if (wantsUnattendedAgents()) {
+    const trust = preAcceptClaudeTrust(process.cwd());
+    if (trust === "failed" && !options.background) {
+      console.log("Note: could not pre-accept Claude's folder-trust dialog \u2014 the agent may ask once.");
+    }
+  }
+  const extraArgs = options.extraArgs ?? [];
+  const flags = [`claude --mcp-config ${mcpConfigPath} --strict-mcp-config`];
+  if (wantsUnattendedAgents() && !extraArgs.includes(SKIP_PERMISSIONS_FLAG)) {
+    flags.push(SKIP_PERMISSIONS_FLAG);
+  }
+  const claudeCmd = [...flags, ...extraArgs].join(" ");
+  tmuxSendCommand(tmuxSession, claudeCmd);
+  const bridge = new TmuxBridge(tmuxSession);
+  const eventLoopPromise = setup.processor.run(bridge.deliver.bind(bridge), setup.wrappedSource).catch(() => {
+  });
+  let lastActivityLabel = null;
+  let lastState;
+  let lastReportAt = 0;
+  const activityTimer = setInterval(() => {
+    let label;
+    let state;
+    try {
+      label = bridge.getActivityLabel();
+      state = claudeStateToActivity(bridge.detectReportedState());
+    } catch {
+      return;
+    }
+    if (!shouldReportActivity({
+      label,
+      state,
+      lastLabel: lastActivityLabel,
+      lastState,
+      lastReportAt,
+      now: Date.now()
+    })) return;
+    lastActivityLabel = label;
+    lastState = state;
+    lastReportAt = Date.now();
+    setup.processor.broadcastActivity(label, state).catch(() => {
+    });
+  }, 1500);
+  activityTimer.unref();
+  let lastBroadcastCtx = -1;
+  const metricsTimer = setInterval(() => {
+    try {
+      const m = readAgentMetrics(process.cwd());
+      if (!m) return;
+      if (m.lastTurnContextTokens === lastBroadcastCtx) return;
+      lastBroadcastCtx = m.lastTurnContextTokens;
+      setup.processor.broadcastMetrics({
+        input_tokens: m.inputTokens,
+        output_tokens: m.outputTokens,
+        cache_read_tokens: m.cacheReadTokens,
+        cache_create_tokens: m.cacheCreateTokens,
+        last_ctx_tokens: m.lastTurnContextTokens,
+        model: m.lastModel
+      }).catch(() => {
+      });
+    } catch {
+    }
+  }, 1e4);
+  metricsTimer.unref();
+  for (let i = 0; i < 10; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (!tmuxSessionExists(tmuxSession)) {
+      console.error("Error: Claude Code exited during startup. Try running again.");
+      clearInterval(activityTimer);
+      clearInterval(metricsTimer);
+      bridge.stop();
+      await setup.cleanup();
+      try {
+        rmSync(tmpDir, { recursive: true });
+      } catch {
+      }
+      resetTerminal();
+      return;
+    }
+  }
+  const inviteAbort = new AbortController();
+  const invitePromise = deliverInvite({
+    agentName: setup.agentName,
+    deliver: (parts) => bridge.deliver(parts, { dedupe: true }),
+    hasJoined: (url) => setup.joinResults.some((jr) => sameApiaryServer(jr.serverUrl, url)),
+    signal: inviteAbort.signal
+  }).then((outcome) => {
+    if (outcome === "abandoned" && !options.background) {
+      console.log(
+        `Note: "${setup.agentName}" did not join the room it was invited to. The invite is still queued \u2014 check the pane, then re-run or use "apiary room resume".`
+      );
+    }
+    return outcome;
+  }).catch(() => "cancelled");
+  saveSession({
+    tmuxSession,
+    agentName: setup.agentName,
+    tmpDir,
+    mcpPort,
+    pid: process.pid
+  });
+  if (options.background) {
+    const noop = (() => true);
+    process.stdout.write = noop;
+    process.stderr.write = noop;
+    await new Promise((resolve3) => {
+      process.on("SIGTERM", resolve3);
+      process.on("SIGINT", resolve3);
+    });
+    clearInterval(activityTimer);
+    clearInterval(metricsTimer);
+    inviteAbort.abort();
+    await invitePromise;
+    bridge.stop();
+    await setup.cleanup();
+    if (tmuxSessionExists(tmuxSession)) tmuxKillSession(tmuxSession);
+    try {
+      rmSync(tmpDir, { recursive: true });
+    } catch {
+    }
+    clearSession(setup.agentName);
+    return;
+  }
+  console.log("Attaching...");
+  console.log(`(Ctrl+B D to detach \u2014 resume with: apiary claude ${setup.agentName} --resume)
+`);
+  try {
+    await tmuxAttach(tmuxSession);
+  } catch {
+  }
+  if (tmuxSessionExists(tmuxSession)) {
+    console.log(`"${setup.agentName}" still running in background.`);
+    console.log(`  Resume:  apiary claude ${setup.agentName} --resume`);
+    console.log(`  Stop:    apiary stop ${setup.agentName}`);
+    const noop = (() => true);
+    process.stdout.write = noop;
+    process.stderr.write = noop;
+    await new Promise((resolve3) => {
+      process.on("SIGINT", resolve3);
+      process.on("SIGTERM", resolve3);
+    });
+  }
+  clearInterval(activityTimer);
+  clearInterval(metricsTimer);
+  inviteAbort.abort();
+  await invitePromise;
+  bridge.stop();
+  await setup.cleanup();
+  if (tmuxSessionExists(tmuxSession)) tmuxKillSession(tmuxSession);
+  try {
+    rmSync(tmpDir, { recursive: true });
+  } catch {
+  }
+  clearSession(setup.agentName);
+  resetTerminal();
+}
+async function resumeClaude(options) {
+  const name = options.name;
+  const sessions = listClaudeSessions();
+  if (sessions.length === 0) {
+    console.error("No active Claude sessions to resume.");
+    process.exit(1);
+  }
+  let session;
+  if (name) {
+    session = sessions.find((s) => s.agentName === name);
+    if (!session) {
+      console.error(`No active session named "${name}". Active sessions:`);
+      for (const s of sessions) console.error(`  - ${s.agentName}`);
+      process.exit(1);
+    }
+  } else if (sessions.length === 1) {
+    session = sessions[0];
+  } else {
+    console.error("Multiple active sessions. Specify which one with --name:");
+    for (const s of sessions) console.error(`  - ${s.agentName}`);
+    process.exit(1);
+  }
+  if (!tmuxSessionExists(session.tmuxSession)) {
+    console.error(`Session "${session.agentName}" tmux session is gone. Cleaning up.`);
+    clearSession(session.agentName);
+    process.exit(1);
+  }
+  try {
+    process.kill(session.pid, 0);
+  } catch {
+    console.error(`Session "${session.agentName}" background process (pid ${session.pid}) is gone. Cleaning up.`);
+    tmuxKillSession(session.tmuxSession);
+    clearSession(session.agentName);
+    try {
+      rmSync(session.tmpDir, { recursive: true });
+    } catch {
+    }
+    process.exit(1);
+  }
+  console.log(`Resuming session "${session.agentName}"...
+`);
+  try {
+    await tmuxAttach(session.tmuxSession);
+  } catch {
+  }
+  if (tmuxSessionExists(session.tmuxSession)) {
+    console.log(`"${session.agentName}" still running in background.`);
+    console.log(`  Resume:  apiary claude ${session.agentName} --resume`);
+    console.log(`  Stop:    apiary stop ${session.agentName}`);
+  }
+}
+async function stopClaude(name, all) {
+  const sessions = listClaudeSessions();
+  if (sessions.length === 0) {
+    if (all) return;
+    console.error("No active Claude sessions.");
+    process.exit(1);
+  }
+  if (all) {
+    for (const s of sessions) {
+      stopSession(s);
+    }
+    return;
+  }
+  let session;
+  if (name) {
+    session = sessions.find((s) => s.agentName === name);
+    if (!session) {
+      console.error(`No active session named "${name}". Active sessions:`);
+      for (const s of sessions) console.error(`  - ${s.agentName}`);
+      process.exit(1);
+    }
+  } else if (sessions.length === 1) {
+    session = sessions[0];
+  } else {
+    console.error("Multiple active sessions. Use --name or --all:");
+    for (const s of sessions) console.error(`  - ${s.agentName}`);
+    process.exit(1);
+  }
+  stopSession(session);
+}
+function stopSession(session) {
+  if (tmuxSessionExists(session.tmuxSession)) {
+    tmuxKillSession(session.tmuxSession);
+  }
+  try {
+    process.kill(session.pid, "SIGTERM");
+  } catch {
+  }
+  try {
+    rmSync(session.tmpDir, { recursive: true });
+  } catch {
+  }
+  clearSession(session.agentName);
+  resetTerminal();
+  console.log(`Stopped "${session.agentName}".`);
+}
+
+// src/cli/opencode/run.ts
+import { spawn } from "child_process";
+function listOpencodeSessions() {
+  return listAgentSessions("opencode");
+}
+async function runOpencode(options) {
+  const opencodePort = 14096 + Math.floor(Math.random() * 1e3);
+  const opencodeUrl = `http://127.0.0.1:${opencodePort}`;
+  const roomSessions = /* @__PURE__ */ new Map();
+  async function findApiarySession() {
+    try {
+      const res = await fetch(`${opencodeUrl}/session`);
+      if (!res.ok) return null;
+      const sessions = await res.json();
+      for (const sess of sessions.slice(0, 3)) {
+        const msgRes = await fetch(`${opencodeUrl}/session/${sess.id}/message`);
+        if (!msgRes.ok) continue;
+        const messages = await msgRes.json();
+        for (const msg of messages) {
+          for (const part of msg.parts ?? []) {
+            if (part.type === "tool" && part.tool?.includes("apiary__")) {
+              return sess.id;
+            }
+          }
+        }
+      }
+      return sessions.length > 0 ? sessions[0].id : null;
+    } catch {
+      return null;
+    }
+  }
+  const setup = await setupAgentRuntime({
+    ...options,
+    joinUrls: void 0
+  });
+  const opencodeConfig = {
+    mcp: {
+      apiary: {
+        type: "remote",
+        url: setup.mcpServer.url,
+        oauth: false
+      }
+    }
+  };
+  const extraArgs = options.extraArgs ?? [];
+  const opencodeArgs = ["serve", "--port", String(opencodePort), ...extraArgs];
+  console.log("Launching OpenCode...");
+  let child;
+  try {
+    child = spawn("opencode", opencodeArgs, {
+      env: {
+        ...process.env,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify(opencodeConfig)
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch {
+    console.error("Error: opencode is required but not found. Install it from https://opencode.ai");
+    await setup.cleanup();
+    process.exit(1);
+  }
+  child.stderr?.on("data", (chunk) => {
+    process.stderr.write(chunk);
+  });
+  let childExited = false;
+  child.on("exit", () => {
+    childExited = true;
+  });
+  child.on("error", async () => {
+    console.error("Error: failed to start opencode. Is it installed?");
+    await setup.cleanup();
+    process.exit(1);
+  });
+  const ready = await pollForReady(opencodeUrl, 3e4);
+  if (!ready) {
+    console.error("OpenCode did not become ready within 30 seconds.");
+    child.kill();
+    await setup.cleanup();
+    process.exit(1);
+  }
+  console.log(`  OpenCode running on ${opencodeUrl}`);
+  saveAgentSession({
+    runtime: "opencode",
+    agentName: setup.agentName,
+    pid: process.pid,
+    childPid: child.pid
+  });
+  async function deliver(parts) {
+    const roomId = setup.processor.currentContextRoomId;
+    if (!roomId) return;
+    if (!roomSessions.has(roomId)) {
+      const sid = await findApiarySession();
+      if (!sid) return;
+      roomSessions.set(roomId, sid);
+      console.log(`  Linked room ${roomId} \u2192 session ${sid}`);
+    }
+    const targetSession = roomSessions.get(roomId);
+    const text = contentPartsToString(parts);
+    if (!text.trim()) return;
+    try {
+      const res = await fetch(`${opencodeUrl}/session/${targetSession}/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          parts: [{ type: "text", text }]
+        })
+      });
+      await res.text();
+    } catch {
+    }
+  }
+  const eventLoopPromise = setup.processor.run(deliver, setup.wrappedSource);
+  console.log(`
+  OpenCode agent running.`);
+  console.log(`  To watch: opencode attach ${opencodeUrl}
+`);
+  const exitPromise = new Promise((resolve3) => {
+    child.on("exit", resolve3);
+  });
+  const signalPromise = new Promise((resolve3) => {
+    const handler = () => {
+      resolve3();
+    };
+    process.on("SIGINT", handler);
+    process.on("SIGTERM", handler);
+  });
+  await Promise.race([exitPromise, signalPromise]);
+  if (!childExited) {
+    child.kill();
+  }
+  await setup.cleanup();
+  clearAgentSession("opencode", setup.agentName);
+  console.log("Disconnected.");
+}
+async function stopOpencode(name, all) {
+  const sessions = listOpencodeSessions();
+  if (sessions.length === 0) {
+    if (all) return;
+    console.error("No active OpenCode sessions.");
+    process.exit(1);
+  }
+  if (all) {
+    for (const s of sessions) stopOpencodeSession(s);
+    return;
+  }
+  let session;
+  if (name) {
+    session = sessions.find((s) => s.agentName === name);
+    if (!session) {
+      console.error(`No active OpenCode session named "${name}". Active sessions:`);
+      for (const s of sessions) console.error(`  - ${s.agentName}`);
+      process.exit(1);
+    }
+  } else if (sessions.length === 1) {
+    session = sessions[0];
+  } else {
+    console.error("Multiple active OpenCode sessions. Use --name or --all:");
+    for (const s of sessions) console.error(`  - ${s.agentName}`);
+    process.exit(1);
+  }
+  stopOpencodeSession(session);
+}
+function stopOpencodeSession(session) {
+  if (session.childPid) {
+    try {
+      process.kill(session.childPid, "SIGTERM");
+    } catch {
+    }
+  }
+  if (isAgentAlive(session)) {
+    try {
+      process.kill(session.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  clearAgentSession("opencode", session.agentName);
+  console.log(`Stopped "${session.agentName}".`);
+}
+async function pollForReady(url, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(`${url}/session/status`);
+      if (res.ok) return true;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+
+// src/cli/codex/run.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { rmSync as rmSync3 } from "fs";
+import { homedir as homedir6 } from "os";
+
+// src/cli/codex/queue.ts
+import { execFileSync } from "child_process";
+import { readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync2, existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+function userCodexSessionsDir(codexHome) {
+  return join5(codexHome ?? process.env.CODEX_HOME ?? join5(homedir4(), ".codex"), "sessions");
+}
+function parseSessionMeta(firstLine) {
+  try {
+    const record = JSON.parse(firstLine);
+    if (record?.type !== "session_meta") return null;
+    const payload = record.payload ?? {};
+    const sessionId = payload.session_id ?? payload.id;
+    const startedAt = Date.parse(payload.timestamp ?? "");
+    if (typeof sessionId !== "string" || typeof payload.cwd !== "string") return null;
+    if (Number.isNaN(startedAt)) return null;
+    return { sessionId, cwd: payload.cwd, startedAt };
+  } catch {
+    return null;
+  }
+}
+function rolloutFiles(root) {
+  const found = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync3(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path = join5(dir, entry);
+      let stat;
+      try {
+        stat = statSync2(path);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) walk(path);
+      else if (entry.startsWith("rollout-") && entry.endsWith(".jsonl")) {
+        found.push({ path, mtime: stat.mtimeMs });
+      }
+    }
+  };
+  walk(root);
+  return found.sort((a, b) => b.mtime - a.mtime).map((f) => f.path);
+}
+function findCodexSessionId(opts) {
+  const root = opts.sessionsDir ?? userCodexSessionsDir();
+  if (!existsSync4(root)) return null;
+  const floor = opts.startedAfter - (opts.slackMs ?? 5e3);
+  for (const path of rolloutFiles(root)) {
+    let firstLine;
+    try {
+      firstLine = readFileSync3(path, "utf-8").split("\n", 1)[0] ?? "";
+    } catch {
+      continue;
+    }
+    const meta = parseSessionMeta(firstLine);
+    if (!meta) continue;
+    if (meta.cwd !== opts.cwd) continue;
+    if (meta.startedAt < floor) continue;
+    return meta.sessionId;
+  }
+  return null;
+}
+var defaultRunner = (threadId, text) => {
+  execFileSync("codex", ["queue", "--thread", threadId, "--message", text], {
+    stdio: "ignore"
+  });
+};
+function queueCodexMessage(threadId, text, run = defaultRunner) {
+  try {
+    run(threadId, text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/codex/tmux-bridge.ts
+var SPINNER_CHARS2 = "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F";
+var APPROVAL_PATTERNS = [
+  "Would you like to",
+  "needs your approval",
+  "Press Enter to confirm or Esc to cancel",
+  "Do you want to approve",
+  // v0.15x MCP tool approval: "Allow the apiary MCP server to run tool "x"?"
+  /Allow the .+ MCP server to run tool/,
+  "Allow for this session",
+  // Strings taken from the Codex binary itself rather than guessed.
+  "Allow Codex to run",
+  "Allow Codex to apply proposed code changes?",
+  "enter to submit | esc to cancel"
+];
+var BLOCKED_PATTERNS = [
+  // Not a bare "Welcome to Codex" — the ordinary ready banner opens
+  // "Welcome to Codex! Type a message to get started."
+  /Welcome to Codex, /,
+  "Finish signing in via your browser",
+  "Sign in with ChatGPT",
+  "Sign in with Device Code",
+  "Provide your own API key",
+  "Sign in to continue",
+  // `[\s\S]` not `.`: the screen renders these on separate lines, and `.`
+  // does not cross a newline, so the original pattern never matched.
+  /You are running Codex in [\s\S]+Do you want to allow/,
+  "Do you trust the files in this folder"
+];
+var STREAMING_PATTERNS = [
+  /Working\s*\(\d+[smh]/,
+  // "Working (12s" or "Working (1m 30s"
+  /Working\s*$/,
+  // "Working" at end of line (just started)
+  /esc to interrupt/
+  // hint text during streaming
+];
+var MENTION_POPUP_PATTERNS = [
+  /enter\s+insert\b[\s\S]{0,40}?esc\s+close/i
+];
+function codexMentionPopupIsOpen(lines) {
+  const tail = lines.slice(-20).join("\n");
+  return MENTION_POPUP_PATTERNS.some((p) => p.test(tail));
+}
+function defaultUndeliveredWarning2(text) {
+  const preview = text.replace(/\s+/g, " ").slice(0, 80);
+  process.stderr.write(`apiary: message NOT delivered to the agent \u2014 still in its composer: ${preview}
+`);
+}
+var CodexTmuxBridge = class {
+  session;
+  queue = [];
+  pollTimer = null;
+  pollIntervalMs;
+  pasteDelayMs;
+  keystrokeDelayMs;
+  stopped = false;
+  resolveThreadId;
+  threadId = null;
+  onUndelivered;
+  constructor(session, opts) {
+    this.session = session;
+    this.pollIntervalMs = opts?.pollIntervalMs ?? 200;
+    this.pasteDelayMs = opts?.pasteDelayMs ?? 150;
+    this.keystrokeDelayMs = opts?.keystrokeDelayMs ?? 50;
+    this.resolveThreadId = opts?.resolveThreadId;
+    this.onUndelivered = opts?.onUndelivered ?? defaultUndeliveredWarning2;
+  }
+  /**
+   * The Codex session id, resolved once and remembered.
+   *
+   * Resolution is deferred because the session does not exist at construction
+   * time — Codex is still starting — and it is retried on later deliveries
+   * until it succeeds.
+   */
+  thread() {
+    if (this.threadId) return this.threadId;
+    if (!this.resolveThreadId) return null;
+    try {
+      this.threadId = this.resolveThreadId();
+    } catch {
+      this.threadId = null;
+    }
+    return this.threadId;
+  }
+  /**
+   * Delivery callback — drop-in replacement for EventProcessor's deliver.
+   * Pass `bridge.deliver.bind(bridge)` to EventProcessor.run().
+   */
+  async deliver(parts, opts) {
+    const text = contentPartsToString(parts);
+    if (!text.trim()) return;
+    this.inject(text, opts?.dedupe === true);
+  }
+  /**
+   * Detect the current TUI state by reading the screen.
+   */
+  detectState() {
+    if (tmuxPaneIsShell(this.session)) return "absent";
+    const lines = this.captureScreen();
+    return detectCodexStateFromLines(lines);
+  }
+  /**
+   * Codex's live status text ("Working (12s • esc to interrupt)") for the room
+   * strip, or null when idle. Mirrors the Claude bridge's getActivityLabel so
+   * both runtimes can report the same shape.
+   */
+  getActivityLabel() {
+    return extractCodexActivityLabel(this.captureScreen());
+  }
+  /**
+   * Try to inject text, choosing strategy based on TUI state.
+   * Text is flattened to a single line to avoid multi-line paste issues.
+   */
+  inject(text, dedupe) {
+    const flat = text.replace(/\n/g, " ");
+    const state = this.detectState();
+    if (state !== "absent") {
+      const threadId = this.thread();
+      if (threadId && queueCodexMessage(threadId, flat)) return;
+    }
+    switch (state) {
+      case "idle":
+        this.injectIdle(flat);
+        break;
+      case "typing":
+        this.injectWhileTyping(flat);
+        break;
+      default:
+        this.enqueue(flat, dedupe);
+        break;
+    }
+  }
+  /** Capture the screen via tmux capture-pane. */
+  captureScreen() {
+    return tmuxCapturePane(this.session);
+  }
+  /**
+   * Inject into an idle prompt using bracketed paste.
+   *
+   * Bracketed paste wraps text in ESC[200~...ESC[201~ so crossterm
+   * delivers it as a single Paste event, bypassing the burst detector.
+   * The wrapping happens in one write — see tmuxInjectPaste for why that
+   * matters. After the paste, we wait for the Enter suppression window
+   * (120ms) to expire, then send Enter to submit.
+   */
+  injectIdle(text) {
+    tmuxInjectPaste(this.session, text);
+    this.sleep(this.pasteDelayMs);
+    this.dismissMentionPopup();
+    tmuxSendEnter(this.session);
+    this.confirmSubmitted(text);
+  }
+  /**
+   * Check the message left the composer, and try once more if it did not.
+   *
+   * A submitted message moves into the transcript; one that is still in the
+   * composer was not sent. The retry re-runs the popup guard first, because the
+   * popup is what eats an Enter — and if the text is still there after that,
+   * nothing this bridge can do will send it, so it says so rather than leaving
+   * the room to infer silence.
+   */
+  confirmSubmitted(text) {
+    this.sleep(this.pasteDelayMs);
+    if (!composerStillHolds(this.captureScreen(), text)) return;
+    this.dismissMentionPopup();
+    tmuxSendEnter(this.session);
+    this.sleep(this.pasteDelayMs);
+    if (!composerStillHolds(this.captureScreen(), text)) return;
+    this.onUndelivered(text);
+  }
+  /**
+   * Close the @-mention popup before submitting, if the injection opened it.
+   *
+   * Codex classifies incoming bytes as a paste or as typing partly on timing,
+   * so a payload we sent as a bracketed paste can still be read as typing on a
+   * loaded machine. When that happens a `@` opens the mention popup, and Enter
+   * there *inserts the highlighted completion* instead of submitting. On
+   * 2026-09-10 that turned a room message reading "sooo @all" into
+   * "sooo @Openai-Templates" — the top hit was an installed Codex plugin — and
+   * left it unsent in the composer, so the next message appended to the same
+   * stuck line and the agent looked like it was ignoring the operator.
+   *
+   * Escape closes the popup and leaves the composed text untouched, so the
+   * Enter that follows submits what we actually injected.
+   *
+   * Only ever sent when the popup is on screen: Escape is also Codex's
+   * interrupt, so an unconditional one would cancel a turn in progress.
+   */
+  dismissMentionPopup() {
+    if (!codexMentionPopupIsOpen(this.captureScreen())) return;
+    tmuxSendKey(this.session, "Escape");
+    this.sleep(this.keystrokeDelayMs);
+  }
+  /**
+   * Inject while the user is typing:
+   * 1. Ctrl+U — cut to beginning of line (into kill buffer)
+   * 2. Bracketed paste our text + Enter
+   * 3. Ctrl+Y — yank user's text back from kill buffer
+   */
+  injectWhileTyping(text) {
+    tmuxSendKey(this.session, "C-u");
+    this.sleep(this.keystrokeDelayMs);
+    tmuxInjectPaste(this.session, text);
+    this.sleep(this.pasteDelayMs);
+    this.dismissMentionPopup();
+    tmuxSendEnter(this.session);
+    this.confirmSubmitted(text);
+    this.sleep(this.keystrokeDelayMs);
+    tmuxSendKey(this.session, "C-y");
+  }
+  /**
+   * Add to queue and start polling if not already.
+   *
+   * With `dedupe`, identical pending text is dropped: a caller that retries a
+   * delivery it never saw land (the invite loop) would otherwise stack up N
+   * copies of the same prompt, all flushing at once when the TUI frees up.
+   *
+   * Off by default, and deliberately so — room events must never be collapsed.
+   * Two formatted events carry distinct `#ref`s so they should differ anyway,
+   * but "should" is not a guarantee worth silently dropping a message on.
+   */
+  enqueue(text, dedupe) {
+    if (dedupe && this.queue.includes(text)) return;
+    this.queue.push(text);
+    this.startPolling();
+  }
+  /** Start the polling timer to drain queued events. */
+  startPolling() {
+    if (this.pollTimer || this.stopped) return;
+    this.pollTimer = setInterval(() => this.drainQueue(), this.pollIntervalMs);
+  }
+  /** Stop the polling timer. */
+  stopPolling() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  /**
+   * Try to drain one queued event if the state is safe.
+   * Drains one at a time — each injection may trigger streaming,
+   * so the next poll re-checks state before injecting more.
+   */
+  drainQueue() {
+    if (this.queue.length === 0) {
+      this.stopPolling();
+      return;
+    }
+    const state = this.detectState();
+    if (state === "idle" || state === "typing") {
+      const text = this.queue.shift();
+      if (state === "idle") {
+        this.injectIdle(text);
+      } else {
+        this.injectWhileTyping(text);
+      }
+      if (this.queue.length === 0) {
+        this.stopPolling();
+      }
+    }
+  }
+  /** Cleanup. */
+  stop() {
+    this.stopped = true;
+    this.stopPolling();
+    this.queue.length = 0;
+  }
+  /** Synchronous sleep — only used for tiny keystroke delays. */
+  sleep(ms) {
+    if (ms <= 0) return;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  }
+};
+function matchesAny2(text, patterns) {
+  const haystack = text.toLowerCase();
+  for (const pattern of patterns) {
+    if (typeof pattern === "string") {
+      if (haystack.includes(pattern.toLowerCase())) return true;
+    } else if (pattern.test(text) || new RegExp(pattern.source, pattern.flags.includes("i") ? pattern.flags : pattern.flags + "i").test(text)) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectCodexStateFromLines(lines) {
+  if (lines.length === 0) return "unknown";
+  const tail = lines.slice(-20);
+  const tailText = tail.join("\n");
+  if (matchesAny2(tailText, BLOCKED_PATTERNS)) return "blocked";
+  if (matchesAny2(tailText, APPROVAL_PATTERNS)) return "approval";
+  for (const pattern of STREAMING_PATTERNS) {
+    if (pattern.test(tailText)) return "streaming";
+  }
+  const lastFew = tail.slice(-5).join("");
+  for (const ch of SPINNER_CHARS2) {
+    if (lastFew.includes(ch)) return "streaming";
+  }
+  const nonEmpty = tail.filter((l) => l.trim().length > 0);
+  if (nonEmpty.length > 0) {
+    return "idle";
+  }
+  return "unknown";
+}
+function extractCodexActivityLabel(lines) {
+  for (const line of lines.slice(-12).reverse()) {
+    const m = /(Working|Thinking|Compacting|Reviewing)\b[^)\n]*/.exec(line);
+    if (!m) continue;
+    const label = m[0].replace(/\s*[•·]?\s*esc to interrupt.*$/i, "").trim();
+    if (label) return label.slice(0, 120);
+  }
+  return null;
+}
+
+// src/cli/codex/launch.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync as readdirSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+var STARTUP_TIMEOUT_SEC = 15;
+var TOOL_TIMEOUT_SEC = 60;
+var PROFILE_PREFIX = "apiary-";
+function userCodexHome(env = process.env) {
+  const fromEnv = env.CODEX_HOME?.trim();
+  return fromEnv && fromEnv.length > 0 ? fromEnv : join6(homedir5(), ".codex");
+}
+function codexToolApprovalMode(env = process.env) {
+  const override = env.APIARY_CODEX_TOOL_APPROVAL?.trim();
+  if (override && override.length > 0) return override;
+  return wantsUnattendedAgents(env) ? "approve" : "ask";
+}
+function codexProfileName(agentName) {
+  const safe = agentName.replace(/[^A-Za-z0-9_-]/g, "-").slice(0, 64);
+  return `${PROFILE_PREFIX}${/[A-Za-z0-9]/.test(safe) ? safe : "agent"}`;
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function renderCodexProfile(mcpUrl, approvalMode = codexToolApprovalMode(), unattended = wantsUnattendedAgents()) {
+  const blocks = [
+    // Top-level keys must precede every table header, or TOML parses them as
+    // members of the last table.
+    ...unattended ? [[
+      "# Written by apiary. Layered over your own config; deleted when the agent stops.",
+      "#",
+      "# No approval prompts: nobody is watching this pane, so a prompt is a",
+      "# permanent stall. Commands still run inside Codex's sandbox \u2014 anything",
+      "# it will not allow returns a failure to the model instead of asking.",
+      'approval_policy = "never"'
+    ].join("\n")] : [],
+    [
+      ...unattended ? [] : ["# Written by apiary. Layered over your own config; deleted when the agent stops."],
+      "[mcp_servers.apiary]",
+      `url = ${tomlString(mcpUrl)}`,
+      `startup_timeout_sec = ${STARTUP_TIMEOUT_SEC}`,
+      `tool_timeout_sec = ${TOOL_TIMEOUT_SEC}`
+    ].join("\n"),
+    ...RUNTIME_TOOL_NAMES.map((tool) => [
+      `[mcp_servers.apiary.tools.${tool}]`,
+      `approval_mode = ${tomlString(approvalMode)}`
+    ].join("\n"))
+  ];
+  return blocks.join("\n\n") + "\n";
+}
+function codexProfilePath(agentName, codexHome = userCodexHome()) {
+  return join6(codexHome, `${codexProfileName(agentName)}.config.toml`);
+}
+function prepareCodexLaunch(agentName, mcpUrl, extraArgs = [], codexHome = userCodexHome()) {
+  mkdirSync2(codexHome, { recursive: true });
+  const profilePath = codexProfilePath(agentName, codexHome);
+  writeFileSync3(profilePath, renderCodexProfile(mcpUrl), { mode: 384 });
+  const command = ["codex", "--profile", codexProfileName(agentName), ...extraArgs].join(" ");
+  return { command, profilePath };
+}
+function clearCodexProfile(agentName, codexHome = userCodexHome()) {
+  try {
+    rmSync2(codexProfilePath(agentName, codexHome), { force: true });
+  } catch {
+  }
+}
+function pruneCodexProfiles(liveAgentNames, codexHome = userCodexHome()) {
+  if (!existsSync5(codexHome)) return 0;
+  const live = new Set(liveAgentNames.map((name) => `${codexProfileName(name)}.config.toml`));
+  let removed = 0;
+  try {
+    for (const entry of readdirSync4(codexHome)) {
+      if (!entry.startsWith(PROFILE_PREFIX) || !entry.endsWith(".config.toml")) continue;
+      if (live.has(entry)) continue;
+      try {
+        rmSync2(join6(codexHome, entry), { force: true });
+        removed++;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return removed;
+}
+
+// src/cli/codex/run.ts
+function listCodexSessions() {
+  return listAgentSessions("codex");
+}
+function codexAvailable() {
+  try {
+    execFileSync2("codex", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runCodex(options) {
+  if (options.headless) {
+    const setup2 = await setupAgentRuntime(options);
+    const deliver = async (parts) => {
+      const text = contentPartsToString(parts);
+      if (text.trim()) process.stdout.write(text + "\n");
+    };
+    const eventLoopPromise2 = setup2.processor.run(deliver, setup2.wrappedSource, setup2.initialParts).catch(() => {
+    });
+    process.stderr.write(`MCP server: ${setup2.mcpServer.url}
+`);
+    await new Promise((resolve3) => {
+      process.on("SIGINT", resolve3);
+      process.on("SIGTERM", resolve3);
+    });
+    await setup2.cleanup();
+    await eventLoopPromise2;
+    return;
+  }
+  if (!tmuxAvailable()) {
+    console.error("Error: tmux is required but not found. Install it with: brew install tmux");
+    process.exit(1);
+  }
+  if (!codexAvailable()) {
+    console.error("Error: codex is required but not found. Install it with: npm install -g @openai/codex");
+    process.exit(1);
+  }
+  const setup = await setupAgentRuntime({ ...options, joinUrls: void 0 });
+  const mcpPort = new URL(setup.mcpServer.url).port;
+  const mcpUrl = `http://127.0.0.1:${mcpPort}/mcp`;
+  const tmuxSession = `apiary_${setup.agentName}`;
+  if (tmuxSessionExists(tmuxSession)) {
+    tmuxKillSession(tmuxSession);
+  }
+  const home = homedir6();
+  const cwdFull = process.cwd();
+  const cwdShort = cwdFull.startsWith(home) ? "~" + cwdFull.slice(home.length) : cwdFull;
+  const tabTitle = `${agentEmoji(setup.agentName)} ${setup.agentName} \xB7 ${cwdShort}`;
+  console.log("Launching Codex...");
+  tmuxCreateSession(tmuxSession, tabTitle);
+  pruneCodexProfiles([
+    setup.agentName,
+    ...listCodexSessions().filter(isAgentAlive).map((s) => s.agentName)
+  ]);
+  const { command } = prepareCodexLaunch(setup.agentName, mcpUrl, options.extraArgs ?? []);
+  const launchedAt = Date.now();
+  tmuxSendCommand(tmuxSession, command);
+  const bridge = new CodexTmuxBridge(tmuxSession, {
+    resolveThreadId: () => findCodexSessionId({ cwd: cwdFull, startedAfter: launchedAt })
+  });
+  const eventLoopPromise = setup.processor.run(bridge.deliver.bind(bridge), setup.wrappedSource).catch(() => {
+  });
+  let lastActivityLabel = null;
+  let lastState;
+  let lastReportAt = 0;
+  const activityTimer = setInterval(() => {
+    let label;
+    let state;
+    try {
+      label = bridge.getActivityLabel();
+      state = codexStateToActivity(bridge.detectState());
+    } catch {
+      return;
+    }
+    if (!shouldReportActivity({
+      label,
+      state,
+      lastLabel: lastActivityLabel,
+      lastState,
+      lastReportAt,
+      now: Date.now()
+    })) return;
+    lastActivityLabel = label;
+    lastState = state;
+    lastReportAt = Date.now();
+    setup.processor.broadcastActivity(label, state).catch(() => {
+    });
+  }, 1500);
+  activityTimer.unref();
+  for (let i = 0; i < 10; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (!tmuxSessionExists(tmuxSession)) {
+      console.error("Error: Codex exited during startup. Try running again.");
+      clearCodexProfile(setup.agentName);
+      clearInterval(activityTimer);
+      bridge.stop();
+      await setup.cleanup();
+      resetTerminal();
+      return;
+    }
+  }
+  saveAgentSession({
+    runtime: "codex",
+    agentName: setup.agentName,
+    pid: process.pid,
+    tmuxSession
+  });
+  const inviteAbort = new AbortController();
+  const invitePromise = deliverInvite({
+    agentName: setup.agentName,
+    deliver: (parts) => bridge.deliver(parts, { dedupe: true }),
+    hasJoined: (url) => setup.joinResults.some((jr) => sameApiaryServer(jr.serverUrl, url)),
+    signal: inviteAbort.signal
+  }).then((outcome) => {
+    if (outcome === "abandoned" && !options.background) {
+      console.log(
+        `Note: "${setup.agentName}" did not join the room it was invited to. The invite is still queued \u2014 check the pane, then re-run or use "apiary room resume".`
+      );
+    }
+    return outcome;
+  }).catch(() => "cancelled");
+  if (options.background) {
+    const noop = (() => true);
+    process.stdout.write = noop;
+    process.stderr.write = noop;
+    await new Promise((resolve3) => {
+      process.on("SIGTERM", resolve3);
+      process.on("SIGINT", resolve3);
+    });
+    inviteAbort.abort();
+    await invitePromise;
+    clearInterval(activityTimer);
+    bridge.stop();
+    await setup.cleanup();
+    if (tmuxSessionExists(tmuxSession)) tmuxKillSession(tmuxSession);
+    clearCodexProfile(setup.agentName);
+    clearAgentSession("codex", setup.agentName);
+    return;
+  }
+  console.log("Attaching to Codex session...\n");
+  try {
+    await tmuxAttach(tmuxSession);
+  } catch {
+  }
+  inviteAbort.abort();
+  await invitePromise;
+  clearInterval(activityTimer);
+  bridge.stop();
+  await setup.cleanup();
+  tmuxKillSession(tmuxSession);
+  clearCodexProfile(setup.agentName);
+  clearAgentSession("codex", setup.agentName);
+  resetTerminal();
+  console.log("Disconnected.");
+}
+async function stopCodex(name, all) {
+  const sessions = listCodexSessions();
+  if (sessions.length === 0) {
+    if (all) return;
+    console.error("No active Codex sessions.");
+    process.exit(1);
+  }
+  if (all) {
+    for (const s of sessions) stopCodexSession(s);
+    return;
+  }
+  let session;
+  if (name) {
+    session = sessions.find((s) => s.agentName === name);
+    if (!session) {
+      console.error(`No active Codex session named "${name}". Active sessions:`);
+      for (const s of sessions) console.error(`  - ${s.agentName}`);
+      process.exit(1);
+    }
+  } else if (sessions.length === 1) {
+    session = sessions[0];
+  } else {
+    console.error("Multiple active Codex sessions. Use --name or --all:");
+    for (const s of sessions) console.error(`  - ${s.agentName}`);
+    process.exit(1);
+  }
+  stopCodexSession(session);
+}
+function stopCodexSession(session) {
+  if (session.tmuxSession && tmuxSessionExists(session.tmuxSession)) {
+    tmuxKillSession(session.tmuxSession);
+  }
+  if (isAgentAlive(session)) {
+    try {
+      process.kill(session.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  clearCodexProfile(session.agentName);
+  if (session.tmpDir) {
+    try {
+      rmSync3(session.tmpDir, { recursive: true });
+    } catch {
+    }
+  }
+  clearAgentSession("codex", session.agentName);
+  resetTerminal();
+  console.log(`Stopped "${session.agentName}".`);
+}
+
+// src/cli/version.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+function readPackageField(field) {
+  try {
+    const dir = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync4(resolve2(dir, "../../package.json"), "utf-8"));
+    return typeof pkg[field] === "string" ? pkg[field] : null;
+  } catch {
+    return null;
+  }
+}
+function getVersion() {
+  return readPackageField("version") ?? process.env.npm_package_version ?? "unknown";
+}
+
+// src/cli/help.ts
+function printUsage(stream = console.log) {
+  const color = process.stdout.isTTY;
+  const Y = color ? "\x1B[33m" : "";
+  const C = color ? "\x1B[36m" : "";
+  const G = color ? "\x1B[32m" : "";
+  const D = color ? "\x1B[2m" : "";
+  const B = color ? "\x1B[1m" : "";
+  const R = color ? "\x1B[0m" : "";
+  const COL = 40;
+  const ansi = /\x1b\[[0-9;]*m/g;
+  const row = (cmd, desc) => {
+    const visible = cmd.replace(ansi, "").length;
+    return `  ${cmd}${" ".repeat(Math.max(2, COL - visible))}${D}${desc}${R}`;
+  };
+  stream("");
+  stream(`  ${Y}${B}apiary${R} ${D}v${getVersion()} \u2014 shared rooms for AI agents${R}`);
+  stream("");
+  stream(`  ${G}${B}Workspace${R}`);
+  stream(row(`${C}apiary room create${R}`, "Create a workspace + invite participants"));
+  stream(row(`${C}apiary room ${Y}<name>${R} ${D}[--share]${R}`, "Start a workspace + join"));
+  stream(row(`${C}apiary room resume ${Y}<name>${R}`, "Rejoin your workspace"));
+  stream(row(`${C}apiary room list${R}`, "List your workspaces"));
+  stream("");
+  stream(`  ${G}${B}Who can reach the room${R}`);
+  stream(row(`${D}--bind ${Y}tailscale${R}`, "Your devices anywhere, via Tailscale \u2014 not the local network"));
+  stream(row(`${D}--bind ${Y}lan${R}`, "Anyone on the same wifi"));
+  stream(row(`${D}--share${R}`, "A public cloudflared URL, for people off your tailnet"));
+  stream(`      ${D}room create asks this if you don't pass it. Default: this machine only.${R}`);
+  stream("");
+  stream(`  ${G}${B}Participants${R}  ${D}(each person connects their own agents)${R}`);
+  stream(row(`${C}apiary join ${Y}<url>${R} ${D}[${Y}<name>${R}${D}]${R}`, "Join a workspace"));
+  stream(row(`${C}apiary claude ${Y}<name>${R} ${D}[--admin]${R}`, "Connect Claude Code to the room"));
+  stream(row(`${C}apiary codex ${Y}<name>${R} ${D}[--admin]${R}`, "Connect Codex to the room"));
+  stream(row(`${D}--mode ${Y}standby${R}`, "Quiet until @mentioned, pinged or whispered to"));
+  stream(`      ${D}In room create, suffix the alias instead: ${R}${C}bee:standby${R}${D}. The first agent${R}`);
+  stream(`      ${D}listens to everything, the rest go standby \u2014 one remark, one reply.${R}`);
+  stream("");
+  stream(`  ${G}${B}In the room${R}`);
+  stream(row(`${C}/watch ${Y}<agent>${R}`, "Open that agent's terminal in a new window (Ctrl+<n> too)"));
+  stream(row(`${C}/setmode ${Y}<agent> <mode>${R}`, "Change who an agent listens to, live"));
+  stream(row(`${C}/ping ${Y}<agent>${R}`, "Ask for a one-line status"));
+  stream(`      ${D}The strip shows each agent as \u2713 idle, \u2026 working, or \u23F8 needs you \u2014${R}`);
+  stream(`      ${D}"needs you" means it is stuck on something only you can clear.${R}`);
+  stream("");
+  stream(row(`${C}apiary ps${R}`, "List active rooms + agents"));
+  stream(row(`${C}apiary stop ${D}[${Y}<name>${R}${D} | --all]${R}`, "Stop agents + rooms"));
+  stream(row(`${C}apiary examples${R}`, "Examples + workflows"));
+  stream("");
+}
+function printExamples() {
+  const color = process.stdout.isTTY;
+  const Y = color ? "\x1B[33m" : "";
+  const C = color ? "\x1B[36m" : "";
+  const G = color ? "\x1B[32m" : "";
+  const D = color ? "\x1B[2m" : "";
+  const B = color ? "\x1B[1m" : "";
+  const R = color ? "\x1B[0m" : "";
+  const log = console.log.bind(console);
+  log("");
+  log(`  ${Y}${B}apiary examples${R}`);
+  log("");
+  log(`  ${G}${B}Create a workspace${R}`);
+  log(`    ${C}apiary room create${R}                        ${D}# guided setup \u2014 name it, invite participants${R}`);
+  log(`    ${C}apiary room ${Y}sprint-42${R}                    ${D}# quick start \u2014 host + join immediately${R}`);
+  log(`    ${C}apiary room ${Y}sprint-42${R} ${D}--bind tailscale${R}     ${D}# reachable from your phone, over Tailscale only${R}`);
+  log(`    ${C}apiary room ${Y}sprint-42${R} ${D}--share${R}              ${D}# same, with a public tunnel URL${R}`);
+  log(`    ${D}Ctrl+C leaves the server running \u2014 rejoin anytime:${R}`);
+  log(`    ${C}apiary room resume ${Y}sprint-42${R}`);
+  log("");
+  log(`  ${G}${B}Join a workspace${R}  ${D}(each person connects their own agents)${R}`);
+  log(`    ${C}apiary join ${Y}<url>${R}                        ${D}# join as a participant${R}`);
+  log(`    ${C}apiary join ${Y}<url>${R} ${D}--guest${R}               ${D}# join read-only${R}`);
+  log(`    ${C}apiary claude ${Y}Cleo${R} ${D}--admin${R}               ${D}# connect your Claude Code agent${R}`);
+  log(`    ${C}apiary codex ${Y}Rex${R}                        ${D}# connect your Codex agent${R}`);
+  log(`    ${C}apiary codex ${Y}Rex${R} ${D}--mode standby${R}         ${D}# quiet until @mentioned, pinged or whispered${R}`);
+  log(`    ${D}Tell your agent the room URL \u2014 it joins via apiary__join_room.${R}`);
+  log("");
+  log(`  ${G}${B}Authority${R}  ${D}admin > product_owner > member > guest${R}`);
+  log(`    ${C}/promote ${Y}<name>${R}   ${D}# elevate to product owner (can manage members + modes)${R}`);
+  log(`    ${C}/demote ${Y}<name>${R}    ${D}# drop product owner back to member${R}`);
+  log(`    ${C}/mute ${Y}<name>${R}      ${D}# demote to guest (read-only)${R}`);
+  log(`    ${C}/unmute ${Y}<name>${R}    ${D}# restore to member${R}`);
+  log(`    ${C}/kick ${Y}<name>${R}      ${D}# remove from the room (admin only)${R}`);
+  log(`    ${C}/share ${D}--as member${R} ${D}# generate a share link at a specific tier${R}`);
+  log("");
+  log(`  ${G}${B}TUI commands${R}`);
+  log(`    ${C}/who${R}              ${D}list participants with their roles${R}`);
+  log(`    ${C}/watch ${Y}<name>${R}     ${D}open that agent's terminal in a new window (or Ctrl+<n>)${R}`);
+  log(`    ${C}/ping ${Y}<name>${R}      ${D}ping for a status check${R}`);
+  log(`    ${C}/setmode ${Y}<n> <m>${R}  ${D}set engagement mode (admin / product owner)${R}`);
+  log(`    ${C}/share${R}            ${D}generate share links${R}`);
+  log(`    ${C}/tunnel${R}           ${D}start a cloudflared tunnel mid-session (admin)${R}`);
+  log(`    ${C}/clear${R}            ${D}wipe room history (admin)${R}`);
+  log(`    ${C}/sound${R}            ${D}toggle notification sounds${R}`);
+  log(`    ${C}/leave${R}            ${D}disconnect${R}`);
+  log("");
+  log(`  ${G}${B}Messaging${R}  ${D}(agent tool params)${R}`);
+  log(`    ${D}Whisper \u2014 visible only to named recipients:${R}`);
+  log(`    ${C}apiary__send_message(room, content, null, ${Y}["Alice", "Bob"]${R}${C})${R}`);
+  log(`    ${D}Attachments \u2014 local file or image:${R}`);
+  log(`    ${C}apiary__send_message(room, content, null, null, ${Y}[{ type: "path", path: "..." }]${R}${C})${R}`);
+  log("");
+  log(`  ${G}${B}Sessions${R}`);
+  log(`    ${C}apiary ps${R}                            ${D}# list rooms + agents with join links${R}`);
+  log(`    ${C}apiary stop ${Y}Cleo${R}                     ${D}# stop one agent${R}`);
+  log(`    ${C}apiary stop ${D}--all${R}                     ${D}# stop everything${R}`);
+  log("");
+}
+
+// src/cli/index.ts
+var args = process.argv.slice(2);
+function getFlag(name, arr = args) {
+  const idx = arr.indexOf(`--${name}`);
+  if (idx === -1) return void 0;
+  const value = arr[idx + 1];
+  if (value === void 0 || value.startsWith("--")) return void 0;
+  return value;
+}
+function getAllFlags(name, arr = args) {
+  const results = [];
+  const flag = `--${name}`;
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] === flag && arr[i + 1] && !arr[i + 1].startsWith("--")) {
+      results.push(arr[i + 1]);
+    }
+  }
+  return results;
+}
+function bindFlag(args2) {
+  const spec = getFlag("bind", args2);
+  if (!spec) return void 0;
+  const res = resolveBindAddress(spec);
+  if (!res.ok) {
+    console.error(`Error: ${res.error}`);
+    process.exit(1);
+  }
+  if (res.note) console.log(`  Listening on ${res.address} \u2014 ${res.note}`);
+  return res.address;
+}
+async function main() {
+  if (args[0] === "examples") {
+    printExamples();
+    return;
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    printUsage();
+    return;
+  }
+  if (args.includes("--version") || args.includes("-v") || args[0] === "version") {
+    try {
+      const { createRequire } = await import("module");
+      const require2 = createRequire(import.meta.url);
+      const pkg = require2("../../package.json");
+      console.log(pkg.version);
+    } catch {
+      console.log("unknown");
+    }
+    return;
+  }
+  if (args[0] === "update") {
+    const { runUpdate } = await import("../update-JGE3WCQB.js");
+    const targetVersion = args[1] && !args[1].startsWith("--") ? args[1] : void 0;
+    await runUpdate(targetVersion);
+    return;
+  }
+  printUpdateNotice();
+  checkForUpdate();
+  if (args[0] === "stop") {
+    const rest = args.slice(1);
+    const all = rest.includes("--all");
+    const positional = rest.find((a) => !a.startsWith("--"));
+    const name = getFlag("name", rest) ?? positional;
+    const { roomStop } = await import("../room-Z7KDRVYD.js");
+    if (all) {
+      for (const r of listRoomSessions()) {
+        try {
+          await roomStop(r.roomName, { session: r, quietIfDead: true });
+        } catch {
+        }
+      }
+      await stopClaude(void 0, true);
+      await stopCodex(void 0, true);
+      await stopOpencode(void 0, true);
+      return;
+    }
+    if (name) {
+      const room = listRoomSessions().find((s) => s.roomName === name);
+      if (room) {
+        await roomStop(name, { session: room });
+        return;
+      }
+      if (listCodexSessions().some((s) => s.agentName === name)) {
+        await stopCodex(name, false);
+        return;
+      }
+      if (listOpencodeSessions().some((s) => s.agentName === name)) {
+        await stopOpencode(name, false);
+        return;
+      }
+    }
+    await stopClaude(name, false);
+    return;
+  }
+  if (args[0] === "ps") {
+    const rooms = listRoomSessions();
+    const claudeAgents = listClaudeSessions().map((s) => ({ runtime: "claude", agentName: s.agentName, pid: s.pid }));
+    const codexAgents = listCodexSessions().map((s) => ({ runtime: "codex", agentName: s.agentName, pid: s.pid }));
+    const opencodeAgents = listOpencodeSessions().map((s) => ({ runtime: "opencode", agentName: s.agentName, pid: s.pid }));
+    const agents = [...claudeAgents, ...codexAgents, ...opencodeAgents];
+    if (rooms.length === 0 && agents.length === 0) {
+      console.log("No active sessions.");
+      return;
+    }
+    for (const r of rooms) {
+      let alive = false;
+      try {
+        process.kill(r.pid, 0);
+        alive = true;
+      } catch {
+      }
+      if (!alive) continue;
+      const joinUrl = buildShareUrl(
+        r.publicUrl !== r.serverUrl ? r.publicUrl : r.serverUrl,
+        r.memberToken
+      );
+      console.log(`  \x1B[1m${r.roomName}\x1B[0m  \x1B[2m(room, pid ${r.pid})\x1B[0m`);
+      console.log(`    \x1B[2mJoin:\x1B[0m  \x1B[36mapiary join\x1B[0m ${joinUrl}`);
+    }
+    for (const s of agents) {
+      let alive = false;
+      try {
+        process.kill(s.pid, 0);
+        alive = true;
+      } catch {
+      }
+      const status = alive ? "running" : "stale";
+      console.log(`  ${s.agentName}  (${s.runtime}, pid ${s.pid}, ${status})`);
+    }
+    return;
+  }
+  if (args[0] === "room") {
+    const sub = args[1];
+    const roomArgs = args.slice(2);
+    if (sub === "create") {
+      const portStr = getFlag("port", roomArgs);
+      const port = portStr ? parseInt(portStr, 10) : void 0;
+      const { roomCreate } = await import("../room-Z7KDRVYD.js");
+      await roomCreate({
+        room: getFlag("room", roomArgs) ?? roomArgs.find((a) => !a.startsWith("--")),
+        port,
+        share: roomArgs.includes("--share"),
+        expose: roomArgs.includes("--expose"),
+        bind: bindFlag(roomArgs),
+        foundation: !roomArgs.includes("--no-foundation")
+      });
+      return;
+    }
+    if (sub === "resume") {
+      const name = roomArgs.find((a) => !a.startsWith("--"));
+      if (!name) {
+        console.error("Usage: apiary room resume <name>");
+        process.exit(1);
+      }
+      const { roomResume } = await import("../room-Z7KDRVYD.js");
+      await roomResume(name);
+      return;
+    }
+    if (sub === "list" || sub === "ls") {
+      const { roomList } = await import("../room-Z7KDRVYD.js");
+      roomList();
+      return;
+    }
+    if (sub === "stop") {
+      const name = roomArgs.find((a) => !a.startsWith("--"));
+      if (!name) {
+        console.error("Usage: apiary room stop <name>");
+        process.exit(1);
+      }
+      const { roomStop } = await import("../room-Z7KDRVYD.js");
+      await roomStop(name);
+      return;
+    }
+    {
+      const allRoomArgs = args.slice(1);
+      const positionals = allRoomArgs.filter((a) => !a.startsWith("--"));
+      const roomName = positionals[0];
+      const userName = positionals[1] ?? getFlag("name", allRoomArgs);
+      const portStr = getFlag("port", allRoomArgs);
+      const port = portStr ? parseInt(portStr, 10) : void 0;
+      if (port !== void 0 && (isNaN(port) || port < 0 || port > 65535)) {
+        console.error(`Invalid port: ${portStr}`);
+        process.exit(1);
+      }
+      const { spawnDaemonServer, isDaemonResult } = await import("../room-Z7KDRVYD.js");
+      const daemonRes = await spawnDaemonServer({
+        room: roomName,
+        port,
+        share: allRoomArgs.includes("--share"),
+        expose: allRoomArgs.includes("--expose"),
+        bind: bindFlag(allRoomArgs)
+      });
+      if (!isDaemonResult(daemonRes)) {
+        console.error(`Failed to start server: ${daemonRes.reason}`);
+        if (daemonRes.portInUse) {
+          console.error(`Tip: a previous room daemon is bound. Run 'apiary ps' to inspect, 'apiary stop --all' to free it.`);
+        } else if (daemonRes.stderr?.trim()) {
+          console.error(daemonRes.stderr);
+        }
+        process.exit(1);
+      }
+      const daemon = daemonRes;
+      const adminJoinUrl = buildShareUrl(daemon.serverUrl, daemon.adminToken);
+      const participantShareUrl = buildShareUrl(
+        daemon.publicUrl !== daemon.serverUrl ? daemon.publicUrl : daemon.serverUrl,
+        daemon.memberToken
+      );
+      await join({ server: adminJoinUrl, name: userName, shareUrl: participantShareUrl });
+      console.log(`
+  Server still running (room: ${daemon.roomName})`);
+      console.log(`  Rejoin: apiary room resume ${daemon.roomName}
+`);
+      return;
+    }
+  }
+  if (args[0] === "mcp") {
+    const restArgs = args.slice(1);
+    const joinUrls = getAllFlags("join", restArgs);
+    const positionalName = restArgs.find((a, i) => {
+      if (a.startsWith("--")) return false;
+      if (i > 0 && (/* @__PURE__ */ new Set(["--name", "--join"])).has(restArgs[i - 1])) return false;
+      return true;
+    });
+    const name = getFlag("name", restArgs) ?? positionalName;
+    const pendingUrls = [...joinUrls];
+    if (name) {
+      const { consumeInvite } = await import("../invites-OFXIQLLN.js");
+      const inviteUrl = consumeInvite(name);
+      if (inviteUrl) pendingUrls.push(inviteUrl);
+    }
+    const { runMcpServer } = await import("../run-DOADB4T7.js");
+    await runMcpServer({
+      joinUrls: pendingUrls.length > 0 ? pendingUrls : void 0,
+      name,
+      admin: restArgs.includes("--admin")
+    });
+    return;
+  }
+  const isRunAlias = args[0] === "claude" || args[0] === "codex" || args[0] === "opencode";
+  if (args[0] === "run" && (args[1] === "claude" || args[1] === "opencode" || args[1] === "codex") || isRunAlias) {
+    const runtime = isRunAlias ? args[0] : args[1];
+    const restArgs = args.slice(isRunAlias ? 1 : 2);
+    const ddIndex = restArgs.indexOf("--");
+    const apiaryArgs = ddIndex >= 0 ? restArgs.slice(0, ddIndex) : restArgs;
+    const explicitExtra = ddIndex >= 0 ? restArgs.slice(ddIndex + 1) : [];
+    const KNOWN_FLAGS = /* @__PURE__ */ new Set(["--name", "--admin", "--headless", "--resume", "--join", "--background", "--mode"]);
+    const unknownArgs = [];
+    for (let i = 0; i < apiaryArgs.length; i++) {
+      const arg = apiaryArgs[i];
+      if (arg.startsWith("--") && !KNOWN_FLAGS.has(arg)) {
+        unknownArgs.push(arg);
+        if (i + 1 < apiaryArgs.length && !apiaryArgs[i + 1].startsWith("--")) {
+          unknownArgs.push(apiaryArgs[++i]);
+        }
+      }
+    }
+    const extraArgs = [...unknownArgs, ...explicitExtra];
+    const joinUrls = getAllFlags("join", apiaryArgs);
+    const positionalName = apiaryArgs.find((a, i) => {
+      if (a.startsWith("--")) return false;
+      if (i > 0 && KNOWN_FLAGS.has(apiaryArgs[i - 1])) return false;
+      return true;
+    });
+    const runtimeOptions = {
+      joinUrls: joinUrls.length > 0 ? joinUrls : void 0,
+      name: getFlag("name", apiaryArgs) ?? positionalName,
+      admin: apiaryArgs.includes("--admin"),
+      headless: apiaryArgs.includes("--headless"),
+      resume: apiaryArgs.includes("--resume"),
+      background: apiaryArgs.includes("--background"),
+      mode: parseEngagementMode(getFlag("mode", apiaryArgs)),
+      extraArgs
+    };
+    if (runtime === "claude") {
+      await runClaude(runtimeOptions);
+    } else if (runtime === "opencode") {
+      await runOpencode(runtimeOptions);
+    } else {
+      await runCodex(runtimeOptions);
+    }
+    return;
+  }
+  if (args[0] === "join") {
+    const server = args[1];
+    if (!server || server.startsWith("--")) {
+      console.error("Usage: apiary join <url> [<name>] [--guest] [--headless]");
+      process.exit(1);
+    }
+    const joinName = args[2] && !args[2].startsWith("--") ? args[2] : getFlag("name");
+    await join({
+      server,
+      name: joinName,
+      guest: args.includes("--guest"),
+      headless: args.includes("--headless")
+    });
+    return;
+  }
+  if (args[0] === "serve") {
+    const portStr = getFlag("port");
+    const port = portStr ? parseInt(portStr, 10) : void 0;
+    if (port !== void 0 && (isNaN(port) || port < 0 || port > 65535)) {
+      console.error(`Invalid port: ${portStr}`);
+      process.exit(1);
+    }
+    const shareTtlStr = getFlag("share-token-ttl");
+    const shareTtlMs = shareTtlStr ? parseInt(shareTtlStr, 10) : void 0;
+    await serve({
+      room: getFlag("room"),
+      port,
+      share: args.includes("--share"),
+      headless: args.includes("--headless"),
+      expose: args.includes("--expose"),
+      bind: bindFlag(args),
+      corsOrigins: getAllFlags("cors-origin"),
+      shareTtlMs
+    });
+    return;
+  }
+  if (args.length === 0 || args[0]?.startsWith("--")) {
+    const portStr = getFlag("port");
+    const port = portStr ? parseInt(portStr, 10) : void 0;
+    if (port !== void 0 && (isNaN(port) || port < 0 || port > 65535)) {
+      console.error(`Invalid port: ${portStr}`);
+      process.exit(1);
+    }
+    const result = await serve({
+      room: getFlag("room"),
+      port,
+      share: args.includes("--share"),
+      quiet: true,
+      expose: args.includes("--expose"),
+      bind: bindFlag(args),
+      corsOrigins: getAllFlags("cors-origin")
+    });
+    const adminJoinUrl = buildShareUrl(result.serverUrl, result.adminToken);
+    const participantShareUrl = buildShareUrl(
+      result.publicUrl !== result.serverUrl ? result.publicUrl : result.serverUrl,
+      result.memberToken
+    );
+    await join({
+      server: adminJoinUrl,
+      name: getFlag("name"),
+      shareUrl: participantShareUrl
+    });
+    return;
+  }
+  console.error(`Unknown command: ${args[0]}
+`);
+  printUsage(console.error);
+  process.exit(1);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map