erosolar-cli 1.7.429 → 1.7.430

package/dist/ui/display.js

@@ -1,146 +1,15 @@
-import { createSpinner } from 'nanospinner';
-import { clearScreenDown, cursorTo } from 'node:readline';
+/**
+ * Display - Simplified UI facade that routes all output through UnifiedUIRenderer
+ *
+ * This class now serves as a compatibility layer, providing the same API
+ * but delegating all actual rendering to UnifiedUIRenderer.
+ */
 import { theme, icons } from './theme.js';
-import { formatRichContent, renderMessagePanel, renderMessageBody } from './richText.js';
+import { renderMessagePanel, renderMessageBody } from './richText.js';
 import { getTerminalColumns } from './layout.js';
 import { highlightError } from './textHighlighter.js';
 import { renderSectionHeading } from './designSystem.js';
 import { isPlainOutputMode } from './outputMode.js';
-import { writeLock } from './writeLock.js';
-import { renderStatusLine } from './unified/layout.js';
-import { isStreamingMode } from './globalWriteLock.js';
-/**
- * Output lock to prevent race conditions during spinner/stream output.
- * Ensures that spinner frames don't interleave with streamed content.
- * Uses a simple lock mechanism suitable for Node.js single-threaded event loop.
- */
-class OutputLock {
-    static instance = null;
-    locked = false;
-    pendingCallbacks = [];
-    static getInstance() {
-        if (!OutputLock.instance) {
-            OutputLock.instance = new OutputLock();
-        }
-        return OutputLock.instance;
-    }
-    /**
-     * Synchronously check if output is locked (spinner is active).
-     * Used to prevent stream writes during spinner animation.
-     */
-    isLocked() {
-        return this.locked;
-    }
-    /**
-     * Lock output during spinner animation.
-     */
-    lock() {
-        this.locked = true;
-    }
-    /**
-     * Unlock output and process any pending callbacks.
-     */
-    unlock() {
-        this.locked = false;
-        // Process any pending writes
-        while (this.pendingCallbacks.length > 0) {
-            const callback = this.pendingCallbacks.shift();
-            if (callback) {
-                callback();
-            }
-        }
-    }
-    /**
-     * Execute a callback safely, queueing if output is locked.
-     */
-    safeWrite(callback) {
-        if (this.locked) {
-            this.pendingCallbacks.push(callback);
-            return;
-        }
-        callback();
-    }
-}
-/**
- * Tracks line output to stdout for banner rewriting and cursor positioning.
- * Instances are cached per stream to keep banner calculations consistent.
- */
-class StdoutLineTracker {
-    static instances = new WeakMap();
-    static getInstance(stream = process.stdout) {
-        const existing = StdoutLineTracker.instances.get(stream);
-        if (existing) {
-            return existing;
-        }
-        const tracker = new StdoutLineTracker(stream);
-        StdoutLineTracker.instances.set(stream, tracker);
-        return tracker;
-    }
-    linesWritten = 0;
-    suspended = false;
-    stream;
-    originalWrite;
-    constructor(stream) {
-        this.stream = stream;
-        this.originalWrite = stream.write.bind(stream);
-        this.patchStream();
-    }
-    get totalLines() {
-        return this.linesWritten;
-    }
-    /**
-     * Temporarily suspends line tracking while executing a function.
-     * Useful for rewriting content without incrementing line count.
-     */
-    withSuspended(fn) {
-        const wasSuspended = this.suspended;
-        this.suspended = true;
-        try {
-            return fn();
-        }
-        finally {
-            this.suspended = wasSuspended;
-        }
-    }
-    reset() {
-        this.linesWritten = 0;
-    }
-    patchStream() {
-        const tracker = this;
-        this.stream.write = function patched(chunk, encoding, callback) {
-            const actualEncoding = typeof encoding === 'function' ? undefined : encoding;
-            tracker.recordChunk(chunk, actualEncoding);
-            return tracker.originalWrite.call(this, chunk, encoding, callback);
-        };
-    }
-    recordChunk(chunk, encoding) {
-        if (this.suspended) {
-            return;
-        }
-        const text = this.chunkToString(chunk, encoding);
-        if (!text) {
-            return;
-        }
-        this.countNewlines(text);
-    }
-    countNewlines(text) {
-        for (const char of text) {
-            if (char === '\n') {
-                this.linesWritten += 1;
-            }
-        }
-    }
-    chunkToString(chunk, encoding) {
-        if (typeof chunk === 'string') {
-            return chunk;
-        }
-        if (chunk instanceof Uint8Array) {
-            const enc = encoding ?? 'utf8';
-            return Buffer.from(chunk).toString(enc);
-        }
-        return null;
-    }
-}
 // Display configuration constants
 const DISPLAY_CONSTANTS = {
     MIN_BANNER_WIDTH: 32,
@@ -155,60 +24,33 @@ const DISPLAY_CONSTANTS = {
     MAX_THOUGHT_WIDTH: 96,
     MIN_CONTENT_WIDTH: 10,
     MIN_WRAP_WIDTH: 12,
-    SPINNER_INTERVAL: 80,
 };
-// Claude Code style spinner frames: ✻ as primary thinking indicator
-// Alternates between ✻ and ◐ for visual interest
-const SPINNER_FRAMES = ['✻', '◐', '✻', '◓', '✻', '◑', '✻', '◒'];
 /**
- * Display class manages all terminal UI output for the application.
- *
- * Architecture:
- * - Per-stream line tracking via StdoutLineTracker for consistent banner updates
- * - Output interceptor pattern for live update integration
- * - Banner state management for in-place updates
- * - Configurable width constraints via DISPLAY_CONSTANTS
+ * Display class - now a thin wrapper around UnifiedUIRenderer
  *
- * Claude Code Style Formatting:
- * - ⏺ prefix for tool calls, actions, and thinking/reasoning
- * - ⎿ prefix for results, details, and nested information
- * - ─ horizontal separators for dividing sections (edit diffs, etc.)
- * - > prefix for user prompts (handled in theme.ts formatUserPrompt)
- * - Compact epsilon spinner: ∴, ε, ✻
- *
- * Key responsibilities:
- * - Welcome banners and session information display
- * - Message formatting (assistant, system, errors, warnings)
- * - Spinner/thinking indicators
- * - Action and sub-action formatting with tree-style prefixes
- * - Text wrapping and layout management
- *
- * Error handling:
- * - Graceful degradation for non-TTY environments
- * - Input validation on public methods
- * - Safe cursor manipulation with fallback
+ * Provides backward-compatible API while routing all output through the renderer.
  */
 export class Display {
-    stdoutTracker;
     outputStream;
     errorStream;
-    activeSpinner = null;
+    renderer = null;
     outputInterceptors = new Set();
-    outputLock = OutputLock.getInstance();
-    spinnerFrames = [...SPINNER_FRAMES];
-    captureStack = [];
+    // Legacy spinner support for compatibility with existing tests/callers
+    activeSpinner = null;
     thinkingStartTime = null;
-    thinkingElapsedTimer = null;
-    thinkingBaseMessage = 'Thinking...';
-    pendingCarriageReturn = false;
-    // Streaming status line (Claude Code style - fixed at bottom using scroll region)
-    streamingStatusVisible = false;
-    scrollRegionActive = false;
-    savedCursorRow = 0;
     constructor(stream = process.stdout, errorStream) {
         this.outputStream = stream;
         this.errorStream = errorStream ?? stream;
-        this.stdoutTracker = StdoutLineTracker.getInstance(stream);
+    }
+    setRenderer(renderer) {
+        this.renderer = renderer;
+    }
+    enqueueEvent(type, content) {
+        if (!this.renderer || !content) {
+            return false;
+        }
+        this.renderer.addEvent(type, content);
+        return true;
     }
     registerOutputInterceptor(interceptor) {
         if (!interceptor) {
@@ -219,38 +61,6 @@ export class Display {
             this.outputInterceptors.delete(interceptor);
         };
     }
-    /**
-     * Execute output with proper write lock coordination.
-     * All display output goes through this method to prevent race conditions.
-     *
-     * Behavior:
-     * - If write lock is already held, execute directly (we're in a protected context)
-     * - Otherwise acquire lock during output to prevent interleaving
-     * - Notifies interceptors before/after output for cursor positioning
-     */
-    withOutput(fn) {
-        const run = () => {
-            this.notifyBeforeOutput();
-            this.pushCaptureBuffer();
-            try {
-                fn();
-            }
-            finally {
-                const captured = this.popCaptureBuffer();
-                this.notifyAfterOutput(captured || undefined);
-            }
-        };
-        // If lock is already held, execute directly - we're in a protected context
-        // This prevents queuing issues where content gets delayed
-        if (writeLock.isLocked()) {
-            run();
-            return;
-        }
-        // Acquire lock during output to prevent interleaved writes
-        writeLock.withLock(() => {
-            run();
-        }, 'display.withOutput');
-    }
     notifyBeforeOutput() {
         for (const interceptor of this.outputInterceptors) {
             interceptor.beforeWrite?.();
@@ -262,234 +72,92 @@ export class Display {
             interceptors[index]?.afterWrite?.(content);
         }
     }
-    pushCaptureBuffer() {
-        this.captureStack.push('');
-    }
-    appendCapturedOutput(chunk) {
-        if (!chunk || this.captureStack.length === 0) {
+    /**
+     * Clear any active spinner for backward compatibility with legacy rendering.
+     * Optionally emits a newline to separate subsequent output.
+     */
+    clearActiveSpinner(addNewLine) {
+        if (!this.activeSpinner) {
             return;
         }
-        const idx = this.captureStack.length - 1;
-        this.captureStack[idx] = `${this.captureStack[idx] ?? ''}${chunk}`;
-    }
-    popCaptureBuffer() {
-        if (this.captureStack.length === 0) {
-            return '';
+        const spinner = this.activeSpinner;
+        this.activeSpinner = null;
+        if (typeof spinner.clear === 'function') {
+            spinner.clear();
         }
-        return this.captureStack.pop() ?? '';
-    }
-    write(value, target = this.outputStream) {
-        // Write directly - this method is called from within locked contexts
-        // like withOutput(), so we don't need additional locking here.
-        // The globalWriteLock wrapper will handle coordination if needed.
-        try {
-            target.write(value);
-            this.appendCapturedOutput(value);
+        else if (typeof spinner.stop === 'function') {
+            spinner.stop();
         }
-        catch {
-            // Ignore write failures to keep UI resilient
+        if (addNewLine) {
+            if (!this.enqueueEvent('raw', '\n')) {
+                this.outputStream.write('\n');
+            }
         }
     }
-    writeLine(value = '', target = this.outputStream) {
-        this.write(`${value}\n`, target);
-    }
     /**
-     * Write raw content directly to output stream.
-     * For streaming output chunks - writes directly without locks during streaming mode.
-     *
-     * During streaming mode, content is written directly to stdout without any
-     * lock coordination. This ensures streaming content flows smoothly without
-     * being delayed by other UI components.
+     * Write raw content directly
      */
     writeRaw(content) {
-        if (typeof content !== 'string' || !content) {
+        if (!content)
             return;
-        }
-        const normalized = this.normalizeStreamingContent(content);
-        if (!normalized) {
+        this.notifyBeforeOutput();
+        if (this.enqueueEvent('raw', content)) {
+            this.notifyAfterOutput(content);
             return;
         }
-        // During streaming, use withLock to prevent interleaving with escape codes.
-        // This ensures the before/write/after sequence is atomic.
-        if (isStreamingMode()) {
-            writeLock.withLock(() => {
-                this.notifyBeforeOutput();
-                try {
-                    this.outputStream.write(normalized);
-                }
-                catch {
-                    // Ignore write failures to keep UI resilient
-                }
-                finally {
-                    this.notifyAfterOutput(normalized);
-                }
-            }, 'display.writeRaw.streaming');
-            return;
-        }
-        // Outside streaming mode, use locks to coordinate with other UI
-        writeLock.withLock(() => {
-            this.notifyBeforeOutput();
-            try {
-                this.write(normalized);
-            }
-            finally {
-                this.notifyAfterOutput(normalized);
-            }
-        }, 'display.writeRaw');
+        // Fallback if no renderer
+        this.outputStream.write(content);
+        this.notifyAfterOutput(content);
     }
     /**
-     * Normalize streaming chunks so progress-style carriage returns render cleanly.
-     * - Preserve CR-based rewrites instead of converting to newlines
-     * - Clear lines when rewriting to avoid leftover characters
-     * - Carry trailing CR across chunks so the next write can clear before drawing
-     */
-    normalizeStreamingContent(content) {
-        // Normalize CRLF first
-        let text = content.replace(/\r\n/g, '\n');
-        let result = '';
-        // If the previous chunk ended with a bare CR, clear the line before new text
-        if (this.pendingCarriageReturn) {
-            if (text.length === 0) {
-                return '';
-            }
-            if (text[0] !== '\n') {
-                result += '\r\x1b[K';
-            }
-            this.pendingCarriageReturn = false;
-        }
-        let trailingCarriageReturn = false;
-        for (let i = 0; i < text.length; i++) {
-            const char = text[i];
-            if (char === '\r') {
-                const next = text[i + 1];
-                if (next === '\n') {
-                    // CRLF already normalized above; skip CR
-                    continue;
-                }
-                const isLastChar = i === text.length - 1;
-                if (isLastChar) {
-                    // Trailing CR: keep it so cursor is at column 0, but delay clearing
-                    result += '\r';
-                    trailingCarriageReturn = true;
-                }
-                else {
-                    // In-place update: move to start and clear the line before new text
-                    result += '\r\x1b[K';
-                }
-                continue;
-            }
-            result += char;
-        }
-        this.pendingCarriageReturn = trailingCarriageReturn;
-        return result;
-    }
-    /**
-     * Stream chunk helper - writes directly to stdout during streaming.
-     * This is the primary method for streaming AI responses.
+     * Stream chunk (for streaming responses)
      */
     stream(chunk) {
-        this.writeRaw(chunk);
+        if (!chunk)
+            return;
+        this.notifyBeforeOutput();
+        if (this.enqueueEvent('streaming', chunk)) {
+            this.notifyAfterOutput(chunk);
+            return;
+        }
+        // Fallback
+        this.outputStream.write(chunk);
+        this.notifyAfterOutput(chunk);
     }
     /**
-     * Backward-compatible alias for stream().
+     * Backward-compatible alias
      */
     writeStreamChunk(chunk) {
         this.stream(chunk);
     }
     /**
-     * Get the output stream for direct access.
-     * Prefer writeRaw/writeStreamChunk for interceptor support.
+     * Get the output stream for direct access
      */
     getOutputStream() {
         return this.outputStream;
     }
     /**
-     * Current number of lines written to stdout (tracked for positioning).
+     * Show thinking indicator
      */
-    getTotalWrittenLines() {
-        return this.stdoutTracker.totalLines;
-    }
-    /**
-     * Number of lines at the top of the terminal that belong to the pinned banner.
-     * For integrated scroll-region layouts, banners are not pinned, so this is 0.
-     */
-    getPinnedHeaderLines() {
-        return 0;
-    }
-    getColumnWidth() {
-        if (typeof this.outputStream.columns === 'number' &&
-            Number.isFinite(this.outputStream.columns) &&
-            this.outputStream.columns > 0) {
-            return this.outputStream.columns;
-        }
-        return getTerminalColumns();
-    }
-    // Banner is now streamed by the shell - no storage needed
     showThinking(message = 'Thinking…') {
-        // If we already have a spinner, just update its text instead of creating a new one
-        if (this.activeSpinner) {
-            this.thinkingBaseMessage = message;
-            this.activeSpinner.update({ text: message });
-            return;
-        }
-        // Lock output to prevent stream writes from interleaving with spinner frames
-        this.outputLock.lock();
-        // Track when thinking started for elapsed time display
         this.thinkingStartTime = Date.now();
-        this.thinkingBaseMessage = message;
-        // Use Claude Code style spinner with ✻ as primary thinking indicator
-        this.activeSpinner = createSpinner(message, {
-            stream: this.outputStream,
-            spinner: {
-                interval: DISPLAY_CONSTANTS.SPINNER_INTERVAL,
-                frames: this.spinnerFrames,
-            },
-        }).start();
-        // Update spinner with elapsed time every second (Claude Code style)
-        this.thinkingElapsedTimer = setInterval(() => {
-            if (this.activeSpinner && this.thinkingStartTime) {
-                const elapsed = Math.floor((Date.now() - this.thinkingStartTime) / 1000);
-                if (elapsed > 0) {
-                    const elapsedText = this.formatElapsedTime(elapsed);
-                    this.activeSpinner.update({ text: `${this.thinkingBaseMessage} ${theme.ui.muted(`(${elapsedText})`)}` });
-                }
-            }
-        }, 1000);
+        this.enqueueEvent('response', message);
     }
     /**
-     * Format elapsed seconds as human-readable time (e.g., "5s", "1m 23s")
+     * Update thinking message
      */
-    formatElapsedTime(seconds) {
-        if (seconds < 60) {
-            return `${seconds}s`;
-        }
-        const mins = Math.floor(seconds / 60);
-        const secs = seconds % 60;
-        return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
-    }
     updateThinking(message) {
-        this.thinkingBaseMessage = message;
-        if (this.activeSpinner) {
-            // If we have elapsed time, include it in the update
-            if (this.thinkingStartTime) {
-                const elapsed = Math.floor((Date.now() - this.thinkingStartTime) / 1000);
-                if (elapsed > 0) {
-                    const elapsedText = this.formatElapsedTime(elapsed);
-                    this.activeSpinner.update({ text: `${message} ${theme.ui.muted(`(${elapsedText})`)}` });
-                    return;
-                }
-            }
-            this.activeSpinner.update({ text: message });
-        }
-        else {
-            this.showThinking(message);
-        }
+        this.enqueueEvent('response', message);
     }
-    stopThinking(addNewLine = true) {
-        this.clearSpinnerIfActive(addNewLine);
+    /**
+     * Stop thinking
+     */
+    stopThinking(_addNewLine = true) {
+        this.clearActiveSpinner(_addNewLine);
+        this.thinkingStartTime = null;
     }
     /**
-     * Get current thinking elapsed time in milliseconds, or null if not thinking.
+     * Get thinking elapsed time
      */
     getThinkingElapsedMs() {
         if (!this.thinkingStartTime) {
@@ -497,245 +165,70 @@ export class Display {
         }
         return Date.now() - this.thinkingStartTime;
     }
+    /**
+     * Check if spinner is active (always false with new renderer)
+     */
     isSpinnerActive() {
-        return this.activeSpinner !== null;
+        return false;
     }
     /**
-     * Check if output is currently locked (e.g., spinner is active).
-     * Used by external callers to coordinate output timing.
+     * Check if output is locked (always false with event queue)
      */
     isOutputLocked() {
-        return this.outputLock.isLocked();
+        return false;
     }
     /**
-     * Execute a write callback safely, ensuring it doesn't interleave with spinner output.
-     * If spinner is active, the write will be queued until spinner stops.
+     * Safe write (just calls callback immediately with event queue)
      */
     safeWrite(callback) {
-        this.outputLock.safeWrite(callback);
-    }
-    /**
-     * Get terminal rows, with fallback
-     */
-    getTerminalRows() {
-        const stream = this.outputStream;
-        return stream.rows ?? 24;
-    }
-    /**
-     * Set up scroll region to reserve bottom line for status.
-     * This allows content to scroll while status stays fixed.
-     */
-    setupScrollRegion() {
-        if (this.scrollRegionActive || !this.isTTY()) {
-            return;
-        }
-        const rows = this.getTerminalRows();
-        // Reserve bottom 2 lines (separator + status)
-        // Set scroll region from row 1 to row (rows - 2)
-        this.outputStream.write(`\x1b[1;${rows - 2}r`);
-        // Move cursor to end of scroll region
-        this.outputStream.write(`\x1b[${rows - 2};1H`);
-        this.scrollRegionActive = true;
-        this.savedCursorRow = rows - 2;
-    }
-    /**
-     * Tear down scroll region and restore normal terminal.
-     */
-    teardownScrollRegion() {
-        if (!this.scrollRegionActive) {
-            return;
-        }
-        const rows = this.getTerminalRows();
-        // Reset scroll region to full screen
-        this.outputStream.write('\x1b[r');
-        // Clear the status lines at bottom
-        this.outputStream.write(`\x1b[${rows - 1};1H\x1b[2K`);
-        this.outputStream.write(`\x1b[${rows};1H\x1b[2K`);
-        // Move cursor back to where content was
-        this.outputStream.write(`\x1b[${this.savedCursorRow};1H`);
-        this.scrollRegionActive = false;
-        this.streamingStatusVisible = false;
-    }
-    /**
-     * Check if we're in a TTY (can use escape codes)
-     */
-    isTTY() {
-        const stream = this.outputStream;
-        return stream.isTTY === true;
-    }
-    /**
-     * Update the streaming status line (Claude Code style).
-     * When scroll region is active, updates the fixed status area at bottom.
-     * Call with null to clear the status line.
-     * Uses shared writeLock to prevent race conditions with other output.
-     */
-    updateStreamingStatus(status) {
-        // Use shared writeLock to coordinate with terminalInput and streaming output
-        writeLock.withLock(() => {
-            this.updateStreamingStatusInternal(status);
-        }, 'display.updateStreamingStatus');
-    }
-    /**
-     * Internal implementation of updateStreamingStatus (called with lock held)
-     * NOTE: During streaming, we do NOT write status lines to stdout to prevent
-     * race conditions with stream chunks. The status is tracked internally and
-     * the terminalInput's status message display handles showing it in the
-     * reserved input area, separate from the main content stream.
-     */
-    updateStreamingStatusInternal(status) {
-        if (!status) {
-            this.streamingStatusVisible = false;
-            return;
-        }
-        // Just track the status - don't write to stdout during streaming
-        this.streamingStatusVisible = true;
-    }
-    /**
-     * Check if streaming status is currently visible.
-     */
-    isStreamingStatusVisible() {
-        return this.streamingStatusVisible;
-    }
-    /**
-     * Check if scroll region is active.
-     */
-    isScrollRegionActive() {
-        return this.scrollRegionActive;
-    }
-    /**
-     * Clear streaming status and reset state.
-     */
-    clearStreamingStatus() {
-        this.streamingStatusVisible = false;
+        callback();
     }
     /**
-     * Display parallel agent status (Claude Code style).
-     * Shows a tree of running agents with their progress.
+     * Show assistant message
      */
-    parallelAgentStatus(content) {
-        if (!content)
-            return;
-        // During streaming, write directly to output
-        this.withOutput(() => {
-            // Clear current line and write agent status
-            this.writeRaw('\r\x1b[K');
-            this.writeLine(content);
-        });
-    }
-    clearSpinnerIfActive(addNewLine = true) {
-        if (!this.activeSpinner) {
-            return;
-        }
-        // Clear the elapsed time update timer
-        if (this.thinkingElapsedTimer) {
-            clearInterval(this.thinkingElapsedTimer);
-            this.thinkingElapsedTimer = null;
-        }
-        this.thinkingStartTime = null;
-        const spinner = this.activeSpinner;
-        this.activeSpinner = null;
-        // Use stop() instead of clear() so nanospinner removes its SIGINT/SIGTERM listeners.
-        // clear() leaves the listeners attached, which triggers MaxListenersExceededWarning over time.
-        spinner.stop();
-        // Unlock output to process any pending writes
-        this.outputLock.unlock();
-        if (addNewLine) {
-            this.withOutput(() => {
-                this.writeLine();
-            });
-        }
-    }
     showAssistantMessage(content, metadata) {
-        if (!content.trim()) {
+        this.clearActiveSpinner(false);
+        if (!content.trim())
             return;
-        }
-        this.clearSpinnerIfActive();
         const isThought = metadata?.isFinal === false;
         const body = isThought ? this.buildClaudeStyleThought(content) : this.buildChatBox(content, metadata);
-        if (!body.trim()) {
+        if (!body.trim())
             return;
-        }
-        // Claude Code: Final responses use bullet prefix ⏺ with continuation indent
-        const wrapped = this.applySingleBulletBlock(body);
-        this.withOutput(() => {
-            this.writeLine(); // Ensure clean start for the box
-            this.writeLine(wrapped);
-            this.writeLine();
-        });
+        const wrapped = isThought ? this.applySingleBulletBlock(body) : body;
+        this.enqueueEvent('raw', `\n${wrapped}\n\n`);
     }
+    /**
+     * Show narrative (thought)
+     */
     showNarrative(content) {
-        if (!content.trim()) {
+        if (!content.trim())
             return;
-        }
         this.showAssistantMessage(content, { isFinal: false });
     }
+    /**
+     * Show action
+     */
     showAction(text, status = 'info') {
-        if (!text.trim()) {
+        if (!text.trim())
             return;
-        }
-        this.clearSpinnerIfActive();
-        // Claude Code style: always use ⏺ prefix for actions
         const icon = this.formatActionIcon(status);
-        this.withOutput(() => {
-            this.writeLine(this.wrapWithPrefix(text, `${icon} `));
-        });
+        const rendered = this.wrapWithPrefix(text, `${icon} `);
+        this.enqueueEvent('raw', `${rendered}\n`);
     }
+    /**
+     * Show sub-action
+     */
     showSubAction(text, status = 'info') {
-        if (!text.trim()) {
+        if (!text.trim())
             return;
-        }
-        this.clearSpinnerIfActive();
-        const prefersRich = text.includes('```');
-        let rendered = prefersRich ? this.buildRichSubActionLines(text, status) : this.buildWrappedSubActionLines(text, status);
-        if (!rendered.length && prefersRich) {
-            rendered = this.buildWrappedSubActionLines(text, status);
-        }
-        if (!rendered.length) {
+        const lines = this.buildWrappedSubActionLines(text, status);
+        if (!lines.length)
             return;
-        }
-        this.withOutput(() => {
-            this.writeLine(rendered.join('\n'));
-            this.writeLine();
-        });
-    }
-    buildWrappedSubActionLines(text, status) {
-        const lines = text.split('\n').map((line) => line.trimEnd());
-        while (lines.length && !lines[lines.length - 1]?.trim()) {
-            lines.pop();
-        }
-        if (!lines.length) {
-            return [];
-        }
-        const rendered = [];
-        for (let index = 0; index < lines.length; index += 1) {
-            const segment = lines[index] ?? '';
-            const isLast = index === lines.length - 1;
-            const { prefix, continuation } = this.buildSubActionPrefixes(status, isLast);
-            rendered.push(this.wrapWithPrefix(segment, prefix, { continuationPrefix: continuation }));
-        }
-        return rendered;
-    }
-    buildRichSubActionLines(text, status) {
-        const normalized = text.trim();
-        if (!normalized) {
-            return [];
-        }
-        const width = Math.max(DISPLAY_CONSTANTS.MIN_ACTION_WIDTH, Math.min(this.getColumnWidth(), DISPLAY_CONSTANTS.MAX_ACTION_WIDTH));
-        const samplePrefix = this.buildSubActionPrefixes(status, true).prefix;
-        const contentWidth = Math.max(DISPLAY_CONSTANTS.MIN_CONTENT_WIDTH, width - this.visibleLength(samplePrefix));
-        const blocks = formatRichContent(normalized, contentWidth);
-        if (!blocks.length) {
-            return [];
-        }
-        return blocks.map((line, index) => {
-            const isLast = index === blocks.length - 1;
-            const { prefix } = this.buildSubActionPrefixes(status, isLast);
-            if (!line.trim()) {
-                return prefix.trimEnd();
-            }
-            return `${prefix}${line}`;
-        });
+        this.enqueueEvent('raw', `${lines.join('\n')}\n\n`);
     }
+    /**
+     * Show message
+     */
     showMessage(content, role = 'assistant') {
         if (role === 'system') {
             this.showSystemMessage(content);
@@ -744,16 +237,19 @@ export class Display {
             this.showAssistantMessage(content);
         }
     }
+    /**
+     * Show system message
+     */
     showSystemMessage(content) {
-        this.clearSpinnerIfActive();
         const normalized = content.trim();
-        if (!normalized) {
+        if (!normalized)
             return;
-        }
         this.stream(`${normalized}\n\n`);
     }
+    /**
+     * Show error
+     */
     showError(message, error) {
-        this.clearSpinnerIfActive();
         const details = this.formatErrorDetails(error);
         const parts = [`${theme.error('✗')} ${message}`];
         if (details) {
@@ -761,23 +257,26 @@ export class Display {
         }
         this.stream(`${parts.join('\n')}\n`);
     }
+    /**
+     * Show warning
+     */
     showWarning(message) {
-        this.clearSpinnerIfActive();
         this.stream(`${theme.warning('!')} ${message}\n`);
     }
+    /**
+     * Show info
+     */
     showInfo(message) {
-        this.clearSpinnerIfActive();
         this.stream(`${theme.info('ℹ')} ${message}\n`);
     }
     /**
-     * Show a success message with simple styling
+     * Show success
      */
     showSuccess(message) {
-        this.clearSpinnerIfActive();
         this.stream(`${theme.success('✓')} ${message}\n`);
     }
     /**
-     * Show a stylish progress indicator for long operations
+     * Show progress badge
      */
     showProgressBadge(label, current, total) {
         const percentage = Math.round((current / total) * 100);
@@ -786,66 +285,133 @@ export class Display {
         const empty = barWidth - filled;
         const progressBar = `${'█'.repeat(filled)}${'░'.repeat(empty)}`;
         const badge = `[${label}] ${progressBar} ${percentage}%`;
-        this.withOutput(() => {
-            this.write(`\r${theme.info(badge)}`);
-            if (current >= total) {
-                this.writeLine();
-            }
+        this.stream(`\r${theme.info(badge)}`);
+        if (current >= total) {
+            this.stream('\n');
+        }
+    }
+    /**
+     * Show status line
+     */
+    showStatusLine(status, elapsedMs, _context) {
+        const normalized = status?.trim();
+        if (!normalized)
+            return;
+        const elapsed = this.formatElapsed(elapsedMs);
+        const parts = [];
+        parts.push(`${theme.success('✓')} ${normalized}`);
+        if (elapsed) {
+            parts.push(`(${elapsed})`);
+        }
+        this.stream(`${parts.join(' ')}\n`);
+    }
+    /**
+     * Show available tools (no-op)
+     */
+    showAvailableTools(_tools) {
+        // Hidden by default
+    }
+    /**
+     * Show command palette
+     */
+    showCommandPalette(commands, options) {
+        if (!commands || commands.length === 0)
+            return;
+        const panel = this.buildCommandPalette(commands, options);
+        if (!panel.trim())
+            return;
+        this.enqueueEvent('raw', `\n${panel}\n\n`);
+    }
+    /**
+     * Show ready with hints (no-op)
+     */
+    showReadyWithHints() {
+        // Commands hint is now in the renderer
+    }
+    /**
+     * Show planning step
+     */
+    showPlanningStep(step, index, total) {
+        if (!step?.trim() || index < 1 || total < 1 || index > total)
+            return;
+        const width = Math.max(DISPLAY_CONSTANTS.MIN_THOUGHT_WIDTH, Math.min(this.getColumnWidth(), DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
+        const heading = renderSectionHeading(`Plan ${index}/${total}`, {
+            subtitle: step,
+            icon: icons.arrow,
+            tone: 'info',
+            width,
         });
+        this.enqueueEvent('raw', `${heading}\n`);
+    }
+    /**
+     * Show thinking block
+     */
+    showThinkingBlock(content, durationMs) {
+        const block = this.buildClaudeStyleThought(content, durationMs);
+        this.enqueueEvent('raw', `\n${block}\n\n`);
+    }
+    /**
+     * Clear screen
+     */
+    clear() {
+        // Renderer handles this
     }
-    showStatusLine(status, elapsedMs, _context) {
-        this.clearSpinnerIfActive();
-        const normalized = status?.trim();
-        if (!normalized) {
-            return;
-        }
-        const elapsed = this.formatElapsed(elapsedMs);
-        const parts = [
-            { text: `${theme.success('✓')} ${normalized}`, tone: 'success' },
-            elapsed ? { text: `(${elapsed})`, tone: 'muted' } : null,
-        ].filter(Boolean);
-        const line = renderStatusLine(parts, this.getColumnWidth() - 2);
-        this.withOutput(() => {
-            this.writeLine(line);
-        });
+    /**
+     * Update streaming status (routes to renderer)
+     */
+    updateStreamingStatus(status) {
+        this.renderer?.updateStatus(status);
     }
-    showAvailableTools(_tools) {
-        // Hidden by default to match Claude Code style
-        // Tools are available but not listed verbosely on startup
-        // Parameter prefixed with underscore to indicate intentionally unused
+    /**
+     * Clear streaming status
+     */
+    clearStreamingStatus() {
+        this.renderer?.updateStatus(null);
     }
     /**
-     * Show a compact launch panel of slash commands with wrapped descriptions.
+     * Check if streaming status is visible
      */
-    showCommandPalette(commands, options) {
-        if (!commands || commands.length === 0) {
-            return;
-        }
-        const panel = this.buildCommandPalette(commands, options);
-        if (!panel.trim()) {
-            return;
-        }
-        this.withOutput(() => {
-            this.writeLine();
-            this.writeLine(panel);
-            this.writeLine();
-        });
+    isStreamingStatusVisible() {
+        return false; // Renderer manages this
     }
     /**
-     * Show ready message with keyboard shortcuts hint (compact)
-     * Note: Commands are now shown in the banner, so this is a no-op
+     * Legacy compatibility methods (no-ops)
      */
-    showReadyWithHints() {
-        // Commands hint is now included in the banner
+    getTotalWrittenLines() {
+        return 0;
+    }
+    getPinnedHeaderLines() {
+        return 0;
+    }
+    setupScrollRegion() {
+        // No-op - renderer handles layout
+    }
+    teardownScrollRegion() {
+        // No-op
+    }
+    isScrollRegionActive() {
+        return false;
+    }
+    parallelAgentStatus(content) {
+        if (!content)
+            return;
+        this.enqueueEvent('streaming', `${content}\n`);
+    }
+    // ==================== Private Helper Methods ====================
+    getColumnWidth() {
+        if (typeof this.outputStream.columns === 'number' &&
+            Number.isFinite(this.outputStream.columns) &&
+            this.outputStream.columns > 0) {
+            return this.outputStream.columns;
+        }
+        return getTerminalColumns();
     }
     formatErrorDetails(error) {
-        if (!error) {
+        if (!error)
             return null;
-        }
         if (error instanceof Error) {
-            if (error.stack) {
+            if (error.stack)
                 return highlightError(error.stack);
-            }
             return highlightError(error.message);
         }
         if (typeof error === 'string') {
@@ -858,83 +424,22 @@ export class Display {
             return null;
         }
     }
-    showPlanningStep(step, index, total) {
-        // Validate inputs
-        if (!step?.trim()) {
-            return;
-        }
-        if (index < 1 || total < 1 || index > total) {
-            return;
-        }
-        const width = Math.max(DISPLAY_CONSTANTS.MIN_THOUGHT_WIDTH, Math.min(this.getColumnWidth(), DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
-        const heading = renderSectionHeading(`Plan ${index}/${total}`, {
-            subtitle: step,
-            icon: icons.arrow,
-            tone: 'info',
-            width,
-        });
-        this.withOutput(() => {
-            this.writeLine(heading);
-        });
-    }
-    clear() {
-        this.withOutput(() => {
-            try {
-                cursorTo(this.outputStream, 0, 0);
-                clearScreenDown(this.outputStream);
-            }
-            catch {
-                this.write('\x1Bc');
-            }
-        });
-        this.stdoutTracker.reset();
-        // Banner is streamed content - no re-render on clear
-    }
-    formatModelLabel(model) {
-        if (/gpt-5\.1-?codex/i.test(model)) {
-            return model;
-        }
-        if (/sonnet-4[-.]?5/i.test(model)) {
-            return 'Sonnet 4.5';
-        }
-        if (/opus-4[-.]?1/i.test(model)) {
-            return 'Opus 4.1';
-        }
-        if (/haiku-4[-.]?5/i.test(model)) {
-            return 'Haiku 4.5';
-        }
-        if (/gpt-5\.1/i.test(model)) {
-            return 'GPT-5.1';
-        }
-        if (/gpt-5-?pro/i.test(model)) {
-            return 'GPT-5 Pro';
-        }
-        if (/gpt-5-?mini/i.test(model)) {
-            return 'GPT-5 Mini';
-        }
-        if (/gpt-5-?nano/i.test(model)) {
-            return 'GPT-5 Nano';
-        }
-        return model;
-    }
-    compactPath(path, maxLen) {
-        if (!path) {
-            return '';
-        }
-        if (this.visibleLength(path) <= maxLen) {
-            return path;
+    formatElapsed(elapsedMs) {
+        if (typeof elapsedMs !== 'number' || !Number.isFinite(elapsedMs) || elapsedMs < 0) {
+            return null;
         }
-        const parts = path.split('/').filter(Boolean);
-        if (parts.length <= 2) {
-            return `${path.slice(0, Math.max(0, maxLen - 3))}...`;
+        const totalSeconds = Math.max(0, Math.round(elapsedMs / 1000));
+        const minutes = Math.floor(totalSeconds / 60);
+        const seconds = totalSeconds % 60;
+        if (minutes > 0) {
+            return `${minutes}m ${seconds.toString().padStart(2, '0')}s`;
         }
-        return `${parts[0]}/.../${parts[parts.length - 1]}`;
+        return `${seconds}s`;
     }
     buildChatBox(content, metadata) {
         const normalized = content.trim();
-        if (!normalized) {
+        if (!normalized)
             return '';
-        }
         if (isPlainOutputMode()) {
             const body = renderMessageBody(normalized, this.resolveMessageWidth());
             const telemetry = this.formatTelemetryLine(metadata);
@@ -949,19 +454,15 @@ export class Display {
             borderColor: theme.ui.border,
         });
         const telemetry = this.formatTelemetryLine(metadata);
-        if (!telemetry) {
-            return panel;
-        }
-        return `${panel}\n${telemetry}`;
+        return telemetry ? `${panel}\n${telemetry}` : panel;
     }
     resolveMessageWidth() {
         const columns = this.getColumnWidth();
         return Math.max(DISPLAY_CONSTANTS.MIN_MESSAGE_WIDTH, Math.min(columns - DISPLAY_CONSTANTS.MESSAGE_PADDING, DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
     }
     formatTelemetryLine(metadata) {
-        if (!metadata) {
+        if (!metadata)
             return '';
-        }
         const parts = [];
         const elapsed = this.formatElapsed(metadata.elapsedMs);
         if (elapsed) {
@@ -969,28 +470,67 @@ export class Display {
             const elapsedValue = theme.metrics?.elapsedValue ?? theme.secondary;
             parts.push(`${elapsedLabel('elapsed')} ${elapsedValue(elapsed)}`);
         }
-        if (!parts.length) {
+        if (!parts.length)
             return '';
-        }
         const separator = theme.ui.muted(' • ');
         return `  ${parts.join(separator)}`;
     }
-    formatElapsed(elapsedMs) {
-        if (typeof elapsedMs !== 'number' || !Number.isFinite(elapsedMs) || elapsedMs < 0) {
-            return null;
+    buildClaudeStyleThought(content, durationMs) {
+        const thinkingStyle = theme.thinking || {
+            icon: theme.info,
+            text: theme.ui.muted,
+            border: theme.ui.border,
+            label: theme.info,
+        };
+        const width = Math.min(this.getColumnWidth() - 4, 70);
+        const lines = [];
+        // Header
+        if (durationMs !== undefined) {
+            const elapsed = this.formatElapsedTime(Math.floor(durationMs / 1000));
+            lines.push(`${theme.info('∴')} Thought for ${elapsed}`);
         }
-        const totalSeconds = Math.max(0, Math.round(elapsedMs / 1000));
-        const minutes = Math.floor(totalSeconds / 60);
-        const seconds = totalSeconds % 60;
-        if (minutes > 0) {
-            return `${minutes}m ${seconds.toString().padStart(2, '0')}s`;
+        else {
+            lines.push(`${theme.info('✻')} ${thinkingStyle.label('Thinking…')}`);
         }
-        return `${seconds}s`;
+        // Content
+        const contentLines = content.split('\n');
+        const hasContent = contentLines.some(line => line.trim().length > 0);
+        if (hasContent) {
+            lines.push('');
+        }
+        for (const line of contentLines) {
+            const trimmed = line.replace(/\s+$/, '');
+            if (!trimmed.trim()) {
+                lines.push('');
+                continue;
+            }
+            const wrapped = this.wrapLine(trimmed, width - 4);
+            for (const wrappedLine of wrapped) {
+                lines.push(`  ${thinkingStyle.text(wrappedLine)}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    formatElapsedTime(seconds) {
+        if (seconds < 60) {
+            return `${seconds}s`;
+        }
+        const mins = Math.floor(seconds / 60);
+        const secs = seconds % 60;
+        return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+    }
+    applySingleBulletBlock(text) {
+        const lines = text.split('\n');
+        const bullet = `${icons.action} `;
+        const prefix = theme.info(bullet);
+        const indent = ' '.repeat(this.visibleLength(this.stripAnsi(bullet)));
+        return lines
+            .map((line, index) => (index === 0 ? `${prefix}${line}` : `${indent}${line}`))
+            .join('\n');
     }
     buildCommandPalette(commands, options) {
-        if (!commands.length) {
+        if (!commands.length)
             return '';
-        }
         const width = Math.max(DISPLAY_CONSTANTS.MIN_MESSAGE_WIDTH, Math.min(this.getColumnWidth() - 2, DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
         const indent = '  ';
         const grouped = this.groupPaletteCommands(commands);
@@ -1049,39 +589,25 @@ export class Display {
         return Math.min(maxAllowed, budget);
     }
     formatPaletteCategory(category) {
-        if (!category) {
+        if (!category)
             return 'Other';
-        }
         switch (category.toLowerCase()) {
-            case 'configuration':
-                return 'Configuration';
-            case 'workspace':
-                return 'Workspace';
-            case 'diagnostics':
-                return 'Diagnostics';
-            case 'other':
-                return 'Other';
-            default:
-                return category[0]?.toUpperCase() + category.slice(1);
+            case 'configuration': return 'Configuration';
+            case 'workspace': return 'Workspace';
+            case 'diagnostics': return 'Diagnostics';
+            case 'other': return 'Other';
+            default: return category[0]?.toUpperCase() + category.slice(1);
         }
     }
     colorizePaletteText(text, tone) {
         switch (tone) {
-            case 'warn':
-                return theme.warning(text);
-            case 'success':
-                return theme.success(text);
-            case 'info':
-                return theme.info(text);
+            case 'warn': return theme.warning(text);
+            case 'success': return theme.success(text);
+            case 'info': return theme.info(text);
             case 'muted':
-            default:
-                return theme.ui.muted(text);
+            default: return theme.ui.muted(text);
         }
     }
-    /**
-     * Wraps text with a prefix on the first line and optional continuation prefix.
-     * Handles multi-line text and word wrapping intelligently.
-     */
     wrapWithPrefix(text, prefix, options) {
         if (!text) {
             return prefix.trimEnd();
@@ -1114,93 +640,25 @@ export class Display {
         }
         return lines.join('\n');
     }
-    resolveStatusColor(status) {
-        switch (status) {
-            case 'success':
-                return theme.success;
-            case 'error':
-                return theme.error;
-            case 'warning':
-                return theme.warning;
-            case 'pending':
-                return theme.info;
-            default:
-                return theme.secondary;
-        }
-    }
-    formatActionIcon(status) {
-        const colorize = this.resolveStatusColor(status);
-        return colorize(`${icons.action}`);
-    }
-    /**
-     * Prefix a multi-line block with a single bullet, indenting subsequent lines.
-     * Keeps entire assistant responses as one visual event.
-     */
-    applySingleBulletBlock(text) {
-        const lines = text.split('\n');
-        const bullet = `${icons.action} `;
-        const prefix = theme.info(bullet);
-        const indent = ' '.repeat(this.visibleLength(this.stripAnsi(bullet)));
-        return lines
-            .map((line, index) => (index === 0 ? `${prefix}${line}` : `${indent}${line}`))
-            .join('\n');
-    }
-    buildClaudeStyleThought(content, durationMs) {
-        // Claude Code style: ∴ Thought for Xs or ✻ Thinking…
-        const thinkingStyle = theme.thinking || {
-            icon: theme.info,
-            text: theme.ui.muted,
-            border: theme.ui.border,
-            label: theme.info,
-        };
-        const width = Math.min(this.getColumnWidth() - 4, 70);
-        const lines = [];
-        // Header: "∴ Thought for Xs" for completed, "✻ Thinking…" for active
-        if (durationMs !== undefined) {
-            const elapsed = this.formatElapsedTime(Math.floor(durationMs / 1000));
-            lines.push(`${theme.info('∴')} Thought for ${elapsed}`);
-        }
-        else {
-            lines.push(`${theme.info('✻')} ${thinkingStyle.label('Thinking…')}`);
-        }
-        // Parse and format the thinking content with simple indentation
-        const contentLines = content.split('\n');
-        const hasContent = contentLines.some(line => line.trim().length > 0);
-        if (hasContent) {
-            lines.push(''); // Visual gap between header and content
+    buildWrappedSubActionLines(text, status) {
+        const lines = text.split('\n').map((line) => line.trimEnd());
+        while (lines.length && !lines[lines.length - 1]?.trim()) {
+            lines.pop();
         }
-        for (const line of contentLines) {
-            const trimmed = line.replace(/\s+$/, '');
-            if (!trimmed.trim()) {
-                lines.push(''); // Preserve intentional blank lines inside the block
-                continue;
-            }
-            const wrapped = this.wrapLine(trimmed, width - 4);
-            for (const wrappedLine of wrapped) {
-                lines.push(`  ${thinkingStyle.text(wrappedLine)}`);
-            }
+        if (!lines.length)
+            return [];
+        const rendered = [];
+        for (let index = 0; index < lines.length; index += 1) {
+            const segment = lines[index] ?? '';
+            const isLast = index === lines.length - 1;
+            const { prefix, continuation } = this.buildSubActionPrefixes(status, isLast);
+            rendered.push(this.wrapWithPrefix(segment, prefix, { continuationPrefix: continuation }));
         }
-        return lines.join('\n');
-    }
-    /**
-     * Show a thinking block with rich formatting (public method for external use)
-     * @param content The thinking content to display
-     * @param durationMs Optional duration in milliseconds to show "Thought for Xs"
-     */
-    showThinkingBlock(content, durationMs) {
-        this.clearSpinnerIfActive();
-        const block = this.buildClaudeStyleThought(content, durationMs);
-        this.withOutput(() => {
-            this.writeLine();
-            this.writeLine(block);
-            this.writeLine();
-            this.writeLine(); // Extra newline for better visual separation
-        });
+        return rendered;
     }
     buildSubActionPrefixes(status, isLast) {
         if (isLast) {
             const colorize = this.resolveStatusColor(status);
-            // Claude Code style: use ⎿ for sub-action result/detail prefix
             return {
                 prefix: `  ${colorize(icons.subaction)} `,
                 continuation: '    ',
@@ -1212,40 +670,55 @@ export class Display {
             continuation: `  ${branch} `,
         };
     }
-    /**
-     * Wraps a single line of text to fit within the specified width.
-     * Intelligently handles word breaking and preserves spaces.
-     */
+    resolveStatusColor(status) {
+        switch (status) {
+            case 'success': return theme.success;
+            case 'error': return theme.error;
+            case 'warning': return theme.warning;
+            case 'pending': return theme.info;
+            default: return theme.secondary;
+        }
+    }
+    formatActionIcon(status) {
+        const colorize = this.resolveStatusColor(status);
+        return colorize(`${icons.action}`);
+    }
     wrapLine(text, width) {
-        // Handle edge cases
-        if (width <= 0) {
+        if (width <= 0)
             return [text];
-        }
-        if (!text) {
+        if (!text)
             return [''];
-        }
-        if (text.length <= width) {
+        if (text.length <= width)
             return [text];
-        }
         const words = text.split(/\s+/).filter(Boolean);
-        // If no words, chunk the entire text
-        if (!words.length) {
+        if (!words.length)
             return this.chunkWord(text, width);
-        }
         const lines = [];
         let current = '';
         for (const word of words) {
-            const appendResult = this.tryAppendWord(current, word, width);
-            if (appendResult.shouldFlush) {
-                lines.push(current);
+            if (!current) {
+                if (word.length <= width) {
+                    current = word;
+                }
+                else {
+                    const chunks = this.chunkWord(word, width);
+                    lines.push(...chunks.slice(0, -1));
+                    current = chunks[chunks.length - 1] ?? '';
+                }
             }
-            if (appendResult.chunks.length > 0) {
-                // Word was too long and was chunked
-                lines.push(...appendResult.chunks.slice(0, -1));
-                current = appendResult.chunks[appendResult.chunks.length - 1] ?? '';
+            else if (current.length + 1 + word.length <= width) {
+                current = `${current} ${word}`;
             }
             else {
-                current = appendResult.newCurrent;
+                lines.push(current);
+                if (word.length <= width) {
+                    current = word;
+                }
+                else {
+                    const chunks = this.chunkWord(word, width);
+                    lines.push(...chunks.slice(0, -1));
+                    current = chunks[chunks.length - 1] ?? '';
+                }
             }
         }
         if (current) {
@@ -1253,64 +726,23 @@ export class Display {
         }
         return lines.length ? lines : [''];
     }
-    /**
-     * Attempts to append a word to the current line.
-     * Returns instructions on how to handle the word.
-     */
-    tryAppendWord(current, word, width) {
-        if (!word) {
-            return { shouldFlush: false, newCurrent: current, chunks: [] };
-        }
-        // Empty current line - start new line with word
-        if (!current) {
-            if (word.length <= width) {
-                return { shouldFlush: false, newCurrent: word, chunks: [] };
-            }
-            // Word too long, need to chunk it
-            return { shouldFlush: false, newCurrent: '', chunks: this.chunkWord(word, width) };
-        }
-        // Word fits on current line with space
-        if (current.length + 1 + word.length <= width) {
-            return { shouldFlush: false, newCurrent: `${current} ${word}`, chunks: [] };
-        }
-        // Word doesn't fit - flush current and start new line
-        if (word.length <= width) {
-            return { shouldFlush: true, newCurrent: word, chunks: [] };
-        }
-        // Word doesn't fit and is too long - flush current and chunk word
-        return { shouldFlush: true, newCurrent: '', chunks: this.chunkWord(word, width) };
-    }
-    /**
-     * Splits a long word into chunks that fit within the specified width.
-     * Used when a single word is too long to fit on one line.
-     */
     chunkWord(word, width) {
-        if (width <= 0 || !word) {
+        if (width <= 0 || !word)
             return word ? [word] : [''];
-        }
         const chunks = [];
         for (let i = 0; i < word.length; i += width) {
             chunks.push(word.slice(i, i + width));
         }
         return chunks.length > 0 ? chunks : [''];
     }
-    /**
-     * Returns the visible length of a string, excluding ANSI escape codes.
-     */
     visibleLength(value) {
-        if (!value) {
+        if (!value)
             return 0;
-        }
         return this.stripAnsi(value).length;
     }
-    /**
-     * Removes ANSI escape codes from a string to get the visible text.
-     * Uses the standard ANSI escape sequence pattern.
-     */
     stripAnsi(value) {
-        if (!value) {
+        if (!value)
             return '';
-        }
         return value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, '');
     }
 }