@gravity-rail/cli 0.7.2 → 0.8.0

package/dist/register-special-commands.js

@@ -1,3856 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/cli-utils/config.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, join, resolve } from "path";
-var CALLBACK_PORT, CALLBACK_PATH, REDIRECT_URI;
-var init_config = __esm({
-  "src/cli-utils/config.ts"() {
-    "use strict";
-    CALLBACK_PORT = 31337;
-    CALLBACK_PATH = "/oauth/callback";
-    REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
-  }
-});
-
-// src/cli-utils/auth.ts
-import { createServer } from "http";
-import { createHash, randomBytes } from "crypto";
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync, chmodSync, unlinkSync } from "fs";
-import { join as join2 } from "path";
-import { exec } from "child_process";
-function stderr(msg) {
-  process.stderr.write(msg + "\n");
-}
-function isOAuthError(body, errorCode) {
-  try {
-    const parsed = JSON.parse(body);
-    if (parsed.error === errorCode) return true;
-  } catch {
-  }
-  return body.includes(errorCode);
-}
-function validateTokenResponse(tokenData) {
-  if (!tokenData.access_token || typeof tokenData.access_token !== "string") {
-    throw new Error("Token response missing access_token");
-  }
-  if (tokenData.token_type && String(tokenData.token_type).toLowerCase() !== "bearer") {
-    throw new Error(`Unsupported token type: ${tokenData.token_type}`);
-  }
-  let expiresIn = 86400;
-  if (tokenData.expires_in != null) {
-    const raw = Number(tokenData.expires_in);
-    if (!Number.isFinite(raw) || raw < 60 || raw > 31536e3) {
-      stderr(`  Warning: unusual expires_in value (${tokenData.expires_in}), using default`);
-    } else {
-      expiresIn = raw;
-    }
-  }
-  return {
-    accessToken: tokenData.access_token,
-    refreshToken: typeof tokenData.refresh_token === "string" ? tokenData.refresh_token : void 0,
-    expiresIn
-  };
-}
-function generatePKCE() {
-  const codeVerifier = randomBytes(64).toString("base64url").slice(0, 128);
-  const codeChallenge = createHash("sha256").update(codeVerifier).digest("base64url");
-  return { codeVerifier, codeChallenge };
-}
-function openBrowser(url) {
-  const platform = process.platform;
-  let cmd;
-  if (platform === "darwin") {
-    cmd = `open "${url}"`;
-  } else if (platform === "win32") {
-    cmd = `start "" "${url}"`;
-  } else {
-    cmd = `xdg-open "${url}"`;
-  }
-  exec(cmd, (err) => {
-    if (err) {
-      stderr("  Could not open browser automatically.");
-    }
-  });
-}
-function startCallbackServer() {
-  return new Promise((resolve2, reject) => {
-    let authCode = null;
-    let error = null;
-    let receivedState = null;
-    const server = createServer((req, res) => {
-      const url = new URL(req.url, `http://localhost:${CALLBACK_PORT}`);
-      if (url.pathname !== CALLBACK_PATH) {
-        res.writeHead(404);
-        res.end("Not found");
-        return;
-      }
-      if (url.searchParams.has("error")) {
-        error = url.searchParams.get("error");
-        const errorDesc = url.searchParams.get("error_description") || "Unknown error";
-        res.writeHead(200, { "Content-Type": "text/html" });
-        res.end(`
-          <html>
-          <head><title>Authorization Failed</title></head>
-          <body style="font-family: system-ui; text-align: center; padding: 50px;">
-            <h1 style="color: #dc2626;">Authorization Failed</h1>
-            <p>${errorDesc}</p>
-            <p>You can close this window.</p>
-          </body>
-          </html>
-        `);
-        server.close();
-        reject(new Error(`Authorization failed: ${error}`));
-      } else if (url.searchParams.has("code")) {
-        authCode = url.searchParams.get("code");
-        receivedState = url.searchParams.get("state");
-        res.writeHead(200, { "Content-Type": "text/html" });
-        res.end(`
-          <html>
-          <head><title>Authorization Successful</title></head>
-          <body style="font-family: system-ui; text-align: center; padding: 50px;">
-            <h1 style="color: #16a34a;">Authorization Successful!</h1>
-            <p>You can close this window and return to the terminal.</p>
-            <script>setTimeout(() => window.close(), 2000);</script>
-          </body>
-          </html>
-        `);
-        server.close();
-        resolve2({ code: authCode, state: receivedState });
-      } else {
-        res.writeHead(400);
-        res.end("Missing code parameter");
-      }
-    });
-    server.listen(CALLBACK_PORT, "localhost", () => {
-    });
-    const timeout = setTimeout(
-      () => {
-        if (!authCode && !error) {
-          server.close();
-          reject(new Error("Authorization timeout - no response received"));
-        }
-      },
-      5 * 60 * 1e3
-    );
-    timeout.unref();
-  });
-}
-async function dynamicClientRegistration(envConfig, clientName = "Gravity CLI") {
-  stderr("  Registering OAuth client...");
-  const registrationUrl = `${envConfig.apiUrl}/api/v2/oauth/register`;
-  const registrationData = {
-    client_name: clientName,
-    redirect_uris: [REDIRECT_URI],
-    grant_types: ["authorization_code", "refresh_token"],
-    response_types: ["code"],
-    token_endpoint_auth_method: "client_secret_basic",
-    scope: "workspace:admin"
-  };
-  const response = await fetch(registrationUrl, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(registrationData)
-  });
-  if (!response.ok) {
-    throw new Error(`Client registration failed: ${response.status} - ${await response.text()}`);
-  }
-  return await response.json();
-}
-async function performOAuthFlow(options) {
-  const { env, envConfig, credentialsManager, clientName = "Gravity CLI" } = options;
-  let hasRetried = false;
-  while (true) {
-    let creds = credentialsManager.load(env);
-    if (!creds || !creds.clientId) {
-      const registration = await dynamicClientRegistration(envConfig, clientName);
-      creds = {
-        clientId: registration.client_id,
-        clientSecret: registration.client_secret
-      };
-      credentialsManager.save(env, creds);
-    } else {
-      stderr("  Using cached client credentials");
-    }
-    const { codeVerifier, codeChallenge } = generatePKCE();
-    const state = randomBytes(32).toString("base64url");
-    const authParams = new URLSearchParams({
-      response_type: "code",
-      client_id: creds.clientId,
-      redirect_uri: REDIRECT_URI,
-      scope: "workspace:admin",
-      state,
-      code_challenge: codeChallenge,
-      code_challenge_method: "S256"
-    });
-    const authUrl = `${envConfig.apiUrl}/api/v2/oauth/authorize?${authParams}`;
-    const callbackPromise = startCallbackServer();
-    stderr("\n  Opening browser for authorization...");
-    stderr(`  If browser doesn't open, visit:
-  ${authUrl}
-`);
-    openBrowser(authUrl);
-    stderr("  Waiting for authorization (timeout: 5 minutes)...");
-    let code;
-    let receivedState;
-    try {
-      ({ code, state: receivedState } = await callbackPromise);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      if (!hasRetried && isOAuthError(msg, "invalid_client")) {
-        stderr("  Cached client credentials expired, re-registering...");
-        credentialsManager.clear(env);
-        hasRetried = true;
-        continue;
-      }
-      throw err;
-    }
-    if (receivedState !== state) {
-      throw new Error("State mismatch - possible CSRF attack");
-    }
-    stderr("  Authorization code received!");
-    stderr("  Exchanging code for tokens...");
-    const tokenUrl = `${envConfig.apiUrl}/api/v2/oauth/token`;
-    const authHeader = Buffer.from(`${creds.clientId}:${creds.clientSecret}`).toString("base64");
-    const tokenResponse = await fetch(tokenUrl, {
-      method: "POST",
-      headers: {
-        Authorization: `Basic ${authHeader}`,
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
-      body: new URLSearchParams({
-        grant_type: "authorization_code",
-        code,
-        redirect_uri: REDIRECT_URI,
-        code_verifier: codeVerifier
-      })
-    });
-    if (!tokenResponse.ok) {
-      const body = await tokenResponse.text();
-      if (!hasRetried && isOAuthError(body, "invalid_client")) {
-        stderr("  Cached client credentials expired, re-registering...");
-        credentialsManager.clear(env);
-        hasRetried = true;
-        continue;
-      }
-      throw new Error(`Token exchange failed: ${tokenResponse.status} - ${body}`);
-    }
-    const tokenData = await tokenResponse.json();
-    const { accessToken, refreshToken, expiresIn } = validateTokenResponse(tokenData);
-    creds.accessToken = accessToken;
-    creds.refreshToken = refreshToken ?? creds.refreshToken;
-    creds.expiresAt = new Date(Date.now() + expiresIn * 1e3).toISOString();
-    credentialsManager.save(env, creds);
-    stderr("  Authentication successful!");
-    return { accessToken, credentials: creds };
-  }
-}
-var init_auth = __esm({
-  "src/cli-utils/auth.ts"() {
-    "use strict";
-    init_config();
-  }
-});
-
-// src/cli-utils/ui.ts
-import * as readline from "readline";
-async function selectFromList(items, options = {}) {
-  const {
-    title = "Select an item",
-    labelFn = (item) => String(item.name || item.title || item),
-    detailFn = null,
-    env = null,
-    emptyMessage = "No items found.",
-    allowNew = false,
-    newLabel = "Create new..."
-  } = options;
-  if ((!items || items.length === 0) && !allowNew) {
-    console.log(`
-  ${emptyMessage}`);
-    return { item: null, isNew: false };
-  }
-  const displayItems = allowNew ? [NEW_ITEM_MARKER, ...items] : items;
-  return new Promise((resolve2) => {
-    let selectedIndex = allowNew ? 1 : 0;
-    let filterText = "";
-    const getFilteredItems = () => {
-      if (!filterText) return displayItems;
-      const lower = filterText.toLowerCase();
-      return displayItems.filter((item) => {
-        if (item === NEW_ITEM_MARKER) return true;
-        const label = labelFn(item);
-        return label.toLowerCase().includes(lower);
-      });
-    };
-    const render = () => {
-      const filtered = getFilteredItems();
-      process.stdout.write("\x1B[2J\x1B[H");
-      console.log("=".repeat(60));
-      console.log(`${title} (\u2191/\u2193 to move, Enter to select, Esc to cancel)`);
-      console.log("=".repeat(60));
-      if (env) {
-        console.log(`Environment: ${env}`);
-      }
-      console.log(`Filter: ${filterText}${filterText ? "" : "(type to filter)"}`);
-      console.log("");
-      if (filtered.length === 0) {
-        console.log(`  ${emptyMessage}`);
-        console.log("");
-        return;
-      }
-      const maxVisible = 15;
-      let startIdx = Math.max(0, selectedIndex - Math.floor(maxVisible / 2));
-      let endIdx = Math.min(filtered.length, startIdx + maxVisible);
-      if (endIdx - startIdx < maxVisible && startIdx > 0) {
-        startIdx = Math.max(0, endIdx - maxVisible);
-      }
-      if (startIdx > 0) {
-        console.log(`  ... ${startIdx} more above ...`);
-      }
-      for (let i = startIdx; i < endIdx; i++) {
-        const item = filtered[i];
-        const prefix = i === selectedIndex ? "> " : "  ";
-        let line;
-        if (item === NEW_ITEM_MARKER) {
-          line = `\x1B[32m${newLabel}\x1B[0m`;
-        } else {
-          const typedItem = item;
-          line = labelFn(typedItem);
-          if (detailFn) {
-            const detail = detailFn(typedItem);
-            if (detail) {
-              line = `${line}  \x1B[90m${detail}\x1B[0m`;
-            }
-          }
-        }
-        if (i === selectedIndex) {
-          console.log(`\x1B[7m${prefix}${line}\x1B[0m`);
-        } else {
-          console.log(`${prefix}${line}`);
-        }
-      }
-      if (endIdx < filtered.length) {
-        console.log(`  ... ${filtered.length - endIdx} more below ...`);
-      }
-      console.log("");
-      console.log(`  ${filtered.length} item(s)`);
-    };
-    readline.emitKeypressEvents(process.stdin);
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-    render();
-    const handleKeypress = (str, key) => {
-      const filtered = getFilteredItems();
-      if (key.name === "up") {
-        selectedIndex = Math.max(0, selectedIndex - 1);
-        render();
-      } else if (key.name === "down") {
-        selectedIndex = Math.min(filtered.length - 1, selectedIndex + 1);
-        render();
-      } else if (key.name === "return") {
-        cleanup();
-        if (filtered.length > 0 && selectedIndex < filtered.length) {
-          const selected = filtered[selectedIndex];
-          if (selected === NEW_ITEM_MARKER) {
-            resolve2({ item: null, isNew: true });
-          } else {
-            resolve2({ item: selected, isNew: false });
-          }
-        } else {
-          resolve2({ item: null, isNew: false });
-        }
-      } else if (key.name === "escape" || key.ctrl && key.name === "c") {
-        cleanup();
-        resolve2({ item: null, isNew: false });
-      } else if (key.name === "backspace") {
-        filterText = filterText.slice(0, -1);
-        selectedIndex = allowNew ? 0 : 0;
-        render();
-      } else if (str && str.length === 1 && !key.ctrl && !key.meta) {
-        filterText += str;
-        selectedIndex = allowNew ? 0 : 0;
-        render();
-      }
-    };
-    const cleanup = () => {
-      process.stdin.removeListener("keypress", handleKeypress);
-      if (process.stdin.isTTY) {
-        process.stdin.setRawMode(false);
-      }
-      process.stdin.pause();
-      process.stdout.write("\x1B[2J\x1B[H");
-    };
-    process.stdin.on("keypress", handleKeypress);
-    process.stdin.resume();
-  });
-}
-function printTable(items, columns, options = {}) {
-  if (!items || items.length === 0) {
-    console.log("\nNo items found.");
-    return;
-  }
-  if (options.title) {
-    console.log(`
-=== ${options.title} ===`);
-  }
-  if (options.env) {
-    console.log(`Environment: ${options.env}`);
-  }
-  console.log("");
-  const widths = columns.map((col) => {
-    const maxContent = Math.max(...items.map((item) => String(col.getValue(item) ?? "").length));
-    const width = Math.max(col.header.length, maxContent);
-    return col.maxWidth ? Math.min(width, col.maxWidth) : width;
-  });
-  const headerLine = columns.map((col, i) => col.header.padEnd(widths[i])).join("  ");
-  console.log(headerLine);
-  console.log(widths.map((w) => "-".repeat(w)).join("  "));
-  for (const item of items) {
-    const row = columns.map((col, i) => {
-      const value = String(col.getValue(item) ?? "");
-      const width = widths[i];
-      return value.slice(0, width).padEnd(width);
-    }).join("  ");
-    console.log(row);
-  }
-  console.log("");
-  console.log(`Total: ${items.length} item(s)`);
-}
-function formatTimestamp(isoString) {
-  if (!isoString) return "";
-  const date = new Date(isoString);
-  const now = /* @__PURE__ */ new Date();
-  const diff = now.getTime() - date.getTime();
-  if (diff < 6e4) return "just now";
-  if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
-  if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
-  if (diff < 6048e5) return `${Math.floor(diff / 864e5)}d ago`;
-  return date.toLocaleDateString();
-}
-function wrapText(text, width = 70) {
-  const words = text.split(" ");
-  const lines = [];
-  let currentLine = "";
-  for (const word of words) {
-    if (currentLine.length + word.length + 1 <= width) {
-      currentLine += (currentLine ? " " : "") + word;
-    } else {
-      if (currentLine) lines.push(currentLine);
-      currentLine = word;
-    }
-  }
-  if (currentLine) lines.push(currentLine);
-  return lines;
-}
-function printMessage(content, role, indent = "  ") {
-  const roleColors = {
-    user: "\x1B[34m",
-    // Blue
-    assistant: "\x1B[32m",
-    // Green
-    system: "\x1B[90m"
-    // Gray
-  };
-  const resetColor = "\x1B[0m";
-  const color = roleColors[role] || resetColor;
-  const label = role === "user" ? "You" : role === "assistant" ? "Assistant" : "System";
-  console.log(`${indent}${color}[${label}]${resetColor}`);
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const wrapped = wrapText(line, 70);
-    for (const wrappedLine of wrapped) {
-      console.log(`${indent}  ${wrappedLine}`);
-    }
-  }
-  console.log("");
-}
-function clearScreen() {
-  process.stdout.write("\x1B[2J\x1B[H");
-}
-var NEW_ITEM_MARKER;
-var init_ui = __esm({
-  "src/cli-utils/ui.ts"() {
-    "use strict";
-    NEW_ITEM_MARKER = Symbol("NEW_ITEM");
-  }
-});
-
-// src/cli-utils/agui.ts
-function isTextContentEvent(event) {
-  const type = event.type.toLowerCase();
-  return type === "text_message_content";
-}
-function isErrorEvent(event) {
-  const type = event.type.toLowerCase();
-  return type === "run_error";
-}
-function getTextDelta(event) {
-  if (isTextContentEvent(event) && event.delta) {
-    return event.delta;
-  }
-  return null;
-}
-function getErrorMessage(event) {
-  if (isErrorEvent(event)) {
-    return event.message || event.code || "Unknown error";
-  }
-  return null;
-}
-var AGUIClient;
-var init_agui = __esm({
-  "src/cli-utils/agui.ts"() {
-    "use strict";
-    AGUIClient = class {
-      endpointUrl;
-      baseUrl;
-      workspaceUuid;
-      chatId;
-      accessToken;
-      debug;
-      model;
-      appContext;
-      constructor(options) {
-        this.baseUrl = options.baseUrl;
-        this.workspaceUuid = options.workspaceUuid ?? "";
-        this.chatId = options.chatId ?? 0;
-        if (!options.endpointUrl && (!options.workspaceUuid || options.chatId === void 0)) {
-          throw new Error("AGUIClient requires workspaceUuid and chatId, or endpointUrl");
-        }
-        this.endpointUrl = options.endpointUrl ?? `${options.baseUrl}/api/v2/w/${options.workspaceUuid}/web-chat/${options.chatId}/chat/agui`;
-        this.accessToken = options.accessToken;
-        this.debug = options.debug ?? false;
-        this.model = "model" in options ? options.model : "manager";
-        this.appContext = options.appContext;
-      }
-      inferenceStatusUrl() {
-        if (!this.workspaceUuid || this.chatId <= 0) return null;
-        return `${this.baseUrl}/api/v2/w/${this.workspaceUuid}/chats/${this.chatId}/inference/status`;
-      }
-      async waitForInferenceInactive(maxWaitMs = 6e4) {
-        const url = this.inferenceStatusUrl();
-        if (!url) return false;
-        const deadline = Date.now() + maxWaitMs;
-        while (Date.now() < deadline) {
-          try {
-            const res = await fetch(url, {
-              headers: { Authorization: `Bearer ${this.accessToken}` }
-            });
-            if (res.ok) {
-              const body = await res.json();
-              if (!body.active) return true;
-            }
-          } catch (err) {
-            if (this.debug) {
-              console.log(
-                `[DEBUG] waitForInferenceInactive fetch failed: ${err instanceof Error ? err.message : String(err)}`
-              );
-            }
-          }
-          await new Promise((r) => setTimeout(r, 2e3));
-        }
-        return false;
-      }
-      /**
-       * Send messages and stream the response
-       */
-      async sendMessage(messages, onEvent, options) {
-        return this.streamRequest({ messages }, onEvent, options);
-      }
-      /**
-       * Stream an AG-UI request (initial messages or HITL resume).
-       */
-      async streamRequest(request, onEvent, options) {
-        const body = JSON.stringify({
-          ...this.model ? { model: this.model } : {},
-          messages: request.messages ?? [],
-          ...this.appContext ? { appContext: this.appContext } : {},
-          ...request.resumeValue !== void 0 ? { resumeValue: request.resumeValue } : {},
-          ...request.resumeInterruptId ? { resumeInterruptId: request.resumeInterruptId } : {},
-          ...options?.autoApprove ? { context: { autoApprove: true } } : {}
-        });
-        if (this.debug) {
-          console.log(`
-[DEBUG] POST ${this.endpointUrl}`);
-          console.log(
-            `[DEBUG] Body: ${request.resumeValue !== void 0 ? "resume" : `${(request.messages ?? []).length} message(s)`}`
-          );
-        }
-        await this.postStream(body, onEvent, options);
-      }
-      async postStream(body, onEvent, options, conflictRetries = 0) {
-        const response = await fetch(this.endpointUrl, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${this.accessToken}`,
-            "Content-Type": "application/json",
-            Accept: "text/event-stream"
-          },
-          body
-        });
-        if (this.debug) {
-          console.log(`[DEBUG] Response status: ${response.status}`);
-        }
-        if (response.status === 409 && conflictRetries < 3) {
-          const ready = await this.waitForInferenceInactive();
-          if (ready) {
-            await this.postStream(body, onEvent, options, conflictRetries + 1);
-            return;
-          }
-        }
-        if (!response.ok) {
-          const errorText = await response.text().catch(() => "");
-          if (this.debug) {
-            console.log(`[DEBUG] Error response: ${errorText}`);
-          }
-          throw new Error(
-            `Chat request failed: ${response.status}${errorText ? `: ${errorText.slice(0, 200)}` : ""}`
-          );
-        }
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              const data = line.slice(6);
-              if (data === "[DONE]") {
-                onEvent({ type: "done" });
-                continue;
-              }
-              try {
-                const event = JSON.parse(data);
-                onEvent(event);
-              } catch {
-              }
-            }
-          }
-        }
-      }
-    };
-  }
-});
-
-// src/cli-utils/index.ts
-var init_cli_utils = __esm({
-  "src/cli-utils/index.ts"() {
-    "use strict";
-    init_config();
-    init_auth();
-    init_ui();
-    init_agui();
-  }
-});
-
-// src/lib/errors.ts
-var CLIError;
-var init_errors = __esm({
-  "src/lib/errors.ts"() {
-    "use strict";
-    CLIError = class extends Error {
-      constructor(message, exitCode = 1) {
-        super(message);
-        this.exitCode = exitCode;
-        this.name = "CLIError";
-      }
-    };
-  }
-});
-
-// src/lib/pagination.ts
-function isListResult(data) {
-  if (!data || typeof data !== "object" || Array.isArray(data)) return false;
-  const obj = data;
-  return Array.isArray(obj.items) && ("supportsAll" in obj || "meta" in obj && (obj.meta === void 0 || typeof obj.meta === "object"));
-}
-function isPagePaginatedResponse(data) {
-  if (!data || typeof data !== "object") return false;
-  const obj = data;
-  if (!Array.isArray(obj.items) || typeof obj.page !== "number") return false;
-  if (typeof obj.totalPages === "number") return true;
-  if (typeof obj.total === "number" && typeof obj.pageSize === "number") return true;
-  return false;
-}
-function isCursorPaginatedResponse(data) {
-  if (!data || typeof data !== "object") return false;
-  const obj = data;
-  return Array.isArray(obj.items) && typeof obj.hasMore === "boolean";
-}
-function extractPaginationMeta(data) {
-  if (isPagePaginatedResponse(data)) {
-    const totalPages = data.totalPages ?? (data.pageSize ? Math.ceil(data.total / data.pageSize) : void 0);
-    return {
-      total: data.total,
-      page: data.page,
-      totalPages
-    };
-  }
-  if (isCursorPaginatedResponse(data)) {
-    return {
-      hasMore: data.hasMore,
-      nextCursor: data.nextCursor
-    };
-  }
-  return void 0;
-}
-function formatPaginationWarning(meta, supportsAll = true) {
-  if (!meta) return void 0;
-  const allHint = supportsAll ? " Use --all to fetch all pages." : "";
-  if (meta.totalPages !== void 0 && meta.totalPages > 1) {
-    const pageNum = meta.page ?? 1;
-    return `Showing page ${pageNum} of ${meta.totalPages} (${meta.total} total items).${allHint}`;
-  }
-  if (meta.hasMore === true) {
-    return `More results available.${allHint}`;
-  }
-  return void 0;
-}
-function unwrapItems(data) {
-  if (Array.isArray(data)) return data;
-  if (data && typeof data === "object" && "items" in data && Array.isArray(data.items)) {
-    return data.items;
-  }
-  return [data];
-}
-var init_pagination = __esm({
-  "src/lib/pagination.ts"() {
-    "use strict";
-    init_errors();
-  }
-});
-
-// src/lib/output.ts
-function outputData(data, opts, columns, paginationMeta, supportsAll) {
-  let items;
-  let meta;
-  let allSupported;
-  if (isListResult(data)) {
-    items = data.items;
-    meta = data.meta;
-    allSupported = data.supportsAll ?? false;
-  } else {
-    items = unwrapItems(data);
-    meta = paginationMeta ?? extractPaginationMeta(data);
-    allSupported = supportsAll ?? false;
-  }
-  const warning = formatPaginationWarning(meta, allSupported);
-  if (warning) {
-    process.stderr.write(warning + "\n");
-  }
-  switch (opts.outputFormat) {
-    case "json":
-      process.stdout.write(JSON.stringify(items, null, 2) + "\n");
-      break;
-    case "jsonl":
-      for (const item of items) {
-        process.stdout.write(JSON.stringify(item) + "\n");
-      }
-      break;
-    case "table":
-      if (columns) {
-        printTable(items, columns);
-      } else {
-        process.stdout.write(JSON.stringify(items, null, 2) + "\n");
-      }
-      break;
-  }
-}
-function outputSingle(data, opts, columns) {
-  switch (opts.outputFormat) {
-    case "json":
-      process.stdout.write(JSON.stringify(data, null, 2) + "\n");
-      break;
-    case "jsonl":
-      process.stdout.write(JSON.stringify(data) + "\n");
-      break;
-    case "table":
-      if (columns) {
-        printTable([data], columns);
-      } else {
-        process.stdout.write(JSON.stringify(data, null, 2) + "\n");
-      }
-      break;
-  }
-}
-function stderr2(msg) {
-  process.stderr.write(msg + "\n");
-}
-var init_output = __esm({
-  "src/lib/output.ts"() {
-    "use strict";
-    init_cli_utils();
-    init_pagination();
-  }
-});
-
-// src/lib/realm.ts
-import { execSync } from "child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-var CACHE_MAX_AGE_MS;
-var init_realm = __esm({
-  "src/lib/realm.ts"() {
-    "use strict";
-    CACHE_MAX_AGE_MS = 60 * 60 * 1e3;
-  }
-});
-
-// src/lib/org-auth.ts
-import { execFile as execFile2 } from "child_process";
-var ORG_AUTH_TIMEOUT_MS;
-var init_org_auth = __esm({
-  "src/lib/org-auth.ts"() {
-    "use strict";
-    init_output();
-    ORG_AUTH_TIMEOUT_MS = 5 * 60 * 1e3;
-  }
-});
-
-// src/lib/pinned-fetch.ts
-import { Agent, fetch as undiciFetch } from "undici";
-var init_pinned_fetch = __esm({
-  "src/lib/pinned-fetch.ts"() {
-    "use strict";
-  }
-});
-
-// src/lib/context.ts
-import { GravityRailClient } from "@gravity-rail/sdk";
-import { homedir } from "os";
-function requireAuth(ctx) {
-  if (!("apiClient" in ctx)) {
-    throw new Error("Command handler accessed apiClient without declaring requiresAuth");
-  }
-  return ctx;
-}
-var init_context = __esm({
-  "src/lib/context.ts"() {
-    "use strict";
-    init_cli_utils();
-    init_output();
-    init_realm();
-    init_errors();
-    init_org_auth();
-    init_pinned_fetch();
-  }
-});
-
-// src/lib/concierge-api.ts
-function baseUrl(ctx) {
-  return `${ctx.envConfig.apiUrl}/api/v2/concierge`;
-}
-function authHeaders(ctx) {
-  return {
-    Authorization: `Bearer ${ctx.accessToken}`,
-    "Content-Type": "application/json"
-  };
-}
-function toCamelChat(raw) {
-  return {
-    id: raw.id,
-    uuid: raw.uuid,
-    chatType: raw.chat_type,
-    title: raw.title,
-    threadId: raw.thread_id,
-    createdAt: raw.created_at,
-    updatedAt: raw.updated_at
-  };
-}
-function toCamelMessage(raw) {
-  return {
-    id: raw.id,
-    role: raw.role,
-    content: raw.content ?? "",
-    createdAt: raw.createdAt ?? raw.created_at ?? null,
-    toolCalls: raw.toolCalls ?? raw.tool_calls ?? null,
-    toolCallId: raw.toolCallId ?? raw.tool_call_id ?? null
-  };
-}
-async function listConciergeChats(ctx) {
-  const res = await fetch(`${baseUrl(ctx)}/chats`, { headers: authHeaders(ctx) });
-  if (!res.ok) throw new Error(`Failed to list concierge chats: ${res.status}`);
-  const data = await res.json();
-  return data.map(toCamelChat);
-}
-async function createConciergeChat(ctx, title) {
-  const res = await fetch(`${baseUrl(ctx)}/chats`, {
-    method: "POST",
-    headers: authHeaders(ctx),
-    body: JSON.stringify({ title: title ?? null })
-  });
-  if (!res.ok) throw new Error(`Failed to create concierge chat: ${res.status}`);
-  return toCamelChat(await res.json());
-}
-async function getConciergeChat(ctx, chatId) {
-  const res = await fetch(`${baseUrl(ctx)}/chats/${chatId}`, { headers: authHeaders(ctx) });
-  if (!res.ok) throw new Error(`Failed to get concierge chat ${chatId}: ${res.status}`);
-  return toCamelChat(await res.json());
-}
-async function originateConciergeCall(ctx, kind = "concierge_setup") {
-  const res = await fetch(`${baseUrl(ctx)}/calls`, {
-    method: "POST",
-    headers: authHeaders(ctx),
-    body: JSON.stringify({ kind })
-  });
-  if (res.status === 412) {
-    throw new Error("Your account phone is not verified. Run `gr account verify-phone` first.");
-  }
-  if (!res.ok) {
-    const detail = await res.text();
-    throw new Error(`Failed to start concierge call: ${res.status} ${detail}`);
-  }
-  return await res.json();
-}
-async function originateConciergeSms(ctx, kind = "concierge_setup") {
-  const res = await fetch(`${baseUrl(ctx)}/sms`, {
-    method: "POST",
-    headers: authHeaders(ctx),
-    body: JSON.stringify({ kind })
-  });
-  if (res.status === 412) {
-    throw new Error("Your account phone is not verified. Run `gr account verify-phone` first.");
-  }
-  if (!res.ok) {
-    const detail = await res.text();
-    throw new Error(`Failed to start concierge SMS: ${res.status} ${detail}`);
-  }
-  return await res.json();
-}
-async function startAccountPhoneVerify(ctx, phone) {
-  const res = await fetch(`${ctx.envConfig.apiUrl}/api/v2/account/phone/verify/start`, {
-    method: "POST",
-    headers: authHeaders(ctx),
-    body: JSON.stringify({ phone })
-  });
-  if (!res.ok) {
-    const detail = await res.text();
-    throw new Error(`Failed to send verification code: ${res.status} ${detail}`);
-  }
-}
-async function confirmAccountPhoneVerify(ctx, code) {
-  const res = await fetch(`${ctx.envConfig.apiUrl}/api/v2/account/phone/verify/confirm`, {
-    method: "POST",
-    headers: authHeaders(ctx),
-    body: JSON.stringify({ code })
-  });
-  if (!res.ok) {
-    const detail = await res.text();
-    throw new Error(`Failed to confirm verification code: ${res.status} ${detail}`);
-  }
-}
-async function getConciergeChatMessages(ctx, chatId) {
-  const res = await fetch(`${baseUrl(ctx)}/chats/${chatId}/messages`, {
-    headers: authHeaders(ctx)
-  });
-  if (!res.ok)
-    throw new Error(`Failed to get concierge messages for chat ${chatId}: ${res.status}`);
-  const data = await res.json();
-  return data.map(toCamelMessage);
-}
-var init_concierge_api = __esm({
-  "src/lib/concierge-api.ts"() {
-    "use strict";
-  }
-});
-
-// src/commands/account-verify-phone.ts
-var account_verify_phone_exports = {};
-__export(account_verify_phone_exports, {
-  accountVerifyPhoneCommand: () => accountVerifyPhoneCommand
-});
-import * as readline6 from "readline/promises";
-import { stdin as input, stdout as output } from "process";
-async function accountVerifyPhoneCommand(hctx) {
-  const ctx = requireAuth(hctx.ctx);
-  const phoneArg = typeof hctx.args.phone === "string" ? hctx.args.phone : void 0;
-  process.stderr.write(`${TCPA_NOTICE}
-`);
-  const phone = phoneArg ?? await promptLine("Phone number (E.164, e.g. +15551234567): ");
-  if (!phone.trim()) {
-    throw new Error("Phone number is required");
-  }
-  await startAccountPhoneVerify(ctx, phone.trim());
-  process.stderr.write("Verification code sent via SMS.\n");
-  const code = await promptLine("Enter 6-digit code: ");
-  await confirmAccountPhoneVerify(ctx, code.trim());
-  process.stderr.write(
-    "Phone verified. You can use `gr concierge chat --call` or `gr concierge chat --sms`.\n"
-  );
-}
-async function promptLine(question) {
-  const rl = readline6.createInterface({ input, output });
-  try {
-    return await rl.question(question) ?? "";
-  } finally {
-    rl.close();
-  }
-}
-var TCPA_NOTICE;
-var init_account_verify_phone = __esm({
-  "src/commands/account-verify-phone.ts"() {
-    "use strict";
-    init_concierge_api();
-    init_context();
-    TCPA_NOTICE = "By verifying you agree to receive calls and SMS from Gravity Rail at this number.";
-  }
-});
-
-// src/commands/auth-browser.ts
-init_output();
-import { execFile } from "child_process";
-async function authBrowserCommand(ctx, args) {
-  const noOpen = Boolean(args["no-open"]);
-  const account = await ctx.apiClient.getUserAccount();
-  if (!account.email) {
-    process.stderr.write("Error: No email associated with current account\n");
-    process.exit(1);
-  }
-  const response = await ctx.apiClient.requestMagicLink(account.email);
-  if (!response.success || !response.magicLinkUrl) {
-    process.stderr.write("Error: Failed to create magic link\n");
-    process.exit(1);
-  }
-  const url = response.magicLinkUrl;
-  if (noOpen) {
-    process.stdout.write(url + "\n");
-    return;
-  }
-  stderr2(`Opening browser for ${account.email} (${ctx.env})...`);
-  openUrl(url);
-  stderr2("Browser opened. Link expires in 15 minutes.");
-}
-function openUrl(url) {
-  const platform = process.platform;
-  let command;
-  let args;
-  if (platform === "darwin") {
-    command = "open";
-    args = [url];
-  } else if (platform === "win32") {
-    command = "cmd.exe";
-    args = ["/c", "start", "", url];
-  } else {
-    command = "xdg-open";
-    args = [url];
-  }
-  execFile(command, args, (err) => {
-    if (err) {
-      process.stderr.write("Warning: Could not open browser automatically\n");
-    }
-  });
-}
-
-// src/commands/manage.ts
-init_cli_utils();
-init_errors();
-init_context();
-
-// src/lib/cli-client-context.ts
-import path from "path";
-function buildCliConciergeAppContext() {
-  const shell = process.env.SHELL ? path.basename(process.env.SHELL) : void 0;
-  return {
-    clientSurface: "cli",
-    channel: "text",
-    cliContext: {
-      shell,
-      os: process.platform,
-      cwdBasename: path.basename(process.cwd())
-    }
-  };
-}
-
-// src/lib/chat-session.ts
-init_cli_utils();
-
-// src/lib/concierge-agui-loop.ts
-init_agui();
-
-// src/lib/cli-hitl.ts
-import readline3 from "readline";
-
-// src/lib/local-files.ts
-import fs from "fs";
-import path2 from "path";
-var DEFAULT_MAX_READ_BYTES = 5e4;
-var ABSOLUTE_MAX_READ_BYTES = 1e6;
-function resolveSafePath(root, relativePath) {
-  const rootResolved = path2.resolve(root);
-  const target = path2.resolve(rootResolved, relativePath || ".");
-  if (target !== rootResolved && !target.startsWith(rootResolved + path2.sep)) {
-    return null;
-  }
-  let cursor = rootResolved;
-  const rest = path2.relative(rootResolved, target);
-  if (rest && rest !== ".") {
-    for (const segment of rest.split(path2.sep)) {
-      cursor = path2.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(path2.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";
-}
-
-// src/lib/trusted-dirs.ts
-import fs2 from "fs";
-import os from "os";
-import path3 from "path";
-import readline2 from "readline";
-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(fs2.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);
-  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
-  fs2.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 = readline2.createInterface({ input: process.stdin, output: process.stderr });
-  const question = (q) => new Promise((resolve2) => rl.question(q, resolve2));
-  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 = readline3.createInterface({ input: process.stdin, output: process.stderr });
-  const answer = await new Promise((resolve2) => {
-    rl.question("Your choice (value): ", resolve2);
-  });
-  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 };
-}
-
-// src/lib/chat-session.ts
-init_errors();
-import * as readline5 from "readline";
-
-// src/lib/realtime-client.ts
-import { EventEmitter } from "events";
-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((resolve2, 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);
-        resolve2();
-      });
-      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;
-    }
-  }
-};
-
-// src/lib/chat-tui.ts
-import { createWriteStream } from "fs";
-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;
-}
-
-// src/lib/audio.ts
-import { spawn, execSync as execSync2, spawnSync } from "child_process";
-import { EventEmitter as EventEmitter2 } from "events";
-import * as readline4 from "readline";
-var SAMPLE_RATE = 24e3;
-var MIC_CHUNK_BYTES = 4800;
-function checkSoxAvailable() {
-  try {
-    execSync2("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((resolve2) => {
-    try {
-      const proc = spawnSync(command, ["--list-devices"], {
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "pipe"],
-        timeout: 5e3
-      });
-      const output2 = (proc.stdout ?? "") + (proc.stderr ?? "");
-      const devices = [];
-      const lines = output2.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 });
-      }
-      resolve2(devices);
-    } catch {
-      resolve2([{ id: "default", name: "System Default", isDefault: true }]);
-    }
-  });
-}
-async function selectDevice(devices, label) {
-  if (devices.length <= 1) {
-    return devices[0];
-  }
-  const rl = readline4.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((resolve2) => {
-    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));
-      resolve2(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 EventEmitter2 {
-  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,
-      debug,
-      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 = readline5.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve2) => {
-    const prompt = () => {
-      rl.question("\x1B[34mYou:\x1B[0m ", async (input2) => {
-        const trimmed = input2.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!");
-      resolve2();
-    });
-    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((resolve2) => {
-    client.once("closed", resolve2);
-  });
-}
-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((resolve2) => {
-    client.once("closed", resolve2);
-  });
-}
-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/manage.ts
-async function manageCommand(hctx) {
-  const ctx = requireAuth(hctx.ctx);
-  const { workspace, args } = hctx;
-  const asMember = typeof args["as-member"] === "string" ? args["as-member"] : void 0;
-  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 getOrCreateChat(ctx, workspace, chatIdArg, asMember, "manager", !!message);
-  const session = buildWorkspaceSession(ctx, workspace, chat, "Workspace Manager", {
-    appContext: buildCliConciergeAppContext(),
-    allowWrite: true,
-    trustCwd: !!args["trust-cwd"],
-    trustDir: typeof args["trust-dir"] === "string" ? args["trust-dir"] : void 0
-  });
-  process.stderr.write(`Chat #${session.chatId}
-`);
-  await runChatSession(session, args);
-  process.stderr.write(`Chat #${session.chatId}
-`);
-}
-async function chatCommand(hctx) {
-  const ctx = requireAuth(hctx.ctx);
-  const { workspace, args } = hctx;
-  const chatIdArg = typeof args["chat-id"] === "string" ? args["chat-id"] : void 0;
-  const workflowId = typeof args.workflow === "string" ? args.workflow : void 0;
-  const memberId = typeof args.member === "string" ? args.member : void 0;
-  let chat;
-  if (chatIdArg) {
-    const id = Number(chatIdArg);
-    if (isNaN(id)) throw new CLIError("--chat-id must be a number");
-    chat = await ctx.apiClient.getChat(workspace, id);
-  } else if (workflowId) {
-    chat = await createAssignmentChat(ctx.apiClient, workspace, Number(workflowId), memberId);
-  } else if (memberId) {
-    chat = await createMemberChat(ctx.apiClient, workspace, memberId);
-  } else {
-    throw new CLIError(
-      'Specify --workflow <id>, --member <id>, or --chat-id <id>.\nUse "gr manage" for workspace manager chats.'
-    );
-  }
-  const session = buildWorkspaceSession(ctx, workspace, chat, "Chat");
-  await runChatSession(session, args);
-}
-function buildWorkspaceSession(ctx, workspace, chat, label, extra) {
-  const wsBase = ctx.envConfig.apiUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
-  return {
-    ctx,
-    workspaceUuid: workspace,
-    chatId: chat.id,
-    chatUuid: chat.uuid,
-    chatTitle: chat.title || chat.uuid,
-    aguiEndpointUrl: `${ctx.envConfig.apiUrl}/api/v2/w/${workspace}/web-chat/${chat.id}/chat/agui`,
-    wsUrl: `${wsBase}/api/v2/w/${workspace}/realtime/stream-ws`,
-    loadMessages: () => ctx.apiClient.getChatMessages(workspace, chat.id, 50).catch(() => []),
-    label,
-    model: "manager",
-    ...extra
-  };
-}
-async function getOrCreateChat(ctx, workspace, chatIdArg, asMemberId, chatType, skipSelection = false) {
-  if (chatIdArg) {
-    const chatId = Number(chatIdArg);
-    if (isNaN(chatId)) throw new CLIError("--chat-id must be a number");
-    return ctx.apiClient.getChat(workspace, chatId);
-  }
-  if (skipSelection) {
-    return createManagerChat(ctx.apiClient, workspace, asMemberId);
-  }
-  const chatsResponse = await ctx.apiClient.getChats(workspace, {
-    chatType,
-    sortBy: "updatedAt",
-    sortOrder: "desc",
-    pageSize: 20
-  });
-  const chats = chatsResponse.items || [];
-  const { item: selectedChat, isNew } = await selectFromList(chats, {
-    title: "Select a chat or create a new one",
-    labelFn: (chat) => chat.title || `Chat ${chat.uuid.slice(0, 8)}...`,
-    detailFn: (chat) => {
-      const time = formatTimestamp(chat.updatedAt);
-      const msgCount = chat.messageCount || 0;
-      return `${msgCount} msg${msgCount !== 1 ? "s" : ""} - ${time}`;
-    },
-    emptyMessage: "No existing chats.",
-    allowNew: true,
-    newLabel: "+ Start new chat"
-  });
-  if (!selectedChat && !isNew) {
-    throw new CLIError("No chat selected.");
-  }
-  if (isNew) {
-    return createManagerChat(ctx.apiClient, workspace, asMemberId);
-  }
-  return selectedChat;
-}
-async function createManagerChat(apiClient, workspace, asMemberId) {
-  const data = {
-    chatType: "manager",
-    channel: "web-chat"
-  };
-  if (asMemberId) {
-    data.memberId = Number(asMemberId);
-  }
-  const chat = await apiClient.createChat(workspace, data);
-  process.stderr.write(`Created chat #${chat.id}
-`);
-  return chat;
-}
-async function createAssignmentChat(apiClient, workspace, workflowId, asMemberId) {
-  if (isNaN(workflowId)) throw new CLIError("--workflow must be a number");
-  const data = {
-    chatType: "assignment",
-    channel: "web-chat",
-    workflowId
-  };
-  if (asMemberId) {
-    data.memberId = Number(asMemberId);
-  }
-  const chat = await apiClient.createChat(workspace, data);
-  process.stderr.write(`Created assignment chat #${chat.id} (workflow ${workflowId})
-`);
-  return chat;
-}
-async function createMemberChat(apiClient, workspace, memberId) {
-  const id = Number(memberId);
-  if (isNaN(id)) throw new CLIError("--member must be a number");
-  const data = {
-    chatType: "member",
-    channel: "web-chat",
-    memberId: id
-  };
-  const chat = await apiClient.createChat(workspace, data);
-  process.stderr.write(`Created DM chat #${chat.id} (member ${memberId})
-`);
-  return chat;
-}
-
-// src/commands/concierge.ts
-init_cli_utils();
-init_concierge_api();
-init_context();
-init_errors();
-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;
-}
-
-// src/commands/dev.ts
-init_errors();
-init_output();
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
-import { execSync as execSync3 } from "child_process";
-import { join as join4 } from "path";
-async function devImportLocalCommand(ctx, workspace) {
-  stderr2(`Exporting workspace ${workspace}...`);
-  const exportData = await ctx.apiClient.exportWorkspace(workspace);
-  stderr2("Export successful!");
-  stderr2(`  Workflows: ${(exportData.workflows || []).length}`);
-  stderr2(`  Tasks: ${(exportData.tasks || []).length}`);
-  stderr2(`  Data Types: ${(exportData.dataTypes || []).length}`);
-  stderr2(`  Sites: ${(exportData.sites || []).length}`);
-  const slug = workspace.slice(0, 8);
-  const importCacheDir = join4(ctx.credentialsManager.getCacheDir(), "imports");
-  if (!existsSync4(importCacheDir)) {
-    mkdirSync3(importCacheDir, { recursive: true });
-  }
-  const filename = `ws-${slug}-${workspace}.json`;
-  const filepath = join4(importCacheDir, filename);
-  writeFileSync3(filepath, JSON.stringify(exportData, null, 2));
-  stderr2(`Saved to: ${filepath}`);
-  stderr2("Running dev:restore...");
-  const rootDir = findProjectRoot();
-  const relativePath = filepath.replace(rootDir + "/", "");
-  try {
-    const result = execSync3(`yarn dev:restore ${relativePath}`, {
-      cwd: rootDir,
-      stdio: "pipe",
-      encoding: "utf-8"
-    });
-    process.stderr.write(result);
-    const failed = result.includes("Failed/Skipped: ") && !result.includes("Failed/Skipped: 0") || result.includes("Successfully restored: 0");
-    if (failed) throw new CLIError("Import failed");
-  } catch (error) {
-    if (error instanceof CLIError) throw error;
-    const execError = error;
-    if (execError.stdout) process.stderr.write(execError.stdout);
-    if (execError.stderr) process.stderr.write(execError.stderr);
-    throw new CLIError("dev:restore failed");
-  }
-  stderr2(`Import complete: ${workspace}`);
-}
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== "/") {
-    const pkgPath = join4(dir, "package.json");
-    if (existsSync4(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
-        if (pkg.workspaces) return dir;
-      } catch {
-      }
-    }
-    dir = join4(dir, "..");
-  }
-  return process.cwd();
-}
-
-// src/commands/get-started.ts
-init_context();
-var WEB_SETUP = "https://app.gravityrail.com/setup";
-var WEB_GET_STARTED = "https://app.gravityrail.com/get-started";
-var HUMAN_GUIDE = `Gravity Rail \u2014 getting started
-
-1. Authenticate:  gr login --env prod
-   Confirm:       gr whoami
-
-2. Recommended path \u2014 concierge (no workspace required):
-   gr concierge chat --allow-write
-   The concierge can create your org (auto-created on first login), list products,
-   start Stripe checkout, and create your first workspace.
-
-3. Verify workspaces:  gr workspaces list
-
-4. Web wizards (human-friendly):  ${WEB_SETUP}  and  ${WEB_GET_STARTED}
-
-Headless boundary: Stripe checkout needs a human in a browser \u2014 the concierge returns
-a checkout URL; an agent should hand that link to the user, not loop on payment.
-
-Agent-readable steps:  gr get-started --format llm
-`;
-var LLM_GUIDE = `# Gravity Rail CLI bootstrap (agent instructions)
-
-## Preconditions
-- Install: \`npm install -g @gravity-rail/cli\` or \`npx @gravity-rail/cli\`
-- Authenticate: \`gr login --env prod\` (interactive OAuth). Verify with \`gr whoami\`.
-- **Monorepo dev:** from gravity-team with Docker dev up, use \`yarn gr <cmd> --realm superadmin\` (reads \`dev-realms.json\`; no browser). Rebuild: \`yarn workspace @gravity-rail/gr-cli build\`.
-
-## Important facts
-- **Agents/CI:** do not leave stdin open on read-only commands; use \`GRAVITY_RAIL_API_KEY\` or redirect stdin from /dev/null. Commands only read stdin when \`--data\`/\`--file\` is passed.
-- Use \`--env dev|staging|prod\` (default prod) so credentials match the target; \`gr whoami\` shows the active env.
-- After login, an **organization is created automatically** \u2014 do not create a duplicate org unless \`gr organizations list\` is empty.
-- **Workspace is required** for workflow/agent/task commands (\`-w <workspace-uuid>\`).
-- **Concierge does not require \`-w\`** \u2014 use it for first-run setup.
-
-## Recommended path (concierge-driven)
-\`\`\`bash
-gr concierge chat --allow-write --message "Help me set up my first Gravity Rail workspace"
-\`\`\`
-Flags for unattended turns:
-- \`--message\` / \`-m\`: single-turn (non-interactive)
-- \`--auto-approve\`: skip HITL tool approval where policy allows
-- \`--allow-write\`: required for create/update tools
-
-The concierge can: list/create orgs, list org/workspace products, create Stripe checkout sessions, create workspace specs, and \`create_workspace\`.
-
-## Manual CLI path (if not using concierge)
-1. \`gr whoami\` \u2014 confirm account
-2. \`gr organizations list\` \u2014 note org slug/UUID
-3. \`gr concierge chat\` OR web: ${WEB_GET_STARTED}
-4. Product purchase: concierge returns Stripe checkout URL \u2192 **human must complete in browser**
-5. \`gr workspaces list\` \u2014 pick workspace UUID for \`-w\`
-
-## Support (account-level, no workspace)
-\`\`\`bash
-gr support create --type question --title "..." --description "..." --allow-write
-gr support list
-\`\`\`
-
-## Web fallbacks
-- Concierge / setup: ${WEB_SETUP}
-- Wizard: ${WEB_GET_STARTED}
-
-## Headless limits (do not retry forever)
-- Stripe payment / checkout: requires human browser
-- OAuth login: requires human browser
-- Directory trust for future local-file tools: use \`--trust-cwd\` only after user confirms files are safe
-
-## Local project files (CLI only)
-After directory trust + \`--allow-write\`, the concierge can use \`read_local_file\`, \`list_local_dir\`, \`write_local_file\` (client-executed via HITL).
-
-## Verify success
-\`gr workspaces list\` then \`gr workflows list -w <uuid>\` or \`gr agents list -w <uuid>\`
-
-## Local phone / voice QA (monorepo dev)
-\`\`\`bash
-yarn dev:twilio-ngrok --start-ngrok --url gravityrail.ngrok.io dev.<you> -w acme-demo
-yarn gr phone setup
-yarn gr account verify-phone --phone +1\u2026 --allow-write --realm superadmin
-yarn gr concierge chat --call --allow-write --realm superadmin
-yarn gr phone outbound --realm acme-demo/acme-admin --workflow-id 1 --allow-write
-\`\`\`
-See \`.claude/skills/phone-voice-qa/SKILL.md\` and \`./scripts/e2e-voice-phone-matrix.sh\`.
-`;
-async function getStartedCommand(hctx) {
-  const format = hctx.args.format ?? hctx.args.agent;
-  const isLlm = format === "llm" || format === "agent" || hctx.args["format"] === "llm" || !!hctx.args.agent;
-  if (!isLlm) {
-    try {
-      requireAuth(hctx.ctx);
-    } catch {
-    }
-    process.stdout.write(HUMAN_GUIDE);
-    return;
-  }
-  process.stdout.write(LLM_GUIDE);
-}
-
-// src/commands/login.ts
-init_cli_utils();
-init_output();
-import { GravityRailClient as GravityRailClient2 } from "@gravity-rail/sdk";
-async function loginCommand(ctx) {
-  const { accessToken } = await performOAuthFlow({
-    env: ctx.env,
-    envConfig: ctx.envConfig,
-    credentialsManager: ctx.credentialsManager
-  });
-  const apiClient = new GravityRailClient2(accessToken, ctx.envConfig.apiUrl);
-  const account = await apiClient.getUserAccount();
-  stderr2(`Logged in as ${account.name} (${account.email})`);
-}
-async function logoutCommand(ctx) {
-  ctx.credentialsManager.clear(ctx.env);
-  stderr2(`Credentials cleared for ${ctx.env}`);
-}
-
-// src/commands/organizations.ts
-init_output();
-var COLUMNS = [
-  { header: "NAME", getValue: (o) => o.organizationName || "", maxWidth: 35 },
-  { header: "SLUG", getValue: (o) => o.organizationSlug || "", maxWidth: 25 },
-  { header: "UUID", getValue: (o) => o.organizationUuid },
-  { header: "ROLE", getValue: (o) => o.role || "" }
-];
-async function organizationsListCommand(ctx) {
-  const organizations = await ctx.apiClient.getMyOrganizations();
-  outputData(organizations, ctx, COLUMNS);
-}
-
-// src/commands/whoami.ts
-init_output();
-var COLUMNS2 = [
-  { header: "NAME", getValue: (a) => a.name || "", maxWidth: 30 },
-  { header: "EMAIL", getValue: (a) => a.email || "", maxWidth: 40 },
-  { header: "UUID", getValue: (a) => a.uuid },
-  { header: "ENV", getValue: () => "" },
-  { header: "SUPERUSER", getValue: (a) => a.isSuperuser ? "yes" : "no" }
-];
-async function whoamiCommand(ctx) {
-  const account = await ctx.apiClient.getUserAccount();
-  const columns = COLUMNS2.map(
-    (col) => col.header === "ENV" ? { ...col, getValue: () => ctx.env } : col
-  );
-  outputSingle(account, ctx, columns);
-}
-
-// src/register-special-commands.ts
-init_context();
-function registerSpecialCommands(registry) {
-  registry.registerCommand({
-    path: ["login"],
-    description: "Authenticate via OAuth",
-    requiresAuth: false,
-    handler: async ({ ctx }) => {
-      await loginCommand(ctx);
-    }
-  });
-  registry.registerCommand({
-    path: ["logout"],
-    description: "Clear cached credentials",
-    requiresAuth: false,
-    handler: async ({ ctx }) => {
-      await logoutCommand(ctx);
-    }
-  });
-  registry.registerCommand({
-    path: ["auth", "browser"],
-    description: "Open an authenticated browser session using CLI credentials",
-    args: [
-      { name: "no-open", description: "Print the URL instead of opening browser", isFlag: true }
-    ],
-    handler: async ({ ctx, args }) => {
-      await authBrowserCommand(requireAuth(ctx), args);
-    }
-  });
-  registry.registerCommand({
-    path: ["manage"],
-    description: "Interactive workspace manager chat (text, realtime, or voice)",
-    requiresWorkspace: true,
-    mutates: true,
-    args: [
-      { name: "realtime", description: "Use WebSocket realtime connection", isFlag: true },
-      { name: "voice", description: "Enable voice mode (microphone + speaker)", isFlag: true },
-      { name: "message", alias: "m", description: "Single-turn: send one message and exit" },
-      { name: "as-member", description: "Chat as a specific member (by numeric ID)" },
-      { name: "chat-id", description: "Resume an existing chat by numeric ID" },
-      { name: "vad", description: "Voice activity detection: server (default) or client" },
-      { name: "list-devices", description: "List audio devices and exit", isFlag: true },
-      { name: "input-device", description: "Microphone device name or ID" },
-      { name: "output-device", description: "Speaker device name or ID" },
-      { name: "debug", description: "Enable debug logging", isFlag: true },
-      {
-        name: "auto-approve",
-        description: "Auto-approve all tool calls (skip HITL)",
-        isFlag: true
-      },
-      {
-        name: "trust-cwd",
-        description: "Trust files in the current working directory (non-interactive)",
-        isFlag: true
-      },
-      {
-        name: "trust-dir",
-        description: "Trust files in this directory (non-interactive; absolute path)"
-      }
-    ],
-    handler: async (hctx) => {
-      await manageCommand(hctx);
-    }
-  });
-  registry.registerCommand({
-    path: ["chat"],
-    description: "Chat with a workflow, member, or existing chat (text, realtime, or voice)",
-    requiresWorkspace: true,
-    mutates: true,
-    args: [
-      { name: "workflow", description: "Start assignment chat with workflow (by numeric ID)" },
-      { name: "member", description: "Start DM with a member (by numeric ID)" },
-      { name: "chat-id", description: "Resume an existing chat by numeric ID" },
-      { name: "realtime", description: "Use WebSocket realtime connection", isFlag: true },
-      { name: "voice", description: "Enable voice mode (microphone + speaker)", isFlag: true },
-      { name: "message", alias: "m", description: "Single-turn: send one message and exit" },
-      { name: "vad", description: "Voice activity detection: server (default) or client" },
-      { name: "list-devices", description: "List audio devices and exit", isFlag: true },
-      { name: "input-device", description: "Microphone device name or ID" },
-      { name: "output-device", description: "Speaker device name or ID" },
-      { name: "debug", description: "Enable debug logging", isFlag: true },
-      {
-        name: "auto-approve",
-        description: "Auto-approve all tool calls (skip HITL)",
-        isFlag: true
-      }
-    ],
-    handler: async (hctx) => {
-      await chatCommand(hctx);
-    }
-  });
-  registry.registerCommand({
-    path: ["get-started"],
-    description: "Bootstrap instructions for new users and LLM agents",
-    requiresAuth: false,
-    args: [
-      {
-        name: "format",
-        description: "Output format: llm (agent-readable) or default (human)"
-      },
-      {
-        name: "agent",
-        description: "Alias for --format llm",
-        isFlag: true
-      }
-    ],
-    handler: async (hctx) => {
-      await getStartedCommand(hctx);
-    }
-  });
-  registry.registerCommand({
-    path: ["setup"],
-    description: "Alias for get-started \u2014 bootstrap instructions",
-    requiresAuth: false,
-    args: [
-      { name: "format", description: "Output format: llm or default" },
-      { name: "agent", description: "Alias for --format llm", isFlag: true }
-    ],
-    handler: async (hctx) => {
-      await getStartedCommand(hctx);
-    }
-  });
-  registry.registerCommand({
-    path: ["concierge"],
-    description: "Call or SMS your verified phone via the Concierge (server-side)",
-    requiresWorkspace: false,
-    mutates: true,
-    args: [
-      { name: "call", description: "Ring your verified account phone", isFlag: true },
-      { name: "sms", description: "Start an SMS thread on your verified phone", isFlag: true }
-    ],
-    handler: async (hctx) => {
-      await conciergeOutboundCommand(hctx);
-    }
-  });
-  registry.registerCommand({
-    path: ["account", "verify-phone"],
-    description: "Verify your account phone for concierge chat --call / --sms",
-    requiresWorkspace: false,
-    mutates: true,
-    args: [{ name: "phone", description: "E.164 phone number (optional; prompts if omitted)" }],
-    handler: async (hctx) => {
-      const { accountVerifyPhoneCommand: accountVerifyPhoneCommand2 } = await Promise.resolve().then(() => (init_account_verify_phone(), account_verify_phone_exports));
-      await accountVerifyPhoneCommand2(hctx);
-    }
-  });
-  registry.registerCommand({
-    path: ["concierge", "chat"],
-    description: "Interactive concierge chat (text, realtime, or voice)",
-    requiresWorkspace: false,
-    mutates: true,
-    args: [
-      { name: "realtime", description: "Use WebSocket realtime connection", isFlag: true },
-      { name: "voice", description: "Enable voice mode (microphone + speaker)", isFlag: true },
-      {
-        name: "call",
-        description: "Ring your verified account phone (server-side)",
-        isFlag: true
-      },
-      {
-        name: "sms",
-        description: "SMS your verified account phone (server-side)",
-        isFlag: true
-      },
-      { name: "message", alias: "m", description: "Single-turn: send one message and exit" },
-      { name: "chat-id", description: "Resume an existing chat by numeric ID" },
-      { name: "vad", description: "Voice activity detection: server (default) or client" },
-      { name: "list-devices", description: "List audio devices and exit", isFlag: true },
-      { name: "input-device", description: "Microphone device name or ID" },
-      { name: "output-device", description: "Speaker device name or ID" },
-      { name: "debug", description: "Enable debug logging", isFlag: true },
-      {
-        name: "auto-approve",
-        description: "Auto-approve all tool calls (skip HITL)",
-        isFlag: true
-      },
-      {
-        name: "trust-cwd",
-        description: "Trust files in the current working directory (non-interactive)",
-        isFlag: true
-      },
-      {
-        name: "trust-dir",
-        description: "Trust files in this directory (non-interactive; absolute path)"
-      }
-    ],
-    handler: async (hctx) => {
-      await conciergeCommand(hctx);
-    }
-  });
-  registry.registerCommand({
-    path: ["dev", "import-local"],
-    description: "Import remote workspace locally",
-    requiresWorkspace: true,
-    handler: async ({ ctx, workspace }) => {
-      await devImportLocalCommand(requireAuth(ctx), workspace);
-    }
-  });
-  registry.registerCommand({
-    path: ["whoami"],
-    description: "Show current user info",
-    handler: async ({ ctx }) => {
-      await whoamiCommand(requireAuth(ctx));
-    }
-  });
-  registry.registerCommand({
-    path: ["organizations", "list"],
-    description: "List organizations",
-    handler: async ({ ctx }) => {
-      await organizationsListCommand(requireAuth(ctx));
-    }
-  });
-  registry.registerCommand({
-    path: ["orgs", "list"],
-    description: "List organizations",
-    handler: async ({ ctx }) => {
-      await organizationsListCommand(requireAuth(ctx));
-    }
-  });
-}
-export {
-  registerSpecialCommands
-};
-//# sourceMappingURL=register-special-commands.js.map