@pasko70/pibo 1.1.0 → 1.2.0

package/dist/apps/cli-ui/InkSessionApp.js

@@ -0,0 +1,1218 @@
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { isCliSourceError } from "../../cli-session/index.js";
+import { buildCompactTerminalRows, buildSlashCommandCatalog, buildTerminalStatusViewModel, commandSupportLabel, filterSlashCommands, formatSlashCommand, groupSlashCommandsForHelp, normalizeCommandErrorDescriptor, progressBarText, } from "../../session-ui/index.js";
+import { InkTerminalView } from "./InkTerminalView.js";
+import { isExpandableTerminalRow } from "./InkTerminalRow.js";
+const IDENTIFIER_PATTERN = /^(?:user|room|ps|pi|entry|evt|run|create|provider|model|agent)[_:]/i;
+const INITIAL_STATE = {
+    loading: true,
+    rows: [],
+    input: "",
+    mode: "transcript",
+};
+export function InkSessionApp({ source, initialSessionId, maxRows, maxLineChars, onExit }) {
+    const app = useApp();
+    const [state, setState] = useState(INITIAL_STATE);
+    const openedRef = useRef(undefined);
+    const unsubscribeRef = useRef(undefined);
+    const closedRef = useRef(false);
+    const stateRef = useRef(state);
+    useEffect(() => {
+        stateRef.current = state;
+    }, [state]);
+    const closeOpenSession = useCallback(() => {
+        unsubscribeRef.current?.();
+        unsubscribeRef.current = undefined;
+        void openedRef.current?.close();
+        openedRef.current = undefined;
+    }, []);
+    const cleanup = useMemo(() => createCliSessionCleanup(closeOpenSession, () => {
+        void source.close();
+    }), [closeOpenSession, source]);
+    const openSession = useCallback(async (sessionId, message, localRows) => {
+        closeOpenSession();
+        const opened = await source.openSession(sessionId);
+        openedRef.current = opened;
+        const activeRoom = opened.session.roomId
+            ? (await source.listRooms()).find((room) => room.id === opened.session.roomId)
+            : undefined;
+        const rows = [...(localRows ?? []), ...buildCompactTerminalRows(opened.traceView, { showThinking: false })];
+        setState((current) => normalizeInkRowSelection({
+            ...current,
+            loading: false,
+            status: opened.status,
+            activeRoom,
+            session: opened.session,
+            rows,
+            mode: "transcript",
+            picker: undefined,
+            message,
+            error: undefined,
+        }));
+        unsubscribeRef.current = opened.subscribe((sourceUpdate) => {
+            setState((current) => normalizeInkRowSelection({
+                ...current,
+                session: sourceUpdate.session ?? current.session,
+                status: sourceUpdate.status ?? current.status,
+                rows: sourceUpdate.traceView === undefined ? current.rows : buildCompactTerminalRows(sourceUpdate.traceView, { showThinking: false }),
+                error: sourceUpdate.error?.message ?? current.error,
+            }));
+        });
+    }, [closeOpenSession, source]);
+    const requestExit = useCallback(() => {
+        cleanup();
+        onExit?.();
+        app.exit();
+    }, [app, cleanup, onExit]);
+    const submitCommandOrMessage = useCallback(async (rawInput) => {
+        await handleCliSessionSubmittedInput(rawInput, source, stateRef.current, setState, openSession, requestExit);
+    }, [openSession, requestExit, source]);
+    const openSessionPickerForRoom = useCallback(async (room, parent) => {
+        const sessions = await source.listSessions({ roomId: room.id });
+        const createItem = {
+            id: `create:${room.id}`,
+            kind: "create-session",
+            label: "+ New session",
+            description: ["create and open", `room ${abbreviateIdentifier(room.id)}`].join(" · "),
+            roomId: room.id,
+        };
+        const status = await source.getStatus();
+        setState((current) => ({
+            ...current,
+            loading: false,
+            status,
+            activeRoom: room,
+            mode: "session-picker",
+            picker: {
+                kind: "session",
+                title: `Select session in ${room.title}`,
+                items: [...sessions.map(sessionPickerItem), createItem],
+                selectedIndex: 0,
+                emptyMessage: `No sessions in ${room.title}. Create a new session to start chatting.`,
+                roomId: room.id,
+                parent,
+            },
+            message: sessions.length === 0 ? `No sessions in ${room.title}. Press Enter to create one.` : "Select a session with arrow keys, or create a new one.",
+            error: undefined,
+        }));
+    }, [source]);
+    const openRoomPicker = useCallback(async () => {
+        const rooms = await source.listRooms();
+        const defaultIndex = Math.max(0, rooms.findIndex((room) => room.isDefault));
+        const status = await source.getStatus();
+        setState((current) => ({
+            ...current,
+            loading: false,
+            status,
+            activeRoom: undefined,
+            session: undefined,
+            rows: [],
+            mode: "picker",
+            picker: {
+                kind: "room",
+                title: "Select room",
+                items: rooms.map(roomPickerItem),
+                selectedIndex: defaultIndex,
+                emptyMessage: "No rooms are available.",
+            },
+            message: rooms.length === 0 ? "No rooms are available." : "Select a room with arrow keys.",
+            error: undefined,
+        }));
+    }, [source]);
+    const selectPickerItem = useCallback(async () => {
+        const picker = stateRef.current.picker;
+        const item = picker?.items[picker.selectedIndex];
+        if (!picker || !item) {
+            setState((current) => ({ ...current, mode: "transcript", picker: undefined, message: picker?.emptyMessage ?? "Nothing to select." }));
+            return;
+        }
+        try {
+            if (picker.kind === "room") {
+                const room = { id: item.roomId ?? item.id, title: item.label, description: item.description, isDefault: item.id === stateRef.current.status?.activeRoomId };
+                if (picker.action === "create-session") {
+                    const created = await source.createSession({ roomId: room.id, agentId: stateRef.current.status?.activeAgentId });
+                    await openSession(created.id, `Created session ${created.title}.`);
+                    return;
+                }
+                if (picker.action === "select-room") {
+                    const status = await source.getStatus({ sessionId: stateRef.current.session?.id });
+                    setState((current) => ({ ...current, status, activeRoom: room, mode: "transcript", picker: undefined, overlayStack: undefined, message: `Selected room ${room.title}.`, error: undefined }));
+                    return;
+                }
+                await openSessionPickerForRoom(room, picker);
+                return;
+            }
+            if (picker.kind === "session") {
+                if (item.kind === "create-session") {
+                    const created = await source.createSession({ roomId: item.roomId ?? picker.roomId, agentId: stateRef.current.status?.activeAgentId });
+                    await openSession(created.id, `Created session ${created.title}.`);
+                    return;
+                }
+                await openSession(item.id, `Opened session ${item.label}.`);
+                return;
+            }
+            if (picker.kind === "command-menu") {
+                await selectCommandMenuItem(picker, item, source, stateRef.current, setState, openSession);
+                return;
+            }
+            const sessionId = stateRef.current.session?.id;
+            if (!sessionId)
+                throw new Error("No session is open. Use /new or /session first.");
+            const session = await source.setSessionAgent(sessionId, item.id);
+            const status = await source.getStatus({ sessionId });
+            setState((current) => ({
+                ...current,
+                session,
+                status,
+                mode: "transcript",
+                picker: undefined,
+                message: `Selected agent ${item.label}.`,
+                error: undefined,
+            }));
+        }
+        catch (error) {
+            setState((current) => ({ ...current, mode: "transcript", picker: undefined, error: formatCliSessionError(error), message: undefined }));
+        }
+    }, [openSession, openSessionPickerForRoom, source]);
+    useEffect(() => {
+        closedRef.current = false;
+        void (async () => {
+            try {
+                const slashCommands = await safeListSlashCommands(source);
+                setState((current) => ({ ...current, slashCommands }));
+                if (initialSessionId) {
+                    await openSession(initialSessionId);
+                    return;
+                }
+                await openRoomPicker();
+            }
+            catch (error) {
+                setState((current) => ({ ...current, loading: false, error: formatCliSessionError(error) }));
+            }
+        })();
+        return () => {
+            closedRef.current = true;
+            cleanup();
+        };
+    }, [cleanup, initialSessionId, openRoomPicker, openSession, source]);
+    useInput((input, key) => {
+        if (closedRef.current)
+            return;
+        if (key.ctrl && input === "c") {
+            requestExit();
+            return;
+        }
+        if (key.escape) {
+            setState((current) => reduceInkSessionInputState(current, { type: "escape" }));
+            return;
+        }
+        if (key.upArrow) {
+            setState((current) => reduceInkSessionInputState(current, { type: "up" }));
+            return;
+        }
+        if (key.downArrow) {
+            setState((current) => reduceInkSessionInputState(current, { type: "down" }));
+            return;
+        }
+        if (key.return) {
+            const submitted = stateRef.current.input;
+            if (submitted.length === 0 && !stateRef.current.picker && !stateRef.current.slashSuggestions && canToggleSelectedRowDetails(stateRef.current)) {
+                setState((current) => reduceInkSessionInputState(current, { type: "toggle-details" }));
+                return;
+            }
+            if (stateRef.current.slashSuggestions && !stateRef.current.picker) {
+                const accepted = acceptSlashSuggestion(stateRef.current);
+                if (accepted.runInput) {
+                    setState((current) => ({ ...current, input: "", slashSuggestions: undefined, message: undefined, error: undefined }));
+                    void submitCommandOrMessage(accepted.runInput);
+                }
+                else {
+                    setState((current) => ({ ...current, input: accepted.input, slashSuggestions: undefined, message: `Accepted ${accepted.input.trim()}. Press Enter to run or add arguments.`, error: undefined }));
+                }
+                return;
+            }
+            if (submitted.trimStart().startsWith("/")) {
+                setState((current) => reduceInkSessionInputState(current, { type: "enter" }));
+                void submitCommandOrMessage(submitted);
+                return;
+            }
+            if (stateRef.current.picker) {
+                void selectPickerItem();
+                return;
+            }
+            setState((current) => reduceInkSessionInputState(current, { type: "enter" }));
+            void submitCommandOrMessage(submitted);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setState((current) => reduceInkSessionInputState(current, { type: "backspace" }));
+            return;
+        }
+        if (input === "d" && !key.ctrl && !key.meta && stateRef.current.input.length === 0 && !stateRef.current.picker && !stateRef.current.slashSuggestions && canToggleSelectedRowDetails(stateRef.current)) {
+            setState((current) => reduceInkSessionInputState(current, { type: "toggle-details" }));
+            return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+            setState((current) => reduceInkSessionInputState(current, { type: "text", value: input }));
+        }
+    });
+    return React.createElement(InkSessionAppView, { state, maxRows, maxLineChars });
+}
+export function InkSessionAppView({ state, maxRows = 20, maxLineChars }) {
+    const lineLimit = normalizeTerminalLineLimit(maxLineChars);
+    const statusLines = useMemo(() => formatStatusHeaderLines(state, lineLimit), [lineLimit, state]);
+    const commandSummary = useMemo(() => cliCommandHintText(), []);
+    return React.createElement(Box, { flexDirection: "column" }, ...statusLines.map((line, index) => React.createElement(Text, { color: state.status?.connected === false ? "red" : "cyan", key: `status-${index}` }, line)), React.createElement(Text, { color: "gray" }, commandSummary), state.loading ? React.createElement(Text, { color: "yellow" }, "Loading CLI session…") : null, state.error ? React.createElement(Text, { color: "red" }, `Error: ${state.error}`) : null, ...(state.message ? renderBoundedTextLines(state.message, "gray", lineLimit, "message") : []), state.picker ? React.createElement(InkSessionPickerView, { picker: state.picker, maxLineChars: lineLimit }) : null, React.createElement(InkTerminalView, { rows: state.rows, maxRows, maxLineChars: lineLimit, selectedRowId: state.selectedRowId, expandedRowIds: state.expandedRowIds }), state.slashSuggestions ? React.createElement(InkSlashSuggestionsView, { suggestions: state.slashSuggestions, maxLineChars: lineLimit }) : null, React.createElement(Text, { color: state.mode === "transcript" ? "green" : "yellow" }, `› ${state.input}`));
+}
+export function normalizeTerminalLineLimit(maxLineChars) {
+    if (maxLineChars === undefined || !Number.isFinite(maxLineChars))
+        return 220;
+    return Math.max(20, Math.floor(maxLineChars));
+}
+export function InkSlashSuggestionsView({ suggestions, maxLineChars }) {
+    const lineLimit = normalizeTerminalLineLimit(maxLineChars);
+    return React.createElement(Box, { flexDirection: "column" }, React.createElement(Text, { color: "yellow" }, "slash commands"), ...suggestions.items.slice(0, 8).map((command, index) => {
+        const disabled = command.support === "deferred" || command.support === "browser-only" || Boolean(command.unsupportedReason);
+        const item = {
+            id: command.id,
+            label: formatSlashCommand(command),
+            description: [command.description, command.unsupportedReason ? `unavailable: ${command.unsupportedReason}` : undefined].filter(Boolean).join(" · "),
+            disabled,
+        };
+        return React.createElement(Text, { key: command.id, color: overlayItemColor(index === suggestions.selectedIndex, disabled) }, formatOverlayItemLine(item, index === suggestions.selectedIndex, lineLimit));
+    }), React.createElement(Text, { color: "gray" }, "↑↓ select · enter accept/run · esc close · ctrl-c exit"));
+}
+export function InkSessionPickerView({ picker, maxLineChars }) {
+    const lineLimit = normalizeTerminalLineLimit(maxLineChars);
+    const title = compactOverlayTitle(picker.title);
+    if (picker.items.length === 0) {
+        return React.createElement(Box, { flexDirection: "column" }, React.createElement(Text, { color: "yellow" }, title), React.createElement(Text, { color: "gray" }, picker.emptyMessage), React.createElement(Text, { color: "gray" }, "esc back/cancel · ctrl-c exit"));
+    }
+    return React.createElement(Box, { flexDirection: "column" }, React.createElement(Text, { color: "yellow" }, title), ...picker.items.map((item, index) => React.createElement(Text, { key: item.id, color: overlayItemColor(index === picker.selectedIndex, item.disabled === true) }, formatOverlayItemLine(item, index === picker.selectedIndex, lineLimit))), React.createElement(Text, { color: "gray" }, "↑↓ select · enter confirm · esc back/cancel · ctrl-c exit"));
+}
+export function reduceInkSessionInputState(state, action) {
+    if (action.type === "text")
+        return withSlashSuggestions({ ...state, input: state.input + action.value, message: undefined, error: undefined });
+    if (action.type === "backspace")
+        return withSlashSuggestions({ ...state, input: state.input.slice(0, -1) });
+    if (action.type === "toggle-details")
+        return toggleSelectedRowDetails(state);
+    if (action.type === "escape") {
+        if (state.slashSuggestions)
+            return { ...state, slashSuggestions: undefined, overlayStack: popInkSessionOverlay(state.overlayStack), message: "Closed slash suggestions." };
+        if (state.picker?.parent) {
+            return withPickerOverlay({ ...state, picker: state.picker.parent, mode: pickerMode(state.picker.parent), message: "Back." }, state.picker.parent);
+        }
+        return { ...state, input: "", mode: "transcript", picker: undefined, overlayStack: popInkSessionOverlay(state.overlayStack), message: "Canceled." };
+    }
+    if (action.type === "up" || action.type === "down") {
+        if (state.slashSuggestions && !state.picker && state.slashSuggestions.items.length > 0) {
+            const direction = action.type === "up" ? -1 : 1;
+            const selectedIndex = (state.slashSuggestions.selectedIndex + direction + state.slashSuggestions.items.length) % state.slashSuggestions.items.length;
+            return { ...state, slashSuggestions: { ...state.slashSuggestions, selectedIndex } };
+        }
+        if (!state.picker && state.input.length === 0)
+            return selectExpandableRow(state, action.type === "up" ? -1 : 1);
+        if (!state.picker || state.picker.items.length === 0)
+            return state;
+        const direction = action.type === "up" ? -1 : 1;
+        const selectedIndex = (state.picker.selectedIndex + direction + state.picker.items.length) % state.picker.items.length;
+        return { ...state, picker: { ...state.picker, selectedIndex } };
+    }
+    return {
+        ...state,
+        input: "",
+        slashSuggestions: undefined,
+        message: undefined,
+        error: undefined,
+    };
+}
+export function normalizeInkRowSelection(state) {
+    const expandableIds = expandableRowIds(state.rows);
+    const expandedRowIds = (state.expandedRowIds ?? []).filter((id) => expandableIds.includes(id));
+    if (expandableIds.length === 0)
+        return { ...state, selectedRowId: undefined, expandedRowIds };
+    const selectedRowId = state.selectedRowId && expandableIds.includes(state.selectedRowId)
+        ? state.selectedRowId
+        : expandableIds[expandableIds.length - 1];
+    return { ...state, selectedRowId, expandedRowIds };
+}
+function selectExpandableRow(state, direction) {
+    const normalized = normalizeInkRowSelection(state);
+    const ids = expandableRowIds(normalized.rows);
+    if (ids.length === 0)
+        return normalized;
+    const currentIndex = Math.max(0, ids.indexOf(normalized.selectedRowId ?? ids[ids.length - 1]));
+    const selectedRowId = ids[(currentIndex + direction + ids.length) % ids.length];
+    return { ...normalized, selectedRowId, message: `Focused row ${currentIndexLabel(ids, selectedRowId)}. Press d or Enter for details.` };
+}
+function toggleSelectedRowDetails(state) {
+    const normalized = normalizeInkRowSelection(state);
+    const selectedRowId = normalized.selectedRowId;
+    if (!selectedRowId)
+        return { ...normalized, message: "No expandable row is available." };
+    const expanded = new Set(normalized.expandedRowIds ?? []);
+    const opening = !expanded.has(selectedRowId);
+    if (opening)
+        expanded.add(selectedRowId);
+    else
+        expanded.delete(selectedRowId);
+    return {
+        ...normalized,
+        expandedRowIds: [...expanded],
+        message: opening ? "Opened row details." : "Closed row details.",
+    };
+}
+function canToggleSelectedRowDetails(state) {
+    return expandableRowIds(state.rows).length > 0;
+}
+function expandableRowIds(rows) {
+    return rows.filter(isExpandableTerminalRow).map((row) => row.id);
+}
+function currentIndexLabel(ids, selectedRowId) {
+    const index = selectedRowId ? ids.indexOf(selectedRowId) : -1;
+    return index >= 0 ? `${index + 1}/${ids.length}` : `1/${ids.length}`;
+}
+function withSlashSuggestions(state) {
+    if (state.picker || !state.input.trimStart().startsWith("/"))
+        return { ...state, slashSuggestions: undefined, overlayStack: state.slashSuggestions ? popInkSessionOverlay(state.overlayStack) : state.overlayStack };
+    const catalog = state.slashCommands ?? buildSlashCommandCatalog();
+    const items = filterSlashCommands(catalog, state.input);
+    if (items.length === 0)
+        return { ...state, slashSuggestions: undefined, overlayStack: state.slashSuggestions ? popInkSessionOverlay(state.overlayStack) : state.overlayStack };
+    const previous = state.slashSuggestions?.items[state.slashSuggestions.selectedIndex]?.slash;
+    const selectedIndex = Math.max(0, previous ? items.findIndex((item) => item.slash === previous) : 0);
+    const suggestions = { items, selectedIndex };
+    return { ...state, slashSuggestions: suggestions, overlayStack: replaceTopOverlay(state.overlayStack, { kind: "suggestions", suggestions }) };
+}
+function acceptSlashSuggestion(state) {
+    const suggestion = state.slashSuggestions?.items[state.slashSuggestions.selectedIndex];
+    if (!suggestion)
+        return { input: state.input };
+    const trimmed = state.input.trim();
+    const token = trimmed.split(/\s+/, 1)[0] ?? "";
+    if (token === suggestion.slash && trimmed.length > suggestion.slash.length)
+        return { input: state.input, runInput: trimmed };
+    if (token === suggestion.slash && trimmed === suggestion.slash)
+        return { input: suggestion.slash, runInput: suggestion.slash };
+    return { input: `${suggestion.slash} ` };
+}
+export function pushInkSessionOverlay(stack, overlay) {
+    return [...(stack ?? []), overlay];
+}
+export function popInkSessionOverlay(stack) {
+    if (!stack || stack.length <= 1)
+        return undefined;
+    return stack.slice(0, -1);
+}
+export function activeInkSessionOverlay(stack) {
+    return stack?.[stack.length - 1];
+}
+function replaceTopOverlay(stack, overlay) {
+    if (!stack || stack.length === 0)
+        return [overlay];
+    return [...stack.slice(0, -1), overlay];
+}
+function withPickerOverlay(state, picker) {
+    return { ...state, picker, overlayStack: replaceTopOverlay(state.overlayStack, { kind: "picker", picker }) };
+}
+function pickerMode(picker) {
+    if (picker.kind === "agent")
+        return "agent-picker";
+    if (picker.kind === "session")
+        return "session-picker";
+    return "picker";
+}
+export function parseCliSessionInput(input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0)
+        return { type: "empty" };
+    if (!trimmed.startsWith("/"))
+        return { type: "message", text: trimmed };
+    const withoutSlash = trimmed.slice(1);
+    const [name = "", ...rest] = withoutSlash.split(/\s+/);
+    return { type: "command", command: { name: name.toLowerCase(), args: rest.join(" ").trim(), raw: trimmed } };
+}
+export function cliCommandSummaryText(catalog = buildSlashCommandCatalog()) {
+    const availableSlashes = new Set(catalog.map((command) => command.slash));
+    const preferred = ["/help", "/new", "/room", "/session", "/agent", "/profile", "/repair-user-unknown", "/status", "/clear", "/exit", "/quit"];
+    const commands = preferred.filter((slash) => availableSlashes.has(slash));
+    return `Commands: ${commands.join(" ")} (type / for suggestions, /help for catalog)`;
+}
+export function cliCommandHintText() {
+    return "commands: / opens palette · /status runtime · /room /session navigate · /help catalog · ↑↓ focus rows · d/enter details · ctrl-c exit";
+}
+export function cliSessionSlashHelpText(catalog = buildSlashCommandCatalog()) {
+    const grouped = groupSlashCommandsForHelp(catalog);
+    const format = (command) => `${formatSlashCommand(command)} — ${command.description}${command.unsupportedReason ? ` (${command.unsupportedReason})` : ""}`;
+    const available = grouped.available.map((command) => `  ${format(command)} [${commandSupportLabel(command)}]`).join("\n") || "  none";
+    const navigation = grouped.navigation.map((command) => `  ${format(command)} [${commandSupportLabel(command)}]`).join("\n") || "  none";
+    const unsupported = grouped.unsupported.map((command) => `  ${format(command)} [${commandSupportLabel(command)}]`).join("\n") || "  none";
+    return [
+        "Slash command catalog",
+        "Available Web/session actions:",
+        available,
+        "CLI navigation and recovery commands:",
+        navigation,
+        "Unsupported or deferred terminal commands:",
+        unsupported,
+        "Keyboard controls: type / for suggestions; ↑/↓ selects suggestions, pickers, or expandable transcript rows; Enter accepts/runs or opens focused details when the composer is empty; d toggles focused details; Esc closes suggestions or backs out of pickers; room flow is room → session.",
+    ].join("\n");
+}
+export function formatCliSessionStatus(status, session) {
+    if (!status && !session)
+        return "Status unavailable.";
+    const parts = [
+        `source=${status?.source ?? "unknown"}`,
+        `mode=${status?.mode ?? "unknown"}`,
+        `connected=${status?.connected === false ? "no" : "yes"}`,
+        `session=${session?.id ?? status?.activeSessionId ?? "none"}`,
+        `agent=${session?.agentId ?? session?.profile ?? status?.activeAgentId ?? "default"}`,
+        `model=${status?.activeModel ? `${status.activeModel.provider}/${status.activeModel.id}` : "unknown"}`,
+        `rooms=${status?.rooms ?? "unknown"}`,
+        `agents=${status?.agents ?? "unknown"}`,
+    ];
+    if (status?.message)
+        parts.push(`message=${redactCliSessionStatusText(status.message)}`);
+    return parts.join(" | ");
+}
+export async function handleCliSessionSubmittedInput(rawInput, source, state, setState, openSession, requestExit) {
+    const parsed = parseCliSessionInput(rawInput);
+    if (parsed.type === "empty")
+        return;
+    if (parsed.type === "message") {
+        const sessionId = state.session?.id;
+        if (!sessionId) {
+            setState((current) => ({ ...current, error: "No session is open. Use /new to create one or /session to select an existing session." }));
+            return;
+        }
+        try {
+            await source.sendMessage(sessionId, parsed.text);
+            setState((current) => ({ ...current, message: "Message sent.", error: undefined }));
+        }
+        catch (error) {
+            setState((current) => ({ ...current, error: formatCliSessionError(error), message: undefined }));
+        }
+        return;
+    }
+    try {
+        await handleSlashCommand(parsed.command, source, state, setState, openSession, requestExit);
+    }
+    catch (error) {
+        setState((current) => applyCommandResultToState(current, parsed.command, normalizeCommandErrorDescriptor(parsed.command.name, error), current.status));
+    }
+}
+async function handleSlashCommand(command, source, state, setState, openSession, requestExit) {
+    if (command.name === "help") {
+        setState((current) => ({ ...current, message: cliSessionSlashHelpText(current.slashCommands ?? state.slashCommands), error: undefined }));
+        return;
+    }
+    if (command.name === "status") {
+        const result = await source.executeSlashCommand({ command: command.name, args: command.args, sessionId: state.session?.id });
+        const status = await source.getStatus({ sessionId: state.session?.id });
+        setState((current) => applyCommandResultToState(current, command, result.descriptor, status));
+        return;
+    }
+    if (command.name === "clear") {
+        const result = await source.executeSlashCommand({ command: command.name, args: command.args, sessionId: state.session?.id });
+        setState((current) => normalizeInkRowSelection({ ...current, rows: [], message: `${renderCommandResultDescriptorText(result.descriptor, current.session)}\nCleared local display. Session data was not deleted.`, error: undefined }));
+        return;
+    }
+    if (command.name === "exit" || command.name === "quit") {
+        requestExit();
+        return;
+    }
+    if (command.name === "new") {
+        if (!state.activeRoom?.id) {
+            const rooms = await source.listRooms();
+            const defaultIndex = Math.max(0, rooms.findIndex((room) => room.isDefault));
+            const status = await source.getStatus({ sessionId: state.session?.id });
+            setState((current) => ({
+                ...current,
+                status,
+                mode: "picker",
+                picker: {
+                    kind: "room",
+                    action: "create-session",
+                    title: "Select room for new session",
+                    items: rooms.map(roomPickerItem),
+                    selectedIndex: defaultIndex,
+                    emptyMessage: "No rooms are available.",
+                },
+                message: rooms.length === 0 ? "No rooms are available." : "Select the room for the new session.",
+                error: undefined,
+            }));
+            return;
+        }
+        const created = await source.createSession({ roomId: state.activeRoom.id, agentId: state.status?.activeAgentId });
+        await openSession(created.id, `Created session ${created.title}.`);
+        return;
+    }
+    if (command.name === "session" || command.name === "room") {
+        const rooms = await source.listRooms();
+        const status = await source.getStatus({ sessionId: state.session?.id });
+        const activeRoomId = state.activeRoom?.id ?? status.activeRoomId;
+        const activeRoomIndex = rooms.findIndex((room) => room.id === activeRoomId);
+        const selectedIndex = Math.max(0, activeRoomIndex >= 0 ? activeRoomIndex : rooms.findIndex((room) => room.isDefault));
+        setState((current) => ({
+            ...current,
+            status,
+            mode: "picker",
+            picker: {
+                kind: "room",
+                action: command.name === "room" ? "select-room" : undefined,
+                title: command.name === "room" ? "Select active room" : "Select room for sessions",
+                items: rooms.map(roomPickerItem),
+                selectedIndex,
+                emptyMessage: "No rooms are available.",
+            },
+            message: rooms.length === 0 ? "No rooms are available." : command.name === "room" ? "Select the active room with arrow keys." : "Select a room, then choose or create a session.",
+            error: undefined,
+        }));
+        return;
+    }
+    if (command.name === "repair-user-unknown") {
+        if (!source.repairLegacyCliSessions)
+            throw new Error("This source does not support legacy CLI session repair.");
+        const result = await source.repairLegacyCliSessions({ roomId: state.activeRoom?.id });
+        const status = await source.getStatus({ sessionId: state.session?.id });
+        setState((current) => ({
+            ...current,
+            status,
+            message: `Repaired ${result.repaired}/${result.scanned} legacy CLI session${result.scanned === 1 ? "" : "s"}${result.roomId ? ` in ${result.roomId}` : ""}.`,
+            error: undefined,
+        }));
+        return;
+    }
+    if (command.name === "agent" || command.name === "profile") {
+        const agents = await source.listAgents();
+        setState((current) => ({
+            ...current,
+            mode: "agent-picker",
+            picker: {
+                kind: "agent",
+                title: "Select existing agent/profile",
+                items: agents.map(agentPickerItem),
+                selectedIndex: 0,
+                emptyMessage: "No existing agents/profiles are available from this source.",
+            },
+            message: agents.length === 0 ? "No existing agents/profiles are available." : "Select an existing agent/profile with arrow keys.",
+            error: undefined,
+        }));
+        return;
+    }
+    if (command.name === "thinking") {
+        if (command.args.trim()) {
+            validateThinkingLevel(command.args);
+            const result = await source.executeSlashCommand({ command: command.name, args: command.args, sessionId: state.session?.id });
+            const status = await source.getStatus({ sessionId: state.session?.id });
+            setState((current) => applyCommandResultToState(current, command, result.descriptor, status));
+            return;
+        }
+        setState((current) => withPickerOverlay({
+            ...current,
+            mode: "picker",
+            message: "Select a thinking level with arrow keys, then Enter.",
+            error: undefined,
+        }, thinkingPickerState()));
+        return;
+    }
+    if (command.name === "model") {
+        const result = await source.executeSlashCommand({ command: command.name, args: command.args, sessionId: state.session?.id });
+        if (command.args.trim()) {
+            const status = await source.getStatus({ sessionId: state.session?.id });
+            setState((current) => applyCommandResultToState(current, command, result.descriptor, status));
+            return;
+        }
+        const providers = modelProviderItemsFromActionResult(result.rawResult, result.descriptor);
+        if (providers.length === 0) {
+            setState((current) => applyCommandResultToState(current, command, result.descriptor, current.status));
+            return;
+        }
+        setState((current) => withPickerOverlay({
+            ...current,
+            mode: "picker",
+            message: "Select a provider, then choose a model.",
+            error: undefined,
+        }, modelProviderPickerState(providers)));
+        return;
+    }
+    if (command.name === "login") {
+        const result = await source.executeSlashCommand({ command: command.name, args: command.args, sessionId: state.session?.id });
+        if (command.args.trim()) {
+            const status = await source.getStatus({ sessionId: state.session?.id });
+            setState((current) => applyCommandResultToState(current, command, result.descriptor, status));
+            return;
+        }
+        const providers = loginProviderItemsFromActionResult(result.rawResult, result.descriptor);
+        if (providers.length === 0) {
+            setState((current) => applyCommandResultToState(current, command, result.descriptor, current.status));
+            return;
+        }
+        setState((current) => withPickerOverlay({
+            ...current,
+            mode: "picker",
+            message: "Select a login provider, then choose a terminal-safe auth method.",
+            error: undefined,
+        }, loginProviderPickerState(providers)));
+        return;
+    }
+    if (command.name === "fork-candidates") {
+        const result = await source.executeSlashCommand({ command: command.name, args: command.args, sessionId: state.session?.id });
+        const descriptor = result.descriptor;
+        if (command.args.trim() || descriptor.kind !== "menu" || descriptor.items.length === 0) {
+            const status = await source.getStatus({ sessionId: state.session?.id });
+            if (result.openSessionId && result.openSessionId !== state.session?.id) {
+                const localRows = commandResultDescriptorRows(command, descriptor, status, state.session, 0);
+                await openSession(result.openSessionId, undefined, localRows);
+            }
+            else
+                setState((current) => applyCommandResultToState(current, command, descriptor, status));
+            return;
+        }
+        setState((current) => withPickerOverlay({
+            ...current,
+            mode: "picker",
+            message: "Select a fork candidate with arrow keys, then Enter.",
+            error: undefined,
+        }, forkCandidatePickerState(descriptor.items)));
+        return;
+    }
+    const handled = await executeSharedSlashCommand(command, source, state, setState, openSession);
+    if (handled)
+        return;
+    setState((current) => applyCommandResultToState(current, command, { kind: "unsupported", command: command.raw, reason: "Use /help for supported CLI commands." }, current.status));
+}
+async function executeSharedSlashCommand(command, source, state, setState, openSession) {
+    const catalog = state.slashCommands ?? buildSlashCommandCatalog();
+    const descriptor = catalog.find((candidate) => candidate.slash === `/${command.name}` || candidate.aliases?.includes(`/${command.name}`));
+    if (!descriptor || descriptor.group === "cli" || descriptor.group === "navigation")
+        return false;
+    const result = await source.executeSlashCommand({ command: command.name, args: command.args, sessionId: state.session?.id });
+    const status = await source.getStatus({ sessionId: state.session?.id });
+    if (result.openSessionId && result.openSessionId !== state.session?.id) {
+        const localRows = commandResultDescriptorRows(command, result.descriptor, status, state.session, 0);
+        await openSession(result.openSessionId, undefined, localRows);
+        return true;
+    }
+    setState((current) => applyCommandResultToState(current, command, result.descriptor, status));
+    return true;
+}
+const THINKING_LEVELS = ["current/default", "off", "minimal", "low", "medium", "high", "xhigh"];
+const APPLY_THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh"]);
+async function selectCommandMenuItem(picker, item, source, state, setState, openSession) {
+    if (item.disabled) {
+        setState((current) => ({ ...current, message: item.description ? `${item.label}: ${item.description}` : `${item.label} is unavailable.`, error: undefined }));
+        return;
+    }
+    if (picker.action === "thinking-level") {
+        const level = String(item.value ?? item.id);
+        if (level === "current/default") {
+            setState((current) => ({ ...current, mode: "transcript", picker: undefined, overlayStack: popInkSessionOverlay(current.overlayStack), message: "Kept current/default thinking level.", error: undefined }));
+            return;
+        }
+        validateThinkingLevel(level);
+        const result = await source.executeSlashCommand({ command: "thinking", args: level, sessionId: state.session?.id });
+        const status = await source.getStatus({ sessionId: state.session?.id });
+        setState((current) => applyCommandResultToState(current, { name: "thinking", args: level, raw: `/thinking ${level}` }, result.descriptor, status));
+        return;
+    }
+    if (picker.action === "model-provider") {
+        const provider = item.value;
+        const models = provider?.models ?? [];
+        const next = modelChoicePickerState(item, models, picker);
+        setState((current) => withPickerOverlay({ ...current, mode: "picker", message: models.length === 0 ? `${item.label} has no terminal-selectable models.` : `Select model for ${item.label}.`, error: undefined }, next));
+        return;
+    }
+    if (picker.action === "model-choice") {
+        const providerValue = picker.parent?.items[picker.parent.selectedIndex]?.value;
+        const itemValue = item.value && typeof item.value === "object" ? item.value : undefined;
+        const providerId = String(providerValue?.id ?? itemValue?.provider ?? "");
+        const modelId = String(itemValue?.id ?? item.id);
+        const args = providerId ? `${providerId}/${modelId}` : modelId;
+        const result = await source.executeSlashCommand({ command: "model", args, sessionId: state.session?.id });
+        const status = await source.getStatus({ sessionId: state.session?.id });
+        const command = { name: "model", args, raw: `/model ${args}` };
+        if (result.openSessionId && result.openSessionId !== state.session?.id) {
+            const localRows = commandResultDescriptorRows(command, result.descriptor, status, state.session, 0);
+            await openSession(result.openSessionId, undefined, localRows);
+            return;
+        }
+        setState((current) => applyCommandResultToState(current, command, result.descriptor, status));
+        return;
+    }
+    if (picker.action === "login-provider") {
+        const provider = item.value;
+        const methods = provider?.authMethods ?? [];
+        const next = loginMethodPickerState(item, methods, picker);
+        setState((current) => withPickerOverlay({ ...current, mode: "picker", message: methods.length === 0 ? `${item.label} has no terminal auth methods.` : `Select auth method for ${item.label}.`, error: undefined }, next));
+        return;
+    }
+    if (picker.action === "login-method") {
+        const providerValue = picker.parent?.items[picker.parent.selectedIndex]?.value;
+        const providerId = String(providerValue?.id ?? "");
+        const methodId = String(item.id);
+        const args = providerId ? `${providerId}/${methodId}` : methodId;
+        const result = await source.executeSlashCommand({ command: "login", args, sessionId: state.session?.id });
+        const status = await source.getStatus({ sessionId: state.session?.id });
+        setState((current) => applyCommandResultToState(current, { name: "login", args, raw: `/login ${args}` }, result.descriptor, status));
+        return;
+    }
+    if (picker.action === "fork-candidate") {
+        const result = await source.executeSlashCommand({ command: "fork-candidates", args: item.id, sessionId: state.session?.id });
+        const status = await source.getStatus({ sessionId: state.session?.id });
+        const command = { name: "fork-candidates", args: item.id, raw: `/fork-candidates ${item.id}` };
+        if (result.openSessionId && result.openSessionId !== state.session?.id) {
+            const localRows = commandResultDescriptorRows(command, result.descriptor, status, state.session, 0);
+            await openSession(result.openSessionId, undefined, localRows);
+            return;
+        }
+        setState((current) => applyCommandResultToState(current, command, result.descriptor, status));
+        return;
+    }
+    setState((current) => ({ ...current, mode: "transcript", picker: undefined, message: `${item.label} selected.`, error: undefined }));
+}
+function thinkingPickerState() {
+    return {
+        kind: "command-menu",
+        action: "thinking-level",
+        commandName: "thinking",
+        title: "Select thinking level",
+        items: THINKING_LEVELS.map((level) => ({ id: level, kind: "command-option", label: level, value: level, description: level === "current/default" ? "Keep current runtime/default setting" : `Set thinking to ${level}` })),
+        selectedIndex: 0,
+        emptyMessage: "No thinking levels are available.",
+    };
+}
+function validateThinkingLevel(value) {
+    const level = value.trim().toLowerCase();
+    if (!APPLY_THINKING_LEVELS.has(level))
+        throw new Error(`Unsupported thinking level "${value}". Use off, minimal, low, medium, high, or xhigh.`);
+}
+function modelProviderPickerState(providers) {
+    return {
+        kind: "command-menu",
+        action: "model-provider",
+        commandName: "model",
+        title: "Select model provider",
+        items: providers.map((provider) => ({ id: provider.id, kind: "command-option", label: provider.label, description: provider.description, value: provider, disabled: provider.disabled })),
+        selectedIndex: 0,
+        emptyMessage: "No model providers are available.",
+    };
+}
+function modelChoicePickerState(providerItem, models, parent) {
+    return {
+        kind: "command-menu",
+        action: "model-choice",
+        commandName: "model",
+        title: `Select model for ${providerItem.label}`,
+        items: models.map((model) => ({ id: model.id, kind: "command-option", label: model.label, description: model.description, value: { ...model, provider: providerItem.id }, disabled: model.disabled })),
+        selectedIndex: 0,
+        emptyMessage: `${providerItem.label} did not return any terminal-selectable models.`,
+        parent,
+    };
+}
+function loginProviderPickerState(providers) {
+    return {
+        kind: "command-menu",
+        action: "login-provider",
+        commandName: "login",
+        title: "Select login provider",
+        items: providers.map((provider) => ({ id: provider.id, kind: "command-option", label: provider.label, description: provider.description, value: provider, disabled: provider.disabled })),
+        selectedIndex: 0,
+        emptyMessage: "No login providers are available.",
+    };
+}
+function loginMethodPickerState(providerItem, methods, parent) {
+    return {
+        kind: "command-menu",
+        action: "login-method",
+        commandName: "login",
+        title: `Select auth method for ${providerItem.label}`,
+        items: methods.map((method) => ({ id: method.id, kind: "command-option", label: method.label, description: method.description, value: { ...method, provider: providerItem.id }, disabled: method.disabled })),
+        selectedIndex: 0,
+        emptyMessage: `${providerItem.label} did not return any terminal auth methods.`,
+        parent,
+    };
+}
+function forkCandidatePickerState(items) {
+    return {
+        kind: "command-menu",
+        action: "fork-candidate",
+        commandName: "fork-candidates",
+        title: "Select fork candidate",
+        items: items.map((item) => ({ id: item.id, kind: "command-option", label: item.label, description: item.description, value: item, disabled: item.disabled })),
+        selectedIndex: 0,
+        emptyMessage: "No fork candidates are available.",
+    };
+}
+function modelProviderItemsFromActionResult(rawResult, descriptor) {
+    const raw = unwrapActionPayload(rawResult);
+    const providers = recordsField(raw, "providers");
+    if (providers.length > 0)
+        return providers.map((provider, index) => ({
+            id: stringField(provider, "id") ?? stringField(provider, "provider") ?? `provider-${index}`,
+            label: stringField(provider, "label") ?? stringField(provider, "name") ?? stringField(provider, "provider") ?? `Provider ${index + 1}`,
+            description: stringField(provider, "description") ?? (provider.disabled === true ? stringField(provider, "reason") : undefined),
+            disabled: provider.disabled === true,
+            models: recordsField(provider, "models").map((model, modelIndex) => ({
+                id: stringField(model, "id") ?? stringField(model, "model") ?? `model-${modelIndex}`,
+                label: stringField(model, "label") ?? stringField(model, "name") ?? stringField(model, "model") ?? stringField(model, "id") ?? `Model ${modelIndex + 1}`,
+                description: stringField(model, "description") ?? (model.disabled === true ? stringField(model, "reason") : undefined),
+                disabled: model.disabled === true,
+                value: model,
+            })),
+        }));
+    return descriptor.kind === "menu" ? descriptor.items.map((item) => ({ ...item, models: [] })) : [];
+}
+function loginProviderItemsFromActionResult(rawResult, descriptor) {
+    const raw = unwrapActionPayload(rawResult);
+    const providers = recordsField(raw, "providers");
+    if (providers.length > 0)
+        return providers.map((provider, index) => {
+            const id = stringField(provider, "id") ?? stringField(provider, "provider") ?? `provider-${index}`;
+            const configured = provider.configured === true ? "configured" : provider.configured === false ? "not configured" : undefined;
+            return {
+                id,
+                label: stringField(provider, "label") ?? stringField(provider, "name") ?? id,
+                description: [configured, stringField(provider, "description")].filter(Boolean).join(" | ") || undefined,
+                disabled: provider.disabled === true,
+                authMethods: authMethodItems(provider),
+            };
+        });
+    return descriptor.kind === "menu" ? descriptor.items.map((item) => ({ ...item, authMethods: [] })) : [];
+}
+function authMethodItems(provider) {
+    const records = recordsField(provider, "authMethods");
+    if (records.length > 0)
+        return records.map((method, index) => ({
+            id: stringField(method, "id") ?? stringField(method, "method") ?? `method-${index}`,
+            label: authMethodLabel(stringField(method, "label") ?? stringField(method, "name") ?? stringField(method, "method") ?? stringField(method, "id") ?? `Method ${index + 1}`),
+            description: stringField(method, "description") ?? stringField(method, "reason"),
+            disabled: method.disabled === true,
+            value: method,
+        }));
+    return arrayStringField(provider, "authMethods").map((method) => ({ id: method, label: authMethodLabel(method), description: authMethodDescription(method) }));
+}
+function authMethodLabel(method) {
+    if (method === "device_code")
+        return "Device code / OAuth";
+    if (method === "api_key")
+        return "API key";
+    return method;
+}
+function authMethodDescription(method) {
+    if (method === "device_code")
+        return "Open a URL and complete sign-in in any browser.";
+    if (method === "api_key")
+        return "Secret input is not echoed; this flow shows safe setup instructions.";
+    return undefined;
+}
+function unwrapActionPayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const record = value;
+    if (record.ok === true && "result" in record)
+        return record.result;
+    if (record.success === true && "data" in record)
+        return record.data;
+    return value;
+}
+function recordsField(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    const field = value[key];
+    return Array.isArray(field) ? field.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)) : [];
+}
+function arrayStringField(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    const field = value[key];
+    return Array.isArray(field) ? field.filter((item) => typeof item === "string") : [];
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function applyCommandResultToState(current, command, descriptor, status) {
+    return normalizeInkRowSelection({
+        ...current,
+        ...(status ? { status } : {}),
+        mode: "transcript",
+        picker: undefined,
+        slashSuggestions: undefined,
+        overlayStack: undefined,
+        rows: appendCommandResultRows(current.rows, command, descriptor, status, current.session),
+        message: undefined,
+        error: undefined,
+    });
+}
+export function appendCommandResultRows(rows, command, descriptor, status, session) {
+    return [...rows, ...commandResultDescriptorRows(command, descriptor, status, session, rows.length)];
+}
+export function commandResultDescriptorRows(command, descriptor, status, session, startIndex = 0) {
+    const commandLabel = command.raw || `/${command.name}${command.args ? ` ${command.args}` : ""}`;
+    const commandRow = {
+        id: `cli-command:${startIndex}:${command.name}`,
+        kind: "execution.command",
+        status: descriptor.kind === "error" ? "error" : "done",
+        lines: [{ prefix: "bullet", tokens: [{ text: `Ran ${commandLabel}`, tone: "yellow", weight: "semibold" }] }],
+        sourceNodeIds: [`cli-command:${startIndex}:${command.name}`],
+    };
+    const resultRow = commandResultDescriptorRow(command, descriptor, status, session, startIndex + 1);
+    return resultRow ? [commandRow, resultRow] : [commandRow];
+}
+function commandResultDescriptorRow(command, descriptor, status, session, index) {
+    const id = `cli-command-result:${index}:${command.name}`;
+    if (descriptor.kind === "status") {
+        return {
+            id,
+            kind: "tool.status",
+            status: "done",
+            lines: [],
+            output: commandStatusRowOutput(descriptor.status, status, session),
+            sourceNodeIds: [id],
+        };
+    }
+    if (descriptor.kind === "error") {
+        return { id, kind: "error", status: "error", lines: [], error: descriptor.message, sourceNodeIds: [id] };
+    }
+    return {
+        id,
+        kind: "execution.command",
+        status: descriptor.kind === "unsupported" ? "error" : "done",
+        lines: [],
+        output: renderCommandResultDescriptorText(descriptor, session),
+        sourceNodeIds: [id],
+    };
+}
+function commandStatusRowOutput(rawStatus, status, session) {
+    const descriptorStatus = rawStatus && typeof rawStatus === "object" && !Array.isArray(rawStatus) ? rawStatus : {};
+    return {
+        ...descriptorStatus,
+        piboSessionId: session?.id ?? status?.activeSessionId ?? descriptorStatus.piboSessionId,
+        sessionTitle: session?.title,
+        profile: session?.profile ?? session?.agentId ?? status?.activeAgentId,
+        activeModel: status?.activeModel ?? descriptorStatus.activeModel,
+        mode: status?.mode ?? descriptorStatus.mode,
+        connected: status?.connected,
+        queuedMessages: status?.queuedMessages ?? descriptorStatus.queuedMessages,
+        processing: status?.processing ?? descriptorStatus.processing,
+        streaming: status?.streaming ?? descriptorStatus.streaming,
+        cwd: status?.cwd ?? descriptorStatus.cwd,
+        contextUsage: status?.contextUsage ?? descriptorStatus.contextUsage,
+        providerUsage: status?.providerUsage ?? descriptorStatus.providerUsage,
+        activeTools: status?.activeTools ?? descriptorStatus.activeTools,
+        enabledTools: status?.enabledTools ?? descriptorStatus.enabledTools,
+        disposed: status?.disposed ?? descriptorStatus.disposed,
+        thinkingLevel: status?.thinkingLevel ?? descriptorStatus.thinkingLevel,
+        fastMode: status?.fastMode ?? descriptorStatus.fastMode,
+        warnings: status?.warnings ?? descriptorStatus.warnings,
+        errors: status?.errors ?? descriptorStatus.errors,
+        message: status?.message ?? descriptorStatus.message,
+    };
+}
+export function renderCommandResultDescriptorText(descriptor, session) {
+    if (descriptor.kind === "text")
+        return [descriptor.title, descriptor.text].filter(Boolean).join(": ");
+    if (descriptor.kind === "unsupported")
+        return `${descriptor.command}: ${descriptor.reason}`;
+    if (descriptor.kind === "error")
+        return `${descriptor.title ?? "Error"}: ${descriptor.message}`;
+    if (descriptor.kind === "session-link")
+        return `${descriptor.title}: ${descriptor.label ?? "session"} ${descriptor.sessionId}${descriptor.roomLabel ? ` in ${descriptor.roomLabel}` : descriptor.roomId ? ` in room ${descriptor.roomId}` : ""}`;
+    if (descriptor.kind === "status")
+        return renderCliStatusCardText(descriptor.status, session, descriptor.title);
+    if (descriptor.kind === "menu")
+        return [descriptor.title, ...descriptor.items.map((item) => `  ${item.disabled ? "-" : "•"} ${item.label}${item.description ? ` — ${item.description}` : ""}`)].join("\n");
+    return `${descriptor.title ?? "Result"}: ${redactCliSessionStatusText(JSON.stringify(descriptor.value, null, 2))}`;
+}
+export function renderCliStatusCardText(status, session, title = "Status") {
+    const summary = formatCliSessionStatus(status, session);
+    const viewModel = buildTerminalStatusViewModel(statusViewModelInput(status, session));
+    const lines = [`${title}: ${summary}`];
+    for (const field of viewModel.fields)
+        lines.push(`  ${field.label}: ${field.value}`);
+    for (const progress of viewModel.progress)
+        lines.push(`  ${progress.label}: ${progressBarText(progress, progress.state === "available" ? 18 : 12)} — ${progress.text}`);
+    for (const warning of viewModel.warnings)
+        lines.push(`  Warning: ${warning}`);
+    for (const error of viewModel.errors)
+        lines.push(`  Error: ${error}`);
+    return lines.join("\n");
+}
+function statusViewModelInput(status, session) {
+    const runtimeState = status?.connected === false ? "disconnected" : status?.processing ? "processing" : status?.streaming ? "streaming" : status?.mode ?? "unknown";
+    return {
+        session: { id: session?.id ?? status?.activeSessionId, title: session?.title, profile: session?.profile ?? session?.agentId ?? status?.activeAgentId, status: session?.status },
+        model: status?.activeModel ?? session?.model ?? { provider: "unknown", id: "unknown", label: "unknown" },
+        runtime: { state: runtimeState, connected: status?.connected, queuedMessages: status?.queuedMessages, processing: status?.processing, streaming: status?.streaming, disposed: status?.disposed },
+        cwd: status?.cwd,
+        contextUsage: status?.contextUsage,
+        providerUsage: status?.providerUsage,
+        tools: { enabled: status?.enabledTools, active: status?.activeTools },
+        thinking: status?.thinkingLevel ? { level: status.thinkingLevel } : undefined,
+        fastMode: status?.fastMode,
+        warnings: status?.warnings,
+        errors: status?.errors,
+        message: status?.message,
+    };
+}
+function compactOverlayTitle(title) {
+    return title
+        .replace(/^Select existing agent\/profile$/i, "select agent")
+        .replace(/^Select thinking level$/i, "select thinking level")
+        .replace(/^Select model provider$/i, "select model provider")
+        .replace(/^Select login provider$/i, "select login provider")
+        .replace(/^Select fork candidate$/i, "select fork candidate")
+        .replace(/^Select auth method for /i, "select login method — ")
+        .replace(/^Select model for /i, "select model — ")
+        .replace(/^Select session in /i, "select session — ")
+        .replace(/^Select room for new session$/i, "select room — new session")
+        .replace(/^Select active room$/i, "select room")
+        .replace(/^Select room for sessions$/i, "select room — sessions")
+        .replace(/^Select room for /i, "select room — ")
+        .replace(/^Select /i, "select ");
+}
+function formatOverlayItemLine(item, selected, _max) {
+    const marker = selected ? "❯" : " ";
+    const disabled = item.disabled === true;
+    const availability = disabled ? "× " : "";
+    const secondary = item.description ? ` · ${redactCliSessionStatusText(item.description)}` : "";
+    return `${marker} ${availability}${redactCliSessionStatusText(item.label)}${secondary}`;
+}
+function overlayItemColor(selected, disabled) {
+    if (disabled)
+        return "gray";
+    return selected ? "green" : "white";
+}
+function abbreviateIdentifier(value, _max = 24) {
+    return value;
+}
+function itemMetadata(...parts) {
+    return parts.filter(Boolean).join(" · ") || undefined;
+}
+function modelLabel(model) {
+    if (!model)
+        return undefined;
+    return `${model.provider}/${model.id}`;
+}
+function roomPickerItem(room) {
+    const label = room.title || abbreviateIdentifier(room.id) || room.id;
+    return {
+        id: room.id,
+        kind: "room",
+        roomId: room.id,
+        label,
+        description: itemMetadata(room.isDefault ? "default" : undefined, room.description, `room ${abbreviateIdentifier(room.id)}`),
+    };
+}
+function sessionPickerItem(session) {
+    return {
+        id: session.id,
+        kind: "session",
+        roomId: session.roomId,
+        label: session.title || abbreviateIdentifier(session.id) || session.id,
+        description: itemMetadata(session.status, session.profile || session.agentId, modelLabel(session.model), session.updatedAt ? `updated ${session.updatedAt}` : undefined, abbreviateIdentifier(session.id)),
+    };
+}
+function agentPickerItem(agent) {
+    return {
+        id: agent.id,
+        label: agent.name || agent.id,
+        description: itemMetadata(agent.profileName, agent.description, IDENTIFIER_PATTERN.test(agent.id) ? abbreviateIdentifier(agent.id) : undefined),
+    };
+}
+function renderBoundedTextLines(value, color, _max, keyPrefix) {
+    return value.split(/\r?\n/).map((line, index) => React.createElement(Text, { key: `${keyPrefix}-${index}`, color }, line));
+}
+export function formatStatusHeaderLines(state, max = 220) {
+    const source = state.status?.source ?? "starting";
+    const room = statusHeaderRoom(state);
+    const session = state.session?.title ?? state.status?.activeSessionId ?? "no session";
+    const agent = state.session?.agentId ?? state.session?.profile ?? state.status?.activeAgentId ?? "default";
+    const model = state.status?.activeModel ? `${state.status.activeModel.provider}/${state.status.activeModel.id}` : "model unknown";
+    const mode = state.mode === "transcript" ? "transcript" : state.mode;
+    const parts = [`pibo sessions`, source, mode, room ? `room ${room}` : undefined, `session ${session}`, `agent ${agent}`, `model ${model}`].filter(Boolean);
+    const full = parts.join(" · ");
+    if (max >= 112 || full.length <= max)
+        return [full];
+    return [
+        `pibo sessions · ${source} · ${mode}`,
+        room ? `room ${room}` : "room none",
+        `session ${session}`,
+        `agent ${agent} · model ${model}`,
+    ];
+}
+function statusHeaderRoom(state) {
+    const title = state.activeRoom?.title?.trim();
+    if (title)
+        return title;
+    return state.status?.activeRoomId ?? state.session?.roomId;
+}
+export function createCliSessionCleanup(closeOpenSession, closeSource) {
+    let cleanedUp = false;
+    return () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        try {
+            closeOpenSession();
+        }
+        finally {
+            try {
+                closeSource();
+            }
+            catch {
+                // Exit cleanup must be best-effort so terminal shutdown can finish.
+            }
+        }
+    };
+}
+async function safeListSlashCommands(source) {
+    try {
+        return await source.listSlashCommands();
+    }
+    catch {
+        return buildSlashCommandCatalog();
+    }
+}
+async function safeListRooms(source) {
+    try {
+        return await source.listRooms();
+    }
+    catch {
+        return [];
+    }
+}
+function emptySessionRecoveryMessage(status, rooms) {
+    if (status.rooms === "unsupported")
+        return "No sessions found and this source cannot list rooms. Use /new to create a local CLI session.";
+    if (rooms.length === 0)
+        return "No sessions or rooms found. Use /new to create a local CLI session.";
+    return "No sessions found. Use /new to create a local CLI session.";
+}
+export function formatCliSessionError(error) {
+    const message = redactCliSessionStatusText(errorMessage(error));
+    if (isCliSourceError(error)) {
+        if (error.code === "source_closed")
+            return `${message}. Recovery: restart pibo tui:sessions.`;
+        if (error.code === "session_not_found")
+            return `${message}. Recovery: use /session to select another session or /new to create one.`;
+        if (error.code === "agent_not_found")
+            return `${message}. Recovery: use /agent to pick an available existing profile.`;
+        if (error.code === "empty_message")
+            return `${message}. Type a message or use /help.`;
+        return `${message}. Recovery: check local Pibo state, then use /status, /session, or /new.`;
+    }
+    return `${message}. Recovery: use /status for source state or restart the CLI if the problem persists.`;
+}
+function redactCliSessionStatusText(text) {
+    return text
+        .replace(/\b([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD)[A-Z0-9_]*)\s*=\s*([^\s]+)/gi, "$1=[redacted]")
+        .replace(/\b(api[_-]?key|token|secret|password)\s*[:=]\s*([^\s]+)/gi, "$1=[redacted]")
+        .replace(/\b(?:sk|pk|pibo|ghp|github_pat)_[A-Za-z0-9_\-]{8,}\b/g, "[redacted]");
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}