4runr-os 2.10.39 → 2.10.41

package/mk3-tui/src/main.rs

@@ -3,7 +3,8 @@ use crossterm::cursor;
 use crossterm::event::{self, Event, KeyCode, KeyEventKind, MouseEventKind};
 use crossterm::execute;
 use crossterm::terminal::{
-    disable_raw_mode, enable_raw_mode, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen, SetTitle,
+    disable_raw_mode, enable_raw_mode, Clear, ClearType, EnterAlternateScreen,
+    LeaveAlternateScreen, SetTitle,
 };
 use ratatui::prelude::*;
 use std::time::{Duration, Instant};
@@ -11,6 +12,7 @@ use std::time::{Duration, Instant};
 mod app;
 mod debug_log;
 mod io;
+mod monitoring;
 mod screens;
 mod storage;
 mod ui;
@@ -23,6 +25,22 @@ use websocket::{WebSocketClient, WsClientMessage};
 /// Default local WebSocket port for TUI ↔ Node (keep in sync with `DEFAULT_TUI_WS_PORT` in `packages/os-cli/src/tui-defaults.ts`).
 const DEFAULT_TUI_WS_PORT: u16 = 8081;
 
+fn sanitize_monitoring_line(raw: &str) -> String {
+    let mut line: String = raw
+        .chars()
+        .map(|ch| match ch {
+            '\r' | '\n' => ' ',
+            ch if ch.is_control() && ch != '\t' => ' ',
+            ch => ch,
+        })
+        .collect();
+    if line.chars().count() > 500 {
+        line = line.chars().take(500).collect();
+        line.push('…');
+    }
+    line
+}
+
 fn main() -> Result<()> {
     // Window / tab title (otherwise hosts often show the executable name, e.g. mk3-tui)
     let window_title = match std::env::var("4RUNR_CLI_VERSION") {
@@ -33,36 +51,36 @@ fn main() -> Result<()> {
     // Setup terminal (boot screen is now part of TUI)
     enable_raw_mode()?;
     let mut stdout = std::io::stdout();
-    
+
     // Enter alternate screen, hide cursor, clear screen, move to top-left
     execute!(
-        stdout, 
+        stdout,
         EnterAlternateScreen,
         SetTitle(window_title),
         cursor::Hide,
         Clear(ClearType::All),
         cursor::MoveTo(0, 0)
     )?;
-    
+
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
-    
+
     // Clear the terminal buffer to ensure no artifacts
     terminal.clear()?;
 
     // Create app
     let mut app = App::new();
     let mut io_handler = IoHandler::new()?;
-    
+
     // Create runtime for async WebSocket client
     let rt = tokio::runtime::Runtime::new()?;
-    
+
     // Get TUI port from environment variable or default (see DEFAULT_TUI_WS_PORT)
     let tui_port = std::env::var("TUI_PORT")
         .ok()
         .and_then(|p| p.parse::<u16>().ok())
         .unwrap_or(DEFAULT_TUI_WS_PORT);
-    
+
     // Try to connect to WebSocket server
     let ws_url = format!("ws://localhost:{}", tui_port);
     let ws_client = rt.block_on(async {
@@ -78,17 +96,17 @@ fn main() -> Result<()> {
             }
         }
     });
-    
+
     // Track real time for uptime (not from tick counter)
     let start_time = Instant::now();
     let mut last_tick = Instant::now();
     let mut portal_connect_ui_tick = Instant::now();
-    
+
     // Track previous screen to detect portal navigation
     let mut previous_screen: Option<crate::screens::Screen> = None;
     // Last terminal size while Connection or Setup portal is visible (windowed hosts: sync buffer + clear on dimension drift).
     let mut standalone_portal_last_terminal_dims: Option<(u16, u16)> = None;
-    
+
     // Force initial render
     app.request_render("initial");
 
@@ -98,7 +116,7 @@ fn main() -> Result<()> {
         // ┌─────────────────────────────────────────────────────────┐
         // │ STEP 1: UPDATE ANIMATIONS (runs EVERY loop iteration)  │
         // └─────────────────────────────────────────────────────────┘
-        
+
         // Check if portal is active - if so, skip base screen state updates
         // This prevents base screen from affecting portal performance
         use crate::screens::Screen;
@@ -107,7 +125,7 @@ fn main() -> Result<()> {
             current_screen,
             Screen::ConnectionPortal | Screen::SetupPortal | Screen::PortalMonitoring
         );
-        
+
         // DEBUG: Log portal detection
         #[cfg(debug_assertions)]
         {
@@ -115,47 +133,54 @@ fn main() -> Result<()> {
             unsafe {
                 LOG_COUNT += 1;
                 if LOG_COUNT % 100 == 0 {
-                    eprintln!("[MAIN] Current screen: {:?}, Is portal active: {}", current_screen, is_portal_active);
-                    eprintln!("[MAIN] Base screen: {:?}, Overlay stack: {:?}", 
-                        app.state.navigation.base_screen, 
-                        app.state.navigation.overlay_stack);
+                    eprintln!(
+                        "[MAIN] Current screen: {:?}, Is portal active: {}",
+                        current_screen, is_portal_active
+                    );
+                    eprintln!(
+                        "[MAIN] Base screen: {:?}, Overlay stack: {:?}",
+                        app.state.navigation.base_screen, app.state.navigation.overlay_stack
+                    );
                 }
             }
         }
-        
+
         // Only update base screen state when NOT in a portal
         // Portals are standalone screens and don't need base screen updates
         if !is_portal_active {
             // Uptime - always update from real clock (OUTSIDE poll block)
             app.state.uptime_secs = start_time.elapsed().as_secs();
-            
+
             // Spinner - update on timer (every 150ms) - OUTSIDE poll block
             if last_tick.elapsed() >= Duration::from_millis(150) {
-                app.tick();  // Advances spinner_frame
+                app.tick(); // Advances spinner_frame
                 last_tick = Instant::now();
                 app.request_render("animation_tick"); // Request render for animation update
             }
         }
 
         // Connection Portal: redraw while waiting on gateway.connect so the elapsed timer advances
-        if matches!(current_screen, Screen::ConnectionPortal) && app.state.connection_portal.connecting {
+        if matches!(current_screen, Screen::ConnectionPortal)
+            && app.state.connection_portal.connecting
+        {
             if portal_connect_ui_tick.elapsed() >= Duration::from_millis(500) {
                 portal_connect_ui_tick = Instant::now();
                 app.request_immediate_render("portal_connecting_tick");
             }
         }
-        
+
         // Portal Monitoring: auto-refresh every 5 seconds when enabled
         if matches!(current_screen, Screen::PortalMonitoring) {
             let should_auto_refresh = {
                 let pm = &app.state.portal_monitoring;
                 pm.auto_refresh_enabled
                     && !pm.loading
-                    && pm.last_refresh
+                    && pm
+                        .last_refresh
                         .map(|lr| lr.elapsed() >= pm.auto_refresh_interval)
                         .unwrap_or(true)
             };
-            
+
             if should_auto_refresh {
                 if let Some(ws) = &ws_client {
                     app.state.portal_monitoring.last_refresh = Some(Instant::now());
@@ -163,7 +188,7 @@ fn main() -> Result<()> {
                 }
             }
         }
-        
+
         // ┌─────────────────────────────────────────────────────────┐
         // │ STEP 2: CHECK WEBSOCKET MESSAGES                       │
         // └─────────────────────────────────────────────────────────┘
@@ -172,17 +197,26 @@ fn main() -> Result<()> {
                 match msg {
                     WsClientMessage::Connected => {
                         app.add_log("WebSocket connected".to_string());
-                        
+
                         // Step 4.9: Send startup commands to load real data
                         if let Ok(id) = client.send_command("system.status", None) {
-                            app.add_log(format!("Sent system.status (id: {})", &id[id.len().saturating_sub(8)..]));
+                            app.add_log(format!(
+                                "Sent system.status (id: {})",
+                                &id[id.len().saturating_sub(8)..]
+                            ));
                         }
                         if let Ok(id) = client.send_command("agent.list", None) {
-                            app.add_log(format!("Sent agent.list (id: {})", &id[id.len().saturating_sub(8)..]));
+                            app.add_log(format!(
+                                "Sent agent.list (id: {})",
+                                &id[id.len().saturating_sub(8)..]
+                            ));
                         }
                     }
                     WsClientMessage::Disconnected => {
-                        app.add_log("[WEBSOCKET] Disconnected from CLI backend — Gateway link cleared".to_string());
+                        app.add_log(
+                            "[WEBSOCKET] Disconnected from CLI backend — Gateway link cleared"
+                                .to_string(),
+                        );
                         app.on_cli_backend_disconnect();
                     }
                     WsClientMessage::ConnectionLost => {
@@ -199,7 +233,7 @@ fn main() -> Result<()> {
                         if resp.payload.success {
                             // Format response nicely and update state based on command
                             let short_id = &resp.id[resp.id.len().saturating_sub(8)..];
-                            
+
                             // Try to extract and apply data to state
                             if let Some(data) = &resp.payload.data {
                                 if let Some(obj) = data.as_object() {
@@ -217,7 +251,9 @@ fn main() -> Result<()> {
                                             "✓ [{}] Mode: {}, Posture: {}",
                                             short_id,
                                             mode.as_str().unwrap_or("?"),
-                                            obj.get("posture").and_then(|p| p.as_str()).unwrap_or("?")
+                                            obj.get("posture")
+                                                .and_then(|p| p.as_str())
+                                                .unwrap_or("?")
                                         ));
                                     }
                                     // Handle agent.list response
@@ -225,63 +261,100 @@ fn main() -> Result<()> {
                                         if let Some(agents_array) = agents_data.as_array() {
                                             // Parse agents into AgentInfo structs
                                             use crate::app::AgentInfo;
-                                            let agents: Vec<AgentInfo> = agents_array.iter()
+                                            let agents: Vec<AgentInfo> = agents_array
+                                                .iter()
                                                 .filter_map(|agent| {
                                                     let obj = agent.as_object()?;
                                                     Some(AgentInfo {
-                                                        name: obj.get("name")?.as_str()?.to_string(),
-                                                        description: obj.get("description").and_then(|d| d.as_str()).map(|s| s.to_string()),
-                                                        model: obj.get("model").and_then(|m| m.as_str()).unwrap_or("unknown").to_string(),
-                                                        provider: obj.get("provider").and_then(|p| p.as_str()).unwrap_or("unknown").to_string(),
-                                                        system_prompt: obj.get("systemPrompt").and_then(|sp| sp.as_str()).map(|s| s.to_string()),
-                                                        temperature: obj.get("temperature").and_then(|t| t.as_f64()).map(|f| f as f32),
-                                                        max_tokens: obj.get("maxTokens").and_then(|mt| mt.as_u64()).map(|u| u as u32),
-                                                        tools: obj.get("tools")
+                                                        name: obj
+                                                            .get("name")?
+                                                            .as_str()?
+                                                            .to_string(),
+                                                        description: obj
+                                                            .get("description")
+                                                            .and_then(|d| d.as_str())
+                                                            .map(|s| s.to_string()),
+                                                        model: obj
+                                                            .get("model")
+                                                            .and_then(|m| m.as_str())
+                                                            .unwrap_or("unknown")
+                                                            .to_string(),
+                                                        provider: obj
+                                                            .get("provider")
+                                                            .and_then(|p| p.as_str())
+                                                            .unwrap_or("unknown")
+                                                            .to_string(),
+                                                        system_prompt: obj
+                                                            .get("systemPrompt")
+                                                            .and_then(|sp| sp.as_str())
+                                                            .map(|s| s.to_string()),
+                                                        temperature: obj
+                                                            .get("temperature")
+                                                            .and_then(|t| t.as_f64())
+                                                            .map(|f| f as f32),
+                                                        max_tokens: obj
+                                                            .get("maxTokens")
+                                                            .and_then(|mt| mt.as_u64())
+                                                            .map(|u| u as u32),
+                                                        tools: obj
+                                                            .get("tools")
                                                             .and_then(|t| t.as_array())
-                                                            .map(|arr| arr.iter()
-                                                                .filter_map(|v| v.as_str().map(|s| s.to_string()))
-                                                                .collect())
+                                                            .map(|arr| {
+                                                                arr.iter()
+                                                                    .filter_map(|v| {
+                                                                        v.as_str()
+                                                                            .map(|s| s.to_string())
+                                                                    })
+                                                                    .collect()
+                                                            })
                                                             .unwrap_or_default(),
                                                     })
                                                 })
                                                 .collect();
-                                            
+
                                             // Update capabilities with agent names
-                                            app.state.capabilities = agents.iter()
-                                                .map(|a| a.name.clone())
-                                                .collect();
-                                            
+                                            app.state.capabilities =
+                                                agents.iter().map(|a| a.name.clone()).collect();
+
                                             // Update cache with agent data
                                             if let Some(cache) = &mut app.state.cache {
                                                 use crate::storage::cache::AgentData;
                                                 use std::time::{SystemTime, UNIX_EPOCH};
-                                                
-                                                let cache_agents: Vec<AgentData> = agents.iter()
+
+                                                let cache_agents: Vec<AgentData> = agents
+                                                    .iter()
                                                     .map(|agent| AgentData {
                                                         name: agent.name.clone(),
                                                         description: agent.description.clone(),
                                                         model: agent.model.clone(),
                                                         provider: agent.provider.clone(),
-                                                        created_at: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
+                                                        created_at: SystemTime::now()
+                                                            .duration_since(UNIX_EPOCH)
+                                                            .unwrap()
+                                                            .as_secs(),
                                                     })
                                                     .collect();
-                                                
+
                                                 let _ = cache.update_agents(cache_agents);
                                             }
-                                            
+
                                             // Update agent list state
                                             app.state.agent_list.agents = agents;
                                             app.state.agent_list.selected_index = 0;
                                             app.state.agent_list.detail_view = None;
-                                            
+
                                             // Clear pending agent.list ID if this response matches (Step 5.2)
-                                            if Some(&resp.id) == app.state.pending_agent_list_id.as_ref() {
+                                            if Some(&resp.id)
+                                                == app.state.pending_agent_list_id.as_ref()
+                                            {
                                                 app.state.pending_agent_list_id = None;
                                             }
-                                            
+
                                             // Only open AgentList overlay if we're on Main screen (not during boot)
                                             use crate::screens::Screen;
-                                            if app.state.navigation.current_screen() == &Screen::Main {
+                                            if app.state.navigation.current_screen()
+                                                == &Screen::Main
+                                            {
                                                 app.push_overlay(Screen::AgentList);
                                                 app.request_render("agent_list_opened");
                                             }
@@ -290,51 +363,76 @@ fn main() -> Result<()> {
                                     // Handle agent.create response (Step 5.1)
                                     else if let Some(agent) = obj.get("agent") {
                                         // Check if this is a response to our agent.create command
-                                        if Some(&resp.id) == app.state.pending_agent_create_id.as_ref() {
+                                        if Some(&resp.id)
+                                            == app.state.pending_agent_create_id.as_ref()
+                                        {
                                             app.state.pending_agent_create_id = None;
-                                            
+
                                             // Extract agent name for success message
-                                            let agent_name = agent.as_object()
+                                            let agent_name = agent
+                                                .as_object()
                                                 .and_then(|a| a.get("name"))
                                                 .and_then(|n| n.as_str())
                                                 .unwrap_or("unknown");
-                                            
-                                            app.add_log(format!("✓ [{}] Agent '{}' created successfully", short_id, agent_name));
-                                            
+
+                                            app.add_log(format!(
+                                                "✓ [{}] Agent '{}' created successfully",
+                                                short_id, agent_name
+                                            ));
+
                                             // Refresh agent list (Step 5.3)
                                             if let Some(ref ws) = ws_client {
-                                                if let Ok(list_id) = ws.send_command("agent.list", None) {
+                                                if let Ok(list_id) =
+                                                    ws.send_command("agent.list", None)
+                                                {
                                                     app.state.pending_agent_list_id = Some(list_id);
                                                 }
                                             }
                                         } else {
-                                            app.add_log(format!("✓ [{}] Agent response received", short_id));
+                                            app.add_log(format!(
+                                                "✓ [{}] Agent response received",
+                                                short_id
+                                            ));
                                         }
                                     }
                                     // Handle agent.delete response (Step 5.5)
                                     else if let Some(deleted) = obj.get("deleted") {
                                         if deleted.as_bool().unwrap_or(false) {
-                                            if Some(&resp.id) == app.state.pending_agent_delete_id.as_ref() {
+                                            if Some(&resp.id)
+                                                == app.state.pending_agent_delete_id.as_ref()
+                                            {
                                                 app.state.pending_agent_delete_id = None;
-                                                app.add_log(format!("✓ [{}] Agent deleted successfully", short_id));
-                                                
+                                                app.add_log(format!(
+                                                    "✓ [{}] Agent deleted successfully",
+                                                    short_id
+                                                ));
+
                                                 // Refresh agent list (Step 5.5)
                                                 if let Some(ref ws) = ws_client {
-                                                    if let Ok(list_id) = ws.send_command("agent.list", None) {
-                                                        app.state.pending_agent_list_id = Some(list_id);
+                                                    if let Ok(list_id) =
+                                                        ws.send_command("agent.list", None)
+                                                    {
+                                                        app.state.pending_agent_list_id =
+                                                            Some(list_id);
                                                     }
                                                 }
                                             }
                                         }
                                     }
                                     // Step 6: run.list (match pending id first — avoids stealing the chain on unrelated `runs` keys)
-                                    else if Some(&resp.id) == app.state.pending_run_list_id.as_ref() {
+                                    else if Some(&resp.id)
+                                        == app.state.pending_run_list_id.as_ref()
+                                    {
                                         app.state.pending_run_list_id = None;
-                                        if let Some(runs_arr) = obj.get("runs").and_then(|r| r.as_array()) {
+                                        if let Some(runs_arr) =
+                                            obj.get("runs").and_then(|r| r.as_array())
+                                        {
                                             use crate::ui::run_manager::run_info_from_gateway_value;
                                             let mut parsed = Vec::new();
                                             for item in runs_arr {
-                                                if let Some(info) = run_info_from_gateway_value(item) {
+                                                if let Some(info) =
+                                                    run_info_from_gateway_value(item)
+                                                {
                                                     parsed.push(info);
                                                 }
                                             }
@@ -353,18 +451,23 @@ fn main() -> Result<()> {
                                         }
                                     }
                                     // Step 6: run.get (detail) — pending id first so `run` never blocks other handlers
-                                    else if Some(&resp.id) == app.state.pending_run_get_id.as_ref() {
+                                    else if Some(&resp.id)
+                                        == app.state.pending_run_get_id.as_ref()
+                                    {
                                         app.state.pending_run_get_id = None;
                                         if let Some(run_val) = obj.get("run") {
                                             use crate::ui::run_manager::run_info_from_gateway_value;
-                                            if let Some(info) = run_info_from_gateway_value(run_val) {
+                                            if let Some(info) = run_info_from_gateway_value(run_val)
+                                            {
                                                 app.state.run_manager.merge_run_detail(info);
                                             }
                                         }
                                         app.request_render("run_detail_loaded");
                                     }
                                     // Step 6: run.cancel
-                                    else if Some(&resp.id) == app.state.pending_run_cancel_id.as_ref() {
+                                    else if Some(&resp.id)
+                                        == app.state.pending_run_cancel_id.as_ref()
+                                    {
                                         app.state.pending_run_cancel_id = None;
                                         if let (Some(rid), Some(st)) = (
                                             obj.get("runId").and_then(|v| v.as_str()),
@@ -375,18 +478,24 @@ fn main() -> Result<()> {
                                                 short_id, rid, st
                                             ));
                                         } else {
-                                            app.add_log(format!("✓ [{}] Run cancel acknowledged", short_id));
+                                            app.add_log(format!(
+                                                "✓ [{}] Run cancel acknowledged",
+                                                short_id
+                                            ));
                                         }
                                         if let Some(ref ws) = ws_client {
                                             let data = serde_json::json!({ "limit": 50 });
-                                            if let Ok(lid) = ws.send_command("run.list", Some(data)) {
+                                            if let Ok(lid) = ws.send_command("run.list", Some(data))
+                                            {
                                                 app.state.pending_run_list_id = Some(lid);
                                             }
                                         }
                                         app.request_render("run_cancelled");
                                     }
                                     // Step 6: run.quick
-                                    else if Some(&resp.id) == app.state.pending_run_quick_id.as_ref() {
+                                    else if Some(&resp.id)
+                                        == app.state.pending_run_quick_id.as_ref()
+                                    {
                                         app.state.pending_run_quick_id = None;
                                         if let (Some(rid), Some(st)) = (
                                             obj.get("runId").and_then(|v| v.as_str()),
@@ -401,42 +510,197 @@ fn main() -> Result<()> {
                                         }
                                         if let Some(ref ws) = ws_client {
                                             let data = serde_json::json!({ "limit": 50 });
-                                            if let Ok(lid) = ws.send_command("run.list", Some(data)) {
+                                            if let Ok(lid) = ws.send_command("run.list", Some(data))
+                                            {
                                                 app.state.pending_run_list_id = Some(lid);
                                             }
                                         }
                                         app.request_render("run_quick_ok");
                                     }
+                                    // Portal Monitoring Phase 2: monitoring.refresh (section slice)
+                                    else if Some(&resp.id)
+                                        == app.state.pending_monitoring_refresh_id.as_ref()
+                                    {
+                                        app.state.pending_monitoring_refresh_id = None;
+                                        app.state.portal_monitoring.section_refresh_loading = None;
+                                        if obj.get("monitoringRefresh").and_then(|v| v.as_bool())
+                                            == Some(true)
+                                        {
+                                            let section_str = obj
+                                                .get("section")
+                                                .and_then(|v| v.as_str())
+                                                .unwrap_or("");
+                                            use crate::monitoring::MonitoringSection;
+                                            if let Some(sec) =
+                                                MonitoringSection::from_cli_slug(section_str)
+                                            {
+                                                let lines: Vec<String> = obj
+                                                    .get("lines")
+                                                    .and_then(|a| a.as_array())
+                                                    .map(|arr| {
+                                                        arr.iter()
+                                                            .filter_map(|v| {
+                                                                v.as_str()
+                                                                    .map(sanitize_monitoring_line)
+                                                            })
+                                                            .collect()
+                                                    })
+                                                    .unwrap_or_default();
+                                                app.state
+                                                    .portal_monitoring
+                                                    .section_overrides
+                                                    .insert(sec, lines);
+                                            }
+                                        }
+                                        app.request_render("monitoring_refresh_ok");
+                                    }
+                                    // Portal Monitoring Phase 2: monitoring.logs
+                                    else if Some(&resp.id)
+                                        == app.state.pending_monitoring_logs_id.as_ref()
+                                    {
+                                        app.state.pending_monitoring_logs_id = None;
+                                        app.state.portal_monitoring.logs_fetch_loading = false;
+                                        if obj.get("monitoringLogs").and_then(|v| v.as_bool())
+                                            == Some(true)
+                                        {
+                                            let lines: Vec<String> = obj
+                                                .get("logs")
+                                                .and_then(|a| a.as_array())
+                                                .map(|arr| {
+                                                    arr.iter()
+                                                        .filter_map(|entry| {
+                                                            let e = entry.as_object()?;
+                                                            let ts = e
+                                                                .get("timestamp")
+                                                                .and_then(|v| v.as_str())
+                                                                .unwrap_or("");
+                                                            let lvl = e
+                                                                .get("level")
+                                                                .and_then(|v| v.as_str())
+                                                                .unwrap_or("");
+                                                            let msg = e
+                                                                .get("message")
+                                                                .and_then(|v| v.as_str())
+                                                                .unwrap_or("");
+                                                            if ts.is_empty()
+                                                                && lvl.is_empty()
+                                                                && msg.is_empty()
+                                                            {
+                                                                return None;
+                                                            }
+                                                            Some(sanitize_monitoring_line(
+                                                                &format!(
+                                                                    "{} [{}] {}",
+                                                                    ts, lvl, msg
+                                                                ),
+                                                            ))
+                                                        })
+                                                        .collect()
+                                                })
+                                                .unwrap_or_default();
+                                            use crate::monitoring::MonitoringSection;
+                                            app.state
+                                                .portal_monitoring
+                                                .section_overrides
+                                                .insert(MonitoringSection::Logs, lines);
+                                        }
+                                        app.request_render("monitoring_logs_ok");
+                                    }
+                                    // Portal Monitoring Phase 3: monitoring.drill (metrics sub-panels / dependency detail)
+                                    else if Some(&resp.id)
+                                        == app.state.pending_monitoring_drill_id.as_ref()
+                                    {
+                                        app.state.pending_monitoring_drill_id = None;
+                                        app.state.portal_monitoring.metrics_drill_loading = false;
+                                        app.state.portal_monitoring.section_refresh_loading = None;
+                                        if obj.get("monitoringDrill").and_then(|v| v.as_bool())
+                                            == Some(true)
+                                        {
+                                            let target = obj
+                                                .get("target")
+                                                .and_then(|v| v.as_str())
+                                                .unwrap_or("");
+                                            let lines: Vec<String> = obj
+                                                .get("lines")
+                                                .and_then(|a| a.as_array())
+                                                .map(|arr| {
+                                                    arr.iter()
+                                                        .filter_map(|v| {
+                                                            v.as_str().map(sanitize_monitoring_line)
+                                                        })
+                                                        .collect()
+                                                })
+                                                .unwrap_or_default();
+                                            use crate::monitoring::{
+                                                MetricsDrillPanel, MonitoringSection,
+                                            };
+                                            if target == "dependencies_detail" {
+                                                app.state
+                                                    .portal_monitoring
+                                                    .section_overrides
+                                                    .insert(MonitoringSection::Dependencies, lines);
+                                            } else if target == "system_diagnostics" {
+                                                app.state
+                                                    .portal_monitoring
+                                                    .section_overrides
+                                                    .insert(MonitoringSection::System, lines);
+                                            } else if let Some(panel) =
+                                                MetricsDrillPanel::from_cli_target(target)
+                                            {
+                                                app.state.portal_monitoring.metrics_drill =
+                                                    Some(panel);
+                                                app.state.portal_monitoring.metrics_drill_lines =
+                                                    lines;
+                                            }
+                                        }
+                                        app.request_render("monitoring_drill_ok");
+                                    }
                                     // Portal Monitoring: gateway.observability (/metrics snapshot)
-                                    else if Some(&resp.id) == app.state.pending_gateway_observability_id.as_ref() {
+                                    else if Some(&resp.id)
+                                        == app.state.pending_gateway_observability_id.as_ref()
+                                    {
                                         app.state.pending_gateway_observability_id = None;
                                         app.state.portal_monitoring.loading = false;
-                                        app.state.portal_observability_last_poll = Some(Instant::now());
-                                        if obj.get("observability").and_then(|v| v.as_bool()) == Some(true) {
+                                        app.state.portal_observability_last_poll =
+                                            Some(Instant::now());
+                                        if obj.get("observability").and_then(|v| v.as_bool())
+                                            == Some(true)
+                                        {
                                             let snapshot = obj
                                                 .get("snapshotAt")
                                                 .and_then(|v| v.as_str())
                                                 .unwrap_or("")
                                                 .to_string();
+                                            // Snapshot markers — keep substring order compatible with
+                                            // `portal_monitoring::SNAPSHOT_MARKER_*` (CLI healthLines + layout below).
                                             let mut lines: Vec<String> = vec![
                                                 "Portal snapshot (health + metrics on each refresh / auto poll)."
                                                     .to_string(),
                                                 format!("Fetched: {}", if snapshot.is_empty() { "—" } else { snapshot.as_str() }),
                                                 String::new(),
                                             ];
-                                            if let Some(tot) = obj.get("totals").and_then(|v| v.get("httpRequests")) {
+                                            if let Some(tot) = obj
+                                                .get("totals")
+                                                .and_then(|v| v.get("httpRequests"))
+                                            {
                                                 let current = tot
                                                     .as_u64()
                                                     .or_else(|| tot.as_f64().map(|f| f as u64));
                                                 if let Some(c) = current {
                                                     if let (Some(prev), Some(last_t)) = (
-                                                        app.state.portal_monitoring.last_http_for_delta,
-                                                        app.state.portal_monitoring.last_instant_for_delta,
+                                                        app.state
+                                                            .portal_monitoring
+                                                            .last_http_for_delta,
+                                                        app.state
+                                                            .portal_monitoring
+                                                            .last_instant_for_delta,
                                                     ) {
                                                         let d = c.saturating_sub(prev);
-                                                        let el = last_t.elapsed().as_secs_f32().max(0.1);
+                                                        let el =
+                                                            last_t.elapsed().as_secs_f32().max(0.1);
                                                         let per_min = (d as f32 / el) * 60.0;
-                                                        let pulse = if d > 0 { "  *" } else { "  --" };
+                                                        let pulse =
+                                                            if d > 0 { "  *" } else { "  --" };
                                                         lines.push(format!(
                                                             "LIVE: +{} HTTP since last screen refresh (~{:.0}/min){}",
                                                             d, per_min, pulse
@@ -444,13 +708,138 @@ fn main() -> Result<()> {
                                                     } else {
                                                         lines.push("LIVE: first sample — next refresh shows HTTP request rate (poll interval).".to_string());
                                                     }
-                                                    app.state.portal_monitoring.last_http_for_delta = Some(c);
-                                                    app.state.portal_monitoring.last_instant_for_delta =
+                                                    app.state
+                                                        .portal_monitoring
+                                                        .last_http_for_delta = Some(c);
+                                                    app.state
+                                                        .portal_monitoring
+                                                        .last_instant_for_delta =
                                                         Some(std::time::Instant::now());
+                                                    app.state
+                                                        .portal_monitoring
+                                                        .http_total_sparkline
+                                                        .push_back(c);
+                                                    while app
+                                                        .state
+                                                        .portal_monitoring
+                                                        .http_total_sparkline
+                                                        .len()
+                                                        > 48
+                                                    {
+                                                        app.state
+                                                            .portal_monitoring
+                                                            .http_total_sparkline
+                                                            .pop_front();
+                                                    }
                                                 }
                                             }
+                                            if let Some(totals) =
+                                                obj.get("totals").and_then(|v| v.as_object())
+                                            {
+                                                app.state
+                                                    .portal_monitoring
+                                                    .metric_history
+                                                    .push_back(
+                                                    crate::app::metric_history_entry_from_totals(
+                                                        if snapshot.is_empty() {
+                                                            "—".to_string()
+                                                        } else {
+                                                            snapshot.clone()
+                                                        },
+                                                        totals,
+                                                    ),
+                                                );
+                                                while app
+                                                    .state
+                                                    .portal_monitoring
+                                                    .metric_history
+                                                    .len()
+                                                    > 720
+                                                {
+                                                    app.state
+                                                        .portal_monitoring
+                                                        .metric_history
+                                                        .pop_front();
+                                                }
+                                            }
+                                            // Phase 5 v1: dependency alerts are text-derived from
+                                            // observability health lines, not a structured readiness enum.
+                                            let dependency_status = {
+                                                let mut status = if obj
+                                                    .get("healthOk")
+                                                    .and_then(|v| v.as_bool())
+                                                    == Some(false)
+                                                {
+                                                    "unhealthy"
+                                                } else {
+                                                    "healthy"
+                                                };
+                                                if let Some(arr) = obj
+                                                    .get("healthLines")
+                                                    .and_then(|a| a.as_array())
+                                                {
+                                                    for v in arr {
+                                                        if let Some(s) = v.as_str() {
+                                                            let l = s.to_lowercase();
+                                                            if l.contains("✗")
+                                                                || l.contains(": down")
+                                                                || l.contains("not ready")
+                                                            {
+                                                                status = "unhealthy";
+                                                                break;
+                                                            }
+                                                            if l.contains("⚠")
+                                                                || l.contains("degraded")
+                                                                || l.contains("warning")
+                                                            {
+                                                                status = "degraded";
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                                status.to_string()
+                                            };
+                                            if let Some(prev) = app
+                                                .state
+                                                .portal_monitoring
+                                                .last_dependency_status
+                                                .clone()
+                                            {
+                                                if prev != dependency_status {
+                                                    app.state
+                                                        .portal_monitoring
+                                                        .dependency_alerts
+                                                        .push_back(
+                                                            crate::app::DependencyAlertEntry {
+                                                                timestamp: if snapshot.is_empty() {
+                                                                    "—".to_string()
+                                                                } else {
+                                                                    snapshot.clone()
+                                                                },
+                                                                previous: prev,
+                                                                current: dependency_status.clone(),
+                                                            },
+                                                        );
+                                                    while app
+                                                        .state
+                                                        .portal_monitoring
+                                                        .dependency_alerts
+                                                        .len()
+                                                        > 10
+                                                    {
+                                                        app.state
+                                                            .portal_monitoring
+                                                            .dependency_alerts
+                                                            .pop_front();
+                                                    }
+                                                }
+                                            }
+                                            app.state.portal_monitoring.last_dependency_status =
+                                                Some(dependency_status);
                                             lines.push(String::new());
-                                            if let Some(arr) = obj.get("healthLines").and_then(|a| a.as_array()) {
+                                            if let Some(arr) =
+                                                obj.get("healthLines").and_then(|a| a.as_array())
+                                            {
                                                 for v in arr {
                                                     if let Some(s) = v.as_str() {
                                                         lines.push(s.to_string());
@@ -463,7 +852,9 @@ fn main() -> Result<()> {
                                                     .to_string(),
                                             );
                                             lines.push(String::new());
-                                            if let Some(arr) = obj.get("statsLines").and_then(|a| a.as_array()) {
+                                            if let Some(arr) =
+                                                obj.get("statsLines").and_then(|a| a.as_array())
+                                            {
                                                 for v in arr {
                                                     if let Some(s) = v.as_str() {
                                                         lines.push(s.to_string());
@@ -471,8 +862,13 @@ fn main() -> Result<()> {
                                                 }
                                             }
                                             lines.push(String::new());
-                                            lines.push("Top HTTP routes (from http_requests_total labels)".to_string());
-                                            if let Some(arr) = obj.get("routeLines").and_then(|a| a.as_array()) {
+                                            lines.push(
+                                                "Top HTTP routes (from http_requests_total labels)"
+                                                    .to_string(),
+                                            );
+                                            if let Some(arr) =
+                                                obj.get("routeLines").and_then(|a| a.as_array())
+                                            {
                                                 if !arr.is_empty() {
                                                     lines.push(
                                                         "  (method route)                         count".to_string(),
@@ -490,11 +886,21 @@ fn main() -> Result<()> {
                                                 }
                                             } else {
                                                 lines.push(
-                                                    "  (no route breakdown in response.)".to_string(),
+                                                    "  (no route breakdown in response.)"
+                                                        .to_string(),
                                                 );
                                             }
-                                            app.state.portal_monitoring.last_updated = Some(snapshot);
+                                            app.state.portal_monitoring.last_updated =
+                                                Some(snapshot);
                                             app.state.portal_monitoring.content_lines = lines;
+                                            app.state.portal_monitoring.section_overrides.clear();
+                                            app.state.portal_monitoring.section_refresh_loading =
+                                                None;
+                                            app.state.portal_monitoring.logs_fetch_loading = false;
+                                            app.state.portal_monitoring.metrics_drill = None;
+                                            app.state.portal_monitoring.metrics_drill_lines.clear();
+                                            app.state.portal_monitoring.metrics_drill_loading =
+                                                false;
                                             app.state.portal_monitoring.error = None;
                                             app.state.portal_monitoring.scroll_offset = 0;
                                         } else {
@@ -507,41 +913,55 @@ fn main() -> Result<()> {
                                     // Handle gateway.connect response (Step 7.5)
                                     else if let Some(connected) = obj.get("connected") {
                                         if connected.as_bool().unwrap_or(false) {
-                                            if Some(&resp.id) == app.state.pending_gateway_connect_id.as_ref() {
+                                            if Some(&resp.id)
+                                                == app.state.pending_gateway_connect_id.as_ref()
+                                            {
                                                 app.state.pending_gateway_connect_id = None;
-                                                
+
                                                 use crate::app::OperationMode;
                                                 app.state.operation_mode = OperationMode::Connected;
-                                                
-                                                let url = obj.get("url")
+
+                                                let url = obj
+                                                    .get("url")
                                                     .and_then(|v| v.as_str())
                                                     .unwrap_or("unknown");
-                                                
+
                                                 app.state.gateway_url = Some(url.to_string());
-                                                app.state.connection_portal.last_successful_url = Some(url.to_string());
+                                                app.state.connection_portal.last_successful_url =
+                                                    Some(url.to_string());
                                                 app.state.connection_portal.finish_connecting();
-                                                app.state.connection_portal.connection_success = true;  // Phase 1.3: Set success flag
-                                                // Dashboard "Demo Mode / NET" used `connected`, which was never set — align with Gateway link
+                                                app.state.connection_portal.connection_success =
+                                                    true; // Phase 1.3: Set success flag
+                                                          // Dashboard "Demo Mode / NET" used `connected`, which was never set — align with Gateway link
                                                 app.state.connected = true;
-                                                
+
                                                 // Parse activity log if present
                                                 if let Some(activity_log) = obj.get("activityLog") {
-                                                    if let Some(log_array) = activity_log.as_array() {
-                                                        app.state.connection_portal.activity_log.clear();
+                                                    if let Some(log_array) = activity_log.as_array()
+                                                    {
+                                                        app.state
+                                                            .connection_portal
+                                                            .activity_log
+                                                            .clear();
                                                         for entry in log_array {
-                                                            if let Some(entry_obj) = entry.as_object() {
-                                                                let timestamp = entry_obj.get("timestamp")
+                                                            if let Some(entry_obj) =
+                                                                entry.as_object()
+                                                            {
+                                                                let timestamp = entry_obj
+                                                                    .get("timestamp")
                                                                     .and_then(|v| v.as_str())
                                                                     .unwrap_or("")
                                                                     .to_string();
-                                                                let level_str = entry_obj.get("level")
+                                                                let level_str = entry_obj
+                                                                    .get("level")
                                                                     .and_then(|v| v.as_str())
                                                                     .unwrap_or("info");
-                                                                let message = entry_obj.get("message")
+                                                                let message = entry_obj
+                                                                    .get("message")
                                                                     .and_then(|v| v.as_str())
                                                                     .unwrap_or("")
                                                                     .to_string();
-                                                                
+
                                                                 use crate::app::LogLevel;
                                                                 let level = match level_str {
                                                                     "success" => LogLevel::Success,
@@ -549,36 +969,55 @@ fn main() -> Result<()> {
                                                                     "error" => LogLevel::Error,
                                                                     _ => LogLevel::Info,
                                                                 };
-                                                                
-                                                                app.state.connection_portal.add_log_entry(timestamp, level, message);
+
+                                                                app.state
+                                                                    .connection_portal
+                                                                    .add_log_entry(
+                                                                        timestamp, level, message,
+                                                                    );
                                                             }
                                                         }
                                                     }
                                                 }
-                                                
+
                                                 // Phase 1.2: Prominent connection success notification
-                                                app.add_log("═══════════════════════════════════════════".to_string());
+                                                app.add_log(
+                                                    "═══════════════════════════════════════════"
+                                                        .to_string(),
+                                                );
                                                 app.add_log(format!("✅ CONNECTED TO GATEWAY"));
                                                 app.add_log(format!("   URL: {}", url));
                                                 app.add_log(format!("   Status: Connected"));
                                                 app.add_log("   Note: connect checks /health + /ready; Shield/Sentinel run on the Gateway during jobs.".to_string());
-                                                app.add_log("═══════════════════════════════════════════".to_string());
-                                                app.add_log(format!("[MODE] Switched to CONNECTED mode"));
-                                                
+                                                app.add_log(
+                                                    "═══════════════════════════════════════════"
+                                                        .to_string(),
+                                                );
+                                                app.add_log(format!(
+                                                    "[MODE] Switched to CONNECTED mode"
+                                                ));
+
                                                 // Phase 2.1: Immediately verify connection with health check
-                                                app.add_log(format!("[GATEWAY] Verifying connection health..."));
+                                                app.add_log(format!(
+                                                    "[GATEWAY] Verifying connection health..."
+                                                ));
                                                 if let Some(ref ws) = ws_client {
-                                                    if let Ok(health_id) = ws.send_command("gateway.health", None) {
-                                                        app.state.pending_gateway_health_id = Some(health_id);
+                                                    if let Ok(health_id) =
+                                                        ws.send_command("gateway.health", None)
+                                                    {
+                                                        app.state.pending_gateway_health_id =
+                                                            Some(health_id);
                                                     }
                                                     // Refresh posture / NET labels from CLI (matches gateway-backed system.status)
                                                     let _ = ws.send_command("system.status", None);
                                                 }
-                                                
+
                                                 // CRITICAL: Request render after state change to update UI
                                                 // CRITICAL: Use immediate render for instant success display
-                                                app.request_immediate_render("gateway_connect_success");
-                                                
+                                                app.request_immediate_render(
+                                                    "gateway_connect_success",
+                                                );
+
                                                 // Phase 1.3: Portal will show success state (user closes with ESC)
                                                 // Don't auto-close - let user see success message
                                             }
@@ -590,11 +1029,20 @@ fn main() -> Result<()> {
                                             app.state.connected = false;
                                             app.state.gateway_healthy = false;
                                             app.state.gateway_db_summary = None;
-                                            app.add_log(format!("✓ [{}] Disconnected from Gateway", short_id));
+                                            app.add_log(format!(
+                                                "✓ [{}] Disconnected from Gateway",
+                                                short_id
+                                            ));
                                             app.add_log(format!("[MODE] Switched to LOCAL mode"));
                                             app.state.pending_gateway_observability_id = None;
+                                            app.state.pending_monitoring_refresh_id = None;
+                                            app.state.pending_monitoring_logs_id = None;
+                                            app.state.pending_monitoring_drill_id = None;
                                             app.state.portal_observability_last_poll = None;
-                                            app.state.portal_monitoring = crate::app::PortalMonitoringState::default();
+                                            app.state.portal_monitoring =
+                                                crate::app::PortalMonitoringState::default();
+                                            app.state.advanced_monitoring =
+                                                crate::app::AdvancedMonitoringState::default();
                                             if let Some(ref ws) = ws_client {
                                                 let _ = ws.send_command("system.status", None);
                                             }
@@ -602,18 +1050,33 @@ fn main() -> Result<()> {
                                     }
                                     // Handle setup.detect response
                                     else if let Some(local_bundle) = obj.get("localBundle") {
-                                        if Some(&resp.id) == app.state.pending_setup_detect_id.as_ref() {
+                                        if Some(&resp.id)
+                                            == app.state.pending_setup_detect_id.as_ref()
+                                        {
                                             app.state.pending_setup_detect_id = None;
                                             app.state.setup_portal.detecting = false;
                                             app.state.setup_portal.detecting_since = None;
-                                            
-                                            use crate::app::{DetectionResult, BundleStatus, CloudStatus};
-                                            
-                                            let bundle_status = if let Some(bundle_obj) = local_bundle.as_object() {
+
+                                            use crate::app::{
+                                                BundleStatus, CloudStatus, DetectionResult,
+                                            };
+
+                                            let bundle_status = if let Some(bundle_obj) =
+                                                local_bundle.as_object()
+                                            {
                                                 BundleStatus {
-                                                    available: bundle_obj.get("available").and_then(|v| v.as_bool()).unwrap_or(false),
-                                                    running: bundle_obj.get("running").and_then(|v| v.as_bool()).unwrap_or(false),
-                                                    path: bundle_obj.get("path").and_then(|v| v.as_str()).map(|s| s.to_string()),
+                                                    available: bundle_obj
+                                                        .get("available")
+                                                        .and_then(|v| v.as_bool())
+                                                        .unwrap_or(false),
+                                                    running: bundle_obj
+                                                        .get("running")
+                                                        .and_then(|v| v.as_bool())
+                                                        .unwrap_or(false),
+                                                    path: bundle_obj
+                                                        .get("path")
+                                                        .and_then(|v| v.as_str())
+                                                        .map(|s| s.to_string()),
                                                 }
                                             } else {
                                                 app.state.setup_portal.error = Some(
@@ -625,33 +1088,54 @@ fn main() -> Result<()> {
                                                     path: None,
                                                 }
                                             };
-                                            
-                                            let cloud_obj = obj.get("cloudServer").and_then(|v| v.as_object());
+
+                                            let cloud_obj =
+                                                obj.get("cloudServer").and_then(|v| v.as_object());
                                             let cloud_status = CloudStatus {
-                                                available: cloud_obj.and_then(|o| o.get("available")).and_then(|v| v.as_bool()).unwrap_or(false),
-                                                status: cloud_obj.and_then(|o| o.get("status")).and_then(|v| v.as_str()).unwrap_or("Unknown").to_string(),
+                                                available: cloud_obj
+                                                    .and_then(|o| o.get("available"))
+                                                    .and_then(|v| v.as_bool())
+                                                    .unwrap_or(false),
+                                                status: cloud_obj
+                                                    .and_then(|o| o.get("status"))
+                                                    .and_then(|v| v.as_str())
+                                                    .unwrap_or("Unknown")
+                                                    .to_string(),
                                             };
-                                            
-                                            app.state.setup_portal.detection_result = Some(DetectionResult {
-                                                local_bundle: bundle_status,
-                                                cloud_server: cloud_status,
-                                            });
-                                            
-                                            app.add_log("[SETUP] Gateway detection complete".to_string());
+
+                                            app.state.setup_portal.detection_result =
+                                                Some(DetectionResult {
+                                                    local_bundle: bundle_status,
+                                                    cloud_server: cloud_status,
+                                                });
+
+                                            app.add_log(
+                                                "[SETUP] Gateway detection complete".to_string(),
+                                            );
                                         }
                                     }
                                     // Phase 2.1: Handle gateway.health response
                                     else if let Some(healthy) = obj.get("healthy") {
-                                        if Some(&resp.id) == app.state.pending_gateway_health_id.as_ref() {
+                                        if Some(&resp.id)
+                                            == app.state.pending_gateway_health_id.as_ref()
+                                        {
                                             app.state.pending_gateway_health_id = None;
-                                            
+
                                             let is_healthy = healthy.as_bool().unwrap_or(false);
-                                            let latency = obj.get("latency").and_then(|v| v.as_u64()).unwrap_or(0);
-                                            let deps_ready = obj.get("ready").and_then(|v| v.as_bool());
+                                            let latency = obj
+                                                .get("latency")
+                                                .and_then(|v| v.as_u64())
+                                                .unwrap_or(0);
+                                            let deps_ready =
+                                                obj.get("ready").and_then(|v| v.as_bool());
 
                                             let mut db_summary: Option<String> = None;
-                                            if let Some(h) = obj.get("health").and_then(|v| v.as_object()) {
-                                                if let Some(fr) = h.get("fourRunrDb").and_then(|v| v.as_object()) {
+                                            if let Some(h) =
+                                                obj.get("health").and_then(|v| v.as_object())
+                                            {
+                                                if let Some(fr) =
+                                                    h.get("fourRunrDb").and_then(|v| v.as_object())
+                                                {
                                                     let mode = fr
                                                         .get("mode")
                                                         .and_then(|v| v.as_str())
@@ -689,15 +1173,20 @@ fn main() -> Result<()> {
                                                 app.state.gateway_healthy = false;
                                                 app.state.gateway_db_summary = None;
                                                 app.state.connection_portal.finish_connecting();
-                                                let error = obj.get("error").and_then(|v| v.as_str()).unwrap_or("Unknown error");
-                                                app.add_log(format!("⚠ [{}] Gateway health check failed: {} ({}ms)", short_id, error, latency));
+                                                let error = obj
+                                                    .get("error")
+                                                    .and_then(|v| v.as_str())
+                                                    .unwrap_or("Unknown error");
+                                                app.add_log(format!(
+                                                    "⚠ [{}] Gateway health check failed: {} ({}ms)",
+                                                    short_id, error, latency
+                                                ));
                                             }
-                                            
+
                                             // CRITICAL: Request render after health state change
                                             app.request_render("gateway_health_update");
                                         }
-                                    }
-                                    else {
+                                    } else {
                                         app.add_log(format!("✓ [{}] Success", short_id));
                                     }
                                 } else {
@@ -708,41 +1197,60 @@ fn main() -> Result<()> {
                             }
                         } else {
                             let short_id = &resp.id[resp.id.len().saturating_sub(8)..];
-                            let error_msg = resp.payload.error.unwrap_or_else(|| "Unknown error".to_string());
-                            
+                            let error_msg = resp
+                                .payload
+                                .error
+                                .unwrap_or_else(|| "Unknown error".to_string());
+
                             // Check if this is a response to agent.create command (Step 5.1)
                             if Some(&resp.id) == app.state.pending_agent_create_id.as_ref() {
                                 app.state.pending_agent_create_id = None;
-                                app.add_log(format!("✗ [{}] Agent creation failed: {}", short_id, error_msg));
+                                app.add_log(format!(
+                                    "✗ [{}] Agent creation failed: {}",
+                                    short_id, error_msg
+                                ));
                             }
                             // Check if this is a response to agent.delete command (Step 5.5)
                             else if Some(&resp.id) == app.state.pending_agent_delete_id.as_ref() {
                                 app.state.pending_agent_delete_id = None;
-                                app.add_log(format!("✗ [{}] Agent deletion failed: {}", short_id, error_msg));
-                            }
-                            else if Some(&resp.id) == app.state.pending_run_list_id.as_ref() {
+                                app.add_log(format!(
+                                    "✗ [{}] Agent deletion failed: {}",
+                                    short_id, error_msg
+                                ));
+                            } else if Some(&resp.id) == app.state.pending_run_list_id.as_ref() {
                                 app.state.pending_run_list_id = None;
                                 app.state.run_manager.loading = false;
-                                app.add_log(format!("✗ [{}] run.list failed: {}", short_id, error_msg));
-                            }
-                            else if Some(&resp.id) == app.state.pending_run_get_id.as_ref() {
+                                app.add_log(format!(
+                                    "✗ [{}] run.list failed: {}",
+                                    short_id, error_msg
+                                ));
+                            } else if Some(&resp.id) == app.state.pending_run_get_id.as_ref() {
                                 app.state.pending_run_get_id = None;
-                                app.add_log(format!("✗ [{}] run.get failed: {}", short_id, error_msg));
-                            }
-                            else if Some(&resp.id) == app.state.pending_run_cancel_id.as_ref() {
+                                app.add_log(format!(
+                                    "✗ [{}] run.get failed: {}",
+                                    short_id, error_msg
+                                ));
+                            } else if Some(&resp.id) == app.state.pending_run_cancel_id.as_ref() {
                                 app.state.pending_run_cancel_id = None;
-                                app.add_log(format!("✗ [{}] run.cancel failed: {}", short_id, error_msg));
-                            }
-                            else if Some(&resp.id) == app.state.pending_run_quick_id.as_ref() {
+                                app.add_log(format!(
+                                    "✗ [{}] run.cancel failed: {}",
+                                    short_id, error_msg
+                                ));
+                            } else if Some(&resp.id) == app.state.pending_run_quick_id.as_ref() {
                                 app.state.pending_run_quick_id = None;
-                                app.add_log(format!("✗ [{}] run.quick failed: {}", short_id, error_msg));
+                                app.add_log(format!(
+                                    "✗ [{}] run.quick failed: {}",
+                                    short_id, error_msg
+                                ));
                             }
                             // Check if this is a response to gateway.connect command (Step 7.5)
-                            else if Some(&resp.id) == app.state.pending_gateway_connect_id.as_ref() {
+                            else if Some(&resp.id)
+                                == app.state.pending_gateway_connect_id.as_ref()
+                            {
                                 app.state.pending_gateway_connect_id = None;
                                 app.state.connection_portal.finish_connecting();
                                 app.state.connection_portal.error = Some(error_msg.clone());
-                                
+
                                 // Parse activity log from error response if present
                                 if let Some(data_value) = &resp.payload.data {
                                     if let Some(obj) = data_value.as_object() {
@@ -751,18 +1259,21 @@ fn main() -> Result<()> {
                                                 app.state.connection_portal.activity_log.clear();
                                                 for entry in log_array {
                                                     if let Some(entry_obj) = entry.as_object() {
-                                                        let timestamp = entry_obj.get("timestamp")
+                                                        let timestamp = entry_obj
+                                                            .get("timestamp")
                                                             .and_then(|v| v.as_str())
                                                             .unwrap_or("")
                                                             .to_string();
-                                                        let level_str = entry_obj.get("level")
+                                                        let level_str = entry_obj
+                                                            .get("level")
                                                             .and_then(|v| v.as_str())
                                                             .unwrap_or("info");
-                                                        let message = entry_obj.get("message")
+                                                        let message = entry_obj
+                                                            .get("message")
                                                             .and_then(|v| v.as_str())
                                                             .unwrap_or("")
                                                             .to_string();
-                                                        
+
                                                         use crate::app::LogLevel;
                                                         let level = match level_str {
                                                             "success" => LogLevel::Success,
@@ -770,17 +1281,22 @@ fn main() -> Result<()> {
                                                             "error" => LogLevel::Error,
                                                             _ => LogLevel::Info,
                                                         };
-                                                        
-                                                        app.state.connection_portal.add_log_entry(timestamp, level, message);
+
+                                                        app.state.connection_portal.add_log_entry(
+                                                            timestamp, level, message,
+                                                        );
                                                     }
                                                 }
                                             }
                                         }
                                     }
                                 }
-                                
-                                app.add_log(format!("✗ [{}] Gateway connection failed: {}", short_id, error_msg));
-                                
+
+                                app.add_log(format!(
+                                    "✗ [{}] Gateway connection failed: {}",
+                                    short_id, error_msg
+                                ));
+
                                 // CRITICAL: Use immediate render for instant error display
                                 app.request_immediate_render("gateway_connect_error");
                             }
@@ -790,24 +1306,69 @@ fn main() -> Result<()> {
                                 app.state.setup_portal.detecting = false;
                                 app.state.setup_portal.detecting_since = None;
                                 app.state.setup_portal.error = Some(error_msg.clone());
-                                app.add_log(format!("✗ [{}] Setup detection failed: {}", short_id, error_msg));
+                                app.add_log(format!(
+                                    "✗ [{}] Setup detection failed: {}",
+                                    short_id, error_msg
+                                ));
                             }
                             // Phase 2.1: Check if this is a response to gateway.health command
-                            else if Some(&resp.id) == app.state.pending_gateway_health_id.as_ref() {
+                            else if Some(&resp.id) == app.state.pending_gateway_health_id.as_ref()
+                            {
                                 app.state.pending_gateway_health_id = None;
                                 app.state.gateway_healthy = false;
                                 app.state.gateway_db_summary = None;
-                                app.add_log(format!("⚠ [{}] Gateway health check failed: {}", short_id, error_msg));
-                                
+                                app.add_log(format!(
+                                    "⚠ [{}] Gateway health check failed: {}",
+                                    short_id, error_msg
+                                ));
+
                                 // CRITICAL: Request render after health state change
                                 app.request_render("gateway_health_error");
-                            }
-                            else if Some(&resp.id) == app.state.pending_gateway_observability_id.as_ref() {
+                            } else if Some(&resp.id)
+                                == app.state.pending_gateway_observability_id.as_ref()
+                            {
                                 app.state.pending_gateway_observability_id = None;
                                 app.state.portal_monitoring.loading = false;
                                 app.state.portal_observability_last_poll = Some(Instant::now());
                                 app.state.portal_monitoring.error = Some(error_msg.clone());
                                 app.request_render("portal_observability_err");
+                            } else if Some(&resp.id)
+                                == app.state.pending_monitoring_refresh_id.as_ref()
+                            {
+                                app.state.pending_monitoring_refresh_id = None;
+                                app.state.portal_monitoring.section_refresh_loading = None;
+                                app.state.portal_monitoring.error =
+                                    Some(format!("monitoring.refresh failed: {}", error_msg));
+                                app.add_log(format!(
+                                    "✗ [{}] monitoring.refresh failed: {}",
+                                    short_id, error_msg
+                                ));
+                                app.request_render("monitoring_refresh_err");
+                            } else if Some(&resp.id)
+                                == app.state.pending_monitoring_logs_id.as_ref()
+                            {
+                                app.state.pending_monitoring_logs_id = None;
+                                app.state.portal_monitoring.logs_fetch_loading = false;
+                                app.state.portal_monitoring.error =
+                                    Some(format!("monitoring.logs failed: {}", error_msg));
+                                app.add_log(format!(
+                                    "✗ [{}] monitoring.logs failed: {}",
+                                    short_id, error_msg
+                                ));
+                                app.request_render("monitoring_logs_err");
+                            } else if Some(&resp.id)
+                                == app.state.pending_monitoring_drill_id.as_ref()
+                            {
+                                app.state.pending_monitoring_drill_id = None;
+                                app.state.portal_monitoring.metrics_drill_loading = false;
+                                app.state.portal_monitoring.section_refresh_loading = None;
+                                app.state.portal_monitoring.error =
+                                    Some(format!("monitoring.drill failed: {}", error_msg));
+                                app.add_log(format!(
+                                    "✗ [{}] monitoring.drill failed: {}",
+                                    short_id, error_msg
+                                ));
+                                app.request_render("monitoring_drill_err");
                             }
                             // Generic error handling
                             else {
@@ -823,12 +1384,10 @@ fn main() -> Result<()> {
                                 } else {
                                     ""
                                 };
-                                
+
                                 app.add_log(format!(
                                     "✗ [{}]{} Error: {}",
-                                    short_id,
-                                    command_hint,
-                                    error_msg
+                                    short_id, command_hint, error_msg
                                 ));
                             }
                         }
@@ -856,6 +1415,9 @@ fn main() -> Result<()> {
                 if app.state.navigation.current_screen() == &Screen::PortalMonitoring
                     && app.state.operation_mode == OperationMode::Connected
                     && app.state.pending_gateway_observability_id.is_none()
+                    && app.state.pending_monitoring_refresh_id.is_none()
+                    && app.state.pending_monitoring_logs_id.is_none()
+                    && app.state.pending_monitoring_drill_id.is_none()
                 {
                     let interval = Duration::from_secs(5);
                     let due = app
@@ -869,7 +1431,7 @@ fn main() -> Result<()> {
                 }
             }
         }
-        
+
         // ┌─────────────────────────────────────────────────────────┐
         // │ STEP 3: RENDER (conditional - only when needed)         │
         // └─────────────────────────────────────────────────────────┘
@@ -892,24 +1454,28 @@ fn main() -> Result<()> {
                     | crate::screens::Screen::SetupPortal
                     | crate::screens::Screen::PortalMonitoring
             );
-            
+
             // Clear only on screen switch (but not when switching TO Setup Portal; we'll clear after autoresize)
             let is_switching = match (&previous_screen, &current_screen) {
                 (Some(prev), current) => prev != current,
                 (None, _) => true,
             };
-            let switching_to_setup_portal = is_switching && matches!(current_screen, crate::screens::Screen::SetupPortal);
+            let switching_to_setup_portal =
+                is_switching && matches!(current_screen, crate::screens::Screen::SetupPortal);
 
             if is_switching && !switching_to_setup_portal {
                 #[cfg(debug_assertions)]
-                eprintln!("[MAIN] SCREEN SWITCH: {:?} -> {:?} (clearing)", previous_screen, current_screen);
+                eprintln!(
+                    "[MAIN] SCREEN SWITCH: {:?} -> {:?} (clearing)",
+                    previous_screen, current_screen
+                );
                 debug_log::log_screen(
                     &format!("{:?}", previous_screen.as_ref().unwrap_or(&current_screen)),
                     &format!("{:?}", current_screen),
                 );
                 terminal.clear()?;
             }
-            
+
             // Connection + Setup portals: autoresize every frame (windowed CMD/conhost buffer vs viewport drift).
             // Clear on Setup entry (generic switch clear is skipped for Setup); clear when terminal dimensions
             // change while either portal is open. See docs/SETUP-PORTAL-WINDOWED-FIX-PLAN.md.
@@ -945,7 +1511,7 @@ fn main() -> Result<()> {
                     standalone_portal_last_terminal_dims = Some(dims);
                 }
             }
-            
+
             let render_start = Instant::now();
             terminal.draw(|f| app.render(f))?;
             let render_duration = render_start.elapsed().as_millis() as u64;
@@ -953,11 +1519,11 @@ fn main() -> Result<()> {
             if on_standalone_portal {
                 debug_log::log_flicker_debug("DRAW_DONE", &format!("ms={}", render_duration));
             }
-            
+
             // Update previous screen tracking
             previous_screen = Some(current_screen);
         }
-        
+
         // Setup Portal: if detection has been running too long, unstick so user can ESC or retry
         if app.state.navigation.current_screen() == &screens::Screen::SetupPortal
             && app.state.setup_portal.detecting
@@ -966,13 +1532,14 @@ fn main() -> Result<()> {
                 if since.elapsed() >= Duration::from_secs(8) {
                     app.state.setup_portal.detecting = false;
                     app.state.setup_portal.detecting_since = None;
-                    app.state.setup_portal.error = Some("Detection timed out. Press ESC to close or try again.".to_string());
+                    app.state.setup_portal.error =
+                        Some("Detection timed out. Press ESC to close or try again.".to_string());
                     app.add_log("[SETUP] Detection timed out".to_string());
                     app.request_immediate_render("setup_detect_timeout");
                 }
             }
         }
-        
+
         // ┌─────────────────────────────────────────────────────────┐
         // │ STEP 4: CHECK FOR INPUT (non-blocking with timeout)    │
         // └─────────────────────────────────────────────────────────┘
@@ -1033,25 +1600,20 @@ fn main() -> Result<()> {
             }
         }
         // If no input, loop continues immediately - animations keep running!
-        
+
         // Check for pending agent deletion (Step 5.5)
         if app.state.agent_delete_requested {
             app.state.agent_delete_requested = false;
             app.delete_selected_agent(&ws_client);
         }
-        
+
         // Check for IO updates (non-blocking)
         io_handler.update(&mut app).ok();
     }
 
     // Restore terminal
     disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(), 
-        cursor::Show,
-        LeaveAlternateScreen
-    )?;
+    execute!(terminal.backend_mut(), cursor::Show, LeaveAlternateScreen)?;
 
     Ok(())
 }
-