@vibesdotdev/chat 0.0.0-stage → 1.0.0-rc.0

package/dist/tui/chat.tui-app.impl.consumer.js

@@ -0,0 +1,724 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { settleNow, CaughtFailureSchema as ChatCaughtFailureSchema } from '@vibesdotdev/kernel';
+import * as z from 'zod/v4';
+import { ChatRoomSettingsPatchSchema } from "../client/schemas/settings.js";
+import { readRecord, readString, readStringArray } from "./utils/descriptor-read.js";
+import { mapUnifiedMessageToLegacyMessage } from "../svelte/stores/chat/svelte/runtime-chat-mappers.js";
+import { formatChatApprovalPreview } from "../schemas/approval-preview.js";
+/**
+ * Chat Client — tui/app implementation (consumer).
+ *
+ * Three-pane layout:
+ *  - Left sidebar: rooms list (live via `client.rooms.subscribe`).
+ *  - Right top: scrolling message history for the active room (live via
+ *    `room.messages.subscribe`).
+ *  - Right bottom: composer pane (input + send).
+ *
+ * Keyboard:
+ *  - `r`     → REFRESH the `chat.rooms` state.
+ *  - `Ctrl+S` → SEND the composer content.
+ *  - `Esc`   → deselect active room; if none active, navigate back to `/`.
+ *
+ * Data flows ONLY through:
+ *  - `useTuiState(chatRoomsStateKey)` for rooms + messages.
+ *  - `useTuiDispatch(chatRoomsStateKey)` for SELECT_ROOM / SEND_MESSAGE / REFRESH.
+ *
+ * Zero ambient env reads, zero direct fetch, zero `new RuntimeChatClient()` —
+ * the state impl is the single boundary into the chat runtime client.
+ */
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useViewport } from '@vibesdotdev/tui';
+import { ToolWidgetRuntimeRegistrar } from '@vibesdotdev/tools/tui/tool-widgets';
+import { useTuiState, useTuiDispatch } from '@vibesdotdev/tui/state/hooks';
+import { HStack, VStack } from '@vibesdotdev/tui/components/layout';
+import { DSButton, DSStatus, DSText, HeaderBar, Panel } from '@vibesdotdev/tui/components/content';
+import { PageHeader, PageLayout } from '@vibesdotdev/tui/components/page';
+import { dsBase, dsColors, dsSpace } from '@vibesdotdev/tui/theme';
+import { useContributeScreenStatus } from '@vibesdotdev/tui/shell';
+import { useKeyboardLayer, useInputModeStore } from '@vibesdotdev/tui/input';
+import { OptionalChatKeybindHandlers } from "./ChatKeybindHandlers.js";
+import { ErrorBoundary } from '@vibesdotdev/tui/components/feedback';
+import { ChatSearchOverlay } from "./components/ChatSearchOverlay.js";
+import { ChatExportOverlay } from "./components/ChatExportOverlay.js";
+import { exportToJSON, exportToMarkdown } from "./utils/export-chat.js";
+import { saveExportToFile } from "./utils/export-chat.impl.consumer.js";
+import { isCapabilityError } from '@vibesdotdev/kernel';
+import { useChatUIStore } from "./stores/index.js";
+import { chatRoomsStateKey } from "./chat.tui-state.key.js";
+import { RoomsListPane } from "./components/RoomsListPane.js";
+import { ComposerPane } from "./components/ComposerPane.js";
+import { ChatLayout } from "./components/ChatLayout.js";
+import { ChatRoomHistory } from "./components/ChatRoomHistory.js";
+import { ChatAgentSelectorOverlay } from "./components/ChatAgentSelectorOverlay.js";
+function roomTitle(room) {
+    if (!room)
+        return 'No room selected';
+    if (room.title?.trim())
+        return room.title;
+    return '(untitled)';
+}
+function truncateInline(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    if (maxLength <= 1)
+        return value.slice(0, maxLength);
+    return `${value.slice(0, maxLength - 1).trimEnd()}…`;
+}
+/**
+ * Ambient, friendly model token — the local-first benefit the user cares about,
+ * not the fully-qualified provider id. `lmstudio:qwen/qwen3.6-instruct` → `qwen3.6`.
+ */
+function formatModelShort(modelLabel) {
+    const basename = modelLabel.split(/[/:]/).pop()?.trim() ?? modelLabel;
+    const dash = basename.indexOf('-');
+    const head = dash > 0 ? basename.slice(0, dash) : basename;
+    const friendly = dash > 0 && /\d/.test(head) ? head : basename;
+    return truncateInline(friendly, 18);
+}
+/**
+ * One quiet, ambient config line for the composer — mode · [agent] · model.
+ * Replaces the five-chip ChatSetupBar (config is ambient, not architectural —
+ * TUI-WEB-PARITY-DESIGN.md §config). The agent is omitted when absent: "no agent"
+ * is the benign default, and the `@ agent` hint already says how to add one. The
+ * local-first `local` token is stated once, by the gateway status line (auth),
+ * not repeated here — a local model name already implies on-device execution.
+ */
+function formatAmbientConfig({ modeLabel, agentSummary, modelLabel }) {
+    const hasAgent = agentSummary.trim().length > 0 && agentSummary !== 'no agent';
+    return [modeLabel, hasAgent ? agentSummary : '', formatModelShort(modelLabel)]
+        .filter((part) => part.trim().length > 0)
+        .join(' · ');
+}
+function activeRoomMetadata(room) {
+    return readRecord(room?.metadata);
+}
+function activeModeDescriptor(room, modes) {
+    const metadata = activeRoomMetadata(room);
+    const modeId = readString(metadata.modeId) ??
+        readString(metadata.roomMode) ??
+        readString(room?.roomMode) ??
+        readString(readRecord(room).type);
+    if (!modeId)
+        return null;
+    return modes.find((mode) => mode.id === modeId) ?? null;
+}
+function formatModeLabel(room, modes) {
+    const mode = activeModeDescriptor(room, modes);
+    if (mode?.name)
+        return mode.name;
+    const metadata = activeRoomMetadata(room);
+    return (readString(metadata.modeId) ??
+        readString(metadata.roomMode) ??
+        readString(room?.roomMode) ??
+        readString(readRecord(room).type) ??
+        'standard');
+}
+function formatModelLabel(room) {
+    const metadata = activeRoomMetadata(room);
+    return (readString(metadata.modelId) ??
+        readString(readRecord(room).modelId) ??
+        'default model');
+}
+function formatAgentSummary(participants) {
+    const agents = participants.filter((participant) => participant.type === 'agent');
+    if (agents.length === 0)
+        return 'no agent';
+    if (agents.length === 1)
+        return agents[0]?.name ?? agents[0]?.id ?? '1 agent';
+    return `${agents.length} agents`;
+}
+function agentInputsFromIds(agentIds, agents) {
+    const byId = new Map(agents.map((agent) => [agent.id, agent]));
+    return agentIds.flatMap((id) => {
+        const agent = byId.get(id);
+        if (!agent)
+            return [];
+        return [
+            {
+                id: agent.id,
+                type: 'agent',
+                name: agent.name,
+                description: agent.description,
+                responseStyle: 'auto',
+                enabled: true,
+                source: 'runtime'
+            }
+        ];
+    });
+}
+function formatVisibilitySummary(room) {
+    const metadata = activeRoomMetadata(room);
+    const visibility = readString(metadata.visibility) ??
+        readString(readRecord(room).visibility);
+    const maxTokens = metadata.maxTokens;
+    const tokens = z.number().finite().safeParse(maxTokens).success
+        ? `${maxTokens} tokens`
+        : maxTokens === null
+            ? 'default tokens'
+            : null;
+    if (visibility && tokens)
+        return `${visibility} · ${tokens}`;
+    if (visibility)
+        return visibility;
+    if (tokens)
+        return tokens;
+    return undefined;
+}
+function settingsPatchFrom(value) {
+    const parsed = ChatRoomSettingsPatchSchema.safeParse(value);
+    return parsed.success && Object.keys(parsed.data).length ? parsed.data : null;
+}
+function ChatRuntimeStatus({ error, onRefresh, onHome }) {
+    const { width, height } = useViewport();
+    const compact = width <= 90 || height <= 26;
+    const isError = Boolean(error);
+    const detail = error ??
+        (compact
+            ? 'Connecting rooms and messages.'
+            : 'Connecting to rooms, message history, and the composer.');
+    const nextStep = isError
+        ? 'Refresh room sync or open logs for diagnostics.'
+        : 'Studio will open the room list as soon as chat state is ready.';
+    return (_jsxs(VStack, { grow: true, gap: 0, style: {
+            flexShrink: 1,
+            minHeight: 0
+        }, children: [_jsx(HeaderBar, { left: _jsxs(_Fragment, { children: [_jsx(DSStatus, { status: isError ? 'error' : 'loading', label: isError ? 'Chat rooms could not open' : 'Opening chat' }), _jsx("text", { style: { fg: dsBase.mutedForeground }, children: `· ${detail}` })] }), right: _jsxs(_Fragment, { children: [_jsx(DSButton, { label: "Refresh", size: compact ? 'xs' : 'sm', color: isError ? 'danger' : 'primary', variant: "ghost", onClick: onRefresh }), onHome && (_jsx(DSButton, { label: "Home", size: compact ? 'xs' : 'sm', color: "neutral", variant: "ghost", onClick: onHome }))] }) }), _jsxs(VStack, { gap: compact ? 0 : dsSpace.xs, style: {
+                    flexGrow: 1,
+                    flexShrink: 1,
+                    minHeight: 0,
+                    justifyContent: 'center',
+                    paddingLeft: compact ? dsSpace.sm : dsSpace.md,
+                    paddingRight: compact ? dsSpace.sm : dsSpace.md
+                }, children: [_jsx("text", { style: { fg: isError ? dsColors.danger.solid : dsColors.primary.solid }, children: isError ? 'Chat state is unavailable.' : 'Preparing the live chat workspace.' }), !compact && _jsx("text", { style: { fg: dsBase.mutedForeground }, children: nextStep })] })] }));
+}
+function ChatRoomChooser({ rooms, selectedId, onSelect, onNew, width, height, compact, denseList, queuedMessage }) {
+    const hasRooms = rooms.length > 0;
+    const previewRoom = rooms.find((room) => String(room.id) === selectedId) ?? rooms[0];
+    const previewMode = formatModeLabel(previewRoom, []);
+    const previewVisibility = formatVisibilitySummary(previewRoom);
+    const previewTitle = truncateInline(roomTitle(previewRoom), compact ? 28 : 32);
+    const chooserPaneWidth = Math.max(34, Math.min(48, Math.floor(width * 0.38)));
+    const emptyPaneWidth = Math.max(58, Math.min(72, width - 8));
+    const roomPaneWidth = hasRooms ? chooserPaneWidth : emptyPaneWidth;
+    const roomListTextWidth = compact ? Math.max(24, width - 16) : Math.max(24, roomPaneWidth - 8);
+    const previewRoomId = previewRoom ? String(previewRoom.id) : null;
+    return (_jsxs(VStack, { grow: true, gap: 0, children: [_jsx(HeaderBar, { left: _jsxs(_Fragment, { children: [_jsx("text", { style: { fg: hasRooms ? dsColors.primary.solid : dsColors.warning.solid }, children: hasRooms ? `Choose a room · ${rooms.length} available` : 'No chat rooms yet' }), _jsx("text", { style: { fg: dsBase.mutedForeground }, children: queuedMessage
+                                ? 'Message ready · choose a room to send'
+                                : hasRooms
+                                    ? 'Pick the conversation to continue'
+                                    : 'Ctrl+R refresh · Esc Home' })] }), right: _jsx(DSButton, { label: "New conversation", variant: "filled", color: "primary", size: compact ? 'xs' : 'sm', onClick: onNew }) }), _jsxs(HStack, { gap: compact ? 0 : dsSpace.md, align: "stretch", style: {
+                    flexGrow: 1,
+                    flexShrink: 1,
+                    minHeight: 0,
+                    overflow: 'hidden',
+                    paddingLeft: compact ? 0 : dsSpace.md,
+                    paddingRight: compact ? 0 : dsSpace.md
+                }, children: [_jsx(VStack, { style: {
+                            width: compact ? '100%' : roomPaneWidth,
+                            minWidth: compact ? undefined : roomPaneWidth,
+                            flexShrink: compact ? 1 : 0,
+                            flexGrow: compact ? 1 : 0,
+                            minHeight: 0,
+                            overflow: 'hidden'
+                        }, children: _jsx(Panel, { padding: "xs", gap: "xs", header: _jsx(HeaderBar, { padding: "none", left: _jsx(DSText, { bold: true, children: "Rooms" }), right: _jsx(DSText, { variant: "muted", children: `${rooms.length} total` }) }), children: hasRooms ? (_jsx(RoomsListPane, { rooms: rooms, selectedId: selectedId, onSelect: onSelect, maxVisible: Math.max(3, height - (denseList ? 12 : 14)), compact: denseList, textWidth: roomListTextWidth })) : (_jsxs(VStack, { gap: compact ? 0 : dsSpace.xs, style: {
+                                    justifyContent: 'center',
+                                    paddingLeft: compact ? dsSpace.sm : dsSpace.md,
+                                    paddingRight: compact ? dsSpace.sm : dsSpace.md,
+                                    flexGrow: 1,
+                                    flexShrink: 1,
+                                    minHeight: 0
+                                }, children: [_jsx("text", { style: { fg: dsBase.foreground }, children: "Create a conversation here, with any runtime agents you want." }), !compact && (_jsx("text", { style: { fg: dsBase.mutedForeground }, children: "Press N or choose New conversation." }))] })) }) }), hasRooms && !compact && previewRoom ? (_jsx(VStack, { style: {
+                            flexGrow: 1,
+                            flexShrink: 1,
+                            minHeight: 0,
+                            overflow: 'hidden',
+                            paddingBottom: dsSpace.sm
+                        }, children: _jsxs(Panel, { status: queuedMessage ? 'success' : 'info', padding: "xs", gap: "xs", header: _jsx(HeaderBar, { padding: "none", left: _jsx(DSText, { bold: true, children: queuedMessage ? 'Queued message' : 'Continue' }), right: _jsx(DSText, { variant: "muted", children: previewMode }) }), footer: _jsx(HeaderBar, { padding: "none", left: _jsxs(HStack, { gap: 1, children: [_jsx(DSText, { variant: "success", bold: true, children: "Enter" }), _jsx(DSText, { children: "Open thread" })] }), right: previewRoomId ? (_jsx(DSButton, { label: "Open", variant: "filled", color: "primary", size: "xs", onClick: () => onSelect(previewRoomId) })) : null }), children: [_jsxs(VStack, { gap: "xs", children: [_jsx(DSText, { variant: "primary", bold: true, children: previewTitle }), _jsx(DSText, { variant: "muted", children: queuedMessage
+                                                ? 'Queued draft will send after opening this room.'
+                                                : 'Selected conversation is ready to open.' })] }), _jsxs(HStack, { gap: 2, children: [_jsxs(HStack, { gap: 1, children: [_jsx(DSText, { variant: "muted", children: "Mode" }), _jsx(DSText, { children: previewMode })] }), previewVisibility ? (_jsxs(HStack, { gap: 1, children: [_jsx(DSText, { variant: "muted", children: "Scope" }), _jsx(DSText, { children: previewVisibility })] })) : null] }), queuedMessage ? (_jsxs(VStack, { gap: "xs", children: [_jsx(DSText, { variant: "muted", children: "Draft" }), _jsx(DSText, { children: truncateInline(queuedMessage, 96) })] })) : null] }) })) : null] })] }));
+}
+/**
+ * Empty room = the focused composer plus ONE quiet invitation line. The
+ * floating "Start conversation" config card is gone (TUI-WEB-PARITY-DESIGN.md
+ * /chat exemplar): the conversation is the page, config is ambient, and the
+ * send / agent affordances live in the one hint line — not restated in a card.
+ */
+function ChatEmptyThreadState({ modelLabel, compact, width }) {
+    const lineWidth = compact ? '100%' : Math.max(48, Math.min(76, Math.floor(width * 0.7)));
+    const model = formatModelShort(modelLabel);
+    return (_jsx(VStack, { align: "center", justify: "center", style: {
+            width: '100%',
+            flexShrink: 0,
+            paddingLeft: compact ? dsSpace.sm : dsSpace.md,
+            paddingRight: compact ? dsSpace.sm : dsSpace.md
+        }, children: _jsx(VStack, { style: { width: lineWidth }, align: "center", children: _jsx(DSText, { variant: "muted", children: `Start the conversation · ${model} · @ add · A manage · /setup` }) }) }));
+}
+function ChatClientAppInner({ runtime, navigate, embedded = false, routeState, initialRoomId, initialMessage }) {
+    const { width, height } = useViewport();
+    const compact = width <= 90 || height <= 26;
+    const denseTranscript = width <= 140 || height <= 32;
+    const state = useTuiState(chatRoomsStateKey);
+    const dispatch = useTuiDispatch(chatRoomsStateKey);
+    const initialRouteState = readRecord(routeState);
+    const routedInitialRoomId = initialRoomId ?? readString(initialRouteState.initialRoomId);
+    const routedInitialMessage = initialMessage ?? readString(initialRouteState.initialMessage);
+    const freshRoomRequested = initialRouteState.newRoom === true;
+    const initialModeId = readString(initialRouteState.initialModeId);
+    const initialTitle = readString(initialRouteState.initialTitle);
+    const initialCodeSessionId = readString(initialRouteState.codeSessionId);
+    const initialWorkspaceRoot = readString(initialRouteState.workspaceRoot);
+    const initialCodeSessionHostKind = initialRouteState.codeSessionHostKind === 'cloud' ||
+        initialRouteState.codeSessionHostKind === 'host'
+        ? initialRouteState.codeSessionHostKind
+        : undefined;
+    const freshRoomRequestKey = JSON.stringify({
+        message: routedInitialMessage ?? null,
+        modeId: initialModeId ?? null,
+        title: initialTitle ?? null,
+        codeSessionId: initialCodeSessionId ?? null,
+        codeSessionHostKind: initialCodeSessionHostKind ?? null,
+        workspaceRoot: initialWorkspaceRoot ?? null
+    });
+    const [composerValue, setComposerValue] = useState('');
+    const [appliedInitialRoomId, setAppliedInitialRoomId] = useState(null);
+    const [appliedInitialMessage, setAppliedInitialMessage] = useState(null);
+    const [appliedFreshRoomRequest, setAppliedFreshRoomRequest] = useState(null);
+    const [queuedInitialMessage, setQueuedInitialMessage] = useState(null);
+    const [initialRoomSelectionRequested, setInitialRoomSelectionRequested] = useState(false);
+    const [agentSelectorMode, setAgentSelectorMode] = useState(null);
+    const [selectedAgentIds, setSelectedAgentIds] = useState([]);
+    const rooms = state?.rooms ?? [];
+    const activeRoomId = state?.activeRoomId ?? null;
+    const participants = state?.participants ?? [];
+    const messages = state?.messages ?? [];
+    const chatModes = state?.chatModes ?? [];
+    const sending = state?.sending ?? false;
+    const generating = state?.generating ?? false;
+    const error = state?.error ?? null;
+    const pendingApproval = state?.pendingApproval ?? null;
+    const modelLoading = state?.modelLoading ?? null;
+    const composerOptions = state?.composerOptions ?? {
+        models: [],
+        agents: [],
+        folders: [],
+        degraded: ['models', 'agents', 'folders']
+    };
+    const [chatNotice, setChatNotice] = useState(null);
+    const stateActiveRoom = state?.activeRoom ?? null;
+    const activeRoom = stateActiveRoom ?? rooms.find((room) => String(room.id) === activeRoomId);
+    const chooserDefaultRoomId = !activeRoomId && rooms[0] ? String(rooms[0].id) : null;
+    const availableAgents = useMemo(() => {
+        const byId = new Map(composerOptions.agents.map((agent) => [agent.id, agent]));
+        for (const participant of participants) {
+            if (participant.type !== 'agent' || byId.has(participant.id))
+                continue;
+            byId.set(participant.id, {
+                id: participant.id,
+                name: participant.name,
+                description: participant.description
+            });
+        }
+        return Array.from(byId.values());
+    }, [composerOptions.agents, participants]);
+    // Contribute this screen's facts + hints to the ONE gateway-owned status line
+    // (screen-status contract) instead of free-printing a chat footer bar. Room is
+    // the single source of room identity; the hint line is chat's primary actions
+    // (the doctrine /chat exemplar: Enter send · / commands · @ agent). No auth,
+    // no refresh-age, no readiness word, no room count — the gateway owns auth and
+    // connection, and those tokens were the banned status-line noise.
+    const chatHints = activeRoomId
+        ? [
+            { keys: 'return', label: 'send' },
+            ...(generating ? [{ keys: 'ctrl+g', label: 'stop' }] : []),
+            { keys: '/', label: 'commands' },
+            { keys: '@', label: 'add agent' },
+            { keys: 'a', label: 'agents' }
+        ]
+        : [
+            { keys: 'return', label: 'open' },
+            { keys: 'n', label: 'new' },
+            { keys: 'escape', label: 'home' }
+        ];
+    useContributeScreenStatus('chat.client', {
+        facts: activeRoomId && activeRoom ? [{ slot: 'room', value: roomTitle(activeRoom) }] : [],
+        hints: chatHints
+    });
+    const selectRoom = useCallback((id) => {
+        dispatch({ type: 'SELECT_ROOM', payload: { roomId: id } });
+    }, [dispatch]);
+    const triggerSend = useCallback((submittedContent) => {
+        const content = (submittedContent ?? composerValue).trim();
+        if (content.length === 0)
+            return false;
+        dispatch({ type: 'SEND_MESSAGE', payload: { content } });
+        setComposerValue('');
+        return true;
+    }, [composerValue, dispatch]);
+    const triggerCancelGeneration = useCallback(() => {
+        dispatch({ type: 'CANCEL_GENERATION' });
+    }, [dispatch]);
+    const openChooserDefaultRoom = useCallback(() => {
+        if (!chooserDefaultRoomId)
+            return false;
+        selectRoom(chooserDefaultRoomId);
+        return true;
+    }, [chooserDefaultRoomId, selectRoom]);
+    const triggerRefresh = useCallback(() => {
+        dispatch({ type: 'REFRESH' });
+    }, [dispatch]);
+    const openNewConversation = useCallback(() => {
+        setSelectedAgentIds([]);
+        setAgentSelectorMode('new');
+    }, []);
+    const openAgentManager = useCallback(() => {
+        setSelectedAgentIds(participants
+            .filter((participant) => participant.type === 'agent' && participant.enabled)
+            .map((participant) => participant.id));
+        setAgentSelectorMode('manage');
+    }, [participants]);
+    const confirmAgentSelection = useCallback((agentIds) => {
+        const agents = agentInputsFromIds(agentIds, availableAgents);
+        if (agentSelectorMode === 'new') {
+            dispatch({ type: 'CREATE_ROOM', payload: { participants: agents } });
+            setChatNotice(agents.length > 0
+                ? `Creating a conversation with ${agents.length} agent${agents.length === 1 ? '' : 's'}.`
+                : 'Creating a conversation.');
+        }
+        else if (agentSelectorMode === 'manage') {
+            dispatch({ type: 'SET_AGENTS', payload: { agents } });
+            setChatNotice(agents.length > 0
+                ? `Updating this conversation to ${agents.length} agent${agents.length === 1 ? '' : 's'}.`
+                : 'Removing agents from this conversation.');
+        }
+        setAgentSelectorMode(null);
+    }, [agentSelectorMode, availableAgents, dispatch]);
+    const resolveApproval = useCallback((approved, workspaceAccessChoice) => {
+        dispatch({
+            type: 'RESOLVE_APPROVAL',
+            payload: { approved, workspaceAccessChoice }
+        });
+    }, [dispatch]);
+    const handlePrefixResult = useCallback((result) => {
+        if (result.type === 'navigate') {
+            navigate?.(result.route);
+            return;
+        }
+        if (result.type === 'insert') {
+            setComposerValue(result.text);
+            return;
+        }
+        if (result.type === 'clear') {
+            setComposerValue('');
+            return;
+        }
+        if (result.type === 'send') {
+            const text = result.text.trim();
+            if (text)
+                dispatch({ type: 'SEND_MESSAGE', payload: { content: text } });
+            setComposerValue('');
+            return;
+        }
+        if (result.type === 'toast') {
+            setChatNotice(result.message);
+            return;
+        }
+        if (result.type !== 'augment')
+            return;
+        if (result.augmentId === 'chat.rooms') {
+            // `/rooms` — leave the thread and open the session chooser (separate page).
+            dispatch({ type: 'SELECT_ROOM', payload: { roomId: null } });
+            setComposerValue('');
+            return;
+        }
+        if (result.augmentId === 'chat.settings') {
+            const staged = readRecord(result.staged);
+            const patch = settingsPatchFrom(staged.patch);
+            if (!patch) {
+                setChatNotice('No chat setting selected.');
+                return;
+            }
+            const label = readString(staged.label) ?? undefined;
+            dispatch({ type: 'UPDATE_SETTINGS', payload: { patch, label } });
+            setComposerValue('');
+            setChatNotice(label ? `Applied ${label}.` : 'Updated chat settings.');
+            return;
+        }
+        if (result.augmentId === 'participants') {
+            const staged = readRecord(result.staged);
+            const agentId = readString(staged.agentId) ?? readStringArray(staged.agentIds)[0];
+            if (!agentId) {
+                setChatNotice('No agent selected.');
+                return;
+            }
+            dispatch({
+                type: 'ADD_AGENT',
+                payload: {
+                    agentId,
+                    name: readString(staged.name) ?? undefined,
+                    description: readString(staged.description) ?? undefined,
+                    modelHint: readString(staged.modelHint) ?? undefined
+                }
+            });
+            setChatNotice(`Added ${readString(staged.name) ?? agentId}.`);
+        }
+    }, [dispatch, navigate]);
+    const searchOverlayOpen = useChatUIStore((state) => state.searchOverlayOpen);
+    const chatRoomListCollapsed = useChatUIStore((state) => state.chatRoomListCollapsed);
+    const exportOverlayOpen = useChatUIStore((state) => state.exportOverlayOpen);
+    const exportFormat = useChatUIStore((state) => state.exportFormat);
+    const exportIncludeMetadata = useChatUIStore((state) => state.exportIncludeMetadata);
+    const exportIncludeToolCalls = useChatUIStore((state) => state.exportIncludeToolCalls);
+    const exportIncludeThinking = useChatUIStore((state) => state.exportIncludeThinking);
+    const onToggleSidebar = useCallback(() => {
+        const current = useChatUIStore.getState(runtime).chatRoomListCollapsed;
+        useChatUIStore.getState(runtime).setChatRoomListCollapsed(!current);
+    }, []);
+    const runExport = useCallback(async () => {
+        const ui = useChatUIStore.getState(runtime);
+        // The transcript comes from the runtime `chat.rooms` tui/state (domain data),
+        // not a TUI-local store; the export utils read the shared ChatMessage shape.
+        const exportable = messages.map(mapUnifiedMessageToLegacyMessage);
+        const options = {
+            format: ui.exportFormat,
+            includeMetadata: ui.exportIncludeMetadata,
+            includeToolCalls: ui.exportIncludeToolCalls,
+            includeThinking: ui.exportIncludeThinking
+        };
+        const content = ui.exportFormat === 'json'
+            ? exportToJSON(exportable, options)
+            : exportToMarkdown(exportable, options);
+        const ext = ui.exportFormat === 'json' ? 'json' : 'md';
+        const filename = `chat-export-${activeRoomId ?? 'room'}-${Date.now()}.${ext}`;
+        ui.setExportOverlayOpen(false);
+        try {
+            const written = await saveExportToFile(runtime, content, filename);
+            setChatNotice(`Exported ${exportable.length} messages → ${written}`);
+        }
+        catch (error) {
+            const diagnostics = runtime.diagnostics;
+            settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(error) }));
+            // The notice names the typed refusal; the failure itself stays out of the transcript.
+            setChatNotice(`Export failed (${error instanceof Error && isCapabilityError(error) ? error.reason : 'write failed'}).`);
+        }
+    }, [activeRoomId, messages, runtime]);
+    useKeyboardLayer('focused', (key) => {
+        const isEnter = key.name === 'return' || key.name === 'enter';
+        if (!isEnter || key.ctrl || key.meta || key.shift || key.alt || activeRoomId) {
+            return false;
+        }
+        return openChooserDefaultRoom();
+    }, {
+        enabled: () => Boolean(state?.loaded && chooserDefaultRoomId),
+        description: 'chat-chooser-open-default',
+        deps: [activeRoomId, chooserDefaultRoomId, openChooserDefaultRoom, state?.loaded]
+    });
+    useKeyboardLayer('global', (key) => {
+        if (!key.ctrl || key.name !== 'g')
+            return false;
+        triggerCancelGeneration();
+        return true;
+    }, {
+        allowInInsertMode: true,
+        enabled: () => generating,
+        description: 'chat-cancel-generation',
+        deps: [generating, triggerCancelGeneration]
+    });
+    useKeyboardLayer('focused', (key) => {
+        if (key.name !== 'n' || key.ctrl || key.meta || key.alt)
+            return false;
+        if (useInputModeStore.getState().mode === 'insert')
+            return false;
+        openNewConversation();
+        return true;
+    }, {
+        enabled: () => Boolean(state?.loaded && !activeRoomId && !agentSelectorMode),
+        description: 'chat-new-conversation',
+        deps: [activeRoomId, agentSelectorMode, openNewConversation, state?.loaded]
+    });
+    useKeyboardLayer('focused', (key) => {
+        if (key.name !== 'a' || key.ctrl || key.meta || key.alt)
+            return false;
+        if (useInputModeStore.getState().mode === 'insert')
+            return false;
+        openAgentManager();
+        return true;
+    }, {
+        enabled: () => Boolean(activeRoomId && !agentSelectorMode && !pendingApproval),
+        description: 'chat-manage-agents',
+        deps: [activeRoomId, agentSelectorMode, openAgentManager, pendingApproval]
+    });
+    // A/D resolve the pending tool approval. Never while a text input owns the
+    // keyboard (insert mode) — 'a'/'d' typed into the composer are letters, not
+    // decisions.
+    useKeyboardLayer('focused', (key) => {
+        if (!pendingApproval)
+            return false;
+        if (useInputModeStore.getState().mode === 'insert')
+            return false;
+        if (key.ctrl || key.meta || key.alt)
+            return false;
+        const name = key.name ?? '';
+        const workspaceGrant = Boolean(pendingApproval.workspaceAccess);
+        if (workspaceGrant) {
+            if (name === 'f') {
+                resolveApproval(true, 'from');
+                return true;
+            }
+            if (name === 'w') {
+                resolveApproval(true, 'always');
+                return true;
+            }
+            if (name === 'd') {
+                resolveApproval(false, 'deny');
+                return true;
+            }
+            return false;
+        }
+        if (name === 'a') {
+            resolveApproval(true);
+            return true;
+        }
+        if (name === 'd') {
+            resolveApproval(false);
+            return true;
+        }
+        return false;
+    }, {
+        enabled: () => Boolean(pendingApproval),
+        description: 'chat-tool-approval-decision',
+        deps: [pendingApproval, resolveApproval]
+    });
+    useEffect(() => {
+        const roomId = routedInitialRoomId?.trim() ?? '';
+        if (!state?.loaded || !roomId || appliedInitialRoomId === roomId)
+            return;
+        if (activeRoomId === roomId) {
+            setAppliedInitialRoomId(roomId);
+            return;
+        }
+        if (!rooms.some((room) => String(room.id) === roomId))
+            return;
+        dispatch({ type: 'SELECT_ROOM', payload: { roomId } });
+        setAppliedInitialRoomId(roomId);
+    }, [activeRoomId, appliedInitialRoomId, dispatch, rooms, routedInitialRoomId, state?.loaded]);
+    useEffect(() => {
+        if (!freshRoomRequested ||
+            !state?.loaded ||
+            appliedFreshRoomRequest === freshRoomRequestKey) {
+            return;
+        }
+        const text = routedInitialMessage?.trim() ?? '';
+        const metadata = {};
+        if (initialCodeSessionId)
+            metadata.codeSessionId = initialCodeSessionId;
+        if (initialCodeSessionHostKind) {
+            metadata.codeSessionHostKind = initialCodeSessionHostKind;
+        }
+        if (initialWorkspaceRoot)
+            metadata.workspaceRoot = initialWorkspaceRoot;
+        const room = {
+            modeId: initialModeId ?? undefined,
+            title: initialTitle ?? undefined,
+            autoTitle: !initialTitle && text ? true : undefined,
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined
+        };
+        setAppliedFreshRoomRequest(freshRoomRequestKey);
+        setAppliedInitialMessage(text || null);
+        setQueuedInitialMessage(null);
+        setInitialRoomSelectionRequested(false);
+        setComposerValue('');
+        dispatch({
+            type: 'CREATE_ROOM',
+            payload: {
+                room,
+                initialMessage: text || undefined
+            }
+        });
+    }, [
+        appliedFreshRoomRequest,
+        dispatch,
+        freshRoomRequestKey,
+        freshRoomRequested,
+        initialCodeSessionHostKind,
+        initialCodeSessionId,
+        initialModeId,
+        initialTitle,
+        initialWorkspaceRoot,
+        routedInitialMessage,
+        state?.loaded
+    ]);
+    useEffect(() => {
+        const text = routedInitialMessage?.trim() ?? '';
+        if (freshRoomRequested || !text || appliedInitialMessage === text)
+            return;
+        setAppliedInitialMessage(text);
+        setQueuedInitialMessage(text);
+        setComposerValue(text);
+        setInitialRoomSelectionRequested(false);
+    }, [appliedInitialMessage, freshRoomRequested, routedInitialMessage]);
+    useEffect(() => {
+        const text = queuedInitialMessage?.trim();
+        if (!state?.loaded || !text || sending)
+            return;
+        if (!activeRoomId) {
+            const firstRoom = rooms[0];
+            if (initialRoomSelectionRequested)
+                return;
+            setInitialRoomSelectionRequested(true);
+            if (firstRoom) {
+                dispatch({ type: 'SELECT_ROOM', payload: { roomId: String(firstRoom.id) } });
+            }
+            else {
+                dispatch({ type: 'CREATE_ROOM', payload: { initialMessage: text } });
+                setComposerValue('');
+                setQueuedInitialMessage(null);
+            }
+            return;
+        }
+        dispatch({ type: 'SEND_MESSAGE', payload: { content: text } });
+        setComposerValue('');
+        setQueuedInitialMessage(null);
+        setInitialRoomSelectionRequested(false);
+    }, [
+        activeRoomId,
+        dispatch,
+        initialRoomSelectionRequested,
+        queuedInitialMessage,
+        rooms,
+        sending,
+        state?.loaded
+    ]);
+    if (!state || !state.loaded) {
+        return (_jsx(PageLayout, { noScroll: true, header: embedded ? undefined : (_jsx(PageHeader, { title: "Chat", description: "Rooms, messages, and composer" })), children: _jsx(ChatRuntimeStatus, { error: state?.error, onRefresh: triggerRefresh, onHome: !embedded && navigate ? () => navigate('/') : undefined }) }));
+    }
+    const modeLabel = formatModeLabel(activeRoom, chatModes);
+    const modelLabel = formatModelLabel(activeRoom);
+    const agentSummary = formatAgentSummary(participants);
+    const activeNotice = error ? `! ${error}` : chatNotice;
+    const activeNoticeTone = error ? 'danger' : 'primary';
+    // Typing indicator covers the gap between send and the assistant turn
+    // appearing: once the assistant row exists it carries its own live
+    // generating/streaming affordance, so the indicator hands off to it.
+    const lastMessage = messages.at(-1);
+    const showTypingIndicator = generating && lastMessage?.role !== 'assistant';
+    return (_jsxs(_Fragment, { children: [_jsx(OptionalChatKeybindHandlers, { navigate: navigate, onSend: triggerSend, onOpenDefaultRoom: openChooserDefaultRoom, onRefresh: triggerRefresh, getActiveRoomId: () => activeRoomId, onDeselectRoom: () => dispatch({ type: 'SELECT_ROOM', payload: { roomId: null } }), getMessageById: (id) => {
+                    const m = messages.find((mm) => String(mm.id) === id);
+                    if (!m)
+                        return undefined;
+                    const record = m;
+                    return {
+                        content: record.content,
+                        messageType: record.senderType ? 'text' : undefined
+                    };
+                }, getCurrentMessageIds: () => messages.map((m) => String(m.id)) }), _jsxs(PageLayout, { noScroll: true, header: embedded ? undefined : (_jsx(PageHeader, { title: "Chat", description: "Rooms, messages, and composer" })), children: [activeNotice ? (_jsx(HStack, { style: { paddingLeft: dsSpace.sm, paddingRight: dsSpace.sm, flexShrink: 0 }, children: _jsx(DSText, { variant: activeNoticeTone === 'danger' ? 'danger' : 'primary', children: activeNotice }) })) : null, searchOverlayOpen && activeRoomId && (_jsx(ChatSearchOverlay, { roomId: activeRoomId, messages: messages, onClose: () => useChatUIStore.getState(runtime).setSearchOverlayOpen(false) })), exportOverlayOpen && activeRoomId && (_jsx(ChatExportOverlay, { selectedFormat: exportFormat, setSelectedFormat: (format) => useChatUIStore.getState(runtime).setExportFormat(format), includeMetadata: exportIncludeMetadata, setIncludeMetadata: (v) => useChatUIStore.getState(runtime).setExportIncludeMetadata(v), includeToolCalls: exportIncludeToolCalls, setIncludeToolCalls: (v) => useChatUIStore.getState(runtime).setExportIncludeToolCalls(v), includeThinking: exportIncludeThinking, setIncludeThinking: (v) => useChatUIStore.getState(runtime).setExportIncludeThinking(v), onExport: () => {
+                            void runExport();
+                        }, onClose: () => useChatUIStore.getState(runtime).setExportOverlayOpen(false), messageCount: messages.length })), !activeRoomId ? (_jsx(ChatRoomChooser, { rooms: rooms, selectedId: chooserDefaultRoomId, onSelect: selectRoom, onNew: openNewConversation, width: width, height: height, compact: compact, denseList: compact || denseTranscript, queuedMessage: queuedInitialMessage })) : (_jsx(ChatLayout, { header: _jsx(HeaderBar, { left: _jsxs(_Fragment, { children: [_jsx(DSText, { bold: true, children: roomTitle(activeRoom) }), _jsx(DSText, { variant: "muted", children: formatAmbientConfig({ modeLabel, agentSummary, modelLabel }) })] }), right: _jsx(DSButton, { label: `Agents ${participants.filter((participant) => participant.type === 'agent' && participant.enabled).length}`, variant: "ghost", color: "primary", size: "xs", onClick: openAgentManager }) }), history: _jsx(ChatRoomHistory, { messages: messages, roomId: activeRoomId, dense: denseTranscript, showTypingIndicator: showTypingIndicator, emptyState: _jsx(ChatEmptyThreadState, { modelLabel: modelLabel, compact: compact, width: width }) }), input: _jsxs(VStack, { gap: 0, children: [pendingApproval && (_jsx(HeaderBar, { left: _jsxs(VStack, { gap: 0, children: [_jsx(DSText, { bold: true, color: dsColors.warning.solid, children: "\u23F8 Tool needs approval" }), _jsx(DSText, { children: pendingApproval.toolName }), _jsx(DSText, { variant: "muted", children: formatChatApprovalPreview(pendingApproval.input) }), pendingApproval.workspaceAccess ? (_jsxs(DSText, { variant: "muted", children: [pendingApproval.workspaceAccess.toLabel, " from", ' ', pendingApproval.workspaceAccess.fromLabel] })) : null] }), right: pendingApproval.workspaceAccess ? (_jsxs(HStack, { gap: 1, children: [_jsx(DSText, { variant: "success", bold: true, children: "F" }), _jsx(DSText, { children: "from here" }), _jsx(DSText, { variant: "muted", children: "\u00B7" }), _jsx(DSText, { variant: "success", bold: true, children: "W" }), _jsx(DSText, { children: "always" }), _jsx(DSText, { variant: "muted", children: "\u00B7" }), _jsx(DSText, { variant: "danger", bold: true, children: "D" }), _jsx(DSText, { children: "deny" })] })) : (_jsxs(HStack, { gap: 1, children: [_jsx(DSText, { variant: "success", bold: true, children: "A" }), _jsx(DSText, { children: "approve" }), _jsx(DSText, { variant: "muted", children: "\u00B7" }), _jsx(DSText, { variant: "danger", bold: true, children: "D" }), _jsx(DSText, { children: "deny" })] })) })), _jsx(ComposerPane, { activeRoomId: activeRoomId, value: composerValue, onChange: setComposerValue, onSend: triggerSend, onCancel: triggerCancelGeneration, runtime: runtime, onPrefixResult: handlePrefixResult, sending: sending, generating: generating, modelLoading: modelLoading, ambientConfig: messages.length > 0
+                                        ? formatAmbientConfig({ modeLabel, agentSummary, modelLabel })
+                                        : undefined, compact: compact })] }), sidebarCollapsed: chatRoomListCollapsed, onToggleSidebar: onToggleSidebar })), agentSelectorMode ? (_jsx(ChatAgentSelectorOverlay, { title: agentSelectorMode === 'new' ? 'New conversation agents' : 'Conversation agents', confirmLabel: agentSelectorMode === 'new' ? 'Create' : 'Save', agents: availableAgents, degraded: composerOptions.degraded.includes('agents'), selectedIds: selectedAgentIds, onChange: setSelectedAgentIds, onConfirm: confirmAgentSelection, onClose: () => setAgentSelectorMode(null) })) : null] })] }));
+}
+function ChatClientApp(props) {
+    return (_jsxs(ErrorBoundary, { onCleanup: () => { }, children: [_jsx(ToolWidgetRuntimeRegistrar, { runtime: props.runtime }), _jsx(ChatClientAppInner, { ...props })] }));
+}
+const impl = { component: ChatClientApp };
+export default impl;
+//# sourceMappingURL=chat.tui-app.impl.consumer.js.map