4runr-os 1.0.15 → 1.0.22

package/dist/index.js

@@ -11,39 +11,55 @@ import { GatewayClient } from './gateway-client.js';
 import { executeLocalModel, verifyLocalModelServer } from './local-model-executor.js';
 import { checkOllamaInstallation, installOllama, startOllamaServer, downloadModel, verifyLocalExecution } from './local-setup.js';
 import { loadSession, clearSession, createSession, isSessionValid, getSessionTimeRemaining, getUserAgentsPath, getUserToolsPath } from './auth.js';
-// ANSI colors - Enhanced 4Runr Brand Colors
-const colors = {
-    reset: '\x1b[0m',
-    bright: '\x1b[1m',
-    cyan: '\x1b[36m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m', // 4Runr Purple
-    purple: '\x1b[35m', // 4Runr Purple (#6E56CF)
-    red: '\x1b[31m',
-    gray: '\x1b[90m',
-    dim: '\x1b[2m',
-    brightGreen: '\x1b[1m\x1b[32m',
-    brightCyan: '\x1b[1m\x1b[36m',
-    brightMagenta: '\x1b[1m\x1b[35m',
-    brightPurple: '\x1b[1m\x1b[35m',
-    // RGB colors for more vibrant purple
-    purpleRGB: '\x1b[38;2;110;86;207m', // #6E56CF
-    purpleBright: '\x1b[1m\x1b[38;2;110;86;207m',
-    purpleDim: '\x1b[2m\x1b[38;2;110;86;207m',
-    // Accent colors
-    pink: '\x1b[38;2;236;72;153m', // #ec4899
-    orange: '\x1b[38;2;249;115;22m', // #f97316
-    teal: '\x1b[38;2;6;182;212m', // #06b6d4
-};
-const { cyan, green, yellow, blue, magenta, red, gray, bright, reset, dim, brightGreen, brightCyan, brightMagenta, purpleRGB, purpleBright, purpleDim, pink, orange, teal } = colors;
+import { C_BRAND, C_ACCENT, C_TEXT, C_MUTED, C_SUCCESS, C_WARN, C_ERROR, C_DIM, C_LINK, C_BRAND_BRIGHT, C_ACCENT_BRIGHT, C_TEXT_BRIGHT, RESET, BOLD, } from './theme.js';
+import { Header, StatusBar, Section, Table, Alert, truncateId, truncateText, } from './ui-primitives.js';
+import { getLastAgent, setLastAgent, setLastConnectionTarget, setLastMode, } from './state.js';
+import { Copy } from './copy.js';
+import { createProgress, stopAllAnimations } from './animations.js';
+import { getState, updateAppState } from './store.js';
+import { renderHomeView } from './ui/home-view.js';
+// Legacy color aliases for backward compatibility during refactor
+const cyan = C_ACCENT;
+const green = C_SUCCESS;
+const yellow = C_WARN;
+const red = C_ERROR;
+const gray = C_MUTED;
+const bright = BOLD;
+const reset = RESET;
+const dim = C_DIM;
+const brightGreen = C_SUCCESS + BOLD;
+const brightCyan = C_ACCENT_BRIGHT;
+const purpleRGB = C_BRAND;
+const purpleBright = C_BRAND_BRIGHT;
+const teal = C_ACCENT;
+const magenta = C_BRAND;
+const blue = C_ACCENT;
+let currentView = 'BOOT';
+// Legacy globals (being migrated to state store)
 let client = null;
 let systemReady = false;
 let gatewayConnected = false;
 let localMode = false; // Run without gateway (local-only)
 let currentUser = null; // Current logged-in user
 let sessionCheckInterval = null; // Session expiry checker
+/**
+ * Sync legacy globals to state store
+ * Call this after any global state change to keep store in sync
+ * TODO: Remove this once all code uses state store directly
+ */
+function syncStateToStore() {
+    updateAppState({
+        currentView,
+        gatewayClient: client,
+        gatewayConnected,
+        gatewayUrl: gatewayUrl || null,
+        localMode,
+        currentUser,
+        sessionCheckInterval,
+        systemReady,
+        // Note: customAgents and runHistory are synced separately when they change
+    });
+}
 // Gateway URL - configurable via GATEWAY_URL environment variable or config file
 // Default: Official 4Runr server (but connection requires login)
 // Override: Set GATEWAY_URL environment variable
@@ -64,7 +80,10 @@ let multilineMode = false;
 let multilineResolver = null;
 let multilineLines = [];
 let multilineEndMarker = 'END';
+// Custom agents storage
+// NOTE: Using types from types.ts now
 const customAgents = new Map();
+// Custom tools storage
 const customTools = new Map();
 // Get config directory path
 function getConfigDir() {
@@ -149,122 +168,128 @@ const aiConfig = {
     model: null,
     apiKey: null
 };
-// Simulate boot sequence - Revolutionary 4Runr Branding
+// Track if this is first run completion (for brand moment)
+let firstRunCompleted = false;
+// BOOT: Sequential, deterministic, never fails hard (max 2s animation)
 async function bootSequence() {
     console.clear();
-    // 4Runr - The Innovation. Clean, modern, uniquely 4Runr.
-    console.log(`${reset}
-${purpleRGB}╭─────────────────────────────────────────────────────────────────────────╮${reset}
-${purpleRGB}│${reset}                                                                         ${purpleRGB}│${reset}
-${purpleRGB}│${reset}    ${purpleBright}4${reset}${brightCyan}Runr${reset}                                                                    ${purpleRGB}│${reset}
-${purpleRGB}│${reset}                                                                         ${purpleRGB}│${reset}
-${purpleRGB}│${reset}    ${dim}AI Agent Operating System${reset}  ${purpleRGB}│${reset}  ${teal}Version 2.0.0${reset}                          ${purpleRGB}│${reset}
-${purpleRGB}│${reset}                                                                         ${purpleRGB}│${reset}
-${purpleRGB}╰─────────────────────────────────────────────────────────────────────────╯${reset}
-${reset}`);
-    await sleep(300);
-    console.log(`\n${purpleRGB}Initializing 4Runr AI Agent OS...${reset}`);
-    await sleep(200);
-    // Check for existing session
+    currentView = 'BOOT';
+    const bootStartTime = Date.now();
+    // 1. Header - render immediately, no delays
+    const mode = localMode ? 'LOCAL' : 'REMOTE';
+    console.log(Header('2.0.0', mode));
+    console.log();
+    // 2. Boot sequence messages (sequential, calm, max 2s total)
+    const checkResults = [];
+    // Step 1: Initializing runtime
+    const progress1 = createProgress(Copy.boot.initializing, 200);
+    progress1.start();
+    await sleep(150);
+    progress1.stop(true);
+    checkResults.push({ label: 'Runtime', status: 'OK' });
+    // Step 2: Loading configuration
+    const progress2 = createProgress(Copy.boot.loadingConfig, 200);
+    progress2.start();
+    await sleep(150);
     const savedSession = loadSession();
-    if (savedSession && isSessionValid(savedSession)) {
+    const configLoaded = savedSession && isSessionValid(savedSession);
+    if (configLoaded) {
         currentUser = savedSession;
-        console.log(`${dim}[BOOT] Session: ${green}${savedSession.username}${reset}${dim} (${getSessionTimeRemaining(savedSession)}m)${reset}`);
-        // Try to reconnect to gateway and verify components
-        if (!localMode && (savedSession.gatewayUrl || gatewayUrl)) {
-            const urlToUse = savedSession.gatewayUrl || gatewayUrl;
-            console.log(`${purpleRGB}Connecting...${reset}`);
-            try {
-                client = new GatewayClient({ gatewayUrl: urlToUse });
-                const health = await client.health();
-                gatewayConnected = true;
-                gatewayUrl = urlToUse;
-                // Clean component verification
-                console.log(`${dim}Verifying components...${reset}\n`);
-                // Gateway
-                process.stdout.write(`${cyan}Gateway${reset}${gray}      ${reset}`);
-                await sleep(80);
-                console.log(`${green}✓${reset} ${dim}${health.status}${reset}`);
-                // Database
-                process.stdout.write(`${cyan}Database${reset}${gray}    ${reset}`);
-                await sleep(80);
-                console.log(`${green}✓${reset} ${dim}${health.persistence}${reset}`);
-                // Sentinel
-                process.stdout.write(`${cyan}Sentinel${reset}${gray}    ${reset}`);
-                await sleep(80);
-                try {
-                    const sentinelRes = await fetch(`${gatewayUrl}/sentinel/health`);
-                    if (sentinelRes.ok) {
-                        const sentinel = await sentinelRes.json();
-                        console.log(`${green}✓${reset} ${dim}${sentinel?.status || 'active'}${reset}`);
-                    }
-                    else {
-                        console.log(`${yellow}⚠${reset} ${dim}offline${reset}`);
-                    }
-                }
-                catch {
-                    console.log(`${yellow}⚠${reset} ${dim}offline${reset}`);
-                }
-                // Metrics
-                process.stdout.write(`${cyan}Metrics${reset}${gray}     ${reset}`);
-                await sleep(80);
-                try {
-                    const metricsRes = await fetch(`${gatewayUrl}/api/metrics`);
-                    if (metricsRes.ok) {
-                        console.log(`${green}✓${reset}`);
-                    }
-                    else {
-                        console.log(`${yellow}⚠${reset}`);
-                    }
-                }
-                catch {
-                    console.log(`${yellow}⚠${reset}`);
-                }
-                // AI Providers
-                process.stdout.write(`${cyan}AI Providers${reset}${gray} ${reset}`);
-                await sleep(80);
-                console.log(`${green}✓${reset} ${dim}ready${reset}\n`);
-            }
-            catch (error) {
-                console.log(`${yellow}✗${reset} ${dim}(mainframe unavailable)${reset}`);
-                gatewayConnected = false;
-            }
-        }
     }
-    else {
-        // No session - user needs to connect
-        if (localMode) {
-            console.log(`${green}Local mode${reset} ${dim}(no remote features)${reset}\n`);
+    progress2.stop(!!configLoaded);
+    checkResults.push({ label: 'Configuration', status: configLoaded ? 'OK' : 'WARN' });
+    // Step 3: Checking gateway
+    const progress3 = createProgress(Copy.boot.checkingGateway, 300);
+    progress3.start();
+    await sleep(200);
+    let gatewayStatus = 'WARN';
+    if (!localMode && (savedSession?.gatewayUrl || gatewayUrl)) {
+        const urlToUse = savedSession?.gatewayUrl || gatewayUrl;
+        try {
+            client = new GatewayClient({ gatewayUrl: urlToUse });
+            const health = await client.health();
+            gatewayConnected = true;
+            gatewayUrl = urlToUse;
+            gatewayStatus = 'OK';
+            setLastConnectionTarget(urlToUse);
         }
-        else {
-            console.log(`${yellow}Not connected${reset}`);
-            console.log(`${dim}Use ${purpleBright}connect <username>${reset}${dim} to connect${reset}`);
-            console.log(`${dim}Or run with ${purpleBright}--local${reset}${dim} for offline mode${reset}\n`);
+        catch {
+            gatewayStatus = 'WARN';
+            gatewayConnected = false;
         }
     }
-    await sleep(200);
-    // Clean, modern ready state
-    console.log(`${green}Ready${reset}  ${purpleRGB}4Runr OS v2.0.0${reset}\n`);
-    if (currentUser) {
-        if (gatewayConnected) {
-            console.log(`${green}Connected${reset}  ${dim}${currentUser.username}${reset}  ${dim}${getSessionTimeRemaining(currentUser)}m session${reset}\n`);
+    else if (localMode) {
+        gatewayStatus = 'OK';
+    }
+    progress3.stop(gatewayStatus === 'OK');
+    checkResults.push({ label: 'Gateway', status: gatewayStatus });
+    // Step 4: Checking database
+    const progress4 = createProgress(Copy.boot.checkingDatabase, 200);
+    progress4.start();
+    await sleep(150);
+    let dbStatus = 'WARN';
+    if (gatewayConnected && client) {
+        try {
+            const health = await client.health();
+            dbStatus = health.persistence === 'enabled' ? 'OK' : 'WARN';
         }
-        else {
-            console.log(`${yellow}Partial connection${reset}  ${dim}${currentUser.username}${reset}  ${dim}${getSessionTimeRemaining(currentUser)}m session${reset}`);
-            console.log(`${dim}Remote features unavailable${reset}\n`);
+        catch {
+            dbStatus = 'WARN';
         }
     }
-    else if (!localMode) {
-        console.log(`${dim}Type ${purpleBright}connect <username>${reset}${dim} to connect${reset}\n`);
+    else if (localMode) {
+        dbStatus = 'OK'; // Local mode doesn't need DB
+    }
+    progress4.stop(dbStatus === 'OK');
+    checkResults.push({ label: 'Database', status: dbStatus });
+    // Step 5: Loading agent registry
+    const progress5 = createProgress(Copy.boot.loadingAgents, 200);
+    progress5.start();
+    await sleep(150);
+    loadCustomAgents();
+    const agentsLoaded = customAgents.size > 0;
+    progress5.stop(agentsLoaded);
+    checkResults.push({ label: 'Agent registry', status: agentsLoaded ? 'OK' : 'WARN' });
+    // Ensure total boot time ≤ 2s
+    const elapsed = Date.now() - bootStartTime;
+    if (elapsed < 2000) {
+        await sleep(2000 - elapsed);
+    }
+    // Summary
+    const checkLines = [];
+    checkResults.forEach(result => {
+        const statusColor = result.status === 'OK' ? C_SUCCESS :
+            result.status === 'WARN' ? C_WARN : C_ERROR;
+        const statusText = result.status === 'OK' ? 'OK' :
+            result.status === 'WARN' ? 'WARN' : 'ERROR';
+        checkLines.push(`${result.label}: ${statusColor}${statusText}${RESET}`);
+    });
+    console.log(Section('INITIALIZATION', checkLines));
+    console.log();
+    // Final status (ALL CAPS for system state)
+    let finalStatus;
+    if (gatewayStatus === 'OK' && gatewayConnected) {
+        finalStatus = `${C_SUCCESS}${Copy.status.ready}${RESET}`;
+        // Brand moment: boot complete
+        console.log(`${C_MUTED}${Copy.brand.bootComplete}${RESET}`);
+    }
+    else if (localMode) {
+        finalStatus = `${C_SUCCESS}${Copy.status.offlineMode}${RESET}`;
     }
     else {
-        console.log(`${green}Local mode${reset} ${dim}(no remote features)${reset}\n`);
+        finalStatus = `${C_WARN}${Copy.status.notConnected}${RESET}`;
     }
+    console.log(finalStatus);
     systemReady = true;
     // Start session expiry checker
     if (currentUser && !localMode) {
         startSessionChecker();
     }
+    // Save mode to state
+    setLastMode(localMode ? 'LOCAL' : 'REMOTE');
+    // Auto transition to HOME
+    await sleep(200);
+    await showHomeView();
 }
 /**
  * Start session expiry checker
@@ -308,14 +333,103 @@ async function progress(items) {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
-// Show welcome screen - Clean, modern, uniquely 4Runr
-function showWelcome() {
-    console.log(`${purpleRGB}4Runr AI Agent Operating System${reset}\n`);
-    console.log(`${dim}Quick start:${reset}`);
-    console.log(`${dim}  help${reset}     ${dim}See available commands${reset}`);
-    console.log(`${dim}  config${reset}   ${dim}Configure AI providers${reset}`);
-    console.log(`${dim}  build${reset}    ${dim}Create a custom AI agent${reset}`);
-    console.log(`${dim}  exit${reset}     ${dim}Quit${reset}\n`);
+// Helper: Show agent config (read-only)
+async function showAgentConfig(agent) {
+    // 2. AGENT CONFIG (Read-Only)
+    const identityLines = [];
+    identityLines.push(`Name: ${C_TEXT}${agent.name}${RESET}`);
+    identityLines.push(`Description: ${C_MUTED}${agent.description || 'No description'}${RESET}`);
+    console.log(Section('IDENTITY', identityLines));
+    console.log();
+    const modelLines = [];
+    const modelShort = agent.baseAgent.includes(':')
+        ? agent.baseAgent.split(':').pop() || 'unknown'
+        : agent.baseAgent;
+    modelLines.push(`Model: ${C_ACCENT}${modelShort}${RESET}`);
+    if (agent.temperature !== undefined) {
+        modelLines.push(`Temperature: ${C_ACCENT}${agent.temperature}${RESET}`);
+    }
+    console.log(Section('MODEL', modelLines));
+    console.log();
+    const toolsLines = [];
+    if (agent.tools && agent.tools.length > 0) {
+        toolsLines.push(`Enabled: ${C_ACCENT}${agent.tools.length}${RESET}`);
+        agent.tools.forEach(tool => {
+            toolsLines.push(`${C_TEXT}${tool}${RESET}`);
+        });
+    }
+    else {
+        toolsLines.push(`${C_MUTED}No tools enabled${RESET}`);
+    }
+    console.log(Section('TOOLS', toolsLines));
+    console.log();
+    const memoryLines = [];
+    memoryLines.push(`Memory type: ${C_ACCENT}NONE${RESET}  ${C_MUTED}(not implemented)${RESET}`);
+    console.log(Section('MEMORY', memoryLines));
+    console.log();
+    // Tags (if we had them)
+    const tagsLines = [];
+    tagsLines.push(`${C_MUTED}No tags${RESET}`);
+    console.log(Section('TAGS', tagsLines));
+    console.log();
+}
+// Track boot time for uptime calculation
+const bootTime = Date.now();
+const runHistory = [];
+function formatRelativeTime(timestamp) {
+    const seconds = Math.floor((Date.now() - timestamp) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+function formatUptime() {
+    const seconds = Math.floor((Date.now() - bootTime) / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+}
+/**
+ * HOME: Situation Awareness
+ *
+ * REFACTORED: Now uses state store + UI renderer pattern
+ *
+ * Pattern:
+ * 1. Update state (view change)
+ * 2. Sync legacy globals to store
+ * 3. Call pure renderer function
+ * 4. Output result
+ *
+ * This is the pattern all views should follow.
+ */
+async function showHomeView() {
+    // 1. Update state
+    currentView = 'HOME';
+    // 2. Sync legacy globals to state store
+    // TODO: Once all code uses state store, this sync won't be needed
+    syncStateToStore();
+    // 3. Sync customAgents and runHistory to store
+    const state = getState();
+    updateAppState({
+        customAgents: customAgents,
+        runHistory: runHistory,
+    });
+    // 4. Call pure renderer (state → string)
+    const newState = getState();
+    const output = renderHomeView(newState);
+    // 5. Output result
+    console.log();
+    console.log(output);
 }
 // Interactive prompt helper
 function prompt(rl, question) {
@@ -349,49 +463,42 @@ const commands = {
             if (args.length > 0) {
                 const cmd = commands[args[0]];
                 if (cmd) {
-                    console.log(`\n${bright}${args[0]}${reset}`);
-                    console.log(`  ${cmd.description}`);
-                    console.log(`  Usage: ${cyan}${cmd.usage}${reset}\n`);
+                    const lines = [];
+                    lines.push(`${C_TEXT_BRIGHT}${args[0]}${RESET}`);
+                    lines.push(cmd.description);
+                    lines.push(`Usage: ${C_LINK}${cmd.usage}${RESET}`);
+                    console.log(Section('COMMAND', lines));
+                    console.log();
                 }
                 else {
-                    console.log(`${red}Unknown command: ${args[0]}${reset}`);
+                    console.log(Alert('error', `${Copy.error.invalidCommand}: ${args[0]}`, undefined, 'help'));
+                    console.log();
                 }
             }
             else {
-                // Beautiful help menu with 4Runr branding
-                console.log(`\n${purpleRGB}╔═══════════════════════════════════════════════════════════════════════════╗${reset}`);
-                console.log(`${purpleRGB}║${reset}  ${brightCyan}${bright}Available Commands${reset}                                                  ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}╠═══════════════════════════════════════════════════════════════════════════╣${reset}`);
-                console.log(`${purpleRGB}║${reset}  ${purpleBright}${bright}AI Configuration${reset}                                                      ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}config${reset}${gray}       ${dim}Configure AI provider (OpenAI/Anthropic)${reset}                    ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}models${reset}${gray}       ${dim}List available AI models${reset}                              ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}ai-status${reset}${gray}    ${dim}Show stored API keys and configuration${reset}                   ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}                                                                           ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}  ${purpleBright}${bright}Agent Management${reset}                                                      ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}run-agent${reset}${gray}    ${dim}Start chatting with an AI agent${reset}                        ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}build${reset}${gray}        ${dim}Build a custom AI agent (interactive)${reset}                      ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}agents${reset}${gray}       ${dim}List available agents${reset}                                 ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}                                                                           ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}  ${purpleBright}${bright}Run Management${reset}                                                         ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}create${reset}${gray}       ${dim}Create a new run${reset}                                     ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}start${reset}${gray}        ${dim}Start a run${reset}                                         ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}get${reset}${gray}          ${dim}Get run details${reset}                                     ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}list${reset}${gray}         ${dim}List all runs${reset}                                       ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}                                                                           ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}  ${purpleBright}${bright}Connection${reset}                                                           ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}connect${reset}${gray}      ${dim}Connect to mainframe (required for remote features)${reset}        ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}disconnect${reset}${gray}   ${dim}Disconnect from mainframe${reset}                             ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}whoami${reset}${gray}       ${dim}Show current connection and session info${reset}                ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}                                                                           ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}  ${purpleBright}${bright}System${reset}                                                              ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}status${reset}${gray}       ${dim}Show system status${reset}                                   ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}gateway${reset}${gray}      ${dim}Manage gateway connection${reset}                             ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}sentinel${reset}${gray}     ${dim}Show Sentinel monitoring${reset}                              ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}metrics${reset}${gray}      ${dim}Show system metrics${reset}                                  ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}clear${reset}${gray}        ${dim}Clear the screen${reset}                                     ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}║${reset}    ${cyan}${bright}exit${reset}${gray}         ${dim}Exit 4Runr OS${reset}                                       ${purpleRGB}║${reset}`);
-                console.log(`${purpleRGB}╚═══════════════════════════════════════════════════════════════════════════╝${reset}\n`);
+                // Clean, precise help menu
+                const commandLines = [];
+                commandLines.push(`${C_LINK}home${RESET}     Mission control overview`);
+                commandLines.push(`${C_LINK}connect${RESET}  Connect to remote`);
+                commandLines.push(`${C_LINK}build${RESET}    Create or edit agent`);
+                commandLines.push(`${C_LINK}start${RESET}    Begin execution`);
+                commandLines.push(`${C_LINK}metrics${RESET}  Performance and history`);
+                commandLines.push(`${C_LINK}system${RESET}   Infrastructure status`);
+                commandLines.push(`${C_LINK}help${RESET}     Show this help`);
+                commandLines.push(`${C_LINK}exit${RESET}     Quit`);
+                console.log(Section('COMMANDS', commandLines));
+                console.log();
             }
+            // StatusBar
+            const mode = localMode ? 'LOCAL' : (gatewayConnected ? 'REMOTE' : 'OFFLINE');
+            console.log(StatusBar({
+                mode: mode,
+                connected: gatewayConnected,
+                target: gatewayUrl ? truncateText(gatewayUrl, 30) : undefined,
+                workspace: currentUser?.username,
+                lastAction: 'help',
+            }));
+            console.log();
         }
     },
     config: {
@@ -537,9 +644,74 @@ const commands = {
         }
     },
     build: {
-        description: 'Build a custom AI agent (interactive)',
-        usage: 'build',
+        description: 'Create or edit agent',
+        usage: 'build [new|edit <agent>]',
         handler: async (args, rl) => {
+            currentView = 'AGENT_LAB';
+            console.log();
+            const action = args[0] || 'list';
+            const agentName = args[1];
+            // 1. SELECT AGENT
+            if (action === 'list' || (!action && !agentName)) {
+                // Show agent list/table
+                const agentRows = [];
+                if (customAgents.size > 0) {
+                    Array.from(customAgents.entries()).forEach(([key, agent]) => {
+                        const agentId = truncateId(key, 8);
+                        const modelShort = agent.baseAgent.includes(':')
+                            ? agent.baseAgent.split(':').pop()?.substring(0, 12) || 'unknown'
+                            : truncateText(agent.baseAgent, 12);
+                        const lastModified = 'N/A'; // Would need file modification time
+                        const status = 'IDLE';
+                        agentRows.push([
+                            agentId,
+                            truncateText(agent.name, 20),
+                            modelShort,
+                            lastModified,
+                            status,
+                        ]);
+                    });
+                }
+                const agentTable = agentRows.length > 0
+                    ? Table(['ID', 'NAME', 'MODEL', 'LAST MODIFIED', 'STATUS'], agentRows, 10)
+                    : `${C_MUTED}${Copy.agent.noAgents}${RESET}`;
+                console.log(Section('SELECT AGENT', [agentTable]));
+                console.log();
+                // If only one agent, auto-select it
+                if (customAgents.size === 1) {
+                    const singleAgent = Array.from(customAgents.values())[0];
+                    // Show config for single agent
+                    await showAgentConfig(singleAgent);
+                    return;
+                }
+                // Show actions
+                const actionLines = [];
+                actionLines.push(`${C_LINK}build new${RESET}  ${C_MUTED}Create new agent${RESET}`);
+                if (customAgents.size > 0) {
+                    actionLines.push(`${C_LINK}build edit <name>${RESET}  ${C_MUTED}Edit existing agent${RESET}`);
+                }
+                console.log(Section('ACTIONS', actionLines));
+                console.log();
+                currentView = 'HOME';
+                return;
+            }
+            // Handle edit action
+            if (action === 'edit' && agentName) {
+                const agent = customAgents.get(agentName.toLowerCase());
+                if (!agent) {
+                    console.log(Alert('error', `Agent not found: ${agentName}`, undefined, 'build'));
+                    console.log();
+                    currentView = 'HOME';
+                    return;
+                }
+                await showAgentConfig(agent);
+                // Then proceed to edit flow (would be implemented)
+                return;
+            }
+            // Handle new action
+            if (action === 'new' || (!action && !agentName)) {
+                // Proceed with creation flow
+            }
             // Check if API keys are stored on server
             let providers = [];
             try {
@@ -550,12 +722,17 @@ const commands = {
                 }
             }
             catch (error) {
-                console.log(`${red}✗${reset} Error fetching providers: ${error.message}\n`);
+                console.log(`${red}Providers unavailable${reset}`);
+                console.log(`${dim}Reason: ${error.message}${reset}`);
+                console.log(`${dim}Next: ${cyan}config${reset}${dim} to configure providers${reset}\n`);
+                currentView = 'HOME';
                 return;
             }
             if (providers.length === 0) {
-                console.log(`${red}No API keys found on server${reset}`);
-                console.log(`${gray}Please run ${bright}config${reset}${gray} to add your API keys first${reset}\n`);
+                console.log(`${red}No providers configured${reset}`);
+                console.log(`${dim}Reason: No API keys found${reset}`);
+                console.log(`${dim}Next: ${cyan}config${reset}${dim} to add API keys${reset}\n`);
+                currentView = 'HOME';
                 return;
             }
             // Auto-select provider/model if not set
@@ -590,9 +767,19 @@ const commands = {
                     return;
                 }
             }
-            console.log(`\n${dim}┌─ AGENT BUILDER ───────────────────────────────┐${reset}`);
-            console.log(`${dim}│${reset} ${brightGreen}Create Custom AI Agent${reset}`);
-            console.log(`${dim}└──────────────────────────────────────────────────┘${reset}\n`);
+            // Show agent list
+            console.log(`${purpleRGB}Agent List${reset}`);
+            if (customAgents.size > 0) {
+                customAgents.forEach((agent) => {
+                    console.log(`  ${cyan}${agent.name}${reset}  ${dim}${agent.description || 'No description'}${reset}`);
+                });
+            }
+            else {
+                console.log(`  ${dim}None yet${reset}`);
+            }
+            console.log();
+            // Agent configuration summary (will be shown after creation)
+            console.log(`${purpleRGB}Creating new agent${reset}\n`);
             // Model type selection (local vs remote)
             console.log(`${bright}Model Type:${reset}`);
             console.log(`  1. ${cyan}Remote${reset} (OpenAI, Anthropic - requires API key)`);
@@ -853,8 +1040,24 @@ const commands = {
             };
             customAgents.set(name.toLowerCase(), customAgent);
             saveCustomAgents();
-            console.log(`\n${green}✓${reset} Agent created: ${bright}${name}${reset}`);
-            console.log(`  Use ${cyan}run-agent ${name}${reset} to start chatting\n`);
+            // Save as last agent
+            setLastAgent(name);
+            // Show success and return to agent config view
+            console.log(Alert('success', `${Copy.agent.created}: ${name}`, undefined, `start ${name}`));
+            console.log();
+            // Show the created agent's config (read-only)
+            const createdAgent = customAgents.get(name.toLowerCase());
+            if (createdAgent) {
+                await showAgentConfig(createdAgent);
+            }
+            // Show actions
+            const actionLines = [];
+            actionLines.push(`${C_LINK}start ${name}${RESET}  ${C_MUTED}Begin execution${RESET}`);
+            actionLines.push(`${C_LINK}home${RESET}  ${C_MUTED}Return to overview${RESET}`);
+            console.log(Section('ACTIONS', actionLines));
+            console.log();
+            // Transition: AGENT_LAB → HOME
+            currentView = 'HOME';
         }
     },
     agents: {
@@ -975,6 +1178,91 @@ const commands = {
             rl.prompt();
         }
     },
+    system: {
+        description: 'Show infrastructure readiness and risks',
+        usage: 'system',
+        handler: async () => {
+            currentView = 'SYSTEM';
+            console.log();
+            // 1. INFRASTRUCTURE
+            const infraLines = [];
+            // Gateway
+            if (gatewayConnected && client) {
+                try {
+                    const health = await client.health();
+                    const endpoint = truncateText(gatewayUrl || '', 40);
+                    infraLines.push(`Gateway: ${C_SUCCESS}UP${RESET}  ${C_MUTED}${endpoint}${RESET}`);
+                }
+                catch {
+                    infraLines.push(`Gateway: ${C_ERROR}DOWN${RESET}  ${C_MUTED}unhealthy${RESET}`);
+                }
+            }
+            else {
+                infraLines.push(`Gateway: ${C_ERROR}DOWN${RESET}  ${C_MUTED}not connected${RESET}`);
+            }
+            // Database
+            let dbType = 'none';
+            let dbStatus = 'N/A';
+            if (gatewayConnected && client) {
+                try {
+                    const health = await client.health();
+                    dbType = health.persistence === 'enabled' ? 'sqlite' : 'none';
+                    dbStatus = health.persistence === 'enabled' ? 'connected' : 'disabled';
+                    const statusColor = dbStatus === 'connected' ? C_SUCCESS : C_WARN;
+                    infraLines.push(`Database: ${statusColor}${dbStatus.toUpperCase()}${RESET}  ${C_MUTED}Type: ${dbType}${RESET}`);
+                }
+                catch {
+                    infraLines.push(`Database: ${C_WARN}UNKNOWN${RESET}  ${C_MUTED}Type: ${dbType}${RESET}`);
+                }
+            }
+            else {
+                infraLines.push(`Database: ${C_WARN}MISSING${RESET}  ${C_MUTED}Type: ${dbType}${RESET}`);
+            }
+            // External APIs (simplified for v1)
+            if (gatewayConnected) {
+                try {
+                    const metricsRes = await fetch(`${gatewayUrl}/api/metrics`);
+                    infraLines.push(`Metrics API: ${metricsRes.ok ? C_SUCCESS + 'UP' : C_WARN + 'DOWN' + RESET}`);
+                }
+                catch {
+                    infraLines.push(`Metrics API: ${C_WARN}DOWN${RESET}`);
+                }
+            }
+            else {
+                infraLines.push(`Metrics API: ${C_WARN}N/A${RESET}  ${C_MUTED}not connected${RESET}`);
+            }
+            console.log(Section('INFRASTRUCTURE', infraLines));
+            console.log();
+            // 2. SECURITY
+            const securityLines = [];
+            // Auth mode
+            let authMode = 'NONE';
+            if (currentUser) {
+                authMode = 'BASIC'; // Simplified - would check actual auth type
+            }
+            securityLines.push(`Auth mode: ${C_ACCENT}${authMode}${RESET}`);
+            // Rate limiting
+            const rateLimitEnabled = false; // v1: not implemented
+            securityLines.push(`Rate limiting: ${rateLimitEnabled ? C_SUCCESS + 'ENABLED' : C_WARN + 'DISABLED' + RESET}`);
+            // Environment
+            const env = process.env.NODE_ENV === 'production' ? 'PROD' : 'DEV';
+            const envColor = env === 'PROD' ? C_SUCCESS : C_WARN;
+            securityLines.push(`Environment: ${envColor}${env}${RESET}`);
+            console.log(Section('SECURITY', securityLines));
+            console.log();
+            // StatusBar
+            const mode = localMode ? 'LOCAL' : (gatewayConnected ? 'REMOTE' : 'OFFLINE');
+            console.log(StatusBar({
+                mode: mode,
+                connected: gatewayConnected,
+                target: gatewayUrl ? truncateText(gatewayUrl, 30) : undefined,
+                workspace: currentUser?.username,
+                lastAction: 'system',
+            }));
+            console.log();
+            currentView = 'HOME';
+        }
+    },
     status: {
         description: 'Show system status',
         usage: 'status',
@@ -1075,27 +1363,116 @@ const commands = {
         }
     },
     start: {
-        description: 'Start a run',
-        usage: 'start <run-id>',
-        handler: async (args) => {
-            if (!client || !gatewayConnected) {
-                console.log(`${red}Gateway not connected. Use ${bright}gateway connect${reset}${red} first.${reset}\n`);
+        description: 'Begin execution',
+        usage: 'start [agent]',
+        handler: async (args, rl) => {
+            // Auto-redirect: if no agents exist, go to agent lab
+            if (customAgents.size === 0) {
+                console.log(Alert('info', Copy.agent.noAgents, 'Create one', 'build'));
+                console.log();
+                // Transition to AGENT_LAB
+                currentView = 'AGENT_LAB';
+                await commands.build.handler([], rl);
                 return;
             }
+            currentView = 'RUN_CONSOLE';
+            console.log();
+            let agentName;
+            let agent;
             if (args.length === 0) {
-                console.log(`${red}Usage: start <run-id>${reset}\n`);
-                return;
-            }
-            const runId = args[0];
-            console.log(`${gray}Starting run ${runId}...${reset}`);
-            try {
-                await client.runs.start(runId);
-                console.log(`${green}✓${reset} Run started`);
-                console.log(`  Use ${cyan}get ${runId}${reset} to check status\n`);
+                // Shortcut: use last agent if available
+                const lastAgent = getLastAgent();
+                if (lastAgent) {
+                    agentName = lastAgent;
+                    agent = customAgents.get(lastAgent.toLowerCase());
+                }
+                // If no last agent or last agent not found, auto-select or prompt
+                if (!agent) {
+                    if (customAgents.size === 1) {
+                        // Auto-select if only one agent
+                        agent = Array.from(customAgents.values())[0];
+                        agentName = agent.name;
+                    }
+                    else {
+                        // Multiple agents: list and prompt
+                        console.log(Section('AVAILABLE AGENTS', []));
+                        const agentList = Array.from(customAgents.values());
+                        agentList.forEach((a, i) => {
+                            console.log(`  ${i + 1}. ${C_ACCENT}${a.name}${RESET}  ${C_MUTED}${a.description || 'No description'}${RESET}`);
+                        });
+                        console.log();
+                        const choice = await prompt(rl, `${C_ACCENT}Select agent (1-${agentList.length}):${RESET} `);
+                        const index = parseInt(choice) - 1;
+                        if (index >= 0 && index < agentList.length) {
+                            agent = agentList[index];
+                            agentName = agent.name;
+                        }
+                        else {
+                            console.log(Alert('error', Copy.error.invalidCommand, undefined, 'start'));
+                            console.log();
+                            currentView = 'HOME';
+                            return;
+                        }
+                    }
+                }
             }
-            catch (error) {
-                console.log(`${red}✗${reset} Error: ${error.message}\n`);
+            else {
+                agentName = args.join(' ').trim();
+                agent = customAgents.get(agentName.toLowerCase());
+                if (!agent) {
+                    console.log(Alert('error', `Agent not found: ${agentName}`, undefined, 'build'));
+                    console.log();
+                    currentView = 'HOME';
+                    return;
+                }
             }
+            // Save last agent
+            if (agentName) {
+                setLastAgent(agentName);
+            }
+            // 1. RUN INFO
+            const runId = truncateId(`run-${Date.now()}`, 12);
+            const startedTime = new Date().toISOString();
+            const runInfoLines = [];
+            runInfoLines.push(`Run ID: ${C_ACCENT}${runId}${RESET}`);
+            runInfoLines.push(`Agent: ${C_TEXT}${agent.name}${RESET}`);
+            runInfoLines.push(`Started: ${C_MUTED}${startedTime}${RESET}`);
+            runInfoLines.push(`Target: ${C_ACCENT}${localMode ? 'LOCAL' : 'REMOTE'}${RESET}`);
+            console.log(Section('RUN INFO', runInfoLines));
+            console.log();
+            // 2. LIVE STREAM
+            const streamLines = [];
+            streamLines.push(`${C_MUTED}${Copy.agent.awaitingOutput}${RESET}`);
+            console.log(Section('LIVE STREAM', streamLines));
+            console.log();
+            // 3. STATUS
+            const statusLines = [];
+            statusLines.push(`Current phase: ${C_ACCENT}initializing${RESET}`);
+            statusLines.push(`Step count: ${C_ACCENT}0${RESET}`);
+            statusLines.push(`Time elapsed: ${C_ACCENT}0s${RESET}`);
+            console.log(Section('STATUS', statusLines));
+            console.log();
+            // Note: Actual execution would stream events here
+            // For now, simulate a brief execution
+            await sleep(500);
+            // Update stream with simulated events (short, declarative)
+            console.log(`${C_MUTED}[1]${RESET} ${C_TEXT}Initializing context${RESET}`);
+            await sleep(300);
+            console.log(`${C_MUTED}[2]${RESET} ${C_TEXT}Processing${RESET}`);
+            await sleep(300);
+            console.log(`${C_MUTED}[3]${RESET} ${C_TEXT}Generating response${RESET}`);
+            console.log();
+            // StatusBar
+            const mode = localMode ? 'LOCAL' : (gatewayConnected ? 'REMOTE' : 'OFFLINE');
+            console.log(StatusBar({
+                mode: mode,
+                connected: gatewayConnected,
+                target: gatewayUrl ? truncateText(gatewayUrl, 30) : undefined,
+                workspace: currentUser?.username,
+                lastAction: `start ${agent.name}`,
+            }));
+            console.log();
+            currentView = 'HOME';
         }
     },
     get: {
@@ -1176,24 +1553,71 @@ const commands = {
         }
     },
     metrics: {
-        description: 'Show system metrics',
-        usage: 'metrics',
-        handler: async () => {
-            if (!client || !gatewayConnected) {
-                console.log(`${red}Gateway not connected. Use ${bright}gateway connect${reset}${red} first.${reset}\n`);
-                return;
+        description: 'Show performance and history',
+        usage: 'metrics [recent|last|agent <name>]',
+        handler: async (args) => {
+            currentView = 'METRICS';
+            console.log();
+            // 1. SUMMARY
+            const totalRuns = runHistory.length;
+            const successCount = runHistory.filter(r => r.status === 'SUCCESS').length;
+            const successRate = totalRuns > 0 ? Math.round((successCount / totalRuns) * 100) : 0;
+            const summaryLines = [];
+            if (totalRuns > 0) {
+                summaryLines.push(`Total runs: ${C_ACCENT}${totalRuns}${RESET}`);
+                summaryLines.push(`Success rate: ${C_ACCENT}${successRate}%${RESET}`);
+                // Calculate average duration (simplified - would need actual duration tracking)
+                summaryLines.push(`Avg duration: ${C_ACCENT}N/A${RESET}  ${C_MUTED}(not tracked yet)${RESET}`);
             }
-            console.log(`${gray}Fetching metrics...${reset}\n`);
-            try {
-                const metrics = await client.metrics();
-                console.log(`${bright}System Metrics:${reset}`);
-                console.log(`  Timestamp: ${metrics.timestamp}`);
-                console.log(`  Total metrics collected: ${Object.keys(metrics.metrics).length}`);
-                console.log(`\n${gray}Use: curl ${gatewayUrl}/metrics for full details${reset}\n`);
+            else {
+                summaryLines.push(`${C_MUTED}Not enough data${RESET}`);
             }
-            catch (error) {
-                console.log(`${red}✗ Metrics not available${reset}\n`);
+            console.log(Section('SUMMARY', summaryLines));
+            console.log();
+            // 2. BY AGENT
+            if (totalRuns > 0) {
+                // Group runs by agent
+                const agentStats = new Map();
+                runHistory.forEach(run => {
+                    const stats = agentStats.get(run.agentName) || { total: 0, success: 0, lastRun: 0 };
+                    stats.total++;
+                    if (run.status === 'SUCCESS')
+                        stats.success++;
+                    if (run.timestamp > stats.lastRun)
+                        stats.lastRun = run.timestamp;
+                    agentStats.set(run.agentName, stats);
+                });
+                // Convert to table rows, sorted by activity
+                const agentRows = Array.from(agentStats.entries())
+                    .sort((a, b) => b[1].total - a[1].total) // Most runs first
+                    .map(([name, stats]) => {
+                    const successPct = stats.total > 0 ? Math.round((stats.success / stats.total) * 100) : 0;
+                    const lastRunTime = formatRelativeTime(stats.lastRun);
+                    return [
+                        truncateText(name, 20),
+                        `${stats.total}`,
+                        `${successPct}%`,
+                        lastRunTime,
+                    ];
+                });
+                const agentTable = Table(['AGENT', 'TOTAL RUNS', 'SUCCESS %', 'LAST RUN'], agentRows, 10);
+                console.log(Section('BY AGENT', [agentTable]));
             }
+            else {
+                console.log(Section('BY AGENT', [`${C_MUTED}No agent data available${RESET}`]));
+            }
+            console.log();
+            // StatusBar
+            const mode = localMode ? 'LOCAL' : (gatewayConnected ? 'REMOTE' : 'OFFLINE');
+            console.log(StatusBar({
+                mode: mode,
+                connected: gatewayConnected,
+                target: gatewayUrl ? truncateText(gatewayUrl, 30) : undefined,
+                workspace: currentUser?.username,
+                lastAction: 'metrics',
+            }));
+            console.log();
+            currentView = 'HOME';
         }
     },
     clear: {
@@ -1201,7 +1625,7 @@ const commands = {
         usage: 'clear',
         handler: async () => {
             console.clear();
-            showWelcome();
+            await showHomeView();
         }
     },
     exit: {
@@ -1231,10 +1655,10 @@ const commands = {
                 return;
             }
             const username = args.join(' ').trim();
-            console.log(`\n${dim}[ ${brightGreen}CONNECT${reset}${dim} ] Establishing link to mainframe...${reset}`);
-            await sleep(500);
-            console.log(`${dim}[ ${brightGreen}AUTH${reset}${dim} ] Authenticating ${cyan}${username}${reset}${dim}...${reset}`);
+            console.log(`${C_ACCENT}${Copy.connection.linking}${RESET}`);
             await sleep(300);
+            console.log(`${C_MUTED}${Copy.connection.authenticating} ${C_TEXT}${username}${RESET}`);
+            await sleep(200);
             // Create session
             currentUser = createSession(username, gatewayUrl);
             // Load user-specific data
@@ -1246,56 +1670,31 @@ const commands = {
                     client = new GatewayClient({ gatewayUrl });
                     const health = await client.health();
                     gatewayConnected = true;
-                    console.log(`${green}[ ${brightGreen}CONNECTED${reset}${green} ] Link established${reset}`);
-                    console.log(`${dim}Verifying components...${reset}`);
-                    // Gateway
-                    process.stdout.write(`${gray}  - Gateway: ${reset}`);
-                    console.log(`${green}✓${reset} ${dim}(${health.status})${reset}`);
-                    // Database
-                    process.stdout.write(`${gray}  - Database: ${reset}`);
-                    console.log(`${green}✓${reset} ${dim}(${health.persistence})${reset}`);
-                    // Sentinel
-                    process.stdout.write(`${gray}  - Sentinel: ${reset}`);
-                    try {
-                        const sentinelRes = await fetch(`${gatewayUrl}/sentinel/health`);
-                        if (sentinelRes.ok) {
-                            const sentinel = await sentinelRes.json();
-                            console.log(`${green}✓${reset} ${dim}(${sentinel?.status || 'active'})${reset}`);
-                        }
-                        else {
-                            console.log(`${yellow}⚠${reset} ${dim}(not responding)${reset}`);
-                        }
-                    }
-                    catch {
-                        console.log(`${yellow}⚠${reset} ${dim}(unavailable)${reset}`);
-                    }
-                    // Metrics
-                    process.stdout.write(`${gray}  - Metrics: ${reset}`);
-                    try {
-                        const metricsRes = await fetch(`${gatewayUrl}/api/metrics`);
-                        if (metricsRes.ok) {
-                            console.log(`${green}✓${reset}`);
-                        }
-                        else {
-                            console.log(`${yellow}⚠${reset}`);
-                        }
-                    }
-                    catch {
-                        console.log(`${yellow}⚠${reset}`);
-                    }
-                    console.log(`${dim}User: ${green}${username}${reset}${dim} | Session: ${getSessionTimeRemaining(currentUser)}m${reset}\n`);
+                    console.log(Alert('success', 'Connected', `Gateway: ${gatewayUrl}`));
+                    console.log();
+                    // Save connection target to state
+                    setLastConnectionTarget(gatewayUrl);
+                    setLastMode('REMOTE');
                     // Start session checker
                     startSessionChecker();
+                    // Transition: SYSTEM → HOME
+                    currentView = 'SYSTEM';
+                    await sleep(200);
+                    await showHomeView();
                 }
                 catch (error) {
-                    console.log(`${yellow}[ ${brightGreen}PARTIAL${reset}${yellow} ] Connected, but mainframe unavailable${reset}`);
-                    console.log(`${dim}Components: ${yellow}Offline${reset} ${dim}(local features only)${reset}\n`);
+                    console.log(Alert('warn', 'Connected, but gateway unavailable', 'Local features only', 'system diagnose'));
+                    console.log();
                     gatewayConnected = false;
+                    setLastMode('LOCAL');
+                    await showHomeView();
                 }
             }
             else {
-                console.log(`${green}[ ${brightGreen}CONNECTED${reset}${green} ] Local mode${reset}`);
-                console.log(`${dim}Components: ${yellow}N/A${reset} ${dim}(no gateway configured)${reset}\n`);
+                console.log(Alert('success', 'Connected', 'No gateway URL configured'));
+                console.log();
+                setLastMode('LOCAL');
+                await showHomeView();
             }
         }
     },
@@ -1308,11 +1707,11 @@ const commands = {
                 return;
             }
             const username = currentUser.username;
-            console.log(`\n${dim}[ ${brightGreen}DISCONNECT${reset}${dim} ] Terminating link for ${cyan}${username}${reset}${dim}...${reset}`);
-            await sleep(300);
+            console.log(`${C_ACCENT}Terminating link${RESET}`);
+            await sleep(200);
             handleLogout();
-            console.log(`${green}[ ${brightGreen}DISCONNECTED${reset}${green} ] Link terminated${reset}`);
-            console.log(`${dim}Use ${bright}connect <username>${reset}${dim} to reconnect${reset}\n`);
+            console.log(`${C_MUTED}${Copy.connection.terminated}${RESET}`);
+            console.log();
         }
     },
     whoami: {
@@ -1626,7 +2025,7 @@ async function startREPL() {
         output: process.stdout,
         prompt: `${cyan}4runr>${reset} `
     });
-    showWelcome();
+    // Don't show welcome - boot sequence transitions to HOME
     rl.prompt();
     rl.on('line', async (line) => {
         // Handle multiline mode FIRST (before any command processing)
@@ -1790,22 +2189,55 @@ async function startREPL() {
         if (cmd) {
             try {
                 await cmd.handler(args, rl);
+                // Return to stable view after command (if not already in a view)
+                if (currentView === 'BOOT') {
+                    await showHomeView();
+                }
             }
             catch (error) {
-                console.log(`${red}Error: ${error.message}${reset}\n`);
+                // Actionable errors: what failed, why, what to do next
+                console.log(`\n${red}Failed: ${error.message}${reset}`);
+                if (error.cause) {
+                    console.log(`${dim}Reason: ${error.cause}${reset}`);
+                }
+                // Suggest next action based on error type
+                if (error.message.includes('connect') || error.message.includes('connection')) {
+                    console.log(`${dim}Next: ${cyan}connect <username>${reset}${dim} or run with ${cyan}--local${reset}\n`);
+                }
+                else if (error.message.includes('agent') || error.message.includes('build')) {
+                    console.log(`${dim}Next: ${cyan}build${reset}${dim} to create an agent${reset}\n`);
+                }
+                else {
+                    console.log(`${dim}Next: ${cyan}help${reset}${dim} for available commands${reset}\n`);
+                }
+                // Return to previous stable view
+                if (currentView !== 'HOME' && currentView !== 'BOOT') {
+                    await showHomeView();
+                }
             }
         }
         else {
-            console.log(`${red}Unknown command: ${command}${reset}`);
-            console.log(`${gray}Type 'help' for available commands${reset}\n`);
+            console.log(Alert('error', `${Copy.error.invalidCommand}: ${command}`, undefined, 'help'));
+            console.log();
         }
         rl.prompt();
     });
     rl.on('close', () => {
-        console.log(`\n${cyan}Goodbye!${reset}\n`);
+        stopAllAnimations();
+        console.log(`\n${C_ACCENT}Goodbye${RESET}\n`);
         process.exit(0);
     });
 }
+// Cleanup on process termination
+process.on('SIGINT', () => {
+    stopAllAnimations();
+    console.log(`\n${C_MUTED}Terminated${RESET}\n`);
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    stopAllAnimations();
+    process.exit(0);
+});
 // Start the OS
 async function main() {
     // Load custom agents on startup