4runr-os 2.1.2 → 2.1.5

package/dist/ui/v3/commands/commandEngine.js

@@ -1,3289 +0,0 @@
-/**
- * Section 3: Command Engine (UI-Agnostic)
- *
- * Pure command engine that sits between command line and UI state.
- *
- * Rules:
- * - Does not know about blessed
- * - Does not render UI
- * - Does not contain business logic
- * - Only parses input, executes commands, and emits structured results
- * - UI layer consumes results and mutates UiState
- *
- * Architectural Rule (Non-Negotiable):
- * - UI-agnostic
- * - Side-effect free
- * - Deterministic
- */
-import { available, unavailable } from '../state/value.js';
-import { listAgents, getAgent, createAgent as v1CreateAgent } from '../v1Adapters/agents.js';
-import { connect as v1Connect } from '../v1Adapters/connect.js';
-import { startRun, listRuns } from '../v1Adapters/runs.js';
-import { loadConfig } from '../v1Adapters/config.js';
-import { diagnoseGateway } from './diagnose.js';
-import { classifyError } from './errorClassifier.js';
-import { URL } from 'url';
-/**
- * UI actions that the UI layer interprets
- */
-export var UiAction;
-(function (UiAction) {
-    UiAction["EXIT"] = "EXIT";
-    UiAction["CLEAR_FEED"] = "CLEAR_FEED";
-    UiAction["HOME"] = "HOME";
-})(UiAction || (UiAction = {}));
-/**
- * Parse command line input
- *
- * Responsibilities:
- * - Trim leading/trailing whitespace
- * - Support quoted arguments: "quoted value" and 'quoted value'
- * - Preserve spaces inside quotes
- * - Split unquoted tokens on whitespace
- *
- * Rules:
- * - Empty input → return { name: "", args: [], raw }
- * - Parsing never throws
- * - Parsing never emits UI output
- */
-export function parse(line) {
-    const raw = line;
-    const trimmed = line.trim();
-    // Empty input
-    if (!trimmed) {
-        return { name: '', args: [], raw };
-    }
-    // Remove prompt if present
-    const withoutPrompt = trimmed.replace(/^4runr>\s*/, '').trim();
-    if (!withoutPrompt) {
-        return { name: '', args: [], raw };
-    }
-    // Parse with quoted argument support
-    const tokens = [];
-    let current = '';
-    let inDoubleQuote = false;
-    let inSingleQuote = false;
-    for (let i = 0; i < withoutPrompt.length; i++) {
-        const char = withoutPrompt[i];
-        if (char === '"' && !inSingleQuote) {
-            if (inDoubleQuote) {
-                // End of double-quoted string
-                tokens.push(current);
-                current = '';
-                inDoubleQuote = false;
-            }
-            else {
-                // Start of double-quoted string
-                inDoubleQuote = true;
-            }
-        }
-        else if (char === "'" && !inDoubleQuote) {
-            if (inSingleQuote) {
-                // End of single-quoted string
-                tokens.push(current);
-                current = '';
-                inSingleQuote = false;
-            }
-            else {
-                // Start of single-quoted string
-                inSingleQuote = true;
-            }
-        }
-        else if ((char === ' ' || char === '\t') && !inDoubleQuote && !inSingleQuote) {
-            // Whitespace outside quotes - end current token
-            if (current) {
-                tokens.push(current);
-                current = '';
-            }
-        }
-        else {
-            // Regular character - add to current token
-            current += char;
-        }
-    }
-    // Add final token if any
-    if (current || inDoubleQuote || inSingleQuote) {
-        tokens.push(current);
-    }
-    if (tokens.length === 0) {
-        return { name: '', args: [], raw };
-    }
-    const name = tokens[0].toLowerCase();
-    const args = tokens.slice(1);
-    return { name, args, raw };
-}
-/**
- * Execute a parsed command
- *
- * Responsibilities:
- * - Route to a command handler
- * - Return a CommandResult object
- * - Never mutate UI directly
- *
- * Rules:
- * - Never emits UI output directly
- * - Only side effects via returned data
- */
-export async function execute(parsed, ctx) {
-    // Step 2: Normalization in single place (deterministic)
-    // Normalize the parsed command name and args
-    const normalizedName = parsed.name ? parsed.name.replace(/\s+/g, ' ').trim().toLowerCase() : '';
-    const normalizedArgs = parsed.args.map(arg => arg.replace(/\s+/g, ' ').trim()).filter(arg => arg.length > 0);
-    // Step 1: Debug trace - execute entry
-    const isDebug = process.env.TUI_DEBUG === '1';
-    const debugEvents = [];
-    if (isDebug) {
-        debugEvents.push({
-            id: `dbg-execute-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'DBG',
-            level: 'INFO',
-            msg: `execute cmd="${normalizedName}" argc=${normalizedArgs.length}`,
-        });
-    }
-    // Empty command after normalization
-    if (!normalizedName) {
-        return { events: debugEvents };
-    }
-    // Step 3: Check for blocked commands (should be none, but verify)
-    // No filters - all registered commands are allowed
-    // Step 1: Debug trace - route lookup
-    const handler = commands[normalizedName];
-    const exists = !!handler;
-    if (isDebug) {
-        debugEvents.push({
-            id: `dbg-route-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'DBG',
-            level: 'INFO',
-            msg: `route hit="${normalizedName}" exists=${exists}`,
-        });
-    }
-    if (!handler) {
-        // Unknown command - return debug events + unknown handler result
-        const unknownResult = handleUnknown(normalizedName);
-        return {
-            events: [...debugEvents, ...unknownResult.events],
-            uiStateUpdate: unknownResult.uiStateUpdate,
-            action: unknownResult.action,
-        };
-    }
-    // Step 4: [CMD] event is emitted by handler (connect handler emits it first)
-    // Step 5: Handler is awaited (Promise.resolve ensures async handlers work)
-    // Top-level try/catch to prevent swallowed exceptions
-    try {
-        const result = handler(ctx, normalizedArgs);
-        // Handle both sync and async handlers
-        const finalResult = await Promise.resolve(result);
-        // Prepend debug events to result events
-        return {
-            ...finalResult,
-            events: [...debugEvents, ...finalResult.events],
-        };
-    }
-    catch (error) {
-        // Handler error - emit error event (no stack trace, no raw dump)
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        const sanitized = errorMsg.substring(0, 50).trim();
-        const finalMsg = sanitized || 'Internal command error';
-        return {
-            events: [
-                ...debugEvents,
-                {
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: finalMsg,
-                },
-            ],
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                network: unavailable('Internal error', 'Retry command'),
-            }),
-        };
-    }
-}
-/**
- * Sanitize user input for display in error messages
- */
-function sanitizeUserInput(input, maxLength = 50) {
-    // Remove control characters and newlines
-    let sanitized = input.replace(/[\x00-\x1F\x7F-\x9F\n\r\t]/g, '');
-    // Truncate to max length
-    if (sanitized.length > maxLength) {
-        sanitized = sanitized.substring(0, maxLength) + '...';
-    }
-    return sanitized;
-}
-/**
- * Handle unknown command
- *
- * Rules:
- * - Emit exactly one event
- * - <command> must be capped (reuse Section 2.5 echo cap)
- * - No stack traces
- * - No extra lines
- * - No duplicate emissions
- */
-function handleUnknown(cmd) {
-    const sanitizedCmd = sanitizeUserInput(cmd, 50);
-    return {
-        events: [{
-                id: `err-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'ERR',
-                level: 'ERROR',
-                msg: `UNKNOWN COMMAND: ${sanitizedCmd} (try: help)`,
-            }],
-    };
-}
-/**
- * Network connection attempt ID tracker
- * Prevents stale updates from overlapping connection attempts
- */
-// networkAttemptId removed - using gatewayConnectionStore instead
-/**
- * Command registration map
- *
- * Explicit command map - no dynamic loading, no reflection, no plugin system
- */
-const commands = {
-    help: handleHelp,
-    clear: handleClear,
-    home: handleHome,
-    exit: handleExit,
-    // Section 6: Real commands (V1-backed)
-    'agents': handleAgents,
-    'connect': handleConnect,
-    'verify': handleVerify,
-    'test': handleTest,
-    'status': handleStatus,
-    'start': handleStart,
-    'runs': handleRuns,
-    'system': handleSystem,
-    'diagnose': handleDiagnose,
-    // Debug commands (only available with TUI_DEBUG=1)
-    'debug': handleDebug,
-};
-/**
- * Handle help command
- *
- * Emits help text to Operations Feed
- * Text must be static and explicit (no dynamic introspection)
- */
-function handleHelp(ctx, args) {
-    return {
-        events: [
-            {
-                id: `help-1-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: 'AVAILABLE COMMANDS:',
-            },
-            {
-                id: `help-2-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' help',
-            },
-            {
-                id: `help-3-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' clear',
-            },
-            {
-                id: `help-4-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' home',
-            },
-            {
-                id: `help-5-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' exit',
-            },
-            {
-                id: `help-6-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' agents list',
-            },
-            {
-                id: `help-7-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' agents create',
-            },
-            {
-                id: `help-8-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' agents inspect <id>',
-            },
-            {
-                id: `help-9-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' connect — connect to Gateway (uses default target)',
-            },
-            {
-                id: `help-9b-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' connect — connect to Gateway',
-            },
-            {
-                id: `help-test-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' test            - Quick connection test (single API call)',
-            },
-            {
-                id: `help-verify-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' verify          - Full connection test (multiple endpoints)',
-            },
-            {
-                id: `help-status-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' status          - Show connection status and load capabilities',
-            },
-            {
-                id: `help-10-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' start <agentId>',
-            },
-            {
-                id: `help-11-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' runs list',
-            },
-            {
-                id: `help-12-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: ' system',
-            },
-        ],
-    };
-}
-/**
- * Handle clear command
- *
- * Does not clear screen
- * Does not reset panels
- * Emits no output events
- * Returns action: CLEAR_FEED
- */
-function handleClear(ctx, args) {
-    return {
-        events: [], // No output events
-        action: UiAction.CLEAR_FEED,
-    };
-}
-/**
- * Handle home command
- *
- * Emits a short status line
- * Returns action: HOME
- */
-function handleHome(ctx, args) {
-    return {
-        events: [
-            {
-                id: `home-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: 'HOME VIEW',
-            },
-        ],
-        action: UiAction.HOME,
-    };
-}
-/**
- * Handle exit command
- *
- * Emits optional confirmation event (optional but consistent)
- * Returns action: EXIT
- */
-function handleExit(ctx, args) {
-    return {
-        events: [
-            {
-                id: `exit-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: 'Exiting...',
-            },
-        ],
-        action: UiAction.EXIT,
-    };
-}
-// ============================================================================
-// Section 6: Real Commands (V1-Backed)
-// ============================================================================
-/**
- * Handle agents command (list, create, inspect)
- */
-async function handleAgents(ctx, args) {
-    const subcommand = args[0]?.toLowerCase() || 'list';
-    if (subcommand === 'list') {
-        return handleAgentsList(ctx, args.slice(1));
-    }
-    else if (subcommand === 'create') {
-        return handleAgentsCreate(ctx, args.slice(1));
-    }
-    else if (subcommand === 'inspect') {
-        return handleAgentsInspect(ctx, args.slice(1));
-    }
-    else {
-        return {
-            events: [{
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: `Unknown agents subcommand: ${subcommand} (try: list, create, inspect)`,
-                }],
-        };
-    }
-}
-/**
- * 1️⃣ agents list
- *
- * Calls v1Adapters/agents.listAgents()
- * Updates assets → AVAILABLE with real counts
- */
-async function handleAgentsList(ctx, args) {
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: 'agents list',
-    };
-    try {
-        const result = listAgents();
-        if (!result.ok) {
-            // Failure: assets → UNAVAILABLE
-            const classified = classifyError(result.error, 'list agents');
-            return {
-                events: [
-                    cmdEvent,
-                    {
-                        id: `err-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'ERR',
-                        level: 'ERROR',
-                        msg: `Failed to list agents: ${classified.message}`,
-                    },
-                ],
-                uiStateUpdate: (prev) => ({
-                    ...prev,
-                    assets: unavailable(classified.message, classified.nextAction),
-                }),
-            };
-        }
-        const agents = result.data;
-        const count = agents.length;
-        // Success: assets → AVAILABLE (even if count is 0 - valid empty state)
-        const assetsState = {
-            total: count,
-            active: 0, // TODO: track active agents
-            idle: count,
-            error: 0,
-        };
-        // Emit exactly one terminal event: [OK] if count > 0, [WARN] if count === 0
-        const resultEvent = {
-            id: `result-${Date.now()}`,
-            ts: Date.now(),
-            tag: count === 0 ? 'WARN' : 'OK', // [OK] for success, [WARN] for empty
-            level: count === 0 ? 'WARN' : 'INFO', // WARN for empty, INFO for success
-            msg: count === 0 ? 'No agents found' : `${count} agent${count === 1 ? '' : 's'} found`,
-        };
-        return {
-            events: [
-                cmdEvent,
-                resultEvent,
-            ],
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                assets: available(assetsState),
-            }),
-        };
-    }
-    catch (error) {
-        const classified = classifyError(error, 'list agents');
-        return {
-            events: [
-                cmdEvent,
-                {
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: `Failed to list agents: ${classified.message}`,
-                },
-            ],
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                assets: unavailable(classified.message, classified.nextAction),
-            }),
-        };
-    }
-}
-/**
- * 2️⃣ agents create
- *
- * Accepts arguments or minimal defaults
- * Calls v1Adapters/agents.createAgent()
- */
-async function handleAgentsCreate(ctx, args) {
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: 'agents create',
-    };
-    try {
-        // Parse agent name from args (first arg)
-        const name = args[0]?.trim();
-        if (!name) {
-            return {
-                events: [
-                    cmdEvent,
-                    {
-                        id: `err-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'ERR',
-                        level: 'ERROR',
-                        msg: 'Agent name required (usage: agents create <name>)',
-                    },
-                ],
-            };
-        }
-        // Create minimal agent (can be extended later)
-        const agent = {
-            name,
-            description: args[1] || undefined,
-            provider: {
-                type: 'openai',
-                model: 'gpt-3.5-turbo',
-            },
-        };
-        const result = v1CreateAgent(agent);
-        if (!result.ok) {
-            return {
-                events: [
-                    cmdEvent,
-                    {
-                        id: `err-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'ERR',
-                        level: 'ERROR',
-                        msg: `Failed to create agent: ${result.error.message}`,
-                    },
-                ],
-                uiStateUpdate: (prev) => ({
-                    ...prev,
-                    assets: unavailable(result.error.message || 'Failed to create agent', result.error.nextAction || 'Check config and retry'),
-                }),
-            };
-        }
-        // Success: refresh assets list
-        const listResult = listAgents();
-        const assetsState = listResult.ok ? {
-            total: listResult.data.length,
-            active: 0,
-            idle: listResult.data.length,
-            error: 0,
-        } : {
-            total: 0,
-            active: 0,
-            idle: 0,
-            error: 0,
-        };
-        return {
-            events: [
-                cmdEvent,
-                {
-                    id: `ok-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'CMD',
-                    level: 'INFO',
-                    msg: `Agent "${name}" created`,
-                },
-            ],
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                assets: available(assetsState),
-            }),
-        };
-    }
-    catch (error) {
-        return {
-            events: [
-                cmdEvent,
-                {
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: `Failed to create agent: ${error.message || 'Unknown error'}`,
-                },
-            ],
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                assets: unavailable('Failed to create agent', 'Check config and retry'),
-            }),
-        };
-    }
-}
-/**
- * 3️⃣ agents inspect <id>
- *
- * Calls v1Adapters/agents.getAgent(id)
- * Updates posture → AVAILABLE
- */
-async function handleAgentsInspect(ctx, args) {
-    const agentId = args[0]?.trim();
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: `agents inspect ${agentId || ''}`,
-    };
-    if (!agentId) {
-        return {
-            events: [
-                cmdEvent,
-                {
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: 'Agent ID required (usage: agents inspect <id>)',
-                },
-            ],
-        };
-    }
-    try {
-        const result = getAgent(agentId);
-        if (!result.ok) {
-            return {
-                events: [
-                    cmdEvent,
-                    {
-                        id: `err-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'ERR',
-                        level: 'ERROR',
-                        msg: `Agent not found: ${agentId}`,
-                    },
-                ],
-                uiStateUpdate: (prev) => ({
-                    ...prev,
-                    posture: unavailable(result.error.message || 'Agent not found', result.error.nextAction || 'Run "agents list"'),
-                }),
-            };
-        }
-        // Success: posture → AVAILABLE
-        const agent = result.data;
-        return {
-            events: [
-                cmdEvent,
-                {
-                    id: `ok-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'OK',
-                    level: 'INFO',
-                    msg: `Agent loaded: ${agent.name}`,
-                },
-            ],
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                posture: available({
-                    mode: 'HUB',
-                    agentId: agent.name, // Include agent ID per spec
-                }),
-            }),
-        };
-    }
-    catch (error) {
-        return {
-            events: [
-                cmdEvent,
-                {
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: `Failed to inspect agent: ${error.message || 'Unknown error'}`,
-                },
-            ],
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                posture: unavailable('Agent not found', 'Run "agents list"'),
-            }),
-        };
-    }
-}
-/**
- * 4️⃣ connect
- *
- * Section 6.2: Gateway Connection Enforcement (FINAL, NON-NEGOTIABLE)
- *
- * Connects to canonical Gateway endpoint.
- * - Ignores any arguments (parser may still accept them, but they are ignored)
- * - Always calls resolveGatewayUrl()
- * - Emits lifecycle events in exact order
- * - Uses LOADING state with attemptId to prevent stale updates
- * - Guarantees reset in finally block
- */
-async function handleConnect(ctx, args) {
-    // Import store and gateway config
-    const { gatewayConnectionStore } = await import('../state/gatewayConnectionStore.js');
-    const gatewayConfig = await import('../config/gateway.js');
-    // Step 1: Resolve target with source tracking
-    const { url: inputTarget, source } = gatewayConfig.resolveGatewayUrlWithSource();
-    // Step 2: Emit [CMD] connect
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: 'connect',
-    };
-    const events = [cmdEvent];
-    // Step 3: Log target source
-    events.push({
-        id: `sys-source-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'SYS',
-        level: 'INFO',
-        msg: `gateway target source: ${source}`,
-    });
-    // Step 4: Set connecting state in store
-    gatewayConnectionStore.setConnecting(inputTarget, 5000);
-    // Step 5: Emit connecting event
-    events.push({
-        id: `sys-connecting-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'SYS',
-        level: 'INFO',
-        msg: 'CONNECTING...',
-    });
-    // Step 6: Attempt connection
-    try {
-        const result = await v1Connect();
-        if (!result.ok) {
-            // Failure: Update store with error
-            const errorCode = result.error.code || 'UNKNOWN';
-            const errorMsg = result.error.message || 'Gateway unreachable';
-            const nextAction = result.error.nextAction || 'Retry "connect"';
-            gatewayConnectionStore.setError(inputTarget, errorCode, errorMsg, nextAction);
-            events.push({
-                id: `err-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'ERR',
-                level: 'ERROR',
-                msg: errorMsg,
-            });
-            // Emit store state for debugging
-            const storeState = gatewayConnectionStore.getState();
-            events.push({
-                id: `sys-network-state-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `network_state=${storeState.status}`,
-            });
-            return { events };
-        }
-        // Success: Update store with connection info
-        const effectiveTarget = result.data.endpoint; // The endpoint that actually worked (might be different from input)
-        const healthData = result.data.healthData;
-        const latency = result.data.latency;
-        gatewayConnectionStore.setConnected(inputTarget, effectiveTarget, healthData, latency);
-        // Auto-load capabilities after successful connection
-        const { capabilitiesStore } = await import('../state/capabilitiesStore.js');
-        const { GatewayClient } = await import('../../../gateway-client.js');
-        capabilitiesStore.setLoading();
-        // Fetch capabilities in background (don't block)
-        (async () => {
-            try {
-                const client = new GatewayClient({ gatewayUrl: effectiveTarget });
-                const response = await fetch(`${effectiveTarget}/api/capabilities`, {
-                    method: 'GET',
-                    signal: AbortSignal.timeout(5000),
-                });
-                if (response.ok) {
-                    const data = await response.json();
-                    const items = data.capabilities || data.items || [];
-                    capabilitiesStore.setLoaded(items);
-                }
-                else {
-                    // Endpoint doesn't exist - set empty list
-                    capabilitiesStore.setLoaded([]);
-                }
-            }
-            catch {
-                // Non-fatal - set empty list
-                capabilitiesStore.setLoaded([]);
-            }
-        })();
-        // Show input vs effective target if different
-        if (effectiveTarget !== inputTarget) {
-            events.push({
-                id: `sys-targets-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `connect: input=${inputTarget} effective=${effectiveTarget}`,
-            });
-        }
-        else {
-            events.push({
-                id: `sys-target-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `connect: target=${inputTarget}`,
-            });
-        }
-        // Show clean connection message
-        const endpointUrl = new URL(effectiveTarget);
-        const displayHost = endpointUrl.hostname === '127.0.0.1' ? 'localhost' : endpointUrl.hostname;
-        const displayPort = endpointUrl.port || (endpointUrl.protocol === 'https:' ? '443' : '80');
-        events.push({
-            id: `ok-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'OK',
-            level: 'INFO',
-            msg: `Connected to ${displayHost}:${displayPort}`,
-        });
-        // Show gateway verification info
-        if (healthData) {
-            const status = healthData.status || 'alive';
-            const persistence = healthData.persistence || 'unknown';
-            events.push({
-                id: `sys-verify-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `Gateway: ${status} | Persistence: ${persistence}${latency ? ` | Latency: ${latency}ms` : ''}`,
-            });
-        }
-        // Emit store state for debugging
-        const storeState = gatewayConnectionStore.getState();
-        events.push({
-            id: `sys-network-state-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `network_state=${storeState.status}`,
-        });
-        return { events };
-    }
-    catch (error) {
-        // Step 7: Catch-all error handler
-        const errorMsg = error?.message || 'Connection failed';
-        const errorCode = error?.code || 'UNKNOWN';
-        gatewayConnectionStore.setError(inputTarget, errorCode, errorMsg, 'Retry "connect"');
-        events.push({
-            id: `err-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: errorMsg,
-        });
-        // Emit store state for debugging
-        const storeState = gatewayConnectionStore.getState();
-        events.push({
-            id: `sys-network-state-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `network_state=${storeState.status}`,
-        });
-        return { events };
-    }
-}
-/**
- * 4.5️⃣ test
- *
- * Simple test - makes ONE API call to prove connection works
- * Just calls /health and shows the result
- */
-async function handleTest(ctx, args) {
-    const { gatewayConnectionStore } = await import('../state/gatewayConnectionStore.js');
-    const gatewayConfig = await import('../config/gateway.js');
-    const { GatewayClient } = await import('../../../gateway-client.js');
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: 'test',
-    };
-    const events = [cmdEvent];
-    // Check store state first
-    const storeState = gatewayConnectionStore.getState();
-    if (storeState.status !== 'connected') {
-        events.push({
-            id: `err-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: `Not connected (status: ${storeState.status}). Run "connect" first.`,
-        });
-        return { events };
-    }
-    // Type guard: ensure we have resolvedTo
-    if (!('resolvedTo' in storeState) || !storeState.resolvedTo) {
-        events.push({
-            id: `err-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: `Connection state missing resolvedTo. Run "connect" again.`,
-        });
-        return { events };
-    }
-    // Use the resolved endpoint from the store (the one that actually worked)
-    const gatewayUrl = storeState.resolvedTo;
-    // Debug: log what URL we're using
-    events.push({
-        id: `sys-test-debug-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'SYS',
-        level: 'INFO',
-        msg: `Using gateway URL: ${gatewayUrl}`,
-    });
-    const client = new GatewayClient({ gatewayUrl });
-    events.push({
-        id: `sys-test-start-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'SYS',
-        level: 'INFO',
-        msg: `Testing connection to ${storeState.resolvedTo}...`,
-    });
-    // Make a single API call to /health
-    try {
-        const startTime = Date.now();
-        const healthResponse = await client.health();
-        const latency = Date.now() - startTime;
-        // Show clear success message
-        events.push({
-            id: `ok-test-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'OK',
-            level: 'INFO',
-            msg: `✓ Connection verified! Gateway responded in ${latency}ms`,
-        });
-        // Show response details
-        events.push({
-            id: `sys-test-details-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `  Status: ${healthResponse.status || 'ok'}`,
-        });
-        if (healthResponse.persistence) {
-            events.push({
-                id: `sys-test-persistence-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `  Persistence: ${healthResponse.persistence}`,
-            });
-        }
-        if (healthResponse.version) {
-            events.push({
-                id: `sys-test-version-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `  Version: ${healthResponse.version}`,
-            });
-        }
-        // Show the full response for debugging
-        events.push({
-            id: `sys-test-response-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `  Response: ${JSON.stringify(healthResponse).substring(0, 100)}...`,
-        });
-    }
-    catch (error) {
-        events.push({
-            id: `err-test-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: `✗ Connection test failed: ${error.message || 'Unknown error'}`,
-        });
-        if (error.code) {
-            events.push({
-                id: `err-test-code-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'ERR',
-                level: 'ERROR',
-                msg: `  Error code: ${error.code}`,
-            });
-        }
-    }
-    return { events };
-}
-/**
- * 4.6️⃣ verify
- *
- * Makes real API calls to prove the connection works
- * Tests: /health, /ready, /api/runs, /metrics
- */
-async function handleVerify(ctx, args) {
-    const { gatewayConnectionStore } = await import('../state/gatewayConnectionStore.js');
-    const gatewayConfig = await import('../config/gateway.js');
-    const { GatewayClient } = await import('../../../gateway-client.js');
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: 'verify',
-    };
-    const events = [cmdEvent];
-    // Check store state first
-    const storeState = gatewayConnectionStore.getState();
-    if (storeState.status !== 'connected') {
-        events.push({
-            id: `err-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: `Not connected (status: ${storeState.status}). Run "connect" first.`,
-        });
-        return { events };
-    }
-    // Use the resolved endpoint from the store (the one that actually worked)
-    const gatewayUrl = storeState.resolvedTo;
-    const client = new GatewayClient({ gatewayUrl });
-    events.push({
-        id: `sys-verify-start-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'SYS',
-        level: 'INFO',
-        msg: `Verifying connection to ${storeState.resolvedTo}...`,
-    });
-    // Test 1: Health check
-    try {
-        const startTime = Date.now();
-        const healthResponse = await client.health();
-        const latency = Date.now() - startTime;
-        events.push({
-            id: `ok-health-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'OK',
-            level: 'INFO',
-            msg: `✓ /health: ${healthResponse.status || 'ok'} (${latency}ms)`,
-        });
-        if (healthResponse.persistence) {
-            events.push({
-                id: `sys-persistence-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `  Persistence: ${healthResponse.persistence}`,
-            });
-        }
-    }
-    catch (error) {
-        events.push({
-            id: `err-health-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: `✗ /health failed: ${error.message || 'Unknown error'}`,
-        });
-    }
-    // Test 2: Ready check
-    try {
-        const startTime = Date.now();
-        const readyResponse = await fetch(`${gatewayUrl}/ready`, {
-            method: 'GET',
-            signal: AbortSignal.timeout(5000),
-        });
-        const latency = Date.now() - startTime;
-        const data = await readyResponse.json();
-        events.push({
-            id: `ok-ready-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'OK',
-            level: 'INFO',
-            msg: `✓ /ready: ${data.status || readyResponse.status} (${latency}ms)`,
-        });
-    }
-    catch (error) {
-        events.push({
-            id: `err-ready-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: `✗ /ready failed: ${error.message || 'Unknown error'}`,
-        });
-    }
-    // Test 3: List runs (requires auth, but tests API endpoint)
-    try {
-        const startTime = Date.now();
-        const runsResponse = await fetch(`${gatewayUrl}/api/runs?limit=1`, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${process.env.GATEWAY_TOKEN || ''}`,
-            },
-            signal: AbortSignal.timeout(5000),
-        });
-        const latency = Date.now() - startTime;
-        if (runsResponse.ok) {
-            const data = await runsResponse.json();
-            events.push({
-                id: `ok-runs-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'OK',
-                level: 'INFO',
-                msg: `✓ /api/runs: ${runsResponse.status} (${latency}ms) - ${data.runs?.length || 0} runs`,
-            });
-        }
-        else {
-            events.push({
-                id: `warn-runs-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'WARN',
-                msg: `⚠ /api/runs: ${runsResponse.status} (${latency}ms) - ${runsResponse.status === 401 ? 'Auth required' : 'Error'}`,
-            });
-        }
-    }
-    catch (error) {
-        events.push({
-            id: `err-runs-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: `✗ /api/runs failed: ${error.message || 'Unknown error'}`,
-        });
-    }
-    // Test 4: Metrics endpoint (optional - longer timeout, warn on failure)
-    try {
-        const startTime = Date.now();
-        const metricsResponse = await fetch(`${gatewayUrl}/metrics`, {
-            method: 'GET',
-            signal: AbortSignal.timeout(15000), // 15s timeout for metrics
-        });
-        const latency = Date.now() - startTime;
-        const text = await metricsResponse.text();
-        const lines = text.split('\n').filter(l => l.trim() && !l.startsWith('#')).length;
-        events.push({
-            id: `ok-metrics-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'OK',
-            level: 'INFO',
-            msg: `✓ /metrics: ${metricsResponse.status} (${latency}ms) - ${lines} metrics`,
-        });
-    }
-    catch (error) {
-        // Metrics is optional - show WARN not ERR
-        const errorMsg = error.message || 'Unknown error';
-        const isTimeout = errorMsg.includes('timeout') || errorMsg.includes('aborted');
-        events.push({
-            id: `warn-metrics-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'WARN',
-            msg: `⚠ /metrics unavailable (${isTimeout ? 'timeout' : errorMsg.substring(0, 30)})`,
-        });
-    }
-    // Summary
-    events.push({
-        id: `sys-verify-done-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'SYS',
-        level: 'INFO',
-        msg: 'Verification complete. Connection is working.',
-    });
-    return { events };
-}
-/**
- * 4.7️⃣ status
- *
- * Prints connection summary and fetches capabilities
- */
-async function handleStatus(ctx, args) {
-    const { gatewayConnectionStore } = await import('../state/gatewayConnectionStore.js');
-    const { capabilitiesStore } = await import('../state/capabilitiesStore.js');
-    const { GatewayClient } = await import('../../../gateway-client.js');
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: 'status',
-    };
-    const events = [cmdEvent];
-    // Get connection state
-    const connState = gatewayConnectionStore.getState();
-    // Print connection summary
-    if (connState.status === 'connected') {
-        events.push({
-            id: `sys-status-conn-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `Connection: CONNECTED`,
-        });
-        if (connState.target !== connState.resolvedTo) {
-            events.push({
-                id: `sys-status-targets-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `  Target: ${connState.target} → ${connState.resolvedTo}`,
-            });
-        }
-        else {
-            events.push({
-                id: `sys-status-target-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `  Target: ${connState.resolvedTo}`,
-            });
-        }
-        if (connState.latencyMs !== undefined) {
-            events.push({
-                id: `sys-status-latency-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `  Latency: ${connState.latencyMs}ms`,
-            });
-        }
-        // PROOF: Make a real API call right now to verify connection works
-        events.push({
-            id: `sys-status-verify-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `Verifying connection with live API call...`,
-        });
-        try {
-            const verifyStartTime = Date.now();
-            const verifyClient = new GatewayClient({ gatewayUrl: connState.resolvedTo });
-            const verifyHealth = await verifyClient.health();
-            const verifyLatency = Date.now() - verifyStartTime;
-            // Show actual response data to prove it's real
-            events.push({
-                id: `ok-status-verify-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'OK',
-                level: 'INFO',
-                msg: `✓ Verified: Gateway responded in ${verifyLatency}ms`,
-            });
-            if (verifyHealth.status) {
-                events.push({
-                    id: `sys-status-health-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: `  Health: ${verifyHealth.status}`,
-                });
-            }
-            if (verifyHealth.persistence) {
-                events.push({
-                    id: `sys-status-persistence-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: `  Persistence: ${verifyHealth.persistence}`,
-                });
-            }
-            // Show timestamp from server to prove it's real
-            if (verifyHealth.time) {
-                events.push({
-                    id: `sys-status-time-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: `  Server time: ${verifyHealth.time}`,
-                });
-            }
-        }
-        catch (error) {
-            // If verification fails, connection is NOT real
-            events.push({
-                id: `err-status-verify-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'ERR',
-                level: 'ERROR',
-                msg: `✗ Verification FAILED: ${error.message || 'Connection not working'}`,
-            });
-            // Update store to reflect reality
-            gatewayConnectionStore.setError(connState.resolvedTo, error.code || 'VERIFY_FAILED', 'Connection verification failed', 'Run "connect" again');
-            return { events };
-        }
-        // Fetch capabilities (endpoint may not exist - that's OK)
-        capabilitiesStore.setLoading();
-        try {
-            // Try /api/capabilities endpoint (may not exist on all Gateway versions)
-            const response = await fetch(`${connState.resolvedTo}/api/capabilities`, {
-                method: 'GET',
-                signal: AbortSignal.timeout(5000),
-            });
-            if (response.ok) {
-                const data = await response.json();
-                const items = data.capabilities || data.items || [];
-                capabilitiesStore.setLoaded(items);
-                events.push({
-                    id: `ok-capabilities-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'OK',
-                    level: 'INFO',
-                    msg: `Capabilities: ${items.length} items loaded`,
-                });
-            }
-            else if (response.status === 404) {
-                // 404 is expected - endpoint doesn't exist yet (not an error)
-                capabilitiesStore.setLoaded([]);
-                events.push({
-                    id: `sys-capabilities-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: `Capabilities: endpoint not implemented (404) - this is normal`,
-                });
-            }
-            else {
-                // Other error status
-                capabilitiesStore.setLoaded([]);
-                events.push({
-                    id: `sys-capabilities-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: `Capabilities: endpoint returned ${response.status}`,
-                });
-            }
-        }
-        catch (error) {
-            // Network error - non-fatal
-            capabilitiesStore.setLoaded([]);
-            const errorMsg = error.message?.substring(0, 40) || 'unavailable';
-            events.push({
-                id: `sys-capabilities-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `Capabilities: ${errorMsg}`,
-            });
-        }
-    }
-    else {
-        events.push({
-            id: `sys-status-conn-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'WARN',
-            msg: `Connection: ${connState.status.toUpperCase()}`,
-        });
-        if (connState.status === 'error' && 'message' in connState) {
-            events.push({
-                id: `sys-status-error-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'WARN',
-                msg: `  Error: ${connState.message}`,
-            });
-        }
-    }
-    return { events };
-}
-/**
- * 5️⃣ start <agentId>
- *
- * Calls v1Adapters/runs.startRun(agentId)
- * Updates posture → AVAILABLE (mode: RUNNING)
- */
-async function handleStart(ctx, args) {
-    const agentId = args[0]?.trim();
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: `start ${agentId || ''}`,
-    };
-    if (!agentId) {
-        return {
-            events: [
-                cmdEvent,
-                {
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: 'Agent ID required (usage: start <agentId>)',
-                },
-            ],
-        };
-    }
-    // Get connection state - REQUIREMENT A: use effective gateway URL from store
-    const { gatewayConnectionStore } = await import('../state/gatewayConnectionStore.js');
-    const connState = gatewayConnectionStore.getState();
-    // REQUIREMENT A: Check if connected and have effective URL
-    if (connState.status !== 'connected' || !connState.resolvedTo) {
-        return {
-            events: [
-                cmdEvent,
-                {
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: 'Not connected. Run "connect" first.',
-                },
-            ],
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                network: unavailable('Not connected', 'Run "connect" first'),
-                posture: unavailable('Cannot start run - not connected', 'Run "connect" first'),
-            }),
-        };
-    }
-    // REQUIREMENT B: Use effective gateway URL from store (single source of truth)
-    const effectiveGatewayUrl = connState.resolvedTo;
-    // REQUIREMENT C: Add debug output to prove routing is correct
-    const events = [
-        cmdEvent,
-        {
-            id: `sys-start-gateway-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `Using gateway URL: ${effectiveGatewayUrl}`,
-        },
-    ];
-    try {
-        const result = await startRun(agentId, undefined, effectiveGatewayUrl);
-        // Add debug logs to events if present
-        if (result.ok && result.debugLogs) {
-            result.debugLogs.forEach((log) => {
-                events.push({
-                    id: `sys-debug-${Date.now()}-${Math.random()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: log.replace(/^\[SYS\]\s*/, ''), // Remove duplicate [SYS] tag
-                });
-            });
-        }
-        if (!result.ok) {
-            const error = result.error;
-            const httpStatus = error.httpStatus;
-            const responseBody = error.responseBody;
-            // Add debug logs to events if present
-            if (error.debugLogs) {
-                error.debugLogs.forEach((log) => {
-                    events.push({
-                        id: `sys-debug-${Date.now()}-${Math.random()}`,
-                        ts: Date.now(),
-                        tag: 'SYS',
-                        level: 'INFO',
-                        msg: log.replace(/^\[SYS\]\s*/, ''), // Remove duplicate [SYS] tag
-                    });
-                });
-            }
-            // Build detailed error message
-            let errorMsg = `Failed to start run: ${error.message}`;
-            if (httpStatus) {
-                errorMsg = `${httpStatus} ${httpStatus === 400 ? 'Bad Request' : httpStatus === 404 ? 'Not Found' : httpStatus === 401 ? 'Unauthorized' : 'Error'}: ${error.message}`;
-            }
-            // Include response body if available
-            if (responseBody) {
-                try {
-                    const bodyStr = typeof responseBody === 'string' ? responseBody : JSON.stringify(responseBody);
-                    errorMsg += `\n  Response: ${bodyStr}`;
-                }
-                catch {
-                    // Ignore serialization errors
-                }
-            }
-            events.push({
-                id: `err-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'ERR',
-                level: 'ERROR',
-                msg: errorMsg,
-            });
-            return {
-                events,
-                uiStateUpdate: (prev) => ({
-                    ...prev,
-                    posture: unavailable(error.message, error.nextAction || 'Check gateway connection and agent ID'),
-                }),
-            };
-        }
-        // Success: posture → AVAILABLE (mode: RUNNING)
-        events.push({
-            id: `ok-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'OK',
-            level: 'INFO',
-            msg: `Run started: ${result.data.id}`,
-        });
-        return {
-            events,
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                posture: available({
-                    mode: 'RUNNING',
-                }),
-            }),
-        };
-    }
-    catch (error) {
-        const classified = classifyError(error, 'start run');
-        events.push({
-            id: `err-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: `Failed to start run: ${classified.message}`,
-        });
-        return {
-            events,
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                posture: unavailable(classified.message, classified.nextAction),
-            }),
-        };
-    }
-}
-/**
- * 6️⃣ runs list
- *
- * Calls v1Adapters/runs (needs listRuns function - TODO)
- * Updates posture → AVAILABLE
- */
-async function handleRuns(ctx, args) {
-    const subcommand = args[0]?.toLowerCase() || 'list';
-    if (subcommand === 'list') {
-        return handleRunsList(ctx, args.slice(1));
-    }
-    else {
-        return {
-            events: [{
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: `Unknown runs subcommand: ${subcommand} (try: list)`,
-                }],
-        };
-    }
-}
-async function handleRunsList(ctx, args) {
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: 'runs list',
-    };
-    // Check connection first
-    const { gatewayConnectionStore } = await import('../state/gatewayConnectionStore.js');
-    const connState = gatewayConnectionStore.getState();
-    if (connState.status !== 'connected') {
-        const classified = classifyError({ code: 'NOT_CONNECTED', message: 'Not connected' }, 'list runs');
-        return {
-            events: [
-                cmdEvent,
-                {
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: `Failed to list runs: ${classified.message}`,
-                },
-            ],
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                network: unavailable(classified.message, classified.nextAction),
-                assets: unavailable('Cannot fetch runs - not connected', 'Run "connect" first'),
-            }),
-        };
-    }
-    // Add debug output
-    const events = [
-        cmdEvent,
-        {
-            id: `sys-runs-gateway-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `Fetching runs from: ${connState.resolvedTo}`,
-        },
-    ];
-    try {
-        // Use resolved endpoint from store (same as start command)
-        const result = await listRuns({ limit: 50 }, connState.resolvedTo);
-        // Add debug logs to events if present
-        if (result.ok && result.debugLogs) {
-            result.debugLogs.forEach((log) => {
-                events.push({
-                    id: `sys-debug-${Date.now()}-${Math.random()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: log.replace(/^\[SYS\]\s*/, ''), // Remove duplicate [SYS] tag
-                });
-            });
-        }
-        if (!result.ok) {
-            const error = result.error;
-            const httpStatus = error.httpStatus;
-            const responseBody = error.responseBody;
-            // Build detailed error message
-            let errorMsg = `Failed to list runs: ${error.message}`;
-            if (httpStatus) {
-                errorMsg = `${httpStatus} ${httpStatus === 400 ? 'Bad Request' : httpStatus === 401 ? 'Unauthorized' : httpStatus === 403 ? 'Forbidden' : httpStatus === 404 ? 'Not Found' : 'Error'}: ${error.message}`;
-            }
-            // Include response body if available
-            if (responseBody) {
-                try {
-                    const bodyStr = typeof responseBody === 'string' ? responseBody : JSON.stringify(responseBody);
-                    errorMsg += `\n  Response: ${bodyStr}`;
-                }
-                catch {
-                    // Ignore serialization errors
-                }
-            }
-            // Add debug logs to events if present
-            if (error.debugLogs) {
-                error.debugLogs.forEach((log) => {
-                    events.push({
-                        id: `sys-debug-${Date.now()}-${Math.random()}`,
-                        ts: Date.now(),
-                        tag: 'SYS',
-                        level: 'INFO',
-                        msg: log.replace(/^\[SYS\]\s*/, ''), // Remove duplicate [SYS] tag
-                    });
-                });
-            }
-            events.push({
-                id: `err-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'ERR',
-                level: 'ERROR',
-                msg: errorMsg,
-            });
-            return {
-                events,
-                uiStateUpdate: (prev) => ({
-                    ...prev,
-                    assets: unavailable(error.message, error.nextAction || 'Check gateway connection'),
-                }),
-            };
-        }
-        const runs = result.data;
-        const count = runs.length;
-        const activeCount = runs.filter(r => r.status === 'running' || r.status === 'queued').length;
-        const completedCount = runs.filter(r => r.status === 'completed').length;
-        const errorCount = runs.filter(r => r.status === 'failed' || r.status === 'cancelled').length;
-        // Debug: Show what we got
-        events.push({
-            id: `sys-runs-count-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `Found ${count} run${count === 1 ? '' : 's'}: ${activeCount} active, ${completedCount} completed, ${errorCount} failed`,
-        });
-        // Show run IDs for debugging
-        if (count > 0 && count <= 10) {
-            runs.forEach((run, idx) => {
-                events.push({
-                    id: `sys-run-${idx}-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: `  ${idx + 1}. ${run.id} (${run.status}) - ${run.name}`,
-                });
-            });
-        }
-        // Update Assets panel with run summary
-        const assetsState = {
-            total: count,
-            active: activeCount,
-            idle: completedCount,
-            error: errorCount,
-        };
-        // Emit exactly one terminal event
-        const resultEvent = {
-            id: `result-${Date.now()}`,
-            ts: Date.now(),
-            tag: count === 0 ? 'WARN' : 'OK',
-            level: count === 0 ? 'WARN' : 'INFO',
-            msg: count === 0 ? 'No runs found' : `${count} run${count === 1 ? '' : 's'} found (${activeCount} active, ${completedCount} completed, ${errorCount} failed)`,
-        };
-        events.push(resultEvent);
-        return {
-            events,
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                assets: available(assetsState),
-            }),
-        };
-    }
-    catch (error) {
-        const classified = classifyError(error, 'list runs');
-        events.push({
-            id: `err-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: `Failed to list runs: ${classified.message}`,
-        });
-        return {
-            events,
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                assets: unavailable(classified.message, classified.nextAction),
-            }),
-        };
-    }
-}
-/**
- * 7️⃣ diagnose
- *
- * Diagnoses Gateway connection issues
- * Shows detailed information about why connect is failing
- */
-async function handleDiagnose(ctx, args) {
-    const events = [
-        {
-            id: `cmd-diagnose-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'CMD',
-            level: 'INFO',
-            msg: 'diagnose',
-        },
-        {
-            id: `sys-diagnose-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: 'Diagnosing Gateway connection...',
-        },
-    ];
-    try {
-        const result = await diagnoseGateway();
-        // Show endpoint being tested
-        events.push({
-            id: `diag-endpoint-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `Testing: ${result.endpoint}`,
-        });
-        if (result.healthReachable && result.healthResponse) {
-            // Success!
-            events.push({
-                id: `diag-success-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'OK',
-                level: 'INFO',
-                msg: `✅ Gateway is reachable`,
-            });
-            const healthStr = JSON.stringify(result.healthResponse).substring(0, 150);
-            events.push({
-                id: `diag-health-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `Health: ${healthStr}...`,
-            });
-        }
-        else {
-            // Failure - show detailed error
-            events.push({
-                id: `diag-error-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'ERR',
-                level: 'ERROR',
-                msg: `❌ ${result.error || 'Connection failed'}`,
-            });
-            if (result.errorCode) {
-                events.push({
-                    id: `diag-code-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: `Error code: ${result.errorCode}`,
-                });
-            }
-            // Provide specific guidance based on error
-            if (result.errorCode === 'ECONNREFUSED') {
-                events.push({
-                    id: `diag-help-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: 'Gateway is not running. Start it with: docker-compose up -d gateway',
-                });
-            }
-            else if (result.errorCode === 'ETIMEDOUT' || result.errorCode === 'ECONNABORTED') {
-                events.push({
-                    id: `diag-help-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: 'Connection timeout. Check firewall or network connectivity.',
-                });
-            }
-            else if (result.errorCode?.startsWith('HTTP_404')) {
-                events.push({
-                    id: `diag-help-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'SYS',
-                    level: 'INFO',
-                    msg: 'Health endpoint not found. Gateway may be running but misconfigured.',
-                });
-            }
-        }
-        return { events };
-    }
-    catch (error) {
-        events.push({
-            id: `diag-exception-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'ERR',
-            level: 'ERROR',
-            msg: `Diagnostic failed: ${error?.message || 'Unknown error'}`,
-        });
-        return { events };
-    }
-}
-/**
- * 8️⃣ system
- *
- * Aggregates network state, config, agent count, run count
- * Updates statusStrip → AVAILABLE
- */
-async function handleSystem(ctx, args) {
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: 'system',
-    };
-    const events = [cmdEvent];
-    try {
-        // Get connection state
-        const { gatewayConnectionStore } = await import('../state/gatewayConnectionStore.js');
-        const connState = gatewayConnectionStore.getState();
-        // Aggregate system state
-        const agentsResult = listAgents();
-        const configResult = loadConfig();
-        const agentCount = agentsResult.ok ? agentsResult.data.length : 0;
-        const connected = connState.status === 'connected';
-        // Build status summary
-        const statusLeft = connected ? 'ONLINE' : 'OFFLINE';
-        const statusRight = `Agents: ${agentCount}`;
-        // Show system health summary
-        events.push({
-            id: `sys-health-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `System Health Snapshot`,
-        });
-        events.push({
-            id: `sys-conn-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: connected ? 'INFO' : 'WARN',
-            msg: `  Gateway: ${connected ? 'CONNECTED' : connState.status.toUpperCase()}`,
-        });
-        if (connected && connState.resolvedTo) {
-            events.push({
-                id: `sys-endpoint-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'SYS',
-                level: 'INFO',
-                msg: `  Endpoint: ${connState.resolvedTo}`,
-            });
-        }
-        events.push({
-            id: `sys-agents-${Date.now()}`,
-            ts: Date.now(),
-            tag: 'SYS',
-            level: 'INFO',
-            msg: `  Agents: ${agentCount}`,
-        });
-        // Refresh resources (trigger collector update)
-        const { collectResources } = await import('../collectors/resources.js');
-        const resources = await collectResources();
-        // Determine overall health
-        const isHealthy = connected && agentCount >= 0; // Basic health check
-        events.push({
-            id: isHealthy ? `ok-${Date.now()}` : `warn-${Date.now()}`,
-            ts: Date.now(),
-            tag: isHealthy ? 'OK' : 'WARN',
-            level: isHealthy ? 'INFO' : 'WARN',
-            msg: isHealthy ? 'System healthy' : 'Partial connectivity',
-        });
-        return {
-            events,
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                resources, // Refresh resources
-                statusStrip: available({
-                    left: statusLeft,
-                    right: statusRight,
-                }),
-                // Refresh network timestamp if connected (preserve state, just update)
-                network: connected && connState.status === 'connected' ? prev.network : prev.network,
-            }),
-        };
-    }
-    catch (error) {
-        const classified = classifyError(error, 'system check');
-        return {
-            events: [
-                cmdEvent,
-                {
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: `System check failed: ${classified.message}`,
-                },
-            ],
-            uiStateUpdate: (prev) => ({
-                ...prev,
-                statusStrip: unavailable(classified.message, classified.nextAction),
-            }),
-        };
-    }
-}
-/**
- * 9️⃣ debug <subcommand>
- *
- * Debug commands for TUI lifecycle investigation
- * Only available with TUI_DEBUG=1
- */
-async function handleDebug(ctx, args) {
-    // Check if debug mode is enabled (some commands require it, but geo is always available)
-    const isDebugMode = process.env.TUI_DEBUG === '1';
-    const subcommand = args[0]?.toLowerCase();
-    if (!subcommand) {
-        return {
-            events: [{
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: 'Usage: debug <ui|geo|resize|resize-test|resize-torture|resize-trace|layout|tree|dump-layout|fullscreen|size|listeners|stdout>',
-                }],
-        };
-    }
-    // Allow geo and layout dump commands without debug mode (diagnostic tools)
-    const alwaysAllowed = ['geo', 'geometry', 'dump-layout', 'layout', 'layout-detail'];
-    const requiresDebug = !alwaysAllowed.includes(subcommand);
-    if (requiresDebug && !isDebugMode) {
-        return {
-            events: [{
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: 'Debug commands require TUI_DEBUG=1 environment variable (except: geo, dump-layout, layout)',
-                }],
-        };
-    }
-    const cmdEvent = {
-        id: `cmd-${Date.now()}`,
-        ts: Date.now(),
-        tag: 'CMD',
-        level: 'INFO',
-        msg: `debug ${subcommand}`,
-    };
-    // Import debug utils (lazy load)
-    try {
-        const debugUtils = await import('../ui/debugUtils.js');
-        if (subcommand === 'ui') {
-            // Step 1B: UI inventory dump
-            // Get the screen from UIRuntime
-            const { getUIRuntime } = await import('../ui/uiRuntime.js');
-            const runtime = getUIRuntime();
-            debugUtils.dumpUIInventory(runtime.screen);
-            return {
-                events: [cmdEvent, {
-                        id: `dbg-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: 'UI inventory dumped to Operations (check above)',
-                    }],
-            };
-        }
-        else if (subcommand === 'geo' || subcommand === 'geometry') {
-            // Step 1: Enhanced geometry debug (prove which values change on fullscreen)
-            const { getUIRuntime } = await import('../ui/uiRuntime.js');
-            const { getTerminalGeometry, formatGeometry } = await import('../tui/geometry.js');
-            const runtime = getUIRuntime();
-            const geo = getTerminalGeometry(runtime.screen);
-            // Get all geometry sources
-            const screenCols = runtime.screen.cols ?? 'N/A';
-            const screenRows = runtime.screen.rows ?? 'N/A';
-            const screenWidth = runtime.screen.width ?? 'N/A';
-            const screenHeight = runtime.screen.height ?? 'N/A';
-            const stdoutCols = process.stdout.columns ?? 'N/A';
-            const stdoutRows = process.stdout.rows ?? 'N/A';
-            return {
-                events: [
-                    cmdEvent,
-                    {
-                        id: `dbg-geo-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `=== GEOMETRY SOURCES ===`,
-                    },
-                    {
-                        id: `dbg-geo-screen-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `screen.cols=${screenCols} screen.rows=${screenRows}`,
-                    },
-                    {
-                        id: `dbg-geo-screen-wh-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `screen.width=${screenWidth} screen.height=${screenHeight}`,
-                    },
-                    {
-                        id: `dbg-geo-stdout-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `stdout.columns=${stdoutCols} stdout.rows=${stdoutRows}`,
-                    },
-                    {
-                        id: `dbg-geo-final-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `Final: ${formatGeometry(geo)}`,
-                    },
-                    {
-                        id: `dbg-geo-layout-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `Layout using: cols=${geo.cols} rows=${geo.rows} safeCols=${geo.safeCols} safeRows=${geo.safeRows}`,
-                    },
-                ],
-            };
-        }
-        else if (subcommand === 'resize') {
-            // Phase C1: Resize stats
-            const resizeStats = debugUtils.getResizeStats();
-            const { getUIRuntime } = await import('../ui/uiRuntime.js');
-            const runtime = getUIRuntime();
-            const childrenCount = (runtime.screen.children || []).length;
-            return {
-                events: [
-                    cmdEvent,
-                    {
-                        id: `dbg-resize-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `=== RESIZE STATS ===`,
-                    },
-                    {
-                        id: `dbg-resize2-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `Events: ${resizeStats.eventCount}`,
-                    },
-                    {
-                        id: `dbg-resize3-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `Applies: ${resizeStats.applyCount}`,
-                    },
-                    {
-                        id: `dbg-resize4-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `Handler bound: ${resizeStats.handlerBound ? 'yes' : 'no'}`,
-                    },
-                    {
-                        id: `dbg-resize5-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `Screen children: ${childrenCount} (should be constant)`,
-                    },
-                    {
-                        id: `dbg-resize6-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `Debounce: 100ms`,
-                    },
-                    {
-                        id: `dbg-resize7-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `=== END RESIZE STATS ===`,
-                    },
-                ],
-            };
-        }
-        else if (subcommand === 'resize-test') {
-            // Comprehensive resize diagnostics (must pass all checks)
-            const { getUIRuntime } = await import('../ui/uiRuntime.js');
-            const { getTerminalGeometry, formatGeometry } = await import('../tui/geometry.js');
-            const runtime = getUIRuntime();
-            const geo = getTerminalGeometry(runtime.screen);
-            const resizeStats = debugUtils.getResizeStats();
-            // Get all dimension sources
-            const screenCols = runtime.screen.cols ?? 'N/A';
-            const screenRows = runtime.screen.rows ?? 'N/A';
-            const screenWidth = runtime.screen.width ?? 'N/A';
-            const screenHeight = runtime.screen.height ?? 'N/A';
-            const stdoutCols = process.stdout.columns ?? 'N/A';
-            const stdoutRows = process.stdout.rows ?? 'N/A';
-            // Get screen children count (must be constant)
-            const childrenCount = (runtime.screen.children || []).length;
-            // Check for duplicates
-            const commandLineCount = (runtime.screen.children || []).filter((w) => w.type === 'textbox' || w.type === 'box').length;
-            const events = [
-                cmdEvent,
-                {
-                    id: `dbg-test-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `=== RESIZE TEST DIAGNOSTICS ===`,
-                },
-                {
-                    id: `dbg-test-1-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `--- Terminal Dimensions ---`,
-                },
-                {
-                    id: `dbg-test-2-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `process.stdout: columns=${stdoutCols} rows=${stdoutRows}`,
-                },
-                {
-                    id: `dbg-test-3-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `screen.cols=${screenCols} screen.rows=${screenRows}`,
-                },
-                {
-                    id: `dbg-test-4-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `screen.width=${screenWidth} screen.height=${screenHeight}`,
-                },
-                {
-                    id: `dbg-test-5-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Final geometry: ${formatGeometry(geo)}`,
-                },
-                {
-                    id: `dbg-test-6-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `--- Resize Stats ---`,
-                },
-                {
-                    id: `dbg-test-7-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Events: ${resizeStats.eventCount}`,
-                },
-                {
-                    id: `dbg-test-8-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Applies: ${resizeStats.applyCount}`,
-                },
-                {
-                    id: `dbg-test-9-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Handler bound: ${resizeStats.handlerBound ? 'yes' : 'no'}`,
-                },
-                {
-                    id: `dbg-test-10-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Resize listeners: ${resizeStats.listenerCount || 0} (expected: 1-2)`,
-                },
-                {
-                    id: `dbg-test-11-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `--- UI State ---`,
-                },
-                {
-                    id: `dbg-test-12-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Screen children: ${childrenCount} (should be constant ~8)`,
-                },
-                {
-                    id: `dbg-test-13-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `UI rebuilds: ${resizeStats.uiRebuildCount || 0} (must be 0)`,
-                },
-                {
-                    id: `dbg-test-14-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: childrenCount > 10 ? 'ERROR' : 'INFO',
-                    msg: `${childrenCount > 10 ? '⚠ FAIL' : '✓ PASS'}: Children count check (${childrenCount} <= 10)`,
-                },
-                {
-                    id: `dbg-test-15-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: (resizeStats.uiRebuildCount || 0) > 0 ? 'ERROR' : 'INFO',
-                    msg: `${(resizeStats.uiRebuildCount || 0) > 0 ? '⚠ FAIL' : '✓ PASS'}: No UI rebuilds (${resizeStats.uiRebuildCount || 0} === 0)`,
-                },
-                {
-                    id: `dbg-test-16-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: (resizeStats.listenerCount || 0) > 2 ? 'ERROR' : 'INFO',
-                    msg: `${(resizeStats.listenerCount || 0) > 2 ? '⚠ FAIL' : '✓ PASS'}: Listener count check (${resizeStats.listenerCount || 0} <= 2)`,
-                },
-                {
-                    id: `dbg-test-17-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `--- Layout Bounds ---`,
-                },
-                {
-                    id: `dbg-test-18-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `safeCols: ${geo.safeCols}, safeRows: ${geo.safeRows}`,
-                },
-                {
-                    id: `dbg-test-19-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Max right edge allowed: ${geo.safeCols - 1}`,
-                },
-                {
-                    id: `dbg-test-20-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `=== END RESIZE TEST ===`,
-                },
-                {
-                    id: `dbg-test-21-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Toggle fullscreen and run again to verify stats update correctly.`,
-                },
-            ];
-            return { events };
-        }
-        else if (subcommand === 'resize-torture' || subcommand === 'torture') {
-            // Resize torture test - comprehensive widget duplication detection
-            const { getUIRuntime } = await import('../ui/uiRuntime.js');
-            const runtime = getUIRuntime();
-            const screen = runtime.screen;
-            const widgets = runtime.widgets;
-            // Get current dimensions
-            const { getTerminalGeometry } = await import('../tui/geometry.js');
-            const geo = getTerminalGeometry(screen);
-            // Count all widgets recursively
-            function countWidgets(node, depth = 0) {
-                const result = { total: 0, byType: {}, byId: {} };
-                if (!node)
-                    return result;
-                result.total = 1;
-                // Track by type
-                const type = node.type || 'unknown';
-                result.byType[type] = (result.byType[type] || 0) + 1;
-                // Track by ID (if available)
-                const id = node.options?.id || node._id || 'no-id';
-                result.byId[id] = (result.byId[id] || 0) + 1;
-                // Recursively count children
-                if (node.children && Array.isArray(node.children)) {
-                    for (const child of node.children) {
-                        const childResult = countWidgets(child, depth + 1);
-                        result.total += childResult.total;
-                        // Merge byType
-                        for (const [t, count] of Object.entries(childResult.byType)) {
-                            result.byType[t] = (result.byType[t] || 0) + count;
-                        }
-                        // Merge byId
-                        for (const [i, count] of Object.entries(childResult.byId)) {
-                            result.byId[i] = (result.byId[i] || 0) + count;
-                        }
-                    }
-                }
-                return result;
-            }
-            const widgetStats = countWidgets(screen);
-            // Check for duplicates
-            const duplicateTypes = [];
-            for (const [type, count] of Object.entries(widgetStats.byType)) {
-                if (count > 1 && type !== 'box' && type !== 'text' && type !== 'line') {
-                    duplicateTypes.push(`${type}=${count}`);
-                }
-            }
-            const duplicateIds = [];
-            for (const [id, count] of Object.entries(widgetStats.byId)) {
-                if (count > 1 && id !== 'no-id') {
-                    duplicateIds.push(`${id}=${count}`);
-                }
-            }
-            // Count specific widgets
-            const postureCount = widgetStats.byType['box'] || 0; // Approximate
-            const commandLineCount = screen.children.filter((w) => w === widgets.commandLine).length;
-            // Get resize stats
-            const resizeStats = debugUtils.getResizeStats();
-            const events = [
-                cmdEvent,
-                {
-                    id: `dbg-torture-1-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `=== RESIZE TORTURE TEST ===`,
-                },
-                {
-                    id: `dbg-torture-2-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Instructions: Toggle fullscreen ↔ windowed 10 times, then run this again.`,
-                },
-                {
-                    id: `dbg-torture-3-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: ``,
-                },
-                {
-                    id: `dbg-torture-4-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Current terminal: ${geo.cols}x${geo.rows} (source: ${geo.source})`,
-                },
-                {
-                    id: `dbg-torture-5-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: ``,
-                },
-                {
-                    id: `dbg-torture-6-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `--- Widget Counts ---`,
-                },
-                {
-                    id: `dbg-torture-7-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Total widgets: ${widgetStats.total} (should be stable ~8-15)`,
-                },
-                {
-                    id: `dbg-torture-8-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Screen.children: ${screen.children.length}`,
-                },
-                {
-                    id: `dbg-torture-9-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Command line instances: ${commandLineCount} (must be 1)`,
-                },
-                {
-                    id: `dbg-torture-10-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: ``,
-                },
-                {
-                    id: `dbg-torture-11-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `--- Widget Types ---`,
-                },
-            ];
-            // Add widget type counts
-            for (const [type, count] of Object.entries(widgetStats.byType)) {
-                events.push({
-                    id: `dbg-torture-type-${type}-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  ${type}: ${count}`,
-                });
-            }
-            events.push({
-                id: `dbg-torture-12-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: ``,
-            });
-            events.push({
-                id: `dbg-torture-13-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: `--- Resize Stats ---`,
-            });
-            events.push({
-                id: `dbg-torture-14-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: `Resize events: ${resizeStats.eventCount}`,
-            });
-            events.push({
-                id: `dbg-torture-15-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: `Resize applies: ${resizeStats.applyCount}`,
-            });
-            events.push({
-                id: `dbg-torture-16-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: `UI rebuilds: ${resizeStats.uiRebuildCount || 0} (must be 0)`,
-            });
-            events.push({
-                id: `dbg-torture-17-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: ``,
-            });
-            events.push({
-                id: `dbg-torture-18-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: duplicateTypes.length > 0 ? 'ERROR' : 'INFO',
-                msg: `--- Duplication Check ---`,
-            });
-            if (duplicateTypes.length > 0) {
-                events.push({
-                    id: `dbg-torture-19-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'ERROR',
-                    msg: `⚠ FAIL: Duplicate widget types detected: ${duplicateTypes.join(', ')}`,
-                });
-            }
-            else {
-                events.push({
-                    id: `dbg-torture-19-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `✓ PASS: No duplicate widget types`,
-                });
-            }
-            if (commandLineCount > 1) {
-                events.push({
-                    id: `dbg-torture-20-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'ERROR',
-                    msg: `⚠ FAIL: Multiple command lines (${commandLineCount})`,
-                });
-            }
-            else {
-                events.push({
-                    id: `dbg-torture-20-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `✓ PASS: Single command line`,
-                });
-            }
-            if ((resizeStats.uiRebuildCount || 0) > 0) {
-                events.push({
-                    id: `dbg-torture-21-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'ERROR',
-                    msg: `⚠ FAIL: UI was rebuilt ${resizeStats.uiRebuildCount} times (should be 0)`,
-                });
-            }
-            else {
-                events.push({
-                    id: `dbg-torture-21-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `✓ PASS: No UI rebuilds`,
-                });
-            }
-            events.push({
-                id: `dbg-torture-22-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: ``,
-            });
-            events.push({
-                id: `dbg-torture-23-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: `=== END TORTURE TEST ===`,
-            });
-            return { events };
-        }
-        else if (subcommand === 'size') {
-            // dbg:size - Show terminal sizing and environment info (works in V3 and V4)
-            const { handleSizeCommandWithScreen } = await import('../../../core/commands/size.js');
-            const { getUIRuntime } = await import('../ui/uiRuntime.js');
-            const runtime = getUIRuntime();
-            const screen = runtime.screen;
-            // Pass screen object to get actual dimensions
-            return handleSizeCommandWithScreen(ctx, args, {
-                width: screen.width,
-                height: screen.height,
-                cols: screen.cols,
-                rows: screen.rows,
-            });
-        }
-        else if (subcommand === 'tree') {
-            // Widget tree diagnostic - shows widget counts to detect duplication
-            const { getUIRuntime } = await import('../ui/uiRuntime.js');
-            const runtime = getUIRuntime();
-            const screen = runtime.screen;
-            const widgets = runtime.widgets;
-            // Count widgets recursively
-            function countWidgets(node, depth = 0) {
-                const result = { total: 0, byName: {} };
-                if (!node)
-                    return result;
-                result.total = 1;
-                // Try to identify widget by title or type
-                const name = node.options?.title || node.options?.content || node.type || 'unknown';
-                const shortName = name.substring(0, 30).replace(/\s+/g, '_');
-                result.byName[shortName] = (result.byName[shortName] || 0) + 1;
-                // Recursively count children
-                if (node.children && Array.isArray(node.children)) {
-                    for (const child of node.children) {
-                        const childResult = countWidgets(child, depth + 1);
-                        result.total += childResult.total;
-                        // Merge byName
-                        for (const [n, count] of Object.entries(childResult.byName)) {
-                            result.byName[n] = (result.byName[n] || 0) + count;
-                        }
-                    }
-                }
-                return result;
-            }
-            // Count specific widgets
-            const screenChildren = screen.children || [];
-            const postureCount = screenChildren.filter((w) => w === widgets.posture).length;
-            const resourcesCount = screenChildren.filter((w) => w === widgets.resources).length;
-            const assetsCount = screenChildren.filter((w) => w === widgets.assets).length;
-            const operationsCount = screenChildren.filter((w) => w === widgets.operations).length;
-            const networkCount = screenChildren.filter((w) => w === widgets.network).length;
-            const capabilitiesCount = screenChildren.filter((w) => w === widgets.capabilities).length;
-            const commandLineCount = screenChildren.filter((w) => w === widgets.commandLine).length;
-            const statusStripCount = screenChildren.filter((w) => w === widgets.statusStrip).length;
-            const treeStats = countWidgets(screen);
-            const events = [
-                cmdEvent,
-                {
-                    id: `dbg-tree-1-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `=== WIDGET TREE DIAGNOSTIC ===`,
-                },
-                {
-                    id: `dbg-tree-2-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: ``,
-                },
-                {
-                    id: `dbg-tree-3-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `screen.children.length: ${screenChildren.length} (expected: 8)`,
-                },
-                {
-                    id: `dbg-tree-4-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Total recursive nodes: ${treeStats.total}`,
-                },
-                {
-                    id: `dbg-tree-5-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: ``,
-                },
-                {
-                    id: `dbg-tree-6-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `--- Panel Counts (must be 1 each) ---`,
-                },
-                {
-                    id: `dbg-tree-7-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: postureCount === 1 ? 'INFO' : 'ERROR',
-                    msg: `POSTURE: ${postureCount} ${postureCount === 1 ? '✓' : '⚠ FAIL'}`,
-                },
-                {
-                    id: `dbg-tree-8-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: resourcesCount === 1 ? 'INFO' : 'ERROR',
-                    msg: `RESOURCES: ${resourcesCount} ${resourcesCount === 1 ? '✓' : '⚠ FAIL'}`,
-                },
-                {
-                    id: `dbg-tree-9-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: assetsCount === 1 ? 'INFO' : 'ERROR',
-                    msg: `ASSETS: ${assetsCount} ${assetsCount === 1 ? '✓' : '⚠ FAIL'}`,
-                },
-                {
-                    id: `dbg-tree-10-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: operationsCount === 1 ? 'INFO' : 'ERROR',
-                    msg: `OPERATIONS: ${operationsCount} ${operationsCount === 1 ? '✓' : '⚠ FAIL'}`,
-                },
-                {
-                    id: `dbg-tree-11-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: networkCount === 1 ? 'INFO' : 'ERROR',
-                    msg: `NETWORK: ${networkCount} ${networkCount === 1 ? '✓' : '⚠ FAIL'}`,
-                },
-                {
-                    id: `dbg-tree-12-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: capabilitiesCount === 1 ? 'INFO' : 'ERROR',
-                    msg: `CAPABILITIES: ${capabilitiesCount} ${capabilitiesCount === 1 ? '✓' : '⚠ FAIL'}`,
-                },
-                {
-                    id: `dbg-tree-13-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: commandLineCount === 1 ? 'INFO' : 'ERROR',
-                    msg: `COMMAND_LINE: ${commandLineCount} ${commandLineCount === 1 ? '✓' : '⚠ FAIL'}`,
-                },
-                {
-                    id: `dbg-tree-14-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: statusStripCount === 1 ? 'INFO' : 'ERROR',
-                    msg: `STATUS_STRIP: ${statusStripCount} ${statusStripCount === 1 ? '✓' : '⚠ FAIL'}`,
-                },
-                {
-                    id: `dbg-tree-15-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: ``,
-                },
-                {
-                    id: `dbg-tree-16-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: screenChildren.length === 8 ? 'INFO' : 'ERROR',
-                    msg: `${screenChildren.length === 8 ? '✓ PASS' : '⚠ FAIL'}: Total children count (${screenChildren.length} === 8)`,
-                },
-                {
-                    id: `dbg-tree-17-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: ``,
-                },
-                {
-                    id: `dbg-tree-18-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `=== END TREE DIAGNOSTIC ===`,
-                },
-                {
-                    id: `dbg-tree-19-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Toggle fullscreen and run again to verify counts stay stable.`,
-                },
-            ];
-            return { events };
-        }
-        else if (subcommand === 'layout') {
-            // Layout overlay toggle - shows live layout instrumentation
-            const { setLayoutOverlayEnabled, getLayoutOverlayEnabled } = await import('../ui/phase1RuntimeClean.js');
-            if (args[1]?.toLowerCase() === 'on' || args[1]?.toLowerCase() === 'enable') {
-                setLayoutOverlayEnabled(true);
-                return {
-                    events: [
-                        cmdEvent,
-                        {
-                            id: `dbg-layout-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'DBG',
-                            level: 'INFO',
-                            msg: 'Layout overlay ENABLED - live layout stats will show in Operations panel',
-                        },
-                    ],
-                };
-            }
-            else if (args[1]?.toLowerCase() === 'off' || args[1]?.toLowerCase() === 'disable') {
-                setLayoutOverlayEnabled(false);
-                return {
-                    events: [
-                        cmdEvent,
-                        {
-                            id: `dbg-layout-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'DBG',
-                            level: 'INFO',
-                            msg: 'Layout overlay DISABLED',
-                        },
-                    ],
-                };
-            }
-            else {
-                // Show current status
-                const enabled = getLayoutOverlayEnabled();
-                return {
-                    events: [
-                        cmdEvent,
-                        {
-                            id: `dbg-layout-status-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'DBG',
-                            level: 'INFO',
-                            msg: `Layout overlay: ${enabled ? 'ENABLED' : 'DISABLED'}`,
-                        },
-                        {
-                            id: `dbg-layout-usage-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'DBG',
-                            level: 'INFO',
-                            msg: `Usage: debug layout <on|off>`,
-                        },
-                    ],
-                };
-            }
-        }
-        else if (subcommand === 'resize-trace' || subcommand === 'trace-resize') {
-            // Resize trace mode toggle
-            const { setResizeTraceEnabled, getResizeTraceEnabled } = await import('../ui/phase1RuntimeClean.js');
-            const { getUIRuntime } = await import('../ui/uiRuntime.js');
-            if (args[1]?.toLowerCase() === 'on' || args[1]?.toLowerCase() === 'enable') {
-                setResizeTraceEnabled(true);
-                return {
-                    events: [
-                        cmdEvent,
-                        {
-                            id: `dbg-trace-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'DBG',
-                            level: 'INFO',
-                            msg: 'Resize trace ENABLED - all resize events will be logged',
-                        },
-                    ],
-                };
-            }
-            else if (args[1]?.toLowerCase() === 'off' || args[1]?.toLowerCase() === 'disable') {
-                setResizeTraceEnabled(false);
-                return {
-                    events: [
-                        cmdEvent,
-                        {
-                            id: `dbg-trace-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'DBG',
-                            level: 'INFO',
-                            msg: 'Resize trace DISABLED',
-                        },
-                    ],
-                };
-            }
-            else {
-                // Show current status
-                const enabled = getResizeTraceEnabled();
-                const runtime = getUIRuntime();
-                const childrenCount = (runtime.screen.children || []).length;
-                const resizeStats = debugUtils.getResizeStats();
-                return {
-                    events: [
-                        cmdEvent,
-                        {
-                            id: `dbg-trace-status-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'DBG',
-                            level: 'INFO',
-                            msg: `Resize trace: ${enabled ? 'ENABLED' : 'DISABLED'}`,
-                        },
-                        {
-                            id: `dbg-trace-status2-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'DBG',
-                            level: 'INFO',
-                            msg: `Usage: debug resize-trace <on|off>`,
-                        },
-                        {
-                            id: `dbg-trace-status3-${Date.now()}`,
-                            ts: Date.now(),
-                            tag: 'DBG',
-                            level: 'INFO',
-                            msg: `Current: Events=${resizeStats.eventCount}, Applies=${resizeStats.applyCount}, Children=${childrenCount}`,
-                        },
-                    ],
-                };
-            }
-        }
-        else if (subcommand === 'dump-layout' || subcommand === 'layout' || subcommand === 'layout-detail') {
-            // Phase D: Layout dump - comprehensive debugging
-            // Pure snapshot: compute once, print once, return immediately (no async operations)
-            const { dumpLayout } = await import('../ui/phase1RuntimeClean.js');
-            const layoutLines = dumpLayout();
-            // Limit output to prevent spam (max 30 lines)
-            const MAX_OUTPUT_LINES = 30;
-            const linesToShow = layoutLines.slice(0, MAX_OUTPUT_LINES);
-            const events = [cmdEvent];
-            for (const line of linesToShow) {
-                events.push({
-                    id: `dbg-layout-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: line,
-                });
-            }
-            // Add truncation notice if needed
-            if (layoutLines.length > MAX_OUTPUT_LINES) {
-                events.push({
-                    id: `dbg-layout-trunc-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `... (output truncated, ${layoutLines.length - MAX_OUTPUT_LINES} more lines)`,
-                });
-            }
-            // Return immediately - no async operations, no render calls, no resize triggers
-            return { events };
-        }
-        else if (subcommand === 'fullscreen') {
-            // Fullscreen diagnostic - shows 12 critical values for fullscreen debugging
-            const { getUIRuntime } = await import('../ui/uiRuntime.js');
-            const { computePhase1Layout } = await import('../ui/layout/phase1Layout.js');
-            const runtime = getUIRuntime();
-            const screen = runtime.screen;
-            // Get all dimension sources
-            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 stdoutCols = process.stdout.columns ?? 'N/A';
-            const stdoutRows = process.stdout.rows ?? 'N/A';
-            const stderrCols = process.stderr.columns ?? 'N/A';
-            const stderrRows = process.stderr.rows ?? 'N/A';
-            // Get actual geometry being used (authoritative source)
-            const { getTerminalGeometry, getTerminalSize } = await import('../tui/geometry.js');
-            const actualSize = getTerminalSize(screen);
-            const actualGeo = getTerminalGeometry(screen);
-            // Compute layout to get metadata (pass fresh screen to use current geometry)
-            const layoutResult = computePhase1Layout(screen.width ?? 80, screen.height ?? 24, screen);
-            const events = [
-                cmdEvent,
-                {
-                    id: `dbg-fullscreen-1-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `=== FULLSCREEN DIAGNOSTIC ===`,
-                },
-                {
-                    id: `dbg-fullscreen-2-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `A. TERMINAL DIMENSIONS (all sources):`,
-                },
-                {
-                    id: `dbg-fullscreen-3-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  screen.width: ${screenWidth}`,
-                },
-                {
-                    id: `dbg-fullscreen-4-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  screen.height: ${screenHeight}`,
-                },
-                {
-                    id: `dbg-fullscreen-5-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  screen.program.cols: ${programCols}`,
-                },
-                {
-                    id: `dbg-fullscreen-6-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  screen.program.rows: ${programRows}`,
-                },
-                {
-                    id: `dbg-fullscreen-7-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  process.stdout.columns: ${stdoutCols}`,
-                },
-                {
-                    id: `dbg-fullscreen-8-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  process.stdout.rows: ${stdoutRows}`,
-                },
-                {
-                    id: `dbg-fullscreen-9-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  process.stderr.columns: ${stderrCols}`,
-                },
-                {
-                    id: `dbg-fullscreen-10-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  process.stderr.rows: ${stderrRows}`,
-                },
-                {
-                    id: `dbg-fullscreen-11-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: ``,
-                },
-                {
-                    id: `dbg-fullscreen-12-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `C. GEOMETRY USED (authoritative):`,
-                },
-                {
-                    id: `dbg-fullscreen-13-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  getTerminalSize() source: ${actualSize.source}`,
-                },
-                {
-                    id: `dbg-fullscreen-14-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  getTerminalSize() cols: ${actualSize.cols}`,
-                },
-                {
-                    id: `dbg-fullscreen-15-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  getTerminalSize() rows: ${actualSize.rows}`,
-                },
-                {
-                    id: `dbg-fullscreen-16-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  getTerminalGeometry() safeCols: ${actualGeo.safeCols}`,
-                },
-                {
-                    id: `dbg-fullscreen-17-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  getTerminalGeometry() safeRows: ${actualGeo.safeRows}`,
-                },
-                {
-                    id: `dbg-fullscreen-18-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  Terminal mode: ${actualGeo.mode}`,
-                },
-            ];
-            // Add layout metadata if available
-            if (layoutResult.ok && layoutResult.metadata) {
-                const m = layoutResult.metadata;
-                events.push({
-                    id: `dbg-fullscreen-19-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: ``,
-                }, {
-                    id: `dbg-fullscreen-20-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `B. LAYOUT METADATA (what layout is using):`,
-                }, {
-                    id: `dbg-fullscreen-21-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  layout.colsUsed: ${m.colsUsed} (should match safeCols or be close)`,
-                }, {
-                    id: `dbg-fullscreen-22-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  layout.rowsUsed: ${m.rowsUsed} (should match safeRows or be close)`,
-                }, {
-                    id: `dbg-fullscreen-23-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  layout.availableWidth: ${m.availableWidth}`,
-                }, {
-                    id: `dbg-fullscreen-24-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  layout.availableHeight: ${m.availableHeight}`,
-                }, {
-                    id: `dbg-fullscreen-25-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  layout.gutters: ${m.gutters}`,
-                }, {
-                    id: `dbg-fullscreen-26-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  layout.margins: ${m.margins} (browser=${actualGeo.mode === 'browser' ? 'yes' : 'no'})`,
-                }, {
-                    id: `dbg-fullscreen-27-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  layout.minCols: ${m.minCols}`,
-                }, {
-                    id: `dbg-fullscreen-28-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `  layout.maxCols: ${m.maxCols ?? 'none (no max)'}`,
-                });
-            }
-            else {
-                events.push({
-                    id: `dbg-fullscreen-19-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: ``,
-                }, {
-                    id: `dbg-fullscreen-20-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: `B. LAYOUT ERROR: ${layoutResult.errorMessage || 'Layout computation failed'}`,
-                });
-            }
-            // Add diagnostic summary
-            events.push({
-                id: `dbg-fullscreen-summary-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: ``,
-            }, {
-                id: `dbg-fullscreen-summary2-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: `DIAGNOSTIC: If cols/rows DON'T change in fullscreen → Windows Terminal settings (font/padding).`,
-            }, {
-                id: `dbg-fullscreen-summary3-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: `If cols/rows DO change but colsUsed stays small → layout clamping bug (check code).`,
-            });
-            events.push({
-                id: `dbg-fullscreen-end-${Date.now()}`,
-                ts: Date.now(),
-                tag: 'DBG',
-                level: 'INFO',
-                msg: `=== END FULLSCREEN DIAGNOSTIC ===`,
-            });
-            return { events };
-        }
-        else if (subcommand === 'listeners') {
-            // Step 2B: Listener bindings dump
-            debugUtils.dumpListenerBindings();
-            return {
-                events: [cmdEvent, {
-                        id: `dbg-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: 'Listener bindings dumped to Operations (check above)',
-                    }],
-            };
-        }
-        else if (subcommand === 'stdout') {
-            // Step 3B: Blocked writes dump
-            debugUtils.dumpBlockedWrites();
-            return {
-                events: [cmdEvent, {
-                        id: `dbg-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: 'Blocked stdout/stderr writes dumped to Operations (check above)',
-                    }],
-            };
-        }
-        else {
-            return {
-                events: [cmdEvent, {
-                        id: `err-${Date.now()}`,
-                        ts: Date.now(),
-                        tag: 'ERR',
-                        level: 'ERROR',
-                        msg: `Unknown debug subcommand: ${subcommand} (try: ui, geo, resize, resize-test, resize-torture, resize-trace, layout, tree, dump-layout, fullscreen, size, listeners, stdout)`,
-                    }],
-            };
-        }
-    }
-    catch (error) {
-        return {
-            events: [cmdEvent, {
-                    id: `err-${Date.now()}`,
-                    ts: Date.now(),
-                    tag: 'ERR',
-                    level: 'ERROR',
-                    msg: `Debug command failed: ${error.message || 'Unknown error'}`,
-                }],
-        };
-    }
-}
-//# sourceMappingURL=commandEngine.js.map