@pickle-pee/genesis-cli 0.0.1 → 0.0.2

package/dist/mode-dispatch.js

@@ -23,6 +23,7 @@ exports.movePermissionSelection = movePermissionSelection;
 exports.permissionDecisionFromSelection = permissionDecisionFromSelection;
 exports.formatInteractiveToolTitle = formatInteractiveToolTitle;
 exports.formatInteractiveToolResult = formatInteractiveToolResult;
+exports.createDebouncedCallback = createDebouncedCallback;
 exports.computeSlashSuggestions = computeSlashSuggestions;
 exports.formatSlashSuggestionHint = formatSlashSuggestionHint;
 exports.acceptFirstSlashSuggestion = acceptFirstSlashSuggestion;
@@ -42,9 +43,11 @@ exports.formatTurnNotice = formatTurnNotice;
 exports.mergeStreamingText = mergeStreamingText;
 exports.wrapTranscriptContent = wrapTranscriptContent;
 exports.computeVisibleTranscriptLines = computeVisibleTranscriptLines;
+exports.extractPlainTextSelection = extractPlainTextSelection;
 exports.computeTranscriptDisplayRows = computeTranscriptDisplayRows;
 exports.materializeAssistantTranscriptBlock = materializeAssistantTranscriptBlock;
 exports.appendAssistantTranscriptBlock = appendAssistantTranscriptBlock;
+exports.appendTranscriptBlockWithSpacer = appendTranscriptBlockWithSpacer;
 exports.computeFooterStartRow = computeFooterStartRow;
 const node_child_process_1 = require("node:child_process");
 const promises_1 = require("node:fs/promises");
@@ -71,6 +74,8 @@ function createModeHandler(mode) {
             return new RpcModeHandler();
     }
 }
+const TURN_NOTICE_ELAPSED_THRESHOLD_MS = 2_000;
+const RESIZE_REDRAW_DEBOUNCE_MS = 120;
 // ---------------------------------------------------------------------------
 // Interactive mode
 // ---------------------------------------------------------------------------
@@ -87,10 +92,17 @@ class InteractiveModeHandler {
     _changedPaths = new Set();
     _transcriptBlocks = [];
     _assistantBuffer = "";
-    _streamingReservedRows = 0;
-    _streamingDisplayRows = 0;
-    _renderedStreamingStartRow = null;
     _turnNotice = null;
+    _turnNoticeAnimationFrame = 0;
+    _turnNoticeTimer = null;
+    _turnStartedAt = null;
+    _detailPanelExpanded = false;
+    _detailPanelScroll = 0;
+    _thinkingBuffer = "";
+    _activeTurnUsageTotals = emptyUsageSnapshot();
+    _currentMessageUsage = emptyUsageSnapshot();
+    _lastTurnUsage = null;
+    _sessionUsageTotals = emptyUsageSnapshot();
     _commandSuggestions = [];
     _toolCalls = new Map();
     _queuedInputs = [];
@@ -98,6 +110,9 @@ class InteractiveModeHandler {
     _renderedFooterUi = null;
     _renderedFooterStartRow = null;
     _welcomeLines = [];
+    _transcriptScrollOffset = 0;
+    _renderedTranscriptViewportLines = [];
+    _mouseSelection = null;
     async start(runtime) {
         const handler = this;
         if (!process.stdin.isTTY || !process.stdout.isTTY) {
@@ -128,11 +143,14 @@ class InteractiveModeHandler {
             onResume: () => {
                 this.rerenderInteractiveRegions();
             },
-            useAlternateScreen: false,
-            enableMouseTracking: false,
+            useAlternateScreen: true,
+            enableMouseTracking: true,
         });
-        const onResize = () => {
+        const debouncedResizeRedraw = createDebouncedCallback(() => {
             this.rerenderInteractiveRegions();
+        }, RESIZE_REDRAW_DEBOUNCE_MS);
+        const onResize = () => {
+            debouncedResizeRedraw.schedule();
         };
         process.stdout.on("resize", onResize);
         const resolveAgentDir = () => {
@@ -150,16 +168,24 @@ class InteractiveModeHandler {
             this._changedPaths.clear();
             this._transcriptBlocks.length = 0;
             this._assistantBuffer = "";
-            this._streamingReservedRows = 0;
-            this._streamingDisplayRows = 0;
-            this._renderedStreamingStartRow = null;
+            this.stopTurnNoticeAnimation();
             this._turnNotice = null;
+            this._turnNoticeAnimationFrame = 0;
+            this._turnStartedAt = null;
+            this._detailPanelExpanded = false;
+            this._detailPanelScroll = 0;
+            this._thinkingBuffer = "";
+            this._activeTurnUsageTotals = emptyUsageSnapshot();
+            this._currentMessageUsage = emptyUsageSnapshot();
+            this._lastTurnUsage = null;
+            this._sessionUsageTotals = emptyUsageSnapshot();
             this._commandSuggestions = [];
             this._toolCalls.clear();
             this._queuedInputs.length = 0;
             this._pendingPermissionSelection = 0;
             this._renderedFooterUi = null;
             this._renderedFooterStartRow = null;
+            this._transcriptScrollOffset = 0;
             sessionTitle = undefined;
             interactionState = (0, ui_1.initialInteractionState)();
             sessionRef.current.events.on("session_closed", (event) => {
@@ -772,6 +798,9 @@ class InteractiveModeHandler {
                     this.rerenderInteractiveRegions();
                 }
             },
+            onMouse: (event) => {
+                this.handleMouseEvent(event);
+            },
         });
         ttySession.enter();
         this.renderWelcome(sessionRef.current);
@@ -822,6 +851,8 @@ class InteractiveModeHandler {
                 // Regular prompt
                 if (this._activeTurn !== null) {
                     this._queuedInputs.push(trimmed);
+                    this.preserveThinkingNoticeForQueuedBacklog();
+                    this.renderFooterRegion();
                     line = await inputLoop.nextLine();
                     continue;
                 }
@@ -831,6 +862,7 @@ class InteractiveModeHandler {
         }
         finally {
             process.stdout.off("resize", onResize);
+            debouncedResizeRedraw.cancel();
             inputLoop.close();
             process.stdout.write(ansiResetScrollRegion());
             ttySession.restore();
@@ -850,7 +882,61 @@ class InteractiveModeHandler {
     renderPromptLine() {
         this.renderFooterRegion();
     }
+    handleMouseEvent(event) {
+        if (!this.isTranscriptMouseRow(event.row)) {
+            if (event.kind === "leftdown") {
+                this.clearMouseSelection();
+            }
+            return;
+        }
+        if (event.kind === "leftdown") {
+            this._mouseSelection = {
+                anchorRow: event.row,
+                anchorColumn: event.column,
+                focusRow: event.row,
+                focusColumn: event.column,
+            };
+            this.renderTranscriptViewport();
+            return;
+        }
+        if (this._mouseSelection === null) {
+            return;
+        }
+        this._mouseSelection = {
+            ...this._mouseSelection,
+            focusRow: event.row,
+            focusColumn: event.column,
+        };
+        this.renderTranscriptViewport();
+        if (event.kind === "leftup") {
+            const selectedText = this.currentTranscriptSelectionText();
+            if (selectedText.length > 0) {
+                copyTextToClipboard(selectedText);
+            }
+        }
+    }
     handleSpecialKey(key) {
+        if (key === "ctrlo") {
+            this.toggleDetailPanel();
+            return;
+        }
+        if (key === "esc" && this._detailPanelExpanded) {
+            this._detailPanelExpanded = false;
+            this.renderFooterRegion();
+            return;
+        }
+        if (this._detailPanelExpanded) {
+            const detailScrollDelta = detailPanelScrollDeltaForKey(key, this.currentDetailPanelViewport().viewportSize);
+            if (detailScrollDelta !== 0) {
+                this.scrollDetailPanel(detailScrollDelta);
+                return;
+            }
+        }
+        const transcriptScrollDelta = transcriptScrollDeltaForKey(key, this.currentTranscriptViewportRows());
+        if (transcriptScrollDelta !== 0) {
+            this.scrollTranscript(transcriptScrollDelta);
+            return;
+        }
         if (this._pendingPermissionCallId !== null) {
             if (key === "up" || key === "shifttab") {
                 this._pendingPermissionSelection = movePermissionSelection(this._pendingPermissionSelection, -1);
@@ -894,11 +980,17 @@ class InteractiveModeHandler {
             }
             return;
         }
+        if (event.category === "usage" && event.type === "usage_updated") {
+            this.updateTurnUsage(event.usage, event.isFinal);
+            this.renderPromptLine();
+            return;
+        }
         if (!shouldRenderInteractiveTranscriptEvent(event)) {
             this.renderPromptLine();
             return;
         }
         if (event.category === "text" && event.type === "thinking_delta") {
+            this._thinkingBuffer += event.content;
             if (this._turnNotice === null) {
                 this.startTurnFeedback();
             }
@@ -907,10 +999,14 @@ class InteractiveModeHandler {
         }
         if (event.category === "text" && event.type === "text_delta") {
             if (this._turnNotice !== "responding") {
+                this._turnNoticeAnimationFrame = 0;
                 this._turnNotice = "responding";
+                this.startTurnNoticeAnimation();
             }
+            const previousRows = this.currentTranscriptDisplayRows();
             this._assistantBuffer = mergeStreamingText(this._assistantBuffer, event.content);
-            this.renderStreamingAssistantBlock();
+            this.adjustTranscriptScrollForGrowth(previousRows, this.currentTranscriptDisplayRows());
+            this.fullRedrawInteractiveScreen();
             return;
         }
         this.flushAssistantBuffer(false);
@@ -931,12 +1027,11 @@ class InteractiveModeHandler {
         }
         const assistantBlock = materializeAssistantTranscriptBlock(this._assistantBuffer);
         if (assistantBlock !== null) {
+            const previousRows = this.currentTranscriptDisplayRows();
             this.rememberAssistantTranscriptBlock(assistantBlock);
+            this.adjustTranscriptScrollForGrowth(previousRows, this.currentTranscriptDisplayRows());
         }
         this._assistantBuffer = "";
-        this._streamingReservedRows = 0;
-        this._streamingDisplayRows = 0;
-        this._renderedStreamingStartRow = null;
         if (redrawPrompt) {
             this.renderPromptLine();
         }
@@ -946,39 +1041,35 @@ class InteractiveModeHandler {
             return;
         }
         this._turnNotice = "thinking";
+        this._turnNoticeAnimationFrame = 0;
+        this.startTurnNoticeAnimation();
         this.renderPromptLine();
     }
-    renderStreamingAssistantBlock() {
-        const rendered = formatTranscriptAssistantLine(this._assistantBuffer);
-        const lines = wrapTranscriptContent(rendered, process.stdout.columns ?? 80);
-        const renderedWidth = this.terminalWidth();
-        const rows = countRenderedTerminalRows(lines, renderedWidth);
-        const previousStartRow = this._renderedStreamingStartRow;
-        const previousRows = this._streamingReservedRows;
-        this._streamingDisplayRows = rows;
-        this.renderFooterRegion();
-        const footerStartRow = this._renderedFooterStartRow ??
-            computeFooterStartRow(this._welcomeLines.length, this.terminalHeight(), this.currentFooterHeight(), this.currentTranscriptDisplayRows());
-        if (isFooterBottomAnchored(footerStartRow, this.terminalHeight(), this.currentFooterHeight())) {
-            this.reserveStreamingRows(rows);
+    startTurnNoticeAnimation() {
+        if (this._turnNoticeTimer !== null) {
+            return;
         }
-        else {
-            this._streamingReservedRows = rows;
-        }
-        const startRow = footerStartRow - rows;
-        const transcriptBottomRow = footerStartRow - 1;
-        const clearStartRow = previousStartRow === null ? startRow : Math.min(startRow, previousStartRow);
-        const clearEndRow = previousStartRow === null
-            ? transcriptBottomRow
-            : Math.max(transcriptBottomRow, previousStartRow + previousRows - 1);
-        this.clearTranscriptRows(clearStartRow, clearEndRow);
-        this.writeLinesAtRow(startRow, lines, renderedWidth);
-        this._renderedStreamingStartRow = startRow;
-        this.renderFooterRegion();
+        this._turnNoticeTimer = setInterval(() => {
+            if (this._turnNotice === null) {
+                return;
+            }
+            this._turnNoticeAnimationFrame = (this._turnNoticeAnimationFrame + 1) % 3;
+            this.renderFooterRegion();
+        }, 400);
+        this._turnNoticeTimer.unref?.();
+    }
+    stopTurnNoticeAnimation() {
+        if (this._turnNoticeTimer === null) {
+            return;
+        }
+        clearInterval(this._turnNoticeTimer);
+        this._turnNoticeTimer = null;
     }
     writeTranscriptText(text, newline, redrawPrompt = true) {
         this.flushAssistantBuffer(false);
+        const previousRows = this.currentTranscriptDisplayRows();
         this.rememberTranscriptBlock(text, newline);
+        this.adjustTranscriptScrollForGrowth(previousRows, this.currentTranscriptDisplayRows());
         const logicalLines = text.split("\n");
         const outputLines = newline ? logicalLines : logicalLines.slice(0, -1).concat(logicalLines.at(-1) ?? "");
         if (outputLines.length > 0) {
@@ -1012,35 +1103,131 @@ class InteractiveModeHandler {
         this.renderPromptLine();
     }
     startPromptTurn(session, prompt, sink) {
+        this.startUserTurn(session, prompt, sink, "prompt");
+    }
+    startQueuedContinueTurn(session, input, sink) {
+        this.startUserTurn(session, input, sink, "continue");
+    }
+    startUserTurn(session, input, sink, mode) {
         this.flushAssistantBuffer(false);
-        this.writeTranscriptText(formatTranscriptUserLine(prompt), true, false);
+        this.writeTranscriptText(formatTranscriptUserLine(input), true, false);
+        this._turnStartedAt = Date.now();
+        this._detailPanelExpanded = false;
+        this._detailPanelScroll = 0;
+        this._thinkingBuffer = "";
+        this._activeTurnUsageTotals = emptyUsageSnapshot();
+        this._currentMessageUsage = emptyUsageSnapshot();
         this.startTurnFeedback();
-        this.rememberHistory(prompt);
-        this._activeTurn = session
-            .prompt(prompt)
+        this.rememberHistory(input);
+        const sendTurn = mode === "continue" ? (value) => session.continue(value) : (value) => session.prompt(value);
+        this._activeTurn = sendTurn(input)
             .catch((err) => {
             sink.writeError(`Error: ${err}`);
         })
             .finally(() => {
+            this.stopTurnNoticeAnimation();
+            const completedTurnUsage = this.currentTurnUsage();
             this._activeTurn = null;
             this.flushAssistantBuffer(false);
             this._turnNotice = null;
-            const nextQueued = this._queuedInputs.shift();
-            if (nextQueued) {
-                this.startPromptTurn(session, nextQueued, sink);
+            this._turnNoticeAnimationFrame = 0;
+            this._turnStartedAt = null;
+            this._detailPanelExpanded = false;
+            this._detailPanelScroll = 0;
+            this._thinkingBuffer = "";
+            if (hasUsageSnapshot(completedTurnUsage)) {
+                this._lastTurnUsage = completedTurnUsage;
+                this._sessionUsageTotals = addUsageSnapshots(this._sessionUsageTotals, completedTurnUsage);
+            }
+            this._activeTurnUsageTotals = emptyUsageSnapshot();
+            this._currentMessageUsage = emptyUsageSnapshot();
+            const queuedInputBatch = this.drainQueuedInputs();
+            if (queuedInputBatch !== null) {
+                this.startQueuedContinueTurn(session, queuedInputBatch, sink);
                 return;
             }
             this.fullRedrawInteractiveScreen();
         });
     }
+    drainQueuedInputs() {
+        if (this._queuedInputs.length === 0) {
+            return null;
+        }
+        const queued = [...this._queuedInputs];
+        this._queuedInputs.length = 0;
+        return queued.join("\n\n");
+    }
+    preserveThinkingNoticeForQueuedBacklog() {
+        if (this._activeTurn === null) {
+            return;
+        }
+        if (this._turnNotice === "responding") {
+            this._turnNotice = "thinking";
+            this.startTurnNoticeAnimation();
+            return;
+        }
+        if (this._turnNotice === null) {
+            this.startTurnFeedback();
+        }
+    }
+    toggleDetailPanel() {
+        if (this.currentDetailPanelContentLines().length === 0) {
+            return;
+        }
+        this._detailPanelExpanded = !this._detailPanelExpanded;
+        if (this._detailPanelExpanded) {
+            this._detailPanelScroll = 0;
+        }
+        this.renderFooterRegion();
+    }
+    scrollDetailPanel(delta) {
+        const viewport = this.currentDetailPanelViewport();
+        if (viewport.totalLines <= viewport.viewportSize) {
+            return;
+        }
+        const maxScroll = Math.max(0, viewport.totalLines - viewport.viewportSize);
+        const next = Math.max(0, Math.min(maxScroll, this._detailPanelScroll + delta));
+        if (next === this._detailPanelScroll) {
+            return;
+        }
+        this._detailPanelScroll = next;
+        this.renderFooterRegion();
+    }
+    scrollTranscript(delta) {
+        const maxScroll = this.currentTranscriptMaxScroll();
+        if (delta === 0 || maxScroll <= 0) {
+            return;
+        }
+        const next = Math.max(0, Math.min(maxScroll, this._transcriptScrollOffset + delta));
+        if (next === this._transcriptScrollOffset) {
+            return;
+        }
+        this.clearMouseSelection(false);
+        this._transcriptScrollOffset = next;
+        this.renderTranscriptViewport();
+        this.renderFooterRegion();
+    }
     buildFooterUi() {
+        const activeToolLabel = summarizeActiveToolNotice(this._toolCalls);
+        const detailPanel = this.currentDetailPanelViewport();
         return formatInteractiveFooter({
             terminalWidth: process.stdout.columns ?? 80,
             prompt: this._prompt,
             buffer: this._inputState.buffer,
             cursor: this._inputState.cursor,
             suggestions: this._commandSuggestions,
-            turnNotice: this._turnNotice,
+            turnNotice: activeToolLabel !== null ? "tool" : this._turnNotice,
+            turnNoticeAnimationFrame: this._turnNoticeAnimationFrame,
+            elapsedMs: this.currentTurnElapsedMs(),
+            currentTurnUsage: this.currentTurnUsage(),
+            lastTurnUsage: this._lastTurnUsage,
+            sessionUsage: this._sessionUsageTotals,
+            activeToolLabel,
+            showPendingOutputIndicator: this.shouldShowPendingOutputIndicator(activeToolLabel),
+            detailPanelExpanded: this._detailPanelExpanded,
+            detailPanelLines: detailPanel.lines,
+            detailPanelSummary: detailPanel.summary,
+            queuedInputs: this._queuedInputs,
             permission: this._pendingPermissionCallId !== null && this._pendingPermissionDetails !== null
                 ? {
                     details: this._pendingPermissionDetails,
@@ -1049,15 +1236,132 @@ class InteractiveModeHandler {
                 : null,
         });
     }
+    currentDetailPanelContentLines() {
+        if (this._thinkingBuffer.trim().length === 0) {
+            return [];
+        }
+        return wrapTranscriptContent(this._thinkingBuffer.trim(), this.terminalWidth());
+    }
+    shouldShowPendingOutputIndicator(activeToolLabel) {
+        if (this._assistantBuffer.length > 0) {
+            return true;
+        }
+        if (activeToolLabel === null) {
+            return false;
+        }
+        const lastNonEmptyIndex = findLastNonEmptyBlockIndex(this._transcriptBlocks);
+        if (lastNonEmptyIndex === -1) {
+            return false;
+        }
+        const lastBlock = this._transcriptBlocks[lastNonEmptyIndex] ?? "";
+        return !isTranscriptUserBlock(lastBlock) && !lastBlock.startsWith("⏺ ") && !lastBlock.startsWith("  ⎿ ");
+    }
+    currentDetailPanelViewport() {
+        const lines = this.currentDetailPanelContentLines();
+        if (lines.length === 0) {
+            return { lines: [], summary: null, viewportSize: 0, totalLines: 0 };
+        }
+        if (!this._detailPanelExpanded) {
+            return {
+                lines: [],
+                summary: "ctrl+o to expand",
+                viewportSize: 0,
+                totalLines: lines.length,
+            };
+        }
+        const viewportSize = Math.max(3, this.terminalHeight() - 8);
+        const maxScroll = Math.max(0, lines.length - viewportSize);
+        const start = Math.max(0, Math.min(this._detailPanelScroll, maxScroll));
+        const end = Math.min(lines.length, start + viewportSize);
+        const summary = lines.length <= viewportSize
+            ? "esc to collapse · ↑↓"
+            : `esc to collapse · ↑↓ · ${start + 1}-${end}/${lines.length}`;
+        return {
+            lines: lines.slice(start, end),
+            summary,
+            viewportSize,
+            totalLines: lines.length,
+        };
+    }
     rerenderInteractiveRegions() {
+        this.clearMouseSelection(false);
+        this.clampTranscriptScrollOffset();
         this.fullRedrawInteractiveScreen();
     }
+    adjustTranscriptScrollForGrowth(previousRows, nextRows) {
+        this.clearMouseSelection(false);
+        if (this._transcriptScrollOffset === 0) {
+            return;
+        }
+        const delta = Math.max(0, nextRows - previousRows);
+        if (delta === 0) {
+            this.clampTranscriptScrollOffset();
+            return;
+        }
+        this._transcriptScrollOffset += delta;
+        this.clampTranscriptScrollOffset();
+    }
+    updateTurnUsage(usage, isFinal) {
+        const normalized = normalizeUsageSnapshot(usage);
+        if (isFinal) {
+            this._activeTurnUsageTotals = addUsageSnapshots(this._activeTurnUsageTotals, normalized);
+            this._currentMessageUsage = emptyUsageSnapshot();
+            return;
+        }
+        this._currentMessageUsage = normalized;
+    }
+    currentTurnUsage() {
+        const usage = addUsageSnapshots(this._activeTurnUsageTotals, this._currentMessageUsage);
+        return hasUsageSnapshot(usage) ? usage : null;
+    }
+    currentTurnElapsedMs() {
+        if (this._turnNotice === null || this._turnStartedAt === null) {
+            return null;
+        }
+        return Math.max(0, Date.now() - this._turnStartedAt);
+    }
     terminalWidth() {
         return Math.max(1, process.stdout.columns ?? 80);
     }
     terminalHeight() {
         return Math.max(6, process.stdout.rows ?? 24);
     }
+    currentTranscriptViewportRows() {
+        const footerUi = this.buildFooterUi();
+        const transcriptTopRow = 1;
+        const transcriptBottomRow = computeFooterStartRow(0, this.terminalHeight(), footerUi.lines.length, this.currentTranscriptDisplayRows()) - 1;
+        return Math.max(0, transcriptBottomRow - transcriptTopRow + 1);
+    }
+    currentTranscriptMaxScroll() {
+        return Math.max(0, this.currentTranscriptDisplayRows() - this.currentTranscriptViewportRows());
+    }
+    clampTranscriptScrollOffset() {
+        this._transcriptScrollOffset = Math.max(0, Math.min(this._transcriptScrollOffset, this.currentTranscriptMaxScroll()));
+    }
+    isTranscriptMouseRow(row) {
+        const footerStartRow = this._renderedFooterStartRow ?? computeFooterStartRow(0, this.terminalHeight(), this.currentFooterHeight(), this.currentTranscriptDisplayRows());
+        return row >= 1 && row < footerStartRow;
+    }
+    clearMouseSelection(redraw = true) {
+        if (this._mouseSelection === null) {
+            return;
+        }
+        this._mouseSelection = null;
+        if (redraw) {
+            this.renderTranscriptViewport();
+        }
+    }
+    currentTranscriptSelectionText() {
+        if (this._mouseSelection === null) {
+            return "";
+        }
+        return extractPlainTextSelection(this._renderedTranscriptViewportLines, {
+            startRow: this._mouseSelection.anchorRow - 1,
+            startColumn: this._mouseSelection.anchorColumn,
+            endRow: this._mouseSelection.focusRow - 1,
+            endColumn: this._mouseSelection.focusColumn,
+        });
+    }
     transcriptBottomRow(footerHeight = this.currentFooterHeight()) {
         return Math.max(1, this.terminalHeight() - footerHeight);
     }
@@ -1067,9 +1371,10 @@ class InteractiveModeHandler {
     renderFooterRegion() {
         const ui = this.buildFooterUi();
         const footerHeight = ui.lines.length;
-        const startRow = computeFooterStartRow(this._welcomeLines.length, this.terminalHeight(), footerHeight, this.currentTranscriptDisplayRows());
+        const startRow = computeFooterStartRow(0, this.terminalHeight(), footerHeight, this.currentTranscriptDisplayRows());
         const oldStartRow = this._renderedFooterStartRow;
         const oldHeight = this._renderedFooterUi?.lines.length ?? 0;
+        const footerMoved = oldStartRow !== null && oldStartRow !== startRow;
         if (oldStartRow !== null && oldStartRow !== startRow) {
             for (let index = 0; index < oldHeight; index += 1) {
                 this.writeAbsoluteTerminalLine(oldStartRow + index, "");
@@ -1090,6 +1395,9 @@ class InteractiveModeHandler {
         process.stdout.write((0, ui_1.ansiShowCursor)());
         this._renderedFooterUi = { ...ui, renderedWidth: this.terminalWidth() };
         this._renderedFooterStartRow = startRow;
+        if (footerMoved) {
+            this.renderTranscriptViewport();
+        }
     }
     applyTranscriptViewport(footerHeight) {
         process.stdout.write(ansiSetScrollRegion(1, this.transcriptBottomRow(footerHeight)));
@@ -1100,27 +1408,6 @@ class InteractiveModeHandler {
         }
         this.fullRedrawInteractiveScreen();
     }
-    reserveStreamingRows(rows) {
-        if (rows <= this._streamingReservedRows) {
-            return;
-        }
-        this.applyTranscriptViewport(this.currentFooterHeight());
-        for (let index = this._streamingReservedRows; index < rows; index += 1) {
-            process.stdout.write(ansiCursorTo(this.transcriptBottomRow(), 1));
-            process.stdout.write("\n");
-        }
-        this._streamingReservedRows = rows;
-    }
-    clearTranscriptRows(startRow, endRow) {
-        for (let row = startRow; row <= endRow; row += 1) {
-            this.writeAbsoluteTerminalLine(row, "");
-        }
-    }
-    writeLinesAtRow(startRow, lines, width) {
-        for (let index = 0; index < lines.length; index += 1) {
-            this.writeAbsoluteTerminalLine(startRow + index, fitTerminalLine(lines[index] ?? "", width));
-        }
-    }
     writeAbsoluteTerminalLine(row, line) {
         process.stdout.write(ansiDisableAutoWrap());
         process.stdout.write(ansiCursorTo(row, 1));
@@ -1128,12 +1415,19 @@ class InteractiveModeHandler {
         process.stdout.write(line);
         process.stdout.write(ansiEnableAutoWrap());
     }
+    clearVisibleScreenRows() {
+        for (let row = 1; row <= this.terminalHeight(); row += 1) {
+            this.writeAbsoluteTerminalLine(row, "");
+        }
+    }
     rememberTranscriptBlock(text, newline) {
         const block = newline ? text : text.replace(/\n$/, "");
         if (block.length === 0) {
             return;
         }
-        this._transcriptBlocks.push(block);
+        const nextBlocks = appendTranscriptBlockWithSpacer(this._transcriptBlocks, block);
+        this._transcriptBlocks.length = 0;
+        this._transcriptBlocks.push(...nextBlocks);
     }
     rememberAssistantTranscriptBlock(block) {
         const nextBlocks = appendAssistantTranscriptBlock(this._transcriptBlocks, block);
@@ -1141,42 +1435,94 @@ class InteractiveModeHandler {
         this._transcriptBlocks.push(...nextBlocks);
     }
     fullRedrawInteractiveScreen() {
-        if (this._welcomeLines.length === 0) {
-            return;
-        }
+        this.clampTranscriptScrollOffset();
         process.stdout.write(ansiResetScrollRegion());
         process.stdout.write((0, ui_1.ansiCursorHome)());
-        process.stdout.write("\x1b[2J");
-        for (let index = 0; index < this._welcomeLines.length; index += 1) {
-            this.writeAbsoluteTerminalLine(index + 1, fitTerminalLine(this._welcomeLines[index] ?? "", this.terminalWidth()));
-        }
+        this.clearVisibleScreenRows();
         this._renderedFooterUi = null;
         this._renderedFooterStartRow = null;
-        this._streamingReservedRows = 0;
-        this._renderedStreamingStartRow = null;
-        this._streamingDisplayRows =
-            this._assistantBuffer.length > 0
-                ? countRenderedTerminalRows(wrapTranscriptContent(formatTranscriptAssistantLine(this._assistantBuffer), this.terminalWidth()), this.terminalWidth())
-                : 0;
         this.renderTranscriptViewport();
         this.renderFooterRegion();
-        if (this._assistantBuffer.length > 0) {
-            this.renderStreamingAssistantBlock();
-        }
     }
     renderTranscriptViewport() {
         const footerUi = this.buildFooterUi();
-        const transcriptTopRow = this._welcomeLines.length + 1;
-        const transcriptBottomRow = computeFooterStartRow(this._welcomeLines.length, this.terminalHeight(), footerUi.lines.length, this.currentTranscriptDisplayRows()) - 1;
+        const transcriptTopRow = 1;
+        const transcriptBottomRow = computeFooterStartRow(0, this.terminalHeight(), footerUi.lines.length, this.currentTranscriptDisplayRows()) - 1;
         const availableRows = Math.max(0, transcriptBottomRow - transcriptTopRow + 1);
-        const visibleLines = computeVisibleTranscriptLines(this._transcriptBlocks, this.terminalWidth(), availableRows);
+        const visibleLines = computeVisibleTranscriptLines(this.currentRenderedTranscriptBlocks(), this.terminalWidth(), availableRows, this._transcriptScrollOffset);
+        this._renderedTranscriptViewportLines = visibleLines.map((line) => stripAnsiWelcome(line));
         for (let row = transcriptTopRow; row <= transcriptBottomRow; row += 1) {
             const index = row - transcriptTopRow;
-            this.writeAbsoluteTerminalLine(row, fitTerminalLine(visibleLines[index] ?? "", this.terminalWidth()));
+            const visibleLine = visibleLines[index] ?? "";
+            const plainLine = this._renderedTranscriptViewportLines[index] ?? "";
+            const selectionColumns = this.selectionColumnsForRow(row);
+            const renderedLine = selectionColumns === null
+                ? fitTerminalLine(visibleLine, this.terminalWidth())
+                : renderSelectedPlainTranscriptLine(plainLine, selectionColumns.startColumn, selectionColumns.endColumn, this.terminalWidth());
+            this.writeAbsoluteTerminalLine(row, renderedLine);
+        }
+    }
+    selectionColumnsForRow(row) {
+        if (this._mouseSelection === null) {
+            return null;
+        }
+        const start = compareTerminalSelectionPoints(this._mouseSelection.anchorRow, this._mouseSelection.anchorColumn, this._mouseSelection.focusRow, this._mouseSelection.focusColumn) <= 0
+            ? {
+                row: this._mouseSelection.anchorRow,
+                column: this._mouseSelection.anchorColumn,
+            }
+            : {
+                row: this._mouseSelection.focusRow,
+                column: this._mouseSelection.focusColumn,
+            };
+        const end = start.row === this._mouseSelection.anchorRow && start.column === this._mouseSelection.anchorColumn
+            ? {
+                row: this._mouseSelection.focusRow,
+                column: this._mouseSelection.focusColumn,
+            }
+            : {
+                row: this._mouseSelection.anchorRow,
+                column: this._mouseSelection.anchorColumn,
+            };
+        if (row < start.row || row > end.row) {
+            return null;
+        }
+        if (start.row === end.row) {
+            return {
+                startColumn: Math.min(start.column, end.column),
+                endColumn: Math.max(start.column, end.column),
+            };
         }
+        if (row === start.row) {
+            return {
+                startColumn: start.column,
+                endColumn: this.terminalWidth() + 1,
+            };
+        }
+        if (row === end.row) {
+            return {
+                startColumn: 1,
+                endColumn: end.column,
+            };
+        }
+        return {
+            startColumn: 1,
+            endColumn: this.terminalWidth() + 1,
+        };
     }
     currentTranscriptDisplayRows() {
-        return computeTranscriptDisplayRows(this._transcriptBlocks, this.terminalWidth()) + this._streamingDisplayRows;
+        return computeTranscriptDisplayRows(this.currentRenderedTranscriptBlocks(), this.terminalWidth());
+    }
+    currentRenderedTranscriptBlocks() {
+        const welcomeBlocks = this._welcomeLines;
+        if (this._assistantBuffer.length === 0) {
+            return [...welcomeBlocks, ...this._transcriptBlocks];
+        }
+        const assistantBlock = materializeAssistantTranscriptBlock(this._assistantBuffer);
+        if (assistantBlock === null) {
+            return [...welcomeBlocks, ...this._transcriptBlocks];
+        }
+        return appendAssistantTranscriptBlock([...welcomeBlocks, ...this._transcriptBlocks], assistantBlock);
     }
 }
 // ---------------------------------------------------------------------------
@@ -1289,9 +1635,9 @@ function applyWelcomeBorderColor(text) {
 }
 function buildWelcomeHintLine(width) {
     if (width < 64) {
-        return "Start: Enter  Help: /help  Scroll: wheel/PageUp/PageDown";
+        return "Start: Enter  Help: /help  Exit: /exit";
     }
-    return "Start: type a prompt and press Enter  Help: /help  Scroll: wheel/PageUp/PageDown";
+    return "Start: type a prompt and press Enter  Help: /help  Exit: /exit";
 }
 exports.WELCOME_BIBLE_GREETINGS = [
     "Let there be light.",
@@ -1330,6 +1676,7 @@ function buildWelcomeLines(input) {
         center(`${CYAN}${input.model}${RESET} ${DIM}via${RESET} ${input.provider}`),
         formatWelcomeBottomBorder(width),
         buildWelcomeHintLine(width),
+        "",
     ];
 }
 function formatWelcomeTopBorder(width, version) {
@@ -1394,7 +1741,31 @@ function formatInteractiveFooter(state) {
     const separator = formatInteractiveInputSeparator(computeInteractiveFooterSeparatorWidth(state.terminalWidth));
     const lines = [];
     if (state.turnNotice !== null) {
-        lines.push(formatTurnNotice(state.turnNotice));
+        lines.push(formatTurnNotice(state.turnNotice, {
+            animationFrame: state.turnNoticeAnimationFrame ?? 0,
+            elapsedMs: state.elapsedMs ?? null,
+            usage: state.currentTurnUsage ?? null,
+            showPendingOutputIndicator: state.showPendingOutputIndicator ?? false,
+            queuedCount: state.queuedInputs?.length ?? 0,
+            toolLabel: state.activeToolLabel ?? null,
+        }));
+    }
+    else {
+        if (hasUsageSnapshot(state.lastTurnUsage ?? null)) {
+            lines.push(formatUsageSummaryLine("Last turn", state.lastTurnUsage));
+        }
+        if (hasUsageSnapshot(state.sessionUsage ?? null)) {
+            lines.push(formatUsageSummaryLine("Session", state.sessionUsage));
+        }
+    }
+    if ((state.detailPanelSummary?.length ?? 0) > 0) {
+        lines.push(`${theme_js_1.INTERACTIVE_THEME.muted}↳ ${state.detailPanelSummary}${theme_js_1.INTERACTIVE_THEME.reset}`);
+        if (state.detailPanelExpanded) {
+            lines.push(...(state.detailPanelLines ?? []));
+        }
+    }
+    if ((state.queuedInputs?.length ?? 0) > 0) {
+        lines.push(...formatQueuedPromptPreviewLines(state.queuedInputs ?? [], state.terminalWidth));
     }
     lines.push(separator);
     if (state.permission !== null) {
@@ -1523,6 +1894,78 @@ function summarizeToolParameters(toolName, parameters) {
     }
     return "";
 }
+function summarizeActiveToolNotice(toolCalls) {
+    if (toolCalls.size === 0) {
+        return null;
+    }
+    const [first] = toolCalls.values();
+    if (!first) {
+        return "Running tools";
+    }
+    const title = formatInteractiveToolTitle(first.toolName, first.parameters).replace(/^⏺\s+/, "");
+    if (toolCalls.size === 1) {
+        return `Running ${title}`;
+    }
+    return `Running ${toolCalls.size} tools`;
+}
+function detailPanelScrollDeltaForKey(key, viewportSize) {
+    switch (key) {
+        case "up":
+        case "wheelup":
+            return -1;
+        case "down":
+        case "wheeldown":
+            return 1;
+        case "pageup":
+            return -Math.max(1, viewportSize - 1);
+        case "pagedown":
+            return Math.max(1, viewportSize - 1);
+        default:
+            return 0;
+    }
+}
+function transcriptScrollDeltaForKey(key, viewportSize) {
+    switch (key) {
+        case "pageup":
+            return Math.max(1, viewportSize - 1);
+        case "pagedown":
+            return -Math.max(1, viewportSize - 1);
+        case "wheelup":
+            return 3;
+        case "wheeldown":
+            return -3;
+        default:
+            return 0;
+    }
+}
+function compareTerminalSelectionPoints(leftRow, leftColumn, rightRow, rightColumn) {
+    if (leftRow !== rightRow) {
+        return leftRow - rightRow;
+    }
+    return leftColumn - rightColumn;
+}
+function createDebouncedCallback(callback, delayMs) {
+    let timer = null;
+    return {
+        schedule() {
+            if (timer !== null) {
+                clearTimeout(timer);
+            }
+            timer = setTimeout(() => {
+                timer = null;
+                callback();
+            }, delayMs);
+            timer.unref?.();
+        },
+        cancel() {
+            if (timer === null) {
+                return;
+            }
+            clearTimeout(timer);
+            timer = null;
+        },
+    };
+}
 function normalizeToolResultLines(toolName, result, startedParameters) {
     if ((!result || result.trim().length === 0) && startedParameters) {
         if (toolName === "write" || toolName === "edit") {
@@ -1718,11 +2161,106 @@ function truncatePlainTerminalText(text, width) {
     }
     return output;
 }
-function formatTurnNotice(kind) {
+function formatQueuedPromptPreviewLines(queuedInputs, terminalWidth) {
+    const DIM = "\x1b[2m";
+    const YELLOW = "\x1b[33m";
+    const RESET = "\x1b[0m";
+    const maxVisible = 2;
+    const previewWidth = Math.max(12, terminalWidth - 18);
+    const lines = queuedInputs.slice(0, maxVisible).map((input, index) => {
+        const label = queuedInputs.length > 1 ? `↳ Queued ${index + 1}: ` : "↳ Queued: ";
+        return `${DIM}${YELLOW}${label}${RESET}${truncatePlainTerminalText(input, previewWidth)}`;
+    });
+    if (queuedInputs.length > maxVisible) {
+        lines.push(`${DIM}${YELLOW}↳ +${queuedInputs.length - maxVisible} more queued${RESET}`);
+    }
+    return lines;
+}
+function formatTurnNotice(kind, options = {}) {
+    const DIM = "\x1b[2m";
+    const CYAN = "\x1b[36m";
+    const RESET = "\x1b[0m";
+    const suffix = ".".repeat(((options.animationFrame ?? 0) % 3) + 1);
+    const label = kind === "thinking"
+        ? `Thinking${suffix}`
+        : kind === "responding"
+            ? `Responding${suffix}`
+            : `${options.toolLabel ?? "Running tools"}${suffix}`;
+    const meta = [];
+    if ((options.elapsedMs ?? 0) >= TURN_NOTICE_ELAPSED_THRESHOLD_MS) {
+        meta.push(formatElapsedLabel(options.elapsedMs ?? 0));
+    }
+    const usageLabel = formatUsageCompact(options.usage ?? null, options.showPendingOutputIndicator ?? false);
+    if (usageLabel.length > 0) {
+        meta.push(usageLabel);
+    }
+    if ((options.queuedCount ?? 0) > 0) {
+        meta.push(`${options.queuedCount} queued`);
+    }
+    return `${DIM}${CYAN}· ${label}${meta.length > 0 ? ` (${meta.join(" · ")})` : ""}${RESET}`;
+}
+function formatUsageSummaryLine(label, usage) {
     const DIM = "\x1b[2m";
     const CYAN = "\x1b[36m";
     const RESET = "\x1b[0m";
-    return kind === "thinking" ? `${DIM}${CYAN}· Thinking…${RESET}` : `${DIM}${CYAN}· Responding…${RESET}`;
+    return `${DIM}${CYAN}· ${label}: ${formatUsageCompact(usage)}${RESET}`;
+}
+function formatUsageCompact(usage, showPendingOutputIndicator = false) {
+    if (usage && usage.output > 0) {
+        return `↓ ${formatTokenCount(usage.output)} tokens`;
+    }
+    if (showPendingOutputIndicator) {
+        return "↓";
+    }
+    return "";
+}
+function formatElapsedLabel(elapsedMs) {
+    const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000));
+    if (totalSeconds < 60) {
+        return `${totalSeconds}s`;
+    }
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes < 60) {
+        return seconds === 0 ? `${minutes}m` : `${minutes}m ${seconds}s`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes === 0 ? `${hours}h` : `${hours}h ${remainingMinutes}m`;
+}
+function formatTokenCount(count) {
+    if (count < 1_000)
+        return `${count}`;
+    if (count < 10_000)
+        return `${(count / 1_000).toFixed(1).replace(/\.0$/, "")}k`;
+    return `${Math.round(count / 1_000)}k`;
+}
+function emptyUsageSnapshot() {
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 };
+}
+function normalizeUsageSnapshot(usage) {
+    return {
+        input: Math.max(0, usage.input),
+        output: Math.max(0, usage.output),
+        cacheRead: Math.max(0, usage.cacheRead),
+        cacheWrite: Math.max(0, usage.cacheWrite),
+        totalTokens: Math.max(0, usage.totalTokens),
+    };
+}
+function addUsageSnapshots(left, right) {
+    return {
+        input: left.input + right.input,
+        output: left.output + right.output,
+        cacheRead: left.cacheRead + right.cacheRead,
+        cacheWrite: left.cacheWrite + right.cacheWrite,
+        totalTokens: left.totalTokens + right.totalTokens,
+    };
+}
+function hasUsageSnapshot(usage) {
+    if (!usage) {
+        return false;
+    }
+    return usage.input > 0 || usage.output > 0 || usage.cacheRead > 0 || usage.cacheWrite > 0 || usage.totalTokens > 0;
 }
 function mergeStreamingText(existing, incoming) {
     if (incoming.length === 0)
@@ -1781,7 +2319,7 @@ function wrapTranscriptContent(content, width) {
     lines.push(current);
     return lines;
 }
-function computeVisibleTranscriptLines(blocks, width, maxRows) {
+function computeVisibleTranscriptLines(blocks, width, maxRows, offsetFromBottom = 0) {
     if (maxRows <= 0 || blocks.length === 0) {
         return [];
     }
@@ -1789,7 +2327,77 @@ function computeVisibleTranscriptLines(blocks, width, maxRows) {
     if (flattened.length <= maxRows) {
         return flattened;
     }
-    return flattened.slice(flattened.length - maxRows);
+    const maxOffset = Math.max(0, flattened.length - maxRows);
+    const clampedOffset = Math.max(0, Math.min(offsetFromBottom, maxOffset));
+    const end = flattened.length - clampedOffset;
+    const start = Math.max(0, end - maxRows);
+    return flattened.slice(start, end);
+}
+function extractPlainTextSelection(lines, selection) {
+    if (lines.length === 0) {
+        return "";
+    }
+    const startFirst = selection.startRow < selection.endRow ||
+        (selection.startRow === selection.endRow && selection.startColumn <= selection.endColumn);
+    const start = startFirst
+        ? { row: selection.startRow, column: selection.startColumn }
+        : { row: selection.endRow, column: selection.endColumn };
+    const end = startFirst
+        ? { row: selection.endRow, column: selection.endColumn }
+        : { row: selection.startRow, column: selection.startColumn };
+    const selectedLines = [];
+    for (let row = start.row; row <= end.row; row += 1) {
+        const line = lines[row] ?? "";
+        const fromColumn = row === start.row ? start.column : 1;
+        const toColumn = row === end.row ? end.column : Number.MAX_SAFE_INTEGER;
+        selectedLines.push(slicePlainTextByDisplayColumns(line, fromColumn - 1, toColumn - 1));
+    }
+    return selectedLines.join("\n").replace(/\s+$/g, "").replace(/\n[ \t]+$/gm, "");
+}
+function renderSelectedPlainTranscriptLine(line, startColumn, endColumn, width) {
+    const safeStart = Math.max(1, Math.min(startColumn, endColumn));
+    const safeEnd = Math.max(safeStart, Math.max(startColumn, endColumn));
+    const before = slicePlainTextByDisplayColumns(line, 0, safeStart - 1);
+    const selected = slicePlainTextByDisplayColumns(line, safeStart - 1, safeEnd - 1);
+    const after = slicePlainTextByDisplayColumns(line, safeEnd - 1, Number.MAX_SAFE_INTEGER);
+    const inverse = "\x1b[7m";
+    const reset = "\x1b[0m";
+    return fitTerminalLine(`${before}${inverse}${selected.length > 0 ? selected : " "}${reset}${after}`, width);
+}
+function slicePlainTextByDisplayColumns(text, startColumn, endColumnExclusive) {
+    const start = Math.max(0, startColumn);
+    const end = Math.max(start, endColumnExclusive);
+    let output = "";
+    let used = 0;
+    for (const ch of text) {
+        const charWidth = (0, terminal_display_width_js_1.measureTerminalDisplayWidth)(ch);
+        const nextUsed = used + charWidth;
+        if (nextUsed > start && used < end) {
+            output += ch;
+        }
+        if (used >= end) {
+            break;
+        }
+        used = nextUsed;
+    }
+    return output;
+}
+function copyTextToClipboard(text) {
+    if (text.length === 0) {
+        return;
+    }
+    if (process.platform === "darwin") {
+        (0, node_child_process_1.spawnSync)("pbcopy", [], { input: text, stdio: ["pipe", "ignore", "ignore"] });
+        return;
+    }
+    if (process.platform === "win32") {
+        (0, node_child_process_1.spawnSync)("clip", [], { input: text, stdio: ["pipe", "ignore", "ignore"] });
+        return;
+    }
+    (0, node_child_process_1.spawnSync)("sh", ["-c", "command -v wl-copy >/dev/null 2>&1 && wl-copy || xclip -selection clipboard"], {
+        input: text,
+        stdio: ["pipe", "ignore", "ignore"],
+    });
 }
 function computeTranscriptDisplayRows(blocks, width) {
     return flattenTranscriptLines(blocks, width).length;
@@ -1801,20 +2409,32 @@ function materializeAssistantTranscriptBlock(buffer) {
     return formatTranscriptAssistantLine(buffer);
 }
 function appendAssistantTranscriptBlock(blocks, assistantBlock) {
-    const lastNonEmptyBlock = [...blocks].reverse().find((block) => block.length > 0);
-    if (lastNonEmptyBlock && isTranscriptUserBlock(lastNonEmptyBlock)) {
-        return [...blocks, "", assistantBlock];
+    return appendTranscriptBlockWithSpacer(blocks, assistantBlock);
+}
+function appendTranscriptBlockWithSpacer(blocks, block) {
+    if (block.length === 0) {
+        return [...blocks];
+    }
+    const lastNonEmptyIndex = findLastNonEmptyBlockIndex(blocks);
+    if (lastNonEmptyIndex === -1) {
+        return [block];
+    }
+    const normalized = blocks.slice(0, lastNonEmptyIndex + 1);
+    return [...normalized, "", block];
+}
+function findLastNonEmptyBlockIndex(blocks) {
+    for (let index = blocks.length - 1; index >= 0; index -= 1) {
+        if ((blocks[index] ?? "").length > 0) {
+            return index;
+        }
     }
-    return [...blocks, assistantBlock];
+    return -1;
 }
 function computeFooterStartRow(welcomeLineCount, terminalHeight, footerHeight, transcriptRows) {
     const naturalStartRow = welcomeLineCount + 1 + Math.max(0, transcriptRows);
     const bottomAnchoredStartRow = Math.max(1, terminalHeight - footerHeight + 1);
     return Math.min(naturalStartRow, bottomAnchoredStartRow);
 }
-function isFooterBottomAnchored(startRow, terminalHeight, footerHeight) {
-    return startRow === Math.max(1, terminalHeight - footerHeight + 1);
-}
 function flattenTranscriptLines(blocks, width) {
     const flattened = [];
     for (const block of blocks) {