erosolar-cli 2.1.52 → 2.1.54

package/dist/ui/UnifiedUIRenderer.js

@@ -13,7 +13,7 @@ import { EventEmitter } from 'node:events';
 import { homedir } from 'node:os';
 import { theme } from './theme.js';
 import { isPlainOutputMode } from './outputMode.js';
-import { renderDivider, renderStatusLines } from './unified/layout.js';
+import { renderDivider } from './unified/layout.js';
 const ESC = {
     HIDE_CURSOR: '\x1b[?25l',
     SHOW_CURSOR: '\x1b[?25h',
@@ -38,6 +38,7 @@ export class UnifiedUIRenderer extends EventEmitter {
     interactive;
     rows = 24;
     cols = 80;
+    lastRenderWidth = null;
     eventQueue = [];
     isProcessingQueue = false;
     buffer = '';
@@ -69,20 +70,32 @@ export class UnifiedUIRenderer extends EventEmitter {
     promptHeight = 0;
     lastOverlayHeight = 0;
     lastPromptIndex = 0;
+    overlayBottomPadding = 1;
     inlinePanel = [];
     overlayInvalidated = false;
     hasConversationContent = false;
     isPromptActive = false;
     inputRenderOffset = 0;
+    plainPasteIdleMs = 24;
+    plainPasteWindowMs = 60;
+    plainPasteTriggerChars = 24;
+    plainPasteNewlineAssist = 3;
     cursorVisibleColumn = 1;
     inBracketedPaste = false;
     pasteBuffer = '';
+    inPlainPaste = false;
+    plainPasteBuffer = '';
+    plainPasteTimer = null;
+    pasteBurstWindowStart = 0;
+    pasteBurstCharCount = 0;
+    plainRecentChunks = [];
     lastRenderedEventKey = null;
     lastOutputEndedWithNewline = true;
     hasRenderedPrompt = false;
     hasEverRenderedOverlay = false; // Track if we've ever rendered to prevent first-render scrollback pollution
     lastOverlay = null;
     allowPromptRender = true;
+    inputCapture = null;
     constructor(output = process.stdout, input = process.stdin, options) {
         super();
         this.output = output;
@@ -131,6 +144,8 @@ export class UnifiedUIRenderer extends EventEmitter {
         this.renderPrompt();
     }
     cleanup() {
+        this.cancelInputCapture(new Error('Renderer disposed'));
+        this.cancelPlainPasteCapture();
         if (!this.interactive) {
             this.rl.close();
             return;
@@ -174,6 +189,14 @@ export class UnifiedUIRenderer extends EventEmitter {
         if (this.handleBracketedPaste(str, key)) {
             return;
         }
+        if (this.handlePlainPaste(str, key)) {
+            return;
+        }
+        if (this.inputCapture && key.ctrl && (key.name === 'c' || key.name === 'd')) {
+            this.cancelInputCapture(new Error('Input capture cancelled'));
+            this.clearBuffer();
+            return;
+        }
         if (key.ctrl && key.shift && key.name?.toLowerCase() === 'a') {
             this.emit('toggle-critical-approval');
             return;
@@ -319,6 +342,7 @@ export class UnifiedUIRenderer extends EventEmitter {
         if (sequence === '\x1b[200~') {
             this.inBracketedPaste = true;
             this.pasteBuffer = '';
+            this.cancelPlainPasteCapture();
             return true;
         }
         if (!this.inBracketedPaste) {
@@ -366,10 +390,141 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
         this.inBracketedPaste = false;
         this.pasteBuffer = '';
+        this.cancelPlainPasteCapture();
+    }
+    handlePlainPaste(str, key) {
+        // Fallback paste capture when bracketed paste isn't supported
+        if (this.inBracketedPaste || key?.ctrl || key?.meta) {
+            this.resetPlainPasteBurst();
+            this.pruneRecentPlainChunks();
+            return false;
+        }
+        const sequence = key?.sequence ?? '';
+        const chunk = typeof str === 'string' && str.length > 0 ? str : sequence;
+        if (!chunk) {
+            this.resetPlainPasteBurst();
+            this.pruneRecentPlainChunks();
+            return false;
+        }
+        const now = Date.now();
+        this.trackPlainPasteBurst(chunk.length, now);
+        if (!this.inPlainPaste) {
+            this.recordRecentPlainChunk(chunk, now);
+        }
+        const chunkMultiple = chunk.length > 1;
+        const hasNewline = /[\r\n]/.test(chunk);
+        const burstActive = this.pasteBurstWindowStart > 0 && now - this.pasteBurstWindowStart <= this.plainPasteWindowMs;
+        const burstTrigger = burstActive && this.pasteBurstCharCount >= this.plainPasteTriggerChars;
+        const newlineTrigger = hasNewline && (this.inPlainPaste || chunkMultiple || this.pasteBurstCharCount >= this.plainPasteNewlineAssist);
+        const looksLikePaste = this.inPlainPaste || chunkMultiple || burstTrigger || newlineTrigger;
+        if (!looksLikePaste) {
+            this.pruneRecentPlainChunks();
+            return false;
+        }
+        let chunkAlreadyCaptured = false;
+        if (!this.inPlainPaste) {
+            this.inPlainPaste = true;
+            const reclaimed = this.reclaimRecentPlainChunks();
+            if (reclaimed.length > 0) {
+                const removeCount = Math.min(this.buffer.length, reclaimed.length);
+                const suffix = this.buffer.slice(-removeCount);
+                if (removeCount > 0 && suffix === reclaimed.slice(-removeCount)) {
+                    this.buffer = this.buffer.slice(0, this.buffer.length - removeCount);
+                    this.cursor = Math.max(0, this.buffer.length);
+                }
+                this.plainPasteBuffer = reclaimed;
+                chunkAlreadyCaptured = reclaimed.endsWith(chunk);
+            }
+            else {
+                this.plainPasteBuffer = '';
+            }
+        }
+        if (!chunkAlreadyCaptured) {
+            this.plainPasteBuffer += chunk;
+        }
+        this.schedulePlainPasteCommit();
+        return true;
+    }
+    trackPlainPasteBurst(length, now) {
+        if (!this.pasteBurstWindowStart || now - this.pasteBurstWindowStart > this.plainPasteWindowMs) {
+            this.pasteBurstWindowStart = now;
+            this.pasteBurstCharCount = 0;
+        }
+        this.pasteBurstCharCount += length;
+    }
+    resetPlainPasteBurst() {
+        this.pasteBurstWindowStart = 0;
+        this.pasteBurstCharCount = 0;
+    }
+    cancelPlainPasteCapture() {
+        if (this.plainPasteTimer) {
+            clearTimeout(this.plainPasteTimer);
+            this.plainPasteTimer = null;
+        }
+        this.inPlainPaste = false;
+        this.plainPasteBuffer = '';
+        this.plainRecentChunks = [];
+        this.resetPlainPasteBurst();
+    }
+    recordRecentPlainChunk(text, at) {
+        const windowStart = at - this.plainPasteWindowMs;
+        this.plainRecentChunks.push({ text, at });
+        this.plainRecentChunks = this.plainRecentChunks.filter(entry => entry.at >= windowStart);
+    }
+    pruneRecentPlainChunks() {
+        if (!this.plainRecentChunks.length)
+            return;
+        const now = Date.now();
+        const windowStart = now - this.plainPasteWindowMs;
+        this.plainRecentChunks = this.plainRecentChunks.filter(entry => entry.at >= windowStart);
+    }
+    reclaimRecentPlainChunks() {
+        if (!this.plainRecentChunks.length)
+            return '';
+        const combined = this.plainRecentChunks.map(entry => entry.text).join('');
+        this.plainRecentChunks = [];
+        return combined;
+    }
+    schedulePlainPasteCommit() {
+        if (this.plainPasteTimer) {
+            clearTimeout(this.plainPasteTimer);
+        }
+        this.plainPasteTimer = setTimeout(() => {
+            this.finalizePlainPaste();
+        }, this.plainPasteIdleMs);
+    }
+    finalizePlainPaste() {
+        if (!this.inPlainPaste)
+            return;
+        const content = this.plainPasteBuffer.replace(/\r\n?/g, '\n');
+        this.inPlainPaste = false;
+        this.plainPasteBuffer = '';
+        this.plainRecentChunks = [];
+        this.resetPlainPasteBurst();
+        if (this.plainPasteTimer) {
+            clearTimeout(this.plainPasteTimer);
+            this.plainPasteTimer = null;
+        }
+        if (!content)
+            return;
+        const lines = content.split('\n');
+        if (lines.length > 1 || content.length > 200) {
+            this.collapsedPaste = { text: content, lines: lines.length, chars: content.length };
+            this.buffer = '';
+            this.cursor = 0;
+            this.updateSuggestions();
+            this.renderPrompt();
+            this.emitInputChange();
+            return;
+        }
+        this.insertText(content);
     }
     insertText(text) {
         if (!text)
             return;
+        if (this.inPlainPaste) {
+            return;
+        }
         if (this.collapsedPaste) {
             this.expandCollapsedPaste();
         }
@@ -384,6 +539,24 @@ export class UnifiedUIRenderer extends EventEmitter {
             this.expandCollapsedPaste();
             return;
         }
+        if (this.inputCapture) {
+            const shouldTrim = this.inputCapture.options.trim;
+            const normalizedCapture = shouldTrim ? text.trim() : text;
+            if (!this.inputCapture.options.allowEmpty && !normalizedCapture) {
+                this.renderPrompt();
+                return;
+            }
+            const resolver = this.inputCapture;
+            this.inputCapture = null;
+            this.buffer = '';
+            this.cursor = 0;
+            this.inputRenderOffset = 0;
+            this.resetSuggestions();
+            this.renderPrompt();
+            this.emitInputChange();
+            resolver.resolve(normalizedCapture);
+            return;
+        }
         const normalized = text.trim();
         if (!normalized) {
             this.renderPrompt();
@@ -785,79 +958,59 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
         // Rich mode: inline overlay anchored to current scrollback (no full-screen clear)
         this.updateTerminalSize();
+        const maxWidth = this.safeWidth();
+        if (this.lastRenderWidth !== null && maxWidth !== this.lastRenderWidth) {
+            // Terminal resized; force a clean anchor so the overlay doesn't jitter.
+            this.overlayInvalidated = true;
+        }
+        this.lastRenderWidth = maxWidth;
         const overlay = this.buildOverlayLines();
         if (!overlay.lines.length) {
             return;
         }
-        const lines = overlay.lines;
-        const promptIndex = Math.max(0, Math.min(overlay.promptIndex, lines.length - 1));
-        const height = lines.length;
-        const prevHeight = this.lastOverlay?.lines.length ?? this.lastOverlayHeight ?? 0;
-        const prevPromptIndex = this.lastOverlay?.promptIndex ?? this.lastPromptIndex ?? promptIndex;
-        const needsFreshAnchor = this.overlayInvalidated || !this.hasRenderedPrompt;
-        // For first render, ensure we start on a fresh line
-        if (needsFreshAnchor) {
-            if (!this.lastOutputEndedWithNewline) {
-                this.write('\n');
-                this.lastOutputEndedWithNewline = true;
-            }
-            // Write blank lines to push the overlay below scrollback
-            // This ensures the overlay doesn't mix with scrollback content
-            for (let i = 0; i < height; i++) {
-                this.write('\n');
-            }
-            // Move cursor back up to where we want to start the overlay
-            if (height > 0) {
-                this.write(`\x1b[${height}A`);
-            }
-            this.write('\r');
+        const renderedLines = overlay.lines.map(line => this.truncateLine(line, maxWidth));
+        if (!renderedLines.length) {
+            return;
         }
-        else {
-            // Move to the top of the previous overlay relative to the prompt row
-            if (prevPromptIndex > 0) {
-                this.write(`\x1b[${prevPromptIndex}A`);
-            }
-            this.write('\r');
-            // Clear previous overlay footprint
-            const rowsToClear = Math.max(prevHeight, height);
-            for (let idx = 0; idx < rowsToClear; idx++) {
-                this.write(ESC.CLEAR_LINE);
-                if (idx < rowsToClear - 1) {
-                    this.write('\n');
-                }
-            }
-            if (rowsToClear > 1) {
-                this.write(`\x1b[${rowsToClear - 1}A`);
-            }
-            this.write('\r');
+        let promptIndex = Math.max(0, Math.min(overlay.promptIndex, renderedLines.length - 1));
+        let height = renderedLines.length;
+        // Keep at least one free line below the overlay so typing always has breathing room
+        const bottomPadding = this.overlayBottomPadding;
+        const totalRows = this.rows || 24;
+        const availableRows = Math.max(1, totalRows - bottomPadding);
+        if (height > availableRows) {
+            renderedLines.splice(availableRows);
+            height = renderedLines.length;
+            promptIndex = Math.max(0, Math.min(promptIndex, height - 1));
+        }
+        const startRow = Math.max(1, availableRows - height + 1);
+        const promptRow = startRow + promptIndex;
+        const promptCol = Math.min(Math.max(1, 3 + this.cursor), this.cols || 80);
+        // Clear any previous overlay footprint (status, prompt, controls) to avoid leaking into scrollback
+        this.clearOverlayRows(height, startRow);
+        if (bottomPadding > 0 && startRow + height <= totalRows) {
+            this.write(ESC.TO(startRow + height, 1));
+            this.write(ESC.CLEAR_LINE);
         }
-        // Write overlay lines in place (relative to current scrollback)
+        // Render overlay lines in place without pushing scrollback
         for (let idx = 0; idx < height; idx++) {
-            const line = this.truncateLine(lines[idx] ?? '', this.safeWidth());
+            const row = startRow + idx;
+            const line = renderedLines[idx] ?? '';
+            this.write(ESC.TO(row, 1));
             this.write(ESC.CLEAR_LINE);
-            this.write(line);
-            if (idx < height - 1) {
-                this.write('\n');
+            if (line) {
+                this.write(line);
             }
         }
         // Position cursor at prompt row/col
-        const fromBottomToPrompt = height - 1 - promptIndex;
-        if (fromBottomToPrompt > 0) {
-            this.write(`\x1b[${fromBottomToPrompt}A`);
-        }
-        else if (fromBottomToPrompt < 0) {
-            this.write(`\x1b[${-fromBottomToPrompt}B`);
-        }
-        const promptCol = Math.min(Math.max(1, 3 + this.cursor), this.cols);
-        this.write('\r');
-        this.write(ESC.TO_COL(promptCol));
+        this.write(ESC.TO(promptRow, promptCol));
         this.cursorVisibleColumn = promptCol;
         this.hasRenderedPrompt = true;
         this.hasEverRenderedOverlay = true; // Mark that we've rendered at least once
         this.isPromptActive = true;
         this.lastOverlayHeight = height;
         this.lastPromptIndex = promptIndex;
-        this.lastOverlay = { lines, promptIndex };
+        this.lastOverlay = { lines: renderedLines, promptIndex };
         this.overlayInvalidated = false;
         this.lastOutputEndedWithNewline = true;
         this.promptHeight = height;
@@ -865,6 +1018,8 @@ export class UnifiedUIRenderer extends EventEmitter {
     buildOverlayLines() {
         const lines = [];
         const maxWidth = this.safeWidth();
+        // Top border to frame status/meta block
+        lines.push(this.truncateLine(renderDivider(Math.min(maxWidth, 96), 'status'), maxWidth));
         const chromeLines = this.buildChromeLines();
         for (const line of chromeLines) {
             lines.push(this.truncateLine(line, maxWidth));
@@ -895,12 +1050,10 @@ export class UnifiedUIRenderer extends EventEmitter {
         return { lines, promptIndex };
     }
     buildChromeLines() {
-        const parts = [...this.buildStatusParts(), ...this.buildMetaParts()];
-        if (parts.length === 0) {
-            return [];
-        }
         const maxWidth = this.safeWidth();
-        return renderStatusLines(parts, maxWidth).map((line) => this.truncateLine(line, maxWidth));
+        const statusLines = this.buildStatusBlock(maxWidth);
+        const metaLines = this.buildMetaBlock(maxWidth);
+        return [...statusLines, ...metaLines];
     }
     abbreviatePath(pathValue) {
         const home = homedir();
@@ -909,54 +1062,116 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
         return pathValue;
     }
-    buildStatusParts() {
-        const statuses = [this.statusStreaming, this.statusOverride, this.statusMessage].filter((value, index, arr) => Boolean(value) && arr.indexOf(value) === index);
-        const label = statuses.length > 0 ? statuses.join(' • ') : 'Ready for prompts';
-        const isReady = label.toLowerCase().includes('ready');
-        const tone = isReady ? 'success' : 'info';
-        const parts = [{ text: `● ${label}`, tone }];
+    buildStatusBlock(maxWidth) {
+        const statusLabel = this.composeStatusLabel();
+        if (!statusLabel) {
+            return [];
+        }
+        const segments = [];
+        segments.push(`${theme.ui.muted('status')} ${this.applyTone(statusLabel.text, statusLabel.tone)}`);
         if (this.statusMeta.sessionTime) {
-            parts.push({ text: `runtime ${this.statusMeta.sessionTime}`, tone: 'muted' });
+            segments.push(`${theme.ui.muted('runtime')} ${theme.ui.muted(this.statusMeta.sessionTime)}`);
         }
         if (this.statusMeta.contextPercent !== undefined) {
             const ctx = this.statusMeta.contextPercent;
-            const ctxTone = ctx > 90 ? 'error' : ctx > 70 ? 'warn' : 'muted';
-            parts.push({ text: `ctx ${ctx}%`, tone: ctxTone });
+            const tone = ctx > 90 ? 'error' : ctx > 70 ? 'warn' : 'muted';
+            const color = tone === 'error' ? theme.error : tone === 'warn' ? theme.warning : theme.ui.muted;
+            segments.push(`${theme.ui.muted('ctx')} ${color(`${ctx}%`)}`);
         }
-        return parts;
+        return this.wrapSegments(segments, maxWidth);
     }
-    buildMetaParts() {
-        const parts = [];
+    buildMetaBlock(maxWidth) {
+        const segments = [];
         if (this.statusMeta.profile) {
-            parts.push({ text: `profile ${this.statusMeta.profile}`, tone: 'info' });
+            segments.push(this.formatMetaSegment('profile', this.statusMeta.profile, 'info'));
         }
         const model = this.statusMeta.provider && this.statusMeta.model
-            ? `${this.statusMeta.provider} · ${this.statusMeta.model}`
+            ? `${this.statusMeta.provider} / ${this.statusMeta.model}`
             : this.statusMeta.model || this.statusMeta.provider;
         if (model) {
-            parts.push({ text: `model ${model}`, tone: 'info' });
+            segments.push(this.formatMetaSegment('model', model, 'info'));
         }
         const workspace = this.statusMeta.workspace || this.statusMeta.directory;
         if (workspace) {
-            parts.push({ text: `dir ${this.abbreviatePath(workspace)}`, tone: 'muted' });
+            segments.push(this.formatMetaSegment('dir', this.abbreviatePath(workspace), 'muted'));
         }
         if (this.statusMeta.writes) {
-            parts.push({ text: `writes ${this.statusMeta.writes}`, tone: 'muted' });
+            segments.push(this.formatMetaSegment('writes', this.statusMeta.writes, 'muted'));
         }
         if (this.statusMeta.toolSummary) {
-            parts.push({ text: this.statusMeta.toolSummary, tone: 'muted' });
+            segments.push(this.formatMetaSegment('tools', this.statusMeta.toolSummary, 'muted'));
         }
-        const sessionLabel = this.statusMeta.sessionLabel;
-        if (sessionLabel) {
-            parts.push({ text: `session ${sessionLabel}`, tone: 'muted' });
+        if (this.statusMeta.sessionLabel) {
+            segments.push(this.formatMetaSegment('session', this.statusMeta.sessionLabel, 'muted'));
         }
         if (this.statusMeta.version) {
-            parts.push({ text: `v${this.statusMeta.version}`, tone: 'muted' });
+            segments.push(this.formatMetaSegment('build', `v${this.statusMeta.version}`, 'muted'));
         }
-        if (parts.length === 0) {
+        if (segments.length === 0) {
             return [];
         }
-        return parts;
+        return this.wrapSegments(segments, maxWidth);
+    }
+    composeStatusLabel() {
+        const statuses = [this.statusStreaming, this.statusOverride, this.statusMessage].filter((value, index, arr) => Boolean(value) && arr.indexOf(value) === index);
+        const text = statuses.length > 0 ? statuses.join(' / ') : 'Ready for prompts';
+        if (!text.trim()) {
+            return null;
+        }
+        const normalized = text.toLowerCase();
+        const tone = normalized.includes('ready') ? 'success' : 'info';
+        return { text, tone };
+    }
+    formatMetaSegment(label, value, tone) {
+        const colorizer = tone === 'success'
+            ? theme.success
+            : tone === 'warn'
+                ? theme.warning
+                : tone === 'error'
+                    ? theme.error
+                    : tone === 'muted'
+                        ? theme.ui.muted
+                        : theme.info;
+        return `${theme.ui.muted(label)} ${colorizer(value)}`;
+    }
+    applyTone(text, tone) {
+        switch (tone) {
+            case 'success':
+                return theme.success(text);
+            case 'warn':
+                return theme.warning(text);
+            case 'error':
+                return theme.error(text);
+            case 'info':
+            default:
+                return theme.info(text);
+        }
+    }
+    wrapSegments(segments, maxWidth) {
+        const lines = [];
+        const separator = theme.ui.muted('  |  ');
+        let current = '';
+        for (const segment of segments) {
+            const normalized = segment.trim();
+            if (!normalized)
+                continue;
+            if (!current) {
+                current = this.truncateLine(normalized, maxWidth);
+                continue;
+            }
+            const candidate = `${current}${separator}${normalized}`;
+            if (this.visibleLength(candidate) <= maxWidth) {
+                current = candidate;
+            }
+            else {
+                lines.push(this.truncateLine(current, maxWidth));
+                current = this.truncateLine(normalized, maxWidth);
+            }
+        }
+        if (current) {
+            lines.push(this.truncateLine(current, maxWidth));
+        }
+        return lines;
     }
     buildControlLines() {
         const lines = [];
@@ -1084,6 +1299,37 @@ export class UnifiedUIRenderer extends EventEmitter {
         this.renderPrompt();
         this.emitInputChange();
     }
+    captureInput(options = {}) {
+        if (this.inputCapture) {
+            return Promise.reject(new Error('Input capture already in progress'));
+        }
+        if (options.resetBuffer) {
+            this.buffer = '';
+            this.cursor = 0;
+            this.inputRenderOffset = 0;
+            this.resetSuggestions();
+            this.renderPrompt();
+            this.emitInputChange();
+        }
+        return new Promise((resolve, reject) => {
+            this.inputCapture = {
+                resolve,
+                reject,
+                options: {
+                    trim: options.trim !== false,
+                    allowEmpty: options.allowEmpty ?? false,
+                },
+            };
+        });
+    }
+    cancelInputCapture(reason) {
+        if (!this.inputCapture) {
+            return;
+        }
+        const capture = this.inputCapture;
+        this.inputCapture = null;
+        capture.reject?.(reason ?? new Error('Input capture cancelled'));
+    }
     // ------------ Helpers ------------
     safeWidth() {
         const cols = this.output.isTTY ? this.cols || 80 : 80;
@@ -1139,6 +1385,17 @@ export class UnifiedUIRenderer extends EventEmitter {
         }
         return result;
     }
+    clearOverlayRows(rows, startRow) {
+        const totalRows = this.rows || 24;
+        const limit = Math.max(0, Math.min(rows, totalRows));
+        for (let idx = 0; idx < limit; idx++) {
+            const row = startRow + idx;
+            if (row < 1 || row > totalRows)
+                continue;
+            this.write(ESC.TO(row, 1));
+            this.write(ESC.CLEAR_LINE);
+        }
+    }
     getBuffer() {
         return this.buffer;
     }
@@ -1154,6 +1411,7 @@ export class UnifiedUIRenderer extends EventEmitter {
         this.emitInputChange();
     }
     clearBuffer() {
+        this.cancelPlainPasteCapture();
         this.buffer = '';
         this.cursor = 0;
         this.inputRenderOffset = 0;
@@ -1205,28 +1463,26 @@ export class UnifiedUIRenderer extends EventEmitter {
         this.addEvent('prompt', normalized);
     }
     clearPromptArea() {
-        const rows = Math.max(this.promptHeight, this.lastOverlay?.lines.length ?? 0);
-        if (rows === 0)
+        const height = this.lastOverlay?.lines.length ?? this.promptHeight ?? 0;
+        if (height === 0)
             return;
-        const promptIndex = this.lastOverlay?.promptIndex ?? this.lastPromptIndex ?? 0;
-        if (promptIndex > 0) {
-            this.write(`\x1b[${promptIndex}A`);
-        }
-        this.write('\r');
-        for (let i = 0; i < rows; i++) {
+        this.updateTerminalSize();
+        const totalRows = this.rows || 24;
+        const startRow = Math.max(1, Math.max(1, totalRows - this.overlayBottomPadding) - height + 1);
+        this.clearOverlayRows(height, startRow);
+        // Keep the padding row clean as well
+        const paddingRow = startRow + height;
+        if (this.overlayBottomPadding > 0 && paddingRow <= totalRows) {
+            this.write(ESC.TO(paddingRow, 1));
             this.write(ESC.CLEAR_LINE);
-            if (i < rows - 1) {
-                this.write('\n');
-            }
         }
-        if (rows > 1) {
-            this.write(`\x1b[${rows - 1}A`);
-        }
-        this.write('\r');
-        this.lastOverlayHeight = rows;
-        this.lastPromptIndex = promptIndex;
+        // Move cursor to the bottom ready for new scrollback output
+        this.write(ESC.TO(totalRows, 1));
+        this.lastOverlayHeight = height;
+        this.lastPromptIndex = this.lastOverlay?.promptIndex ?? this.lastPromptIndex;
         this.lastOverlay = null;
         this.overlayInvalidated = true;
+        this.promptHeight = 0;
     }
     updateTerminalSize() {
         if (this.output.isTTY) {