@arbidocs/tui 0.3.16 → 0.3.17

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 'use strict';
 
-var commander = require('commander');
 var sdk = require('@arbidocs/sdk');
+var commander = require('commander');
 var piTui = require('@mariozechner/pi-tui');
 var chalk = require('chalk');
 require('fake-indexeddb/auto');
@@ -13,6 +13,78 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 
+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/tui-helpers.ts
+var tui_helpers_exports = {};
+__export(tui_helpers_exports, {
+  applyWorkspaceSelection: () => applyWorkspaceSelection,
+  requireAuth: () => requireAuth,
+  runInteractiveFlow: () => runInteractiveFlow,
+  showMessage: () => showMessage,
+  switchWorkspace: () => switchWorkspace
+});
+function requireAuth(tui, message = "Not authenticated. Use /login first.") {
+  if (tui.authContext) return true;
+  showMessage(tui, message, "error");
+  return false;
+}
+function showMessage(tui, message, level) {
+  tui.chatLog.addSystem(message, level);
+  tui.requestRender();
+}
+async function switchWorkspace(tui, workspaceId) {
+  if (!tui.authContext) return null;
+  try {
+    const ws = await sdk.selectWorkspaceById(
+      tui.authContext.arbi,
+      workspaceId,
+      tui.authContext.loginResult.serverSessionKey,
+      tui.store.requireCredentials().signingPrivateKeyBase64
+    );
+    tui.state.workspaceId = ws.external_id;
+    tui.state.workspaceName = ws.name;
+    tui.state.conversationMessageId = null;
+    tui.store.clearChatSession();
+    tui.store.updateConfig({ selectedWorkspaceId: ws.external_id });
+    await tui.refreshWorkspaceContext();
+    return ws;
+  } catch (err) {
+    showMessage(tui, `Failed to switch workspace: ${sdk.getErrorMessage(err)}`, "error");
+    return null;
+  }
+}
+async function applyWorkspaceSelection(tui, workspaceId, workspaceName) {
+  if (!workspaceId) return;
+  const wsCtx = await sdk.resolveWorkspace(tui.store, workspaceId);
+  tui.setWorkspaceContext(wsCtx);
+  tui.state.workspaceName = workspaceName ?? null;
+}
+async function runInteractiveFlow(tui, pauseMessage, action, errorPrefix) {
+  showMessage(tui, pauseMessage);
+  tui.stopTui();
+  try {
+    const result = await action();
+    tui.restartTui();
+    return result;
+  } catch (err) {
+    tui.restartTui();
+    showMessage(tui, `${errorPrefix}: ${sdk.getErrorMessage(err)}`, "error");
+    return null;
+  }
+}
+var init_tui_helpers = __esm({
+  "src/tui-helpers.ts"() {
+  }
+});
 var colors = {
   /** Primary accent — teal/cyan used for headings, prompts, highlights */
   accent: chalk__default.default.cyan,
@@ -99,7 +171,7 @@ var AssistantMessage = class extends piTui.Container {
   label;
   constructor() {
     super();
-    this.label = new piTui.Text(colors.assistantLabel("Assistant"), 1, 0);
+    this.label = new piTui.Text(colors.assistantLabel("ARBI"), 1, 0);
     this.markdown = new piTui.Markdown("", 1, 0, assistantMarkdownTheme);
     this.addChild(this.label);
     this.addChild(this.markdown);
@@ -124,6 +196,23 @@ var SystemMessage = class extends piTui.Text {
     super(styleFn(message), 1, 0);
   }
 };
+var RightAlignedText = class {
+  text;
+  styleFn;
+  constructor(text, styleFn) {
+    this.text = text;
+    this.styleFn = styleFn;
+  }
+  invalidate() {
+  }
+  render(width) {
+    if (!this.text || this.text.trim() === "") return [];
+    const styled = this.styleFn(this.text);
+    const textWidth = piTui.visibleWidth(styled);
+    const padding = Math.max(0, width - textWidth);
+    return [" ".repeat(padding) + styled];
+  }
+};
 var AgentStep = class extends piTui.Text {
   completed = false;
   constructor(focus) {
@@ -160,6 +249,11 @@ var ChatLog = class extends piTui.Container {
     this.addChild(new SystemMessage(message, level));
     this.addChild(new piTui.Spacer(1));
   }
+  /** Add a right-aligned summary line (e.g. stream stats). */
+  addSummary(text) {
+    this.addChild(new RightAlignedText(text, colors.systemInfo));
+    this.addChild(new piTui.Spacer(1));
+  }
   /** Add a received DM message (cyan label with sender email). */
   addDm(senderEmail, text) {
     const container = new piTui.Container();
@@ -195,13 +289,17 @@ var ChatLog = class extends piTui.Container {
     this.activeSteps.push(step);
     this.addChild(step);
   }
-  /** Finalize the current assistant response. */
-  finalizeAssistant() {
+  /** Remove all active agent steps from the chat log (e.g. when streaming starts). */
+  clearActiveSteps() {
     for (const step of this.activeSteps) {
-      step.complete();
+      this.removeChild(step);
     }
-    this.activeAssistant = null;
     this.activeSteps = [];
+  }
+  /** Finalize the current assistant response. */
+  finalizeAssistant() {
+    this.clearActiveSteps();
+    this.activeAssistant = null;
     this.addChild(new piTui.Spacer(1));
   }
 };
@@ -306,30 +404,32 @@ var ToastContainer = class extends piTui.Container {
   }
 };
 
-// src/commands.ts
-var commands = [
-  { name: "help", description: "Show available commands" },
-  { name: "login", description: "Log in (re-authenticate)" },
-  { name: "register", description: "Register a new account" },
-  { name: "create", description: "Create a new workspace: /create <name>" },
-  { name: "workspace", description: "Switch workspace: /workspace <id>" },
-  { name: "workspaces", description: "List all workspaces" },
-  { name: "contacts", description: "List contacts (type @name to DM)" },
-  { name: "invite", description: "Invite a contact: /invite user@example.com" },
-  { name: "docs", description: "List documents in current workspace" },
-  { name: "upload", description: "Upload a file: /upload <path>" },
-  { name: "delete", description: "Delete a document: /delete <doc-id>" },
-  { name: "conversations", description: "List conversations" },
-  { name: "new", description: "Start fresh conversation (clear threading)" },
-  { name: "models", description: "List available AI models" },
-  { name: "health", description: "Show system health status" },
-  { name: "status", description: "Show auth/workspace/connection status" },
-  { name: "logout", description: "Log out and clear credentials" },
-  { name: "exit", description: "Exit TUI" },
-  { name: "quit", description: "Exit TUI" }
-];
+// src/command-registry.ts
+init_tui_helpers();
+var registry = /* @__PURE__ */ new Map();
+function registerCommand(def) {
+  registry.set(def.name, def);
+}
+function registerCommands(defs) {
+  for (const def of defs) {
+    registerCommand(def);
+  }
+}
+function toSlashCommands() {
+  const cmds = [];
+  for (const def of registry.values()) {
+    if (def.hidden) continue;
+    cmds.push({ name: def.name, description: def.description });
+  }
+  return cmds;
+}
 function formatHelpText() {
-  const lines = commands.filter((c) => c.name !== "quit").map((c) => `  /${c.name} \u2014 ${c.description}`);
+  const lines = [];
+  for (const def of registry.values()) {
+    if (def.hidden) continue;
+    const hint = def.argHint ? ` <${def.argHint}>` : "";
+    lines.push(`  /${def.name}${hint} \u2014 ${def.description}`);
+  }
   return [
     "Available commands:",
     "",
@@ -346,6 +446,133 @@ function formatHelpText() {
     "  Escape \u2014 Abort streaming"
   ].join("\n");
 }
+async function dispatchCommand(tui, input2) {
+  const trimmed = input2.trim();
+  if (!trimmed.startsWith("/")) return false;
+  const parts = trimmed.slice(1).split(/\s+/);
+  const cmdName = parts[0]?.toLowerCase();
+  const args = parts.slice(1);
+  if (!cmdName) return false;
+  const def = registry.get(cmdName);
+  if (!def) {
+    showMessage(tui, `Unknown command: /${cmdName}. Type /help for available commands.`, "warning");
+    return true;
+  }
+  if (def.minArgs && args.length < def.minArgs) {
+    const hint = def.argHint ? ` <${def.argHint}>` : "";
+    showMessage(tui, `Usage: /${def.name}${hint}`, "warning");
+    return true;
+  }
+  let ctx;
+  if (def.requires === "none") {
+    ctx = { requires: "none", args, rawInput: trimmed, tui };
+  } else if (def.requires === "auth") {
+    if (!tui.authContext) {
+      showMessage(tui, "Not authenticated. Use /login first.", "error");
+      return true;
+    }
+    ctx = {
+      requires: "auth",
+      args,
+      rawInput: trimmed,
+      tui,
+      arbi: tui.authContext.arbi,
+      authContext: tui.authContext
+    };
+  } else {
+    if (!tui.authContext) {
+      showMessage(tui, "Not authenticated. Use /login first.", "error");
+      return true;
+    }
+    if (!tui.wsContext) {
+      showMessage(tui, "No workspace selected. Use /workspace <id> first.", "warning");
+      return true;
+    }
+    ctx = {
+      requires: "workspace",
+      args,
+      rawInput: trimmed,
+      tui,
+      arbi: tui.wsContext.arbi,
+      authContext: tui.authContext,
+      wsContext: tui.wsContext,
+      authHeaders: {
+        baseUrl: tui.wsContext.config.baseUrl,
+        accessToken: tui.wsContext.accessToken,
+        workspaceKeyHeader: tui.wsContext.workspaceKeyHeader
+      }
+    };
+  }
+  try {
+    const result = await def.run(ctx);
+    if (typeof result === "string") {
+      showMessage(tui, result);
+    } else if (Array.isArray(result)) {
+      showMessage(tui, result.join("\n"));
+    }
+  } catch (err) {
+    showMessage(tui, `Command /${def.name} failed: ${sdk.getErrorMessage(err)}`, "error");
+  }
+  return true;
+}
+
+// src/commands/general.ts
+var generalCommands = [
+  {
+    name: "help",
+    description: "Show available commands",
+    requires: "none",
+    run: () => formatHelpText()
+  },
+  {
+    name: "status",
+    description: "Show auth/workspace/connection status",
+    requires: "none",
+    run: (ctx) => {
+      const { tui } = ctx;
+      const { state } = tui;
+      return [
+        `Authenticated: ${state.isAuthenticated ? colors.success("yes") : colors.error("no")}`,
+        `Workspace: ${state.workspaceName ? colors.accent(state.workspaceName) : colors.muted("none")}`,
+        `Workspace ID: ${state.workspaceId ?? colors.muted("none")}`,
+        `Conversation: ${state.conversationMessageId ? colors.muted(state.conversationMessageId) : colors.muted("new")}`,
+        `Status: ${state.activityStatus}`,
+        `WebSocket: ${tui.wsConnected ? colors.success("connected") : colors.muted("disconnected")}`
+      ];
+    }
+  },
+  {
+    name: "new",
+    description: "Start fresh conversation (clear threading)",
+    requires: "none",
+    run: (ctx) => {
+      const { tui } = ctx;
+      tui.state.conversationMessageId = null;
+      tui.lastMetadata = null;
+      tui.store.clearChatSession();
+      return "Started new conversation.";
+    }
+  },
+  {
+    name: "exit",
+    description: "Exit TUI",
+    requires: "none",
+    run: (ctx) => {
+      const { tui } = ctx;
+      tui.shutdown();
+    }
+  },
+  {
+    name: "quit",
+    description: "Exit TUI",
+    requires: "none",
+    hidden: true,
+    run: (ctx) => {
+      const { tui } = ctx;
+      tui.shutdown();
+    }
+  }
+];
 async function promptSelect(message, choices) {
   return prompts.select({ message, choices });
 }
@@ -483,218 +710,396 @@ ${sdk.getErrorMessage(err)}
     }
   }
 }
-function requireAuth(tui, message = "Not authenticated. Use /login first.") {
-  if (tui.authContext) return true;
-  showMessage(tui, message, "error");
-  return false;
-}
-function showMessage(tui, message, level) {
-  tui.chatLog.addSystem(message, level);
-  tui.requestRender();
-}
-async function switchWorkspace(tui, workspaceId) {
-  if (!tui.authContext) return null;
-  try {
-    const ws = await sdk.selectWorkspaceById(
-      tui.authContext.arbi,
-      workspaceId,
-      tui.authContext.loginResult.serverSessionKey,
-      tui.store.requireCredentials().signingPrivateKeyBase64
-    );
-    tui.state.workspaceId = ws.external_id;
-    tui.state.workspaceName = ws.name;
-    tui.state.conversationMessageId = null;
-    tui.store.clearChatSession();
-    tui.store.updateConfig({ selectedWorkspaceId: ws.external_id });
-    await tui.refreshWorkspaceContext();
-    return ws;
-  } catch (err) {
-    showMessage(tui, `Failed to switch workspace: ${sdk.getErrorMessage(err)}`, "error");
-    return null;
-  }
-}
-async function applyWorkspaceSelection(tui, workspaceId, workspaceName) {
-  if (!workspaceId) return;
-  const wsCtx = await sdk.resolveWorkspace(tui.store, workspaceId);
-  tui.setWorkspaceContext(wsCtx);
-  tui.state.workspaceName = workspaceName ?? null;
-}
-async function runInteractiveFlow(tui, pauseMessage, action, errorPrefix) {
-  showMessage(tui, pauseMessage);
-  tui.stopTui();
-  try {
-    const result = await action();
-    tui.restartTui();
-    return result;
-  } catch (err) {
-    tui.restartTui();
-    showMessage(tui, `${errorPrefix}: ${sdk.getErrorMessage(err)}`, "error");
-    return null;
-  }
-}
 
-// src/command-handlers.ts
-async function handleCommand(tui, input2) {
-  const trimmed = input2.trim();
-  if (!trimmed.startsWith("/")) return false;
-  const parts = trimmed.slice(1).split(/\s+/);
-  const cmd = parts[0]?.toLowerCase();
-  const args = parts.slice(1);
-  switch (cmd) {
-    case "help":
-      showMessage(tui, formatHelpText());
-      return true;
-    case "login":
-      await handleLogin(tui);
-      return true;
-    case "register":
-      await handleRegister(tui);
-      return true;
-    case "create":
-      await handleCreateWorkspace(tui, args.join(" "));
-      return true;
-    case "workspace":
-      await handleWorkspaceSwitch(tui, args[0]);
-      return true;
-    case "workspaces":
-      await handleListWorkspaces(tui);
-      return true;
-    case "contacts":
-      await handleListContacts(tui);
-      return true;
-    case "invite":
-      await handleInviteContact(tui, args[0]);
-      return true;
-    case "docs":
-      await handleListDocs(tui);
-      return true;
-    case "upload":
-      await handleUpload(tui, args.join(" "));
-      return true;
-    case "delete":
-      await handleDelete(tui, args[0]);
-      return true;
-    case "conversations":
-      await handleListConversations(tui);
-      return true;
-    case "new":
-      handleNewConversation(tui);
-      return true;
-    case "models":
-      await handleModels(tui);
-      return true;
-    case "health":
-      await handleHealth(tui);
-      return true;
-    case "status":
-      handleStatus(tui);
-      return true;
-    case "logout":
-      handleLogout(tui);
-      return true;
-    case "exit":
-    case "quit":
-      tui.shutdown();
-      return true;
-    default:
-      showMessage(tui, `Unknown command: /${cmd}. Type /help for available commands.`, "warning");
-      return true;
-  }
-}
-async function handleLogin(tui) {
-  const result = await runInteractiveFlow(
-    tui,
-    "Pausing TUI for login...",
-    () => interactiveLogin(tui.store),
-    "Login failed"
-  );
-  if (result) {
-    tui.setAuthContext(result.authContext);
-    await applyWorkspaceSelection(tui, result.selectedWorkspaceId, result.selectedWorkspaceName);
-    showMessage(tui, "Logged in successfully.");
-  }
-}
-async function handleRegister(tui) {
-  const result = await runInteractiveFlow(
-    tui,
-    "Pausing TUI for registration...",
-    () => interactiveRegister(tui.store),
-    "Registration failed"
-  );
-  if (result) {
-    tui.setAuthContext(result.authContext);
-    await applyWorkspaceSelection(tui, result.selectedWorkspaceId, result.selectedWorkspaceName);
-    showMessage(tui, "Registered and logged in.");
-  }
-}
-async function handleCreateWorkspace(tui, name) {
-  if (!requireAuth(tui)) return;
-  if (!name.trim()) {
-    showMessage(tui, "Usage: /create <workspace name>", "warning");
-    return;
-  }
-  try {
-    showMessage(tui, `Creating workspace "${name}"...`);
-    const ws = await sdk.workspaces.createWorkspace(tui.authContext.arbi, name.trim());
-    const selected = await switchWorkspace(tui, ws.external_id);
-    if (selected) {
-      showMessage(tui, `Created and switched to workspace: ${colors.accentBold(selected.name)}`);
+// src/commands/auth.ts
+init_tui_helpers();
+var authCommands = [
+  {
+    name: "login",
+    description: "Log in (re-authenticate)",
+    requires: "none",
+    run: async (ctx) => {
+      const { tui } = ctx;
+      const result = await runInteractiveFlow(
+        tui,
+        "Pausing TUI for login...",
+        () => interactiveLogin(tui.store),
+        "Login failed"
+      );
+      if (result) {
+        tui.setAuthContext(result.authContext);
+        await applyWorkspaceSelection(tui, result.selectedWorkspaceId, result.selectedWorkspaceName);
+        showMessage(tui, "Logged in successfully.");
+      }
+    }
+  },
+  {
+    name: "register",
+    description: "Register a new account",
+    requires: "none",
+    run: async (ctx) => {
+      const { tui } = ctx;
+      const result = await runInteractiveFlow(
+        tui,
+        "Pausing TUI for registration...",
+        () => interactiveRegister(tui.store),
+        "Registration failed"
+      );
+      if (result) {
+        tui.setAuthContext(result.authContext);
+        await applyWorkspaceSelection(tui, result.selectedWorkspaceId, result.selectedWorkspaceName);
+        showMessage(tui, "Registered and logged in.");
+      }
+    }
+  },
+  {
+    name: "logout",
+    description: "Log out and clear credentials",
+    requires: "none",
+    run: (ctx) => {
+      const { tui } = ctx;
+      tui.store.deleteCredentials();
+      tui.store.updateConfig({ selectedWorkspaceId: void 0 });
+      tui.store.clearChatSession();
+      tui.authContext = null;
+      tui.state.isAuthenticated = false;
+      tui.state.workspaceId = null;
+      tui.state.workspaceName = null;
+      tui.state.conversationMessageId = null;
+      return "Logged out. Use /login to authenticate again.";
     }
-  } catch (err) {
-    showMessage(tui, `Failed to create workspace: ${sdk.getErrorMessage(err)}`, "error");
-  }
-}
-async function handleWorkspaceSwitch(tui, workspaceId) {
-  if (!requireAuth(tui, "Not authenticated. Please restart and log in.")) return;
-  if (!workspaceId) {
-    await handleListWorkspaces(tui);
-    showMessage(tui, "Use /workspace <id> to switch.");
-    return;
   }
-  showMessage(tui, `Switching to workspace ${workspaceId}...`);
-  const ws = await switchWorkspace(tui, workspaceId);
-  if (ws) {
-    showMessage(tui, `Switched to workspace: ${colors.accentBold(ws.name)}`);
+];
+init_tui_helpers();
+var workspaceCommands = [
+  {
+    name: "workspaces",
+    description: "List all workspaces",
+    requires: "auth",
+    run: async (ctx) => {
+      const { arbi, tui } = ctx;
+      const wsList = await sdk.workspaces.listWorkspaces(arbi);
+      const lines = wsList.map((ws) => {
+        const current = ws.external_id === tui.state.workspaceId ? colors.accent(" (current)") : "";
+        return `  ${ws.external_id}  ${ws.name}${current}`;
+      });
+      return ["Workspaces:", "", ...lines];
+    }
+  },
+  {
+    name: "workspace",
+    description: "Switch workspace",
+    argHint: "id",
+    requires: "auth",
+    run: async (ctx) => {
+      const { args, arbi, tui } = ctx;
+      if (!args[0]) {
+        const wsList = await sdk.workspaces.listWorkspaces(arbi);
+        const lines = wsList.map((ws2) => {
+          const current = ws2.external_id === tui.state.workspaceId ? colors.accent(" (current)") : "";
+          return `  ${ws2.external_id}  ${ws2.name}${current}`;
+        });
+        showMessage(tui, ["Workspaces:", "", ...lines].join("\n"));
+        return "Use /workspace <id> to switch.";
+      }
+      showMessage(tui, `Switching to workspace ${args[0]}...`);
+      const ws = await switchWorkspace(tui, args[0]);
+      if (ws) {
+        return `Switched to workspace: ${colors.accentBold(ws.name)}`;
+      }
+    }
+  },
+  {
+    name: "create",
+    description: "Create a new workspace",
+    argHint: "name",
+    minArgs: 1,
+    requires: "auth",
+    run: async (ctx) => {
+      const { args, arbi, tui } = ctx;
+      const name = args.join(" ").trim();
+      showMessage(tui, `Creating workspace "${name}"...`);
+      const ws = await sdk.workspaces.createWorkspace(arbi, name);
+      const selected = await switchWorkspace(tui, ws.external_id);
+      if (selected) {
+        return `Created and switched to workspace: ${colors.accentBold(selected.name)}`;
+      }
+    }
+  },
+  {
+    name: "ws-delete",
+    description: "Delete a workspace",
+    argHint: "id",
+    minArgs: 1,
+    requires: "auth",
+    run: async (ctx) => {
+      const { args, arbi } = ctx;
+      await sdk.workspaces.deleteWorkspaces(arbi, [args[0]]);
+      return `${colors.success("Deleted")} workspace ${args[0]}`;
+    }
+  },
+  {
+    name: "ws-users",
+    description: "List users in current workspace",
+    requires: "workspace",
+    run: async (ctx) => {
+      const { arbi } = ctx;
+      const users = await sdk.workspaces.listWorkspaceUsers(arbi);
+      if (users.length === 0) return "No users in this workspace.";
+      const lines = users.map((u) => {
+        const name = sdk.formatUserName(u.user);
+        const nameStr = name ? colors.muted(` (${name})`) : "";
+        const role = u.role ? colors.muted(` [${u.role}]`) : "";
+        return `  ${u.user.email}${nameStr}${role}`;
+      });
+      return [`Workspace users (${users.length}):`, "", ...lines];
+    }
+  },
+  {
+    name: "ws-add-user",
+    description: "Add a user to current workspace",
+    argHint: "email",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, arbi } = ctx;
+      const email = args[0].trim();
+      await sdk.workspaces.addWorkspaceUsers(arbi, [email]);
+      return `${colors.success("Added")} ${email} to workspace.`;
+    }
+  },
+  {
+    name: "ws-remove-user",
+    description: "Remove a user from current workspace",
+    argHint: "email",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, arbi } = ctx;
+      const email = args[0].trim();
+      const users = await sdk.workspaces.listWorkspaceUsers(arbi);
+      const user = users.find((u) => u.user.email === email);
+      if (!user) return `User ${email} not found in this workspace.`;
+      const userId = user.user.external_id;
+      if (!userId) return `Could not resolve user ID for ${email}.`;
+      await sdk.workspaces.removeWorkspaceUsers(arbi, [userId]);
+      return `${colors.success("Removed")} ${email} from workspace.`;
+    }
   }
-}
-async function handleListWorkspaces(tui) {
-  if (!requireAuth(tui, "Not authenticated.")) return;
-  try {
-    const wsList = await sdk.workspaces.listWorkspaces(tui.authContext.arbi);
-    const lines = wsList.map((ws) => {
-      const current = ws.external_id === tui.state.workspaceId ? colors.accent(" (current)") : "";
-      return `  ${ws.external_id}  ${ws.name}${current}`;
-    });
-    showMessage(tui, ["Workspaces:", "", ...lines].join("\n"));
-  } catch (err) {
-    showMessage(tui, `Failed to list workspaces: ${sdk.getErrorMessage(err)}`, "error");
+];
+init_tui_helpers();
+var documentCommands = [
+  {
+    name: "docs",
+    description: "List documents in current workspace",
+    requires: "workspace",
+    run: async (ctx) => {
+      const { arbi } = ctx;
+      const docs = await sdk.documents.listDocuments(arbi);
+      if (docs.length === 0) return "No documents in this workspace.";
+      const lines = docs.map((d) => `  ${d.external_id}  ${d.file_name ?? "(unnamed)"}`);
+      return [`Documents (${docs.length}):`, "", ...lines];
+    }
+  },
+  {
+    name: "doc",
+    description: "Show document details",
+    argHint: "id",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, arbi } = ctx;
+      const docs = await sdk.documents.getDocuments(arbi, [args[0]]);
+      if (docs.length === 0) return `Document ${args[0]} not found.`;
+      const doc = docs[0];
+      const lines = [
+        `Document: ${colors.accent(doc.file_name ?? "(unnamed)")}`,
+        "",
+        `  ID:       ${doc.external_id}`,
+        `  Status:   ${doc.status ?? colors.muted("unknown")}`,
+        `  Size:     ${doc.file_size != null ? `${doc.file_size} bytes` : colors.muted("unknown")}`,
+        `  Created:  ${doc.created_at ?? colors.muted("unknown")}`
+      ];
+      return lines;
+    }
+  },
+  {
+    name: "upload",
+    description: "Upload a file",
+    argHint: "path",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, tui, wsContext } = ctx;
+      const filePath = args.join(" ").trim();
+      showMessage(tui, `Uploading ${filePath}...`);
+      const result = await sdk.documentsNode.uploadLocalFile(
+        {
+          baseUrl: wsContext.config.baseUrl,
+          accessToken: wsContext.accessToken,
+          workspaceKeyHeader: wsContext.workspaceKeyHeader
+        },
+        wsContext.workspaceId,
+        filePath
+      );
+      const ids = result.doc_ext_ids.join(", ");
+      showMessage(tui, `${colors.success("Uploaded")} ${result.fileName} \u2014 doc ID(s): ${ids}`);
+      if (result.duplicates && result.duplicates.length > 0) {
+        showMessage(tui, `Duplicates detected: ${result.duplicates.join(", ")}`, "warning");
+      }
+    }
+  },
+  {
+    name: "upload-url",
+    description: "Upload a document from URL",
+    argHint: "url",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, arbi, wsContext, tui } = ctx;
+      const url = args[0].trim();
+      showMessage(tui, `Uploading from ${url}...`);
+      const result = await sdk.documents.uploadUrl(arbi, [url], wsContext.workspaceId);
+      const ids = result.doc_ext_ids.join(", ");
+      return `${colors.success("Uploaded")} from URL \u2014 doc ID(s): ${ids}`;
+    }
+  },
+  {
+    name: "delete",
+    description: "Delete a document",
+    argHint: "doc-id",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, arbi, tui } = ctx;
+      const docId = args[0].trim();
+      showMessage(tui, `Deleting document ${docId}...`);
+      await sdk.documents.deleteDocuments(arbi, [docId]);
+      return `${colors.success("Deleted")} document ${docId}`;
+    }
+  },
+  {
+    name: "parsed",
+    description: "Show parsed content of a document",
+    argHint: "doc-id",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, authHeaders } = ctx;
+      const docId = args[0].trim();
+      const data = await sdk.documents.getParsedContent(authHeaders, docId, "content");
+      const content = data.content;
+      if (!content) return `No parsed content available for document ${docId}.`;
+      const maxLen = 3e3;
+      const truncated = content.length > maxLen ? content.slice(0, maxLen) + "\n... (truncated)" : content;
+      return [`Parsed content for ${docId}:`, "", truncated];
+    }
   }
-}
-async function handleListDocs(tui) {
-  if (!tui.wsContext) {
-    showMessage(tui, "No workspace selected. Use /workspace <id> first.", "warning");
-    return;
+];
+var conversationCommands = [
+  {
+    name: "conversations",
+    description: "List conversations",
+    requires: "workspace",
+    run: async (ctx) => {
+      const { arbi } = ctx;
+      const convs = await sdk.conversations.listConversations(arbi);
+      if (convs.length === 0) return "No conversations in this workspace.";
+      const lines = convs.map((c) => `  ${c.external_id}  ${c.title ?? "(untitled)"}`);
+      return [`Conversations (${convs.length}):`, "", ...lines];
+    }
+  },
+  {
+    name: "conv-delete",
+    description: "Delete a conversation",
+    argHint: "id",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, arbi } = ctx;
+      await sdk.conversations.deleteConversation(arbi, args[0]);
+      return `${colors.success("Deleted")} conversation ${args[0]}`;
+    }
+  },
+  {
+    name: "conv-title",
+    description: "Rename a conversation",
+    argHint: "id title",
+    minArgs: 2,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, arbi } = ctx;
+      const [id, ...titleParts] = args;
+      const title = titleParts.join(" ");
+      await sdk.conversations.updateConversationTitle(arbi, id, title);
+      return `Renamed conversation ${id} to: ${colors.accent(title)}`;
+    }
+  },
+  {
+    name: "conv-share",
+    description: "Share a conversation",
+    argHint: "id",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, arbi } = ctx;
+      const result = await sdk.conversations.shareConversation(arbi, args[0]);
+      const shareId = result.share_ext_id ?? result.external_id;
+      return `${colors.success("Shared")} conversation ${args[0]} \u2014 share ID: ${shareId}`;
+    }
   }
-  try {
-    const docs = await sdk.documents.listDocuments(tui.wsContext.arbi);
-    if (docs.length === 0) {
-      showMessage(tui, "No documents in this workspace.");
-    } else {
-      const lines = docs.map((d) => `  ${d.external_id}  ${d.file_name ?? "(unnamed)"}`);
-      showMessage(tui, [`Documents (${docs.length}):`, "", ...lines].join("\n"));
+];
+var tagCommands = [
+  {
+    name: "tags",
+    description: "List tags in workspace",
+    requires: "workspace",
+    run: async (ctx) => {
+      const { arbi } = ctx;
+      const data = await sdk.tags.listTags(arbi);
+      if (data.length === 0) return "No tags in this workspace.";
+      const lines = data.map((t) => `  ${t.external_id}  ${t.name}`);
+      return [`Tags (${data.length}):`, "", ...lines];
+    }
+  },
+  {
+    name: "tag-create",
+    description: "Create a tag",
+    argHint: "name",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, arbi } = ctx;
+      const name = args.join(" ").trim();
+      const tag = await sdk.tags.createTag(arbi, { name });
+      return `${colors.success("Created")} tag "${tag.name}" \u2014 ID: ${tag.external_id}`;
+    }
+  },
+  {
+    name: "tag-delete",
+    description: "Delete a tag",
+    argHint: "id",
+    minArgs: 1,
+    requires: "workspace",
+    run: async (ctx) => {
+      const { args, arbi } = ctx;
+      await sdk.tags.deleteTag(arbi, args[0]);
+      return `${colors.success("Deleted")} tag ${args[0]}`;
     }
-  } catch (err) {
-    showMessage(tui, `Failed to list documents: ${sdk.getErrorMessage(err)}`, "error");
   }
-}
-async function handleListContacts(tui) {
-  if (!requireAuth(tui)) return;
-  try {
-    const contactList = await sdk.contacts.listContacts(tui.authContext.arbi);
-    const { registered, pending } = sdk.contacts.groupContactsByStatus(contactList);
-    if (registered.length === 0 && pending.length === 0) {
-      showMessage(tui, "No contacts. Use the web app to add contacts.");
-    } else {
+];
+var miscCommands = [
+  {
+    name: "contacts",
+    description: "List contacts (type @name to DM)",
+    requires: "auth",
+    run: async (ctx) => {
+      const { arbi } = ctx;
+      const contactList = await sdk.contacts.listContacts(arbi);
+      const { registered, pending } = sdk.contacts.groupContactsByStatus(contactList);
+      if (registered.length === 0 && pending.length === 0) {
+        return "No contacts. Use the web app to add contacts.";
+      }
       const lines = [];
       if (registered.length > 0) {
         lines.push(`Contacts (${registered.length}):`, "");
@@ -712,184 +1117,217 @@ async function handleListContacts(tui) {
         }
       }
       lines.push("", colors.muted("Type @name to start a DM with a registered contact."));
-      showMessage(tui, lines.join("\n"));
+      return lines;
+    }
+  },
+  {
+    name: "invite",
+    description: "Invite a contact",
+    argHint: "email",
+    minArgs: 1,
+    requires: "auth",
+    run: async (ctx) => {
+      const { args, arbi, tui } = ctx;
+      const email = args[0].trim();
+      const { showMessage: showMessage2 } = await Promise.resolve().then(() => (init_tui_helpers(), tui_helpers_exports));
+      showMessage2(tui, `Inviting ${email}...`);
+      const result = await sdk.contacts.addContacts(arbi, [email]);
+      const contact = result[0];
+      if (contact?.status === "registered") {
+        return `${colors.success("Added")} ${email} \u2014 already registered. You can DM them with @${email.split("@")[0]}`;
+      }
+      return `${colors.success("Invited")} ${email} \u2014 invitation sent. They'll appear in /contacts once they register.`;
+    }
+  },
+  {
+    name: "models",
+    description: "List available AI models",
+    requires: "auth",
+    run: async (ctx) => {
+      const { arbi } = ctx;
+      const data = await sdk.health.getHealthModels(arbi);
+      const models = Array.isArray(data) ? data : data.data ?? [];
+      if (models.length === 0) return "No models available.";
+      const lines = [`Models (${models.length}):`, ""];
+      for (const m of models) {
+        const model = m;
+        const name = model.model_name ?? model.name ?? "unknown";
+        const provider = model.provider ?? "";
+        const apiType = model.api_type ?? "";
+        const parts = [colors.accent(name)];
+        if (provider) parts.push(`provider: ${provider}`);
+        if (apiType) parts.push(`api: ${apiType}`);
+        lines.push(`  ${parts.join("  ")}`);
+      }
+      return lines;
+    }
+  },
+  {
+    name: "health",
+    description: "Show system health status",
+    requires: "auth",
+    run: async (ctx) => {
+      const { arbi } = ctx;
+      const data = await sdk.health.getHealth(arbi);
+      const lines = ["System Health:", ""];
+      const status = data.status;
+      if (status) {
+        const statusColor = status === "healthy" ? colors.success(status) : colors.warning(status);
+        lines.push(`  Status: ${statusColor}`);
+      }
+      const services = data.services;
+      if (services) {
+        lines.push("", "  Services:");
+        for (const [name, info] of Object.entries(services)) {
+          const svc = info;
+          const svcStatus = svc.status;
+          const statusStr = svcStatus ? svcStatus === "healthy" ? colors.success(svcStatus) : colors.error(svcStatus) : colors.muted("unknown");
+          lines.push(`    ${name}: ${statusStr}`);
+        }
+      }
+      return lines;
+    }
+  },
+  {
+    name: "settings",
+    description: "Show user settings",
+    requires: "auth",
+    run: async (ctx) => {
+      const { arbi } = ctx;
+      const data = await sdk.settings.getSettings(arbi);
+      const entries = Object.entries(data);
+      if (entries.length === 0) return "No settings configured.";
+      const lines = ["User Settings:", ""];
+      for (const [key, value] of entries) {
+        const display = typeof value === "object" ? JSON.stringify(value) : String(value);
+        lines.push(`  ${colors.accent(key)}: ${display}`);
+      }
+      return lines;
     }
-  } catch (err) {
-    showMessage(tui, `Failed to list contacts: ${sdk.getErrorMessage(err)}`, "error");
-  }
-}
-async function handleInviteContact(tui, email) {
-  if (!requireAuth(tui)) return;
-  if (!email?.trim()) {
-    showMessage(tui, "Usage: /invite user@example.com", "warning");
-    return;
   }
-  try {
-    showMessage(tui, `Inviting ${email}...`);
-    const result = await sdk.contacts.addContacts(tui.authContext.arbi, [email.trim()]);
-    const contact = result[0];
-    if (contact?.status === "registered") {
-      showMessage(
-        tui,
-        `${colors.success("Added")} ${email} \u2014 already registered. You can DM them with @${email.split("@")[0]}`
-      );
+];
+var MAX_PASSAGE_CHARS = 2e3;
+var CitationPanel = class extends piTui.Box {
+  constructor(citation, passageIndex = 0) {
+    super(1, 1);
+    const chunk = citation.chunks[passageIndex];
+    const docTitle = chunk?.metadata?.doc_title ?? "Unknown document";
+    const page = chunk?.metadata?.page_number;
+    const headerParts = [
+      `${colors.accentBold(`[Citation ${citation.citationNum}]`)} ${colors.textBold(docTitle)}`
+    ];
+    if (page != null) {
+      headerParts.push(colors.muted(`  Page ${page}`));
+    }
+    if (citation.chunks.length > 1) {
+      headerParts.push(colors.muted(`  Passage ${passageIndex + 1}/${citation.chunks.length}`));
+    }
+    this.addChild(new piTui.Text(headerParts.join(""), 0, 0));
+    this.addChild(new piTui.Text("", 0, 0));
+    this.addChild(new piTui.Text(colors.textBold("Statement:"), 0, 0));
+    this.addChild(new piTui.Text(`  ${citation.citationData.statement}`, 0, 0));
+    this.addChild(new piTui.Text("", 0, 0));
+    this.addChild(new piTui.Text(colors.textBold("Passage:"), 0, 0));
+    if (chunk) {
+      let content = chunk.content;
+      if (content.length > MAX_PASSAGE_CHARS) {
+        content = content.slice(0, MAX_PASSAGE_CHARS) + "\n...(truncated)";
+      }
+      this.addChild(new piTui.Markdown(content, 0, 0, markdownTheme));
     } else {
-      showMessage(
-        tui,
-        `${colors.success("Invited")} ${email} \u2014 invitation sent. They'll appear in /contacts once they register.`
+      this.addChild(new piTui.Text(colors.muted("  (no passage data available)"), 0, 0));
+    }
+    this.addChild(new piTui.Text("", 0, 0));
+    const hints = [];
+    if (citation.chunks.length > 1) {
+      hints.push(
+        `/cite ${citation.citationNum} <1-${citation.chunks.length}> to view other passages`
       );
     }
-  } catch (err) {
-    showMessage(tui, `Failed to invite contact: ${sdk.getErrorMessage(err)}`, "error");
+    hints.push("Press Escape to close");
+    this.addChild(new piTui.Text(colors.muted(hints.join("  \xB7  ")), 0, 0));
   }
-}
-async function handleListConversations(tui) {
-  if (!tui.wsContext) {
-    showMessage(tui, "No workspace selected. Use /workspace <id> first.", "warning");
-    return;
-  }
-  try {
-    const convs = await sdk.conversations.listConversations(tui.wsContext.arbi);
-    if (convs.length === 0) {
-      showMessage(tui, "No conversations in this workspace.");
-    } else {
-      const lines = convs.map((c) => `  ${c.external_id}  ${c.title ?? "(untitled)"}`);
-      showMessage(tui, [`Conversations (${convs.length}):`, "", ...lines].join("\n"));
+};
+
+// src/commands/citation.ts
+function handleCite(ctx) {
+  const { tui, args } = ctx;
+  if (!tui.lastMetadata) {
+    return "No citation data available. Ask a question first.";
+  }
+  const count = sdk.countCitations(tui.lastMetadata);
+  if (count === 0) {
+    return "The last response contained no citations.";
+  }
+  const resolved = sdk.resolveCitations(tui.lastMetadata);
+  if (args.length >= 1) {
+    const citationNum = args[0];
+    const citation = resolved.find((r) => r.citationNum === citationNum);
+    if (!citation) {
+      return `Citation [${citationNum}] not found. Use /cite to list all citations.`;
     }
-  } catch (err) {
-    showMessage(tui, `Failed to list conversations: ${sdk.getErrorMessage(err)}`, "error");
-  }
-}
-function handleNewConversation(tui) {
-  tui.state.conversationMessageId = null;
-  tui.store.clearChatSession();
-  showMessage(tui, "Started new conversation.");
-}
-function handleStatus(tui) {
-  const { state } = tui;
-  const lines = [
-    `Authenticated: ${state.isAuthenticated ? colors.success("yes") : colors.error("no")}`,
-    `Workspace: ${state.workspaceName ? colors.accent(state.workspaceName) : colors.muted("none")}`,
-    `Workspace ID: ${state.workspaceId ?? colors.muted("none")}`,
-    `Conversation: ${state.conversationMessageId ? colors.muted(state.conversationMessageId) : colors.muted("new")}`,
-    `Status: ${state.activityStatus}`,
-    `WebSocket: ${tui.wsConnected ? colors.success("connected") : colors.muted("disconnected")}`
-  ];
-  showMessage(tui, lines.join("\n"));
-}
-async function handleUpload(tui, filePath) {
-  const wsCtx = tui.wsContext;
-  if (!wsCtx) {
-    showMessage(tui, "No workspace selected. Use /workspace <id> first.", "warning");
-    return;
-  }
-  if (!filePath.trim()) {
-    showMessage(tui, "Usage: /upload <file-path>", "warning");
-    return;
-  }
-  try {
-    showMessage(tui, `Uploading ${filePath.trim()}...`);
-    const result = await sdk.documentsNode.uploadLocalFile(
-      {
-        baseUrl: wsCtx.config.baseUrl,
-        accessToken: wsCtx.accessToken,
-        workspaceKeyHeader: wsCtx.workspaceKeyHeader
-      },
-      wsCtx.workspaceId,
-      filePath.trim()
-    );
-    const ids = result.doc_ext_ids.join(", ");
-    showMessage(tui, `${colors.success("Uploaded")} ${result.fileName} \u2014 doc ID(s): ${ids}`);
-    if (result.duplicates && result.duplicates.length > 0) {
-      showMessage(tui, `Duplicates detected: ${result.duplicates.join(", ")}`, "warning");
+    let passageIndex = 0;
+    if (args.length >= 2) {
+      const p = parseInt(args[1], 10);
+      if (isNaN(p) || p < 1 || p > citation.chunks.length) {
+        return `Passage must be between 1 and ${citation.chunks.length}.`;
+      }
+      passageIndex = p - 1;
     }
-  } catch (err) {
-    showMessage(tui, `Failed to upload: ${sdk.getErrorMessage(err)}`, "error");
-  }
-}
-async function handleDelete(tui, docId) {
-  if (!tui.wsContext) {
-    showMessage(tui, "No workspace selected. Use /workspace <id> first.", "warning");
-    return;
-  }
-  if (!docId?.trim()) {
-    showMessage(tui, "Usage: /delete <doc-id>  (use /docs to list document IDs)", "warning");
+    const panel = new CitationPanel(citation, passageIndex);
+    tui.showCitationOverlay(panel);
     return;
   }
-  try {
-    showMessage(tui, `Deleting document ${docId}...`);
-    await sdk.documents.deleteDocuments(tui.wsContext.arbi, [docId.trim()]);
-    showMessage(tui, `${colors.success("Deleted")} document ${docId}`);
-  } catch (err) {
-    showMessage(tui, `Failed to delete document: ${sdk.getErrorMessage(err)}`, "error");
+  const summaries = sdk.summarizeCitations(resolved);
+  const lines = [`Citations (${summaries.length}):
+`];
+  for (const s of summaries) {
+    const page = s.pageNumber != null ? `, p${s.pageNumber}` : "";
+    const chunks = s.chunkCount > 1 ? ` (${s.chunkCount} passages)` : "";
+    const truncated = s.statement.length > 100 ? s.statement.slice(0, 100).replace(/\n/g, " ").trim() + "..." : s.statement.replace(/\n/g, " ").trim();
+    lines.push(
+      `  ${colors.accent(`[${s.citationNum}]`)} ${colors.textBold(s.docTitle)}${page}${chunks}`
+    );
+    lines.push(`      ${colors.muted(truncated)}`);
   }
+  lines.push(colors.muted("\nUse /cite <N> to view full passage."));
+  return lines;
 }
-function handleLogout(tui) {
-  tui.store.deleteCredentials();
-  tui.store.updateConfig({ selectedWorkspaceId: void 0 });
-  tui.store.clearChatSession();
-  tui.authContext = null;
-  tui.state.isAuthenticated = false;
-  tui.state.workspaceId = null;
-  tui.state.workspaceName = null;
-  tui.state.conversationMessageId = null;
-  showMessage(tui, "Logged out. Use /login to authenticate again.");
-}
-async function handleHealth(tui) {
-  if (!requireAuth(tui)) return;
-  try {
-    const data = await sdk.health.getHealth(tui.authContext.arbi);
-    const lines = ["System Health:", ""];
-    const status = data.status;
-    if (status) {
-      const statusColor = status === "healthy" ? colors.success(status) : colors.warning(status);
-      lines.push(`  Status: ${statusColor}`);
-    }
-    const services = data.services;
-    if (services) {
-      lines.push("", "  Services:");
-      for (const [name, info] of Object.entries(services)) {
-        const svc = info;
-        const svcStatus = svc.status;
-        const statusStr = svcStatus ? svcStatus === "healthy" ? colors.success(svcStatus) : colors.error(svcStatus) : colors.muted("unknown");
-        lines.push(`    ${name}: ${statusStr}`);
-      }
-    }
-    showMessage(tui, lines.join("\n"));
-  } catch (err) {
-    showMessage(tui, `Failed to fetch health status: ${sdk.getErrorMessage(err)}`, "error");
-  }
-}
-async function handleModels(tui) {
-  if (!requireAuth(tui)) return;
-  try {
-    const data = await sdk.health.getHealthModels(tui.authContext.arbi);
-    const models = Array.isArray(data) ? data : data.data ?? [];
-    if (models.length === 0) {
-      showMessage(tui, "No models available.");
-      return;
-    }
-    const lines = [`Models (${models.length}):`, ""];
-    for (const m of models) {
-      const model = m;
-      const name = model.model_name ?? model.name ?? "unknown";
-      const provider = model.provider ?? "";
-      const apiType = model.api_type ?? "";
-      const parts = [colors.accent(name)];
-      if (provider) parts.push(`provider: ${provider}`);
-      if (apiType) parts.push(`api: ${apiType}`);
-      lines.push(`  ${parts.join("  ")}`);
-    }
-    showMessage(tui, lines.join("\n"));
-  } catch (err) {
-    showMessage(tui, `Failed to fetch models: ${sdk.getErrorMessage(err)}`, "error");
+var citationCommands = [
+  {
+    name: "cite",
+    description: "Browse citations from last response",
+    requires: "none",
+    argHint: "[N] [passage]",
+    run: (ctx) => handleCite(ctx)
+  },
+  {
+    name: "refs",
+    description: "Browse citations from last response",
+    requires: "none",
+    hidden: true,
+    run: (ctx) => handleCite(ctx)
   }
+];
+
+// src/commands/index.ts
+function registerAllCommands() {
+  registerCommands(generalCommands);
+  registerCommands(authCommands);
+  registerCommands(workspaceCommands);
+  registerCommands(documentCommands);
+  registerCommands(conversationCommands);
+  registerCommands(tagCommands);
+  registerCommands(miscCommands);
+  registerCommands(citationCommands);
 }
 async function streamResponse(tui, response) {
   tui.chatLog.startAssistant();
   tui.state.activityStatus = "streaming";
   tui.requestRender();
   let accumulated = "";
+  let elapsedTime = null;
+  let firstToken = true;
   const callbacks = {
     onStreamStart: (data) => {
       if (data.assistant_message_ext_id) {
@@ -897,6 +1335,10 @@ async function streamResponse(tui, response) {
       }
     },
     onToken: (content) => {
+      if (firstToken) {
+        firstToken = false;
+        tui.chatLog.clearActiveSteps();
+      }
       accumulated += content;
       tui.chatLog.updateAssistant(accumulated);
       tui.requestRender();
@@ -908,6 +1350,9 @@ async function streamResponse(tui, response) {
         tui.requestRender();
       }
     },
+    onElapsedTime: (t) => {
+      elapsedTime = t;
+    },
     onError: (message) => {
       tui.chatLog.addSystem(`Stream error: ${message}`, "error");
       tui.requestRender();
@@ -916,6 +1361,13 @@ async function streamResponse(tui, response) {
   try {
     const result = await sdk.streamSSE(response, callbacks);
     tui.chatLog.finalizeAssistant();
+    tui.lastMetadata = result.metadata ?? null;
+    const summary = sdk.formatStreamSummary(result, elapsedTime);
+    if (summary) {
+      const refs = sdk.countCitations(result.metadata ?? null);
+      const refSuffix = refs > 0 ? ` \xB7 ${refs} ref${refs === 1 ? "" : "s"}` : "";
+      tui.chatLog.addSummary(`[${summary}${refSuffix}]`);
+    }
     tui.state.activityStatus = "idle";
     tui.requestRender();
     return result;
@@ -927,6 +1379,7 @@ async function streamResponse(tui, response) {
     throw err;
   }
 }
+init_tui_helpers();
 function deriveEncryptionKeypair(signingPrivateKeyBase64) {
   const signingPrivateKey = client.base64ToBytes(signingPrivateKeyBase64);
   const ed25519PublicKey = signingPrivateKey.slice(32, 64);
@@ -1133,7 +1586,7 @@ async function connectTuiWebSocket(options) {
       baseUrl,
       accessToken,
       onMessage: (msg) => handleMessage(msg, toasts, tui ?? null),
-      onClose: (_code, _reason) => {
+      onClose: () => {
         toasts.show("WebSocket disconnected", "warning", DURATION_DEFAULT);
       },
       onReconnecting: (attempt, maxRetries) => {
@@ -1177,6 +1630,12 @@ var ArbiTui = class {
   encryptionKeyPair = null;
   /** Current DM channel (null = AI chat mode). */
   dmChannel = null;
+  /** Last response metadata — used by /cite for citation browsing. */
+  lastMetadata = null;
+  /** Active citation overlay handle (null when not showing). */
+  citationOverlay = null;
+  /** Input listener ID for overlay dismiss (null when no overlay). */
+  overlayInputListener = null;
   constructor(store) {
     this.store = store;
     this.state = {
@@ -1186,6 +1645,7 @@ var ArbiTui = class {
       activityStatus: "idle",
       isAuthenticated: false
     };
+    registerAllCommands();
     this.tui = new piTui.TUI(new piTui.ProcessTerminal());
     this.header = new piTui.Text(formatHeader(null, "starting..."), 1, 0);
     this.chatLog = new ChatLog();
@@ -1200,11 +1660,11 @@ var ArbiTui = class {
     this.tui.setFocus(this.editor);
   }
   // ── Lifecycle ──────────────────────────────────────────────────────────
-  /** Start the TUI event loop. */
+  /** Start the TUI event loop (clears screen for fullscreen layout). */
   start() {
     this.tui.start();
     this.updateHeader();
-    this.tui.requestRender();
+    this.tui.requestRender(true);
   }
   /** Gracefully shut down the TUI and exit. */
   shutdown() {
@@ -1237,12 +1697,12 @@ var ArbiTui = class {
     this.tui.setFocus(this.editor);
     this.tui.start();
     this.updateHeader();
-    this.tui.requestRender();
+    this.tui.requestRender(true);
   }
   /** Create and wire a new editor instance. */
   createEditor() {
     const editor = new ArbiEditor(this.tui);
-    editor.setAutocompleteProvider(new piTui.CombinedAutocompleteProvider(commands));
+    editor.setAutocompleteProvider(new piTui.CombinedAutocompleteProvider(toSlashCommands()));
     editor.onSubmit = (text) => this.handleSubmit(text);
     editor.onEscape = () => this.handleAbort();
     editor.onCtrlC = () => this.shutdown();
@@ -1312,7 +1772,7 @@ var ArbiTui = class {
       return;
     }
     if (trimmed.startsWith("/")) {
-      const handled = await handleCommand(this, trimmed);
+      const handled = await dispatchCommand(this, trimmed);
       if (handled) return;
     }
     if (this.dmChannel) {
@@ -1385,6 +1845,37 @@ var ArbiTui = class {
       this.header.setText(formatHeader(this.state.workspaceName, statusText));
     }
   }
+  // ── Citation overlay ───────────────────────────────────────────────────
+  /** Show a component as a centered overlay (used by /cite). */
+  showCitationOverlay(component) {
+    this.dismissCitationOverlay();
+    this.citationOverlay = this.tui.showOverlay(component, {
+      anchor: "center",
+      width: "80%",
+      maxHeight: "80%",
+      margin: 2
+    });
+    this.overlayInputListener = this.tui.addInputListener((data) => {
+      if (piTui.matchesKey(data, piTui.Key.escape)) {
+        this.dismissCitationOverlay();
+        return { consume: true };
+      }
+      return void 0;
+    });
+    this.tui.requestRender();
+  }
+  /** Dismiss the active citation overlay. */
+  dismissCitationOverlay() {
+    if (this.citationOverlay) {
+      this.citationOverlay.hide();
+      this.citationOverlay = null;
+    }
+    if (this.overlayInputListener) {
+      this.overlayInputListener();
+      this.overlayInputListener = null;
+    }
+    this.tui.requestRender();
+  }
   // ── DM channel accessors (used by dm-handler) ────────────────────────────
   /** Current DM channel (null = AI chat mode). */
   get currentDmChannel() {