4runr-os 2.1.4 → 2.1.5

package/dist/ui/v3/ui/phase1RuntimeClean.js

@@ -1,1841 +0,0 @@
-/**
- * Phase 1 Runtime - CLEAN IMPLEMENTATION
- *
- * Following strict lifecycle rules:
- * - Single instance guard
- * - Resize updates layout only (no recreate)
- * - Zero stdout writes
- * - Clean unbinding
- */
-import blessed from 'neo-blessed';
-import { computePhase1Layout, MIN_WIDTH, MIN_HEIGHT } from './layout/phase1Layout.js';
-import { isUIMounted, setUIRuntime, getUIRuntime, destroyUIRuntime } from './uiRuntime.js';
-import { feedStore } from '../core/feedStore.js';
-import { eventBus } from '../core/eventBus.js';
-import { enableTuiMode, disableBootPhase } from '../core/logger.js';
-import { buildUiState } from '../state/uiStateBuilder.js';
-import { defaultUiState } from '../state/defaultState.js';
-import { initializePostureState } from '../state/initializePostureState.js';
-import { renderResourcesPanel } from './panels/ResourcesPanel.js';
-import { renderPosturePanel } from './panels/PosturePanel.js';
-import { renderAssetsPanel } from './panels/AssetsPanel.js';
-import { renderNetworkPanel } from './panels/NetworkPanel.js';
-import { renderCapabilitiesPanel } from './panels/CapabilitiesPanel.js';
-import { isAvailable } from '../state/value.js';
-import { parse, execute, UiAction } from '../commands/commandEngine.js';
-import { BOOT_ID, isDebugMode, trackWidget, trackListenerBinding, installStdoutMonkeypatch, updateResizeStats, getResizeStats } from './debugUtils.js';
-import { getTerminalGeometry, getTerminalSize, isGeometryStable, formatGeometry } from '../tui/geometry.js';
-import { detectTerminalMode, getDetectionLog } from '../tui/terminalMode.js';
-const blessedLib = blessed;
-const PROMPT = '4runr> ';
-// Phase B1: Global mount guard - ONE SCREEN. ONE MOUNT. FOREVER.
-if (globalThis.__TUI_MOUNTED__) {
-    throw new Error('TUI already mounted globally - cannot mount twice');
-}
-// Step 1: Mount guard - ensures UI mounted exactly once
-let mounted = false;
-// Step 2: Single widget registry (source of truth)
-let widgets = null;
-// Current UI state
-let currentUiState = {
-    ...defaultUiState,
-    posture: initializePostureState()
-};
-// Command history
-const commandHistory = [];
-let historyIndex = -1;
-// Input state
-let commandInputValue = PROMPT;
-let cursorPosition = PROMPT.length;
-let scrollOffset = 0;
-// Phase C1: Resize debounce (prevent resize storm)
-let resizeDebounceTimer = null;
-let lastAppliedSize = null;
-const RESIZE_DEBOUNCE_MS = 100; // 100ms debounce for smooth resize
-let resizeEventCount = 0;
-let resizeApplyCount = 0;
-let layoutUIInProgress = false; // Guard against re-entrant layoutUI calls
-let isResizing = false; // Freeze flag to prevent state updates during resize
-let resizeLock = false; // Atomic resize lock - prevents concurrent resize operations
-let resizeTraceEnabled = false; // Enable resize trace logging
-let layoutOverlayEnabled = false; // Enable live layout overlay in Operations panel
-let firstResizeSinceMount = true; // Track first resize for immediate render
-// Resize Truth Panel: Track dimension sources and timing (for debug commands only)
-let lastResizeEventAt = null;
-let layoutAppliedAt = null;
-let lastLayoutCols = null;
-let lastLayoutRows = null;
-let lastComputedLayout = null; // Track last computed layout for overlay
-let resizePollingTimer = null;
-let lastPolledSize = null;
-/**
- * Toggle resize trace mode (exported for debug commands)
- */
-export function setResizeTraceEnabled(enabled) {
-    resizeTraceEnabled = enabled;
-}
-/**
- * Get resize trace status (exported for debug commands)
- */
-export function getResizeTraceEnabled() {
-    return resizeTraceEnabled;
-}
-/**
- * Toggle layout overlay mode (exported for debug commands)
- */
-export function setLayoutOverlayEnabled(enabled) {
-    layoutOverlayEnabled = enabled;
-}
-/**
- * Get layout overlay status (exported for debug commands)
- */
-export function getLayoutOverlayEnabled() {
-    return layoutOverlayEnabled;
-}
-// Resize handler guard (Step 4A: bind once)
-let resizeHandlerBound = false;
-/**
- * Issue 2 - Step 1: Single logger that routes to eventBus
- * NEVER writes to stdout
- */
-function log(tag, msg, level = 'INFO') {
-    eventBus.emit({
-        tag,
-        msg: isDebugMode() ? `[boot=${BOOT_ID}] ${msg}` : msg,
-        level
-    });
-}
-/**
- * Step 3: Safe append helper - prevents duplicate appends
- */
-function safeAppend(screen, widget) {
-    // If widget already has a parent, do not append again
-    if (widget.parent) {
-        log('SYS', 'WARN: Widget already has parent, skipping append', 'WARN');
-        return;
-    }
-    // Check if widget already in screen.children
-    const children = screen.children || [];
-    if (children.includes(widget)) {
-        log('SYS', 'WARN: Widget already in screen.children, skipping append', 'WARN');
-        return;
-    }
-    // Safe to append
-    screen.append(widget);
-}
-/**
- * A) mountUI() - Create widgets ONCE
- * Issue 1 - Step 1: Hard mount guard
- */
-function mountUI(screen, layout) {
-    // Issue 1 - Step 1: Hard guard - mount exactly once
-    if (mounted) {
-        // Track UI rebuild attempts (should never happen)
-        updateResizeStats({ uiRebuildCount: (getResizeStats().uiRebuildCount || 0) + 1 });
-        throw new Error('UI already mounted - cannot mount twice');
-    }
-    mounted = true;
-    // Issue 1 - Step 2: Create all widgets as singletons
-    const createdWidgets = {
-        posture: createPanel(screen, layout.posture, 'POSTURE'),
-        resources: createPanel(screen, layout.resources, 'RESOURCES'),
-        assets: createPanel(screen, layout.assets, 'ASSETS'),
-        operations: createPanel(screen, layout.operations, 'OPERATIONS'),
-        network: createPanel(screen, layout.network, 'NETWORK'),
-        capabilities: createPanel(screen, layout.capabilities, 'CAPABILITIES'),
-        statusStrip: createStatusStrip(screen, layout),
-        commandLine: createCommandLine(screen, layout),
-    };
-    // Step 3: Append all widgets ONCE using safeAppend
-    safeAppend(screen, createdWidgets.posture);
-    safeAppend(screen, createdWidgets.resources);
-    safeAppend(screen, createdWidgets.assets);
-    safeAppend(screen, createdWidgets.operations);
-    safeAppend(screen, createdWidgets.network);
-    safeAppend(screen, createdWidgets.capabilities);
-    safeAppend(screen, createdWidgets.statusStrip);
-    safeAppend(screen, createdWidgets.commandLine);
-    // Step 6: Debug - log initial widget count
-    const initialCount = screen.children?.length || 0;
-    log('SYS', `UI mounted: ${initialCount} widgets`);
-    return createdWidgets;
-}
-/**
- * B) layoutUI() - Update positions ONLY
- * Issue 1 - Step 3: NEVER creates or appends widgets
- *
- * @param screen - The blessed screen object
- * @param widgets - The UI widgets to update
- * @param explicitCols - Optional explicit columns (from resize handler, more accurate than screen)
- * @param explicitRows - Optional explicit rows (from resize handler, more accurate than screen)
- */
-function layoutUI(screen, widgets, explicitCols, explicitRows) {
-    // HARD GUARD: Prevent re-entrant calls (critical for preventing duplicate widgets)
-    if (layoutUIInProgress) {
-        if (isDebugMode()) {
-            log('DBG', 'layoutUI already in progress, skipping duplicate call');
-        }
-        return;
-    }
-    layoutUIInProgress = true;
-    try {
-        // Step 2 & 5: Get geometry from authoritative source
-        // If explicit dimensions provided (from resize handler), use those (most accurate during resize)
-        // Otherwise, read from screen using getTerminalGeometry (which prioritizes stdout for native terminals)
-        let cols;
-        let rows;
-        if (explicitCols !== undefined && explicitRows !== undefined) {
-            // Use explicit dimensions from resize handler (most accurate during resize on Windows Terminal)
-            cols = explicitCols;
-            rows = explicitRows;
-        }
-        else {
-            // Fallback: Read from screen (for initial mount or when explicit dimensions not provided)
-            const geo = getTerminalGeometry(screen);
-            cols = geo.cols;
-            rows = geo.rows;
-        }
-        // Step 4 & 5: Compute layout using dimensions
-        const layoutResult = computePhase1Layout(cols, rows, screen);
-        if (!layoutResult.ok || !layoutResult.layout) {
-            log('SYS', `Terminal too small: ${cols}x${rows} (need ${MIN_WIDTH}x${MIN_HEIGHT})`, 'WARN');
-            return;
-        }
-        const layout = layoutResult.layout;
-        // Store layout for overlay
-        lastComputedLayout = layout;
-        // Update widget positions/sizes ONLY (no recreate, no re-append)
-        updateWidgetLayout(widgets.posture, layout.posture);
-        updateWidgetLayout(widgets.resources, layout.resources);
-        updateWidgetLayout(widgets.assets, layout.assets);
-        updateWidgetLayout(widgets.operations, layout.operations);
-        updateWidgetLayout(widgets.network, layout.network);
-        updateWidgetLayout(widgets.capabilities, layout.capabilities);
-        // Update status strip and command line (deterministic calculation)
-        const statusWidth = Math.floor(layout.commandLine.width * 0.2);
-        const commandWidth = layout.commandLine.width - statusWidth - 1;
-        updateWidgetLayout(widgets.statusStrip, {
-            top: layout.commandLine.top,
-            left: layout.commandLine.left,
-            width: statusWidth,
-            height: layout.commandLine.height,
-        });
-        // CRITICAL: Hard clamp command line dimensions (prevents collapse)
-        // Minimum: 60 width, 3 height (if drawing border)
-        const MIN_COMMAND_LINE_WIDTH = 60;
-        const MIN_COMMAND_LINE_HEIGHT = 3;
-        const clampedCommandWidth = Math.max(MIN_COMMAND_LINE_WIDTH, commandWidth);
-        const clampedCommandHeight = Math.max(MIN_COMMAND_LINE_HEIGHT, layout.commandLine.height);
-        // Ensure command line doesn't overflow terminal bounds
-        const geo = getTerminalGeometry(screen);
-        const cmdLeft = layout.commandLine.left + statusWidth + 1;
-        const maxCommandWidth = geo.safeCols - cmdLeft - 1; // Leave 1 char margin
-        const finalCommandWidth = Math.min(clampedCommandWidth, maxCommandWidth);
-        // Final validation: ensure command line fits within terminal
-        const cmdRight = cmdLeft + finalCommandWidth;
-        const cmdBottom = layout.commandLine.top + clampedCommandHeight;
-        // Final validation before applying layout
-        const finalCmdLeft = layout.commandLine.left + statusWidth + 1;
-        let finalCmdWidth = finalCommandWidth;
-        let finalCmdHeight = clampedCommandHeight;
-        if (cmdRight > geo.safeCols || cmdBottom > geo.safeRows) {
-            if (isDebugMode()) {
-                log('ERR', `Command line overflow: right=${cmdRight} (max=${geo.safeCols}), bottom=${cmdBottom} (max=${geo.safeRows}) - clamping`, 'WARN');
-            }
-            // Fallback to safe minimal layout
-            finalCmdWidth = Math.max(MIN_COMMAND_LINE_WIDTH, Math.min(finalCommandWidth, geo.safeCols - cmdLeft - 1));
-            finalCmdHeight = Math.max(MIN_COMMAND_LINE_HEIGHT, Math.min(clampedCommandHeight, geo.safeRows - layout.commandLine.top - 1));
-        }
-        // Assert: cmdLeft + cmdWidth <= cols, cmdTop + cmdHeight <= rows
-        const finalCmdRight = finalCmdLeft + finalCmdWidth;
-        const finalCmdBottom = layout.commandLine.top + finalCmdHeight;
-        if (finalCmdRight > geo.safeCols) {
-            if (isDebugMode()) {
-                log('ERR', `Command line right edge ${finalCmdRight} > terminal cols ${geo.safeCols} - clamping`, 'WARN');
-            }
-            finalCmdWidth = Math.max(MIN_COMMAND_LINE_WIDTH, geo.safeCols - finalCmdLeft - 1);
-        }
-        if (finalCmdBottom > geo.safeRows) {
-            if (isDebugMode()) {
-                log('ERR', `Command line bottom edge ${finalCmdBottom} > terminal rows ${geo.safeRows} - clamping`, 'WARN');
-            }
-            finalCmdHeight = Math.max(MIN_COMMAND_LINE_HEIGHT, geo.safeRows - layout.commandLine.top - 1);
-        }
-        updateWidgetLayout(widgets.commandLine, {
-            top: layout.commandLine.top,
-            left: finalCmdLeft,
-            width: finalCmdWidth,
-            height: finalCmdHeight,
-        });
-        // Update all panel content (may need to reflow for new width)
-        // IMPORTANT: Do NOT clear command line content during relayout - preserve user input
-        updateAllPanels(widgets);
-        // CRITICAL: Restore command line display after relayout (preserves cursor position and input)
-        // Re-display the current input value with cursor to ensure it's visible after resize
-        try {
-            const availableWidth = Math.max(1, widgets.commandLine.width - 4);
-            const fullText = commandInputValue;
-            const cursorIndex = cursorPosition;
-            // Update scroll offset if needed for new width
-            if (cursorIndex - scrollOffset >= availableWidth - 1) {
-                scrollOffset = cursorIndex - availableWidth + 2;
-            }
-            if (cursorIndex < scrollOffset) {
-                scrollOffset = Math.max(0, cursorIndex - 5);
-            }
-            const visibleStart = scrollOffset;
-            const visibleEnd = Math.min(fullText.length, visibleStart + availableWidth - 1);
-            let visibleText = fullText.substring(visibleStart, visibleEnd);
-            const cursorPosInVisible = cursorIndex - visibleStart;
-            const beforeCursor = visibleText.substring(0, cursorPosInVisible);
-            const afterCursor = visibleText.substring(cursorPosInVisible);
-            const displayValue = beforeCursor + '{inverse} {/}' + afterCursor;
-            // Restore command line display (preserves user's typed input)
-            widgets.commandLine.setContent(displayValue);
-        }
-        catch (e) {
-            // If update fails, at least preserve the prompt
-            widgets.commandLine.setContent(PROMPT);
-        }
-        // CRITICAL: Restore focus AFTER all updates (prevents "typing into nothing")
-        // This must be LAST to ensure focus is not stolen by other widgets
-        // Hide cursor at screen level (we render cursor manually in command line)
-        if (screen.program && screen.program.hideCursor) {
-            screen.program.hideCursor();
-        }
-        // Ensure stdin is active
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(true);
-            process.stdin.setEncoding('utf8');
-            if (process.stdin.isPaused()) {
-                process.stdin.resume();
-            }
-        }
-        // Restore focus
-        screen.focused = widgets.commandLine;
-        widgets.commandLine.focus();
-        // Debug logging (only in debug mode to prevent spam)
-        if (isDebugMode()) {
-            const cmdLineInfo = {
-                x: finalCmdLeft,
-                y: layout.commandLine.top,
-                w: finalCmdWidth,
-                h: finalCmdHeight,
-                focused: screen.focused === widgets.commandLine,
-                hidden: widgets.commandLine.hidden || false,
-                detached: widgets.commandLine.detached || false,
-                screenDims: `${screen.width}x${screen.height}`,
-                stdoutDims: `${process.stdout.columns ?? 'N/A'}x${process.stdout.rows ?? 'N/A'}`
-            };
-            log('DBG', `[RELAYOUT] commandLine: x=${cmdLineInfo.x} y=${cmdLineInfo.y} w=${cmdLineInfo.w} h=${cmdLineInfo.h} focused=${cmdLineInfo.focused} hidden=${cmdLineInfo.hidden}`);
-            // Warn if command line is too small
-            if (finalCommandWidth < MIN_COMMAND_LINE_WIDTH) {
-                log('ERR', `Command line width too small: ${finalCommandWidth} < ${MIN_COMMAND_LINE_WIDTH}`, 'WARN');
-            }
-            // Warn if focus lost
-            if (screen.focused !== widgets.commandLine) {
-                log('WARN', `Command line focus lost - restored`, 'WARN');
-            }
-        }
-    }
-    finally {
-        layoutUIInProgress = false;
-    }
-}
-/**
- * Step 1: Single instance guard
- */
-export async function startPhase1Runtime() {
-    // HARD GUARD: If UI already mounted, return immediately
-    if (isUIMounted()) {
-        // Step 7: Use log() function, not eventBus directly (cleaner)
-        log('ERR', 'UI already mounted - cannot mount twice', 'ERROR');
-        return;
-    }
-    // Log boot ID and terminal size
-    log('SYS', `TUI starting (bootId=${BOOT_ID})`);
-    // Detect and log terminal mode (once at boot)
-    const terminalMode = detectTerminalMode();
-    const detectionLog = getDetectionLog();
-    log('SYS', `Terminal mode: ${terminalMode}`);
-    if (isDebugMode()) {
-        for (const line of detectionLog) {
-            log('DBG', line);
-        }
-    }
-    // Hard guard: Check global TUI initialization flag
-    if (globalThis.__TUI_INITIALIZED__) {
-        log('ERR', 'TUI already initialized - refusing to re-init', 'ERROR');
-        throw new Error('TUI already initialized - cannot reinitialize');
-    }
-    globalThis.__TUI_INITIALIZED__ = true;
-    // Issue 2 - Step 2: Patch console in TUI mode (failsafe)
-    // This prevents any library or accidental console.log from breaking the TUI
-    const originalLog = console.log;
-    const originalError = console.error;
-    const originalWarn = console.warn;
-    console.log = (...args) => {
-        log('DBG', args.map(a => String(a)).join(' '));
-    };
-    console.error = (...args) => {
-        log('ERR', args.map(a => String(a)).join(' '), 'ERROR');
-    };
-    console.warn = (...args) => {
-        log('WARN', args.map(a => String(a)).join(' '), 'WARN');
-    };
-    // Step 5: Enable TUI mode (routes stdout writes to eventBus)
-    enableTuiMode();
-    // Set up raw input
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.setEncoding('utf8');
-    }
-    // Create screen (ONCE)
-    const screen = blessedLib.screen({
-        smartCSR: false,
-        fastCSR: false,
-        title: '4Runr OS',
-        fullUnicode: true,
-        sendFocus: false,
-        warnings: false,
-        autoPadding: false,
-        dockBorders: false,
-    });
-    if (!screen) {
-        throw new Error('Failed to create screen');
-    }
-    // Log actual screen dimensions
-    log('SYS', `Screen size: ${screen.width}x${screen.height}`);
-    // Hide cursor
-    if (screen.program?.hideCursor) {
-        screen.program.hideCursor();
-    }
-    // Step 2: Get geometry from authoritative source (screen values are authoritative)
-    // Pass screen so geometry can read screen.cols/rows directly
-    const geo = getTerminalGeometry(screen);
-    // Initialize last applied size (prevents duplicate processing on first resize)
-    lastAppliedSize = { cols: geo.cols, rows: geo.rows };
-    const layoutResult = computePhase1Layout(geo.cols, geo.rows, screen);
-    if (!layoutResult.ok || !layoutResult.layout) {
-        const errorMsg = layoutResult.errorMessage || 'Terminal too small';
-        screen.destroy();
-        throw new Error(errorMsg);
-    }
-    const layout = layoutResult.layout;
-    // Debug: Log layout dimensions
-    if (isDebugMode()) {
-        log('DBG', `Layout computed for ${geo.cols}x${geo.rows} (source: ${geo.source})`);
-        log('DBG', `Left: ${layout.posture.width}w, Center: ${layout.operations.width}w, Right: ${layout.network.width}w`);
-        log('DBG', `Right col position: left=${layout.network.left}, width=${layout.network.width}`);
-        log('DBG', `Right edge: ${layout.network.left + layout.network.width} (screen cols: ${geo.cols})`);
-    }
-    // A) mountUI() - Create widgets ONCE
-    widgets = mountUI(screen, layout);
-    // Track initial mount (not a rebuild)
-    updateResizeStats({ uiRebuildCount: 0 });
-    // Store unbind functions
-    const unbindFns = [];
-    // Step 3A: Install stdout monkeypatch (debug mode)
-    const uninstallStdoutMonkeypatch = installStdoutMonkeypatch();
-    unbindFns.push(uninstallStdoutMonkeypatch);
-    // Restore console on cleanup
-    unbindFns.push(() => {
-        console.log = originalLog;
-        console.error = originalError;
-        console.warn = originalWarn;
-    });
-    // Step 6: Error handlers
-    const uncaughtHandler = (error) => {
-        log('ERR', `Uncaught: ${error.message}`, 'ERROR');
-    };
-    const unhandledHandler = (reason) => {
-        log('ERR', `Unhandled rejection: ${String(reason)}`, 'ERROR');
-    };
-    process.on('uncaughtException', uncaughtHandler);
-    process.on('unhandledRejection', unhandledHandler);
-    unbindFns.push(() => {
-        process.removeListener('uncaughtException', uncaughtHandler);
-        process.removeListener('unhandledRejection', unhandledHandler);
-    });
-    // Setup input handling
-    setupInputHandling(screen, widgets.commandLine, unbindFns);
-    // Step 2 & 3: Setup resize handling (layout update only)
-    setupResizeHandling(screen, widgets, unbindFns);
-    // Setup signal handlers
-    const sigintHandler = () => cleanExit(0);
-    const sigtermHandler = () => cleanExit(0);
-    process.on('SIGINT', sigintHandler);
-    process.on('SIGTERM', sigtermHandler);
-    unbindFns.push(() => {
-        process.removeListener('SIGINT', sigintHandler);
-        process.removeListener('SIGTERM', sigtermHandler);
-    });
-    // Store runtime
-    const runtime = {
-        screen,
-        widgets,
-        isMounted: true,
-        unbindFns,
-    };
-    setUIRuntime(runtime);
-    // Subscribe to eventBus for Operations panel
-    eventBus.subscribe((event) => {
-        feedStore.push(event);
-        if (widgets) {
-            updateOperationsPanel(widgets.operations);
-            screen.render();
-        }
-    });
-    // Initial content update
-    updateAllPanels(widgets);
-    // Initial render
-    screen.render();
-    // Phase B1: Mark as globally mounted
-    globalThis.__TUI_MOUNTED__ = true;
-    // Disable boot phase (enable strict stdout blocking)
-    disableBootPhase();
-    // Start background state updates
-    startBackgroundUpdates(widgets, screen);
-    // Log boot
-    eventBus.emit({
-        tag: 'SYS',
-        msg: 'TUI initialized',
-        level: 'INFO'
-    });
-}
-/**
- * Hard clear terminal buffer - removes all artifacts
- */
-function hardClearTerminal(screen) {
-    try {
-        const program = screen.program;
-        // Method 1: blessed's program clear (most reliable)
-        if (program && typeof program.clear === 'function') {
-            program.clear();
-            if (typeof program.home === 'function') {
-                program.home();
-            }
-            // Also clear scrollback to remove ALL artifacts
-            if (typeof program.eraseInDisplay === 'function') {
-                program.eraseInDisplay('all'); // Clear entire display including scrollback
-            }
-            return;
-        }
-        // Method 2: ANSI escape codes
-        // \x1b[2J = Clear entire screen
-        // \x1b[3J = Clear scrollback buffer (prevents ghosting)
-        // \x1b[H = Move cursor to home position (0,0)
-        if (process.stdout.isTTY) {
-            process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
-        }
-    }
-    catch (e) {
-        // If clear fails, try ANSI escape as last resort
-        if (process.stdout.isTTY) {
-            process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
-        }
-    }
-}
-/**
- * Nuclear teardown - completely destroy all widgets
- * This is the ONLY way to guarantee no ghosting on Windows Terminal
- */
-function nuclearTeardownWidgets(screen, widgets) {
-    try {
-        // Step 1: Detach all widgets from screen
-        const widgetList = [
-            widgets.posture,
-            widgets.resources,
-            widgets.assets,
-            widgets.operations,
-            widgets.network,
-            widgets.capabilities,
-            widgets.statusStrip,
-            widgets.commandLine,
-        ];
-        for (const widget of widgetList) {
-            if (widget && typeof widget.detach === 'function') {
-                widget.detach();
-            }
-        }
-        // Step 2: Remove from screen.children manually (blessed sometimes doesn't clean up)
-        const screenChildren = screen.children || [];
-        for (let i = screenChildren.length - 1; i >= 0; i--) {
-            const child = screenChildren[i];
-            if (widgetList.includes(child)) {
-                screenChildren.splice(i, 1);
-            }
-        }
-        // Step 3: Destroy all widgets
-        for (const widget of widgetList) {
-            if (widget && typeof widget.destroy === 'function') {
-                widget.destroy();
-            }
-        }
-        // Step 4: Clear any remaining children (safety)
-        while (screenChildren.length > 0) {
-            const child = screenChildren.pop();
-            if (child && typeof child.destroy === 'function') {
-                child.destroy();
-            }
-        }
-    }
-    catch (e) {
-        // Log but don't throw - we're in cleanup mode
-        if (isDebugMode()) {
-            log('DBG', `Nuclear teardown error: ${e}`, 'WARN');
-        }
-    }
-}
-/**
- * Nuclear rebuild - completely destroy and recreate all widgets
- * This is the most reliable way to prevent ghosting on Windows Terminal
- */
-function nuclearRebuildUI(cols, rows, screen, oldWidgets) {
-    // Step 1: Hard clear terminal buffer FIRST
-    hardClearTerminal(screen);
-    // Step 2: Nuclear teardown of old widgets
-    nuclearTeardownWidgets(screen, oldWidgets);
-    // Step 3: Recompute layout with new dimensions
-    const geo = getTerminalGeometry(screen);
-    const layout = computePhase1Layout(cols, rows, screen);
-    // Step 4: Reset mount guard (allow remount)
-    mounted = false;
-    // Step 5: Recreate all widgets
-    const newWidgets = mountUI(screen, layout);
-    // Step 6: Restore input state
-    const textbox = newWidgets.commandLine.children?.[0];
-    if (textbox && typeof textbox.setValue === 'function') {
-        textbox.setValue(commandInputValue);
-        if (typeof textbox.setCursor === 'function') {
-            textbox.setCursor(cursorPosition - PROMPT.length);
-        }
-    }
-    // Step 7: Restore focus
-    screen.focused = newWidgets.commandLine;
-    newWidgets.commandLine.focus();
-    // Step 8: Full render
-    screen.render();
-    return newWidgets;
-}
-/**
- * Clean up duplicate widgets - prevents progressive degradation
- * Called before each resize to ensure widget counts stay stable
- */
-function cleanupDuplicateWidgets(screen, validWidgets) {
-    try {
-        const screenChildren = screen.children || [];
-        const validWidgetSet = new Set([
-            validWidgets.posture,
-            validWidgets.resources,
-            validWidgets.assets,
-            validWidgets.operations,
-            validWidgets.network,
-            validWidgets.capabilities,
-            validWidgets.statusStrip,
-            validWidgets.commandLine,
-        ]);
-        // Track counts of each valid widget
-        const widgetCounts = new Map();
-        for (const widget of validWidgetSet) {
-            widgetCounts.set(widget, 0);
-        }
-        // Count occurrences and find duplicates
-        const duplicates = [];
-        const orphanWidgets = [];
-        for (let i = screenChildren.length - 1; i >= 0; i--) {
-            const child = screenChildren[i];
-            if (validWidgetSet.has(child)) {
-                const count = widgetCounts.get(child) || 0;
-                widgetCounts.set(child, count + 1);
-                // If we've seen this widget before, it's a duplicate (keep first, remove rest)
-                if (count > 0) {
-                    duplicates.push(child);
-                }
-            }
-            else {
-                // Widget not in valid set - it's an orphan
-                orphanWidgets.push(child);
-            }
-        }
-        // Remove duplicates and orphans
-        const toRemove = [...duplicates, ...orphanWidgets];
-        if (toRemove.length > 0) {
-            if (isDebugMode() || resizeTraceEnabled) {
-                log('DBG', `[RESIZE] Cleaning up ${toRemove.length} duplicate/orphan widgets (${duplicates.length} dup, ${orphanWidgets.length} orphan)`);
-            }
-            for (const widget of toRemove) {
-                try {
-                    // Detach and destroy
-                    if (typeof widget.detach === 'function') {
-                        widget.detach();
-                    }
-                    if (typeof widget.destroy === 'function') {
-                        widget.destroy();
-                    }
-                    // Remove from screen.children array
-                    const index = screenChildren.indexOf(widget);
-                    if (index >= 0) {
-                        screenChildren.splice(index, 1);
-                    }
-                }
-                catch (e) {
-                    // Ignore cleanup errors
-                }
-            }
-        }
-    }
-    catch (e) {
-        // Ignore cleanup errors - don't break resize if cleanup fails
-        if (isDebugMode()) {
-            log('DBG', `Cleanup error: ${e}`, 'WARN');
-        }
-    }
-}
-/**
- * Atomic resize application - SAFE UPDATE STRATEGY
- *
- * Updates widget positions/sizes without destroying them (prevents blank screen).
- * Uses scrollback clear to remove artifacts while keeping widgets alive.
- *
- * Sequence:
- * 1. Freeze rendering (isResizing = true)
- * 2. Clean up duplicate widgets (prevents progressive degradation)
- * 3. Get fresh dimensions
- * 4. Update widget positions/sizes (layoutUI)
- * 5. Clear scrollback (prevents ghost artifacts)
- * 6. Update all panels (redraw content)
- * 7. Restore focus
- * 8. Unfreeze rendering
- */
-function applyResizeAtomic(cols, rows, screen, currentWidgets) {
-    // ATOMIC LOCK: Prevent concurrent resize operations
-    if (resizeLock) {
-        if (resizeTraceEnabled || isDebugMode()) {
-            log('DBG', `[RESIZE] Resize already in progress, skipping duplicate call`);
-        }
-        return;
-    }
-    resizeLock = true;
-    try {
-        // Step 1: Freeze rendering (ignore state updates during resize)
-        isResizing = true;
-        // CRITICAL: Clean up duplicate widgets BEFORE layout (prevents progressive degradation)
-        // This ensures widget counts stay stable across multiple resize cycles
-        cleanupDuplicateWidgets(screen, currentWidgets);
-        // Resize trace logging
-        if (resizeTraceEnabled || isDebugMode()) {
-            const childrenCount = (screen.children || []).length;
-            log('DBG', `[RESIZE TRACE] Apply #${resizeApplyCount}: ${cols}x${rows}, children=${childrenCount}`);
-        }
-        // Step 2: Get FRESH dimensions (Windows Terminal fullscreen fix)
-        // Re-read dimensions using getTerminalSize() to get the latest values
-        const freshSize = getTerminalSize(screen);
-        const useCols = freshSize.cols;
-        const useRows = freshSize.rows;
-        if (resizeTraceEnabled && (useCols !== cols || useRows !== rows)) {
-            log('DBG', `[RESIZE] Dimensions updated: ${cols}x${rows} -> ${useCols}x${useRows} (source=${freshSize.source})`);
-        }
-        // Step 3: HARD CLEAR terminal buffer BEFORE layout (prevents leftover buffer lines)
-        // This is critical: old borders/text can remain in rows that no widget redraws over
-        try {
-            const program = screen.program;
-            if (program) {
-                // Clear entire screen buffer
-                if (typeof program.clear === 'function') {
-                    program.clear();
-                }
-                // Clear scrollback to prevent ghost artifacts
-                if (typeof program.eraseInDisplay === 'function') {
-                    program.eraseInDisplay('all');
-                }
-                // Move cursor home
-                if (typeof program.home === 'function') {
-                    program.home();
-                }
-                // Flush to ensure clear is applied
-                if (typeof program.flush === 'function') {
-                    program.flush();
-                }
-            }
-        }
-        catch (e) {
-            // Ignore clear errors - not critical if it fails
-        }
-        // Step 4: SAFE UPDATE - update positions/sizes without destroying widgets
-        // This prevents blank screen issues while still handling resize correctly
-        layoutUI(screen, currentWidgets, useCols, useRows);
-        // Track layout application time and dimensions (for Resize Truth Panel)
-        layoutAppliedAt = Date.now();
-        lastLayoutCols = useCols;
-        lastLayoutRows = useRows;
-        // Step 5: Update all panels with current state (redraw content)
-        // Temporarily allow panel updates during resize (we explicitly want this)
-        // This redraws content with the new layout dimensions
-        const wasResizing = isResizing;
-        isResizing = false; // Temporarily disable guard to allow updates
-        try {
-            updateAllPanels(currentWidgets);
-        }
-        finally {
-            isResizing = wasResizing; // Restore guard
-        }
-        // Step 6: Restore command line focus and input state
-        // Hide cursor at screen level
-        if (screen.program && screen.program.hideCursor) {
-            screen.program.hideCursor();
-        }
-        // Ensure stdin is active
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(true);
-            process.stdin.setEncoding('utf8');
-            if (process.stdin.isPaused()) {
-                process.stdin.resume();
-            }
-        }
-        // Restore focus
-        screen.focused = currentWidgets.commandLine;
-        currentWidgets.commandLine.focus();
-        // Step 7: Final render (screen is already cleared, this repaints everything)
-        screen.render();
-        // CRITICAL for Windows Terminal fullscreen: Second-pass resize after render
-        // Windows Terminal fullscreen can have a race condition where blessed updates
-        // dimensions AFTER the first render. Do a second pass after 80ms to catch this.
-        if (process.platform === 'win32') {
-            setTimeout(() => {
-                try {
-                    // Re-read dimensions after a brief delay (blessed may have updated)
-                    const delayedSize = getTerminalSize(screen);
-                    if (delayedSize.cols !== useCols || delayedSize.rows !== useRows) {
-                        if (resizeTraceEnabled || isDebugMode()) {
-                            log('DBG', `[RESIZE] Second-pass: ${useCols}x${useRows} -> ${delayedSize.cols}x${delayedSize.rows}`);
-                        }
-                        // Dimensions changed - reapply resize
-                        applyResizeAtomic(delayedSize.cols, delayedSize.rows, screen, currentWidgets);
-                    }
-                }
-                catch (e) {
-                    // Ignore errors in second-pass
-                }
-            }, 80);
-        }
-        // Step 8: Validate no duplication occurred
-        const screenChildren = screen.children || [];
-        const widgetCount = screenChildren.length;
-        const commandLineCount = screenChildren.filter((w) => w === currentWidgets.commandLine).length;
-        const postureCount = screenChildren.filter((w) => w === currentWidgets.posture).length;
-        const operationsCount = screenChildren.filter((w) => w === currentWidgets.operations).length;
-        if (commandLineCount > 1 || postureCount > 1 || operationsCount > 1) {
-            log('ERR', `DUPLICATION DETECTED: commandLine=${commandLineCount}, posture=${postureCount}, operations=${operationsCount}`, 'ERROR');
-            if (isDebugMode()) {
-                log('DBG', `Total screen children: ${widgetCount} (expected ~8 widgets)`);
-                log('DBG', `Widgets: ${screenChildren.map((w) => w.type || 'unknown').join(', ')}`);
-            }
-        }
-        if (resizeTraceEnabled || (isDebugMode() && resizeApplyCount % 5 === 0)) {
-            const finalChildrenCount = (screen.children || []).length;
-            log('DBG', `[RESIZE TRACE] Complete: children=${finalChildrenCount}, size=${useCols}x${useRows}`);
-        }
-    }
-    finally {
-        // Step 8: Unfreeze rendering and release atomic lock
-        isResizing = false;
-        resizeLock = false;
-    }
-}
-/**
- * Schedule resize application with smooth behavior
- *
- * Strategy:
- * - First resize: render immediately (fast response)
- * - Subsequent resizes: debounce 100ms (smooth, no spam)
- *
- * Ensures:
- * - Debounce: Multiple rapid resize events result in single layout update
- * - Ignore duplicates: Skip if size hasn't changed from last applied
- * - Atomic: Full redraw from scratch, not incremental
- */
-function scheduleResize(nextCols, nextRows, screen, widgets) {
-    // Check if this is the same as last applied (ignore duplicates)
-    if (lastAppliedSize && lastAppliedSize.cols === nextCols && lastAppliedSize.rows === nextRows) {
-        return; // Same size, no need to recompute
-    }
-    // First resize: render immediately for fast response
-    if (firstResizeSinceMount) {
-        firstResizeSinceMount = false;
-        resizeApplyCount++;
-        lastAppliedSize = { cols: nextCols, rows: nextRows };
-        updateResizeStats({ eventCount: resizeEventCount, applyCount: resizeApplyCount });
-        // Immediate atomic resize
-        applyResizeAtomic(nextCols, nextRows, screen, widgets);
-        // Schedule a final debounced resize to catch any rapid subsequent changes
-        if (resizeDebounceTimer) {
-            clearTimeout(resizeDebounceTimer);
-        }
-        resizeDebounceTimer = setTimeout(() => {
-            resizeDebounceTimer = null;
-            // Check if size changed during debounce
-            const currentGeo = getTerminalGeometry(screen);
-            if (currentGeo.cols !== nextCols || currentGeo.rows !== nextRows) {
-                resizeApplyCount++;
-                lastAppliedSize = { cols: currentGeo.cols, rows: currentGeo.rows };
-                updateResizeStats({ eventCount: resizeEventCount, applyCount: resizeApplyCount });
-                applyResizeAtomic(currentGeo.cols, currentGeo.rows, screen, widgets);
-            }
-        }, RESIZE_DEBOUNCE_MS);
-        return;
-    }
-    // Subsequent resizes: cancel pending and schedule new debounced resize
-    if (resizeDebounceTimer) {
-        clearTimeout(resizeDebounceTimer);
-    }
-    resizeDebounceTimer = setTimeout(() => {
-        resizeDebounceTimer = null;
-        resizeApplyCount++;
-        // Update last applied size BEFORE processing (prevents duplicate processing)
-        lastAppliedSize = { cols: nextCols, rows: nextRows };
-        updateResizeStats({ eventCount: resizeEventCount, applyCount: resizeApplyCount });
-        // Get current geometry (may have changed during debounce)
-        const geo = getTerminalGeometry(screen);
-        // Use current geometry if it changed during debounce
-        const finalCols = geo.cols !== nextCols ? geo.cols : nextCols;
-        const finalRows = geo.rows !== nextRows ? geo.rows : nextRows;
-        if (geo.cols !== nextCols || geo.rows !== nextRows) {
-            if (isDebugMode()) {
-                log('DBG', `Size changed during debounce: requested ${nextCols}x${nextRows}, using ${finalCols}x${finalRows}`);
-            }
-        }
-        // Atomic resize application
-        applyResizeAtomic(finalCols, finalRows, screen, widgets);
-        // SECOND PASS: Check if size changed again after 60ms (catches mid-transition changes)
-        // This prevents partial redraws during Windows Terminal fullscreen transitions
-        setTimeout(() => {
-            try {
-                const secondPassGeo = getTerminalGeometry(screen);
-                if (secondPassGeo.cols !== finalCols || secondPassGeo.rows !== finalRows) {
-                    if (resizeTraceEnabled || isDebugMode()) {
-                        log('DBG', `[RESIZE] Second-pass debounce: ${finalCols}x${finalRows} -> ${secondPassGeo.cols}x${secondPassGeo.rows}`);
-                    }
-                    // Size changed again - apply once more
-                    resizeApplyCount++;
-                    lastAppliedSize = { cols: secondPassGeo.cols, rows: secondPassGeo.rows };
-                    updateResizeStats({ eventCount: resizeEventCount, applyCount: resizeApplyCount });
-                    applyResizeAtomic(secondPassGeo.cols, secondPassGeo.rows, screen, widgets);
-                }
-            }
-            catch (e) {
-                // Ignore second-pass errors
-            }
-        }, 60);
-    }, RESIZE_DEBOUNCE_MS);
-}
-/**
- * Step 2: Resize handler - UPDATE LAYOUT ONLY
- * Step 4A: Bind once guard
- */
-function setupResizeHandling(screen, widgets, unbindFns) {
-    // Step 4A: Hard guard - resize handler bound exactly once
-    if (resizeHandlerBound) {
-        log('SYS', 'WARN: Resize handler already bound, skipping', 'WARN');
-        return;
-    }
-    resizeHandlerBound = true;
-    updateResizeStats({ handlerBound: true });
-    // Common resize handler (used by all resize signals: screen, stdout, SIGWINCH, program, polling)
-    const handleResize = (source = 'unknown') => {
-        resizeEventCount++;
-        lastResizeEventAt = Date.now();
-        if (resizeTraceEnabled || (isDebugMode() && resizeEventCount % 5 === 0)) {
-            log('DBG', `[RESIZE] Event #${resizeEventCount} from: ${source}`);
-        }
-        // Check geometry stability (reject impossible sizes)
-        if (!isGeometryStable(screen)) {
-            if (isDebugMode()) {
-                const geo = getTerminalGeometry(screen);
-                log('DBG', `Unstable geometry detected: ${formatGeometry(geo)} - skipping`);
-            }
-            return;
-        }
-        // CRITICAL: Use getTerminalSize() as SINGLE SOURCE OF TRUTH
-        // This ensures consistency between resize handler and layoutUI
-        // getTerminalSize() prioritizes screen.program.cols/rows or screen.width/height
-        // NOT process.stdout (which can lag on Windows fullscreen transitions)
-        const currentSize = getTerminalSize(screen);
-        const cols = currentSize.cols;
-        const rows = currentSize.rows;
-        // Log dimension source for debugging fullscreen issues
-        if (resizeTraceEnabled || (isDebugMode() && resizeEventCount % 10 === 0)) {
-            const stdoutCols = process.stdout.columns ?? 'N/A';
-            const stdoutRows = process.stdout.rows ?? 'N/A';
-            const programCols = screen.program?.cols ?? 'N/A';
-            const programRows = screen.program?.rows ?? 'N/A';
-            log('DBG', `[RESIZE] Using ${currentSize.source}: ${cols}x${rows} (stdout=${stdoutCols}x${stdoutRows}, program=${programCols}x${programRows})`);
-        }
-        // Check if geometry actually changed from last known
-        // Compare against lastAppliedSize to avoid duplicate processing
-        if (lastAppliedSize && lastAppliedSize.cols === cols && lastAppliedSize.rows === rows) {
-            if (resizeTraceEnabled || (isDebugMode() && resizeEventCount % 20 === 0)) {
-                log('DBG', `[RESIZE] Ignored: size unchanged (${cols}x${rows})`);
-            }
-            return; // No-op resize, ignore
-        }
-        // Schedule resize application (debounced + duplicate guard)
-        scheduleResize(cols, rows, screen, widgets);
-    };
-    // Debug: Track listener binding
-    trackListenerBinding('resize');
-    // Count resize listeners (must be exactly 1 for screen + optionally 1 for stdout)
-    let listenerCount = 0;
-    // Instrument ALL resize signals (comprehensive coverage)
-    // 1. Blessed screen resize event
-    screen.on('resize', () => handleResize('screen'));
-    listenerCount++;
-    // 2. process.stdout resize (for Windows compatibility)
-    if (typeof process.stdout.on === 'function') {
-        process.stdout.on('resize', () => handleResize('stdout'));
-        listenerCount++;
-    }
-    // 3. SIGWINCH signal (may not work on Windows but log it anyway)
-    if (typeof process.on === 'function') {
-        try {
-            process.on('SIGWINCH', () => handleResize('SIGWINCH'));
-            listenerCount++;
-        }
-        catch (e) {
-            // SIGWINCH not supported (e.g., Windows)
-        }
-    }
-    // 4. Blessed program resize (if available)
-    if (screen.program && typeof screen.program.on === 'function') {
-        try {
-            screen.program.on('resize', () => handleResize('program'));
-            listenerCount++;
-        }
-        catch (e) {
-            // Program resize not available
-        }
-    }
-    // Update stats with listener count
-    updateResizeStats({ listenerCount });
-    if (isDebugMode()) {
-        log('DBG', `Resize listeners bound: ${listenerCount} (screen, stdout, SIGWINCH, program)`);
-    }
-    // 5. Polling fallback (for Windows + browser terminals where events don't fire reliably)
-    // Windows fullscreen/maximize often fires multiple resizes (or sometimes none)
-    // Use 250ms interval on Windows, 100ms elsewhere
-    const isWindows = process.platform === 'win32';
-    const POLL_INTERVAL_MS = isWindows ? 250 : 100;
-    resizePollingTimer = setInterval(() => {
-        try {
-            // Use getTerminalSize() which prioritizes screen.program.cols/rows or screen.width/height
-            // This is the SAME source used by handleResize() and layoutUI() for consistency
-            const currentSize = getTerminalSize(screen);
-            const currentCols = currentSize.cols;
-            const currentRows = currentSize.rows;
-            // Check if size changed from last polled size OR from last applied size
-            let shouldTrigger = false;
-            if (lastPolledSize) {
-                if (lastPolledSize.cols !== currentCols || lastPolledSize.rows !== currentRows) {
-                    shouldTrigger = true;
-                }
-            }
-            else {
-                // Initialize last polled size
-                lastPolledSize = { cols: currentCols, rows: currentRows };
-            }
-            // Also check against lastAppliedSize (catches cases where event fired but didn't apply)
-            // This is critical for fullscreen transitions where events might miss or lag
-            if (!shouldTrigger && lastAppliedSize) {
-                if (lastAppliedSize.cols !== currentCols || lastAppliedSize.rows !== currentRows) {
-                    shouldTrigger = true;
-                    if (resizeTraceEnabled || (isDebugMode() && resizeEventCount % 10 === 0)) {
-                        log('DBG', `[POLL] Size mismatch: applied=${lastAppliedSize.cols}x${lastAppliedSize.rows}, current=${currentCols}x${currentRows}`);
-                    }
-                }
-            }
-            if (shouldTrigger) {
-                // Size changed - trigger resize via polling
-                if (resizeTraceEnabled) {
-                    const oldSize = lastPolledSize || lastAppliedSize || { cols: 0, rows: 0 };
-                    log('DBG', `[POLL] Size changed: ${oldSize.cols}x${oldSize.rows} -> ${currentCols}x${currentRows} (source=${currentSize.source})`);
-                }
-                handleResize('polling');
-                // Update last polled size
-                lastPolledSize = { cols: currentCols, rows: currentRows };
-            }
-        }
-        catch (e) {
-            // Ignore polling errors
-        }
-    }, POLL_INTERVAL_MS);
-    // Clean up polling timer on unbind
-    unbindFns.push(() => {
-        if (resizePollingTimer) {
-            clearInterval(resizePollingTimer);
-            resizePollingTimer = null;
-        }
-    });
-    unbindFns.push(() => {
-        // Unbind all resize listeners
-        screen.off('resize', handleResize);
-        if (typeof process.stdout.removeListener === 'function') {
-            process.stdout.removeListener('resize', handleResize);
-        }
-        try {
-            process.removeListener('SIGWINCH', handleResize);
-        }
-        catch (e) {
-            // SIGWINCH not supported
-        }
-        if (screen.program && typeof screen.program.off === 'function') {
-            try {
-                screen.program.off('resize', handleResize);
-            }
-            catch (e) {
-                // Program resize not available
-            }
-        }
-        // Clear pending resize timer
-        if (resizeDebounceTimer) {
-            clearTimeout(resizeDebounceTimer);
-            resizeDebounceTimer = null;
-        }
-        // Clear polling timer
-        if (resizePollingTimer) {
-            clearInterval(resizePollingTimer);
-            resizePollingTimer = null;
-        }
-    });
-    // Disable automatic Resize Truth Panel updates - it interferes with command line
-    // User can manually check resize status with debug commands if needed
-    // Resize Truth Panel will still update when Operations panel naturally updates (via eventBus)
-}
-/**
- * Update widget layout (geometry only)
- */
-function updateWidgetLayout(widget, rect) {
-    widget.top = rect.top;
-    widget.left = rect.left;
-    widget.width = rect.width;
-    widget.height = rect.height;
-}
-/**
- * Create a read-only panel
- */
-function createPanel(screen, rect, title) {
-    const panel = blessedLib.box({
-        top: rect.top,
-        left: rect.left,
-        width: rect.width,
-        height: rect.height,
-        border: { type: 'line' },
-        tags: true,
-        content: '',
-        style: {
-            border: { fg: 'cyan' },
-        },
-        wrap: false,
-        scrollable: false,
-        clickable: false,
-        keys: false,
-        mouse: false,
-        input: false,
-        focusable: false, // CRITICAL: Panels must NOT be focusable (prevents cursor from appearing in wrong widget)
-        cursor: {
-            artificial: false, // Don't show cursor in panels
-            shape: 'line',
-            blink: false,
-        },
-    });
-    // Explicitly disable cursor in panel
-    if (panel.setCursor) {
-        panel.setCursor(false);
-    }
-    panel.setLabel(` {cyan-fg}${title}{/}`);
-    // Debug: Track widget creation
-    trackWidget(panel, title);
-    return panel;
-}
-/**
- * Create status strip
- */
-function createStatusStrip(screen, layout) {
-    const statusWidth = Math.floor(layout.commandLine.width * 0.2);
-    const strip = blessedLib.box({
-        top: layout.commandLine.top,
-        left: layout.commandLine.left,
-        width: statusWidth,
-        height: layout.commandLine.height,
-        border: { type: 'line' },
-        tags: true,
-        content: ' OFFLINE',
-        style: {
-            border: { fg: 'grey' },
-            fg: 'grey',
-        },
-        clickable: false,
-        keys: false,
-        mouse: false,
-        input: false,
-        focusable: false,
-    });
-    strip.setLabel(' {grey-fg}STATUS{/}');
-    // Debug: Track widget creation
-    trackWidget(strip, 'STATUS_STRIP');
-    return strip;
-}
-/**
- * Create command line
- */
-function createCommandLine(screen, layout) {
-    const statusWidth = Math.floor(layout.commandLine.width * 0.2);
-    // Hard clamp command line dimensions (prevents collapse)
-    // Minimum: 60 width, 3 height (if drawing border)
-    const MIN_COMMAND_LINE_WIDTH = 60;
-    const MIN_COMMAND_LINE_HEIGHT = 3;
-    const commandWidth = Math.max(MIN_COMMAND_LINE_WIDTH, layout.commandLine.width - statusWidth - 1);
-    const commandHeight = Math.max(MIN_COMMAND_LINE_HEIGHT, layout.commandLine.height);
-    // Ensure command line fits within terminal bounds
-    const geo = getTerminalGeometry(screen);
-    const cmdLeft = layout.commandLine.left + statusWidth + 1;
-    const maxCommandWidth = geo.safeCols - cmdLeft - 1; // Leave 1 char margin
-    const finalCommandWidth = Math.min(commandWidth, maxCommandWidth);
-    // Validate: cmdLeft + finalCommandWidth <= cols, cmdTop + commandHeight <= rows
-    const cmdRight = cmdLeft + finalCommandWidth;
-    const cmdBottom = layout.commandLine.top + commandHeight;
-    if (cmdRight > geo.safeCols || cmdBottom > geo.safeRows) {
-        if (isDebugMode()) {
-            log('ERR', `Command line layout error: right=${cmdRight} (max=${geo.safeCols}), bottom=${cmdBottom} (max=${geo.safeRows})`, 'WARN');
-        }
-        // Fallback to safe minimal layout
-        const safeWidth = Math.max(MIN_COMMAND_LINE_WIDTH, Math.min(finalCommandWidth, geo.safeCols - cmdLeft - 1));
-        const safeHeight = Math.max(MIN_COMMAND_LINE_HEIGHT, Math.min(commandHeight, geo.safeRows - layout.commandLine.top - 1));
-        // Use safe dimensions (will be applied in updateWidgetLayout)
-    }
-    const cmdLine = blessedLib.box({
-        top: layout.commandLine.top,
-        left: layout.commandLine.left + statusWidth + 1,
-        width: commandWidth,
-        height: commandHeight,
-        border: { type: 'line' },
-        tags: true,
-        content: PROMPT,
-        style: {
-            border: { fg: 'cyan' },
-            fg: 'white',
-        },
-        focusable: true, // MUST be focusable
-        keyable: true, // MUST be keyable
-        input: false, // We handle input via stdin, not blessed input
-        keys: false, // We handle keys via stdin, not blessed keys
-        vi: false, // Disable vi mode
-        alwaysScroll: false,
-        cursor: {
-            artificial: true, // Use artificial cursor (we render it manually)
-            shape: 'block',
-            blink: false,
-        },
-    });
-    // Explicitly ensure cursor handling
-    if (cmdLine.setCursor) {
-        // Don't let blessed manage cursor - we handle it manually
-        cmdLine.setCursor(false);
-    }
-    cmdLine.setLabel(' {cyan-fg}COMMAND LINE{/}');
-    // Debug: Track widget creation
-    trackWidget(cmdLine, 'COMMAND_LINE');
-    return cmdLine;
-}
-/**
- * Setup input handling
- */
-function setupInputHandling(screen, commandLine, unbindFns) {
-    const updateDisplay = () => {
-        const availableWidth = commandLine.width - 4;
-        const fullText = commandInputValue;
-        const cursorIndex = cursorPosition;
-        if (cursorIndex - scrollOffset >= availableWidth - 1) {
-            scrollOffset = cursorIndex - availableWidth + 2;
-        }
-        if (cursorIndex < scrollOffset) {
-            scrollOffset = Math.max(0, cursorIndex - 5);
-        }
-        const visibleStart = scrollOffset;
-        const visibleEnd = Math.min(fullText.length, visibleStart + availableWidth - 1);
-        let visibleText = fullText.substring(visibleStart, visibleEnd);
-        const cursorPosInVisible = cursorIndex - visibleStart;
-        const beforeCursor = visibleText.substring(0, cursorPosInVisible);
-        const afterCursor = visibleText.substring(cursorPosInVisible);
-        const displayValue = beforeCursor + '{inverse} {/}' + afterCursor;
-        commandLine.setContent(displayValue);
-        screen.render();
-    };
-    const handleSubmit = async (value) => {
-        const commandPart = value.startsWith(PROMPT) ? value.slice(PROMPT.length).trim() : value.trim();
-        if (!commandPart) {
-            return;
-        }
-        // Add to history
-        commandHistory.push(commandPart);
-        if (commandHistory.length > 100) {
-            commandHistory.shift();
-        }
-        historyIndex = -1;
-        // Clear input
-        commandInputValue = PROMPT;
-        cursorPosition = PROMPT.length;
-        scrollOffset = 0;
-        updateDisplay();
-        // Emit command event
-        eventBus.emit({
-            tag: 'CMD',
-            msg: commandPart,
-            level: 'INFO'
-        });
-        // Execute command
-        const parsed = parse(commandPart);
-        if (!parsed.name)
-            return;
-        const ctx = {};
-        try {
-            const result = await execute(parsed, ctx);
-            // Emit result events
-            for (const event of result.events) {
-                eventBus.emit(event);
-            }
-            // Handle UI state update
-            if (result.uiStateUpdate) {
-                currentUiState = result.uiStateUpdate(currentUiState);
-                const runtime = getUIRuntime();
-                updateAllPanels(runtime.widgets);
-                // CRITICAL: Restore command line focus after command execution
-                // (prevents focus loss after command updates panels)
-                runtime.screen.focused = runtime.widgets.commandLine;
-                runtime.widgets.commandLine.focus();
-                runtime.screen.render();
-            }
-            // Handle actions
-            if (result.action === UiAction.EXIT) {
-                cleanExit(0);
-            }
-            else if (result.action === UiAction.CLEAR_FEED) {
-                feedStore.clear();
-            }
-        }
-        catch (error) {
-            eventBus.emit({
-                tag: 'ERR',
-                msg: `Command error: ${error.message}`,
-                level: 'ERROR'
-            });
-        }
-    };
-    const stdinListener = (data) => {
-        const input = data.toString();
-        if (input === '\x03') { // Ctrl+C
-            cleanExit(0);
-            return;
-        }
-        if (input === '\r' || input === '\n') { // Enter
-            const cmd = commandInputValue.startsWith(PROMPT)
-                ? commandInputValue.slice(PROMPT.length).trim()
-                : commandInputValue.trim();
-            if (cmd) {
-                handleSubmit(commandInputValue).catch(err => {
-                    eventBus.emit({
-                        tag: 'ERR',
-                        msg: `Handler error: ${err.message}`,
-                        level: 'ERROR'
-                    });
-                });
-            }
-            else {
-                commandInputValue = PROMPT;
-                cursorPosition = PROMPT.length;
-                updateDisplay();
-            }
-            return;
-        }
-        if (input === '\x7f' || input === '\x08') { // Backspace
-            if (cursorPosition > PROMPT.length) {
-                commandInputValue = commandInputValue.substring(0, cursorPosition - 1) + commandInputValue.substring(cursorPosition);
-                cursorPosition--;
-                updateDisplay();
-            }
-            return;
-        }
-        if (input === '\x1b[D') { // Left arrow
-            if (cursorPosition > PROMPT.length) {
-                cursorPosition--;
-                updateDisplay();
-            }
-            return;
-        }
-        if (input === '\x1b[C') { // Right arrow
-            if (cursorPosition < commandInputValue.length) {
-                cursorPosition++;
-                updateDisplay();
-            }
-            return;
-        }
-        // Printable characters
-        if (input.length === 1 && input >= ' ' && input <= '~') {
-            commandInputValue = commandInputValue.substring(0, cursorPosition) + input + commandInputValue.substring(cursorPosition);
-            cursorPosition++;
-            updateDisplay();
-        }
-    };
-    process.stdin.on('data', stdinListener);
-    unbindFns.push(() => {
-        process.stdin.removeListener('data', stdinListener);
-    });
-    // CRITICAL: Focus command line and hide cursor on screen (we render cursor manually in command line)
-    // Hide cursor at screen level (blessed will try to show it otherwise)
-    if (screen.program && screen.program.hideCursor) {
-        screen.program.hideCursor();
-    }
-    // Focus command line (this ensures input goes to command line)
-    screen.focused = commandLine;
-    commandLine.focus();
-    // Ensure stdin is properly set up for raw input
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
-        process.stdin.setEncoding('utf8');
-        process.stdin.resume();
-    }
-}
-/**
- * Update all panel content
- *
- * Guard: Skip updates during resize to prevent corruption
- */
-function updateAllPanels(widgets) {
-    // Skip state updates during resize (prevents corruption)
-    if (isResizing) {
-        return;
-    }
-    // Store current focus before updates (in case something steals it)
-    const wasCommandLineFocused = widgets.commandLine && (getUIRuntime()?.screen.focused === widgets.commandLine);
-    updatePanel(widgets.posture, renderPosturePanel(currentUiState.posture));
-    updatePanel(widgets.resources, renderResourcesPanel(currentUiState.resources));
-    updatePanel(widgets.assets, renderAssetsPanel(currentUiState.assets));
-    updateOperationsPanel(widgets.operations);
-    updatePanel(widgets.network, renderNetworkPanel(currentUiState.network));
-    updatePanel(widgets.capabilities, renderCapabilitiesPanel(currentUiState.capabilities));
-    // Update status strip
-    const statusValue = currentUiState.statusStrip;
-    if (isAvailable(statusValue)) {
-        const data = statusValue.value;
-        widgets.statusStrip.setContent(` ${data.left} | ${data.right} `);
-    }
-    else {
-        widgets.statusStrip.setContent(' OFFLINE');
-    }
-    // CRITICAL: Restore command line focus if it was focused (prevents panels from stealing focus)
-    if (wasCommandLineFocused && widgets.commandLine) {
-        const runtime = getUIRuntime();
-        if (runtime) {
-            runtime.screen.focused = widgets.commandLine;
-            widgets.commandLine.focus();
-        }
-    }
-}
-/**
- * Update a panel with content lines
- *
- * Fix: Clear panel content before writing to prevent vertical artifacts
- */
-function updatePanel(panel, lines) {
-    const panelWidth = panel.width;
-    const panelHeight = panel.height;
-    const innerWidth = Math.max(1, panelWidth - 4);
-    const innerHeight = Math.max(1, panelHeight - 2);
-    // Clear panel content first (prevent vertical artifacts)
-    // Fill with blank lines to ensure old content is overwritten
-    const blankLines = [];
-    for (let i = 0; i < innerHeight; i++) {
-        blankLines.push(' '.repeat(innerWidth));
-    }
-    const clearedContent = '\n ' + blankLines.join('\n ');
-    panel.setContent(clearedContent);
-    // Now set actual content
-    const truncatedLines = lines.slice(0, innerHeight).map(line => {
-        if (line.length > innerWidth) {
-            return line.substring(0, innerWidth - 3) + '...';
-        }
-        // Pad with spaces to full width (ensures old content is overwritten)
-        return line.padEnd(innerWidth, ' ');
-    });
-    const content = '\n ' + truncatedLines.join('\n ');
-    panel.setContent(content);
-}
-/**
- * Get Resize Truth Panel line (single line status)
- */
-function getResizeTruthLine() {
-    const runtime = getUIRuntime();
-    if (!runtime)
-        return 'RESIZE: runtime not available';
-    const screen = runtime.screen;
-    const stdoutCols = process.stdout.columns ?? 'N/A';
-    const stdoutRows = process.stdout.rows ?? 'N/A';
-    const screenWidth = screen.width ?? 'N/A';
-    const screenHeight = screen.height ?? 'N/A';
-    const programCols = screen.program?.cols ?? 'N/A';
-    const programRows = screen.program?.rows ?? 'N/A';
-    const geo = getTerminalGeometry(screen);
-    const resizeEventTime = lastResizeEventAt ? new Date(lastResizeEventAt).toLocaleTimeString() : 'never';
-    const layoutTime = layoutAppliedAt ? new Date(layoutAppliedAt).toLocaleTimeString() : 'never';
-    const layoutDims = lastLayoutCols !== null && lastLayoutRows !== null
-        ? `${lastLayoutCols}x${lastLayoutRows}`
-        : 'none';
-    // Format: single line with key metrics
-    return `RESIZE: stdout=${stdoutCols}x${stdoutRows} screen=${screenWidth}x${screenHeight} program=${programCols}x${programRows} | ` +
-        `used=${geo.cols}x${geo.rows}(${geo.source}) layout=${layoutDims} | ` +
-        `event=${resizeEventTime} applied=${layoutTime}`;
-}
-/**
- * Update operations panel
- *
- * Fix: Clear panel content before writing to prevent vertical artifacts
- * Adds: Resize Truth Panel line at top when in debug mode
- */
-function updateOperationsPanel(panel) {
-    const panelHeight = panel.height;
-    const panelWidth = panel.width;
-    const innerHeight = Math.max(1, panelHeight - 2);
-    const innerWidth = Math.max(1, panelWidth - 2);
-    // Clear panel content first (prevent vertical artifacts)
-    const blankLines = [];
-    for (let i = 0; i < innerHeight; i++) {
-        blankLines.push(' '.repeat(innerWidth));
-    }
-    const clearedContent = '\n ' + blankLines.join('\n ');
-    panel.setContent(clearedContent);
-    const lines = [];
-    // Add layout overlay if enabled (live instrumentation)
-    if (layoutOverlayEnabled && lastComputedLayout) {
-        const runtime = getUIRuntime();
-        const screen = runtime.screen;
-        const geo = getTerminalGeometry(screen);
-        // Line 1: Terminal dimensions (both sources)
-        const line1 = `TERM: scr=${screen.width}x${screen.height} out=${process.stdout.columns ?? 'N/A'}x${process.stdout.rows ?? 'N/A'}`;
-        lines.push(line1.substring(0, innerWidth).padEnd(innerWidth, ' '));
-        // Line 2: Layout widths
-        const leftW = lastComputedLayout.posture.width;
-        const centerW = lastComputedLayout.operations.width;
-        const rightW = lastComputedLayout.network.width;
-        const totalW = leftW + centerW + rightW + 4; // +4 for gutters
-        const line2 = `LAYOUT: L=${leftW} C=${centerW} R=${rightW} tot=${totalW} safe=${geo.safeCols}`;
-        lines.push(line2.substring(0, innerWidth).padEnd(innerWidth, ' '));
-        // Line 3: Resize stats
-        const line3 = `RESIZE: cnt=${resizeApplyCount} mode=${geo.mode}`;
-        lines.push(line3.substring(0, innerWidth).padEnd(innerWidth, ' '));
-        // Separator
-        lines.push('─'.repeat(innerWidth));
-    }
-    // Now set actual content (events)
-    const availableLines = innerHeight - lines.length;
-    const events = feedStore.getLatest(availableLines);
-    if (events.length === 0 && lines.length === 0) {
-        lines.push('No operations yet'.padEnd(innerWidth, ' '));
-    }
-    else {
-        for (const event of events.slice(-availableLines)) {
-            const time = new Date(event.ts).toLocaleTimeString();
-            const line = `${time} [${event.tag}] ${event.msg}`;
-            if (line.length > innerWidth) {
-                lines.push(line.substring(0, innerWidth - 3) + '...');
-            }
-            else {
-                // Pad with spaces to full width
-                lines.push(line.padEnd(innerWidth, ' '));
-            }
-        }
-    }
-    const content = '\n ' + lines.join('\n ');
-    panel.setContent(content);
-}
-/**
- * Start background state updates
- *
- * Guard: Skip updates during resize to prevent corruption
- */
-function startBackgroundUpdates(widgets, screen) {
-    const interval = setInterval(async () => {
-        try {
-            // Skip state updates during resize (prevents corruption)
-            if (isResizing) {
-                return;
-            }
-            const newState = await buildUiState(currentUiState);
-            currentUiState = newState;
-            updateAllPanels(widgets);
-            // CRITICAL: Restore command line focus after background updates
-            // (prevents focus from being lost during background panel updates)
-            // Hide cursor at screen level
-            if (screen.program && screen.program.hideCursor) {
-                screen.program.hideCursor();
-            }
-            // Ensure stdin is active
-            if (process.stdin.isTTY && process.stdin.isPaused()) {
-                process.stdin.resume();
-            }
-            screen.focused = widgets.commandLine;
-            widgets.commandLine.focus();
-            screen.render();
-        }
-        catch (error) {
-            // Ignore errors
-        }
-    }, 1500);
-    const runtime = getUIRuntime();
-    runtime.unbindFns.push(() => clearInterval(interval));
-}
-/**
- * Export layout dump for debug commands
- */
-export function dumpLayout() {
-    const runtime = getUIRuntime();
-    const widgets = runtime.widgets;
-    const screen = runtime.screen;
-    const geo = getTerminalGeometry(screen);
-    // Recompute layout to see calculations - use screen dimensions directly
-    const screenCols = screen.cols ?? screen.width ?? geo.cols;
-    const screenRows = screen.rows ?? screen.height ?? geo.rows;
-    const layoutResult = computePhase1Layout(screenCols, screenRows, screen);
-    const lines = [];
-    lines.push(`=== COMPREHENSIVE LAYOUT DEBUG ===`);
-    lines.push(``);
-    // Terminal geometry - ALL dimension sources
-    lines.push(`--- TERMINAL DIMENSIONS (ALL SOURCES) ---`);
-    lines.push(`screen.width: ${screen.width ?? 'N/A'}`);
-    lines.push(`screen.height: ${screen.height ?? 'N/A'}`);
-    lines.push(`screen.cols: ${screen.cols ?? 'N/A'}`);
-    lines.push(`screen.rows: ${screen.rows ?? 'N/A'}`);
-    lines.push(`screen.program.cols: ${screen.program?.cols ?? 'N/A'}`);
-    lines.push(`screen.program.rows: ${screen.program?.rows ?? 'N/A'}`);
-    lines.push(`process.stdout.columns: ${process.stdout.columns ?? 'N/A'}`);
-    lines.push(`process.stdout.rows: ${process.stdout.rows ?? 'N/A'}`);
-    lines.push(`process.stderr.columns: ${process.stderr.columns ?? 'N/A'}`);
-    lines.push(`process.stderr.rows: ${process.stderr.rows ?? 'N/A'}`);
-    lines.push(``);
-    lines.push(`--- GEOMETRY SOURCE OF TRUTH ---`);
-    lines.push(`Used source: ${geo.source}`);
-    lines.push(`Raw terminal: ${geo.cols} cols x ${geo.rows} rows`);
-    lines.push(`Safe terminal: ${geo.safeCols} cols x ${geo.safeRows} rows`);
-    lines.push(`Mode: ${geo.mode}`);
-    lines.push(`Last applied size: ${lastAppliedSize ? `${lastAppliedSize.cols}x${lastAppliedSize.rows}` : 'none'}`);
-    // Dimension mismatch warnings
-    const programCols = screen.program?.cols;
-    const programRows = screen.program?.rows;
-    const stdoutCols = process.stdout.columns;
-    const stdoutRows = process.stdout.rows;
-    if (programCols && stdoutCols && programCols !== stdoutCols) {
-        lines.push(`⚠ WARNING: screen.program.cols (${programCols}) !== process.stdout.columns (${stdoutCols})`);
-    }
-    if (programRows && stdoutRows && programRows !== stdoutRows) {
-        lines.push(`⚠ WARNING: screen.program.rows (${programRows}) !== process.stdout.rows (${stdoutRows})`);
-    }
-    lines.push(``);
-    // Layout calculations (if available)
-    if (layoutResult.ok && layoutResult.layout) {
-        const layout = layoutResult.layout;
-        const GUTTER = 1;
-        const COMMAND_LINE_HEIGHT = 3;
-        const totalGutters = GUTTER * 2;
-        const availableWidth = geo.safeCols - totalGutters;
-        const contentHeight = geo.safeRows - COMMAND_LINE_HEIGHT - GUTTER;
-        lines.push(`--- LAYOUT CALCULATIONS ---`);
-        lines.push(`Available width: ${geo.safeCols} - ${totalGutters} gutters = ${availableWidth}`);
-        lines.push(`Available height: ${geo.safeRows} - ${COMMAND_LINE_HEIGHT} cmd - ${GUTTER} gutter = ${contentHeight}`);
-        lines.push(``);
-        lines.push(`Column widths:`);
-        lines.push(`  Left: ${layout.posture.width} (22% min 28)`);
-        lines.push(`  Center: ${layout.operations.width} (50%)`);
-        lines.push(`  Right: ${layout.network.width} (remainder)`);
-        lines.push(`  Total columns: ${layout.posture.width + layout.operations.width + layout.network.width}`);
-        lines.push(`  Total with gutters: ${layout.posture.width + layout.operations.width + layout.network.width + totalGutters}`);
-        lines.push(``);
-        // Calculate right edge
-        const rightColLeft = layout.posture.width + GUTTER + layout.operations.width + GUTTER;
-        const rightColRight = rightColLeft + layout.network.width;
-        const commandLineRight = layout.commandLine.left + layout.commandLine.width;
-        lines.push(`Position analysis:`);
-        lines.push(`  Right column left: ${rightColLeft}`);
-        lines.push(`  Right column right: ${rightColRight}`);
-        lines.push(`  Command line right: ${commandLineRight}`);
-        lines.push(`  Terminal safeCols: ${geo.safeCols}`);
-        lines.push(`  Terminal raw cols: ${geo.cols}`);
-        lines.push(`  Gap on right: ${geo.safeCols - rightColRight} chars`);
-        lines.push(`  Command line gap: ${geo.safeCols - commandLineRight} chars`);
-        lines.push(``);
-        lines.push(`Height analysis:`);
-        lines.push(`  Content height: ${contentHeight}`);
-        lines.push(`  Operations height: ${layout.operations.height}`);
-        lines.push(`  Command line top: ${layout.commandLine.top}`);
-        lines.push(`  Command line bottom: ${layout.commandLine.top + layout.commandLine.height}`);
-        lines.push(`  Terminal safeRows: ${geo.safeRows}`);
-        lines.push(`  Terminal raw rows: ${geo.rows}`);
-        lines.push(`  Gap on bottom: ${geo.safeRows - (layout.commandLine.top + layout.commandLine.height)} rows`);
-        lines.push(``);
-    }
-    else {
-        lines.push(`⚠ Layout computation failed: ${layoutResult.errorMessage}`);
-        lines.push(``);
-    }
-    // Actual widget positions
-    lines.push(`--- ACTUAL WIDGET POSITIONS ---`);
-    const panels = [
-        { name: 'POSTURE', widget: widgets.posture },
-        { name: 'RESOURCES', widget: widgets.resources },
-        { name: 'ASSETS', widget: widgets.assets },
-        { name: 'OPERATIONS', widget: widgets.operations },
-        { name: 'NETWORK', widget: widgets.network },
-        { name: 'CAPABILITIES', widget: widgets.capabilities },
-        { name: 'STATUS_STRIP', widget: widgets.statusStrip },
-        { name: 'COMMAND_LINE', widget: widgets.commandLine },
-    ];
-    let maxRight = 0;
-    let maxBottom = 0;
-    for (const { name, widget } of panels) {
-        const top = widget.top;
-        const left = widget.left;
-        const width = widget.width;
-        const height = widget.height;
-        const right = left + width;
-        const bottom = top + height;
-        maxRight = Math.max(maxRight, right);
-        maxBottom = Math.max(maxBottom, bottom);
-        lines.push(`${name}:`);
-        lines.push(`  position: (${left}, ${top})`);
-        lines.push(`  size: ${width}w x ${height}h`);
-        lines.push(`  bounds: left=${left} right=${right} top=${top} bottom=${bottom}`);
-        lines.push(`  right edge: ${right} (terminal safeCols: ${geo.safeCols}, raw cols: ${geo.cols})`);
-        lines.push(`  bottom edge: ${bottom} (terminal safeRows: ${geo.safeRows}, raw rows: ${geo.rows})`);
-        // Check for overflow (right edge must be <= cols - 1)
-        const maxRightEdge = geo.safeCols - 1;
-        if (right > maxRightEdge) {
-            lines.push(`  ⚠ OVERFLOW: right edge ${right} > ${maxRightEdge} (will cause scrollbar!)`);
-        }
-        lines.push(``);
-    }
-    lines.push(`--- SUMMARY ---`);
-    lines.push(`Max rendered width: ${maxRight} (terminal safeCols: ${geo.safeCols}, raw cols: ${geo.cols})`);
-    lines.push(`Max rendered height: ${maxBottom} (terminal safeRows: ${geo.safeRows}, raw rows: ${geo.rows})`);
-    lines.push(`Unused width: ${geo.safeCols - maxRight} chars (${((geo.safeCols - maxRight) / geo.safeCols * 100).toFixed(1)}%)`);
-    lines.push(`Unused height: ${geo.safeRows - maxBottom} rows (${((geo.safeRows - maxBottom) / geo.safeRows * 100).toFixed(1)}%)`);
-    lines.push(``);
-    // Overflow checks
-    const maxAllowedRight = geo.safeCols - 1;
-    if (maxRight > maxAllowedRight) {
-        lines.push(`⚠ CRITICAL: Layout overflow detected! Max right edge ${maxRight} > ${maxAllowedRight} (will cause horizontal scrollbar)`);
-    }
-    if (maxRight < geo.safeCols - 5) {
-        lines.push(`⚠ WARNING: Significant unused width detected (${geo.safeCols - maxRight} chars)`);
-    }
-    if (maxBottom < geo.safeRows - 5) {
-        lines.push(`⚠ WARNING: Significant unused height detected (${geo.safeRows - maxBottom} rows)`);
-    }
-    // Command line widget state (CRITICAL for input debugging)
-    lines.push(`--- COMMAND LINE WIDGET STATE ---`);
-    const cmd = widgets.commandLine;
-    const cmdLeft = cmd.left;
-    const cmdTop = cmd.top;
-    const cmdWidth = cmd.width;
-    const cmdHeight = cmd.height;
-    const cmdRight = cmdLeft + cmdWidth;
-    const cmdBottom = cmdTop + cmdHeight;
-    lines.push(`Position: left=${cmdLeft} top=${cmdTop} width=${cmdWidth} height=${cmdHeight}`);
-    lines.push(`Bounds: right=${cmdRight} bottom=${cmdBottom}`);
-    lines.push(`hidden: ${cmd.hidden ?? false}`);
-    lines.push(`detached: ${cmd.detached ?? false}`);
-    lines.push(`visible: ${cmd.visible ?? true}`);
-    lines.push(`focusable: ${cmd.focusable ?? false}`);
-    lines.push(`keyable: ${cmd.keyable ?? false}`);
-    lines.push(`input: ${cmd.input ?? false}`);
-    lines.push(`keys: ${cmd.keys ?? false}`);
-    lines.push(`mouse: ${cmd.mouse ?? false}`);
-    lines.push(`inputOnFocus: ${cmd.inputOnFocus ?? false}`);
-    lines.push(``);
-    lines.push(`Focus state:`);
-    lines.push(`  screen.focused === cmd: ${screen.focused === cmd}`);
-    lines.push(`  screen.focused?.type: ${screen.focused?.type ?? 'N/A'}`);
-    lines.push(`  screen.focused?.name: ${screen.focused?.name ?? 'N/A'}`);
-    lines.push(`  screen.focused?.content: ${screen.focused?.content?.substring(0, 20) ?? 'N/A'}...`);
-    lines.push(``);
-    // Check for global key handlers that might swallow input
-    lines.push(`--- KEY HANDLER CHECK ---`);
-    const screenListeners = screen._listeners || {};
-    const keyListeners = screenListeners.keypress || [];
-    const keyBindings = screen._bindings || {};
-    const globalKeyCount = Object.keys(keyBindings).length;
-    lines.push(`Global screen.key() bindings: ${globalKeyCount}`);
-    lines.push(`Global screen.on('keypress') listeners: ${keyListeners.length}`);
-    if (globalKeyCount > 0 || keyListeners.length > 0) {
-        lines.push(`⚠ WARNING: Global key handlers detected - may swallow input!`);
-        if (globalKeyCount > 0) {
-            lines.push(`  Bound keys: ${Object.keys(keyBindings).slice(0, 10).join(', ')}${Object.keys(keyBindings).length > 10 ? '...' : ''}`);
-        }
-    }
-    else {
-        lines.push(`✓ No global key handlers (good - input goes to command line)`);
-    }
-    lines.push(``);
-    // Layout clamp validation
-    lines.push(`--- LAYOUT CLAMP VALIDATION ---`);
-    const cmdMinWidth = 60;
-    const cmdMinHeight = 3;
-    const cmdMaxWidth = geo.safeCols - 4;
-    const cmdMaxHeight = geo.safeRows - 2;
-    if (cmdWidth < cmdMinWidth) {
-        lines.push(`⚠ ERROR: Command line width ${cmdWidth} < minimum ${cmdMinWidth}`);
-    }
-    else {
-        lines.push(`✓ Command line width OK: ${cmdWidth} >= ${cmdMinWidth}`);
-    }
-    if (cmdHeight < cmdMinHeight) {
-        lines.push(`⚠ ERROR: Command line height ${cmdHeight} < minimum ${cmdMinHeight}`);
-    }
-    else {
-        lines.push(`✓ Command line height OK: ${cmdHeight} >= ${cmdMinHeight}`);
-    }
-    if (cmdRight > geo.safeCols) {
-        lines.push(`⚠ ERROR: Command line right edge ${cmdRight} > terminal cols ${geo.safeCols}`);
-    }
-    else {
-        lines.push(`✓ Command line right edge OK: ${cmdRight} <= ${geo.safeCols}`);
-    }
-    if (cmdBottom > geo.safeRows) {
-        lines.push(`⚠ ERROR: Command line bottom edge ${cmdBottom} > terminal rows ${geo.safeRows}`);
-    }
-    else {
-        lines.push(`✓ Command line bottom edge OK: ${cmdBottom} <= ${geo.safeRows}`);
-    }
-    lines.push(``);
-    lines.push(`=== END LAYOUT DEBUG ===`);
-    // Limit output to prevent hang/spam (max 50 lines for comprehensive debug)
-    const MAX_DEBUG_LINES = 50;
-    if (lines.length > MAX_DEBUG_LINES) {
-        return [
-            ...lines.slice(0, MAX_DEBUG_LINES - 2),
-            `... (${lines.length - MAX_DEBUG_LINES} more lines truncated) ...`,
-            lines[lines.length - 1]
-        ];
-    }
-    return lines;
-}
-/**
- * Step 4: Clean exit
- */
-function cleanExit(code) {
-    destroyUIRuntime();
-    // Restore terminal
-    if (process.stdout.isTTY) {
-        process.stdout.write('\x1b[?25h'); // Show cursor
-        process.stdout.write('\x1b[?1049l'); // Exit alternate screen
-    }
-    process.exit(code);
-}
-//# sourceMappingURL=phase1RuntimeClean.js.map