4runr-os 2.1.4 → 2.1.6

package/dist/ui/v3/ui/phase1Runtime.js

@@ -1,1648 +0,0 @@
-/**
- * Phase 1 Runtime
- *
- * Layout skeleton + dedicated command line
- * - 6 read-only panels
- * - 1 command line (only writable area)
- * - Focus locked to command line
- *
- * Phase 2: Command Router
- * - Command parsing and routing
- * - Output to OPERATIONS FEED panel
- *
- * Phase 3: Operations Feed as Only Output Channel
- * - EventBus system
- * - All output goes through EventBus → feedStore
- * - Long line truncation
- */
-import blessed from 'neo-blessed';
-// Type assertion for blessed (textbox not in types)
-const blessedLib = blessed;
-import { computePhase1Layout } from './layout/phase1Layout.js';
-import { feedStore } from '../core/feedStore.js';
-import { eventBus } from '../core/eventBus.js';
-import { logger, enableTuiMode, disableBootPhase } from '../core/logger.js';
-import { parse, execute, UiAction } from '../commands/commandEngine.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, isUnavailable, isLoading, available, loading } from '../state/value.js';
-import { assertUiState } from '../state/assertUiState.js';
-// Step 1: Boot ID and render count tracking
-// Phase A: UI Layout Fingerprint
-const UI_ROOT_ID = `ui-root-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-const BOOT_ID = `boot-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-const UI_INSTANCE_ID = `ui-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`; // Debug: Track UI instance
-let renderCount = 0;
-let uiInstance = null;
-const DEBUG_LAYOUT = process.env.TUI_DEBUG_LAYOUT === '1';
-// CRITICAL: Hard singleton guard - screen can only be created ONCE
-let screenCreated = false;
-let screenCreationCount = 0; // Debug: Track screen creation count
-let screen = null;
-let panels = [];
-let commandLine = null;
-let statusStrip = null;
-let isCleaningUp = false;
-// CRITICAL: Guard to prevent widgets from being appended multiple times
-let widgetsAppended = false;
-// CRITICAL: Guard to prevent panels from being created multiple times
-let panelsCreated = false;
-const PROMPT = '4runr> '; // Non-editable prompt prefix
-let currentCommandValue = PROMPT; // Track current command value
-// STEP 2: Initialize posture state before first render (prevents flicker)
-const initialPostureState = initializePostureState();
-const initializedDefaultState = {
-    ...defaultUiState,
-    posture: initialPostureState
-};
-// Section 4: Current UiState (initialized with defaultUiState - all UNAVAILABLE)
-let currentUiState = initializedDefaultState;
-let lastResourcesAvailable = null; // Phase 4: Track state transitions
-// CRITICAL: Guard to prevent duplicate handler binding
-let inputHandlersBound = false;
-// Part A: Resize tracking (no longer handling resize, just tracking for warning)
-let lastResizeWidth = 0;
-let lastResizeHeight = 0;
-let uiModeState = 'HUB';
-// S0.4: Command history
-const commandHistory = [];
-let historyIndex = -1; // -1 means not browsing history
-/**
- * S0.1 & S0.4: Reassert focus on command line
- * Called after every render and command execution
- */
-function reassertFocus() {
-    if (commandLine && screen) {
-        commandLine.focus();
-        screen.focused = commandLine;
-    }
-}
-/**
- * Cleanup and exit
- */
-/**
- * Panel-safe line formatter (used ONLY at render time)
- *
- * HARDENED: Explicit width truncation with validation
- *
- * Truncates lines based on panel's inner width.
- * Never truncates when storing events - only at render time.
- *
- * Rules:
- * - If line fits → render as-is
- * - If line too long → truncate to fit and append ...
- * - Never overflow outside the border
- * - Explicit validation of width constraints
- */
-function formatLineForPanel(time, tag, msg, availableWidth) {
-    // HARDENED: Validate availableWidth (must be positive)
-    if (availableWidth <= 0) {
-        return '[ERR]'; // Fallback for invalid width
-    }
-    // Calculate prefix width: "HH:MM:SS  [TAG]  " = time + spaces + brackets + tag + spaces
-    const prefix = `${time}  [${tag}]  `;
-    const prefixWidth = prefix.length;
-    // HARDENED: Ensure prefix doesn't exceed available width
-    if (prefixWidth >= availableWidth) {
-        // Prefix itself is too long - truncate prefix
-        const truncatedPrefix = prefix.substring(0, Math.max(0, availableWidth - 3)) + '...';
-        return truncatedPrefix;
-    }
-    // Available width for message portion
-    const msgWidth = availableWidth - prefixWidth;
-    // HARDENED: Ensure msgWidth is positive
-    if (msgWidth <= 0) {
-        return prefix; // No room for message
-    }
-    // If message fits, return as-is
-    if (msg.length <= msgWidth) {
-        return prefix + msg;
-    }
-    // HARDENED: Explicit truncation with validation
-    // Reserve 3 chars for "..."
-    const truncateAt = Math.max(0, msgWidth - 3);
-    const truncatedMsg = msg.substring(0, truncateAt) + '...';
-    // HARDENED: Final validation - ensure result doesn't exceed availableWidth
-    const result = prefix + truncatedMsg;
-    if (result.length > availableWidth) {
-        // Emergency truncation (should never happen, but safety check)
-        return result.substring(0, availableWidth);
-    }
-    return result;
-}
-/**
- * Section 2: Update operations panel with latest feed entries
- *
- * HARDENED: Explicit max-line enforcement with validation
- *
- * Rules:
- * - Line-budget enforcement: only render last N visible lines (N = box.height - 2)
- * - Panel-safe line formatter: truncate at render time only
- * - Never wrap, never overflow
- * - Explicit validation of line count
- *
- * Empty State Behavior (INTENTIONAL):
- * - When feed is empty (e.g., after CLEAR_FEED action), displays "No operations yet"
- * - This is the Operations renderer's fallback message, NOT an event from clear command
- * - clear command emits no events (returns empty events array)
- * - Message appears once per render, does not duplicate, does not reappear on resize
- * - This is stable and intentional behavior
- */
-function updateOperationsPanel() {
-    const operationsPanel = panels[3]; // OPERATIONS is 4th panel (index 3)
-    if (!operationsPanel)
-        return;
-    // HARDENED: Calculate available space with validation
-    const panelHeight = operationsPanel.height;
-    const panelWidth = operationsPanel.width;
-    // Validate panel dimensions
-    if (panelHeight < 3 || panelWidth < 5) {
-        // Panel too small - set minimal content
-        operationsPanel.setContent('\n [ERR: Panel too small]');
-        return;
-    }
-    // Calculate available space (account for border only)
-    const innerHeight = panelHeight - 2; // Top and bottom border
-    const innerWidth = panelWidth - 2; // Left and right border only (no padding)
-    // HARDENED: Validate inner dimensions
-    if (innerHeight <= 0 || innerWidth <= 0) {
-        operationsPanel.setContent('\n [ERR: Invalid dimensions]');
-        return;
-    }
-    // HARDENED: Explicit max-line enforcement with validation
-    // Line-budget enforcement: only render last N visible lines
-    const maxLines = Math.max(1, Math.floor(innerHeight)); // At least 1 line, floor to ensure integer
-    // HARDENED: Cap maxLines to prevent excessive rendering
-    const MAX_ALLOWED_LINES = 100; // Safety cap
-    const enforcedMaxLines = Math.min(maxLines, MAX_ALLOWED_LINES);
-    // Get events (get slightly more than needed, but enforce limit in rendering)
-    const events = feedStore.getLatest(enforcedMaxLines * 2); // Get more than needed for safety
-    // Format lines with panel-safe formatter
-    const lines = [];
-    // INTENTIONAL: Display fallback message when feed is empty
-    // This appears after CLEAR_FEED action (clear command emits no events)
-    // This is the Operations renderer's fallback - not an event from clear command
-    // Behavior is stable: message appears once, does not duplicate on render, does not reappear on resize
-    if (events.length === 0) {
-        lines.push('No operations yet');
-    }
-    else {
-        // HARDENED: Explicitly enforce max lines - only render the last enforcedMaxLines events
-        const eventsToRender = events.slice(-enforcedMaxLines);
-        // HARDENED: Final validation - ensure we don't exceed enforcedMaxLines
-        if (eventsToRender.length > enforcedMaxLines) {
-            // Safety check - should never happen, but enforce limit
-            eventsToRender.splice(0, eventsToRender.length - enforcedMaxLines);
-        }
-        for (const event of eventsToRender) {
-            const time = formatTimestamp(event.ts);
-            const line = formatLineForPanel(time, event.tag, event.msg, innerWidth);
-            lines.push(line);
-        }
-    }
-    // HARDENED: Final line count validation
-    if (lines.length > enforcedMaxLines) {
-        // Emergency truncation (should never happen)
-        lines.splice(0, lines.length - enforcedMaxLines);
-    }
-    // Join with newlines, add minimal padding
-    const paddingLeft = ' ';
-    const content = lines
-        .map(line => paddingLeft + line)
-        .join('\n');
-    operationsPanel.setContent('\n' + content);
-}
-/**
- * Section 4: Update panel content helper
- *
- * Generic function to update any panel with Value<T> content
- * Handles truncation and padding consistently
- */
-function updatePanelContent(panel, contentLines) {
-    if (!panel)
-        return;
-    const paddingTop = '\n';
-    const paddingLeft = ' ';
-    // CRITICAL: Validate and filter contentLines
-    // Ensure all lines are strings and filter out empty/null/undefined
-    const validLines = contentLines
-        .filter((line) => typeof line === 'string' && line !== null && line !== undefined)
-        .map(line => String(line)); // Ensure string type
-    // Phase C: Explicit grid math - account for borders
-    // Blessed box: 1 char border on each side (left/right/top/bottom)
-    // Inner content area = width - 2 (left + right border) - 2 (left padding only, we add it back)
-    const panelWidth = panel.width;
-    const panelHeight = panel.height;
-    const innerHeight = Math.max(1, panelHeight - 2); // Top and bottom border, min 1
-    const innerWidth = Math.max(1, panelWidth - 2 - 2); // Border (2) + left padding space (2 for safety), min 1
-    // Truncate to fit panel height
-    const displayLines = validLines.slice(0, Math.min(validLines.length, innerHeight));
-    // Truncate each line to fit width
-    const truncatedLines = displayLines.map(line => {
-        return safeLine(line, innerWidth);
-    });
-    // Pad to fill available height if needed
-    while (truncatedLines.length < innerHeight) {
-        truncatedLines.push('');
-    }
-    // Phase E: Layout Debug Overlay - append debug info if enabled
-    if (DEBUG_LAYOUT && panel._debugInfo) {
-        const debug = panel._debugInfo;
-        truncatedLines.push(''); // Empty line separator
-        truncatedLines.push(`w=${debug.w} h=${debug.h}`);
-        truncatedLines.push(`x=${debug.x} y=${debug.y}`);
-        truncatedLines.push(`term=${debug.terminalCols}x${debug.terminalRows}`);
-    }
-    // CRITICAL: Clear old content first, then set new content
-    // This prevents appending/concatenation issues
-    const content = truncatedLines
-        .map(line => paddingLeft + line)
-        .join('\n');
-    // Clear and set content atomically
-    panel.setContent(paddingTop + content);
-}
-/**
- * Section 4: Update posture panel content
- *
- * Updates text in-place without recreating widget (no flicker)
- * No blank panels - always shows AVAILABLE or UNAVAILABLE/UNKNOWN with reason
- */
-function updatePosturePanel() {
-    const posturePanel = panels[0]; // POSTURE is 1st panel (index 0)
-    if (!currentUiState)
-        return;
-    const contentLines = renderPosturePanel(currentUiState.posture);
-    updatePanelContent(posturePanel, contentLines);
-}
-/**
- * Section 4: Update resources panel content
- *
- * Updates text in-place without recreating widget (no flicker)
- * No blank panels - always shows AVAILABLE or UNAVAILABLE/UNKNOWN with reason
- */
-function updateResourcesPanel() {
-    const resourcesPanel = panels[1]; // RESOURCES is 2nd panel (index 1)
-    if (!currentUiState)
-        return;
-    const contentLines = renderResourcesPanel(currentUiState.resources);
-    updatePanelContent(resourcesPanel, contentLines);
-}
-/**
- * Section 4: Update assets panel content
- *
- * Updates text in-place without recreating widget (no flicker)
- * No blank panels - always shows AVAILABLE or UNAVAILABLE/UNKNOWN with reason
- */
-function updateAssetsPanel() {
-    const assetsPanel = panels[2]; // ASSETS is 3rd panel (index 2)
-    if (!currentUiState)
-        return;
-    const contentLines = renderAssetsPanel(currentUiState.assets);
-    updatePanelContent(assetsPanel, contentLines);
-}
-/**
- * Section 4: Update network panel content
- *
- * Updates text in-place without recreating widget (no flicker)
- * No blank panels - always shows AVAILABLE or UNAVAILABLE/UNKNOWN with reason
- */
-function updateNetworkPanel() {
-    const networkPanel = panels[4]; // NETWORK is 5th panel (index 4)
-    if (!currentUiState)
-        return;
-    const contentLines = renderNetworkPanel(currentUiState.network);
-    updatePanelContent(networkPanel, contentLines);
-}
-/**
- * Section 4: Update capabilities panel content
- *
- * Updates text in-place without recreating widget (no flicker)
- * No blank panels - always shows AVAILABLE or UNAVAILABLE/UNKNOWN with reason
- */
-function updateCapabilitiesPanel() {
-    const capabilitiesPanel = panels[5]; // CAPABILITIES is 6th panel (index 5)
-    if (!currentUiState)
-        return;
-    const contentLines = renderCapabilitiesPanel(currentUiState.capabilities);
-    updatePanelContent(capabilitiesPanel, contentLines);
-}
-/**
- * Section 4: Update status strip content
- *
- * Updates status strip with Value<StatusStripState>
- * No blank status - always shows AVAILABLE or UNAVAILABLE/UNKNOWN with reason
- */
-function updateStatusStrip() {
-    if (!statusStrip || !currentUiState)
-        return;
-    const statusValue = currentUiState.statusStrip;
-    if (isAvailable(statusValue)) {
-        const data = statusValue.value;
-        const content = ` ${data.left} | ${data.right} `;
-        statusStrip.setContent(content);
-    }
-    else {
-        // UNAVAILABLE or UNKNOWN - show reason
-        const reason = statusValue.reason || 'Not initialized';
-        const nextAction = ('nextAction' in statusValue ? statusValue.nextAction : undefined) || 'Run "help"';
-        const content = ` ${statusValue.availability}: ${reason} | Next: ${nextAction} `;
-        statusStrip.setContent(content);
-    }
-}
-/**
- * Step 6: Cleanup and exit with proper unmount
- */
-function cleanupAndExit(code = 0) {
-    // Step 6: Call unmount if UI instance exists
-    if (uiInstance) {
-        uiInstance.unmount();
-    }
-    // Fallback cleanup if unmount didn't run
-    // Clean up prompt protection interval if it exists
-    if (commandLine && commandLine._promptProtectionInterval) {
-        clearInterval(commandLine._promptProtectionInterval);
-    }
-    if (isCleaningUp)
-        return;
-    isCleaningUp = true;
-    // Clear render interval
-    if (screen && screen.renderInterval) {
-        clearInterval(screen.renderInterval);
-    }
-    if (screen) {
-        try {
-            screen.destroy();
-        }
-        catch (e) {
-            // Ignore destroy errors
-        }
-        screen = null;
-    }
-    // Restore terminal state
-    if (process.stdout.isTTY) {
-        process.stdout.write('\x1b[?25h'); // Show cursor
-        process.stdout.write('\x1b[?1049l'); // Exit alternate screen
-    }
-    process.exit(code);
-}
-/**
- * Create a read-only panel
- *
- * Phase B: Single PanelFrame - exactly one border per panel
- * Phase C: Explicit width/height - no flex guessing
- * Phase E: Debug overlay support
- */
-function createPanel(screen, boxRect, title, getContent) {
-    const isOperations = title === 'OPERATIONS';
-    // Phase C: Explicit grid math - ensure width accounts for borders
-    // Blessed box borders take 2 chars (1 left + 1 right), so inner width = width - 2
-    // But we pass the full width to blessed, it handles borders internally
-    const explicitWidth = Math.max(3, boxRect.width); // Min 3 to fit border + 1 char
-    const explicitHeight = Math.max(3, boxRect.height); // Min 3 to fit border + 1 char
-    const panel = blessedLib.box({
-        top: boxRect.top,
-        left: boxRect.left,
-        width: explicitWidth,
-        height: explicitHeight,
-        // Phase B: Single border - only the box itself draws borders, no parent containers
-        border: {
-            type: 'line',
-        },
-        tags: true,
-        content: '', // Will be updated if getContent is provided
-        style: {
-            border: {
-                fg: 'cyan',
-            },
-        },
-        // Force no-wrap overflow OFF (or wrap ON) on Operations widget
-        // For "intel console" vibe: truncate on hub (no wrap)
-        wrap: false, // No wrapping - we manually truncate
-        scrollable: false, // No scrolling - we enforce line-budget
-        alwaysScroll: false,
-        // Make panel read-only and non-focusable - CRITICAL
-        clickable: false,
-        keys: false,
-        mouse: false,
-        input: false,
-        keyable: false,
-        focusable: false,
-        // Prevent any interaction
-        interactive: false,
-    });
-    // Phase B: Set title in top border (only once, no parent containers add titles)
-    panel.setLabel(` {cyan-fg}${title.toUpperCase()}{/}`);
-    // Phase E: Layout Debug Overlay
-    if (DEBUG_LAYOUT) {
-        // Store debug info on panel
-        panel._debugInfo = {
-            title,
-            w: explicitWidth,
-            h: explicitHeight,
-            x: boxRect.left,
-            y: boxRect.top,
-            terminalCols: screen.width,
-            terminalRows: screen.height,
-        };
-    }
-    // Store content getter for updates
-    if (getContent) {
-        panel.getContent = getContent;
-    }
-    return panel;
-}
-/**
- * Truncate line to fit width (Phase 3)
- *
- * Rules:
- * - If text.length <= width, return as-is
- * - Else return text.slice(0, width - 1) + "…"
- */
-// Old truncateLine removed - using safeLine instead (defined above)
-/**
- * Section 2: Format feed entries for display in OPERATIONS panel
- *
- * Line format: HH:MM:SS  [TAG]  message...
- */
-function formatTimestamp(ts) {
-    try {
-        const date = new Date(ts);
-        const hours = date.getHours().toString().padStart(2, '0');
-        const minutes = date.getMinutes().toString().padStart(2, '0');
-        const seconds = date.getSeconds().toString().padStart(2, '0');
-        return `${hours}:${minutes}:${seconds}`;
-    }
-    catch {
-        return '00:00:00';
-    }
-}
-/**
- * Safe line truncation helper
- * Strips newlines/tabs, truncates to max width, appends ...
- * FIXED: Prevents text corruption by ensuring valid width and proper truncation
- */
-function safeLine(line, max) {
-    // Validate max width
-    if (max <= 0) {
-        return '';
-    }
-    // Ensure line is a string
-    if (typeof line !== 'string') {
-        line = String(line);
-    }
-    // Strip newlines and tabs, replace with spaces
-    // Also collapse multiple spaces into one
-    let cleaned = line.replace(/[\n\r\t]/g, ' ').replace(/\s+/g, ' ').trim();
-    // Truncate if exceeds max width
-    if (cleaned.length > max) {
-        // Reserve 3 chars for "..."
-        const truncateAt = Math.max(0, max - 3);
-        if (truncateAt > 0) {
-            cleaned = cleaned.substring(0, truncateAt) + '...';
-        }
-        else {
-            // If max is too small, just return "..."
-            cleaned = '...';
-        }
-    }
-    return cleaned;
-}
-/**
- * Format feed entries for display in OPERATIONS panel
- * NOTE: This function is deprecated - use updateOperationsPanel() directly
- * which uses formatLineForPanel() for proper truncation
- */
-function formatFeedEntries(maxLines = 15) {
-    const events = feedStore.getLatest(maxLines);
-    const lines = [];
-    if (events.length === 0) {
-        lines.push('No operations yet');
-    }
-    else {
-        for (const event of events) {
-            const time = formatTimestamp(event.ts);
-            // Don't truncate here - truncation happens in updateOperationsPanel()
-            const line = `${time}  [${event.tag}]  ${event.msg}`;
-            lines.push(line);
-        }
-    }
-    return lines;
-}
-// CRITICAL: Guard to prevent multiple runtime instances
-let runtimeStarted = false;
-// Section 2: Render queue system (prevents render storms)
-let renderQueued = false;
-let renderScheduled = false;
-/**
- * Section 2: Request render (batches multiple render requests)
- * If render already queued, do nothing.
- * Uses setImmediate to batch renders.
- */
-function requestRender() {
-    if (renderQueued) {
-        return; // Already queued, skip
-    }
-    renderQueued = true;
-    if (!renderScheduled) {
-        renderScheduled = true;
-        setImmediate(() => {
-            renderQueued = false;
-            renderScheduled = false;
-            if (screen) {
-                // Step 1: Track render count (only log every 1000 renders for debugging)
-                renderCount++;
-                if (renderCount % 1000 === 0) {
-                    logger.debug(`render() call #${renderCount} (bootId=${BOOT_ID})`);
-                }
-                updateOperationsPanel();
-                screen.render();
-            }
-        });
-    }
-}
-/**
- * Start Phase 1 runtime
- */
-/**
- * Step 3: Hard guard to prevent double mounting
- */
-/**
- * Step 6: Export unmount function for external use
- */
-export function unmountUI() {
-    if (uiInstance) {
-        uiInstance.unmount();
-    }
-}
-export async function startPhase1Runtime() {
-    // Structural Fix B: Hard guard - if UI already mounted, hard stop
-    if (uiInstance !== null) {
-        // Already mounted - hard stop (don't emit to feed, just return)
-        return;
-    }
-    // CRITICAL: Prevent multiple instances from starting
-    if (runtimeStarted) {
-        // Already started - hard stop
-        return;
-    }
-    runtimeStarted = true;
-    // Phase A: UI Layout Fingerprint - Only log in debug mode
-    if (DEBUG_LAYOUT) {
-        eventBus.emit({
-            tag: 'SYS',
-            msg: `UI_ROOT_ID=${UI_ROOT_ID} created (ROOT_RENDER_COUNT will increment)`,
-            level: 'INFO'
-        });
-    }
-    // Structural Fix A: Enable TUI mode (monkeypatches stdout/console, routes to eventBus)
-    enableTuiMode();
-    // CRITICAL: Set up raw input handling FIRST (before blessed can interfere)
-    // This ensures we always receive input, even when blessed breaks on resize
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.setEncoding('utf8');
-    }
-    try {
-        // CRITICAL: Hard singleton guard - screen can only be created ONCE
-        if (screenCreated) {
-            throw new Error(`Screen already created! screenCreationCount=${screenCreationCount}, uiInstanceId=${UI_INSTANCE_ID}`);
-        }
-        screenCreated = true;
-        screenCreationCount++;
-        // Debug: Log screen creation
-        if (DEBUG_LAYOUT) {
-            eventBus.emit({
-                tag: 'SYS',
-                msg: `Screen created #${screenCreationCount} (uiInstanceId=${UI_INSTANCE_ID})`,
-                level: 'INFO'
-            });
-        }
-        // CRITICAL: Block SIGWINCH (resize signal) BEFORE creating screen
-        // This prevents blessed from ever detecting resize events
-        // User will need to restart TUI after resizing terminal
-        if (process.stdout.isTTY) {
-            // Remove all existing SIGWINCH listeners
-            process.removeAllListeners('SIGWINCH');
-            // Add a no-op handler to block the signal
-            process.on('SIGWINCH', () => {
-                // Do nothing - block blessed from seeing this signal
-            });
-        }
-        // Create screen
-        screen = blessedLib.screen({
-            smartCSR: false, // CRITICAL: Disable smartCSR - it can cause duplicate rendering on resize
-            title: '4Runr OS',
-            fullUnicode: true,
-            // CRITICAL: Disable screen-level input handling to prevent double-typing
-            sendFocus: false,
-            warnings: false,
-            // CRITICAL: Disable blessed's automatic resize handling to prevent duplication
-            // We handle resize ourselves (or just ignore it)
-            autoPadding: false,
-            fastCSR: false,
-            // CRITICAL: Disable dockBorders - can cause duplicate borders
-            dockBorders: false,
-            // CRITICAL: Disable resizeTimeout - prevents blessed from doing its own resize handling
-            resizeTimeout: false,
-        });
-        // CRITICAL: Blessed's resize handling causes widget duplication
-        // We can't easily prevent blessed from detecting resize (it listens to process.stdout directly)
-        // So we just don't add any resize handler - let blessed handle it, but don't interfere
-        // If resize causes issues, user needs to restart TUI
-        // CRITICAL: Hide terminal cursor completely - we'll use only visual cursor character
-        // This must be done persistently, as blessed may try to show it during renders
-        const hideCursor = () => {
-            if (screen.program && screen.program.hideCursor) {
-                screen.program.hideCursor();
-            }
-            // Also use ANSI escape code as backup
-            if (process.stdout.isTTY) {
-                process.stdout.write('\x1b[?25l'); // Hide cursor
-            }
-        };
-        // Hide cursor immediately
-        hideCursor();
-        // CRITICAL: Hook into render to keep cursor hidden after every render
-        // Blessed may try to show cursor during render, so we force hide it after
-        const originalRender = screen.render.bind(screen);
-        screen.render = () => {
-            const result = originalRender();
-            // Force hide cursor after every render
-            hideCursor();
-            return result;
-        };
-        if (!screen) {
-            throw new Error('Failed to create screen');
-        }
-        // CRITICAL: Remove ALL screen-level key handlers
-        // They interfere with the textbox's input handling and cause double-typing
-        // The textbox will handle ALL input directly
-        // Only handle Ctrl+C at the process level (already done below with SIGINT)
-        // Handle signals
-        // Step 5: Store process listeners for cleanup
-        const sigintHandler = () => cleanupAndExit(0);
-        const sigtermHandler = () => cleanupAndExit(0);
-        const uncaughtExceptionHandler = (error) => {
-            // Structural Fix A: Use logger, not console
-            logger.error(`Uncaught exception: ${error.message}`);
-            if (error.stack) {
-                logger.error(`Stack: ${error.stack}`);
-            }
-            cleanupAndExit(1);
-        };
-        process.on('SIGINT', sigintHandler);
-        process.on('SIGTERM', sigtermHandler);
-        process.on('uncaughtException', uncaughtExceptionHandler);
-        // Compute layout
-        const width = screen.width;
-        const height = screen.height;
-        const layoutResult = computePhase1Layout(width, height);
-        if (!layoutResult.ok || !layoutResult.layout) {
-            // Terminal too small - show error
-            const errorBox = blessedLib.box({
-                top: Math.floor((height - 5) / 2),
-                left: Math.floor((width - 60) / 2),
-                width: 60,
-                height: 5,
-                border: {
-                    type: 'line',
-                },
-                tags: true,
-                content: `\n ${layoutResult.errorMessage || 'Terminal too small'}\n\n Press q or Ctrl+C to exit`,
-                style: {
-                    border: {
-                        fg: 'red',
-                    },
-                    fg: 'red',
-                },
-            });
-            screen.append(errorBox);
-            screen.render();
-            return;
-        }
-        const layout = layoutResult.layout;
-        // CRITICAL: Create panels ONLY ONCE - prevent duplication on resize
-        if (!panelsCreated) {
-            panelsCreated = true;
-            // Create all panels (read-only)
-            if (!screen)
-                throw new Error('Screen not initialized');
-            // Clear panels array first (safety)
-            panels = [];
-            panels.push(createPanel(screen, layout.posture, 'POSTURE'));
-            // RESOURCES panel (Phase 4: real metrics)
-            const resourcesPanel = createPanel(screen, layout.resources, 'RESOURCES');
-            panels.push(resourcesPanel);
-            panels.push(createPanel(screen, layout.assets, 'ASSETS'));
-            // OPERATIONS panel with feed content (Phase 3: EventBus)
-            const operationsPanel = createPanel(screen, layout.operations, 'OPERATIONS', formatFeedEntries);
-            panels.push(operationsPanel);
-            panels.push(createPanel(screen, layout.network, 'NETWORK'));
-            panels.push(createPanel(screen, layout.capabilities, 'CAPABILITIES'));
-        }
-        // Section 2: Wire eventBus -> feedStore -> OperationsPanel
-        // Subscribe once during app startup
-        eventBus.subscribe((e) => {
-            feedStore.push(e);
-            requestRender();
-        });
-        // CRITICAL: Create status strip and command line ONLY ONCE
-        if (!statusStrip) {
-            // Create status strip (left side of bottom bar)
-            // Make command line bigger - reduce status to 20%
-            const statusWidth = Math.floor(layout.commandLine.width * 0.2); // 20% for status (was 60%)
-            statusStrip = blessedLib.box({
-                top: layout.commandLine.top,
-                left: layout.commandLine.left,
-                width: statusWidth,
-                height: layout.commandLine.height,
-                border: {
-                    type: 'line',
-                },
-                tags: true,
-                content: ' MODE: OFFLINE | CONNECT: NO | POSTURE: UNKNOWN ',
-                style: {
-                    border: {
-                        fg: 'grey',
-                    },
-                    fg: 'grey',
-                },
-                clickable: false,
-                keys: false,
-                mouse: false,
-                input: false,
-            });
-            statusStrip.setLabel(' {grey-fg}STATUS{/}');
-        }
-        // CRITICAL: Create command line ONLY ONCE
-        // Track input value manually (must be outside if block for scope)
-        let commandInputValue = PROMPT;
-        if (!commandLine) {
-            // Create command line (right side of bottom bar)
-            // CRITICAL: Use a plain box instead of textbox to avoid blessed's input duplication bugs
-            const statusWidth = Math.floor(layout.commandLine.width * 0.2);
-            const commandWidth = layout.commandLine.width - statusWidth - 1; // Remaining width
-            commandLine = blessedLib.box({
-                top: layout.commandLine.top,
-                left: layout.commandLine.left + statusWidth + 1,
-                width: commandWidth,
-                height: layout.commandLine.height,
-                border: {
-                    type: 'line',
-                },
-                tags: true,
-                content: PROMPT,
-                style: {
-                    border: {
-                        fg: 'cyan',
-                    },
-                    fg: 'white',
-                    focus: {
-                        border: {
-                            fg: 'green',
-                        },
-                        fg: 'white',
-                    },
-                },
-                // Make it focusable but NOT use blessed's input handling
-                focusable: true,
-                keyable: true,
-                input: false, // CRITICAL: Disable blessed's input handling
-                keys: false, // We'll handle keys manually
-                mouse: false,
-                // CRITICAL: Position cursor at 0,0 relative to the box (inside the border)
-                scrollable: false,
-                alwaysScroll: false,
-            });
-            if (!commandLine)
-                throw new Error('Command line not initialized');
-            commandLine.setLabel(' {cyan-fg}COMMAND LINE{/}');
-        }
-        // Manual input handling - bypass blessed textbox completely
-        let isProcessingKey = false;
-        let cursorPosition = PROMPT.length; // Track cursor position (after prompt)
-        let scrollOffset = 0; // Horizontal scroll offset for long input
-        // Make updateCommandLineDisplay a variable so we can update it on resize
-        // Add horizontal scrolling for long input
-        let updateCommandLineDisplay = () => {
-            if (commandLine && screen) {
-                // Calculate available width (account for border and padding)
-                const availableWidth = commandLine.width - 4; // Left/right border + padding
-                // Calculate cursor position in the full string
-                const fullText = commandInputValue;
-                const cursorIndex = cursorPosition;
-                // If cursor is beyond visible area, adjust scroll
-                if (cursorIndex - scrollOffset >= availableWidth - 1) {
-                    scrollOffset = cursorIndex - availableWidth + 2; // Keep cursor visible
-                }
-                if (cursorIndex < scrollOffset) {
-                    scrollOffset = Math.max(0, cursorIndex - 5); // Show some context before cursor
-                }
-                // Extract visible portion
-                const visibleStart = scrollOffset;
-                const visibleEnd = Math.min(fullText.length, visibleStart + availableWidth - 1);
-                let visibleText = fullText.substring(visibleStart, visibleEnd);
-                // Insert cursor at correct position
-                const cursorPosInVisible = cursorIndex - visibleStart;
-                const beforeCursor = visibleText.substring(0, cursorPosInVisible);
-                const afterCursor = visibleText.substring(cursorPosInVisible);
-                const cursorChar = '{inverse} {/}'; // Inverted space (block cursor)
-                const displayValue = beforeCursor + cursorChar + afterCursor;
-                commandLine.setContent(displayValue);
-                // Render will automatically hide cursor via our hook above
-                screen.render();
-            }
-        };
-        // CRITICAL: Define handleSubmit BEFORE stdin handler so it can be called
-        // Define submit handler as a function so we can call it directly from stdin handler
-        const handleSubmit = async (value) => {
-            // Reset history index
-            historyIndex = -1;
-            // 0) Debug: Emit raw input if TUI_DEBUG=1
-            const isDebug = process.env.TUI_DEBUG === '1';
-            if (isDebug) {
-                const rawCapped = value.length > 50 ? value.substring(0, 50) + '...' : value;
-                eventBus.emit({
-                    id: `dbg-raw-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `raw="${rawCapped}"`,
-                });
-            }
-            // Step 1: Debug trace - submit pipeline
-            // Extract command part (remove prompt if present)
-            const raw = value.startsWith(PROMPT) ? value.slice(PROMPT.length) : value;
-            const commandPart = raw.trim();
-            if (isDebug) {
-                eventBus.emit({
-                    id: `dbg-submit-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `submit raw="${raw}" norm="${commandPart}" len=${commandPart.length}`,
-                });
-            }
-            // Step 2: Normalization is done in execute() - just pass raw trimmed input
-            // Do NOT normalize here (single place only)
-            if (commandPart.length === 0) {
-                // NOOP - no events, just return
-                reassertFocus();
-                return;
-            }
-            // CRITICAL: Parse command BEFORE clearing input (need to know if it's valid)
-            // Section 3: Parse command using UI-agnostic engine (pass raw trimmed input)
-            const parsed = parse(commandPart);
-            // CRITICAL FIX #1: Emit [CMD] event IMMEDIATELY (before any async work)
-            // This makes the command visible instantly in the Operations feed
-            const cmdEvent = {
-                id: `cmd-immediate-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'CMD',
-                level: 'INFO',
-                msg: parsed.name || commandPart,
-            };
-            eventBus.emit(cmdEvent);
-            updateOperationsPanel();
-            screen?.render(); // Show [CMD] event immediately
-            // CRITICAL FIX #2: Clear input IMMEDIATELY (after emitting [CMD], before async work)
-            // This ensures the command line clears instantly when Enter is pressed
-            currentCommandValue = PROMPT;
-            commandInputValue = PROMPT;
-            cursorPosition = PROMPT.length;
-            scrollOffset = 0;
-            // Force update command line display IMMEDIATELY and SYNCHRONOUSLY
-            if (commandLine && screen) {
-                const cursorChar = '{inverse} {/}';
-                commandLine.setContent(PROMPT + cursorChar);
-                updateCommandLineDisplay();
-                screen.render(); // Render immediately to show cleared input
-            }
-            // Add command to history (S0.4)
-            if (commandPart) {
-                commandHistory.push(commandPart);
-                // Keep last 100 commands
-                if (commandHistory.length > 100) {
-                    commandHistory.shift();
-                }
-            }
-            // Empty command - do nothing, keep focus
-            if (!parsed.name) {
-                reassertFocus();
-                return;
-            }
-            // CRITICAL FIX #2: [CMD] event already emitted above for immediate feedback
-            // Commands may emit additional [CMD] events, but we filter duplicates in the feed
-            // Section 3: Execute command using UI-agnostic engine (now async)
-            const ctx = {}; // Lightweight context (empty for now)
-            // Note: connect command now uses LOADING state with attemptId
-            // The command handler returns LOADING state immediately in uiStateUpdate
-            // No need to set CONNECTING state here - command handler does it
-            // CRITICAL: For connect command, set LOADING state IMMEDIATELY
-            // The command handler will emit all events (including probes)
-            // We just set the UI state here for instant feedback
-            if (parsed.name === 'connect') {
-                const { resolveGatewayUrl } = await import('../config/gateway.js');
-                const target = resolveGatewayUrl();
-                // Set LOADING state immediately (command handler will emit events)
-                currentUiState = {
-                    ...currentUiState,
-                    network: loading('Connecting to Gateway...', {
-                        attemptId: Date.now(),
-                        target,
-                        timeout: 5,
-                    }),
-                    statusStrip: available({
-                        left: 'NET: CONNECTING...',
-                        right: 'GATEWAY: CONNECTING',
-                    }),
-                };
-                // Update panels immediately
-                updateNetworkPanel();
-                updateStatusStrip();
-                screen?.render();
-            }
-            // CRITICAL: Start command execution but don't await yet
-            // This allows us to emit immediate events before async work completes
-            const executePromise = execute(parsed, ctx);
-            // For commands that return events immediately (like connect), emit them right away
-            // We'll handle the full result after await
-            let result;
-            try {
-                result = await executePromise;
-            }
-            catch (error) {
-                // Command execution failed - emit error event
-                const errorMsg = error?.message || 'Command execution failed';
-                eventBus.emit({
-                    id: `err-exec-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: errorMsg,
-                });
-                // Update operations panel to show error
-                updateOperationsPanel();
-                screen?.render();
-                return; // Exit early on error
-            }
-            // Section 3: Append CommandResult.events to Operations Feed
-            // Emit ALL events from command handler (including probes for connect)
-            for (const event of result.events) {
-                eventBus.emit(event);
-            }
-            // Update operations panel immediately after emitting all events
-            updateOperationsPanel();
-            screen?.render();
-            // Section 6: Handle UiState update if provided
-            // A) This updates UI immediately (within 50ms) even before async work completes
-            // CRITICAL: Always apply uiStateUpdate if provided (overrides any temporary CONNECTING state)
-            if (result.uiStateUpdate) {
-                // CRITICAL: Apply state update - this will override CONNECTING with UNAVAILABLE on failure
-                try {
-                    const newState = result.uiStateUpdate(currentUiState);
-                    currentUiState = newState;
-                    assertUiState(currentUiState);
-                }
-                catch (stateError) {
-                    // State validation failed - log but don't crash
-                    eventBus.emit({
-                        id: `err-state-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'ERR',
-                        level: 'ERROR',
-                        msg: `State validation error: ${stateError.message}`,
-                    });
-                    // Don't update state if validation fails
-                }
-                // CRITICAL: Force update Network panel FIRST (before other panels)
-                // This ensures CONNECTING state is immediately replaced with UNAVAILABLE on error
-                updateNetworkPanel();
-                updateStatusStrip();
-                // Update other panels
-                updatePosturePanel();
-                updateResourcesPanel();
-                updateAssetsPanel();
-                updateCapabilitiesPanel();
-                // CRITICAL: Force render immediately to show the updated Network panel
-                screen?.render();
-                // Double-check: Verify Network panel was updated (debug only)
-                if (process.env.TUI_DEBUG === '1') {
-                    const networkValue = currentUiState.network;
-                    const isConnecting = isLoading(networkValue);
-                    if (isConnecting && parsed.name === 'connect') {
-                        // This shouldn't happen after error - log it (LOADING should be cleared by command)
-                        eventBus.emit({
-                            id: `dbg-state-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'DBG',
-                            level: 'INFO',
-                            msg: `WARN: Network still LOADING after uiStateUpdate`,
-                        });
-                    }
-                }
-            }
-            else {
-                // If no uiStateUpdate provided, still update panels to reflect current state
-                // This ensures panels don't get stuck in intermediate states
-                updateNetworkPanel();
-                updateStatusStrip();
-                screen?.render();
-            }
-            // CRITICAL: Always update operations panel after command execution
-            // This ensures all events are visible even if no state update occurred
-            updateOperationsPanel();
-            screen?.render();
-            // Section 3: Handle CommandResult.action explicitly
-            if (result.action === UiAction.EXIT) {
-                // Step 6: Call unmount before exit
-                if (uiInstance) {
-                    uiInstance.unmount();
-                }
-                // Exit the application
-                cleanupAndExit(0);
-                return;
-            }
-            if (result.action === UiAction.CLEAR_FEED) {
-                // Clear Operations Feed only (panels remain intact)
-                feedStore.clear();
-                // No output event - clear is silent
-            }
-            if (result.action === UiAction.HOME) {
-                // S0.3: State machine - handle state transitions
-                uiModeState = 'HUB';
-            }
-            // Input already cleared above (before async work)
-            // Just ensure focus and render
-            reassertFocus();
-            // Operations panel already updated above after command execution
-            // Just ensure final render
-            screen?.render();
-        };
-        // Step 5: Store cleanup functions for collectors/timers (must be defined before stdin listener)
-        const cleanupFunctions = [];
-        // Step 5: Store process listener cleanup
-        cleanupFunctions.push(() => {
-            process.removeListener('SIGINT', sigintHandler);
-            process.removeListener('SIGTERM', sigtermHandler);
-            process.removeListener('uncaughtException', uncaughtExceptionHandler);
-        });
-        // CRITICAL: Use RAW stdin handler (blessed breaks on resize)
-        // Read directly from process.stdin - bypasses blessed completely
-        // NOTE: This handler is bound ONCE and never re-bound, so it always uses current variables
-        // Step 5: Store stdin listener cleanup
-        let stdinListener = null;
-        stdinListener = (data) => {
-            // Don't check commandLine here - it might be recreated, but we'll call handleSubmit directly
-            if (!screen)
-                return;
-            const input = data.toString();
-            // Handle Ctrl+C (ASCII 3) - ALWAYS works
-            if (input === '\x03') {
-                cleanupAndExit(0);
-                return;
-            }
-            // Handle Enter (ASCII 13 or 10)
-            if (input === '\r' || input === '\n') {
-                // Extract command part (without prompt)
-                const commandPart = commandInputValue.startsWith(PROMPT)
-                    ? commandInputValue.slice(PROMPT.length).trim()
-                    : commandInputValue.trim();
-                if (commandPart) {
-                    // Call handleSubmit with the full value (it will extract the command part internally)
-                    // This ensures it works even after resize when widget is recreated
-                    // CRITICAL: Don't clear commandInputValue here - handleSubmit does it
-                    handleSubmit(commandInputValue).catch((err) => {
-                        // Emit error to operations feed (visible to user)
-                        eventBus.emit({
-                            id: `err-handler-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'ERR',
-                            level: 'ERROR',
-                            msg: `Command handler error: ${err?.message || String(err)}`,
-                        });
-                        updateOperationsPanel();
-                        screen?.render();
-                    });
-                }
-                else {
-                    // Empty command - just reset
-                    commandInputValue = PROMPT;
-                    cursorPosition = PROMPT.length;
-                    scrollOffset = 0;
-                    updateCommandLineDisplay();
-                }
-                return;
-            }
-            // Handle Backspace (ASCII 127 or 8)
-            if (input === '\x7f' || input === '\x08') {
-                if (cursorPosition > PROMPT.length) {
-                    // Delete character before cursor
-                    const before = commandInputValue.substring(0, cursorPosition - 1);
-                    const after = commandInputValue.substring(cursorPosition);
-                    commandInputValue = before + after;
-                    cursorPosition--;
-                    updateCommandLineDisplay();
-                }
-                return;
-            }
-            // Handle Delete (not standard in raw mode, but handle if received)
-            if (input === '\x1b[3~') {
-                if (cursorPosition < commandInputValue.length) {
-                    const before = commandInputValue.substring(0, cursorPosition);
-                    const after = commandInputValue.substring(cursorPosition + 1);
-                    commandInputValue = before + after;
-                    updateCommandLineDisplay();
-                }
-                return;
-            }
-            // Handle Left Arrow (cursor movement)
-            if (input === '\x1b[D' || input === '\x1b[1;2D') {
-                if (cursorPosition > PROMPT.length) {
-                    cursorPosition--;
-                    updateCommandLineDisplay();
-                }
-                return;
-            }
-            // Handle Right Arrow (cursor movement)
-            if (input === '\x1b[C' || input === '\x1b[1;2C') {
-                if (cursorPosition < commandInputValue.length) {
-                    cursorPosition++;
-                    updateCommandLineDisplay();
-                }
-                return;
-            }
-            // Handle Up Arrow (history navigation)
-            if (input === '\x1b[A') {
-                if (commandHistory.length === 0)
-                    return;
-                if (historyIndex === -1) {
-                    historyIndex = commandHistory.length - 1;
-                }
-                else if (historyIndex > 0) {
-                    historyIndex--;
-                }
-                if (historyIndex >= 0 && historyIndex < commandHistory.length) {
-                    const historyCmd = commandHistory[historyIndex];
-                    const fullValue = `${PROMPT}${historyCmd}`;
-                    commandInputValue = fullValue;
-                    cursorPosition = fullValue.length;
-                    scrollOffset = 0;
-                    updateCommandLineDisplay();
-                }
-                return;
-            }
-            // Handle Down Arrow (history navigation)
-            if (input === '\x1b[B') {
-                if (historyIndex === -1)
-                    return;
-                if (historyIndex < commandHistory.length - 1) {
-                    historyIndex++;
-                    const historyCmd = commandHistory[historyIndex];
-                    const fullValue = `${PROMPT}${historyCmd}`;
-                    commandInputValue = fullValue;
-                    cursorPosition = fullValue.length;
-                    scrollOffset = 0;
-                    updateCommandLineDisplay();
-                }
-                else {
-                    historyIndex = -1;
-                    commandInputValue = PROMPT;
-                    cursorPosition = PROMPT.length;
-                    scrollOffset = 0;
-                    updateCommandLineDisplay();
-                }
-                return;
-            }
-            // Handle Home (move to start of input, after prompt)
-            if (input === '\x1b[H' || input === '\x1b[1~') {
-                cursorPosition = PROMPT.length;
-                updateCommandLineDisplay();
-                return;
-            }
-            // Handle End (move to end of input)
-            if (input === '\x1b[F' || input === '\x1b[4~') {
-                cursorPosition = commandInputValue.length;
-                updateCommandLineDisplay();
-                return;
-            }
-            // Handle Ctrl+V (paste) - ASCII 22
-            if (input === '\x16') {
-                // Paste from clipboard (if available)
-                // Note: In raw mode, we can't easily access clipboard
-                // But we can handle multi-character paste sequences
-                // For now, we'll handle it in the printable characters section
-                // by detecting rapid character sequences
-                return; // Will be handled by detecting rapid input
-            }
-            // Handle Escape (ASCII 27) - clear input
-            if (input === '\x1b') {
-                commandInputValue = PROMPT;
-                cursorPosition = PROMPT.length;
-                scrollOffset = 0;
-                updateCommandLineDisplay();
-                return;
-            }
-            // Handle printable characters (including paste sequences)
-            // Check for multi-character input (paste)
-            if (input.length > 1) {
-                // This is likely a paste - insert all characters at cursor
-                for (let i = 0; i < input.length; i++) {
-                    const ch = input[i];
-                    if (ch >= ' ' && ch <= '~') {
-                        const before = commandInputValue.substring(0, cursorPosition);
-                        const after = commandInputValue.substring(cursorPosition);
-                        commandInputValue = before + ch + after;
-                        cursorPosition++;
-                    }
-                }
-                updateCommandLineDisplay();
-                return;
-            }
-            // Handle single printable character
-            if (input.length === 1 && input >= ' ' && input <= '~') {
-                // Insert at cursor position
-                const before = commandInputValue.substring(0, cursorPosition);
-                const after = commandInputValue.substring(cursorPosition);
-                commandInputValue = before + input + after;
-                cursorPosition++;
-                updateCommandLineDisplay();
-            }
-        };
-        // Step 5: Register stdin listener once
-        process.stdin.on('data', stdinListener);
-        cleanupFunctions.push(() => {
-            if (stdinListener) {
-                process.stdin.removeListener('data', stdinListener);
-            }
-        });
-        // Prompt protection is now handled in the manual keypress handler above
-        // No need for separate protection since we control all input
-        // Handle command submission (Phase 3: EventBus)
-        // CRITICAL: Bind handlers exactly ONCE - never in render loops or intervals
-        if (!commandLine)
-            throw new Error('Command line not initialized');
-        // Structural Fix 3: Hard guard - bind listeners exactly once
-        if (inputHandlersBound) {
-            // Already bound - hard stop (don't log, don't bind again)
-            return;
-        }
-        // Mark as bound BEFORE binding (prevents race conditions)
-        inputHandlersBound = true;
-        // Removed debug log - not needed in production
-        // Attach submit handler to initial commandLine (handleSubmit is defined above)
-        commandLine.on('submit', handleSubmit);
-        // S0.4: Command history navigation (Up/Down)
-        // These are bound once at startup, never in intervals
-        // Note: Up/Down are handled in the manual keypress handler, but we keep these for compatibility
-        screen.key('up', () => {
-            if (screen?.focused !== commandLine)
-                return;
-            if (commandHistory.length === 0)
-                return;
-            if (historyIndex === -1) {
-                // Start browsing from most recent
-                historyIndex = commandHistory.length - 1;
-            }
-            else if (historyIndex > 0) {
-                historyIndex--;
-            }
-            if (historyIndex >= 0 && historyIndex < commandHistory.length) {
-                const historyCmd = commandHistory[historyIndex];
-                const fullValue = `${PROMPT}${historyCmd}`;
-                commandInputValue = fullValue;
-                currentCommandValue = fullValue;
-                cursorPosition = fullValue.length;
-                scrollOffset = 0;
-                updateCommandLineDisplay();
-            }
-        });
-        commandLine.key('down', () => {
-            if (historyIndex === -1)
-                return;
-            if (historyIndex < commandHistory.length - 1) {
-                historyIndex++;
-                const historyCmd = commandHistory[historyIndex];
-                const fullValue = `${PROMPT}${historyCmd}`;
-                commandInputValue = fullValue;
-                currentCommandValue = fullValue;
-                cursorPosition = fullValue.length;
-                scrollOffset = 0;
-                updateCommandLineDisplay();
-            }
-            else {
-                // Reached end of history - clear input (but keep prompt)
-                historyIndex = -1;
-                commandInputValue = PROMPT;
-                currentCommandValue = PROMPT;
-                cursorPosition = PROMPT.length;
-                scrollOffset = 0;
-                updateCommandLineDisplay();
-            }
-        });
-        // S0.4: Esc clears input (handled in manual keypress handler above)
-        // Keep this for compatibility but it should be handled by screen-level handler
-        // Mark handlers as bound (all handlers above are now attached)
-        // This prevents any accidental duplicate binding
-        // Track command value changes (only reset history, don't interfere with input)
-        // Note: We don't use 'keypress' here as it can cause double-typing issues
-        // The textbox handles input automatically, we just need to track when user types
-        // We'll reset history index on submit instead
-        // CRITICAL: NO RESIZE HANDLING
-        // We've blocked SIGWINCH above, so blessed will never detect resize
-        // User must restart TUI after resizing terminal
-        // This is the ONLY way to prevent blessed's duplication bugs
-        // Prevent Tab from moving focus to panels (single handler only, bound once)
-        // Note: Tab handler is already bound above with other keys, so we don't need this
-        // But keeping it as a safety guard (only if somehow handlers weren't bound)
-        if (commandLine && !inputHandlersBound) {
-            logger.warn('Tab handler being bound separately - this should not happen');
-            commandLine.key('tab', () => {
-                // Tab does nothing - stay in command line
-                commandLine?.focus();
-                screen?.render();
-            });
-        }
-        // CRITICAL: Append widgets ONLY ONCE - prevent blessed resize from causing duplication
-        // Guard ensures widgets are never appended multiple times, even if resize triggers re-execution
-        if (!widgetsAppended) {
-            widgetsAppended = true;
-            // CRITICAL: Append command line FIRST so it gets focus by default
-            if (!screen)
-                throw new Error('Screen not initialized');
-            if (commandLine) {
-                screen.append(commandLine);
-                // ONLY the command line should be focusable and receive input
-                commandLine.focusable = true;
-                commandLine.keyable = true;
-                commandLine.input = true;
-                commandLine.keys = true;
-                // Focus immediately after appending
-                commandLine.focus();
-                screen.focused = commandLine;
-            }
-            // Append status strip (not focusable)
-            if (statusStrip) {
-                screen.append(statusStrip);
-                statusStrip.focusable = false;
-                statusStrip.keyable = false;
-                statusStrip.input = false;
-            }
-            // Append all panels AFTER command line (not focusable)
-            panels.forEach(panel => {
-                if (screen) {
-                    screen.append(panel);
-                    // CRITICAL: Ensure panels CANNOT receive focus or input
-                    panel.focusable = false;
-                    panel.keyable = false;
-                    panel.clickable = false;
-                    panel.input = false;
-                }
-            });
-        }
-        // S0.1 & S0.4: Force focus to command line again after all widgets appended
-        if (commandLine && screen) {
-            commandLine.focus();
-            screen.focused = commandLine;
-        }
-        // S0.4: Prevent focus from entering panels - hard lock
-        // Set screen to only allow focus on command line
-        const focusScreen = screen;
-        if (focusScreen) {
-            focusScreen.on('focus', (widget) => {
-                // If focus tries to go to a panel, redirect to command line
-                if (widget && typeof widget !== 'string' && panels.includes(widget)) {
-                    reassertFocus();
-                }
-            });
-            // S0.4: Mouse clicks do nothing except refocus input
-            focusScreen.on('click', () => {
-                reassertFocus();
-            });
-        }
-        // Section 2: Startup events (must emit on boot)
-        // Emit once the screen is ready
-        // Removed verbose "UI booted" message
-        // STEP 5: Posture configuration is visible in POSTURE panel - no need to log to Operations
-        // Runtime fingerprint (for debugging network topology)
-        const os = await import('os');
-        const platform = process.platform;
-        const hostname = os.hostname();
-        const envHostname = process.env.HOSTNAME || 'unknown';
-        const cwd = process.cwd();
-        const hasSshConnection = !!process.env.SSH_CONNECTION;
-        // Get non-internal IPs
-        const interfaces = os.networkInterfaces();
-        const ips = [];
-        for (const ifaceName in interfaces) {
-            const iface = interfaces[ifaceName];
-            if (iface) {
-                for (const addr of iface) {
-                    if (!addr.internal && addr.family === 'IPv4') {
-                        ips.push(addr.address);
-                    }
-                }
-            }
-        }
-        // Removed verbose runtime info (only log in debug mode if needed)
-        // Subscribe to connection store updates and update Network panel
-        const { gatewayConnectionStore } = await import('../state/gatewayConnectionStore.js');
-        const { capabilitiesStore } = await import('../state/capabilitiesStore.js');
-        gatewayConnectionStore.subscribe((connectionState) => {
-            // Update Network panel whenever store changes
-            updateNetworkPanel();
-            // Also update Capabilities panel (depends on connection)
-            updateCapabilitiesPanel();
-            screen?.render();
-            // Only log significant state changes (connected/disconnected), not every update
-            if (connectionState.status === 'connected' || connectionState.status === 'disconnected') {
-                eventBus.emit({
-                    tag: 'SYS',
-                    msg: `Network: ${connectionState.status}`,
-                    level: 'INFO'
-                });
-            }
-        });
-        // Subscribe to capabilities store updates
-        capabilitiesStore.subscribe(() => {
-            updateCapabilitiesPanel();
-            screen?.render();
-        });
-        // Removed verbose "Type help" message
-        // Update operations panel with feed content
-        updateOperationsPanel();
-        // Section 4: Initial UiState build
-        // CRITICAL: Use initializedDefaultState (has correct posture state) not defaultUiState
-        currentUiState = initializedDefaultState;
-        // Section 4: Validate defaultUiState contract
-        assertUiState(currentUiState);
-        // Update all panels with default state (no blank panels)
-        // FIXED: Update panels immediately with default state to prevent showing stale data
-        updatePosturePanel();
-        updateResourcesPanel();
-        updateAssetsPanel();
-        updateNetworkPanel();
-        updateCapabilitiesPanel();
-        updateStatusStrip();
-        // Part A: Initialize resize dimensions (prevents false no-op detection on first resize)
-        if (screen) {
-            lastResizeWidth = screen.width;
-            lastResizeHeight = screen.height;
-        }
-        // Initial render with default state
-        renderCount++;
-        if (DEBUG_LAYOUT) {
-            eventBus.emit({
-                tag: 'SYS',
-                msg: `ROOT_RENDER_COUNT=${renderCount} (UI_ROOT_ID=${UI_ROOT_ID})`,
-                level: 'INFO'
-            });
-        }
-        // Structural Fix 4: Render FIRST with default state, then do async init
-        // Initial render (focus is already set above)
-        screen?.render();
-        // Structural Fix A: Disable boot phase AFTER first render
-        // This enables strict stdout blocking now that blessed is initialized
-        disableBootPhase();
-        // Reassert focus after first render to ensure it sticks
-        reassertFocus();
-        // Structural Fix 4: Move async init AFTER mount (don't block render)
-        // Kick off async state building in background - it will update UI when ready
-        buildUiState(currentUiState).then((newState) => {
-            // Section 4: Validate state contract
-            assertUiState(newState);
-            lastResourcesAvailable = isAvailable(newState.resources);
-            currentUiState = newState;
-            // Update all panels with real state
-            updatePosturePanel();
-            updateResourcesPanel();
-            updateAssetsPanel();
-            updateNetworkPanel();
-            updateCapabilitiesPanel();
-            updateStatusStrip();
-            screen?.render();
-        }).catch((error) => {
-            // If state building fails, keep default state (all UNAVAILABLE)
-            // Error is already logged if DEBUG_NO_TUI=1
-            // Panels already show UNAVAILABLE with reason, so UI is still meaningful
-            logger.error(`State building failed: ${error instanceof Error ? error.message : String(error)}`);
-        });
-        // Render loop to update operations feed and resources (every 1500ms)
-        const renderInterval = setInterval(async () => {
-            // Update operations feed
-            updateOperationsPanel();
-            // Section 4: Update all panels with latest UiState
-            // CRITICAL: Pass currentUiState to preserve command-updated values
-            try {
-                const newState = await buildUiState(currentUiState);
-                // Section 4: Validate state contract
-                assertUiState(newState);
-                // Check for state transition (AVAILABLE → UNAVAILABLE)
-                const wasAvailable = lastResourcesAvailable;
-                const isNowAvailable = isAvailable(newState.resources);
-                if (wasAvailable && !isNowAvailable && isUnavailable(newState.resources)) {
-                    // Transition to UNAVAILABLE - emit event
-                    eventBus.emitTag('SYS', `RESOURCES UNAVAILABLE: ${newState.resources.reason || 'Unknown reason'}`, 'WARN');
-                }
-                lastResourcesAvailable = isNowAvailable;
-                currentUiState = newState;
-                // Section 4: Update all panels (no blank panels)
-                updatePosturePanel();
-                updateResourcesPanel();
-                updateAssetsPanel();
-                updateNetworkPanel();
-                updateCapabilitiesPanel();
-                updateStatusStrip();
-            }
-            catch (error) {
-                // If state building fails, don't crash - just skip this update
-                // Panels already show UNAVAILABLE with reason, so UI is still meaningful
-                // Error is already logged if DEBUG_NO_TUI=1
-            }
-            // Reassert focus periodically to keep cursor in command line
-            // But only if user isn't actively typing (check if we're processing a key)
-            if (!isProcessingKey) {
-                reassertFocus();
-            }
-            screen?.render();
-        }, 1500);
-        // Step 5: Store interval for cleanup
-        screen.renderInterval = renderInterval;
-        cleanupFunctions.push(() => {
-            clearInterval(renderInterval);
-        });
-        // Structural Fix B: Store unmount function in global singleton
-        const unmountFn = () => {
-            logger.debug(`Unmounting UI (bootId=${BOOT_ID}, renderCount=${renderCount})`);
-            isCleaningUp = true;
-            // Step 5: Stop all collectors/timers
-            cleanupFunctions.forEach(cleanup => {
-                try {
-                    cleanup();
-                }
-                catch (error) {
-                    logger.error(`Cleanup function failed: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            });
-            // Cleanup resize debounce timer
-            if (screen?._resizeDebounceTimer) {
-                clearTimeout(screen._resizeDebounceTimer);
-                screen._resizeDebounceTimer = null;
-            }
-            // Step 6: Remove listeners
-            process.removeListener('SIGINT', sigintHandler);
-            process.removeListener('SIGTERM', sigtermHandler);
-            process.removeListener('uncaughtException', uncaughtExceptionHandler);
-            // Step 7: Restore terminal state
-            if (process.stdout.isTTY) {
-                process.stdout.write('\x1b[?25h'); // Show cursor
-                process.stdout.write('\x1b[?1049l'); // Exit alternate screen
-            }
-            // Step 8: Destroy screen
-            if (screen) {
-                try {
-                    screen.destroy();
-                }
-                catch (error) {
-                    // Ignore destroy errors
-                }
-                screen = null;
-            }
-            // Step 9: Reset state
-            panels = [];
-            commandLine = null;
-            statusStrip = null;
-            uiInstance = null;
-            runtimeStarted = false;
-            renderCount = 0;
-            widgetsAppended = false; // Reset append guard
-            screenCreated = false; // Reset screen creation guard
-            screenCreationCount = 0; // Reset creation count
-            // Step 10: Reset global singleton guard
-            import('../tui/startTui.js').then(({ resetTuiGuard }) => {
-                resetTuiGuard();
-            }).catch(() => {
-                // Ignore import errors
-            });
-        };
-        uiInstance = {
-            unmount: unmountFn
-        };
-        // Store unmount in global singleton
-        const { setTuiUnmount } = await import('../tui/startTui.js');
-        setTuiUnmount(unmountFn);
-        // Removed verbose "UI mounted" message
-    }
-    catch (error) {
-        // Structural Fix A: TUI mode remains enabled even on error
-        throw error;
-    }
-}
-//# sourceMappingURL=phase1Runtime.js.map