praxis-agent 0.45.3 → 0.46.0

package/dist/cli/interactive.js

@@ -28,6 +28,7 @@ import { createTuiAppendHistoryChange } from './tui/transcript-window-model.js';
 import { createTuiHistoryChange, resolveTuiRenderer, } from './tui/tui-view-model.js';
 import { projectTuiScreen, } from './tui/tui-screen-model.js';
 import { TuiAnsiSurface } from './tui/ansi-surface.js';
+import { clampTranscriptScrollOffset, createTerminalSelectionContext, createTerminalSelectionState, parseTerminalMouseReport, projectTerminalSelection, refreshTerminalSelection, releaseTerminalSelection, startTerminalSelection, updateTerminalSelection, } from './tui/terminal-selection.js';
 import { QuietInkFrame } from './tui/quiet-frame-adapter.js';
 import { projectQuietScreenFrame, } from './tui/quiet-screen-projector.js';
 import { projectTuiHelpSurface } from './tui/help-surface-model.js';
@@ -374,6 +375,15 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const inputHistoryRef = useRef([]);
     const inputHistoryIndexRef = useRef(null);
     const inputHistoryDraftRef = useRef('');
+    const [pendingInputs, setPendingInputs] = useState([]);
+    const pendingInputsRef = useRef(pendingInputs);
+    pendingInputsRef.current = pendingInputs;
+    const followUpQueueRef = useRef([]);
+    const updatePendingInputs = (update) => {
+        const next = typeof update === 'function' ? update(pendingInputsRef.current) : update;
+        pendingInputsRef.current = next;
+        setPendingInputs(next);
+    };
     const undoStackRef = useRef([]);
     const composerImagesRef = useRef(new Map());
     const nextImageIdRef = useRef(1);
@@ -487,6 +497,11 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         transcriptScrollOffsetRef.current = offset;
         setTranscriptScrollOffsetState(offset);
     };
+    const [terminalSelection, setTerminalSelection] = useState(createTerminalSelectionState);
+    const terminalSelectionRef = useRef(createTerminalSelectionState());
+    const terminalSelectionContextRef = useRef(null);
+    const selectionEdgeTimerRef = useRef(null);
+    const [clearRevision, setClearRevision] = useState(0);
     const sessionLoadRef = useRef(0);
     const [turnDiffs, setTurnDiffs] = useState([]);
     const turnNumberRef = useRef(0);
@@ -1191,6 +1206,56 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const conversationScreen = screen.body.kind === 'conversation' ? screen.body : undefined;
     const transcriptPageRows = conversationScreen?.transcript.pageRows ?? 2;
     const maxTranscriptScrollOffset = conversationScreen?.transcript.maxScrollOffset ?? 0;
+    const stopSelectionEdgeScroll = () => {
+        if (selectionEdgeTimerRef.current !== null) {
+            clearInterval(selectionEdgeTimerRef.current);
+            selectionEdgeTimerRef.current = null;
+        }
+    };
+    const selectionContextRef = terminalSelectionContextRef;
+    const copyTerminalSelection = (text) => {
+        if (!text)
+            return;
+        void sideQuestionClipboardWriter(text).catch((error) => {
+            append({
+                kind: 'warning',
+                text: `Clipboard unavailable: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        });
+    };
+    const beginSelectionEdgeScroll = (direction) => {
+        if (selectionEdgeTimerRef.current !== null)
+            return;
+        selectionEdgeTimerRef.current = setInterval(() => {
+            const context = selectionContextRef.current;
+            const current = terminalSelectionRef.current;
+            if (!context ||
+                current.phase !== 'dragging' ||
+                current.edge !== direction) {
+                stopSelectionEdgeScroll();
+                return;
+            }
+            const offset = transcriptScrollOffsetRef.current;
+            const next = clampTranscriptScrollOffset(offset + (direction === 'older' ? 1 : -1), context.maxTranscriptScrollOffset);
+            if (next === offset) {
+                stopSelectionEdgeScroll();
+                setTerminalSelection((state) => ({ ...state, edge: 'none' }));
+                terminalSelectionRef.current = { ...current, edge: 'none' };
+                return;
+            }
+            setTranscriptScrollOffset(next);
+        }, 80);
+    };
+    useEffect(() => {
+        if (!ansiActive) {
+            stopSelectionEdgeScroll();
+            terminalSelectionRef.current = createTerminalSelectionState();
+            setTerminalSelection(terminalSelectionRef.current);
+        }
+        return () => {
+            stopSelectionEdgeScroll();
+        };
+    }, [ansiActive]);
     const permissionOptions = useMemo(() => [
         ...PERMISSION_OPTIONS,
         ...(allowDangerouslySkipPermissions
@@ -1672,6 +1737,30 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         inputHistoryIndexRef.current = nextIndex;
         updateComposerInput(history[nextIndex] ?? '');
     };
+    const withdrawLatestPending = () => {
+        if (inputRef.current.trim().length !== 0)
+            return false;
+        const pending = pendingInputsRef.current.at(-1);
+        if (!pending)
+            return false;
+        if (pending.kind === 'follow-up') {
+            followUpQueueRef.current = followUpQueueRef.current.filter((item) => item.id !== pending.id);
+            updatePendingInputs((current) => current.filter((item) => item.id !== pending.id));
+            updateComposerInput(pending.text);
+            return true;
+        }
+        const activeSessionId = sessionIdRef.current;
+        const result = activeSessionId
+            ? serviceRef.current?.withdrawSteering?.(activeSessionId, pending.id)
+            : undefined;
+        if (result?.kind === 'withdrawn') {
+            updatePendingInputs((current) => current.filter((item) => item.id !== pending.id));
+            updateComposerInput(result.item.content);
+            return true;
+        }
+        append({ kind: 'warning', text: 'Input is already delivered.' });
+        return true;
+    };
     const dismissExitConfirmation = () => {
         if (!exitConfirmation)
             return;
@@ -1725,6 +1814,33 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             case 'user-message':
                 append({ kind: 'assistant', text: event.message });
                 break;
+            case 'user-input-delivered':
+                // Steering is delivered after the preceding assistant batch has been
+                // persisted. Commit that batch to the visible transcript before the
+                // user row, then start the next provider continuation with a fresh
+                // active buffer. Otherwise the active row would appear after the
+                // steering message and be discarded when the turn finally completes.
+                if ((streamingFrameRef.current?.text.trim().length ?? 0) > 0) {
+                    append({
+                        kind: 'assistant',
+                        text: streamingFrameRef.current?.text ?? '',
+                    });
+                }
+                streamingFrameRef.current?.resetText();
+                streamingFrameRef.current?.resetThinking();
+                streamingFrameRef.current?.flush();
+                updatePendingInputs((current) => current.filter((item) => item.id !== event.id));
+                append({ kind: 'user', text: event.content });
+                break;
+            case 'user-input-rejected':
+                updatePendingInputs((current) => current.filter((item) => item.id !== event.id));
+                if (inputRef.current.trim().length === 0)
+                    updateComposerInput(event.content);
+                append({
+                    kind: 'warning',
+                    text: `Input not delivered · ${redactSensitiveText(event.content, sensitiveValues)}`,
+                });
+                break;
             case 'state':
                 if (event.state === 'awaiting-model') {
                     activeAttemptThinkingItemsRef.current = [];
@@ -3156,7 +3272,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         onTurnChange?.(restoring);
         void restoring.finally(() => onTurnChange?.(null));
     };
-    const submit = async (prompt, shellCommand, images = []) => {
+    const submitTurn = async (prompt, shellCommand, images = [], followUpId, internal = false) => {
         setTranscriptScrollOffset(0);
         const turnNumber = turnNumberRef.current + 1;
         const turnStartedAt = Date.now();
@@ -3171,6 +3287,9 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             ? AbortSignal.any([signal, turnController.signal])
             : turnController.signal;
         setBusy(true);
+        if (followUpId !== undefined) {
+            updatePendingInputs((current) => current.filter((item) => item.id !== followUpId));
+        }
         setTurnDuration(undefined);
         setCommandPaletteOpen(false);
         const submittedCommandName = /^\/([^\s]+)/u.exec(prompt)?.[1]?.toLowerCase();
@@ -3189,9 +3308,10 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         else
             turnMutatedFilesRef.current = true;
         let commands;
+        let turnSucceeded = false;
         try {
             commands = await service();
-            let activeSessionId = sessionId;
+            let activeSessionId = sessionIdRef.current;
             const startedNewSession = activeSessionId === null;
             if (activeSessionId === null) {
                 activeSessionId = randomUUID();
@@ -3260,7 +3380,9 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             streamingFrameRef.current?.flush();
             setStatus('ready');
             setTurnDuration(Date.now() - turnStartedAt);
-            if (runtimeSettingsRef.current.notifChannel !== 'notifications_disabled') {
+            if (!internal &&
+                followUpQueueRef.current.length === 0 &&
+                runtimeSettingsRef.current.notifChannel !== 'notifications_disabled') {
                 notifyTerminal({
                     channel: runtimeSettingsRef.current.notifChannel,
                     title: 'Praxis',
@@ -3270,6 +3392,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                         : { write: notificationWriter }),
                 });
             }
+            turnSucceeded = true;
         }
         catch (error) {
             if (turnController.signal.aborted && !signal?.aborted) {
@@ -3287,7 +3410,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             }
         }
         finally {
-            if (!factory.scheduledPrompts && commands) {
+            if (!internal && !factory.scheduledPrompts && commands) {
                 try {
                     await commands.close?.();
                 }
@@ -3304,6 +3427,62 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             }
             if (turnControllerRef.current === turnController)
                 turnControllerRef.current = null;
+            if (!internal) {
+                setBusy(false);
+            }
+        }
+        return turnSucceeded;
+    };
+    const submit = async (prompt, shellCommand, images = [], followUpId) => {
+        let currentPrompt = prompt;
+        let currentShellCommand = shellCommand;
+        let currentImages = images;
+        let currentFollowUpId = followUpId;
+        let completed = false;
+        try {
+            while (true) {
+                completed = await submitTurn(currentPrompt, currentShellCommand, currentImages, currentFollowUpId, true);
+                if (!completed)
+                    break;
+                const next = followUpQueueRef.current.shift();
+                if (!next)
+                    break;
+                currentPrompt = next.text;
+                currentShellCommand = undefined;
+                currentImages = [];
+                currentFollowUpId = next.id;
+            }
+            if (completed &&
+                runtimeSettingsRef.current.notifChannel !== 'notifications_disabled') {
+                notifyTerminal({
+                    channel: runtimeSettingsRef.current.notifChannel,
+                    title: 'Praxis',
+                    message: 'Turn complete',
+                    ...(notificationWriter === undefined
+                        ? {}
+                        : { write: notificationWriter }),
+                });
+            }
+        }
+        finally {
+            if (!factory.scheduledPrompts) {
+                const commands = serviceRef.current;
+                if (commands) {
+                    try {
+                        await commands.close?.();
+                    }
+                    catch (error) {
+                        append({
+                            kind: 'warning',
+                            text: redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveValues),
+                        });
+                    }
+                    finally {
+                        if (serviceRef.current === commands)
+                            serviceRef.current = null;
+                    }
+                }
+            }
             setBusy(false);
         }
     };
@@ -3360,6 +3539,53 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         return () => controller.abort();
     }, [busy, initialPromptPending, permission, selectingSession, sessionId]);
     useInput((value, key) => {
+        if (ansiActive) {
+            const mouse = parseTerminalMouseReport(value);
+            if (mouse !== null) {
+                const context = terminalSelectionContextRef.current;
+                if (context === null)
+                    return;
+                if (mouse.kind === 'wheel') {
+                    const offset = transcriptScrollOffsetRef.current;
+                    setTranscriptScrollOffset(clampTranscriptScrollOffset(offset + (mouse.direction === 'older' ? 1 : -1), context.maxTranscriptScrollOffset));
+                    return;
+                }
+                if (mouse.kind === 'press') {
+                    stopSelectionEdgeScroll();
+                    const next = startTerminalSelection(context, mouse);
+                    terminalSelectionRef.current = next;
+                    setTerminalSelection(next);
+                    return;
+                }
+                if (mouse.kind === 'drag') {
+                    const current = terminalSelectionRef.current;
+                    if (current.phase !== 'dragging')
+                        return;
+                    const previousEdge = current.edge;
+                    const next = updateTerminalSelection(current, context, mouse);
+                    terminalSelectionRef.current = next;
+                    setTerminalSelection(next);
+                    if (next.edge !== 'none') {
+                        if (next.edge !== previousEdge) {
+                            const offset = transcriptScrollOffsetRef.current;
+                            const moved = clampTranscriptScrollOffset(offset + (next.edge === 'older' ? 1 : -1), context.maxTranscriptScrollOffset);
+                            if (moved !== offset)
+                                setTranscriptScrollOffset(moved);
+                        }
+                        beginSelectionEdgeScroll(next.edge);
+                    }
+                    else
+                        stopSelectionEdgeScroll();
+                    return;
+                }
+                const released = releaseTerminalSelection(terminalSelectionRef.current, context, mouse);
+                stopSelectionEdgeScroll();
+                terminalSelectionRef.current = released.state;
+                setTerminalSelection(released.state);
+                copyTerminalSelection(released.text);
+                return;
+            }
+        }
         const lower = value.toLowerCase();
         const controlKey = (letter) => (key.ctrl && lower === letter) ||
             value === String.fromCharCode(letter.charCodeAt(0) - 96);
@@ -3547,6 +3773,32 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         if (!keybindingAction) {
             keybindingAction = resolveTuiKeybinding(keybindings, keybindingContexts, inputChord);
         }
+        const clearScreenBinding = ansiActive &&
+            (keybindingAction === 'chat:clearScreen' ||
+                (inputChord === 'ctrl+l' && keybindingAction === 'chat:clearInput'));
+        if (clearScreenBinding) {
+            stopSelectionEdgeScroll();
+            const cleared = createTerminalSelectionState();
+            terminalSelectionRef.current = cleared;
+            setTerminalSelection(cleared);
+            setClearRevision((revision) => revision + 1);
+            return;
+        }
+        if (ansiActive && terminalSelectionRef.current.phase !== 'idle') {
+            const selectionAction = resolveTuiKeybinding(keybindings, ['Scroll'], inputChord);
+            if (selectionAction === 'selection:copy') {
+                const context = terminalSelectionContextRef.current;
+                if (context === null)
+                    return;
+                const copied = releaseTerminalSelection(terminalSelectionRef.current, context);
+                copyTerminalSelection(copied.text);
+                return;
+            }
+            stopSelectionEdgeScroll();
+            const cleared = createTerminalSelectionState();
+            terminalSelectionRef.current = cleared;
+            setTerminalSelection(cleared);
+        }
         const scrollIntent = key.pageUp
             ? 'page-older'
             : key.pageDown
@@ -5761,6 +6013,94 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                 void backgrounding;
                 return;
             }
+            const pendingText = inputRef.current.trim();
+            const addPending = (item) => updatePendingInputs((current) => [...current, item]);
+            if (key.upArrow && pendingText.length === 0) {
+                withdrawLatestPending();
+                return;
+            }
+            if (key.return && key.shift) {
+                updateComposerEditor(insertComposerText(editor(), '\n'));
+                return;
+            }
+            if (isKeybinding('chat:submit') && !key.shift && !key.meta && !key.ctrl) {
+                if (!pendingText)
+                    return;
+                const controller = turnControllerRef.current;
+                if (!controller) {
+                    append({
+                        kind: 'warning',
+                        text: 'Turn is completing; input was retained.',
+                    });
+                    return;
+                }
+                const restoreSteeringText = () => {
+                    const current = inputRef.current;
+                    updateComposerInput(current.trim().length === 0
+                        ? pendingText
+                        : `${pendingText}\n${current}`);
+                };
+                // Service construction may still be in flight while the busy composer
+                // is already visible. Clear now so newly typed text becomes a distinct
+                // draft; restore both drafts if the active-turn command loses a race.
+                clearComposerInput();
+                const steer = async () => {
+                    const commands = serviceRef.current ?? (await service());
+                    if (turnControllerRef.current !== controller ||
+                        controller.signal.aborted) {
+                        restoreSteeringText();
+                        append({
+                            kind: 'warning',
+                            text: 'Active turn changed; input was retained.',
+                        });
+                        return;
+                    }
+                    const activeSessionId = sessionIdRef.current;
+                    const result = activeSessionId
+                        ? commands.steer?.(activeSessionId, pendingText)
+                        : undefined;
+                    if (result?.kind === 'accepted') {
+                        addPending({
+                            id: result.item.id,
+                            kind: 'steering',
+                            text: result.item.content,
+                        });
+                    }
+                    else {
+                        restoreSteeringText();
+                        append({
+                            kind: 'warning',
+                            text: result?.kind === 'turn-completing'
+                                ? 'Turn is completing; input was retained.'
+                                : result?.kind === 'not-steerable'
+                                    ? 'This turn cannot be steered; input was retained.'
+                                    : 'Steering is unavailable; input was retained.',
+                        });
+                    }
+                };
+                void steer().catch((error) => {
+                    restoreSteeringText();
+                    warn(error);
+                });
+                return;
+            }
+            if (key.tab || (key.return && key.meta)) {
+                if (!pendingText)
+                    return;
+                if (!turnControllerRef.current) {
+                    append({
+                        kind: 'warning',
+                        text: 'Turn is completing; follow-up input was retained.',
+                    });
+                    return;
+                }
+                const item = { id: randomUUID(), text: pendingText };
+                followUpQueueRef.current.push(item);
+                addPending({ id: item.id, kind: 'follow-up', text: item.text });
+                clearComposerInput();
+                return;
+            }
+            editComposer();
             return;
         }
         if (isKeybinding('chat:imagePaste')) {
@@ -6442,6 +6782,11 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             }
             return;
         }
+        if (isKeybinding('history:previous') &&
+            inputRef.current.length === 0 &&
+            withdrawLatestPending()) {
+            return;
+        }
         if (isKeybinding('history:previous')) {
             restorePromptHistory('previous');
             return;
@@ -6535,6 +6880,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         shellMode,
         busy,
         status: conciseStatus,
+        pendingItems: pendingInputs,
         display: runtimeDisplay,
     }), [
         screen,
@@ -6543,9 +6889,28 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         inputCursor,
         busy,
         conciseStatus,
+        pendingInputs,
         runtimeDisplay,
     ]);
-    return (_jsx(TuiThemeProvider, { settings: themeSettings, screenReader: axScreenReader, children: ansiActive ? (_jsx(TuiAnsiSurface, { frame: quietFrame, onError: () => setAnsiRendererFailed(true) })) : (_jsx(QuietInkFrame, { frame: quietFrame, screenReader: axScreenReader })) }));
+    const terminalSelectionContext = useMemo(() => createTerminalSelectionContext(quietFrame, conversationScreen?.transcript.rows.length ?? 0, transcriptScrollOffset, maxTranscriptScrollOffset), [
+        quietFrame,
+        conversationScreen?.transcript.rows.length,
+        transcriptScrollOffset,
+        maxTranscriptScrollOffset,
+    ]);
+    terminalSelectionContextRef.current = terminalSelectionContext;
+    terminalSelectionRef.current = terminalSelection;
+    useEffect(() => {
+        if (!ansiActive || terminalSelection.phase !== 'dragging')
+            return;
+        const refreshed = refreshTerminalSelection(terminalSelection, terminalSelectionContext);
+        if (refreshed !== terminalSelection) {
+            terminalSelectionRef.current = refreshed;
+            setTerminalSelection(refreshed);
+        }
+    }, [ansiActive, terminalSelection, terminalSelectionContext]);
+    const selectedQuietFrame = useMemo(() => projectTerminalSelection(quietFrame, terminalSelection, terminalSelectionContext), [quietFrame, terminalSelection, terminalSelectionContext]);
+    return (_jsx(TuiThemeProvider, { settings: themeSettings, screenReader: axScreenReader, children: ansiActive ? (_jsx(TuiAnsiSurface, { frame: selectedQuietFrame, clearRevision: clearRevision, onError: () => setAnsiRendererFailed(true) })) : (_jsx(QuietInkFrame, { frame: quietFrame, screenReader: axScreenReader })) }));
 }
 /**
  * Whether the user explicitly saved a `tui` renderer value in configuration.

package/dist/cli/tui/ansi-frame-renderer.d.ts

@@ -20,6 +20,7 @@ export declare class AnsiFullscreenRenderer {
     setStyles(styles?: Partial<Record<TuiTextRole, string>>): void;
     get mounted(): boolean;
     mount(): void;
+    clear(): void;
     draw(frame: AnsiFrame): void;
     dispose(): void;
 }

package/dist/cli/tui/ansi-frame-renderer.js

@@ -4,6 +4,18 @@ const ALTERNATE_SCREEN_ENTER = '\u001b[?1049h';
 const ALTERNATE_SCREEN_LEAVE = '\u001b[?1049l';
 const HIDE_CURSOR = '\u001b[?25l';
 const SHOW_CURSOR = '\u001b[?25h';
+const MOUSE_MODE_ENABLE = [
+    '\u001b[?1000h',
+    '\u001b[?1002h',
+    '\u001b[?1003h',
+    '\u001b[?1006h',
+];
+const MOUSE_MODE_DISABLE = [
+    '\u001b[?1006l',
+    '\u001b[?1003l',
+    '\u001b[?1002l',
+    '\u001b[?1000l',
+];
 const SYNCHRONIZED_BEGIN = '\u001b[?2026h';
 const SYNCHRONIZED_END = '\u001b[?2026l';
 const RESET = '\u001b[0m';
@@ -91,11 +103,16 @@ export class AnsiFullscreenRenderer {
         let alternateScreenEntered = false;
         let cursorHidden = false;
         let synchronizedOutputBegun = false;
+        const mouseModesEnabled = [];
         try {
             alternateScreenEntered = true;
             this.#writer.write(ALTERNATE_SCREEN_ENTER);
             cursorHidden = true;
             this.#writer.write(HIDE_CURSOR);
+            for (const [index, mode] of MOUSE_MODE_ENABLE.entries()) {
+                mouseModesEnabled[index] = true;
+                this.#writer.write(mode);
+            }
             if (this.#synchronizedOutput) {
                 synchronizedOutputBegun = true;
                 this.#writer.write(SYNCHRONIZED_BEGIN);
@@ -106,6 +123,16 @@ export class AnsiFullscreenRenderer {
             this.#mounted = false;
             this.#previousLines = [];
             this.#previousCursor = undefined;
+            for (let index = MOUSE_MODE_ENABLE.length - 1; index >= 0; index -= 1) {
+                if (!mouseModesEnabled[index])
+                    continue;
+                try {
+                    this.#writer.write(MOUSE_MODE_DISABLE[MOUSE_MODE_ENABLE.length - 1 - index]);
+                }
+                catch {
+                    // Rollback must continue if one restoration write fails.
+                }
+            }
             if (synchronizedOutputBegun) {
                 try {
                     this.#writer.write(SYNCHRONIZED_END);
@@ -133,6 +160,40 @@ export class AnsiFullscreenRenderer {
             throw error;
         }
     }
+    clear() {
+        if (!this.#mounted)
+            throw new Error('ANSI fullscreen renderer is not mounted');
+        let firstError;
+        if (this.#synchronizedOutput) {
+            try {
+                this.#writer.write(SYNCHRONIZED_BEGIN);
+            }
+            catch (error) {
+                firstError = error;
+            }
+        }
+        if (firstError === undefined) {
+            try {
+                this.#writer.write('\u001b[2J\u001b[H');
+            }
+            catch (error) {
+                firstError = error;
+            }
+        }
+        if (this.#synchronizedOutput) {
+            try {
+                this.#writer.write(SYNCHRONIZED_END);
+            }
+            catch (error) {
+                if (firstError === undefined)
+                    firstError = error;
+            }
+        }
+        if (firstError !== undefined)
+            throw firstError;
+        this.#previousLines = [];
+        this.#previousCursor = undefined;
+    }
     draw(frame) {
         if (!this.#mounted)
             throw new Error('ANSI fullscreen renderer is not mounted');
@@ -192,17 +253,31 @@ export class AnsiFullscreenRenderer {
     dispose() {
         if (!this.#mounted)
             return;
+        let firstError;
+        const attempt = (write) => {
+            try {
+                this.#writer.write(write);
+            }
+            catch (error) {
+                if (firstError === undefined)
+                    firstError = error;
+            }
+        };
         try {
+            for (const mode of MOUSE_MODE_DISABLE)
+                attempt(mode);
             if (this.#synchronizedOutput)
-                this.#writer.write(SYNCHRONIZED_END);
-            this.#writer.write(SHOW_CURSOR);
-            this.#writer.write(ALTERNATE_SCREEN_LEAVE);
+                attempt(SYNCHRONIZED_END);
+            attempt(SHOW_CURSOR);
+            attempt(ALTERNATE_SCREEN_LEAVE);
         }
         finally {
             this.#mounted = false;
             this.#previousLines = [];
             this.#previousCursor = undefined;
         }
+        if (firstError !== undefined)
+            throw firstError;
     }
 }
 //# sourceMappingURL=ansi-frame-renderer.js.map

package/dist/cli/tui/ansi-surface.d.ts

@@ -3,6 +3,7 @@ import type { QuietFrame } from './quiet-frame.js';
 export interface TuiAnsiSurfaceFrameProps {
     readonly frame: QuietFrame;
     readonly onError: (error: unknown) => void;
+    readonly clearRevision?: number;
 }
 export type TuiAnsiSurfaceProps = TuiAnsiSurfaceFrameProps;
 export declare function projectAnsiQuietFrame(frame: QuietFrame): AnsiFrame;

package/dist/cli/tui/ansi-surface.js

@@ -17,6 +17,7 @@ export function TuiAnsiSurface(props) {
     const styles = useMemo(() => resolveAnsiTextStyles(theme), [theme]);
     const rendererRef = useRef(null);
     const failedRef = useRef(false);
+    const clearRevisionRef = useRef(undefined);
     if (rendererRef.current === null) {
         rendererRef.current = new AnsiFullscreenRenderer({
             writer: { write: (chunk) => stdout.write(chunk) },
@@ -31,6 +32,7 @@ export function TuiAnsiSurface(props) {
             return;
         try {
             renderer.mount();
+            clearRevisionRef.current = props.clearRevision;
         }
         catch (error) {
             failedRef.current = true;
@@ -55,6 +57,10 @@ export function TuiAnsiSurface(props) {
         if (renderer === null)
             return;
         try {
+            if (clearRevisionRef.current !== props.clearRevision) {
+                renderer.clear();
+                clearRevisionRef.current = props.clearRevision;
+            }
             renderer.draw(projectAnsiQuietFrame(props.frame));
         }
         catch (error) {