@guildai/cli 0.11.0 → 0.12.0

package/dist/commands/chat.js

@@ -1,1416 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import React, { useState, useEffect, useRef } from 'react';
-import { Box, Text, Static, render, useInput, useApp } from 'ink';
-import { Command, Option } from 'commander';
-import { getAuthToken } from '../lib/auth.js';
-import { GuildAPIClient } from '../lib/api-client.js';
-import { handleAxiosError, ErrorCodes, debug, isDebugMode, retry, } from '../lib/errors.js';
-import { createSpinner, format } from '../lib/progress.js';
-import { marked } from 'marked';
-import { markedTerminal } from 'marked-terminal';
-import chalk from 'chalk';
-import { readFileSync } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, getAgentName, getAgentNotificationText, applyResponseStreamText, isDoneResponseStreamEvent, isResponseStreamEvent, isRootTaskEvent, } from '../lib/session-events.js';
-import { printResumeHint, fetchSession, fetchSessionEvents, prepareSessionResumeDisplay, } from '../lib/session-resume.js';
-import { DEFAULT_EVENT_TYPES, parseEventFilter, shouldShowEvent, } from '../lib/event-filter.js';
-import { fetchEvents, fetchTasks } from '../lib/session-events-fetch.js';
-import { AgentInstallPrompt } from '../components/AgentInstallPrompt.js';
-import { getWorkspaceId, getWorkspaceSourceLabel } from '../lib/guild-config.js';
-import { ensureInteractiveStdin } from '../lib/stdin.js';
-import { brand, BRAND_COLOR, code as codeColor, hyperlink } from '../lib/colors.js';
-import { SplashAnimation } from '../components/SplashAnimation.js';
-import { LOADING_TIMINGS } from '../lib/loading-messages.js';
-import { suppressScrollbackClear } from '../lib/alternate-screen.js';
-import open from 'open';
-import { TaskView, hasActiveTasks } from '../components/TaskView.js';
-import { getOutputMode, isQuietMode } from '../lib/output-mode.js';
-// ESM equivalent of __dirname
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// Read version from package.json
-const packageJson = JSON.parse(readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
-// ---------------------------------------------------------------------------
-// Workspace error types
-// ---------------------------------------------------------------------------
-/** Thrown when no workspace is configured (no --workspace flag, no config). */
-export class WorkspaceNotConfiguredError extends Error {
-    constructor() {
-        super('No workspace configured.');
-        this.name = 'WorkspaceNotConfiguredError';
-    }
-}
-/** Thrown when the specified workspace ID is not found in the backend. */
-export class WorkspaceNotFoundError extends Error {
-    workspaceId;
-    constructor(workspaceId) {
-        super(`Workspace ${workspaceId} not found.`);
-        this.name = 'WorkspaceNotFoundError';
-        this.workspaceId = workspaceId;
-    }
-}
-/** User-facing error messages for workspace resolution failures. */
-const WORKSPACE_NOT_CONFIGURED_MSG = 'No workspace configured. Pass a --workspace <id_or_name> argument or run guild workspace select';
-const WORKSPACE_NOT_FOUND_MSG = "The workspace doesn't exist.";
-// Configure marked for terminal
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-marked.use(markedTerminal({}, { theme: {} }));
-/**
- * Post-process markdown to fix unrendered inline markdown in list items.
- * marked-terminal has a bug where it uses parse() instead of parseInline()
- * for list items, leaving **bold** and `code` unrendered.
- */
-function fixListItemMarkdown(text) {
-    // Handle bold/strong: **text** -> bold text
-    text = text.replace(/\*\*([^*]+)\*\*/g, (_, content) => chalk.bold(content));
-    // Handle inline code: `text` -> highlighted text
-    text = text.replace(/`([^`]+)`/g, (_, content) => codeColor(content));
-    // Handle italic: _text_ -> italic (underscore style, less ambiguous)
-    text = text.replace(/(?<![\\w])_([^_]+)_(?![\\w])/g, (_, content) => chalk.italic(content));
-    return text;
-}
-function extractMessageText(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith('{') || !trimmed.endsWith('}'))
-        return text;
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (typeof parsed === 'object' && parsed !== null && 'message' in parsed) {
-            return typeof parsed.message === 'string' ? parsed.message : text;
-        }
-    }
-    catch {
-        // If parsing fails, use the content as-is.
-    }
-    return text;
-}
-function extractRuntimeDoneText(content) {
-    if (content === null || content === undefined)
-        return null;
-    if (typeof content === 'string')
-        return content.trim() ? content : null;
-    if (typeof content !== 'object' || Array.isArray(content)) {
-        return JSON.stringify(content);
-    }
-    const record = content;
-    if (Object.keys(record).length === 0)
-        return null;
-    if (record.type === 'text') {
-        if (typeof record.text === 'string')
-            return record.text;
-        if (typeof record.data === 'string')
-            return record.data;
-    }
-    if (typeof record.message === 'string')
-        return record.message;
-    // runtime_done content is agent output, not notification content. Preserve
-    // structured outputs rather than trying to render notification-only shapes.
-    return JSON.stringify(content);
-}
-function renderAssistantMessage(text, taskName) {
-    const rendered = fixListItemMarkdown(marked.parse(text));
-    return `${chalk.green('●')} ${chalk.bold(taskName)}\n${rendered.trim()}`;
-}
-function applyResponseStreamContentsInSequence(contents) {
-    return [...contents]
-        .sort((left, right) => left.sequence - right.sequence)
-        .reduce((currentText, content) => applyResponseStreamText(currentText, content), '');
-}
-/**
- * Output the result of a --once mode session.
- * Handles both JSON and human-readable output formats.
- */
-async function outputOnceResult(sessionId, events, mode) {
-    if (mode === 'json') {
-        console.log(JSON.stringify({ session_id: sessionId, events }, null, 2));
-    }
-    else {
-        const finalAgentMessages = events.filter((e) => e.type === 'agent_notification_message' &&
-            isRootTaskEvent(e) &&
-            !isResponseStreamEvent(e));
-        const responseStreamContents = new Map();
-        const doneStreamIds = [];
-        for (const event of events) {
-            if (!isResponseStreamEvent(event) || !isRootTaskEvent(event))
-                continue;
-            const streamContents = responseStreamContents.get(event.content.stream_id) ?? [];
-            streamContents.push(event.content);
-            responseStreamContents.set(event.content.stream_id, streamContents);
-            if (isDoneResponseStreamEvent(event)) {
-                doneStreamIds.push(event.content.stream_id);
-            }
-        }
-        if (finalAgentMessages.length > 0) {
-            const messageContent = extractMessageText(getAgentNotificationText(finalAgentMessages[finalAgentMessages.length - 1]));
-            const rendered = fixListItemMarkdown(await marked(messageContent));
-            console.log(rendered.trim());
-            return;
-        }
-        const runtimeDoneEvents = events.filter((e) => e.type === 'runtime_done' && isRootTaskEvent(e) && e.content);
-        const runtimeDoneWithContent = runtimeDoneEvents[runtimeDoneEvents.length - 1];
-        if (runtimeDoneWithContent?.type === 'runtime_done') {
-            const runtimeDoneText = extractRuntimeDoneText(runtimeDoneWithContent.content);
-            if (runtimeDoneText) {
-                console.log(runtimeDoneText);
-                return;
-            }
-        }
-        const lastDoneStreamId = doneStreamIds[doneStreamIds.length - 1];
-        const streamFallbackText = lastDoneStreamId !== undefined
-            ? applyResponseStreamContentsInSequence(responseStreamContents.get(lastDoneStreamId) ?? [])
-            : null;
-        if (streamFallbackText !== null) {
-            const rendered = fixListItemMarkdown(await marked(streamFallbackText));
-            console.log(rendered.trim());
-        }
-    }
-}
-import { createSpinner as createAnimatedSpinner, createRandomSpinner, } from '../lib/spinners.js';
-function CustomInput({ value, onChange, onSubmit, trackedTasksSize, setShowTaskPanel, isActive, }) {
-    useInput((input, key) => {
-        // Ctrl-T: toggle task panel
-        if (key.ctrl && input === 't' && trackedTasksSize > 0) {
-            setShowTaskPanel((prev) => !prev);
-            return;
-        }
-        // Enter: submit
-        if (key.return) {
-            onSubmit(value);
-            return;
-        }
-        // Backspace: delete character
-        if (key.backspace || key.delete) {
-            onChange(value.slice(0, -1));
-            return;
-        }
-        // Ctrl+C, Ctrl+D: handled at parent level
-        if (key.ctrl && (input === 'c' || input === 'd')) {
-            return;
-        }
-        // Regular character: append to input
-        if (!key.ctrl && !key.meta && input) {
-            onChange(value + input);
-        }
-    }, { isActive });
-    // Render cursor using chalk.inverse() like ink-text-input does
-    // This creates a block cursor that adapts to the user's terminal theme
-    const renderedValue = value + chalk.inverse(' ');
-    return React.createElement(Text, null, renderedValue);
-}
-function InputWrapper({ isReady, isInterrupted, input, setInput, handleSubmit, trackedTasksSize, setShowTaskPanel, isActive, }) {
-    if (isInterrupted) {
-        return (React.createElement(Box, { height: 1 },
-            React.createElement(Text, { color: "gray" }, chalk.dim('Interrupted — this session cannot be resumed. Press Ctrl+C to exit.'))));
-    }
-    return (React.createElement(Box, { height: 1 },
-        React.createElement(Text, { color: isReady ? BRAND_COLOR : 'gray' }, "> "),
-        isReady && isActive ? (React.createElement(CustomInput, { value: input, onChange: setInput, onSubmit: handleSubmit, trackedTasksSize: trackedTasksSize, setShowTaskPanel: setShowTaskPanel, isActive: isActive })) : isReady ? (React.createElement(Text, null, input)) : (React.createElement(Text, null, chalk.dim('(connecting...)')))));
-}
-export function ChatApp({ initialPrompt, version, workspaceId, versionId, agentName, showSplash = true, resumeSession, resumeEvents, resumeCommand, openDashboard, eventFilter, }) {
-    const { exit } = useApp();
-    const isResuming = !!resumeSession;
-    const [phase, setPhase] = useState(isResuming || !showSplash ? 'chat' : 'splash');
-    const [splashStatus, setSplashStatus] = useState('Initializing');
-    const [connectedSession, setConnectedSession] = useState(resumeSession || null);
-    const [connectedClient, setConnectedClient] = useState(isResuming ? new GuildAPIClient() : null);
-    const [firstMessageReceived, setFirstMessageReceived] = useState(isResuming);
-    const connectionAttempted = useRef(isResuming);
-    const splashStartTime = useRef(Date.now());
-    // Transition from finalizing to chat after a brief delay to clear screen
-    useEffect(() => {
-        if (phase === 'finalizing') {
-            const timeout = setTimeout(() => {
-                setPhase('chat');
-            }, 50); // Brief delay to render the blank frame
-            return () => clearTimeout(timeout);
-        }
-    }, [phase]);
-    // Transition from splash to finalizing when first message is received
-    useEffect(() => {
-        if (!firstMessageReceived || phase !== 'splash')
-            return;
-        // Ensure minimum splash duration for animation to complete
-        const elapsed = Date.now() - splashStartTime.current;
-        const remainingTime = Math.max(0, LOADING_TIMINGS.minLoadingDwell - elapsed);
-        setTimeout(() => {
-            setPhase('finalizing');
-        }, remainingTime);
-    }, [firstMessageReceived, phase]);
-    // Timeout: transition to chat 2 seconds after session is created
-    // Don't make users stare at splash for long-running prompts
-    useEffect(() => {
-        if (!connectedSession || phase === 'chat')
-            return;
-        const timeout = setTimeout(() => {
-            // If still on splash after 2 seconds of session creation, switch to finalizing
-            // so user can see progress logs and task activity
-            if (phase === 'splash') {
-                setPhase('finalizing');
-            }
-        }, 2000);
-        return () => clearTimeout(timeout);
-    }, [connectedSession, phase]);
-    // Start connection attempt during splash
-    useEffect(() => {
-        if (connectionAttempted.current)
-            return;
-        connectionAttempted.current = true;
-        const connect = async () => {
-            try {
-                setSplashStatus('Connecting to Guild servers');
-                const client = new GuildAPIClient();
-                setSplashStatus('Creating session');
-                const session = await retry(() => createSession(client, workspaceId, initialPrompt, versionId, setSplashStatus), {
-                    maxAttempts: 20,
-                    initialDelay: 500,
-                    maxDelay: 5000,
-                    backoffMultiplier: 1.5,
-                    shouldRetry: (error) => {
-                        if (typeof error === 'object' && error !== null) {
-                            const err = error;
-                            return (err.code === 'ECONNREFUSED' ||
-                                err.code === 'ETIMEDOUT' ||
-                                err.code === 'ENOTFOUND' ||
-                                err.code === 'ECONNABORTED');
-                        }
-                        return false;
-                    },
-                });
-                setConnectedClient(client);
-                setConnectedSession(session);
-                setSplashStatus('Waiting for response');
-                // Open dashboard in browser if requested
-                if (openDashboard && session.session_url) {
-                    open(session.session_url).catch(() => {
-                        // Ignore errors opening browser
-                    });
-                }
-                // Don't transition to chat yet - wait for first message from ChatUIWithConnection
-            }
-            catch (error) {
-                debug('Connection error during splash:', error);
-                // Exit Ink first to stop rendering, then clear screen.
-                // Use ESC[H + ESC[J (cursor home + erase below) instead of ESC[2J
-                // to avoid pushing the last splash frame into scrollback.
-                exit();
-                process.stdout.write('\x1b[H\x1b[J');
-                // Get error details and provide clear, actionable guidance
-                const formattedError = handleAxiosError(error);
-                const details = formattedError.details.toLowerCase();
-                // One message, one action - use consistent format from progress.ts
-                if (formattedError.code === ErrorCodes.AUTH_REQUIRED ||
-                    formattedError.code === ErrorCodes.AUTH_TOKEN_INVALID) {
-                    format.error('Not authenticated. Run: guild auth login');
-                }
-                else if (error instanceof WorkspaceNotConfiguredError) {
-                    format.error(WORKSPACE_NOT_CONFIGURED_MSG);
-                }
-                else if (error instanceof WorkspaceNotFoundError) {
-                    format.error(WORKSPACE_NOT_FOUND_MSG);
-                }
-                else if (details.includes('agent')) {
-                    format.error('Agent not found in workspace.');
-                }
-                else {
-                    format.error(formattedError.details);
-                }
-                process.exit(1);
-            }
-        };
-        connect();
-    }, [workspaceId, initialPrompt, versionId]);
-    const chatInstanceKey = `${connectedSession?.id ?? 'pending'}:${resumeEvents?.[resumeEvents.length - 1]?.id ?? 'live'}`;
-    // Render both splash and chat, but only show one at a time
-    // ChatUIWithConnection is always mounted (when connected) so it can stream events in background
-    return (React.createElement(React.Fragment, null,
-        (phase === 'splash' || phase === 'finalizing') && showSplash && (React.createElement(SplashAnimation, { status: splashStatus, version: version, isFinalizing: phase === 'finalizing', onComplete: () => {
-                // Animation complete callback (not used for transition anymore)
-            }, onEscapePress: () => {
-                // User pressed Esc to skip splash screen - only allow if connected
-                if (connectedSession && connectedClient) {
-                    process.stdout.write('\x1b[H\x1b[J'); // Clear screen without pushing to scrollback
-                    setPhase('chat');
-                }
-                // If not connected yet, ignore escape (let connection complete)
-            } })),
-        phase === 'chat' && (React.createElement(ChatUIWithConnection, { key: chatInstanceKey, initialPrompt: initialPrompt, version: version, versionId: versionId, agentName: agentName, client: connectedClient, session: connectedSession, onFirstMessage: () => setFirstMessageReceived(true), resumeEvents: resumeEvents, resumeCommand: resumeCommand, eventFilter: eventFilter })),
-        (phase === 'splash' || phase === 'finalizing') &&
-            connectedSession &&
-            connectedClient && (React.createElement(Box, { display: "none" },
-            React.createElement(ChatUIWithConnection, { initialPrompt: initialPrompt, version: version, versionId: versionId, agentName: agentName, client: connectedClient, session: connectedSession, onFirstMessage: () => setFirstMessageReceived(true), isActive: false, eventFilter: eventFilter })))));
-}
-function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _versionId, agentName, client: preConnectedClient, session: preConnectedSession, onFirstMessage, isActive = true, resumeEvents, resumeCommand, eventFilter, }) {
-    const activeFilter = eventFilter ?? DEFAULT_EVENT_TYPES;
-    // Note: We handle SIGINT directly via process.on, not using useApp().exit
-    // Task panel state - managed at this level to handle keyboard input before TextInput
-    // Default to showing task panel (Ctrl-T to toggle)
-    const [showTaskPanel, setShowTaskPanel] = useState(true);
-    const [tasks, setTasks] = useState([]);
-    // Interactive prompt state for agent install requests
-    const [pendingInstallRequest, setPendingInstallRequest] = useState(null);
-    const promptedEventIds = useRef(new Set());
-    // No header needed - version is shown in splash finale
-    // Only include initial prompt when active (not during splash)
-    // Static component writes to stdout even with display="none"
-    // When resuming, show past events instead of initial prompt
-    const [resumeDisplay] = useState(() => resumeEvents ? prepareSessionResumeDisplay(resumeEvents) : null);
-    const resumeDisplayMessages = resumeDisplay?.displayMessages ?? null;
-    const responseStreamResumeState = resumeDisplay?.responseStreamState ?? null;
-    const sessionLinkMessage = isActive && preConnectedSession?.session_url
-        ? [
-            {
-                key: 'session-link',
-                content: chalk.dim(`Session: ${hyperlink(preConnectedSession.id, preConnectedSession.session_url)}`),
-                type: 'progress',
-            },
-        ]
-        : [];
-    const [messages, setMessages] = useState(resumeDisplayMessages
-        ? resumeDisplayMessages
-        : isActive
-            ? [
-                ...sessionLinkMessage,
-                {
-                    key: 'initial',
-                    content: `${brand('>')} ${initialPrompt}`,
-                    type: 'user',
-                },
-            ]
-            : []);
-    const [input, setInput] = useState('');
-    const inputTextRef = useRef('');
-    // Keep ref in sync so useInput handler can read current input text
-    const updateInput = (value) => {
-        inputTextRef.current = value;
-        setInput(value);
-    };
-    const [currentOperation, setCurrentOperation] = useState(resumeEvents ? '' : 'Waiting for response...');
-    const [exitHint, setExitHint] = useState(null);
-    const [isInterrupted, setIsInterrupted] = useState(false);
-    // Double-tap exit tracking (shared for Ctrl+C and Ctrl+D)
-    const exitKeyPressed = useRef(false);
-    const exitKeyTimeout = useRef(null);
-    // Interrupt tracking - prevents duplicate interrupt requests
-    const isInterrupting = useRef(false);
-    // Debounce Escape after mount so splash-skip doesn't trigger interrupt
-    const mountedAt = useRef(Date.now());
-    // Track terminal size for layout calculations
-    // Debounce resize to prevent spam during rapid resize events
-    const [terminalSize, setTerminalSize] = useState({
-        width: process.stdout.columns || 80,
-        height: process.stdout.rows || 24,
-    });
-    const resizeTimeout = useRef(null);
-    useEffect(() => {
-        const handleResize = () => {
-            // Debounce: only update after resize events stop for 100ms
-            if (resizeTimeout.current) {
-                clearTimeout(resizeTimeout.current);
-            }
-            resizeTimeout.current = setTimeout(() => {
-                setTerminalSize({
-                    width: process.stdout.columns || 80,
-                    height: process.stdout.rows || 24,
-                });
-            }, 100);
-        };
-        process.stdout.on('resize', handleResize);
-        return () => {
-            process.stdout.off('resize', handleResize);
-            if (resizeTimeout.current) {
-                clearTimeout(resizeTimeout.current);
-            }
-        };
-    }, []);
-    // Global keyboard shortcuts
-    useInput((input, key) => {
-        // Escape: Interrupt agent while processing
-        // Ignore Escape within 300ms of mount to prevent splash-skip from triggering interrupt
-        if (key.escape &&
-            client &&
-            session &&
-            currentOperation &&
-            !isInterrupting.current &&
-            Date.now() - mountedAt.current > 300) {
-            isInterrupting.current = true;
-            client
-                .post(`/sessions/${session.id}/interrupt`, {})
-                .then(() => {
-                debug('Session interrupted');
-            })
-                .catch((err) => {
-                debug('Interrupt failed (session may already be done):', err);
-            })
-                .finally(() => {
-                isInterrupting.current = false;
-            });
-            return;
-        }
-        // Ctrl-C: Clear input on first press (if text present), double-tap to exit
-        const isCtrlC = input === '\x03' || (key.ctrl && input === 'c');
-        if (isCtrlC) {
-            // If there's text in the input, clear it instead of showing exit hint
-            if (inputTextRef.current && !exitKeyPressed.current) {
-                updateInput('');
-                return;
-            }
-            if (exitKeyPressed.current) {
-                if (preConnectedSession?.id && resumeCommand) {
-                    printResumeHint(preConnectedSession.id, resumeCommand);
-                }
-                process.exit(0);
-            }
-            exitKeyPressed.current = true;
-            setExitHint('ctrl-c');
-            if (exitKeyTimeout.current)
-                clearTimeout(exitKeyTimeout.current);
-            exitKeyTimeout.current = setTimeout(() => {
-                exitKeyPressed.current = false;
-                setExitHint(null);
-            }, 2000);
-            return;
-        }
-        // Ctrl-D: Double-tap to exit
-        const isCtrlD = input === '\x04' || (key.ctrl && input === 'd');
-        if (isCtrlD) {
-            if (exitKeyPressed.current) {
-                if (preConnectedSession?.id && resumeCommand) {
-                    printResumeHint(preConnectedSession.id, resumeCommand);
-                }
-                process.exit(0);
-            }
-            exitKeyPressed.current = true;
-            setExitHint('ctrl-d');
-            if (exitKeyTimeout.current)
-                clearTimeout(exitKeyTimeout.current);
-            exitKeyTimeout.current = setTimeout(() => {
-                exitKeyPressed.current = false;
-                setExitHint(null);
-            }, 2000);
-            return;
-        }
-    });
-    // Clean up exit key timeout on unmount
-    useEffect(() => {
-        return () => {
-            if (exitKeyTimeout.current) {
-                clearTimeout(exitKeyTimeout.current);
-            }
-        };
-    }, []);
-    // Use pre-established connection directly from props (no state needed)
-    // This ensures we react to parent updates if user escapes splash before connection completes
-    const client = preConnectedClient;
-    const session = preConnectedSession;
-    const isReady = session !== null;
-    // Stateful spinner instance
-    const animatedSpinner = useRef(null);
-    const spinnerSwapInterval = useRef(null);
-    const spinnerTheme = process.env.GUILD_SPINNER_THEME;
-    const isRandomMode = spinnerTheme === 'random';
-    if (!animatedSpinner.current) {
-        animatedSpinner.current = createAnimatedSpinner();
-    }
-    const [spinnerFrame, setSpinnerFrame] = useState(() => animatedSpinner.current?.tick() || '');
-    const sentMessages = useRef(new Set());
-    const pollInterval = useRef(null);
-    const spinnerInterval = useRef(null);
-    const lastEventIdRef = useRef(resumeEvents?.length ? resumeEvents[resumeEvents.length - 1].id : undefined);
-    const isPolling = useRef(false);
-    const receivedResponseSinceLastInput = useRef(false);
-    const firstMessageNotified = useRef(!!resumeEvents);
-    const responseStreamKeys = useRef(responseStreamResumeState?.keys ?? new Map());
-    const responseStreamContents = useRef(responseStreamResumeState?.contents ?? new Map());
-    const responseStreamTexts = useRef(responseStreamResumeState?.texts ?? new Map());
-    const responseStreamTimestamps = useRef(responseStreamResumeState?.timestamps ?? new Map());
-    const responseStreamStatuses = useRef(responseStreamResumeState?.statuses ??
-        new Map());
-    const responseStreamKeysByTask = useRef(responseStreamResumeState?.keysByTask ?? new Map());
-    const clearResponseStreamsForTask = (taskId, options = {}) => {
-        if (!taskId)
-            return;
-        const keys = responseStreamKeysByTask.current.get(taskId);
-        if (!keys?.size)
-            return;
-        // Removed keys disappear from the transcript; detached keys stay rendered
-        // but are no longer tracked as active streams for future cleanup.
-        const removedKeys = new Set();
-        const detachedKeys = new Set();
-        for (const [streamId, key] of responseStreamKeys.current.entries()) {
-            if (keys.has(key)) {
-                if (options.preserveContinued &&
-                    responseStreamStatuses.current.get(streamId) === 'continued' &&
-                    responseStreamTexts.current.get(streamId) !== options.finalText) {
-                    responseStreamKeys.current.delete(streamId);
-                    responseStreamContents.current.delete(streamId);
-                    responseStreamTexts.current.delete(streamId);
-                    responseStreamTimestamps.current.delete(streamId);
-                    responseStreamStatuses.current.delete(streamId);
-                    detachedKeys.add(key);
-                    continue;
-                }
-                responseStreamKeys.current.delete(streamId);
-                responseStreamContents.current.delete(streamId);
-                responseStreamTexts.current.delete(streamId);
-                responseStreamTimestamps.current.delete(streamId);
-                responseStreamStatuses.current.delete(streamId);
-                removedKeys.add(key);
-            }
-        }
-        const inactiveKeys = new Set([...removedKeys, ...detachedKeys]);
-        const remainingKeys = new Set([...keys].filter((key) => !inactiveKeys.has(key)));
-        if (remainingKeys.size > 0) {
-            responseStreamKeysByTask.current.set(taskId, remainingKeys);
-        }
-        else {
-            responseStreamKeysByTask.current.delete(taskId);
-        }
-        setMessages((prev) => prev.filter((message) => !removedKeys.has(message.key)));
-    };
-    const upsertResponseStreamMessage = (event) => {
-        if (!isResponseStreamEvent(event))
-            return;
-        if (!isRootTaskEvent(event))
-            return;
-        const streamId = event.content.stream_id;
-        const taskId = event.task?.id;
-        const existingKey = responseStreamKeys.current.get(streamId);
-        if (event.content.status === 'aborted') {
-            responseStreamContents.current.delete(streamId);
-            responseStreamTexts.current.delete(streamId);
-            responseStreamTimestamps.current.delete(streamId);
-            responseStreamStatuses.current.delete(streamId);
-            if (existingKey) {
-                responseStreamKeys.current.delete(streamId);
-                if (taskId) {
-                    const keys = responseStreamKeysByTask.current.get(taskId);
-                    keys?.delete(existingKey);
-                    if (keys?.size === 0)
-                        responseStreamKeysByTask.current.delete(taskId);
-                }
-                setMessages((prev) => prev.filter((message) => message.key !== existingKey));
-            }
-            return;
-        }
-        const streamContents = responseStreamContents.current.get(streamId) ?? [];
-        const existingContentIndex = streamContents.findIndex((content) => content.sequence === event.content.sequence);
-        if (existingContentIndex === -1) {
-            streamContents.push(event.content);
-        }
-        else {
-            streamContents[existingContentIndex] = event.content;
-        }
-        responseStreamContents.current.set(streamId, streamContents);
-        const text = applyResponseStreamContentsInSequence(streamContents);
-        if (!text.trim())
-            return;
-        const key = existingKey ?? `response-stream-${streamId}`;
-        responseStreamKeys.current.set(streamId, key);
-        responseStreamTexts.current.set(streamId, text);
-        responseStreamStatuses.current.set(streamId, event.content.status);
-        if (taskId) {
-            const keys = responseStreamKeysByTask.current.get(taskId) ?? new Set();
-            keys.add(key);
-            responseStreamKeysByTask.current.set(taskId, keys);
-        }
-        const taskName = agentName || 'assistant';
-        const messageContent = renderAssistantMessage(text, taskName);
-        const timestamp = responseStreamTimestamps.current.get(streamId) ?? new Date().toLocaleTimeString();
-        responseStreamTimestamps.current.set(streamId, timestamp);
-        setMessages((prev) => {
-            const index = prev.findIndex((message) => message.key === key);
-            const message = {
-                key,
-                content: messageContent,
-                type: 'assistant',
-                timestamp,
-            };
-            if (index === -1)
-                return [...prev, message];
-            const next = [...prev];
-            next[index] = message;
-            return next;
-        });
-        if (!firstMessageNotified.current && onFirstMessage) {
-            firstMessageNotified.current = true;
-            onFirstMessage();
-        }
-        if (event.content.status === 'done') {
-            receivedResponseSinceLastInput.current = true;
-            setCurrentOperation('');
-        }
-    };
-    // Mark initial prompt as sent (skip for resume — we already have the events)
-    useEffect(() => {
-        if (!resumeEvents) {
-            sentMessages.current.add(initialPrompt);
-            receivedResponseSinceLastInput.current = false;
-        }
-    }, [initialPrompt, resumeEvents]);
-    // Check if there are active tasks (for spinner logic)
-    const hasActiveTasksNow = hasActiveTasks(tasks);
-    // Spinner animation - run when there's an operation OR active tasks
-    useEffect(() => {
-        if (!currentOperation && !hasActiveTasksNow)
-            return;
-        spinnerInterval.current = setInterval(() => {
-            if (animatedSpinner.current) {
-                setSpinnerFrame(animatedSpinner.current.tick());
-            }
-        }, 50);
-        return () => {
-            if (spinnerInterval.current) {
-                clearInterval(spinnerInterval.current);
-                spinnerInterval.current = null;
-            }
-        };
-    }, [currentOperation, hasActiveTasksNow]);
-    // Random mode: swap spinners periodically
-    useEffect(() => {
-        if (!isRandomMode)
-            return;
-        spinnerSwapInterval.current = setInterval(() => {
-            animatedSpinner.current = createRandomSpinner();
-        }, 5000 + Math.random() * 5000);
-        return () => {
-            if (spinnerSwapInterval.current) {
-                clearInterval(spinnerSwapInterval.current);
-                spinnerSwapInterval.current = null;
-            }
-        };
-    }, [isRandomMode]);
-    // Poll for tasks (like web's useGetSessionTasksQuery)
-    const isPollingTasks = useRef(false);
-    useEffect(() => {
-        if (!client || !session || !isReady)
-            return;
-        const pollTasks = async () => {
-            if (isPollingTasks.current)
-                return;
-            isPollingTasks.current = true;
-            try {
-                const tasksList = await fetchTasks(client, session.id);
-                setTasks(tasksList);
-            }
-            catch (error) {
-                debug('Tasks poll error:', error);
-            }
-            finally {
-                isPollingTasks.current = false;
-            }
-        };
-        // Poll immediately and then every 2 seconds
-        pollTasks();
-        const interval = setInterval(pollTasks, 2000);
-        return () => {
-            clearInterval(interval);
-        };
-    }, [client, session, isReady]);
-    // Poll for messages
-    useEffect(() => {
-        if (!client || !session || !isReady)
-            return;
-        const poll = async () => {
-            if (isPolling.current)
-                return;
-            isPolling.current = true;
-            debug(`poll() called, session=${session.id}, fromId=${lastEventIdRef.current}`);
-            try {
-                const newEvents = await fetchEvents(client, session.id, {
-                    fromId: lastEventIdRef.current,
-                });
-                debug(`Events: fromId=${lastEventIdRef.current}, new=${newEvents.length}`);
-                if (newEvents.length > 0) {
-                    lastEventIdRef.current = newEvents[newEvents.length - 1].id;
-                    for (const event of newEvents) {
-                        // Track task from event if present
-                        const taskInfo = event.task;
-                        // Debug: log ALL events with task info
-                        if (taskInfo) {
-                            const taskName = 'agent' in taskInfo
-                                ? getAgentName(taskInfo.agent)
-                                : 'tool_name' in taskInfo
-                                    ? taskInfo.tool_name || 'task'
-                                    : 'unknown';
-                            debug(`Event: ${event.type}, task=${taskName}:${taskInfo.id.substring(0, 8)}, status=${taskInfo.status}`);
-                        }
-                        else {
-                            debug(`Event: ${event.type} (no task info)`);
-                        }
-                        // Process events that affect the chat UI (task state comes from tasks poll)
-                        if (event.type === 'runtime_error') {
-                            clearResponseStreamsForTask(taskInfo?.id);
-                            // Always clear the spinner on runtime errors so the UI doesn't get stuck
-                            setCurrentOperation('');
-                            // Show runtime errors in the chat (gated on --events filter)
-                            if (shouldShowEvent('runtime_error', activeFilter)) {
-                                const errorText = typeof event.content === 'string' ? event.content : 'Unknown error';
-                                const taskName = agentName || 'assistant';
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `error-${Date.now()}`,
-                                        content: `${chalk.red('●')} ${chalk.bold(taskName)}\n${chalk.red(`Error: ${errorText}`)}`,
-                                        type: 'assistant',
-                                    },
-                                ]);
-                            }
-                        }
-                        else if (event.type === 'runtime_start') {
-                            if (shouldShowEvent('runtime_start', activeFilter)) {
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `runtime-start-${Date.now()}`,
-                                        content: chalk.dim('[runtime/start]'),
-                                        type: 'assistant',
-                                    },
-                                ]);
-                            }
-                        }
-                        else if (event.type === 'runtime_running') {
-                            if (shouldShowEvent('runtime_running', activeFilter)) {
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `runtime-running-${Date.now()}`,
-                                        content: chalk.dim('[runtime/running]'),
-                                        type: 'assistant',
-                                    },
-                                ]);
-                            }
-                        }
-                        else if (event.type === 'runtime_waiting') {
-                            if (shouldShowEvent('runtime_waiting', activeFilter)) {
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `runtime-waiting-${Date.now()}`,
-                                        content: chalk.dim('[runtime/waiting]'),
-                                        type: 'assistant',
-                                    },
-                                ]);
-                            }
-                        }
-                        else if (event.type === 'trigger_message') {
-                            if (shouldShowEvent('trigger_message', activeFilter)) {
-                                const triggerText = typeof event.content === 'object' ? event.content?.data || '' : '';
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `trigger-${Date.now()}`,
-                                        content: `${chalk.cyan('[trigger]')} ${triggerText}`,
-                                        type: 'assistant',
-                                    },
-                                ]);
-                            }
-                        }
-                        else if (event.type === 'system_error') {
-                            if (shouldShowEvent('system_error', activeFilter)) {
-                                const errText = typeof event.content === 'object' ? event.content?.data || '' : '';
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `system-error-${Date.now()}`,
-                                        content: `${chalk.red('[system_error]')} ${errText}`,
-                                        type: 'assistant',
-                                    },
-                                ]);
-                            }
-                        }
-                        else if (event.type === 'llm_start') {
-                            if (shouldShowEvent('llm_start', activeFilter)) {
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `llm-start-${Date.now()}`,
-                                        content: chalk.dim(`[llm_start] provider:${event.provider}`),
-                                        type: 'assistant',
-                                    },
-                                ]);
-                            }
-                        }
-                        else if (event.type === 'llm_done') {
-                            if (shouldShowEvent('llm_done', activeFilter)) {
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `llm-done-${Date.now()}`,
-                                        content: chalk.dim(`[llm_done] HTTP ${event.status_code}`),
-                                        type: 'assistant',
-                                    },
-                                ]);
-                            }
-                        }
-                        else if (event.type === 'agent_notification_progress') {
-                            // Update status line with progress text (task tracking is done by tasks poll)
-                            const rawProgressText = typeof event.content === 'string'
-                                ? event.content
-                                : event.content?.data || '';
-                            // Skip internal task names as progress (e.g., "ui_prompt" when waiting for input)
-                            if (rawProgressText && !isFilteredTaskName(rawProgressText)) {
-                                setCurrentOperation(rawProgressText);
-                            }
-                        }
-                        else if (event.type === 'agent_notification_message') {
-                            if (isResponseStreamEvent(event)) {
-                                upsertResponseStreamMessage(event);
-                                continue;
-                            }
-                            const text = extractMessageText(getAgentNotificationText(event));
-                            if (text.trim()) {
-                                clearResponseStreamsForTask(taskInfo?.id, {
-                                    preserveContinued: true,
-                                    finalText: text,
-                                });
-                                const taskName = agentName || 'assistant';
-                                const messageContent = renderAssistantMessage(text, taskName);
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `msg-${Date.now()}-${Math.random()}`,
-                                        content: messageContent,
-                                        type: 'assistant',
-                                        timestamp: new Date().toLocaleTimeString(),
-                                    },
-                                ]);
-                                // Notify parent that first message has arrived (for splash screen transition)
-                                if (!firstMessageNotified.current && onFirstMessage) {
-                                    firstMessageNotified.current = true;
-                                    onFirstMessage();
-                                }
-                            }
-                            receivedResponseSinceLastInput.current = true;
-                            setCurrentOperation('');
-                        }
-                        else if (event.type === 'agent_notification_error') {
-                            clearResponseStreamsForTask(taskInfo?.id);
-                            // Show error in chat (task status is updated via tasks poll)
-                            const errorText = typeof event.content === 'string'
-                                ? event.content
-                                : event.content?.data || 'Unknown error';
-                            const taskName = agentName || 'assistant';
-                            setMessages((prev) => [
-                                ...prev,
-                                {
-                                    key: `error-${Date.now()}`,
-                                    content: `${chalk.red('●')} ${chalk.bold(taskName)}\n${chalk.red(`Error: ${errorText}`)}`,
-                                    type: 'assistant',
-                                },
-                            ]);
-                            setCurrentOperation('');
-                        }
-                        else if (event.type === 'agent_console') {
-                            // Show console logs when enabled via --events or --debug
-                            // --debug continues to show console logs for backwards compatibility
-                            if (shouldShowEvent('agent_console', activeFilter) || isDebugMode()) {
-                                const content = typeof event.content === 'string' ? event.content : '';
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `console-${Date.now()}-${Math.random()}`,
-                                        content: chalk.dim(`[console.${event.level}] ${content}`),
-                                        type: 'assistant',
-                                    },
-                                ]);
-                            }
-                        }
-                        else if (event.type === 'runtime_done') {
-                            if (shouldShowEvent('runtime_done', activeFilter)) {
-                                // Show runtime_done as a system event when enabled via --events
-                                setMessages((prev) => [
-                                    ...prev,
-                                    {
-                                        key: `runtime-done-${Date.now()}`,
-                                        content: chalk.dim('[runtime/done]'),
-                                        type: 'assistant',
-                                    },
-                                ]);
-                            }
-                            if (!receivedResponseSinceLastInput.current &&
-                                event.content !== undefined &&
-                                taskInfo &&
-                                'agent' in taskInfo) {
-                                // One-shot agents may complete with runtime_done without sending
-                                // agent_notification_message. Display the output if we haven't
-                                // already shown a response for this input cycle.
-                                const contentStr = typeof event.content === 'string'
-                                    ? event.content
-                                    : JSON.stringify(event.content);
-                                clearResponseStreamsForTask(taskInfo.id, {
-                                    preserveContinued: true,
-                                    finalText: contentStr,
-                                });
-                                if (contentStr && contentStr !== '{}' && contentStr !== 'null') {
-                                    const rendered = fixListItemMarkdown(marked.parse(contentStr));
-                                    const taskName = agentName || 'assistant';
-                                    const messageContent = `${chalk.green('●')} ${chalk.bold(taskName)}\n${rendered.trim()}`;
-                                    setMessages((prev) => [
-                                        ...prev,
-                                        {
-                                            key: `msg-${Date.now()}-${Math.random()}`,
-                                            content: messageContent,
-                                            type: 'assistant',
-                                            timestamp: new Date().toLocaleTimeString(),
-                                        },
-                                    ]);
-                                    if (!firstMessageNotified.current && onFirstMessage) {
-                                        firstMessageNotified.current = true;
-                                        onFirstMessage();
-                                    }
-                                    receivedResponseSinceLastInput.current = true;
-                                    setCurrentOperation('');
-                                }
-                            }
-                        }
-                        else if (event.type === 'interrupted') {
-                            clearResponseStreamsForTask(taskInfo?.id);
-                            // Session was interrupted — interrupted sessions are terminal on the backend
-                            setMessages((prev) => [
-                                ...prev,
-                                {
-                                    key: `interrupted-${Date.now()}`,
-                                    content: chalk.dim('⊘ Interrupted'),
-                                    type: 'assistant',
-                                },
-                            ]);
-                            setCurrentOperation('');
-                            setIsInterrupted(true);
-                        }
-                        else if (isUnfulfilledAgentInstallRequest(event)) {
-                            // Check for agent install requests that need user approval
-                            if (!promptedEventIds.current.has(event.id) && !pendingInstallRequest) {
-                                debug(`Found unfulfilled agent install request: ${event.id}`);
-                                promptedEventIds.current.add(event.id);
-                                setPendingInstallRequest(event);
-                            }
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                debug('Polling error:', error);
-            }
-            finally {
-                isPolling.current = false;
-            }
-        };
-        pollInterval.current = setInterval(poll, 2000);
-        poll();
-        return () => {
-            if (pollInterval.current) {
-                clearInterval(pollInterval.current);
-                pollInterval.current = null;
-            }
-        };
-    }, [client, session, isReady, pendingInstallRequest]);
-    // Handle message submission
-    const handleSubmit = async (value) => {
-        const text = value.trim();
-        if (text === 'exit' || text === 'quit') {
-            if (preConnectedSession?.id && resumeCommand) {
-                printResumeHint(preConnectedSession.id, resumeCommand);
-            }
-            process.exit(0);
-        }
-        if (!text || !client || !session || !isReady)
-            return;
-        // Track sent messages to filter echoes from backend
-        sentMessages.current.add(value);
-        // Add user message to display immediately
-        setMessages((prev) => [
-            ...prev,
-            {
-                key: `user-${Date.now()}`,
-                content: `${brand('>')} ${value}`,
-                type: 'user',
-            },
-        ]);
-        // Clear input right after showing the message
-        updateInput('');
-        try {
-            await client.post(`/sessions/${session.id}/events`, {
-                content: value,
-            });
-            receivedResponseSinceLastInput.current = false;
-            setCurrentOperation('Waiting for response...');
-        }
-        catch (error) {
-            debug('Send error:', error);
-            setMessages((prev) => [
-                ...prev,
-                {
-                    key: `error-${Date.now()}`,
-                    content: chalk.red('Failed to send message'),
-                    type: 'assistant',
-                },
-            ]);
-        }
-    };
-    // Active tasks for spinner (excluding filtered internal tasks like ui_prompt)
-    const activeTasksList = tasks.filter((t) => (t.status === 'CREATED' ||
-        t.status === 'STARTED' ||
-        t.status === 'RUNNING' ||
-        t.status === 'WAITING') &&
-        !isFilteredTaskName(getTaskDisplayName(t)));
-    const activeTaskCount = activeTasksList.length;
-    // Calculate status line - only show when we have an active operation
-    const statusLine = (() => {
-        // No operation = idle = no spinner
-        if (!currentOperation) {
-            return '';
-        }
-        if (activeTaskCount > 0) {
-            // Find the most recently updated active task
-            const mostRecentTask = activeTasksList.reduce((a, b) => new Date(b.updated_at) > new Date(a.updated_at) ? b : a);
-            if (!mostRecentTask) {
-                return `${brand(spinnerFrame)} ${currentOperation}`;
-            }
-            const taskName = 'agent' in mostRecentTask
-                ? getAgentName(mostRecentTask.agent)
-                : 'tool_name' in mostRecentTask
-                    ? mostRecentTask.tool_name || 'task'
-                    : 'assistant';
-            // Hide elapsed time for root tasks (no parent) - they run for entire session
-            const isRootTask = !mostRecentTask.parent_task;
-            const elapsed = Math.floor((Date.now() - new Date(mostRecentTask.created_at).getTime()) / 1000);
-            const elapsedText = isRootTask ? '' : `  ${chalk.dim(`(${elapsed}s)`)}`;
-            // Avoid redundancy: if operation already mentions the task, just show operation
-            const showTaskName = !currentOperation.includes(taskName);
-            if (showTaskName) {
-                return `${brand(spinnerFrame)} ${taskName} · ${currentOperation}${elapsedText}`;
-            }
-            return `${brand(spinnerFrame)} ${currentOperation}${elapsedText}`;
-        }
-        // No active tasks but we have an operation (e.g., "Waiting for response...")
-        return `${brand(spinnerFrame)} ${currentOperation}`;
-    })();
-    const terminalWidth = terminalSize.width;
-    // Content always uses full width - drawer overlays on top
-    const contentWidth = terminalWidth;
-    // Drawer doesn't need fixed height - it will match the message container
-    // Ctrl-T hints for toggling task view
-    const hideTasksHintText = '[ctrl-t to hide tasks]';
-    const hideTasksHint = `[${chalk.bold('ctrl-t')} to hide tasks]`;
-    const showTasksHintText = '[ctrl-t to show tasks]';
-    const showTasksHint = `[${chalk.bold('ctrl-t')} to show tasks]`;
-    // Build status line with right-aligned hint
-    // Priority: exit hint > esc to interrupt > ctrl-t task hint
-    // Strip ANSI codes to get visible length (statusLine contains spinner with color codes)
-    const stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, '');
-    const statusWithHint = (() => {
-        let hintText = null;
-        let hint = null;
-        if (exitHint) {
-            hintText = `[${exitHint} again to exit]`;
-            hint = `[${chalk.bold(exitHint)} again to exit]`;
-        }
-        else if (currentOperation) {
-            hintText = '(esc to interrupt)';
-            hint = `(${chalk.bold('esc')} to interrupt)`;
-        }
-        if (!hintText && activeTaskCount > 0 && currentOperation) {
-            hintText = showTaskPanel ? hideTasksHintText : showTasksHintText;
-            hint = showTaskPanel ? hideTasksHint : showTasksHint;
-        }
-        if (hintText && hint) {
-            const visibleStatusLength = stripAnsi(statusLine).length;
-            const hintLength = hintText.length;
-            const totalNeeded = visibleStatusLength + hintLength + 4; // +4 for spacing buffer
-            if (totalNeeded <= contentWidth) {
-                // Right-align hint with padding
-                const padding = contentWidth - visibleStatusLength - hintLength - 2; // -2 for buffer
-                return statusLine + ' '.repeat(Math.max(1, padding)) + chalk.dim(hint);
-            }
-        }
-        return statusLine;
-    })();
-    // Handler for approving agent installation
-    const handleApproveInstall = async () => {
-        if (!pendingInstallRequest || !client || !session?.workspace_id) {
-            throw new Error('Missing required data for agent installation');
-        }
-        const agentId = pendingInstallRequest.requested_agent.id;
-        const eventId = pendingInstallRequest.id;
-        const workspaceId = session.workspace_id;
-        debug(`Approving agent install: agent=${agentId}, event=${eventId}, workspace=${workspaceId}`);
-        await client.post(`/workspaces/${workspaceId}/agents`, {
-            agent_id: agentId,
-            event_id: eventId,
-        });
-    };
-    // Handler for declining agent installation
-    const handleDeclineInstall = async () => {
-        if (!pendingInstallRequest || !client) {
-            throw new Error('Missing required data for declining installation');
-        }
-        const eventId = pendingInstallRequest.id;
-        debug(`Declining agent install: event=${eventId}`);
-        await client.delete(`/events/${eventId}`);
-    };
-    // Handler for when install prompt is complete
-    const handleInstallComplete = () => {
-        setPendingInstallRequest(null);
-    };
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Static, { items: messages }, (msg, index) => (React.createElement(Box, { key: msg.key, flexDirection: "column", marginTop: msg.type === 'user' && index > 0 ? 1 : 0 },
-            React.createElement(Text, null, msg.content)))),
-        showTaskPanel && tasks.length > 0 && currentOperation && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
-            React.createElement(TaskView, { tasks: tasks }))),
-        pendingInstallRequest && (React.createElement(AgentInstallPrompt, { event: pendingInstallRequest, onApprove: handleApproveInstall, onDecline: handleDeclineInstall, onComplete: handleInstallComplete })),
-        React.createElement(Box, { height: 1, marginTop: 1 },
-            React.createElement(Text, null, statusWithHint)),
-        React.createElement(Box, { height: 1 },
-            React.createElement(Text, { color: "gray" }, '─'.repeat(Math.max(1, terminalWidth - 2)))),
-        React.createElement(InputWrapper, { isReady: isReady, isInterrupted: isInterrupted, input: input, setInput: updateInput, handleSubmit: handleSubmit, trackedTasksSize: tasks.length, setShowTaskPanel: setShowTaskPanel, isActive: isActive })));
-}
-export async function ensureAuthenticated() {
-    const token = await getAuthToken();
-    if (!token) {
-        format.error('Not authenticated. Run: guild auth login');
-        process.exit(1);
-    }
-    // Validate token against the server to catch expired/invalid tokens
-    // before any UI (splash, Ink) renders.
-    try {
-        const client = new GuildAPIClient();
-        await client.get('/me');
-    }
-    catch {
-        // Token is expired or invalid — clear it and exit
-        const { clearAuthToken } = await import('../lib/auth.js');
-        await clearAuthToken();
-        format.error('Session expired. Run: guild auth login');
-        process.exit(1);
-    }
-    return token;
-}
-export async function createSession(client, workspaceId, initialPrompt, versionId, onProgress) {
-    const progress = onProgress || (() => { });
-    if (!workspaceId) {
-        // Check for workspace in local (guild.json) or global (~/.guild/config.json) config
-        progress('Loading config');
-        const resolved = await getWorkspaceId();
-        if (resolved) {
-            workspaceId = resolved.workspaceId;
-            const sourceLabel = getWorkspaceSourceLabel(resolved.source);
-            if (sourceLabel) {
-                progress(`Using workspace from ${sourceLabel}`);
-            }
-        }
-    }
-    if (!workspaceId) {
-        throw new WorkspaceNotConfiguredError();
-    }
-    progress('Creating session');
-    const sessionData = {
-        initial_prompt: initialPrompt,
-        session_type: 'chat',
-    };
-    if (versionId) {
-        // API field is "agent_id" but the server expects a version identifier
-        // (resolved by gen_agent_version_id_for). Raw agent UUIDs are not supported.
-        sessionData.agent_id = versionId;
-    }
-    let response;
-    try {
-        response = await client.post(`/workspaces/${workspaceId}/sessions`, sessionData);
-    }
-    catch (error) {
-        const err = handleAxiosError(error);
-        if (err.code === ErrorCodes.NOT_FOUND) {
-            throw new WorkspaceNotFoundError(workspaceId);
-        }
-        throw error;
-    }
-    if (!response) {
-        throw new Error('Failed to create session');
-    }
-    // Include the workspace_id we used to create the session
-    // (backend may return workspace object instead of workspace_id string)
-    return { ...response, workspace_id: workspaceId };
-}
-export function createChatCommand() {
-    const cmd = new Command('chat');
-    cmd
-        .description('Chat with an agent (default: Guild assistant)')
-        .argument('[prompt...]', 'Optional initial prompt (multiple words)')
-        .option('--agent <identifier>', 'Agent ID or full name, e.g., foo~bar (default: assistant)')
-        .option('--once', 'One-shot mode: send message, wait for response, exit (non-interactive)')
-        .option('--workspace <identifier>', 'Workspace ID or full name (e.g., owner/workspace-name)')
-        .option('--no-splash', 'Skip the splash screen animation')
-        .option('--resume <session-id>', 'Resume an existing session')
-        .option('--events <types>', 'Event types to show (default: user). Shorthands: none, user, system, all, or comma-separated type names (e.g. agent_console,llm_start)')
-        // Accept --mode so `guild chat --mode json` works when re-parsed.
-        // The actual value is read from process.argv by getOutputMode().
-        .addOption(new Option('--mode <format>').hideHelp())
-        .addHelpText('after', '\nTo chat with a local agent under development: guild agent chat')
-        .action(async (promptArgs, options) => {
-        const initialPrompt = promptArgs.length > 0 ? promptArgs.join(' ') : 'Hello';
-        const eventFilter = options.events
-            ? parseEventFilter(options.events)
-            : DEFAULT_EVENT_TYPES;
-        if (options.once) {
-            // --once mode: use old spinner-based approach
-            const spinner = createSpinner('Connecting to Guild servers...');
-            spinner.start();
-            try {
-                await ensureAuthenticated();
-                const client = new GuildAPIClient();
-                const session = await createSession(client, options.workspace, initialPrompt, options.agent, (status) => {
-                    spinner.text = status;
-                });
-                spinner.succeed('Connected');
-                if (session.session_url) {
-                    const sessionLink = hyperlink(session.id, session.session_url);
-                    console.error(chalk.dim(`Session: ${sessionLink}`));
-                }
-                console.error('');
-                // Non-interactive mode: send message, wait for response, output JSON
-                // Poll for messages until we get an agent MESSAGE response
-                // Timeout after 5 minutes of INACTIVITY (no new messages)
-                // Agent initialization can take 1-2 minutes with no events
-                const inactivityTimeoutMs = 300000; // 5 minutes
-                const pollIntervalMs = 2000;
-                const maxInactivityAttempts = inactivityTimeoutMs / pollIntervalMs;
-                let lastSeenEventId;
-                const allEvents = [];
-                let inactivityCounter = 0;
-                while (true) {
-                    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-                    const newEvents = await fetchEvents(client, session.id, {
-                        fromId: lastSeenEventId,
-                    });
-                    if (newEvents.length > 0) {
-                        for (const evt of newEvents) {
-                            const taskInfo = evt.task;
-                            if (taskInfo) {
-                                debug(`Event: ${evt.type}, task=${taskInfo.agent || taskInfo.tool_name || 'unknown'}:${(taskInfo.id || '').substring(0, 8)}, status=${taskInfo.status}`);
-                            }
-                            else {
-                                debug(`Event: ${evt.type} (no task info)`);
-                            }
-                        }
-                        allEvents.push(...newEvents);
-                        lastSeenEventId = newEvents[newEvents.length - 1].id;
-                        inactivityCounter = 0;
-                    }
-                    else {
-                        inactivityCounter++;
-                    }
-                    // Check if we got a completion response from the root agent.
-                    // Stream done events are only a rendering fallback; wait for the
-                    // final root message or runtime completion so child drafts cannot
-                    // terminate --once early.
-                    const hasRootTaskDone = allEvents.some((e) => e.type === 'runtime_done' && isRootTaskEvent(e));
-                    const hasAgentMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
-                        isRootTaskEvent(e) &&
-                        !isResponseStreamEvent(e));
-                    const hasRootTaskError = allEvents.some((e) => e.type === 'runtime_error' && isRootTaskEvent(e));
-                    // Check for a ui_prompt request... that ends the game.
-                    const hasUIPromptMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
-                        !isResponseStreamEvent(e) &&
-                        e.task?.tool_name === 'ui_prompt');
-                    if (hasRootTaskError) {
-                        debug('Found error event from root agent, exiting --once mode');
-                        const errorEvents = allEvents.filter((e) => e.type === 'runtime_error' || e.type === 'agent_notification_error');
-                        const outputMode = getOutputMode();
-                        if (errorEvents.length > 0 && outputMode === 'interactive') {
-                            const lastError = errorEvents[errorEvents.length - 1];
-                            const content = lastError.content;
-                            if (content?.data) {
-                                console.error(chalk.red(`Error: ${content.data}`));
-                            }
-                            else {
-                                console.error(chalk.red('Agent failed to start'));
-                            }
-                        }
-                        else if (outputMode === 'json') {
-                            console.log(JSON.stringify({
-                                session_id: session.id,
-                                events: allEvents,
-                                error: true,
-                            }, null, 2));
-                        }
-                        process.exit(1);
-                    }
-                    if (hasRootTaskDone || hasAgentMessage || hasUIPromptMessage) {
-                        debug('Found completion event from root agent, exiting --once mode');
-                        await outputOnceResult(session.id, allEvents, getOutputMode());
-                        process.exit(0);
-                    }
-                    // Timeout if no activity for too long
-                    if (inactivityCounter >= maxInactivityAttempts) {
-                        debug(`Inactivity timeout reached (${maxInactivityAttempts} attempts with no new events)`);
-                        debug(`Exiting with ${allEvents.length} events total`);
-                        await outputOnceResult(session.id, allEvents, getOutputMode());
-                        process.exit(0);
-                    }
-                }
-            }
-            catch (error) {
-                spinner.fail('Connection failed');
-                console.error('');
-                if (error instanceof WorkspaceNotConfiguredError) {
-                    format.error(WORKSPACE_NOT_CONFIGURED_MSG);
-                    process.exit(1);
-                }
-                if (error instanceof WorkspaceNotFoundError) {
-                    format.error(WORKSPACE_NOT_FOUND_MSG);
-                    process.exit(1);
-                }
-                const formattedError = handleAxiosError(error);
-                console.error(`Error: ${formattedError.error}`);
-                console.error(formattedError.details);
-                // Show suggestions if available
-                if (formattedError.suggestions && formattedError.suggestions.length > 0) {
-                    console.error('');
-                    console.error('Suggestions:');
-                    formattedError.suggestions.forEach((suggestion) => {
-                        console.error(`  • ${suggestion}`);
-                    });
-                }
-                process.exit(1);
-            }
-        }
-        else {
-            // Interactive mode - check auth first, then render UI with splash animation
-            ensureInteractiveStdin('guild chat');
-            await ensureAuthenticated();
-            // Build the resume command string for exit hints
-            let resumeCommand = 'guild chat';
-            if (options.agent)
-                resumeCommand += ` --agent ${options.agent}`;
-            // Handle --resume: fetch existing session + events
-            let resumeSession;
-            let resumeSessionEvents;
-            if (options.resume) {
-                const client = new GuildAPIClient();
-                resumeSession = await fetchSession(client, options.resume);
-                resumeSessionEvents = await fetchSessionEvents(client, options.resume);
-            }
-            // Only show splash screen in truly interactive mode
-            // (not --json, not --quiet, not --no-splash, not --resume)
-            const isInteractive = getOutputMode() === 'interactive' && !isQuietMode();
-            const shouldShowSplash = isInteractive && options.splash !== false && !options.resume;
-            // Strip ESC[3J (erase scrollback) from Ink's output to prevent
-            // iTerm2 "clear scrollback" warning during fullscreen splash.
-            if (shouldShowSplash) {
-                suppressScrollbackClear();
-            }
-            const { waitUntilExit } = render(React.createElement(ChatApp, { initialPrompt: initialPrompt, version: packageJson.version, workspaceId: options.workspace, versionId: options.agent, showSplash: shouldShowSplash, resumeSession: resumeSession, resumeEvents: resumeSessionEvents, resumeCommand: resumeCommand, eventFilter: eventFilter }), {
-                exitOnCtrlC: false, // We handle Ctrl-C in useInput (raw mode)
-            });
-            await waitUntilExit();
-        }
-    });
-    return cmd;
-}
-// Thin wrapper for lazy-loading from index.ts (avoids importing React at startup)
-export async function handleChatAction(_promptArgs, _options) {
-    const cmd = createChatCommand();
-    // Re-parse the original argv so the command's own action handler runs
-    await cmd.parseAsync(process.argv.slice(2), { from: 'user' });
-}
-//# sourceMappingURL=chat.js.map