@rubixkube/rubix 0.0.1

package/dist/ui/App.js

@@ -0,0 +1,1766 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { exec, execSync, spawn } from "child_process";
+import { Box, Text, useApp, useInput } from "ink";
+import { Select, Spinner, StatusMessage } from "@inkjs/ui";
+import { clearAuthConfig, loadAuthConfig, saveAuthConfig } from "../core/auth-store.js";
+import { authenticateWithDeviceFlow } from "../core/device-auth.js";
+import { isFolderTrusted, trustFolder, untrustFolder } from "../core/trust-store.js";
+import { createSession, fetchChatHistory, firstHealthyCluster, getOrCreateSession, listClusters, listSessions, streamChat, StreamError, updateSessionState, } from "../core/rubix-api.js";
+import { readFileContext, fetchUrlContext, formatContextBlock, } from "../core/file-context.js";
+import { ChatTranscript } from "./components/ChatTranscript.js";
+import { Composer } from "./components/Composer.js";
+import { DashboardPanel } from "./components/DashboardPanel.js";
+import { SplashScreen } from "./components/SplashScreen.js";
+import { TrustDisclaimer } from "./components/TrustDisclaimer.js";
+import { getConfig } from "../config/env.js";
+import { RUBIX_THEME } from "./theme.js";
+// Auth | Session | Input | Navigation | Help
+const SLASH_COMMANDS = [
+    { name: "/login", description: "Authenticate with device code flow" },
+    { name: "/logout", description: "Clear local auth and sign out" },
+    { name: "/status", description: "Show auth and session status" },
+    { name: "/resume", description: "Resume a previous conversation" },
+    { name: "/new", description: "Start a fresh conversation" },
+    { name: "/cluster", description: "Switch active cluster" },
+    { name: "/paste", description: "Insert clipboard content (avoids terminal paste truncation)" },
+    { name: "/send-shell-output", description: "Send last shell command output to Rubix" },
+    { name: "/clear", description: "Clear current conversation history" },
+    { name: "/rename", description: "Rename current session" },
+    { name: "/console", description: "Open web dashboard in browser" },
+    { name: "/docs", description: "Open docs in browser" },
+    { name: "/help", description: "Toggle shortcut/help panel" },
+    { name: "/exit", description: "Exit Rubix CLI" },
+    { name: "/quit", description: "Exit Rubix CLI (alias of /exit)" },
+    { name: "/untrust", description: "Remove current folder from trusted list" },
+];
+// Submit | New line | Panels | Leader
+const SHORTCUT_ROWS = [
+    { key: "Enter", action: "submit" },
+    { key: "Shift+Enter / Cmd+Enter", action: "new line" },
+    { key: "Esc", action: "close panel / clear input / Esc twice to cancel stream" },
+    { key: "Ctrl+C", action: "pause stream if running; exit when idle (or second press)" },
+    { key: "Ctrl+L", action: "clear terminal screen" },
+    { key: "Ctrl+D", action: "exit when composer empty" },
+    { key: "Ctrl+O", action: "toggle full workflow on last response" },
+    { key: "Ctrl+A / Ctrl+E", action: "cursor to start / end of line" },
+    { key: "Ctrl+K / Ctrl+U", action: "kill to end / start of line" },
+    { key: "?", action: "toggle shortcuts" },
+    { key: "Ctrl+X then H/C/Q", action: "help / clear / quit" },
+];
+const SESSION_PAGE_SIZE = 100;
+const SESSION_MAX_PAGES = 10;
+const STREAM_THROTTLE_MS = 80;
+const IDLE_ACTIVITY_WORDS = [
+    "Boogieing",
+    "Booping",
+    "Bootstrapping",
+    "Burrowing",
+    "Calculating",
+    "Choreographing",
+    "Churning",
+    "Composing",
+    "Crunching",
+    "Dilly-dallying",
+    "Embellishing",
+    "Finagling",
+    "Forging",
+    "Harmonizing",
+    "Hashing",
+    "Ideating",
+    "Marinating",
+    "Philosophising",
+    "Reticulating",
+    "Sketching",
+    "Sublimating",
+    "Thinking",
+    "Twisting",
+    "Undulating",
+    "Unravelling",
+    "Wrangling",
+    "Zigzagging",
+];
+function createMessage(role, content) {
+    return {
+        id: `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        role,
+        content,
+        ts: Date.now(),
+    };
+}
+function fuzzyScore(query, candidate) {
+    if (!query)
+        return 1;
+    let score = 0;
+    let qi = 0;
+    const q = query.toLowerCase();
+    const c = candidate.toLowerCase();
+    for (let i = 0; i < c.length && qi < q.length; i += 1) {
+        if (c[i] === q[qi]) {
+            score += 3;
+            if (i === qi)
+                score += 1;
+            qi += 1;
+        }
+        else {
+            score -= 0.05;
+        }
+    }
+    if (qi < q.length)
+        return Number.NEGATIVE_INFINITY;
+    if (c.startsWith(q))
+        score += 5;
+    if (c.includes(q))
+        score += 2;
+    return score;
+}
+function sessionLabel(sessionId) {
+    if (!sessionId)
+        return "no session";
+    if (sessionId.length <= 12)
+        return sessionId;
+    return `${sessionId.slice(0, 12)}…`;
+}
+function setTerminalTitle(title) {
+    if (typeof process.stdout?.write === "function") {
+        process.stdout.write(`\x1b]0;${title}\x07`);
+    }
+}
+function compactLine(value, max = 64) {
+    const normalized = (value ?? "").replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return null;
+    if (normalized.length <= max)
+        return normalized;
+    return `${normalized.slice(0, Math.max(0, max - 3))}...`;
+}
+function extractThoughtTitle(content, max = 58) {
+    const plain = (content ?? "")
+        .replace(/```[\s\S]*?```/g, "")
+        .replace(/`([^`]*)`/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/\*([^*]+)\*/g, "$1")
+        .replace(/^#+\s+/gm, "")
+        .replace(/\[(.*?)\]\([^)]*\)/g, "$1")
+        .trim();
+    const firstLine = plain.split("\n")[0]?.trim() ?? "";
+    if (!firstLine)
+        return "Thinking";
+    if (firstLine.length <= max)
+        return firstLine;
+    return `${firstLine.slice(0, max - 3)}...`;
+}
+function formatTimeAgo(isoString) {
+    const date = new Date(isoString);
+    const now = new Date();
+    const seconds = Math.floor((now.getTime() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return "just now";
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days === 1)
+        return "yesterday";
+    if (days < 7)
+        return `${days}d ago`;
+    if (days < 30)
+        return `${Math.floor(days / 7)}w ago`;
+    return `${Math.floor(days / 30)}mo ago`;
+}
+export function App({ initialSessionId, seedPrompt }) {
+    const { exit } = useApp();
+    const cwd = useMemo(() => process.cwd(), []);
+    const agentName = useMemo(() => process.env.RUBIX_AGENT_NAME ?? "Rubix Agent", []);
+    const [authConfig, setAuthConfig] = useState(null);
+    const [sessionId, setSessionId] = useState(initialSessionId ?? null);
+    const [status, setStatus] = useState("booting");
+    const [composer, setComposer] = useState("");
+    const [isStreaming, setIsStreaming] = useState(false);
+    const [isAuthLoading, setIsAuthLoading] = useState(true);
+    const [isAuthenticated, setIsAuthenticated] = useState(false);
+    const [folderTrustCheckComplete, setFolderTrustCheckComplete] = useState(false);
+    const [isFolderTrustedStatus, setIsFolderTrustedStatus] = useState(false);
+    const [showTrustDisclaimer, setShowTrustDisclaimer] = useState(false);
+    const [activeUser, setActiveUser] = useState(null);
+    const [isCommandRunning, setIsCommandRunning] = useState(false);
+    const [showHelp, setShowHelp] = useState(false);
+    const [leaderMode, setLeaderMode] = useState(false);
+    const [slashPanelDismissed, setSlashPanelDismissed] = useState(false);
+    const [showSessionsPanel, setShowSessionsPanel] = useState(false);
+    const [sessionsPanelLoading, setSessionsPanelLoading] = useState(false);
+    const [sessionsPanelError, setSessionsPanelError] = useState(null);
+    const [sessionItems, setSessionItems] = useState([]);
+    const [sessionsHasMore, setSessionsHasMore] = useState(false);
+    const [sessionsSearchQuery, setSessionsSearchQuery] = useState("");
+    const [recentSessions, setRecentSessions] = useState([]);
+    const [sessionTitle, setSessionTitle] = useState(null);
+    const [composerResetToken, setComposerResetToken] = useState(0);
+    const [lastError, setLastError] = useState(null);
+    const [escClearArmed, setEscClearArmed] = useState(false);
+    const [messages, setMessages] = useState([]);
+    const [recentActivity, setRecentActivity] = useState([]);
+    const [clusters, setClusters] = useState([]);
+    const [selectedCluster, setSelectedCluster] = useState(null);
+    const [showClusterPanel, setShowClusterPanel] = useState(false);
+    const [clusterPanelLoading, setClusterPanelLoading] = useState(false);
+    const [clusterPanelError, setClusterPanelError] = useState(null);
+    const [pendingClusterSwitch, setPendingClusterSwitch] = useState(null);
+    const [slashSelectedIndex, setSlashSelectedIndex] = useState(0);
+    const [sessionsSelectedIndex, setSessionsSelectedIndex] = useState(0);
+    const [atFilePanelDismissed, setAtFilePanelDismissed] = useState(false);
+    const [atFileCurrentDir, setAtFileCurrentDir] = useState(cwd);
+    const [atFileList, setAtFileList] = useState([]);
+    const [atFileSelectedIndex, setAtFileSelectedIndex] = useState(0);
+    const [shellMode, setShellMode] = useState(false);
+    const [workflowViewMode, setWorkflowViewMode] = useState("detailed");
+    const streamController = useRef(null);
+    const streamAssistantRef = useRef(null);
+    const lastShellRef = useRef(null);
+    const bootPromptHandled = useRef(false);
+    const streamThrottleRef = useRef(null);
+    const [splashSelectionMade, setSplashSelectionMade] = useState(false);
+    const splashActionHandled = useRef(false);
+    const [idleActivityTick, setIdleActivityTick] = useState(0);
+    const [workflowExpandedIds, setWorkflowExpandedIds] = useState(new Set());
+    const [messageQueue, setMessageQueue] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const promptHistory = useMemo(() => {
+        const userContents = messages
+            .filter((m) => m.role === "user")
+            .map((m) => m.content);
+        const deduped = [];
+        for (let i = 0; i < userContents.length; i += 1) {
+            if (i === 0 || userContents[i] !== userContents[i - 1]) {
+                deduped.push(userContents[i]);
+            }
+        }
+        return deduped.reverse();
+    }, [messages]);
+    const canSubmit = useMemo(() => !isStreaming && !isCommandRunning, [isStreaming, isCommandRunning]);
+    const showSetupSplash = useMemo(() => !isAuthLoading && !isAuthenticated, [isAuthLoading, isAuthenticated]);
+    const showDashboard = useMemo(() => !isAuthLoading && isAuthenticated, [isAuthLoading, isAuthenticated]);
+    const slashModeActive = useMemo(() => composer.startsWith("/") && !isStreaming && !isCommandRunning && !isAuthLoading, [composer, isAuthLoading, isCommandRunning, isStreaming]);
+    const slashQuery = useMemo(() => composer.slice(1).trim().toLowerCase(), [composer]);
+    const atModeActive = useMemo(() => composer.startsWith("@") &&
+        !/^@(file|url)\s/.test(composer) &&
+        !isStreaming &&
+        !isCommandRunning &&
+        !isAuthLoading, [composer, isAuthLoading, isCommandRunning, isStreaming]);
+    const atFileQuery = useMemo(() => composer.slice(1).trim().toLowerCase(), [composer]);
+    const atFileFiltered = useMemo(() => {
+        if (!atFileQuery)
+            return atFileList;
+        const q = atFileQuery.toLowerCase();
+        return atFileList.filter((name) => name.toLowerCase().includes(q));
+    }, [atFileList, atFileQuery]);
+    const selectedAtFile = useMemo(() => {
+        if (atFileFiltered.length === 0)
+            return null;
+        return atFileFiltered[atFileSelectedIndex] ?? atFileFiltered[0] ?? null;
+    }, [atFileFiltered, atFileSelectedIndex]);
+    const showAtFilePanel = atModeActive && !atFilePanelDismissed;
+    const slashCandidates = useMemo(() => {
+        if (!slashModeActive)
+            return [];
+        if (!slashQuery)
+            return SLASH_COMMANDS;
+        return SLASH_COMMANDS.map((item) => {
+            const nameScore = fuzzyScore(slashQuery, item.name);
+            const descScore = fuzzyScore(slashQuery, item.description);
+            return { item, nameScore, descScore };
+        })
+            .filter((row) => Number.isFinite(row.nameScore) || Number.isFinite(row.descScore))
+            .sort((a, b) => {
+            // First: name matches (higher score first)
+            if (Number.isFinite(a.nameScore) && !Number.isFinite(b.nameScore))
+                return -1;
+            if (!Number.isFinite(a.nameScore) && Number.isFinite(b.nameScore))
+                return 1;
+            if (Number.isFinite(a.nameScore) && Number.isFinite(b.nameScore))
+                return b.nameScore - a.nameScore;
+            // Second: description matches (higher score first)
+            return b.descScore - a.descScore;
+        })
+            .map((row) => row.item);
+    }, [slashModeActive, slashQuery]);
+    const visibleSlashCandidates = useMemo(() => slashCandidates, [slashCandidates]);
+    const selectedSlashCandidate = useMemo(() => {
+        if (visibleSlashCandidates.length === 0)
+            return null;
+        return visibleSlashCandidates[slashSelectedIndex] ?? visibleSlashCandidates[0] ?? null;
+    }, [visibleSlashCandidates, slashSelectedIndex]);
+    const resetComposer = useCallback((nextValue = "") => {
+        setComposer(nextValue);
+        setComposerResetToken((prev) => prev + 1);
+    }, []);
+    const handleComposerChange = useCallback((newValue) => {
+        setHistoryIndex(-1);
+        if (!shellMode && newValue === "!") {
+            setShellMode(true);
+            setComposer("");
+            setComposerResetToken((prev) => prev + 1);
+            return;
+        }
+        setComposer(newValue);
+    }, [shellMode]);
+    useEffect(() => {
+        if (!composer.startsWith("/")) {
+            setSlashPanelDismissed(false);
+        }
+    }, [composer]);
+    useEffect(() => {
+        if (!composer.startsWith("@")) {
+            setAtFilePanelDismissed(false);
+        }
+    }, [composer]);
+    useEffect(() => {
+        if (atModeActive)
+            setAtFileCurrentDir(cwd);
+    }, [atModeActive, cwd]);
+    useEffect(() => {
+        if (!atModeActive)
+            return;
+        let cancelled = false;
+        fs.readdir(atFileCurrentDir, { withFileTypes: true })
+            .then((entries) => {
+            if (cancelled)
+                return;
+            const sorted = entries
+                .sort((a, b) => {
+                if (a.isDirectory() && !b.isDirectory())
+                    return -1;
+                if (!a.isDirectory() && b.isDirectory())
+                    return 1;
+                return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
+            })
+                .map((e) => (e.isDirectory() ? `${e.name}/` : e.name));
+            const withParent = atFileCurrentDir !== cwd ? ["../", ...sorted] : sorted;
+            setAtFileList(withParent);
+            setAtFileSelectedIndex(0);
+        })
+            .catch(() => {
+            if (!cancelled)
+                setAtFileList([]);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [atModeActive, atFileCurrentDir, cwd]);
+    useEffect(() => {
+        setAtFileSelectedIndex((prev) => atFileFiltered.length === 0 ? 0 : Math.min(prev, atFileFiltered.length - 1));
+    }, [atFileFiltered]);
+    useEffect(() => {
+        const title = sessionTitle?.trim() || (sessionId ? `Session ${sessionLabel(sessionId)}` : "Rubix");
+        setTerminalTitle(title);
+        return () => {
+            setTerminalTitle("Rubix");
+        };
+    }, [sessionId, sessionTitle]);
+    useEffect(() => {
+        setSlashSelectedIndex(0);
+    }, [visibleSlashCandidates]);
+    useEffect(() => {
+        if (slashModeActive && (showSessionsPanel || showClusterPanel)) {
+            setShowSessionsPanel(false);
+            setShowClusterPanel(false);
+        }
+    }, [showSessionsPanel, showClusterPanel, slashModeActive]);
+    useEffect(() => {
+        if (atModeActive && (showSessionsPanel || showClusterPanel)) {
+            setShowSessionsPanel(false);
+            setShowClusterPanel(false);
+        }
+    }, [atModeActive, showSessionsPanel, showClusterPanel]);
+    const prevShowSetupSplash = useRef(showSetupSplash);
+    useEffect(() => {
+        if (showSetupSplash && !prevShowSetupSplash.current) {
+            setSplashSelectionMade(false);
+            splashActionHandled.current = false;
+        }
+        prevShowSetupSplash.current = showSetupSplash;
+    }, [showSetupSplash]);
+    useEffect(() => {
+        return () => {
+            streamController.current?.abort();
+        };
+    }, []);
+    const isBusy = isStreaming || isCommandRunning || status.includes("auth") || status.includes("session");
+    useEffect(() => {
+        if (!isBusy)
+            return;
+        const id = setInterval(() => setIdleActivityTick((t) => t + 1), 2000);
+        return () => clearInterval(id);
+    }, [isBusy]);
+    const addSystemMessage = useCallback((content) => {
+        setMessages((prev) => {
+            const last = prev[prev.length - 1];
+            if (last?.role === "system" && last.content === content)
+                return prev;
+            return [...prev, createMessage("system", content)];
+        });
+    }, []);
+    const recordActivity = useCallback((entry) => {
+        setRecentActivity((prev) => [entry, ...prev.filter((value) => value !== entry)].slice(0, 8));
+    }, []);
+    const updateAssistantMessage = useCallback((assistantId, updater) => {
+        setMessages((prev) => prev.map((message) => {
+            if (message.id !== assistantId)
+                return message;
+            return updater(message);
+        }));
+    }, []);
+    const failAssistantMessage = useCallback((assistantId, message) => {
+        updateAssistantMessage(assistantId, (previous) => ({
+            ...previous,
+            content: previous.content.trim().length > 0 ? previous.content : `Unable to respond: ${message}`,
+            isAccumulating: false,
+        }));
+        setLastError(message);
+        addSystemMessage(message);
+    }, [addSystemMessage, updateAssistantMessage]);
+    const ensureSession = useCallback(async (config, preferredId, clusterIdOverride) => {
+        const clusterId = clusterIdOverride ?? selectedCluster?.cluster_id;
+        const resolved = await getOrCreateSession(config, preferredId, clusterId);
+        setSessionId(resolved);
+        return resolved;
+    }, [selectedCluster?.cluster_id]);
+    const openSessionsPanel = useCallback(async () => {
+        if (!authConfig || !isAuthenticated) {
+            addSystemMessage("Not authenticated. Run /login first.");
+            return;
+        }
+        setShowHelp(false);
+        setShowSessionsPanel(true);
+        setSessionsPanelLoading(true);
+        setSessionsPanelError(null);
+        setSessionItems([]);
+        setSessionsHasMore(false);
+        setStatus("loading sessions");
+        try {
+            const loaded = [];
+            let offset = 0;
+            let reachedLimit = false;
+            for (let page = 0; page < SESSION_MAX_PAGES; page += 1) {
+                const pageItems = await listSessions(authConfig, SESSION_PAGE_SIZE, offset);
+                loaded.push(...pageItems);
+                offset += pageItems.length;
+                if (pageItems.length < SESSION_PAGE_SIZE) {
+                    break;
+                }
+                if (page === SESSION_MAX_PAGES - 1) {
+                    reachedLimit = true;
+                }
+            }
+            setSessionItems(loaded);
+            setSessionsHasMore(reachedLimit);
+            setRecentSessions(loaded.slice(0, 2));
+            setLastError(null);
+            setStatus("ready");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            setSessionsPanelError(message);
+            setLastError(`Failed to load sessions: ${message}`);
+            setStatus("ready");
+        }
+        finally {
+            setSessionsPanelLoading(false);
+        }
+    }, [addSystemMessage, authConfig, isAuthenticated]);
+    const openClusterPanel = useCallback(async () => {
+        if (!authConfig || !isAuthenticated) {
+            addSystemMessage("Not authenticated. Run /login first.");
+            return;
+        }
+        setShowHelp(false);
+        setShowSessionsPanel(false);
+        setShowClusterPanel(true);
+        setClusterPanelLoading(true);
+        setClusterPanelError(null);
+        try {
+            const loaded = await listClusters(authConfig);
+            setClusters(loaded);
+            setClusterPanelError(null);
+        }
+        catch (error) {
+            setClusterPanelError(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            setClusterPanelLoading(false);
+        }
+    }, [authConfig, isAuthenticated, addSystemMessage]);
+    const confirmClusterSwitch = useCallback(async () => {
+        if (!pendingClusterSwitch || !authConfig)
+            return;
+        const cluster = pendingClusterSwitch;
+        setPendingClusterSwitch(null);
+        setSelectedCluster(cluster);
+        setStatus("creating session");
+        try {
+            const nextSession = await createSession(authConfig, undefined, cluster.cluster_id);
+            setSessionId(nextSession);
+            setSessionTitle(null);
+            const latestSessions = await listSessions(authConfig, 20, 0).catch(() => []);
+            setRecentSessions(latestSessions.slice(0, 2));
+            setMessages([]);
+            setStatus("ready");
+            addSystemMessage(`Switched to cluster ${cluster.name}. Started new session.`);
+        }
+        catch (error) {
+            setStatus("ready");
+            addSystemMessage(`Failed to start session for cluster: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }, [pendingClusterSwitch, authConfig, addSystemMessage]);
+    const activateSessionById = useCallback((selectedId) => {
+        const selected = sessionItems.find((item) => item.id === selectedId);
+        if (!selected)
+            return;
+        setSessionId(selected.id);
+        setSessionTitle(selected.title ?? null);
+        setMessages([]);
+        setShowSessionsPanel(false);
+        setSessionsSearchQuery("");
+        setSessionsSelectedIndex(0);
+        setLastError(null);
+        setStatus("loading history");
+        if (authConfig) {
+            fetchChatHistory(authConfig, selected.id)
+                .then((history) => {
+                setMessages(history.length > 0 ? history : []);
+                setStatus("ready");
+                addSystemMessage(`Session ${sessionLabel(selected.id)}${selected.title ? ` — ${selected.title}` : ""}${history.length > 0 ? ` · ${history.length} messages loaded` : ""}`);
+            })
+                .catch((err) => {
+                setStatus("ready");
+                addSystemMessage(`Switched to session ${sessionLabel(selected.id)} (history unavailable: ${err instanceof Error ? err.message : String(err)})`);
+            });
+        }
+        else {
+            setStatus("ready");
+            addSystemMessage(`Switched to session ${sessionLabel(selected.id)}${selected.title ? ` — ${selected.title}` : ""}`);
+        }
+    }, [addSystemMessage, authConfig, sessionItems]);
+    useEffect(() => {
+        let cancelled = false;
+        const loadAuth = async () => {
+            try {
+                const cfg = await loadAuthConfig();
+                if (cancelled)
+                    return;
+                const loggedIn = !!cfg?.isAuthenticated && !!(cfg?.idToken ?? cfg?.authToken);
+                setAuthConfig(cfg);
+                setIsAuthenticated(loggedIn);
+                setActiveUser(cfg?.userName ?? cfg?.userEmail ?? null);
+                if (loggedIn && cfg) {
+                    setStatus("loading clusters");
+                    try {
+                        // Load clusters and recent sessions for dashboard display
+                        const [clusterList, recentList] = await Promise.all([
+                            listClusters(cfg).catch((err) => {
+                                if (!cancelled) {
+                                    addSystemMessage(`Could not load clusters: ${err instanceof Error ? err.message : String(err)}`);
+                                }
+                                return [];
+                            }),
+                            listSessions(cfg, 20, 0).catch((err) => {
+                                if (!cancelled) {
+                                    addSystemMessage(`Could not load recent sessions: ${err instanceof Error ? err.message : String(err)}`);
+                                }
+                                return [];
+                            }),
+                        ]);
+                        const firstCluster = firstHealthyCluster(clusterList);
+                        if (!cancelled) {
+                            setClusters(clusterList);
+                            setSelectedCluster(firstCluster);
+                            setRecentSessions(recentList.slice(0, 2));
+                            setStatus("ready");
+                        }
+                    }
+                    catch (error) {
+                        if (!cancelled) {
+                            setStatus("ready");
+                            addSystemMessage(`Failed to load clusters: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                }
+                else {
+                    setStatus("setup");
+                }
+            }
+            catch (error) {
+                if (!cancelled) {
+                    setStatus("setup");
+                    addSystemMessage(`Failed to read auth config: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            finally {
+                if (!cancelled) {
+                    setIsAuthLoading(false);
+                }
+            }
+        };
+        loadAuth().catch(() => {
+            if (!cancelled)
+                setIsAuthLoading(false);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [addSystemMessage, ensureSession, initialSessionId]);
+    // Check folder trust status after authentication
+    useEffect(() => {
+        if (!isAuthenticated || folderTrustCheckComplete)
+            return;
+        let cancelled = false;
+        const checkTrust = async () => {
+            try {
+                const trusted = await isFolderTrusted(cwd);
+                if (!cancelled) {
+                    setIsFolderTrustedStatus(trusted);
+                    setShowTrustDisclaimer(!trusted);
+                    setFolderTrustCheckComplete(true);
+                }
+            }
+            catch (error) {
+                if (!cancelled) {
+                    setIsFolderTrustedStatus(false);
+                    setShowTrustDisclaimer(true);
+                    setFolderTrustCheckComplete(true);
+                }
+            }
+        };
+        checkTrust().catch(() => {
+            if (!cancelled) {
+                setFolderTrustCheckComplete(true);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [isAuthenticated, folderTrustCheckComplete, cwd]);
+    const handleTrustDisclaimer = useCallback(async (action) => {
+        if (action === "exit") {
+            exit();
+        }
+        else if (action === "trust") {
+            try {
+                await trustFolder(cwd);
+                setIsFolderTrustedStatus(true);
+                setShowTrustDisclaimer(false);
+            }
+            catch (error) {
+                addSystemMessage(`Failed to trust folder: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }, [cwd, exit, addSystemMessage]);
+    const handleSlashCommand = useCallback(async (text) => {
+        const [rawCommand] = text.trim().split(/\s+/, 1);
+        const command = rawCommand.toLowerCase();
+        recordActivity(command);
+        switch (command) {
+            case "/console": {
+                const url = "https://console.rubixkube.ai";
+                if (process.platform === "darwin") {
+                    spawn("open", [url], { stdio: "ignore" });
+                }
+                else if (process.platform === "win32") {
+                    spawn("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+                }
+                else {
+                    spawn("xdg-open", [url], { stdio: "ignore" });
+                }
+                addSystemMessage("Opening https://console.rubixkube.ai in your browser.");
+                return;
+            }
+            case "/docs": {
+                const url = "https://docs.rubixkube.ai";
+                if (process.platform === "darwin") {
+                    spawn("open", [url], { stdio: "ignore" });
+                }
+                else if (process.platform === "win32") {
+                    spawn("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+                }
+                else {
+                    spawn("xdg-open", [url], { stdio: "ignore" });
+                }
+                addSystemMessage("Opening https://docs.rubixkube.ai in your browser.");
+                return;
+            }
+            case "/help":
+                setShowHelp((prev) => !prev);
+                return;
+            case "/exit":
+            case "/quit":
+                exit();
+                return;
+            case "/status":
+                addSystemMessage([
+                    `Auth: ${isAuthenticated ? `logged in as ${activeUser ?? "unknown user"}` : "not logged in"}`,
+                    `Session: ${sessionLabel(sessionId)}`,
+                    `State: ${status}`,
+                ].join("\n"));
+                return;
+            case "/logout":
+                streamController.current?.abort();
+                streamController.current = null;
+                await clearAuthConfig();
+                setAuthConfig(null);
+                setIsAuthenticated(false);
+                setActiveUser(null);
+                setSessionId(null);
+                setSessionTitle(null);
+                setStatus("setup");
+                setMessages([]);
+                addSystemMessage("Logged out. Type /login to set up again.");
+                return;
+            case "/login": {
+                if (isAuthenticated && authConfig) {
+                    addSystemMessage(`Already logged in as ${activeUser ?? "user"}.`);
+                    return;
+                }
+                setStatus("auth");
+                addSystemMessage("Starting login flow...");
+                try {
+                    const nextAuth = await authenticateWithDeviceFlow((message) => addSystemMessage(message));
+                    await saveAuthConfig(nextAuth);
+                    setAuthConfig(nextAuth);
+                    setIsAuthenticated(true);
+                    setActiveUser(nextAuth.userName ?? nextAuth.userEmail ?? null);
+                    const clusterList = await listClusters(nextAuth).catch(() => []);
+                    const firstCluster = firstHealthyCluster(clusterList);
+                    setClusters(clusterList);
+                    setSelectedCluster(firstCluster);
+                    const resolved = await ensureSession(nextAuth, undefined, firstCluster?.cluster_id);
+                    const latestSessions = await listSessions(nextAuth, 20, 0).catch(() => []);
+                    setSessionId(resolved);
+                    setRecentSessions(latestSessions.slice(0, 2));
+                    const currentSession = latestSessions.find((s) => s.id === resolved);
+                    if (currentSession?.title)
+                        setSessionTitle(currentSession.title);
+                    setStatus("ready");
+                    setMessages([]);
+                    addSystemMessage(`Login successful${nextAuth.userName ? `, ${nextAuth.userName}` : ""}. Session ${sessionLabel(resolved)}.`);
+                }
+                catch (error) {
+                    setStatus("setup");
+                    addSystemMessage(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                return;
+            }
+            case "/resume": {
+                await openSessionsPanel();
+                return;
+            }
+            case "/new": {
+                if (!authConfig || !isAuthenticated) {
+                    addSystemMessage("Not authenticated. Run /login first.");
+                    return;
+                }
+                setStatus("creating session");
+                try {
+                    const nextSession = await createSession(authConfig, undefined, selectedCluster?.cluster_id);
+                    setSessionId(nextSession);
+                    setSessionTitle(null);
+                    setMessages([]);
+                    setRecentSessions((prev) => {
+                        const now = new Date().toISOString();
+                        const next = {
+                            id: nextSession,
+                            appName: "SRI Agent",
+                            createdAt: now,
+                            updatedAt: now,
+                        };
+                        return [next, ...prev.filter((s) => s.id !== nextSession)].slice(0, 2);
+                    });
+                    setStatus("ready");
+                    addSystemMessage(`Started new conversation ${sessionLabel(nextSession)}.`);
+                }
+                catch (error) {
+                    setStatus("ready");
+                    addSystemMessage(`Failed to start session: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                return;
+            }
+            case "/cluster": {
+                await openClusterPanel();
+                return;
+            }
+            case "/rename": {
+                if (!authConfig || !isAuthenticated) {
+                    addSystemMessage("Not authenticated. Run /login first.");
+                    return;
+                }
+                if (!sessionId) {
+                    addSystemMessage("No active session. Use /new or /resume.");
+                    return;
+                }
+                const rest = text.slice(rawCommand.length).trim();
+                if (!rest) {
+                    addSystemMessage("Usage: /rename <name>");
+                    return;
+                }
+                try {
+                    await updateSessionState(authConfig, sessionId, { session_title: rest });
+                    setSessionTitle(rest);
+                    setRecentSessions((prev) => prev.map((s) => (s.id === sessionId ? { ...s, title: rest } : s)));
+                    addSystemMessage(`Session renamed to: ${rest}`);
+                }
+                catch (error) {
+                    addSystemMessage(`Rename failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                return;
+            }
+            case "/untrust": {
+                if (!authConfig || !isAuthenticated) {
+                    addSystemMessage("Not authenticated. Run /login first.");
+                    return;
+                }
+                await untrustFolder(cwd);
+                setShowTrustDisclaimer(true);
+                setIsFolderTrustedStatus(false);
+                addSystemMessage("Folder untrusted. You'll be prompted to trust again next time.");
+                return;
+            }
+            case "/send-shell-output": {
+                const last = lastShellRef.current;
+                const streamFn = streamAssistantRef.current;
+                if (last && authConfig && isAuthenticated && sessionId && streamFn) {
+                    const prompt = `Here's the output of my last shell command:\n\n\`\`\`\n$ ${last.cmd}\n${last.output}\n\`\`\``;
+                    const assistantId = `${Date.now()}-assistant`;
+                    setMessages((prev) => [
+                        ...prev,
+                        createMessage("user", prompt),
+                        {
+                            id: assistantId,
+                            role: "assistant",
+                            content: "",
+                            ts: Date.now(),
+                            workflow: [],
+                            isAccumulating: true,
+                        },
+                    ]);
+                    streamFn(prompt, assistantId).catch((error) => {
+                        addSystemMessage(`Failed to send: ${error instanceof Error ? error.message : String(error)}`);
+                    });
+                }
+                else if (!last) {
+                    addSystemMessage("No shell command run yet. Use !ls or !pwd first.");
+                }
+                return;
+            }
+            case "/clear":
+                setMessages([]);
+                return;
+            case "/paste": {
+                try {
+                    let text;
+                    if (process.platform === "darwin") {
+                        text = execSync("pbpaste", { encoding: "utf8", maxBuffer: 1024 * 1024 });
+                    }
+                    else if (process.platform === "win32") {
+                        text = execSync('powershell -Command "Get-Clipboard"', {
+                            encoding: "utf8",
+                            maxBuffer: 1024 * 1024,
+                        });
+                    }
+                    else {
+                        try {
+                            text = execSync("xclip -selection clipboard -o", {
+                                encoding: "utf8",
+                                maxBuffer: 1024 * 1024,
+                            });
+                        }
+                        catch {
+                            text = execSync("xsel --clipboard --output", {
+                                encoding: "utf8",
+                                maxBuffer: 1024 * 1024,
+                            });
+                        }
+                    }
+                    const normalized = (text ?? "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+                    if (normalized) {
+                        resetComposer(normalized);
+                        addSystemMessage("Clipboard inserted. Press Enter to send.");
+                    }
+                    else {
+                        addSystemMessage("Clipboard is empty.");
+                    }
+                }
+                catch (err) {
+                    addSystemMessage(`Paste failed: ${err instanceof Error ? err.message : String(err)}. Install pbpaste (macOS), xclip/xsel (Linux), or use PowerShell (Windows).`);
+                }
+                return;
+            }
+            default:
+                addSystemMessage(`Unknown command: ${command}. Use /help.`);
+        }
+    }, [
+        activeUser,
+        addSystemMessage,
+        authConfig,
+        cwd,
+        ensureSession,
+        exit,
+        isAuthenticated,
+        openClusterPanel,
+        openSessionsPanel,
+        recordActivity,
+        resetComposer,
+        sessionId,
+        status,
+        updateSessionState,
+    ]);
+    const handleSplashAction = useCallback((action) => {
+        if (splashActionHandled.current)
+            return;
+        splashActionHandled.current = true;
+        setSplashSelectionMade(true);
+        if (action === "login") {
+            void handleSlashCommand("/login");
+        }
+        else if (action === "exit") {
+            exit();
+        }
+    }, [exit, handleSlashCommand]);
+    const streamAssistant = useCallback(async (prompt, assistantId, messageParts) => {
+        if (!authConfig || !isAuthenticated) {
+            failAssistantMessage(assistantId, "Not authenticated. Run /login first.");
+            return;
+        }
+        let resolvedSession = sessionId;
+        if (!resolvedSession) {
+            try {
+                resolvedSession = await ensureSession(authConfig);
+                setSessionId(resolvedSession);
+            }
+            catch (error) {
+                failAssistantMessage(assistantId, `Failed to initialize session: ${error instanceof Error ? error.message : String(error)}`);
+                return;
+            }
+        }
+        setStatus("streaming");
+        setIsStreaming(true);
+        setLastError(null);
+        streamController.current?.abort();
+        const controller = new AbortController();
+        streamController.current = controller;
+        const throttle = { pending: "", timer: null };
+        streamThrottleRef.current = throttle;
+        const throttledOnText = (text) => {
+            throttle.pending = text;
+            if (!throttle.timer) {
+                throttle.timer = setTimeout(() => {
+                    throttle.timer = null;
+                    updateAssistantMessage(assistantId, (message) => ({
+                        ...message,
+                        content: throttle.pending,
+                        isAccumulating: true,
+                    }));
+                }, STREAM_THROTTLE_MS);
+            }
+        };
+        const workflowSeen = new Set();
+        let sawWorkflowEvent = false;
+        let didTimeOut = false;
+        const timeoutMs = getConfig().streamTimeoutMs;
+        const streamTimeout = setTimeout(() => {
+            didTimeOut = true;
+            controller.abort();
+        }, timeoutMs);
+        try {
+            const streamAttempt = async (targetSessionId, parts) => streamChat({
+                auth: authConfig,
+                sessionId: targetSessionId,
+                message: prompt,
+                messageParts: parts,
+                signal: controller.signal,
+            }, {
+                onText: throttledOnText,
+                onWorkflow: (event) => {
+                    const eventId = typeof event.details?.id === "string" || typeof event.details?.id === "number"
+                        ? String(event.details.id)
+                        : "";
+                    const eventName = typeof event.details?.name === "string" ? event.details.name : "";
+                    const signature = `${event.type}|${eventId}|${eventName}|${event.content.trim().slice(0, 220).toLowerCase()}`;
+                    if (workflowSeen.has(signature))
+                        return;
+                    sawWorkflowEvent = true;
+                    workflowSeen.add(signature);
+                    updateAssistantMessage(assistantId, (message) => ({
+                        ...message,
+                        workflow: (() => {
+                            const existing = [...(message.workflow ?? [])];
+                            const last = existing[existing.length - 1];
+                            if (event.type === "thought") {
+                                if (last?.type === "thought") {
+                                    const incoming = event.content.trim();
+                                    const previous = last.content.trim();
+                                    const isPartial = event.details?.partial === true;
+                                    if (incoming.length > 0 &&
+                                        (isPartial || incoming.startsWith(previous) || previous.startsWith(incoming))) {
+                                        existing[existing.length - 1] = {
+                                            ...last,
+                                            content: incoming.length >= previous.length ? incoming : previous,
+                                            ts: event.ts,
+                                            details: { ...(last.details ?? {}), ...(event.details ?? {}) },
+                                        };
+                                        return existing;
+                                    }
+                                    if (incoming === previous) {
+                                        return existing;
+                                    }
+                                }
+                            }
+                            existing.push(event);
+                            return existing;
+                        })(),
+                        isAccumulating: true,
+                    }));
+                },
+                onSessionMetadata: (metadata) => {
+                    if (metadata.title || metadata.description || metadata.category) {
+                        const meta = [metadata.title, metadata.description, metadata.category].filter(Boolean).join(" · ");
+                        if (meta)
+                            addSystemMessage(`Session updated: ${meta}`);
+                    }
+                    if (metadata.title && sessionId) {
+                        setSessionTitle(metadata.title);
+                        setRecentSessions((prev) => {
+                            const updated = prev.map((s) => s.id === sessionId ? { ...s, title: metadata.title, updatedAt: new Date().toISOString() } : s);
+                            if (!updated.some((s) => s.id === sessionId)) {
+                                return [
+                                    {
+                                        id: sessionId,
+                                        appName: "SRI Agent",
+                                        createdAt: new Date().toISOString(),
+                                        updatedAt: new Date().toISOString(),
+                                        title: metadata.title,
+                                    },
+                                    ...updated,
+                                ].slice(0, 2);
+                            }
+                            return updated;
+                        });
+                    }
+                },
+            });
+            const result = await streamAttempt(resolvedSession, messageParts);
+            updateAssistantMessage(assistantId, (message) => ({
+                ...message,
+                content: result.text || message.content,
+                isAccumulating: false,
+            }));
+            if (!(result.text ?? "").trim()) {
+                const fallback = sawWorkflowEvent
+                    ? "The agent processed your request but didn't produce a final response. Check the workflow above."
+                    : "No response text was returned. Please try again.";
+                updateAssistantMessage(assistantId, (message) => ({
+                    ...message,
+                    content: message.content.trim().length > 0 ? message.content : fallback,
+                    isAccumulating: false,
+                }));
+                if (!sawWorkflowEvent) {
+                    setLastError("No response text was returned by the backend.");
+                    addSystemMessage("No response text was returned by the backend.");
+                }
+            }
+        }
+        catch (error) {
+            const streamError = error instanceof StreamError ? error : undefined;
+            if (streamError?.reason === "user_cancelled" && !didTimeOut) {
+                updateAssistantMessage(assistantId, (message) => ({
+                    ...message,
+                    isAccumulating: false,
+                }));
+                setLastError("Conversation paused.");
+            }
+            else {
+                const reason = didTimeOut
+                    ? `Response timed out after ${Math.round(getConfig().streamTimeoutMs / 1000)} seconds.`
+                    : `Stream failed: ${error instanceof Error ? error.message : String(error)}`;
+                failAssistantMessage(assistantId, reason);
+            }
+        }
+        finally {
+            clearTimeout(streamTimeout);
+            if (streamThrottleRef.current?.timer) {
+                clearTimeout(streamThrottleRef.current.timer);
+                streamThrottleRef.current = null;
+            }
+            if (streamController.current === controller) {
+                streamController.current = null;
+            }
+            setIsStreaming(false);
+            setStatus("ready");
+        }
+    }, [
+        addSystemMessage,
+        authConfig,
+        ensureSession,
+        failAssistantMessage,
+        isAuthenticated,
+        sessionId,
+        updateAssistantMessage,
+    ]);
+    useEffect(() => {
+        streamAssistantRef.current = streamAssistant;
+    }, [streamAssistant]);
+    const submitText = useCallback((text) => {
+        const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        const trimmed = normalized.trim();
+        const firstChar = text[0] ?? "";
+        if (!trimmed)
+            return;
+        setHistoryIndex(-1);
+        if (!canSubmit) {
+            setMessageQueue((prev) => [...prev, trimmed]);
+            resetComposer("");
+            return;
+        }
+        setLastError(null);
+        if (firstChar === "/") {
+            setMessages((prev) => [...prev, createMessage("user", trimmed)]);
+            setIsCommandRunning(true);
+            handleSlashCommand(trimmed)
+                .catch((error) => {
+                const message = `Command failed: ${error instanceof Error ? error.message : String(error)}`;
+                addSystemMessage(message);
+                setLastError(message);
+            })
+                .finally(() => {
+                setIsCommandRunning(false);
+            });
+            return;
+        }
+        if (!isAuthenticated) {
+            addSystemMessage("Setup required. Type /login.");
+            return;
+        }
+        if (trimmed.startsWith("@")) {
+            const fileMatches = [...trimmed.matchAll(/@file\s+(\S+)/g)];
+            const urlMatches = [...trimmed.matchAll(/@url\s+(\S+)/g)];
+            const userMessage = trimmed
+                .replace(/@file\s+\S+/g, " ")
+                .replace(/@url\s+\S+/g, " ")
+                .replace(/\s+/g, " ")
+                .trim();
+            if (fileMatches.length === 0 && urlMatches.length === 0) {
+                if (atFilePanelDismissed) {
+                    setAtFilePanelDismissed(false);
+                    // Fall through — treat as normal message
+                }
+                else {
+                    addSystemMessage("Usage: @file <path> or @url <url> — type @ to browse files");
+                    return;
+                }
+            }
+            else {
+                if (!userMessage) {
+                    addSystemMessage("Add your question after the @ mentions.");
+                    return;
+                }
+                const userMsgId = `user-${Date.now()}`;
+                setMessages((prev) => [
+                    ...prev,
+                    { id: userMsgId, role: "user", content: trimmed, ts: Date.now() },
+                ]);
+                const assistantId = `${Date.now()}-assistant`;
+                setMessages((prev) => [
+                    ...prev,
+                    {
+                        id: assistantId,
+                        role: "assistant",
+                        content: "",
+                        ts: Date.now(),
+                        workflow: [],
+                        isAccumulating: true,
+                    },
+                ]);
+                recordActivity("@ mention");
+                setIsCommandRunning(true);
+                void (async () => {
+                    const parts = [];
+                    try {
+                        // Match console: main message first, then context parts
+                        parts.push({ text: userMessage });
+                        for (const m of fileMatches) {
+                            const result = await readFileContext(m[1], cwd);
+                            parts.push({
+                                text: formatContextBlock(result, "file", result.truncated ? "truncated" : undefined),
+                            });
+                        }
+                        for (const m of urlMatches) {
+                            const result = await fetchUrlContext(m[1]);
+                            parts.push({
+                                text: formatContextBlock(result, "url", result.truncated ? "truncated" : undefined),
+                            });
+                        }
+                        // Update user message with formatted display (for parsing in ChatTranscript)
+                        const displayContent = parts.map((p) => p.text).join("\n\n");
+                        setMessages((prev) => prev.map((m) => (m.id === userMsgId ? { ...m, content: displayContent } : m)));
+                        await streamAssistant(userMessage, assistantId, parts);
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        failAssistantMessage(assistantId, errMsg);
+                    }
+                    finally {
+                        setIsCommandRunning(false);
+                    }
+                })();
+                return;
+            }
+        }
+        if (firstChar === "!") {
+            const cmd = trimmed.slice(1).trim();
+            setMessages((prev) => [...prev, createMessage("user", trimmed)]);
+            if (!cmd) {
+                addSystemMessage("Usage: !<command> — e.g. !ls, !pwd");
+                return;
+            }
+            setIsCommandRunning(true);
+            recordActivity("! shell");
+            exec(cmd, { cwd: cwd, timeout: 30000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+                setIsCommandRunning(false);
+                const out = (stdout ?? "").trim();
+                const errOut = (stderr ?? "").trim();
+                const output = err ? errOut || out || err.message : out || "(no output)";
+                lastShellRef.current = { cmd, output };
+                const hint = "· /send-shell-output to send to Rubix";
+                addSystemMessage(`$ ${cmd}\n${output}\n\n${hint}`);
+            });
+            return;
+        }
+        const assistantId = `${Date.now()}-assistant`;
+        setMessages((prev) => [
+            ...prev,
+            createMessage("user", trimmed),
+            {
+                id: assistantId,
+                role: "assistant",
+                content: "",
+                ts: Date.now(),
+                workflow: [],
+                isAccumulating: true,
+            },
+        ]);
+        recordActivity("chat prompt");
+        streamAssistant(trimmed, assistantId).catch((error) => {
+            const message = `Failed to stream response: ${error instanceof Error ? error.message : String(error)}`;
+            addSystemMessage(message);
+            setLastError(message);
+        });
+    }, [
+        addSystemMessage,
+        atFilePanelDismissed,
+        canSubmit,
+        cwd,
+        failAssistantMessage,
+        handleSlashCommand,
+        isAuthenticated,
+        recordActivity,
+        resetComposer,
+        streamAssistant,
+    ]);
+    useEffect(() => {
+        if (!isStreaming && !isCommandRunning && messageQueue.length > 0) {
+            const [first, ...rest] = messageQueue;
+            setMessageQueue(rest);
+            submitText(first);
+        }
+    }, [isStreaming, isCommandRunning, messageQueue, submitText]);
+    const submitComposer = useCallback((submittedValue) => {
+        const draft = submittedValue ?? composer;
+        const draftTrimmed = draft.trim();
+        const draftSlashModeActive = draftTrimmed.startsWith("/") && !isStreaming && !isCommandRunning && !isAuthLoading;
+        if (draftSlashModeActive && visibleSlashCandidates.length > 0) {
+            const slashToken = draftTrimmed.split(/\s+/, 1)[0]?.toLowerCase();
+            const selected = selectedSlashCandidate ?? visibleSlashCandidates[0];
+            if (selected) {
+                if (selected.name !== slashToken) {
+                    // User navigated to a different item — run it directly
+                    resetComposer("");
+                    submitText(selected.name);
+                    return;
+                }
+                const isExactSlashCommand = !!SLASH_COMMANDS.find((item) => item.name === slashToken);
+                if (!isExactSlashCommand) {
+                    resetComposer(`${selected.name} `);
+                    return;
+                }
+            }
+        }
+        if (shellMode) {
+            if (draftTrimmed) {
+                submitText(`!${draftTrimmed}`);
+                resetComposer("");
+            }
+            setShellMode(false);
+        }
+        else {
+            submitText(draft);
+            resetComposer("");
+        }
+    }, [
+        composer,
+        isAuthLoading,
+        isCommandRunning,
+        isStreaming,
+        selectedSlashCandidate,
+        shellMode,
+        submitText,
+        visibleSlashCandidates,
+        resetComposer,
+    ]);
+    useEffect(() => {
+        if (!seedPrompt || bootPromptHandled.current)
+            return;
+        bootPromptHandled.current = true;
+        setTimeout(() => submitText(seedPrompt), 0);
+    }, [seedPrompt, submitText]);
+    const handleInput = useCallback((input, key) => {
+        if (!key.escape) {
+            setEscClearArmed(false);
+        }
+        // Arrow navigation for slash panel
+        if (showSlashPanel && visibleSlashCandidates.length > 0) {
+            if (key.downArrow) {
+                setSlashSelectedIndex((prev) => Math.min(prev + 1, visibleSlashCandidates.length - 1));
+                return;
+            }
+            if (key.upArrow) {
+                setSlashSelectedIndex((prev) => Math.max(prev - 1, 0));
+                return;
+            }
+        }
+        // Arrow navigation and selection for @ file panel
+        if (showAtFilePanel) {
+            if (key.escape) {
+                setAtFilePanelDismissed(true);
+                return;
+            }
+            if (atFileFiltered.length > 0 && selectedAtFile) {
+                if (key.downArrow) {
+                    setAtFileSelectedIndex((prev) => Math.min(prev + 1, atFileFiltered.length - 1));
+                    return;
+                }
+                if (key.upArrow) {
+                    setAtFileSelectedIndex((prev) => Math.max(prev - 1, 0));
+                    return;
+                }
+                if (key.tab) {
+                    resetComposer(`@${selectedAtFile}`);
+                    return;
+                }
+                if (key.return) {
+                    if (selectedAtFile === "../") {
+                        setAtFileCurrentDir(path.dirname(atFileCurrentDir));
+                        resetComposer("@");
+                        setAtFileSelectedIndex(0);
+                        return;
+                    }
+                    if (selectedAtFile.endsWith("/")) {
+                        setAtFileCurrentDir(path.join(atFileCurrentDir, selectedAtFile.slice(0, -1)));
+                        resetComposer("@");
+                        setAtFileSelectedIndex(0);
+                        return;
+                    }
+                    const relPath = path.relative(cwd, path.join(atFileCurrentDir, selectedAtFile));
+                    resetComposer(`@file ./${relPath} `);
+                    setAtFilePanelDismissed(true);
+                    return;
+                }
+            }
+        }
+        // Arrow navigation for sessions panel
+        const isShowingSlashPanel = slashModeActive && !slashPanelDismissed;
+        if (showSessionsPanel && !isShowingSlashPanel && !showClusterPanel) {
+            const query = sessionsSearchQuery.toLowerCase();
+            const filtered = sessionItems.filter((item) => {
+                const title = (item.title ?? "").toLowerCase();
+                const desc = (item.description ?? "").toLowerCase();
+                return title.includes(query) || desc.includes(query);
+            });
+            if (filtered.length > 0) {
+                if (key.downArrow) {
+                    setSessionsSelectedIndex((prev) => Math.min(prev + 1, filtered.length - 1));
+                    return;
+                }
+                if (key.upArrow) {
+                    setSessionsSelectedIndex((prev) => Math.max(prev - 1, 0));
+                    return;
+                }
+                if (key.return) {
+                    const selected = filtered[sessionsSelectedIndex];
+                    if (selected) {
+                        activateSessionById(selected.id);
+                        setSessionsSelectedIndex(0);
+                    }
+                    return;
+                }
+            }
+        }
+        // Up arrow: edit first queued message when composer is empty
+        if (key.upArrow && messageQueue.length > 0 && composer.trim().length === 0) {
+            const [first, ...rest] = messageQueue;
+            setMessageQueue(rest);
+            resetComposer(first);
+            return;
+        }
+        // Up/Down: prompt history when composer empty, no interactive panels
+        const hasInteractivePanelOpen = showHelp || (slashModeActive && !slashPanelDismissed) || showAtFilePanel || showSessionsPanel || showClusterPanel;
+        if (!hasInteractivePanelOpen &&
+            composer.trim().length === 0 &&
+            messageQueue.length === 0 &&
+            promptHistory.length > 0) {
+            if (key.upArrow) {
+                const next = historyIndex < promptHistory.length - 1 ? historyIndex + 1 : historyIndex;
+                setHistoryIndex(next);
+                resetComposer(promptHistory[next]);
+                return;
+            }
+            if (key.downArrow) {
+                if (historyIndex <= 0) {
+                    setHistoryIndex(-1);
+                    resetComposer("");
+                }
+                else {
+                    const next = historyIndex - 1;
+                    setHistoryIndex(next);
+                    resetComposer(promptHistory[next]);
+                }
+                return;
+            }
+        }
+        // Pending cluster switch: only Enter to confirm or Esc to cancel
+        if (pendingClusterSwitch) {
+            if (key.return) {
+                confirmClusterSwitch().catch((error) => {
+                    addSystemMessage(`Cluster switch failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+                return;
+            }
+            if (key.escape) {
+                setPendingClusterSwitch(null);
+                addSystemMessage("Cluster switch cancelled.");
+                return;
+            }
+            return;
+        }
+        if (leaderMode) {
+            setLeaderMode(false);
+            if (input === "h" || input === "?") {
+                setShowHelp((prev) => !prev);
+                return;
+            }
+            if (input === "c") {
+                setMessages([]);
+                return;
+            }
+            if (input === "q") {
+                exit();
+                return;
+            }
+        }
+        if (key.ctrl && input === "c") {
+            if (isStreaming) {
+                streamController.current?.abort();
+                streamController.current = null;
+                addSystemMessage("Stream cancelled. Press Ctrl+C again to exit.");
+                return;
+            }
+            exit();
+            return;
+        }
+        if (key.ctrl && input === "l") {
+            if (typeof process.stdout?.write === "function") {
+                process.stdout.write("\x1b[2J\x1b[H");
+            }
+            return;
+        }
+        if (key.ctrl && input === "d" && composer.trim().length === 0) {
+            exit();
+            return;
+        }
+        if (key.ctrl && input === "o") {
+            setWorkflowViewMode((prev) => (prev === "detailed" ? "minimal" : "detailed"));
+            return;
+        }
+        if (key.ctrl && input === "x") {
+            setLeaderMode(true);
+            return;
+        }
+        if (!key.ctrl && !key.meta && input === "?" && composer.length === 0) {
+            setShowHelp((prev) => !prev);
+            setSlashPanelDismissed(false);
+            return;
+        }
+        if (key.escape) {
+            if (shellMode) {
+                setShellMode(false);
+                resetComposer("");
+                return;
+            }
+            const hasOverlayOpen = showHelp || (slashModeActive && !slashPanelDismissed) || showAtFilePanel;
+            const hasInteractivePanelOpen = hasOverlayOpen || showSessionsPanel || showClusterPanel;
+            if (hasInteractivePanelOpen) {
+                setShowHelp(false);
+                setSlashPanelDismissed(true);
+                setAtFilePanelDismissed(true);
+                setShowSessionsPanel(false);
+                setSessionsSearchQuery("");
+                setSessionsSelectedIndex(0);
+                setShowClusterPanel(false);
+                setEscClearArmed(true);
+                return;
+            }
+            if (composer.trim().length === 0 && isStreaming && escClearArmed) {
+                streamController.current?.abort();
+                streamController.current = null;
+                setEscClearArmed(false);
+                return;
+            }
+            if (escClearArmed) {
+                resetComposer("");
+                setEscClearArmed(false);
+            }
+            else {
+                setEscClearArmed(true);
+            }
+            return;
+        }
+        if (key.tab) {
+            if (slashModeActive && visibleSlashCandidates.length > 0) {
+                const selected = selectedSlashCandidate ?? visibleSlashCandidates[0];
+                if (selected) {
+                    resetComposer(`${selected.name} `);
+                    return;
+                }
+            }
+        }
+        // Sessions panel search: regular character input updates search query
+        if (showSessionsInteractivePanel && !key.escape && !key.return && !key.ctrl && !key.meta && input.length === 1) {
+            setSessionsSearchQuery((prev) => prev + input);
+            return;
+        }
+    }, [
+        activateSessionById,
+        addSystemMessage,
+        atFileCurrentDir,
+        atFileFiltered,
+        cwd,
+        composer,
+        confirmClusterSwitch,
+        escClearArmed,
+        exit,
+        historyIndex,
+        isStreaming,
+        leaderMode,
+        messageQueue,
+        messages,
+        pendingClusterSwitch,
+        promptHistory,
+        resetComposer,
+        selectedAtFile,
+        selectedSlashCandidate,
+        sessionItems,
+        sessionsSelectedIndex,
+        sessionsSearchQuery,
+        setAtFileCurrentDir,
+        setAtFilePanelDismissed,
+        setAtFileSelectedIndex,
+        setEscClearArmed,
+        setHistoryIndex,
+        setLeaderMode,
+        setMessages,
+        setPendingClusterSwitch,
+        setShowHelp,
+        setSlashPanelDismissed,
+        setSlashSelectedIndex,
+        setSessionsSelectedIndex,
+        setShowClusterPanel,
+        setShowSessionsPanel,
+        setWorkflowExpandedIds,
+        showAtFilePanel,
+        showHelp,
+        showClusterPanel,
+        showSessionsPanel,
+        shellMode,
+        slashModeActive,
+        slashPanelDismissed,
+        streamAssistant,
+        visibleSlashCandidates,
+    ]);
+    useInput(handleInput);
+    const showTranscript = useMemo(() => {
+        if (showSetupSplash)
+            return messages.length > 0;
+        return !showDashboard || messages.length > 0;
+    }, [messages.length, showDashboard, showSetupSplash]);
+    const showSlashPanel = slashModeActive && !slashPanelDismissed;
+    const showClusterInteractivePanel = showClusterPanel && !showSlashPanel;
+    const showSessionsInteractivePanel = showSessionsPanel && !showSlashPanel && !showClusterInteractivePanel;
+    const showShortcutPanel = showHelp && !showSlashPanel && !showSessionsInteractivePanel && !showClusterInteractivePanel;
+    const latestAssistantMessage = useMemo(() => {
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+            const message = messages[index];
+            if (message?.role === "assistant") {
+                return message;
+            }
+        }
+        return null;
+    }, [messages]);
+    const liveActivity = useMemo(() => {
+        if (lastError && lastError !== "Conversation paused.") {
+            return { text: "Error", detail: lastError, color: "red", spinning: false };
+        }
+        const busy = isStreaming || isCommandRunning || status.includes("auth") || status.includes("session");
+        if (!busy)
+            return null;
+        const workflow = latestAssistantMessage?.workflow ?? [];
+        const latestThought = [...workflow].reverse().find((event) => event.type === "thought");
+        const latestCall = [...workflow].reverse().find((event) => event.type === "function_call");
+        const latestResult = [...workflow].reverse().find((event) => event.type === "function_response");
+        // Show the most recent event by timestamp (tool call in progress > thought > tool result)
+        const callInProgress = latestCall && (!latestResult || latestCall.ts >= latestResult.ts);
+        const mostRecent = callInProgress && latestThought
+            ? latestCall.ts >= latestThought.ts
+                ? "call"
+                : "thought"
+            : callInProgress
+                ? "call"
+                : latestThought
+                    ? "thought"
+                    : latestResult
+                        ? "result"
+                        : null;
+        if (mostRecent === "call" && latestCall) {
+            const toolName = typeof latestCall.details?.name === "string" && latestCall.details.name.trim().length > 0
+                ? latestCall.details.name
+                : "tool";
+            const thoughtDetail = latestThought ? extractThoughtTitle(latestThought.content) : undefined;
+            return {
+                text: toolName,
+                detail: thoughtDetail,
+                color: RUBIX_THEME.colors.tool,
+                spinning: true,
+            };
+        }
+        if (mostRecent === "thought" && latestThought) {
+            const thoughtTitle = extractThoughtTitle(latestThought.content);
+            const toolDetail = callInProgress && latestCall
+                ? typeof latestCall.details?.name === "string" && latestCall.details.name.trim().length > 0
+                    ? latestCall.details.name
+                    : "tool"
+                : undefined;
+            return {
+                text: thoughtTitle,
+                detail: toolDetail,
+                color: RUBIX_THEME.colors.thought,
+                spinning: true,
+            };
+        }
+        if (mostRecent === "result" && latestResult) {
+            const toolName = typeof latestResult.details?.name === "string" && latestResult.details.name.trim().length > 0
+                ? latestResult.details.name
+                : "action";
+            return {
+                text: `${toolName} finished`,
+                detail: undefined,
+                color: RUBIX_THEME.colors.tool,
+                spinning: true,
+            };
+        }
+        if ((latestAssistantMessage?.content ?? "").trim().length > 0) {
+            return { text: "Responding", detail: undefined, spinning: true };
+        }
+        const word = IDLE_ACTIVITY_WORDS[idleActivityTick % IDLE_ACTIVITY_WORDS.length];
+        return {
+            text: `${word}…`,
+            detail: undefined,
+            spinning: true,
+        };
+    }, [idleActivityTick, isCommandRunning, isStreaming, lastError, latestAssistantMessage, status]);
+    const composerSuggestions = useMemo(() => (slashModeActive ? visibleSlashCandidates.map((item) => item.name) : []), [slashModeActive, visibleSlashCandidates]);
+    const clusterSelectOptions = useMemo(() => clusters.map((c) => ({
+        label: `${c.name}  ${c.status}${c.region ? ` · ${c.region}` : ""}${c.cluster_id !== c.name ? ` · ${c.cluster_id}` : ""}`,
+        value: c.cluster_id,
+    })), [clusters]);
+    const sessionSelectOptions = useMemo(() => {
+        const query = sessionsSearchQuery.toLowerCase();
+        return sessionItems
+            .filter((item) => {
+            const title = (item.title ?? "").toLowerCase();
+            const desc = (item.description ?? "").toLowerCase();
+            return title.includes(query) || desc.includes(query);
+        })
+            .map((item) => {
+            const displayTitle = item.title ?? item.description ?? "Untitled session";
+            const timeAgo = formatTimeAgo(item.updatedAt);
+            return {
+                label: `${compactLine(displayTitle, 50) ?? "Untitled session"}  ${timeAgo}`,
+                value: item.id,
+            };
+        });
+    }, [sessionItems, sessionsSearchQuery]);
+    useEffect(() => {
+        // Reset sessions panel selection when filtered options change
+        if (sessionsSelectedIndex >= sessionSelectOptions.length) {
+            setSessionsSelectedIndex(0);
+        }
+    }, [sessionSelectOptions.length, sessionsSelectedIndex]);
+    const composerStatusBusy = false;
+    const composerRightStatus = liveActivity
+        ? ""
+        : showSetupSplash
+            ? "/login required"
+            : isStreaming
+                ? "streaming"
+                : isCommandRunning
+                    ? "running"
+                    : status.includes("auth") || status.includes("session")
+                        ? status
+                        : "";
+    return (_jsxs(Box, { flexDirection: "column", children: [showSetupSplash ? (_jsx(SplashScreen, { agentName: agentName, cwd: cwd, onActionSelect: handleSplashAction, selectDisabled: splashSelectionMade })) : null, showTrustDisclaimer ? (_jsx(TrustDisclaimer, { folderPath: cwd, onActionSelect: handleTrustDisclaimer })) : null, showDashboard && !showTrustDisclaimer ? (_jsx(DashboardPanel, { user: activeUser, agentName: agentName, cwd: cwd, recentSessions: recentSessions, selectedCluster: selectedCluster })) : null, showTranscript ? (_jsx(Box, { marginTop: 1, children: _jsx(ChatTranscript, { messages: messages, workflowViewMode: workflowViewMode }) })) : null, !showTrustDisclaimer ? (_jsx(Box, { marginTop: 1, paddingX: 1, gap: 1, minHeight: 1, children: liveActivity ? (_jsxs(_Fragment, { children: [liveActivity.spinning ? _jsx(Spinner, {}) : _jsx(Text, { color: liveActivity.color ?? "red", children: "!" }), _jsx(Text, { color: liveActivity.color ?? RUBIX_THEME.colors.assistantText, children: liveActivity.text }), liveActivity.detail ? _jsxs(Text, { dimColor: true, children: [" ", liveActivity.detail] }) : null] })) : (_jsx(Text, { dimColor: true, children: " " })) })) : null, lastError ? (_jsx(Box, { marginTop: 1, paddingX: 1, children: _jsx(StatusMessage, { variant: lastError === "Conversation paused." ? "info" : "error", children: lastError }) })) : null, !showSetupSplash && !showTrustDisclaimer ? (_jsx(Box, { marginTop: 1, children: _jsx(Composer, { value: composer, resetToken: composerResetToken, disabled: isCommandRunning || isAuthLoading || !!pendingClusterSwitch || showTrustDisclaimer, placeholder: isStreaming ? "Type to queue (Enter to add)" : "What would you like to do today?", shellMode: shellMode, captureArrowKeys: showAtFilePanel, onChange: handleComposerChange, onSubmit: submitComposer, suggestions: composerSuggestions, busy: composerStatusBusy, rightStatus: composerRightStatus, suggestion: slashModeActive
+                        ? selectedSlashCandidate
+                            ? `${selectedSlashCandidate.name}  ${selectedSlashCandidate.description}`
+                            : "No matching command"
+                        : shellMode
+                            ? "Enter to run"
+                            : isStreaming
+                                ? messageQueue.length > 0
+                                    ? `Enter to queue · ${messageQueue.length} queued · ↑ to edit`
+                                    : "Enter to queue"
+                                : "Shift+Enter new line · / for commands, @ for files, ! for shell" }) })) : null, showSlashPanel ? (_jsxs(Box, { borderStyle: "single", borderColor: RUBIX_THEME.colors.brand, paddingX: 1, flexDirection: "column", children: [visibleSlashCandidates.length === 0 ? (_jsx(Text, { dimColor: true, children: "No matching command" })) : (visibleSlashCandidates.map((item, index) => (_jsxs(Text, { children: [_jsx(Text, { color: index === slashSelectedIndex ? RUBIX_THEME.colors.brand : undefined, children: index === slashSelectedIndex ? "› " : "  " }), _jsx(Text, { bold: index === slashSelectedIndex, color: index === slashSelectedIndex ? RUBIX_THEME.colors.brand : undefined, children: item.name }), _jsxs(Text, { dimColor: true, children: ["  ", item.description] })] }, item.name)))), _jsx(Text, { dimColor: true, children: "\u2191\u2193 navigate \u2022 Enter select \u2022 Tab autocomplete" })] })) : null, showAtFilePanel ? (_jsxs(Box, { borderStyle: "single", borderColor: RUBIX_THEME.colors.brand, paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { color: RUBIX_THEME.colors.brand, children: ["Add file context", atFileCurrentDir !== cwd ? ` · ${path.relative(cwd, atFileCurrentDir)}/` : "", atFileQuery ? ` · filter: "${atFileQuery}"` : ""] }), atFileFiltered.length === 0 ? (_jsx(Text, { dimColor: true, children: atFileQuery ? "No matching files" : "No files in directory" })) : ((() => {
+                        const visibleCount = 7;
+                        const start = Math.max(0, Math.min(atFileSelectedIndex - 6, atFileFiltered.length - visibleCount));
+                        return atFileFiltered.slice(start, start + visibleCount).map((name, i) => {
+                            const idx = start + i;
+                            return (_jsxs(Text, { children: [_jsx(Text, { color: idx === atFileSelectedIndex ? RUBIX_THEME.colors.brand : undefined, children: idx === atFileSelectedIndex ? "› " : "  " }), _jsx(Text, { bold: idx === atFileSelectedIndex, color: idx === atFileSelectedIndex ? RUBIX_THEME.colors.brand : undefined, children: name })] }, name));
+                        });
+                    })()), _jsxs(Text, { dimColor: true, children: [atFileFiltered.length, " item", atFileFiltered.length === 1 ? "" : "s", " \u00B7 Tab complete \u00B7 \u2191\u2193 navigate \u00B7 Enter add/dir \u00B7 Esc cancel (text as normal)"] })] })) : null, showSessionsInteractivePanel ? (_jsxs(Box, { borderStyle: "single", borderColor: RUBIX_THEME.colors.brand, paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { color: RUBIX_THEME.colors.brand, children: ["Sessions ", sessionsSearchQuery ? `(searching: "${sessionsSearchQuery}")` : ""] }), sessionsPanelLoading ? (_jsx(Spinner, { label: "loading sessions..." })) : sessionsPanelError ? (_jsxs(Text, { color: "red", children: ["Failed to load sessions: ", sessionsPanelError] })) : sessionSelectOptions.length === 0 ? (_jsx(Text, { dimColor: true, children: sessionsSearchQuery ? "No matching sessions" : "No sessions found. Use /new to create one." })) : (_jsx(Box, { flexDirection: "column", children: (() => {
+                            const visibleCount = 7;
+                            const start = Math.max(0, Math.min(sessionsSelectedIndex - 6, sessionSelectOptions.length - visibleCount));
+                            return sessionSelectOptions.slice(start, start + visibleCount).map((option, i) => {
+                                const idx = start + i;
+                                const isSelected = idx === sessionsSelectedIndex;
+                                const sessionItem = sessionItems.find((item) => item.id === option.value);
+                                const title = compactLine(sessionItem?.title ?? sessionItem?.description ?? "Untitled session", 50) ?? "Untitled session";
+                                const subtitle = `${formatTimeAgo(sessionItem?.updatedAt ?? new Date().toISOString())}${sessionItem?.clusterId ? ` · ${sessionItem.clusterId}` : ""}`;
+                                return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: isSelected ? RUBIX_THEME.colors.brand : undefined, children: isSelected ? "› " : "  " }), _jsx(Text, { bold: isSelected, color: isSelected ? RUBIX_THEME.colors.brand : undefined, children: title })] }), _jsxs(Text, { dimColor: true, children: ["    ", subtitle] })] }, option.value));
+                            });
+                        })() })), _jsxs(Text, { dimColor: true, children: [sessionSelectOptions.length, " session", sessionSelectOptions.length === 1 ? "" : "s", " shown", sessionsHasMore ? " (more available)" : ""] }), _jsx(Text, { dimColor: true, children: "Type to search \u2022 \u2191\u2193 navigate \u2022 Enter switch \u2022 Esc close" })] })) : null, pendingClusterSwitch ? (_jsxs(Box, { borderStyle: "single", borderColor: "yellow", paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["Switch to cluster: ", pendingClusterSwitch.name] }), _jsx(Text, { dimColor: true, children: "This will start a new session with cluster context." }), _jsx(Text, { dimColor: true, children: "Press Enter to confirm \u00B7 Esc to cancel" })] })) : null, showClusterInteractivePanel ? (_jsxs(Box, { borderStyle: "single", borderColor: RUBIX_THEME.colors.brand, paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { color: RUBIX_THEME.colors.brand, children: ["Clusters", selectedCluster ? ` · active: ${selectedCluster.name}` : ""] }), clusterPanelLoading ? (_jsx(Spinner, { label: "loading clusters..." })) : clusterPanelError ? (_jsxs(Text, { color: "red", children: ["Failed to load clusters: ", clusterPanelError] })) : clusters.length === 0 ? (_jsx(Text, { dimColor: true, children: "No clusters found. Register a cluster via the console." })) : (_jsx(Select, { options: clusterSelectOptions, visibleOptionCount: 7, onChange: (value) => {
+                            const cluster = clusters.find((c) => c.cluster_id === value);
+                            if (!cluster)
+                                return;
+                            setShowClusterPanel(false);
+                            setPendingClusterSwitch(cluster);
+                        } })), _jsxs(Text, { dimColor: true, children: [clusters.length, " cluster", clusters.length === 1 ? "" : "s", " \u00B7 \u2191\u2193 navigate \u00B7 Enter select \u00B7 Esc close"] })] })) : null, showShortcutPanel ? (_jsxs(Box, { borderStyle: "single", borderColor: RUBIX_THEME.colors.brand, paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: RUBIX_THEME.colors.brand, children: "Shortcuts" }), SHORTCUT_ROWS.map((row) => (_jsxs(Text, { dimColor: true, children: [row.key.padEnd(24), " ", row.action] }, row.key))), _jsx(Text, { dimColor: true, children: "/login /logout /status /resume /new /cluster /paste /send-shell-output /clear /rename /console /docs /help /exit /quit" })] })) : null] }));
+}