@gravity-rail/cli 0.5.1 → 0.7.0

package/dist/chunk-QVG4L6BE.js

@@ -0,0 +1,2199 @@
+#!/usr/bin/env node
+import { AGUIClient, clearScreen, printMessage, requireAuth, originateConciergeCall, originateConciergeSms, getConciergeChatMessages, getConciergeChat, createConciergeChat, listConciergeChats, selectFromList, formatTimestamp, getTextDelta, getErrorMessage } from './chunk-3EO4COHB.js';
+import { CLIError } from './chunk-XRBVAFCB.js';
+import path3 from 'path';
+import * as readline from 'readline';
+import readline__default from 'readline';
+import fs, { createWriteStream } from 'fs';
+import os from 'os';
+import { EventEmitter } from 'events';
+import { execSync, spawn, spawnSync } from 'child_process';
+
+function buildCliConciergeAppContext() {
+  const shell = process.env.SHELL ? path3.basename(process.env.SHELL) : void 0;
+  return {
+    clientSurface: "cli",
+    channel: "text",
+    cliContext: {
+      shell,
+      os: process.platform,
+      cwdBasename: path3.basename(process.cwd())
+    }
+  };
+}
+var DEFAULT_MAX_READ_BYTES = 5e4;
+var ABSOLUTE_MAX_READ_BYTES = 1e6;
+function resolveSafePath(root, relativePath) {
+  const rootResolved = path3.resolve(root);
+  const target = path3.resolve(rootResolved, relativePath || ".");
+  if (target !== rootResolved && !target.startsWith(rootResolved + path3.sep)) {
+    return null;
+  }
+  let cursor = rootResolved;
+  const rest = path3.relative(rootResolved, target);
+  if (rest && rest !== ".") {
+    for (const segment of rest.split(path3.sep)) {
+      cursor = path3.join(cursor, segment);
+      try {
+        const lstat = fs.lstatSync(cursor);
+        if (lstat.isSymbolicLink()) {
+          return null;
+        }
+      } catch {
+        break;
+      }
+    }
+  }
+  return target;
+}
+function executeCliLocalFileAction(root, interrupt, opts) {
+  const safe = resolveSafePath(root, interrupt.path);
+  if (!safe) {
+    return { ok: false, error: "Path escapes trusted directory" };
+  }
+  try {
+    switch (interrupt.action) {
+      case "read_file": {
+        if (!fs.existsSync(safe)) {
+          return { ok: false, error: "File not found" };
+        }
+        const stat = fs.lstatSync(safe);
+        if (stat.isSymbolicLink()) {
+          return { ok: false, error: "Path escapes trusted directory" };
+        }
+        if (!stat.isFile()) {
+          return { ok: false, error: "Not a file" };
+        }
+        const requested = Number.isFinite(interrupt.max_bytes) ? Math.max(1, Math.min(Number(interrupt.max_bytes), ABSOLUTE_MAX_READ_BYTES)) : DEFAULT_MAX_READ_BYTES;
+        if (stat.size > requested) {
+          const buf = fs.readFileSync(safe, { encoding: "utf8" });
+          return {
+            ok: true,
+            content: buf.slice(0, requested) + `
+
+[truncated at ${requested} bytes]`
+          };
+        }
+        return { ok: true, content: fs.readFileSync(safe, "utf8") };
+      }
+      case "list_dir": {
+        if (!fs.existsSync(safe)) {
+          return { ok: false, error: "Directory not found" };
+        }
+        const entries = fs.readdirSync(safe, { withFileTypes: true });
+        const lines = entries.slice(0, 200).map((e) => e.isDirectory() ? `${e.name}/` : e.name);
+        if (entries.length > 200) {
+          lines.push(`... and ${entries.length - 200} more`);
+        }
+        return { ok: true, content: lines.join("\n") };
+      }
+      case "write_file": {
+        if (!opts.allowWrite) {
+          return { ok: false, error: "Write requires --allow-write" };
+        }
+        if (interrupt.content === void 0) {
+          return { ok: false, error: "Missing content for write_file" };
+        }
+        fs.mkdirSync(path3.dirname(safe), { recursive: true });
+        fs.writeFileSync(safe, interrupt.content, "utf8");
+        return { ok: true, content: "written" };
+      }
+      default:
+        return { ok: false, error: `Unknown action: ${interrupt.action}` };
+    }
+  } catch (e) {
+    return { ok: false, error: sanitizeLocalFileError(e) };
+  }
+}
+function sanitizeLocalFileError(e) {
+  if (e && typeof e === "object" && "code" in e) {
+    const code = e.code;
+    if (code === "ENOENT") return "File or directory not found";
+    if (code === "EACCES" || code === "EPERM") return "Permission denied";
+    if (code === "EISDIR") return "Not a file";
+    if (code === "ENOTDIR") return "Not a directory";
+  }
+  return "Local file operation failed";
+}
+function isCliLocalFileInterrupt(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return v.type === "cli_local_file" && typeof v.action === "string" && typeof v.path === "string";
+}
+var STORE_VERSION = 1;
+function storePath() {
+  const base = process.env.XDG_CONFIG_HOME ?? (process.platform === "win32" ? path3.join(process.env.APPDATA ?? os.homedir(), "gravityrail") : path3.join(os.homedir(), ".config", "gravityrail"));
+  return path3.join(base, "trusted-dirs.json");
+}
+function loadTrustedDirsStore() {
+  const file = storePath();
+  try {
+    const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    if (raw?.version === STORE_VERSION && Array.isArray(raw.always)) {
+      return { version: STORE_VERSION, always: raw.always.map((p) => path3.resolve(p)) };
+    }
+  } catch {
+  }
+  return { version: STORE_VERSION, always: [] };
+}
+function saveTrustedDirsStore(store) {
+  const file = storePath();
+  const dir = path3.dirname(file);
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs.writeFileSync(file, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
+}
+function isDirectoryTrusted(dirPath, opts) {
+  if (opts?.trustCwdFlag) return true;
+  const resolved = path3.resolve(dirPath);
+  const store = loadTrustedDirsStore();
+  return store.always.includes(resolved);
+}
+async function promptTrustInteractive(dirPath) {
+  const rl = readline__default.createInterface({ input: process.stdin, output: process.stderr });
+  const question = (q) => new Promise((resolve) => rl.question(q, resolve));
+  process.stderr.write(
+    `
+Gravity Rail may read files in:
+  ${dirPath}
+
+File contents can influence the assistant. Do you trust the files in this directory?
+  [1] Trust once (this session)
+  [2] Trust always (remember for this path)
+  [3] No \u2014 do not read local files
+
+Choice [1/2/3] (default 3): `
+  );
+  const answer = (await question("")).trim() || "3";
+  rl.close();
+  if (answer === "1") return "once";
+  if (answer === "2") return "always";
+  return "denied";
+}
+var sessionTrusted = /* @__PURE__ */ new Set();
+async function resolveDirectoryTrust(opts) {
+  const dir = path3.resolve(opts.trustDir ?? opts.cwd ?? process.cwd());
+  if (isDirectoryTrusted(dir, { trustCwdFlag: opts.trustCwd })) return "trusted";
+  if (sessionTrusted.has(dir)) return "trusted";
+  if (opts.trustDir && path3.resolve(opts.trustDir) === dir) {
+    sessionTrusted.add(dir);
+    return "trusted";
+  }
+  if (opts.trustCwd) {
+    sessionTrusted.add(dir);
+    return "trusted";
+  }
+  if (!process.stdin.isTTY || opts.nonInteractive) {
+    return "denied";
+  }
+  const decision = await promptTrustInteractive(dir);
+  if (decision === "denied") {
+    return "denied";
+  }
+  if (decision === "always") {
+    const store = loadTrustedDirsStore();
+    if (!store.always.includes(dir)) {
+      store.always.push(dir);
+      saveTrustedDirsStore(store);
+    }
+  }
+  sessionTrusted.add(dir);
+  return "trusted";
+}
+
+// src/lib/cli-hitl.ts
+function extractHumanInputRequest(event) {
+  const type = String(event.type ?? "").toUpperCase();
+  if (type === "CUSTOM" && event.name === "human_input_request") {
+    return event.value;
+  }
+  if (event.name === "human_input_request") {
+    return event.value;
+  }
+  return null;
+}
+async function handleCliHitlInterrupt(value, opts) {
+  if (!value || typeof value !== "object") return null;
+  const payload = value;
+  if (isCliLocalFileInterrupt(payload)) {
+    const interrupt = payload;
+    if (typeof payload.interrupt_id === "string") {
+      interrupt.interrupt_id = payload.interrupt_id;
+    }
+    return handleCliLocalFile(interrupt, opts);
+  }
+  if (payload.type === "present_choice") {
+    return handlePresentChoiceTerminal(payload);
+  }
+  return null;
+}
+async function handleCliLocalFile(interrupt, opts) {
+  const trust = await resolveDirectoryTrust({
+    cwd: process.cwd(),
+    trustCwd: opts.trustCwd,
+    trustDir: opts.trustDir,
+    // Interactive sessions: prompt on first local-file use (review feedback).
+    nonInteractive: opts.nonInteractive ?? process.stdin.isTTY !== true
+  });
+  if (trust !== "trusted") {
+    return {
+      resumeValue: JSON.stringify({
+        ok: false,
+        error: "Directory not trusted for local file access. Re-run with --trust-cwd or --trust-dir <path>, or approve trust interactively when prompted."
+      }),
+      resumeInterruptId: interrupt.interrupt_id
+    };
+  }
+  process.stderr.write(`
+[local ${interrupt.action}] ${interrupt.path}
+`);
+  const result = executeCliLocalFileAction(process.cwd(), interrupt, {
+    allowWrite: opts.allowWrite
+  });
+  return {
+    resumeValue: JSON.stringify(result),
+    resumeInterruptId: interrupt.interrupt_id
+  };
+}
+async function handlePresentChoiceTerminal(payload) {
+  const prompt = typeof payload.user_prompt === "string" && payload.user_prompt || typeof payload.description === "string" && payload.description || "Choose an option";
+  const markup = typeof payload.openui_markup === "string" ? payload.openui_markup : "";
+  process.stderr.write(`
+${prompt}
+`);
+  if (markup) {
+    process.stderr.write(`${markup.slice(0, 2e3)}
+`);
+  }
+  if (!process.stdin.isTTY) {
+    return {
+      resumeValue: "",
+      resumeInterruptId: typeof payload.interrupt_id === "string" ? payload.interrupt_id : void 0
+    };
+  }
+  const rl = readline__default.createInterface({ input: process.stdin, output: process.stderr });
+  const answer = await new Promise((resolve) => {
+    rl.question("Your choice (value): ", resolve);
+  });
+  rl.close();
+  return {
+    resumeValue: answer.trim(),
+    resumeInterruptId: typeof payload.interrupt_id === "string" ? payload.interrupt_id : void 0
+  };
+}
+
+// src/lib/concierge-agui-loop.ts
+var MAX_HITL_ROUNDS = 25;
+async function runConciergeAguiLoop(client, initialMessages, onEvent, opts) {
+  let streamText = "";
+  let hasToolCalls = false;
+  let resume;
+  for (let round = 0; round < MAX_HITL_ROUNDS; round++) {
+    let hitlPayload = null;
+    await client.streamRequest(
+      resume ? {
+        messages: [],
+        resumeValue: resume.resumeValue,
+        resumeInterruptId: resume.resumeInterruptId
+      } : { messages: initialMessages },
+      (event) => {
+        onEvent(event);
+        const delta = getTextDelta(event);
+        if (delta) streamText += delta;
+        const type = event.type?.toLowerCase() ?? "";
+        if (type === "tool_call_start") hasToolCalls = true;
+        const errorMsg = getErrorMessage(event);
+        if (errorMsg) process.stderr.write(`\x1B[31mError: ${errorMsg}\x1B[0m
+`);
+        const hitl = extractHumanInputRequest(event);
+        if (hitl) hitlPayload = hitl;
+      },
+      { autoApprove: opts.autoApprove }
+    );
+    if (!hitlPayload) {
+      break;
+    }
+    const next = await handleCliHitlInterrupt(hitlPayload, {
+      allowWrite: opts.allowWrite,
+      autoApprove: opts.autoApprove,
+      trustCwd: opts.trustCwd,
+      trustDir: opts.trustDir,
+      nonInteractive: opts.nonInteractive
+    });
+    if (!next) {
+      process.stderr.write(
+        "  [HITL] Unsupported interrupt in CLI \u2014 open app.gravityrail.com/setup to continue.\n"
+      );
+      break;
+    }
+    resume = next;
+    streamText = "";
+  }
+  return { streamText, hasToolCalls };
+}
+var RealtimeClient = class extends EventEmitter {
+  ws = null;
+  connected = false;
+  options;
+  constructor(options) {
+    super();
+    this.options = {
+      vadMode: "server",
+      debug: false,
+      ...options
+    };
+  }
+  /** Connect to the realtime WebSocket endpoint */
+  connect() {
+    if (typeof globalThis.WebSocket === "undefined") {
+      return Promise.reject(
+        new Error("WebSocket not available. Node.js 22+ is required for realtime mode.")
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const params = new URLSearchParams();
+      if (this.options.vadMode) {
+        params.append("vad", this.options.vadMode);
+      }
+      const url = params.toString() ? `${this.options.url}?${params.toString()}` : this.options.url;
+      if (this.options.debug) {
+        process.stderr.write(`[debug] Connecting to ${url}
+`);
+      }
+      this.ws = new WebSocket(url);
+      this.ws.onerror = (event) => {
+        const msg = event instanceof ErrorEvent ? event.message : "WebSocket connection failed";
+        if (!this.connected) {
+          reject(new Error(msg));
+        } else {
+          this.emit("error", new Error(msg));
+        }
+      };
+      this.ws.onclose = (event) => {
+        const reason = event.code === 1006 ? "Connection lost" : event.reason || "Closed";
+        this.connected = false;
+        this.emit("closed", { reason, code: event.code });
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const data = typeof event.data === "string" ? event.data : event.data.toString();
+          const parsed = JSON.parse(data);
+          this.emit("ws_recv", parsed);
+          this.handleEvent(parsed);
+        } catch {
+          if (this.options.debug) {
+            process.stderr.write(`[debug] Failed to parse message
+`);
+          }
+        }
+      };
+      this.ws.onopen = () => {
+        if (this.options.debug) {
+          process.stderr.write("[debug] WebSocket connected, sending login\n");
+        }
+        this.sendCustom("voice.login", {
+          token: this.options.token,
+          chat_id: this.options.chatId,
+          vad: this.options.vadMode
+        });
+      };
+      const timeout = setTimeout(() => {
+        if (!this.connected) {
+          this.close();
+          reject(new Error("Connection timeout - no login response within 10s"));
+        }
+      }, 1e4);
+      this.once("connected", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      this.once("error", () => {
+        clearTimeout(timeout);
+      });
+    });
+  }
+  handleEvent(event) {
+    switch (event.type) {
+      case "CUSTOM":
+        this.handleCustomEvent(event.name || "", event.value);
+        break;
+      case "TEXT_MESSAGE_START":
+        this.emit("text_start", { messageId: event.messageId || "" });
+        break;
+      case "TEXT_MESSAGE_CONTENT":
+        this.emit("text_delta", {
+          messageId: event.messageId || "",
+          delta: event.delta || ""
+        });
+        break;
+      case "TEXT_MESSAGE_END":
+        this.emit("text_end", { messageId: event.messageId || "" });
+        break;
+      case "TOOL_CALL_START":
+        this.emit("tool_call_start", {
+          toolCallId: event.toolCallId || "",
+          toolCallName: event.toolCallName || ""
+        });
+        break;
+      case "TOOL_CALL_ARGS":
+        this.emit("tool_call_args", {
+          toolCallId: event.toolCallId || "",
+          delta: event.delta || ""
+        });
+        break;
+      case "TOOL_CALL_END":
+        this.emit("tool_call_end", { toolCallId: event.toolCallId || "" });
+        break;
+      case "TOOL_CALL_RESULT":
+        this.emit("tool_call_result", {
+          toolCallId: event.toolCallId || "",
+          result: event.result
+        });
+        break;
+      case "RUN_STARTED":
+        this.emit("run_started", { runId: event.runId });
+        break;
+      case "RUN_FINISHED":
+        this.emit("run_finished", { runId: event.runId });
+        break;
+      case "RUN_ERROR":
+        this.emit("run_error", {
+          message: event.message || "Unknown error",
+          code: event.code
+        });
+        break;
+      default:
+        if (this.options.debug) {
+          process.stderr.write(`[debug] Unknown event type: ${event.type}
+`);
+        }
+    }
+  }
+  handleCustomEvent(name, value) {
+    switch (name) {
+      case "voice.login_success":
+        this.connected = true;
+        this.emit("connected", {
+          chatId: value?.chat_id,
+          memberId: value?.member_id,
+          assistantId: value?.assistant_id
+        });
+        break;
+      case "voice.audio":
+        if (value?.data) {
+          const pcm16 = Buffer.from(value.data, "base64");
+          this.emit("audio", { pcm16, messageId: value.message_id });
+        }
+        break;
+      case "voice.audio_begin":
+        this.emit("audio_begin", { messageId: value?.message_id });
+        break;
+      case "voice.audio_end":
+        this.emit("audio_end", { messageId: value?.message_id });
+        break;
+      case "voice.interrupt":
+        this.emit("interrupt", { messageId: value?.message_id });
+        break;
+      case "voice.response_message":
+        if (value) {
+          this.emit("response_message", value);
+        }
+        break;
+      case "voice.transcription":
+        if (value) {
+          this.emit("transcription", { text: value.text, role: value.role });
+        }
+        break;
+      case "voice.truncate":
+        if (value) {
+          this.emit("truncate", {
+            messageId: value.message_id,
+            content: value.content,
+            originalContent: value.original_content,
+            truncationReason: value.truncation_reason || "barge_in",
+            truncatedAtMs: value.audio_end_ms
+          });
+        }
+        break;
+      case "app.data_update":
+      case "app.navigation":
+      case "app.notification":
+        break;
+      default:
+        if (this.options.debug) {
+          process.stderr.write(`[debug] Unknown CUSTOM event: ${name}
+`);
+        }
+    }
+  }
+  sendCustom(name, value) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    const event = { type: "CUSTOM", name };
+    if (value !== void 0) {
+      event.value = value;
+    }
+    this.emit("ws_send", event);
+    this.ws.send(JSON.stringify(event));
+  }
+  /** Send raw PCM16 audio data (will be base64-encoded) */
+  sendAudio(pcm16) {
+    this.sendCustom("voice.audio", {
+      data: pcm16.toString("base64"),
+      format: "pcm16",
+      sample_rate: 24e3
+    });
+  }
+  /** Signal the start of an audio utterance */
+  sendAudioBegin(messageId) {
+    this.sendCustom("voice.audio_begin", { message_id: messageId });
+  }
+  /** Signal the end of an audio utterance */
+  sendAudioEnd() {
+    this.sendCustom("voice.audio_end");
+  }
+  /** Send a text message (triggers AI inference) */
+  sendTextMessage(content) {
+    this.sendCustom("voice.user_message", {
+      message: { role: "user", content }
+    });
+  }
+  /** Send interrupt signal with playback position */
+  sendInterrupt(audioEndMs, messageId) {
+    this.sendCustom("voice.interrupt", {
+      audio_end_ms: audioEndMs,
+      message_id: messageId
+    });
+  }
+  /** Check if the client is connected */
+  isConnected() {
+    return this.connected && this.ws?.readyState === WebSocket.OPEN;
+  }
+  /** Close the connection */
+  close() {
+    this.connected = false;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+};
+function isToolCall(item) {
+  return "kind" in item && item.kind === "tool_call";
+}
+function isToolResult(item) {
+  return "kind" in item && item.kind === "tool_result";
+}
+function getTruncationLabel(reason, truncatedAtMs) {
+  const timeStr = truncatedAtMs ? ` at ${(truncatedAtMs / 1e3).toFixed(1)}s` : "";
+  switch (reason) {
+    case "barge_in":
+      return `interrupted: user spoke${timeStr}`;
+    case "client_interrupt":
+      return `interrupted${timeStr}`;
+    case "user_cancel":
+      return `cancelled by user${timeStr}`;
+    case "error":
+      return `error${timeStr}`;
+    default:
+      return `interrupted${timeStr}`;
+  }
+}
+function getExtraContent(content, originalContent) {
+  if (!content || !originalContent) return null;
+  const stripped = content.replace(/—interrupted$/, "");
+  if (originalContent.startsWith(stripped)) {
+    const extra = originalContent.slice(stripped.length);
+    return extra.length > 0 ? extra : null;
+  }
+  return originalContent !== content ? originalContent : null;
+}
+var CSI = "\x1B[";
+var HIDE_CURSOR = `${CSI}?25l`;
+var SHOW_CURSOR = `${CSI}?25h`;
+var ALT_SCREEN_ON = `${CSI}?1049h`;
+var ALT_SCREEN_OFF = `${CSI}?1049l`;
+var CLEAR_EOL = `${CSI}K`;
+var RESET = `${CSI}0m`;
+var MOUSE_ON = `${CSI}?1000h${CSI}?1006h`;
+var MOUSE_OFF = `${CSI}?1000l${CSI}?1006l`;
+var BLUE = `${CSI}34m`;
+var GREEN = `${CSI}32m`;
+var GRAY = `${CSI}90m`;
+var YELLOW = `${CSI}33m`;
+var ORANGE = `${CSI}38;5;208m`;
+var LIGHT_BLUE = `${CSI}38;5;117m`;
+var DIM = `${CSI}2m`;
+var DIM_ITALIC_GRAY = `${CSI}2;3;90m`;
+function moveTo(row, col) {
+  return `${CSI}${row};${col}H`;
+}
+var ChatTUI = class {
+  items = [];
+  inputBuffer = "";
+  isStreaming = false;
+  streamContent = "";
+  scrollOffset = 0;
+  expandDetails = false;
+  rows = 24;
+  cols = 80;
+  started = false;
+  renderTimer = null;
+  displayLinesCache = null;
+  debugLinesCache = null;
+  options;
+  // Debug panel state
+  debugEntries = [];
+  debugPanelVisible = false;
+  debugLogStream = null;
+  // Escape sequence accumulator for raw stdin parsing
+  escBuf = "";
+  escTimer = null;
+  constructor(options) {
+    this.options = options;
+    this.debugPanelVisible = !!options.debug;
+  }
+  /** Whether the debug panel is currently being rendered */
+  get debugVisible() {
+    return this.debugPanelVisible;
+  }
+  // ─── Lifecycle ──────────────────────────────────────────────────────
+  start() {
+    this.updateDimensions();
+    process.stdout.write(ALT_SCREEN_ON + MOUSE_ON);
+    process.stdout.write(`${CSI}1;${Math.max(1, this.rows - 2)}r`);
+    process.stdin.setEncoding("utf8");
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.on("data", this.onData);
+    process.stdin.resume();
+    process.stdout.on("resize", this.onResize);
+    process.on("exit", this.restoreTerminal);
+    if (this.options.debug && this.options.env !== "prod") {
+      this.debugLogStream = createWriteStream("gr-cli-realtime-debug.log", { flags: "a" });
+      this.debugLogStream.write(`
+--- session ${(/* @__PURE__ */ new Date()).toISOString()} ---
+`);
+    }
+    this.started = true;
+    this.render();
+  }
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.renderTimer) {
+      clearTimeout(this.renderTimer);
+      this.renderTimer = null;
+    }
+    this.clearEsc();
+    if (this.debugLogStream) {
+      this.debugLogStream.end();
+      this.debugLogStream = null;
+    }
+    this.restoreTerminal();
+    process.stdout.removeListener("resize", this.onResize);
+    process.stdin.removeListener("data", this.onData);
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdin.pause();
+    process.removeListener("exit", this.restoreTerminal);
+  }
+  // ─── Chat state ────────────────────────────────────────────────────
+  loadHistory(items) {
+    this.items = items.filter((item) => isToolCall(item) ? true : item.content?.trim());
+    this.dirty();
+  }
+  streamStart() {
+    this.isStreaming = true;
+    this.streamContent = "";
+    this.scrollOffset = 0;
+    this.dirty();
+  }
+  streamDelta(delta) {
+    this.streamContent += delta;
+    this.dirty();
+  }
+  streamEnd() {
+    if (this.streamContent.trim()) {
+      this.items.push({ role: "assistant", content: this.streamContent });
+    }
+    this.isStreaming = false;
+    this.streamContent = "";
+    this.dirty();
+  }
+  toolCallStart(id, name) {
+    this.items.push({ kind: "tool_call", id, name, args: "", done: false });
+    this.dirty();
+  }
+  toolCallArgs(id, delta) {
+    const tc = this.findToolCall(id);
+    if (tc) {
+      tc.args += delta;
+      this.dirty();
+    }
+  }
+  toolCallEnd(id) {
+    const tc = this.findToolCall(id);
+    if (tc) {
+      tc.done = true;
+      this.dirty();
+    }
+  }
+  /** Add a transcription of the user's spoken words (voice mode) */
+  addTranscription(text) {
+    this.items.push({ role: "user", content: text });
+    this.scrollOffset = 0;
+    this.dirty();
+  }
+  /**
+   * Truncate the most recent assistant message (voice interruption).
+   * Replaces its content with the spoken portion and stores the original.
+   */
+  truncateAssistant(content, originalContent, reason, truncatedAtMs) {
+    if (this.isStreaming) {
+      this.isStreaming = false;
+      this.streamContent = "";
+    }
+    for (let i = this.items.length - 1; i >= 0; i--) {
+      const item = this.items[i];
+      if ("role" in item && item.role === "assistant") {
+        item.content = content;
+        item.truncationReason = reason;
+        item.truncatedAtMs = truncatedAtMs;
+        item.originalContent = originalContent;
+        this.dirty();
+        return;
+      }
+    }
+    this.items.push({
+      role: "assistant",
+      content,
+      truncationReason: reason,
+      truncatedAtMs,
+      originalContent
+    });
+    this.dirty();
+  }
+  toolCallResult(toolCallId, toolName, content) {
+    this.items.push({ kind: "tool_result", toolCallId, toolName, content });
+    this.dirty();
+  }
+  /** Find the tool name for a given tool call ID */
+  findToolCallName(toolCallId) {
+    for (let i = this.items.length - 1; i >= 0; i--) {
+      const item = this.items[i];
+      if (isToolCall(item) && item.id === toolCallId) return item.name;
+    }
+    return "tool";
+  }
+  showError(msg) {
+    this.items.push({ role: "system", content: `Error: ${msg}` });
+    this.dirty();
+  }
+  // ─── Debug panel ──────────────────────────────────────────────────
+  /** Log a WebSocket message to the debug panel and (optionally) log file */
+  logDebug(direction, raw) {
+    const redacted = redactAudio(raw);
+    const now = /* @__PURE__ */ new Date();
+    const ts = `${pad2(now.getHours())}:${pad2(now.getMinutes())}:${pad2(now.getSeconds())}`;
+    if (this.debugLogStream) {
+      const logLine = JSON.stringify({ ts: now.toISOString(), dir: direction, ...redacted });
+      this.debugLogStream.write(logLine + "\n");
+    }
+    const summary = buildDebugSummary(direction, redacted);
+    let detail;
+    try {
+      detail = JSON.stringify(redacted, null, 2);
+    } catch {
+      detail = String(redacted);
+    }
+    this.debugEntries.push({ direction, summary, detail, ts });
+    if (this.debugEntries.length > 500) {
+      this.debugEntries = this.debugEntries.slice(-300);
+    }
+    this.debugLinesCache = null;
+    this.dirty();
+  }
+  // ─── Private helpers ──────────────────────────────────────────────
+  findToolCall(id) {
+    for (let i = this.items.length - 1; i >= 0; i--) {
+      const item = this.items[i];
+      if (isToolCall(item) && item.id === id) return item;
+    }
+    return void 0;
+  }
+  dirty() {
+    this.displayLinesCache = null;
+    this.debugLinesCache = null;
+    this.scheduleRender();
+  }
+  restoreTerminal = () => {
+    process.stdout.write(`${MOUSE_OFF}${CSI}r${ALT_SCREEN_OFF}${SHOW_CURSOR}`);
+  };
+  updateDimensions() {
+    this.rows = process.stdout.rows || 24;
+    this.cols = process.stdout.columns || 80;
+  }
+  /** Width of the chat (left) panel */
+  chatWidth() {
+    if (!this.debugVisible) return this.cols;
+    return Math.max(30, Math.floor(this.cols * 0.6) - 1);
+  }
+  /** Width of the debug (right) panel */
+  debugWidth() {
+    if (!this.debugVisible) return 0;
+    return this.cols - this.chatWidth() - 1;
+  }
+  scrollHeight() {
+    return Math.max(1, this.rows - 2);
+  }
+  pageSize() {
+    return Math.max(1, this.rows - 4);
+  }
+  // ─── Scroll ───────────────────────────────────────────────────────
+  scrollUp(lines) {
+    const total = this.getDisplayLines().length;
+    const max = Math.max(0, total - this.scrollHeight());
+    this.scrollOffset = Math.min(max, this.scrollOffset + lines);
+    this.render();
+  }
+  scrollDown(lines) {
+    this.scrollOffset = Math.max(0, this.scrollOffset - lines);
+    this.render();
+  }
+  scrollToTop() {
+    const total = this.getDisplayLines().length;
+    this.scrollOffset = Math.max(0, total - this.scrollHeight());
+    this.render();
+  }
+  scrollToBottom() {
+    this.scrollOffset = 0;
+    this.render();
+  }
+  // ─── Raw stdin parsing ────────────────────────────────────────────
+  //
+  // We parse stdin directly instead of using readline.emitKeypressEvents
+  // because readline doesn't understand SGR mouse sequences and leaks
+  // their contents into keypress events as regular characters.
+  onData = (data) => {
+    for (let i = 0; i < data.length; i++) {
+      const ch = data[i];
+      if (this.escBuf) {
+        this.escBuf += ch;
+        if (this.escBuf.length === 2) {
+          if (ch !== "[") {
+            this.clearEsc();
+          }
+          continue;
+        }
+        if (/[A-Za-z~]/.test(ch)) {
+          this.handleCSI(this.escBuf.slice(2, -1), ch);
+          this.clearEsc();
+        } else if (this.escBuf.length > 32) {
+          this.clearEsc();
+        }
+        continue;
+      }
+      if (ch === "\x1B") {
+        this.escBuf = "\x1B";
+        this.escTimer = setTimeout(() => {
+          this.escBuf = "";
+          this.escTimer = null;
+        }, 100);
+        continue;
+      }
+      this.handleByte(ch);
+    }
+  };
+  clearEsc() {
+    this.escBuf = "";
+    if (this.escTimer) {
+      clearTimeout(this.escTimer);
+      this.escTimer = null;
+    }
+  }
+  /** Handle a parsed CSI sequence: params is everything between \x1B[ and the final char */
+  handleCSI(params, code) {
+    if (params.startsWith("<") && (code === "M" || code === "m")) {
+      if (code === "m") return;
+      const parts = params.slice(1).split(";");
+      if (parts.length >= 1) {
+        const button = parseInt(parts[0], 10);
+        if (button === 64) this.scrollUp(3);
+        else if (button === 65) this.scrollDown(3);
+      }
+      return;
+    }
+    if (!params) {
+      if (code === "A") {
+        this.scrollUp(1);
+        return;
+      }
+      if (code === "B") {
+        this.scrollDown(1);
+        return;
+      }
+      if (code === "H") {
+        this.scrollToTop();
+        return;
+      }
+      if (code === "F") {
+        this.scrollToBottom();
+        return;
+      }
+    }
+    if (code === "~") {
+      if (params === "5") {
+        this.scrollUp(this.pageSize());
+        return;
+      }
+      if (params === "6") {
+        this.scrollDown(this.pageSize());
+        return;
+      }
+      if (params === "1") {
+        this.scrollToTop();
+        return;
+      }
+      if (params === "4") {
+        this.scrollToBottom();
+        return;
+      }
+    }
+  }
+  /** Handle a single non-escape byte */
+  handleByte(ch) {
+    const code = ch.charCodeAt(0);
+    if (code === 3) {
+      this.stop();
+      this.options.onExit();
+      return;
+    }
+    if (code === 2) {
+      this.scrollUp(this.pageSize());
+      return;
+    }
+    if (code === 6) {
+      this.scrollDown(this.pageSize());
+      return;
+    }
+    if (code === 4) {
+      this.debugPanelVisible = !this.debugPanelVisible;
+      this.displayLinesCache = null;
+      this.debugLinesCache = null;
+      this.render();
+      return;
+    }
+    if (code === 15) {
+      this.expandDetails = !this.expandDetails;
+      this.displayLinesCache = null;
+      this.debugLinesCache = null;
+      this.render();
+      return;
+    }
+    if (code === 13) {
+      this.handleEnter();
+      return;
+    }
+    if (code === 127 || code === 8) {
+      if (this.inputBuffer.length > 0) {
+        this.inputBuffer = this.inputBuffer.slice(0, -1);
+        this.renderInputLine();
+      }
+      return;
+    }
+    if (code < 32) return;
+    this.inputBuffer += ch;
+    this.renderInputLine();
+  }
+  handleEnter() {
+    const text = this.inputBuffer.trim();
+    this.inputBuffer = "";
+    if (!text) {
+      this.renderInputLine();
+      return;
+    }
+    if (text.toLowerCase() === "exit" || text.toLowerCase() === "quit") {
+      this.stop();
+      this.options.onExit();
+      return;
+    }
+    this.items.push({ role: "user", content: text });
+    this.scrollOffset = 0;
+    this.displayLinesCache = null;
+    this.render();
+    this.options.onSend(text);
+  }
+  // ─── Events ───────────────────────────────────────────────────────
+  onResize = () => {
+    this.updateDimensions();
+    process.stdout.write(`${CSI}1;${Math.max(1, this.rows - 2)}r`);
+    this.displayLinesCache = null;
+    this.debugLinesCache = null;
+    this.render();
+  };
+  // ─── Rendering ────────────────────────────────────────────────────
+  scheduleRender() {
+    if (!this.started || this.renderTimer) return;
+    this.renderTimer = setTimeout(() => {
+      this.renderTimer = null;
+      this.render();
+    }, 30);
+  }
+  getDisplayLines() {
+    if (!this.displayLinesCache) {
+      this.displayLinesCache = this.buildDisplayLines();
+    }
+    return this.displayLinesCache;
+  }
+  getDebugLines() {
+    if (!this.debugLinesCache) {
+      this.debugLinesCache = this.buildDebugLines();
+    }
+    return this.debugLinesCache;
+  }
+  render() {
+    if (!this.started) return;
+    this.updateDimensions();
+    const sh = this.scrollHeight();
+    const displayLines = this.getDisplayLines();
+    const total = displayLines.length;
+    const maxOff = Math.max(0, total - sh);
+    if (this.scrollOffset > maxOff) this.scrollOffset = maxOff;
+    let visible;
+    if (total <= sh) {
+      visible = [...new Array(sh - total).fill(""), ...displayLines];
+    } else {
+      const end = total - this.scrollOffset;
+      const start = end - sh;
+      visible = displayLines.slice(start, end);
+    }
+    const buf = [HIDE_CURSOR];
+    if (this.debugVisible) {
+      this.renderSplitScreen(buf, visible, sh);
+    } else {
+      for (let i = 0; i < sh; i++) {
+        buf.push(moveTo(i + 1, 1), visible[i] || "", CLEAR_EOL);
+      }
+    }
+    buf.push(moveTo(this.rows - 1, 1), this.buildSeparator(), CLEAR_EOL);
+    buf.push(moveTo(this.rows, 1), `${BLUE}You:${RESET} ${this.inputBuffer}${CLEAR_EOL}`);
+    buf.push(SHOW_CURSOR);
+    process.stdout.write(buf.join(""));
+  }
+  renderSplitScreen(buf, chatVisible, sh) {
+    const cw = this.chatWidth();
+    const dw = this.debugWidth();
+    const divCol = cw + 1;
+    const debugLines = this.getDebugLines();
+    const debugTotal = debugLines.length;
+    let debugVisible;
+    if (debugTotal <= sh) {
+      debugVisible = [...new Array(sh - debugTotal).fill(""), ...debugLines];
+    } else {
+      debugVisible = debugLines.slice(debugTotal - sh);
+    }
+    for (let i = 0; i < sh; i++) {
+      const chatLine = truncateAnsi(chatVisible[i] || "", cw);
+      const debugLine = truncateAnsi(debugVisible[i] || "", dw);
+      buf.push(
+        moveTo(i + 1, 1),
+        chatLine,
+        CLEAR_EOL,
+        // clear to end handles rest, but we need to position divider
+        moveTo(i + 1, divCol),
+        `${DIM}\u2502${RESET}`,
+        debugLine
+      );
+      buf.push(CLEAR_EOL);
+    }
+  }
+  renderInputLine() {
+    process.stdout.write(
+      `${moveTo(this.rows, 1)}${BLUE}You:${RESET} ${this.inputBuffer}${CLEAR_EOL}`
+    );
+  }
+  // ─── Separator ────────────────────────────────────────────────────
+  buildSeparator() {
+    const hints = [];
+    if (this.scrollOffset > 0) {
+      hints.push(`\u2191${this.scrollOffset}`);
+    }
+    const hasDetails = this.items.some((i) => isToolCall(i) || isToolResult(i)) || this.options.debug;
+    if (hasDetails) {
+      hints.push(`^O ${this.expandDetails ? "collapse" : "details"}`);
+    }
+    if (this.options.debug) {
+      hints.push(`^D ${this.debugPanelVisible ? "hide" : "show"} debug`);
+    }
+    const lineWidth = Math.min(this.cols, 60);
+    if (!hints.length) {
+      return `${GRAY}${"\u2500".repeat(lineWidth)}${RESET}`;
+    }
+    const hintStr = ` ${hints.join("  ")} `;
+    const dashes = Math.max(0, lineWidth - hintStr.length);
+    const left = Math.max(2, Math.floor(dashes / 2));
+    const right = Math.max(2, dashes - left);
+    return `${GRAY}${"\u2500".repeat(left)}${hintStr}${"\u2500".repeat(right)}${RESET}`;
+  }
+  // ─── Chat display line building ───────────────────────────────────
+  buildDisplayLines() {
+    const lines = [];
+    const w = this.chatWidth();
+    for (const item of this.items) {
+      if (isToolCall(item)) {
+        this.appendToolCallLines(lines, item, w);
+      } else if (isToolResult(item)) {
+        this.appendToolResultLines(lines, item, w);
+      } else {
+        this.appendMessageLines(lines, item, w);
+      }
+      lines.push("");
+    }
+    if (this.isStreaming) {
+      this.appendStreamLines(lines, w);
+    }
+    return lines;
+  }
+  appendToolCallLines(lines, tc, width) {
+    const status = tc.done ? "Called" : "Calling";
+    const summary = `  ${GRAY}${status} ${tc.name}${tc.done ? "" : "..."}${RESET}`;
+    if (!this.expandDetails) {
+      lines.push(summary);
+      return;
+    }
+    lines.push(summary);
+    if (tc.args) {
+      let formatted = tc.args;
+      try {
+        formatted = JSON.stringify(JSON.parse(tc.args), null, 2);
+      } catch {
+      }
+      const indent = "    ";
+      for (const argLine of formatted.split("\n")) {
+        for (const wl of this.wrapText(argLine, width - indent.length)) {
+          lines.push(`${indent}${GRAY}${wl}${RESET}`);
+        }
+      }
+    }
+  }
+  appendToolResultLines(lines, tr, width) {
+    if (!this.expandDetails) {
+      const maxLen = width - 10;
+      const preview = tr.content.replace(/\n/g, " ").slice(0, maxLen);
+      const truncated = preview.length < tr.content.length ? "..." : "";
+      lines.push(`    ${GRAY}\u2192 ${tr.toolName}: ${preview}${truncated}${RESET}`);
+      return;
+    }
+    lines.push(`    ${GRAY}\u2192 ${tr.toolName} result:${RESET}`);
+    let formatted = tr.content;
+    try {
+      formatted = JSON.stringify(JSON.parse(tr.content), null, 2);
+    } catch {
+    }
+    const indent = "      ";
+    for (const resultLine of formatted.split("\n")) {
+      for (const wl of this.wrapText(resultLine, width - indent.length)) {
+        lines.push(`${indent}${GRAY}${wl}${RESET}`);
+      }
+    }
+  }
+  appendMessageLines(lines, msg, width) {
+    if (msg.role === "system") {
+      for (const para of msg.content.split("\n")) {
+        for (const wl of this.wrapText(para, width - 2)) {
+          lines.push(`  ${GRAY}${wl}${RESET}`);
+        }
+      }
+      return;
+    }
+    const isUser = msg.role === "user";
+    const label = isUser ? `${BLUE}You:${RESET} ` : `${GREEN}Assistant:${RESET} `;
+    const labelWidth = isUser ? 5 : 12;
+    const indent = " ".repeat(labelWidth);
+    let first = true;
+    const displayContent = msg.truncationReason ? msg.content.replace(/—interrupted$/, "") : msg.content;
+    for (const para of displayContent.split("\n")) {
+      for (const wl of this.wrapText(para, width - labelWidth)) {
+        lines.push(first ? label + wl : indent + wl);
+        first = false;
+      }
+    }
+    if (msg.truncationReason) {
+      const reasonLabel = getTruncationLabel(msg.truncationReason, msg.truncatedAtMs);
+      lines.push(`${indent}${YELLOW}[${reasonLabel}]${RESET}`);
+      const extra = getExtraContent(msg.content, msg.originalContent);
+      if (extra) {
+        for (const para of extra.split("\n")) {
+          for (const wl of this.wrapText(para, width - labelWidth)) {
+            lines.push(`${indent}${DIM_ITALIC_GRAY}${wl}${RESET}`);
+          }
+        }
+      }
+    }
+  }
+  appendStreamLines(lines, width) {
+    const label = `${GREEN}Assistant:${RESET} `;
+    const labelWidth = 12;
+    const indent = " ".repeat(labelWidth);
+    if (!this.streamContent) {
+      lines.push(label);
+      return;
+    }
+    let first = true;
+    for (const para of this.streamContent.split("\n")) {
+      for (const wl of this.wrapText(para, width - labelWidth)) {
+        lines.push(first ? label + wl : indent + wl);
+        first = false;
+      }
+    }
+  }
+  // ─── Debug display line building ──────────────────────────────────
+  buildDebugLines() {
+    const lines = [];
+    const dw = this.debugWidth();
+    if (dw <= 0) return lines;
+    for (const entry of this.debugEntries) {
+      const color = entry.direction === "in" ? ORANGE : LIGHT_BLUE;
+      const arrow = entry.direction === "in" ? "\u25BC" : "\u25B2";
+      const prefix = `${DIM}${entry.ts}${RESET} ${color}${arrow}${RESET} `;
+      const prefixWidth = entry.ts.length + 3;
+      if (!this.expandDetails) {
+        const maxSummary = dw - prefixWidth;
+        const summaryText = entry.summary.slice(0, maxSummary);
+        lines.push(`${prefix}${color}${summaryText}${RESET}`);
+      } else {
+        lines.push(`${prefix}${color}${entry.summary}${RESET}`);
+        const indent = " ".repeat(prefixWidth);
+        for (const detailLine of entry.detail.split("\n")) {
+          for (const wl of this.wrapText(detailLine, dw - prefixWidth)) {
+            lines.push(`${indent}${color}${DIM}${wl}${RESET}`);
+          }
+        }
+        lines.push("");
+      }
+    }
+    return lines;
+  }
+  // ─── Text utilities ───────────────────────────────────────────────
+  wrapText(text, maxWidth) {
+    if (maxWidth <= 0) maxWidth = 1;
+    if (!text) return [""];
+    if (text.length <= maxWidth) return [text];
+    const words = text.split(" ");
+    const result = [];
+    let current = "";
+    for (const word of words) {
+      if (!current) {
+        current = word;
+      } else if (current.length + 1 + word.length <= maxWidth) {
+        current += " " + word;
+      } else {
+        result.push(current);
+        current = word;
+      }
+    }
+    if (current) result.push(current);
+    return result.length ? result : [""];
+  }
+};
+function pad2(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function truncateAnsi(s, maxCols) {
+  if (maxCols <= 0) return "";
+  let visible = 0;
+  let i = 0;
+  while (i < s.length && visible < maxCols) {
+    if (s[i] === "\x1B") {
+      const end = s.indexOf("m", i);
+      if (end !== -1) {
+        i = end + 1;
+      } else {
+        i++;
+      }
+    } else {
+      visible++;
+      i++;
+    }
+  }
+  return s.slice(0, i) + RESET;
+}
+function redactAudio(msg) {
+  if (!msg || typeof msg !== "object") return msg;
+  const clone = { ...msg };
+  if (clone.type === "CUSTOM" && clone.value && typeof clone.value === "object") {
+    const name = clone.name || "";
+    if (name === "voice.audio" && clone.value.data) {
+      clone.value = { ...clone.value, data: "[audio]" };
+    }
+  }
+  return clone;
+}
+function buildDebugSummary(_direction, msg) {
+  if (!msg || typeof msg !== "object") return String(msg);
+  if (msg.type === "CUSTOM") {
+    const name = msg.name || "?";
+    if (name === "voice.audio") return name;
+    if (msg.value && typeof msg.value === "object") {
+      const keys = Object.keys(msg.value);
+      if (keys.length <= 3) {
+        return `${name} {${keys.join(", ")}}`;
+      }
+      return `${name} {${keys.length} keys}`;
+    }
+    return name;
+  }
+  const type = msg.type || "?";
+  if (msg.delta) {
+    const preview = msg.delta.length > 30 ? msg.delta.slice(0, 30) + "..." : msg.delta;
+    return `${type} "${preview}"`;
+  }
+  if (msg.toolCallName) {
+    return `${type} ${msg.toolCallName}`;
+  }
+  return type;
+}
+var SAMPLE_RATE = 24e3;
+var MIC_CHUNK_BYTES = 4800;
+function checkSoxAvailable() {
+  try {
+    execSync("which sox", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listInputDevices() {
+  return listDevices("rec");
+}
+async function listOutputDevices() {
+  return listDevices("play");
+}
+function listDevices(command) {
+  return new Promise((resolve) => {
+    try {
+      const proc = spawnSync(command, ["--list-devices"], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 5e3
+      });
+      const output = (proc.stdout ?? "") + (proc.stderr ?? "");
+      const devices = [];
+      const lines = output.split("\n");
+      for (const line of lines) {
+        const match = line.match(/(?:Input|Output)\s+Device\s+(\d+)\s*:\s*(.+)/i);
+        if (match && match[1] && match[2]) {
+          devices.push({
+            id: match[1],
+            name: match[2].trim(),
+            isDefault: devices.length === 0
+            // First device is typically the default
+          });
+        }
+      }
+      if (devices.length === 0) {
+        devices.push({ id: "default", name: "System Default", isDefault: true });
+      }
+      resolve(devices);
+    } catch {
+      resolve([{ id: "default", name: "System Default", isDefault: true }]);
+    }
+  });
+}
+async function selectDevice(devices, label) {
+  if (devices.length <= 1) {
+    return devices[0];
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+    terminal: true
+  });
+  process.stderr.write(`
+  ${label}:
+`);
+  for (let i = 0; i < devices.length; i++) {
+    const dev = devices[i];
+    const marker = dev.isDefault ? " (default)" : "";
+    process.stderr.write(`    ${i + 1}. ${dev.name}${marker}
+`);
+  }
+  return new Promise((resolve) => {
+    const defaultIdx = devices.findIndex((d) => d.isDefault);
+    const defaultNum = defaultIdx >= 0 ? defaultIdx + 1 : 1;
+    rl.question(`  Select [${defaultNum}]: `, (answer) => {
+      rl.close();
+      const num = answer.trim() ? parseInt(answer.trim(), 10) : defaultNum;
+      const idx = Math.max(0, Math.min(devices.length - 1, num - 1));
+      resolve(devices[idx]);
+    });
+  });
+}
+var MicCapture = class {
+  process = null;
+  onData;
+  buffer = Buffer.alloc(0);
+  constructor(onData) {
+    this.onData = onData;
+  }
+  /** Start recording from the microphone */
+  start(deviceId) {
+    const args = [
+      "-q",
+      // quiet
+      "-t",
+      "raw",
+      // raw PCM output
+      "-r",
+      String(SAMPLE_RATE),
+      "-e",
+      "signed-integer",
+      "-b",
+      "16",
+      // 16-bit
+      "-c",
+      "1",
+      // mono
+      "-L",
+      // little-endian
+      "-"
+      // stdout
+    ];
+    const env = { ...process.env };
+    if (deviceId && deviceId !== "default") {
+      env.AUDIODEV = deviceId;
+    }
+    this.process = spawn("rec", args, {
+      env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.process.stdout?.on("data", (data) => {
+      this.buffer = Buffer.concat([this.buffer, data]);
+      while (this.buffer.length >= MIC_CHUNK_BYTES) {
+        const chunk = this.buffer.subarray(0, MIC_CHUNK_BYTES);
+        this.buffer = this.buffer.subarray(MIC_CHUNK_BYTES);
+        this.onData(Buffer.from(chunk));
+      }
+    });
+    this.process.stderr?.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg && !msg.includes("WARN")) {
+        process.stderr.write(`[mic] ${msg}
+`);
+      }
+    });
+    this.process.on("error", (err) => {
+      process.stderr.write(`[mic] Process error: ${err.message}
+`);
+    });
+  }
+  /** Stop recording */
+  stop() {
+    if (this.process) {
+      this.process.kill("SIGTERM");
+      this.process = null;
+    }
+    this.buffer = Buffer.alloc(0);
+  }
+};
+var AudioPlayer = class extends EventEmitter {
+  process = null;
+  deviceId;
+  // When true, we own the SoX process's stdin and are actively streaming to it.
+  // When false with a process, the stdin has been closed and SoX is draining.
+  streaming = false;
+  // Buffer chunks when another response is already playing
+  pendingChunks = [];
+  pendingBytes = 0;
+  // Queue of complete response buffers waiting to play
+  queue = [];
+  // Playback position tracking for barge-in
+  currentMessageId;
+  playbackStartTime = 0;
+  // Date.now() when SoX started
+  bytesWritten = 0;
+  // total bytes piped to SoX for duration estimation
+  constructor(deviceId) {
+    super();
+    this.deviceId = deviceId;
+  }
+  /** Check if audio is currently playing or queued */
+  get isPlaying() {
+    return this.process !== null || this.queue.length > 0;
+  }
+  /** Get the message ID of the currently playing audio */
+  get playingMessageId() {
+    return this.currentMessageId;
+  }
+  /** Duration of audio written so far in ms */
+  get currentDurationMs() {
+    return this.bytesWritten / (SAMPLE_RATE * 2) * 1e3;
+  }
+  /**
+   * Estimate current playback position in milliseconds.
+   * Uses wall-clock time since SoX started playing.
+   */
+  getPlaybackTimeMs() {
+    if (!this.process || this.playbackStartTime === 0) return null;
+    const elapsed = Date.now() - this.playbackStartTime;
+    return Math.min(elapsed, this.currentDurationMs);
+  }
+  /**
+   * Stream PCM16 audio data for playback.
+   * On the first chunk, spawns SoX and begins playback immediately.
+   */
+  write(pcm16) {
+    if (this.process && !this.streaming) {
+      this.pendingChunks.push(pcm16);
+      this.pendingBytes += pcm16.length;
+      return;
+    }
+    if (!this.process) {
+      this.spawnSoxProcess();
+    }
+    this.process.stdin.write(pcm16);
+    this.bytesWritten += pcm16.length;
+  }
+  /**
+   * End the current audio response.
+   * If streaming, closes stdin to let SoX finish playing.
+   * If buffering behind another response, adds to the queue.
+   */
+  endResponse(messageId) {
+    if (this.streaming && this.process) {
+      this.currentMessageId = messageId;
+      this.streaming = false;
+      this.process.stdin.end();
+    } else if (this.pendingChunks.length > 0) {
+      const audio = Buffer.concat(this.pendingChunks);
+      this.pendingChunks = [];
+      this.pendingBytes = 0;
+      this.queue.push({ audio, messageId });
+    }
+  }
+  /** Stop current playback, discard all queued audio */
+  stop() {
+    this.pendingChunks = [];
+    this.pendingBytes = 0;
+    this.queue = [];
+    this.streaming = false;
+    const wasPlaying = this.process !== null;
+    if (this.process) {
+      try {
+        this.process.stdin?.destroy();
+        this.process.kill("SIGTERM");
+      } catch {
+      }
+      this.process = null;
+    }
+    this.currentMessageId = void 0;
+    this.playbackStartTime = 0;
+    this.bytesWritten = 0;
+    if (wasPlaying) {
+      this.emit("done");
+    }
+  }
+  /** Spawn a SoX `play` process reading raw PCM from stdin */
+  spawnSoxProcess() {
+    this.bytesWritten = 0;
+    this.currentMessageId = void 0;
+    const args = [
+      "-q",
+      // quiet
+      "-t",
+      "raw",
+      "-r",
+      String(SAMPLE_RATE),
+      "-e",
+      "signed-integer",
+      "-b",
+      "16",
+      "-c",
+      "1",
+      "-L",
+      // little-endian
+      "-"
+      // read from stdin
+    ];
+    const env = { ...process.env };
+    if (this.deviceId && this.deviceId !== "default") {
+      env.AUDIODEV = this.deviceId;
+    }
+    const proc = spawn("play", args, {
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    proc.on("error", (err) => {
+      process.stderr.write(`[player] Process error: ${err.message}
+`);
+    });
+    proc.on("exit", (code, _signal) => {
+      if (code !== null && code !== 0 && code !== 143) {
+        process.stderr.write(`[player] SoX exited with code ${code}
+`);
+      }
+      if (this.process === proc) {
+        this.process = null;
+        this.streaming = false;
+        if (this.queue.length > 0) {
+          const next = this.queue.shift();
+          this.playQueued(next.audio, next.messageId);
+        } else {
+          this.emit("done");
+        }
+      }
+    });
+    proc.stderr?.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg) {
+        process.stderr.write(`[player:sox] ${msg}
+`);
+      }
+    });
+    proc.stdout?.resume();
+    this.process = proc;
+    this.streaming = true;
+    this.playbackStartTime = Date.now();
+    this.emit("playing");
+  }
+  /** Play a complete pre-buffered response (from the queue) */
+  playQueued(audio, messageId) {
+    this.spawnSoxProcess();
+    this.currentMessageId = messageId;
+    this.process.stdin.write(audio);
+    this.bytesWritten = audio.length;
+    this.process.stdin.end();
+    this.streaming = false;
+  }
+};
+
+// src/lib/chat-session.ts
+async function runChatSession(session, args) {
+  const debug = !!args.debug;
+  const isVoice = !!args.voice;
+  const isRealtime = !!args.realtime || isVoice;
+  const message = typeof args.message === "string" ? args.message : void 0;
+  const autoApprove = !!args["auto-approve"];
+  if (args["list-devices"]) {
+    await listAudioDevices();
+    return;
+  }
+  if (!message && !process.stdin.isTTY) {
+    throw new CLIError(
+      "Interactive mode requires a TTY. Use --message for non-interactive mode."
+    );
+  }
+  const allowWrite = !!args["allow-write"] || !!session.allowWrite;
+  if (message) {
+    await singleTurnChatSession(session, message, debug, autoApprove, allowWrite);
+  } else if (isVoice) {
+    await voiceChatSession(session, vadMode(args), args, debug);
+  } else if (isRealtime) {
+    await realtimeChatSession(session, vadMode(args), debug);
+  } else {
+    await interactiveChatSession(session, debug, autoApprove, allowWrite);
+  }
+}
+function vadMode(args) {
+  return typeof args.vad === "string" ? args.vad : "server";
+}
+async function singleTurnChatSession(session, message, debug, autoApprove = false, allowWrite = false) {
+  const aguiClient = new AGUIClient({
+    baseUrl: session.ctx.envConfig.apiUrl,
+    workspaceUuid: session.workspaceUuid,
+    chatId: session.chatId,
+    endpointUrl: session.aguiEndpointUrl,
+    accessToken: session.ctx.accessToken,
+    debug,
+    model: session.model,
+    appContext: session.appContext
+  });
+  const onEvent = (event) => {
+    const type = event.type?.toLowerCase() ?? "";
+    if (type === "tool_call_start") {
+      const name = event.toolCallName ?? event.name ?? "";
+      process.stderr.write(`  [${name}]
+`);
+    }
+  };
+  const { streamText, hasToolCalls } = await runConciergeAguiLoop(
+    aguiClient,
+    [{ role: "user", content: message }],
+    onEvent,
+    {
+      autoApprove,
+      allowWrite: allowWrite || !!session.allowWrite,
+      trustCwd: session.trustCwd,
+      trustDir: session.trustDir,
+      nonInteractive: true
+    }
+  );
+  if (streamText) {
+    process.stdout.write(`\x1B[32mAssistant:\x1B[0m ${streamText}
+`);
+    return;
+  }
+  if (hasToolCalls) {
+    process.stderr.write("  (waiting for completion...)\n");
+    const maxWaitMs = 18e4;
+    const pollIntervalMs = 2e3;
+    const startTime = Date.now();
+    let finalText = "";
+    while (Date.now() - startTime < maxWaitMs) {
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+      try {
+        const msgs = await session.loadMessages();
+        for (let i = msgs.length - 1; i >= 0; i--) {
+          const m = msgs[i];
+          if (m.role === "assistant" && m.content && !m.tool_calls?.length) {
+            finalText = m.content;
+            break;
+          }
+        }
+        if (finalText) break;
+      } catch {
+      }
+    }
+    process.stdout.write(`\x1B[32mAssistant:\x1B[0m ${finalText || "(no text response)"}
+`);
+  } else {
+    process.stdout.write(`\x1B[32mAssistant:\x1B[0m (no response)
+`);
+  }
+}
+async function interactiveChatSession(session, debug, autoApprove, allowWrite) {
+  const aguiClient = new AGUIClient({
+    baseUrl: session.ctx.envConfig.apiUrl,
+    workspaceUuid: session.workspaceUuid,
+    chatId: session.chatId,
+    endpointUrl: session.aguiEndpointUrl,
+    accessToken: session.ctx.accessToken,
+    debug,
+    model: session.model,
+    appContext: session.appContext
+  });
+  clearScreen();
+  console.log("=".repeat(60));
+  console.log(session.label);
+  console.log("=".repeat(60));
+  console.log(`Chat: ${session.chatTitle}`);
+  console.log("Type your message and press Enter. Type 'exit' or Ctrl+C to quit.");
+  console.log("=".repeat(60));
+  console.log("");
+  const existingMessages = await session.loadMessages();
+  if (existingMessages.length > 0) {
+    console.log("\x1B[90m--- Previous messages ---\x1B[0m\n");
+    for (const msg of existingMessages.slice(-10)) {
+      const text = typeof msg.content === "string" ? msg.content : "";
+      if (text && text.trim()) {
+        printMessage(text, msg.role);
+      }
+    }
+    console.log("\x1B[90m--- End of history ---\x1B[0m\n");
+  }
+  const conversationMessages = [];
+  for (const msg of existingMessages.slice(-10)) {
+    const text = typeof msg.content === "string" ? msg.content : "";
+    if (text && text.trim() && (msg.role === "user" || msg.role === "assistant")) {
+      conversationMessages.push({ role: msg.role, content: text });
+    }
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    const prompt = () => {
+      rl.question("\x1B[34mYou:\x1B[0m ", async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+          prompt();
+          return;
+        }
+        if (trimmed.toLowerCase() === "exit" || trimmed.toLowerCase() === "quit") {
+          console.log("\nGoodbye!");
+          rl.close();
+          return;
+        }
+        conversationMessages.push({ role: "user", content: trimmed });
+        process.stdout.write("\n\x1B[32mAssistant:\x1B[0m ");
+        let assistantContent = "";
+        try {
+          const { streamText } = await runConciergeAguiLoop(
+            aguiClient,
+            conversationMessages,
+            (event) => {
+              const delta = getTextDelta(event);
+              if (delta) {
+                process.stdout.write(delta);
+                assistantContent += delta;
+              }
+              const errorMsg = getErrorMessage(event);
+              if (errorMsg) console.log(`
+\x1B[31mError: ${errorMsg}\x1B[0m`);
+            },
+            {
+              autoApprove,
+              allowWrite: allowWrite || !!session.allowWrite,
+              debug,
+              trustCwd: session.trustCwd,
+              trustDir: session.trustDir
+            }
+          );
+          if (streamText && !assistantContent) {
+            assistantContent = streamText;
+            process.stdout.write(streamText);
+          }
+          if (assistantContent) {
+            conversationMessages.push({ role: "assistant", content: assistantContent });
+          }
+          console.log("\n");
+        } catch (error) {
+          console.log(
+            `
+\x1B[31mError: ${error instanceof Error ? error.message : error}\x1B[0m
+`
+          );
+        }
+        prompt();
+      });
+    };
+    rl.on("close", () => {
+      console.log("\nGoodbye!");
+      resolve();
+    });
+    prompt();
+  });
+}
+function buildHistory(messages) {
+  const history = [];
+  for (const msg of messages.slice(-30)) {
+    const text = typeof msg.content === "string" ? msg.content : "";
+    if (msg.role === "user" || msg.role === "assistant") {
+      if (text.trim()) {
+        history.push({ role: msg.role, content: text });
+      }
+      if (msg.role === "assistant" && msg.tool_calls) {
+        for (const tc of msg.tool_calls) {
+          history.push({
+            kind: "tool_call",
+            id: tc.id,
+            name: tc.function.name,
+            args: tc.function.arguments || "",
+            done: true
+          });
+        }
+      }
+    } else if (msg.role === "tool") {
+      const toolName = msg.name || "tool";
+      history.push({
+        kind: "tool_result",
+        toolCallId: msg.tool_call_id || "",
+        toolName,
+        content: text
+      });
+    }
+  }
+  return history;
+}
+function wireRealtimeEvents(client, tui) {
+  client.on("text_start", () => tui.streamStart());
+  client.on("text_delta", (data) => tui.streamDelta(data.delta));
+  client.on("text_end", () => tui.streamEnd());
+  client.on("tool_call_start", (data) => {
+    tui.toolCallStart(data.toolCallId, data.toolCallName);
+  });
+  client.on("tool_call_args", (data) => {
+    tui.toolCallArgs(data.toolCallId, data.delta);
+  });
+  client.on("tool_call_end", (data) => {
+    tui.toolCallEnd(data.toolCallId);
+  });
+  client.on("tool_call_result", (data) => {
+    const toolName = tui.findToolCallName(data.toolCallId);
+    const content = typeof data.result === "string" ? data.result : JSON.stringify(data.result);
+    tui.toolCallResult(data.toolCallId, toolName, content);
+  });
+  client.on("run_error", (data) => {
+    tui.showError(data.message);
+  });
+  client.on("error", (err) => {
+    tui.showError(`Connection: ${err.message}`);
+  });
+  client.on("ws_recv", (msg) => tui.logDebug("in", msg));
+  client.on("ws_send", (msg) => tui.logDebug("out", msg));
+}
+async function realtimeChatSession(session, vad, debug) {
+  const client = new RealtimeClient({
+    url: session.wsUrl,
+    token: session.ctx.accessToken,
+    chatId: session.chatId,
+    vadMode: vad,
+    debug
+  });
+  process.stderr.write(`Connecting to ${session.label.toLowerCase()}...
+`);
+  try {
+    await client.connect();
+  } catch (err) {
+    throw new CLIError(`Failed to connect: ${err instanceof Error ? err.message : err}`);
+  }
+  const existingMessages = await session.loadMessages();
+  const history = buildHistory(existingMessages);
+  const tui = new ChatTUI({
+    onSend: (text) => {
+      client.sendTextMessage(text);
+    },
+    onExit: () => {
+      client.close();
+    },
+    debug,
+    env: session.ctx.env
+  });
+  wireRealtimeEvents(client, tui);
+  client.on("closed", () => {
+    tui.stop();
+    console.log("Disconnected.");
+  });
+  tui.loadHistory(history);
+  tui.start();
+  await new Promise((resolve) => {
+    client.once("closed", resolve);
+  });
+}
+async function voiceChatSession(session, vad, args, debug) {
+  if (!checkSoxAvailable()) {
+    throw new CLIError(
+      "Voice mode requires SoX. Install it:\n  macOS:   brew install sox\n  Linux:   apt install sox\n  Windows: choco install sox"
+    );
+  }
+  const inputDeviceName = typeof args["input-device"] === "string" ? args["input-device"] : void 0;
+  const outputDeviceName = typeof args["output-device"] === "string" ? args["output-device"] : void 0;
+  let inputDeviceId;
+  let outputDeviceId;
+  if (!inputDeviceName || !outputDeviceName) {
+    process.stderr.write("\n  Audio Devices\n");
+  }
+  if (inputDeviceName) {
+    inputDeviceId = inputDeviceName;
+  } else {
+    const inputDevices = await listInputDevices();
+    const selected = await selectDevice(inputDevices, "Input (microphone)");
+    inputDeviceId = selected.id;
+  }
+  if (outputDeviceName) {
+    outputDeviceId = outputDeviceName;
+  } else {
+    const outputDevices = await listOutputDevices();
+    const selected = await selectDevice(outputDevices, "Output (speaker)");
+    outputDeviceId = selected.id;
+  }
+  const client = new RealtimeClient({
+    url: session.wsUrl,
+    token: session.ctx.accessToken,
+    chatId: session.chatId,
+    vadMode: vad,
+    debug
+  });
+  process.stderr.write(`
+Connecting to ${session.label.toLowerCase()}...
+`);
+  try {
+    await client.connect();
+  } catch (err) {
+    throw new CLIError(`Failed to connect: ${err instanceof Error ? err.message : err}`);
+  }
+  const existingMessages = await session.loadMessages();
+  const history = buildHistory(existingMessages);
+  const mic = new MicCapture((pcm16) => {
+    if (!client.isConnected()) return;
+    client.sendAudio(pcm16);
+  });
+  const player = new AudioPlayer(outputDeviceId);
+  function cleanup() {
+    mic.stop();
+    player.stop();
+    client.close();
+  }
+  const tui = new ChatTUI({
+    onSend: (text) => {
+      client.sendTextMessage(text);
+    },
+    onExit: () => {
+      cleanup();
+    },
+    debug,
+    env: session.ctx.env
+  });
+  wireRealtimeEvents(client, tui);
+  client.on("audio", (data) => {
+    player.write(data.pcm16);
+  });
+  client.on("audio_end", (data) => {
+    player.endResponse(data?.messageId);
+  });
+  client.on("interrupt", () => {
+    const playbackMs = player.getPlaybackTimeMs();
+    const messageId = player.playingMessageId;
+    if (playbackMs !== null && playbackMs > 0 && player.isPlaying) {
+      client.sendInterrupt(playbackMs, messageId);
+      player.stop();
+      if (debug) {
+        tui.logDebug("in", {
+          type: "CUSTOM",
+          name: "voice.interrupt",
+          value: { action: "echoed", audioEndMs: playbackMs, messageId }
+        });
+      }
+    } else if (debug) {
+      tui.logDebug("in", {
+        type: "CUSTOM",
+        name: "voice.interrupt",
+        value: { action: "ignored", wasPlaying: player.isPlaying }
+      });
+    }
+  });
+  client.on("truncate", (data) => {
+    player.stop();
+    tui.truncateAssistant(
+      data.content ?? "",
+      data.originalContent,
+      data.truncationReason ?? "barge_in",
+      data.truncatedAtMs
+    );
+  });
+  client.on("response_message", (data) => {
+    if (data.role === "user" && data.content) {
+      tui.addTranscription(data.content);
+    }
+  });
+  client.on("closed", () => {
+    tui.stop();
+    cleanup();
+    console.log("Disconnected.");
+  });
+  tui.loadHistory(history);
+  tui.start();
+  mic.start(inputDeviceId);
+  await new Promise((resolve) => {
+    client.once("closed", resolve);
+  });
+}
+async function listAudioDevices() {
+  if (!checkSoxAvailable()) {
+    throw new CLIError(
+      "Device listing requires SoX. Install it:\n  macOS:   brew install sox\n  Linux:   apt install sox\n  Windows: choco install sox"
+    );
+  }
+  const inputs = await listInputDevices();
+  const outputs = await listOutputDevices();
+  console.log("Input devices (microphone):");
+  for (const dev of inputs) {
+    const marker = dev.isDefault ? " (default)" : "";
+    console.log(`  ${dev.id}: ${dev.name}${marker}`);
+  }
+  console.log("\nOutput devices (speaker):");
+  for (const dev of outputs) {
+    const marker = dev.isDefault ? " (default)" : "";
+    console.log(`  ${dev.id}: ${dev.name}${marker}`);
+  }
+}
+
+// src/commands/concierge.ts
+async function conciergeOutboundCommand(hctx) {
+  const ctx = requireAuth(hctx.ctx);
+  const { args } = hctx;
+  if (args.call && args.sms) {
+    throw new CLIError("--call and --sms are mutually exclusive");
+  }
+  if (args.call) {
+    const result = await originateConciergeCall(ctx);
+    process.stderr.write(
+      `Concierge call started. callSid=${result.callSid} startedAt=${result.startedAt}
+`
+    );
+    return;
+  }
+  if (args.sms) {
+    const result = await originateConciergeSms(ctx);
+    process.stderr.write(
+      `Concierge SMS started. messageSid=${result.messageSid} conversationId=${result.conversationId}
+`
+    );
+    return;
+  }
+  throw new CLIError(
+    "Use `gr concierge chat --call`, `gr concierge chat --sms`, or `gr concierge chat` for interactive mode."
+  );
+}
+async function conciergeCommand(hctx) {
+  const ctx = requireAuth(hctx.ctx);
+  const { args } = hctx;
+  if (args.call || args.sms) {
+    if (args.call && args.sms) {
+      throw new CLIError("--call and --sms are mutually exclusive");
+    }
+    if (args.voice || args.realtime) {
+      throw new CLIError("--call/--sms cannot be combined with --voice or --realtime");
+    }
+    await conciergeOutboundCommand(hctx);
+    return;
+  }
+  const chatIdArg = typeof args["chat-id"] === "string" ? args["chat-id"] : void 0;
+  const message = typeof args.message === "string" ? args.message : void 0;
+  const chat = await getOrCreateConciergeChat(ctx, chatIdArg, !!message);
+  const session = buildConciergeSession(ctx, chat, args);
+  await runChatSession(session, args);
+}
+function buildConciergeSession(ctx, chat, args) {
+  const wsBase = ctx.envConfig.apiUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+  return {
+    ctx,
+    workspaceUuid: "",
+    chatId: chat.id,
+    chatUuid: chat.uuid,
+    chatTitle: chat.title || chat.uuid,
+    aguiEndpointUrl: `${ctx.envConfig.apiUrl}/api/v2/concierge/chats/${chat.id}/chat/agui`,
+    wsUrl: `${wsBase}/api/v2/concierge/voice/stream-ws`,
+    loadMessages: () => getConciergeChatMessages(ctx, chat.id).catch(() => []),
+    label: "Concierge",
+    model: void 0,
+    // concierge doesn't send model field
+    appContext: buildCliConciergeAppContext(),
+    allowWrite: true,
+    trustCwd: !!args["trust-cwd"],
+    trustDir: typeof args["trust-dir"] === "string" ? args["trust-dir"] : void 0
+  };
+}
+async function getOrCreateConciergeChat(ctx, chatIdArg, skipSelection) {
+  if (chatIdArg) {
+    const id = Number(chatIdArg);
+    if (isNaN(id)) throw new CLIError("--chat-id must be a number");
+    return getConciergeChat(ctx, id);
+  }
+  if (skipSelection) {
+    const chat = await createConciergeChat(ctx);
+    process.stderr.write(`Created concierge chat #${chat.id}
+`);
+    return chat;
+  }
+  const chats = await listConciergeChats(ctx);
+  const { item: selectedChat, isNew } = await selectFromList(chats, {
+    title: "Select a concierge chat or create a new one",
+    labelFn: (c) => c.title || `Chat ${c.uuid.slice(0, 8)}...`,
+    detailFn: (c) => formatTimestamp(c.updatedAt),
+    emptyMessage: "No existing concierge chats.",
+    allowNew: true,
+    newLabel: "+ Start new chat"
+  });
+  if (!selectedChat && !isNew) {
+    throw new CLIError("No chat selected.");
+  }
+  if (isNew) {
+    const chat = await createConciergeChat(ctx);
+    process.stderr.write(`Created concierge chat #${chat.id}
+`);
+    return chat;
+  }
+  return selectedChat;
+}
+
+export { buildCliConciergeAppContext, conciergeCommand, conciergeOutboundCommand, runChatSession };
+//# sourceMappingURL=chunk-QVG4L6BE.js.map
+//# sourceMappingURL=chunk-QVG4L6BE.js.map