4runr-os 2.10.75 → 2.10.76

package/mk3-tui/src/app.rs

@@ -838,16 +838,16 @@ impl App {
     }
 
     pub fn open_shield_dashboard(&mut self, ws: Option<&WebSocketClient>) {
-        self.state.pending_shield_load_id = None;
         self.push_overlay(Screen::ShieldDashboard);
         self.state
             .logs
             .push_back("[NAV] Opening Shield (production safety layer)...".into());
         if self.state.operation_mode == OperationMode::Connected {
             if let Some(ws) = ws {
-                self.begin_shield_load_request(ws);
+                self.begin_shield_load_request(ws, false);
             }
         } else {
+            self.state.shield_dashboard.loading = false;
             self.state.shield_dashboard.error = Some(
                 "Connect to Gateway first (connect portal).".to_string(),
             );
@@ -855,20 +855,39 @@ impl App {
         self.request_immediate_render("open_shield_dashboard");
     }
 
-    pub fn begin_shield_load_request(&mut self, ws: &WebSocketClient) {
+    pub fn begin_shield_load_request(&mut self, ws: &WebSocketClient, force: bool) {
         if self.state.operation_mode != OperationMode::Connected {
             return;
         }
-        if self.state.pending_shield_load_id.is_some() {
+        if !force && self.state.pending_shield_load_id.is_some() {
             return;
         }
-        self.state.shield_dashboard.loading = true;
+        if force {
+            self.state.pending_shield_load_id = None;
+        }
+        self.state.shield_dashboard.mark_loading();
         self.state.shield_dashboard.error = None;
         if let Ok(id) = ws.send_command("shield.load", None) {
             self.state.pending_shield_load_id = Some(id);
         } else {
-            self.state.shield_dashboard.loading = false;
+            self.state.shield_dashboard.fail_loading(
+                "Failed to send shield.load to CLI.".to_string(),
+            );
+        }
+    }
+
+    pub fn open_run_from_shield_block(&mut self, ws: Option<&WebSocketClient>, run_id: &str) {
+        self.push_overlay(Screen::RunManager);
+        self.state.run_manager.detail_run_id = Some(run_id.to_string());
+        self.add_log(format!(
+            "[SHIELD] Opening blocked run {} in Run Manager",
+            &run_id[run_id.len().saturating_sub(8)..]
+        ));
+        if let Some(ws) = ws {
+            self.begin_run_list_request(ws, false);
+            self.begin_run_get_request(ws, run_id);
         }
+        self.request_immediate_render("shield_open_run");
     }
 
     pub fn open_sentinel_config(&mut self, ws: Option<&WebSocketClient>) {
@@ -2652,6 +2671,7 @@ impl App {
         key: KeyEvent,
         ws_client: Option<&WebSocketClient>,
     ) -> anyhow::Result<bool> {
+        use crate::ui::shield_dashboard::ShieldTab;
         use crossterm::event::KeyModifiers;
 
         if key.modifiers.contains(KeyModifiers::CONTROL) {
@@ -2662,14 +2682,84 @@ impl App {
         }
 
         match key.code {
+            KeyCode::Tab => {
+                self.state.shield_dashboard.tab = self.state.shield_dashboard.tab.next();
+                self.request_render("shield_tab");
+            }
+            KeyCode::BackTab => {
+                self.state.shield_dashboard.tab = self.state.shield_dashboard.tab.prev();
+                self.request_render("shield_tab_back");
+            }
+            KeyCode::Left => {
+                self.state.shield_dashboard.tab = self.state.shield_dashboard.tab.prev();
+                self.request_render("shield_tab_left");
+            }
+            KeyCode::Right => {
+                self.state.shield_dashboard.tab = self.state.shield_dashboard.tab.next();
+                self.request_render("shield_tab_right");
+            }
+            KeyCode::Up => {
+                if self.state.shield_dashboard.tab == ShieldTab::Enforcement
+                    && self.state.shield_dashboard.selected_block_index > 0
+                {
+                    self.state.shield_dashboard.selected_block_index -= 1;
+                    self.request_render("shield_block_up");
+                }
+            }
+            KeyCode::Down => {
+                if self.state.shield_dashboard.tab == ShieldTab::Enforcement {
+                    let max = self.state.shield_dashboard.recent_blocks.len();
+                    if max > 0 && self.state.shield_dashboard.selected_block_index + 1 < max {
+                        self.state.shield_dashboard.selected_block_index += 1;
+                        self.request_render("shield_block_down");
+                    }
+                }
+            }
+            KeyCode::Enter => {
+                if self.state.shield_dashboard.tab == ShieldTab::Enforcement {
+                    if let Some(row) = self
+                        .state
+                        .shield_dashboard
+                        .recent_blocks
+                        .get(self.state.shield_dashboard.selected_block_index)
+                    {
+                        let run_id = row.id.clone();
+                        self.open_run_from_shield_block(ws_client, &run_id);
+                    }
+                }
+            }
             KeyCode::Char('r') | KeyCode::Char('R') => {
                 if self.state.operation_mode == OperationMode::Connected {
                     if let Some(ws) = ws_client {
-                        self.begin_shield_load_request(ws);
+                        self.begin_shield_load_request(ws, true);
                     }
+                } else {
+                    self.state.shield_dashboard.fail_loading(
+                        "Connect to Gateway first (connect portal).".to_string(),
+                    );
                 }
                 self.request_render("shield_refresh");
             }
+            KeyCode::Char('o') | KeyCode::Char('O') => {
+                self.push_overlay(Screen::RunManager);
+                if let Some(ws) = ws_client {
+                    self.begin_run_list_request(ws, false);
+                }
+                self.add_log("[SHIELD] Opened Run Manager".to_string());
+                self.request_render("shield_open_runs");
+            }
+            KeyCode::Char('p') | KeyCode::Char('P') => {
+                if self.state.operation_mode == OperationMode::Connected {
+                    self.state.navigation.navigate_to_base(Screen::PortalMonitoring);
+                    if let Some(ws) = ws_client {
+                        self.begin_portal_observability_request(ws);
+                    }
+                    self.add_log("[SHIELD] Opened Portal Monitoring".to_string());
+                } else {
+                    self.add_log("[SHIELD] Connect to Gateway first.".to_string());
+                }
+                self.request_render("shield_open_monitoring");
+            }
             KeyCode::Char('a') | KeyCode::Char('A') => {
                 self.state.shield_dashboard.auto_refresh_enabled =
                     !self.state.shield_dashboard.auto_refresh_enabled;

package/mk3-tui/src/main.rs

@@ -205,9 +205,26 @@ fn main() -> Result<()> {
             };
             if shield_poll {
                 if let Some(ws) = &ws_client {
-                    app.begin_shield_load_request(ws);
+                    app.begin_shield_load_request(ws, false);
                 }
             }
+
+            // Loading timeout — never spin forever if CLI deduped or dropped a response
+            let loading_stuck = {
+                let sd = &app.state.shield_dashboard;
+                sd.loading
+                    && sd
+                        .loading_started
+                        .map(|t| t.elapsed() >= std::time::Duration::from_secs(12))
+                        .unwrap_or(false)
+            };
+            if loading_stuck {
+                app.state.shield_dashboard.fail_loading(
+                    "Shield load timed out — press R to refresh.".to_string(),
+                );
+                app.state.pending_shield_load_id = None;
+                app.request_render("shield_load_timeout");
+            }
         }
 
         // Run Manager: live poll run.list every ~3s when enabled (no manual R)
@@ -1625,8 +1642,9 @@ fn main() -> Result<()> {
                                 ));
                             } else if Some(&resp.id) == app.state.pending_shield_load_id.as_ref() {
                                 app.state.pending_shield_load_id = None;
-                                app.state.shield_dashboard.loading = false;
-                                app.state.shield_dashboard.error = Some(error_msg.clone());
+                                app.state
+                                    .shield_dashboard
+                                    .fail_loading(error_msg.clone());
                                 app.add_log(format!(
                                     "✗ [{}] shield.load failed: {}",
                                     short_id, error_msg

package/mk3-tui/src/ui/shield_dashboard.rs

@@ -34,8 +34,44 @@ pub struct ShieldBlockRow {
     pub created_at: String,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ShieldTab {
+    Overview,
+    Enforcement,
+    Help,
+}
+
+impl ShieldTab {
+    pub fn label(self) -> &'static str {
+        match self {
+            ShieldTab::Overview => "Overview",
+            ShieldTab::Enforcement => "Enforcement",
+            ShieldTab::Help => "Help",
+        }
+    }
+
+    pub fn next(self) -> Self {
+        match self {
+            ShieldTab::Overview => ShieldTab::Enforcement,
+            ShieldTab::Enforcement => ShieldTab::Help,
+            ShieldTab::Help => ShieldTab::Overview,
+        }
+    }
+
+    pub fn prev(self) -> Self {
+        match self {
+            ShieldTab::Overview => ShieldTab::Help,
+            ShieldTab::Enforcement => ShieldTab::Overview,
+            ShieldTab::Help => ShieldTab::Enforcement,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ShieldDashboardState {
+    pub tab: ShieldTab,
+    pub selected_block_index: usize,
+    pub loaded_once: bool,
     pub enabled: bool,
     pub mode: String,
     pub health_status: String,
@@ -51,6 +87,7 @@ pub struct ShieldDashboardState {
     pub warnings: Vec<String>,
     pub recent_blocks: Vec<ShieldBlockRow>,
     pub loading: bool,
+    pub loading_started: Option<std::time::Instant>,
     pub error: Option<String>,
     pub last_refresh: Option<std::time::Instant>,
     pub auto_refresh_enabled: bool,
@@ -60,6 +97,9 @@ pub struct ShieldDashboardState {
 impl Default for ShieldDashboardState {
     fn default() -> Self {
         Self {
+            tab: ShieldTab::Overview,
+            selected_block_index: 0,
+            loaded_once: false,
             enabled: false,
             mode: "off".to_string(),
             health_status: String::new(),
@@ -75,6 +115,7 @@ impl Default for ShieldDashboardState {
             warnings: Vec::new(),
             recent_blocks: Vec::new(),
             loading: false,
+            loading_started: None,
             error: None,
             last_refresh: None,
             auto_refresh_enabled: true,
@@ -94,7 +135,9 @@ impl ShieldDashboardState {
         recent: Vec<ShieldBlockRow>,
     ) {
         self.loading = false;
+        self.loading_started = None;
         self.error = None;
+        self.loaded_once = true;
         self.enabled = health.enabled;
         self.mode = health.mode.clone();
         self.health_status = health.status.clone();
@@ -109,8 +152,24 @@ impl ShieldDashboardState {
         self.rewrites_total = metrics.rewrites;
         self.warnings = warnings;
         self.recent_blocks = recent;
+        if self.selected_block_index >= self.recent_blocks.len() {
+            self.selected_block_index = 0;
+        }
         self.last_refresh = Some(std::time::Instant::now());
     }
+
+    pub fn mark_loading(&mut self) {
+        self.loading = true;
+        if self.loading_started.is_none() {
+            self.loading_started = Some(std::time::Instant::now());
+        }
+    }
+
+    pub fn fail_loading(&mut self, message: String) {
+        self.loading = false;
+        self.loading_started = None;
+        self.error = Some(message);
+    }
 }
 
 #[derive(Debug, Clone, Default)]
@@ -315,21 +374,31 @@ pub fn render(f: &mut Frame, state: &AppState) {
 
     use ratatui::layout::{Constraint, Direction, Layout};
 
+    let refresh_hint = if sd.loading {
+        " ↻"
+    } else {
+        ""
+    };
     let live = if sd.auto_refresh_enabled { " · LIVE" } else { "" };
     let header_title = format!(
-        " 🛡️  Shield — {} · {} block(s) · {} mask(s){} ",
-        sd.mode.to_uppercase(),
+        " 🛡️  Shield — {} · {} block(s) · {} mask(s){}{} ",
+        if sd.loaded_once {
+            sd.mode.to_uppercase()
+        } else {
+            "…".to_string()
+        },
         sd.blocks_total,
         sd.masks_total,
-        live
+        live,
+        refresh_hint
     );
 
     let chunks = Layout::default()
         .direction(Direction::Vertical)
         .constraints([
             Constraint::Length(3),
-            Constraint::Min(10),
-            Constraint::Length(8),
+            Constraint::Length(3),
+            Constraint::Min(8),
             Constraint::Length(3),
         ])
         .split(area);
@@ -341,22 +410,53 @@ pub fn render(f: &mut Frame, state: &AppState) {
         .style(Style::default().bg(BG_PANEL));
     f.render_widget(header, chunks[0]);
 
-    let mid = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-        .split(chunks[1]);
-
-    render_status_panel(f, mid[0], sd);
-    render_metrics_panel(f, mid[1], sd);
-    render_enforcement_panel(f, chunks[2], sd);
+    render_tab_bar(f, chunks[1], sd);
+
+    if !sd.loaded_once && sd.loading {
+        let block = Block::default()
+            .title(" Loading ")
+            .borders(Borders::ALL)
+            .border_style(Style::default().fg(CYBER_CYAN));
+        let inner = block.inner(chunks[2]);
+        f.render_widget(block, chunks[2]);
+        f.render_widget(
+            Paragraph::new(vec![
+                Line::from(""),
+                Line::from("Fetching Shield health, config, metrics, and run history…")
+                    .style(Style::default().fg(TEXT_PRIMARY)),
+                Line::from(""),
+                Line::from("Press R to retry if this takes more than a few seconds.")
+                    .style(Style::default().fg(TEXT_DIM)),
+            ])
+            .alignment(Alignment::Center),
+            inner,
+        );
+    } else {
+        match sd.tab {
+            ShieldTab::Overview => {
+                let mid = Layout::default()
+                    .direction(Direction::Horizontal)
+                    .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
+                    .split(chunks[2]);
+                render_status_panel(f, mid[0], sd);
+                render_metrics_panel(f, mid[1], sd);
+            }
+            ShieldTab::Enforcement => render_enforcement_panel(f, chunks[2], sd),
+            ShieldTab::Help => render_help_panel(f, chunks[2], sd),
+        }
+    }
 
-    let footer_msg = if sd.loading {
-        "Loading live Shield state from Gateway…".to_string()
-    } else if let Some(e) = &sd.error {
-        e.clone()
+    let status_line = if let Some(e) = &sd.error {
+        format!("⚠ {}  |  ", e)
+    } else if sd.loading {
+        "Refreshing…  |  ".to_string()
     } else {
-        "R Refresh · A Live toggle · ESC Close".to_string()
+        String::new()
     };
+    let footer_msg = format!(
+        "{}Tab/←→ Switch view · ↑↓ Select block · Enter Open run · R Refresh · O Runs · P Monitoring · A Live · ESC Close",
+        status_line
+    );
     let footer_color = if sd.error.is_some() {
         Color::Rgb(255, 69, 69)
     } else {
@@ -376,6 +476,68 @@ pub fn render(f: &mut Frame, state: &AppState) {
     );
 }
 
+fn render_tab_bar(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
+    let tabs = [ShieldTab::Overview, ShieldTab::Enforcement, ShieldTab::Help];
+    let spans: Vec<Span> = tabs
+        .iter()
+        .flat_map(|tab| {
+            let active = *tab == sd.tab;
+            [
+                Span::styled(
+                    format!(" {} ", tab.label()),
+                    Style::default()
+                        .fg(if active { SHIELD_ORANGE } else { TEXT_DIM })
+                        .add_modifier(if active {
+                            Modifier::BOLD
+                        } else {
+                            Modifier::empty()
+                        }),
+                ),
+                Span::raw("│"),
+            ]
+        })
+        .collect();
+    let block = Block::default()
+        .borders(Borders::LEFT | Borders::RIGHT)
+        .border_style(Style::default().fg(TEXT_MUTED));
+    f.render_widget(
+        Paragraph::new(Line::from(spans)).alignment(Alignment::Center),
+        block.inner(area),
+    );
+    f.render_widget(block, area);
+}
+
+fn render_help_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
+    let block = Block::default()
+        .title(" How Shield works in production ")
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(BRAND_PURPLE))
+        .style(Style::default().bg(BG_PANEL));
+    let inner = block.inner(area);
+    f.render_widget(block, area);
+
+    let mut lines: Vec<Line> = ABOUT_SHIELD
+        .iter()
+        .map(|l| Line::from(*l).style(Style::default().fg(TEXT_PRIMARY)))
+        .collect();
+    lines.push(Line::from(""));
+    lines.push(
+        Line::from("Navigation from this screen:")
+            .style(Style::default().fg(NEON_GREEN).bold()),
+    );
+    lines.push(Line::from("  O — open Run Manager (all runs, SHIELD badge on blocks)"));
+    lines.push(Line::from("  P — open Portal Monitoring (Prometheus Shield counters)"));
+    lines.push(Line::from("  Enforcement tab → Enter on a row opens that blocked run"));
+    if !sd.warnings.is_empty() {
+        lines.push(Line::from(""));
+        lines.push(Line::from("Active warnings:").style(Style::default().fg(AMBER_WARN).bold()));
+        for w in &sd.warnings {
+            lines.push(Line::from(format!("  ⚠ {}", w)).style(Style::default().fg(AMBER_WARN)));
+        }
+    }
+    f.render_widget(Paragraph::new(lines).wrap(Wrap { trim: false }), inner);
+}
+
 fn render_status_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
     let block = Block::default()
         .title(" Status & detectors ")
@@ -495,7 +657,7 @@ fn metric_line(label: &str, value: u64, color: Color) -> Line<'static> {
 fn render_enforcement_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState) {
     let block = Block::default()
         .title(format!(
-            " Recent enforcement ({} blocked run(s) in history) ",
+            " Blocked runs ({}) — ↑↓ select · Enter open in Run Manager ",
             sd.recent_blocks.len()
         ))
         .borders(Borders::ALL)
@@ -508,23 +670,31 @@ fn render_enforcement_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState
         let empty = vec![
             Line::from(""),
             Line::from("No blocked runs in Gateway history yet.").style(Style::default().fg(TEXT_DIM)),
-            Line::from("Shield is active on every run — blocks appear here when production").style(Style::default().fg(TEXT_MUTED)),
-            Line::from("traffic triggers injection/PII policy (failed status + SHIELD in Run Manager).").style(Style::default().fg(TEXT_MUTED)),
+            Line::from(""),
+            Line::from("Shield still evaluates every agent/API run on input.").style(Style::default().fg(TEXT_MUTED)),
+            Line::from("Press O to open Run Manager · P for live Prometheus metrics.").style(Style::default().fg(NEON_GREEN)),
         ];
-        f.render_widget(Paragraph::new(empty), inner);
+        f.render_widget(Paragraph::new(empty).alignment(Alignment::Center), inner);
         return;
     }
 
     let items: Vec<ListItem> = sd
         .recent_blocks
         .iter()
-        .map(|r| {
+        .enumerate()
+        .map(|(idx, r)| {
             let short_id = if r.id.len() > 8 {
                 &r.id[r.id.len() - 8..]
             } else {
                 &r.id
             };
+            let prefix = if idx == sd.selected_block_index {
+                "▶ "
+            } else {
+                "  "
+            };
             ListItem::new(Line::from(vec![
+                Span::styled(prefix, Style::default().fg(SHIELD_ORANGE).bold()),
                 Span::styled(
                     format!("{} ", r.created_at),
                     Style::default().fg(TEXT_MUTED),
@@ -535,7 +705,11 @@ fn render_enforcement_panel(f: &mut Frame, area: Rect, sd: &ShieldDashboardState
                 ),
                 Span::styled(
                     format!("{} — ", r.name),
-                    Style::default().fg(TEXT_PRIMARY),
+                    Style::default().fg(if idx == sd.selected_block_index {
+                        CYBER_CYAN
+                    } else {
+                        TEXT_PRIMARY
+                    }),
                 ),
                 Span::styled(
                     r.reason.chars().take(48).collect::<String>(),

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "4runr-os",
-  "version": "2.10.75",
+  "version": "2.10.76",
   "type": "module",
-  "description": "4Runr AI Agent OS - Secure terminal interface for AI agents. v2.10.75: Dedicated Shield dashboard (shield command) — live metrics, detectors, enforcement history.",
+  "description": "4Runr AI Agent OS - Secure terminal interface for AI agents. v2.10.76: Shield dashboard usable — fix shield.load dedupe hang, tabs, shortcuts, enforcement drill-down.",
   "main": "dist/index.js",
   "bin": {
     "4runr": "dist/index.js",