feat(tui): add skills and MCP server count indicator in status bar

Rework per review on #399, rebased on the app/ module split:
- discovery no longer runs inside App::new: the count is computed on a
  spawn_blocking background task (discover_skills can shell out to git
  clone via skills.urls) and drained through a one-shot channel,
  mirroring recent_sessions_pending
- mcp count reads McpManager::server_count() (connected servers), set
  by the CLI at startup and on every reconnect, not the configured list
- footer emits only the non-zero halves: 3 skills / 2 mcp instead of
  '3 skills 0 mcp'
- comment indentation fixed

Author: alecuba16

src-rust/crates/cli/src/main.rs

@@ -1874,6 +1874,13 @@ async fn run_interactive(
     // Set up terminal
     let mut terminal = setup_terminal(live_config.mouse_capture_enabled())?;
     let mut app = App::new(live_config.clone(), cost_tracker.clone());
+    // Status-bar indicator tracks *connected* servers, not the configured
+    // list (a server that fails to handshake is configured but not connected).
+    app.mcp_server_count = tool_ctx
+        .mcp_manager
+        .as_ref()
+        .map(|manager| manager.server_count())
+        .unwrap_or(0);
     if let Some(error) = settings_load_error {
         app.invalid_config_dialog =
             claurst_tui::InvalidConfigDialogState::show_settings_error(&error);
@@ -4194,6 +4201,11 @@ async fn run_interactive(
             let new_mcp_manager = connect_mcp_manager_arc(&decision.allowed).await;
             tool_ctx.mcp_manager = new_mcp_manager.clone();
             app.mcp_manager = new_mcp_manager.clone();
+            // Keep the status-bar indicator in sync with the live count.
+            app.mcp_server_count = new_mcp_manager
+                .as_ref()
+                .map(|manager| manager.server_count())
+                .unwrap_or(0);
             tools_arc = build_tools_with_mcp(new_mcp_manager.clone());
             if app.mcp_view.visible {
                 app.refresh_mcp_view();

src-rust/crates/tui/src/app/mod.rs

@@ -246,6 +246,19 @@ pub struct App {
     pub remote_session_url: Option<String>,
     /// Live MCP manager snapshot source when available.
     pub mcp_manager: Option<Arc<claurst_mcp::McpManager>>,
+    /// Number of connected MCP servers for the status-bar indicator. Updated
+    /// by the caller (CLI) at startup and on every MCP reconnect so it tracks
+    /// `McpManager::server_count()`, not just the configured list.
+    pub mcp_server_count: usize,
+    /// Number of discovered skills for the status-bar indicator. Populated
+    /// once in the background from the skill loader (discovery can shell out
+    /// to `git clone`, so it must not run inside `App::new`).
+    pub skill_count: usize,
+    /// When `true`, the main event loop should spawn a one-shot background
+    /// task to discover skills and report the count.
+    pub skill_count_pending: bool,
+    /// Receiver for the background skill-count discovery.
+    pub skill_count_rx: Option<tokio::sync::mpsc::Receiver<usize>>,
     /// Queued request for a real MCP reconnect from the interactive loop.
     pub pending_mcp_reconnect: bool,
     /// Set after an in-session provider connection (e.g. a Claude Pro/Max OAuth
@@ -647,6 +660,12 @@ impl App {
             session_title: None,
             remote_session_url: None,
             mcp_manager: None,
+            mcp_server_count: 0,
+            skill_count: 0,
+            // Discover skills once, lazily, on the first run-loop iteration
+            // (never inside the constructor — see the field docs).
+            skill_count_pending: true,
+            skill_count_rx: None,
             pending_mcp_reconnect: false,
             pending_provider_reload: false,
             pending_mcp_panel_auth: None,

src-rust/crates/tui/src/app/run.rs

@@ -393,6 +393,39 @@ impl App {
                 });
             }
 
+            // Drain the one-shot skill-count discovery into the status-bar
+            // indicator. Discovery runs on a background task because it can
+            // shell out to `git clone` for `skills.urls` entries.
+            if let Some(ref mut rx) = self.skill_count_rx {
+                match rx.try_recv() {
+                    Ok(count) => {
+                        self.skill_count = count;
+                        self.skill_count_rx = None;
+                    }
+                    Err(tokio::sync::mpsc::error::TryRecvError::Disconnected) => {
+                        self.skill_count_rx = None;
+                    }
+                    Err(tokio::sync::mpsc::error::TryRecvError::Empty) => {}
+                }
+            }
+
+            // Spawn the one-shot skill discovery when requested (startup).
+            if self.skill_count_pending {
+                self.skill_count_pending = false;
+                let root = self.project_root();
+                let skills_config = self.config.skills.clone();
+                let (tx, rx) = tokio::sync::mpsc::channel(1);
+                self.skill_count_rx = Some(rx);
+                tokio::spawn(async move {
+                    let count = tokio::task::spawn_blocking(move || {
+                        claurst_core::discover_skills(&root, &skills_config).len()
+                    })
+                    .await
+                    .unwrap_or(0);
+                    let _ = tx.send(count).await;
+                });
+            }
+
             // Drain voice transcription events (non-blocking).
             // When the background recording/transcription task emits a
             // TranscriptReady event we insert the text directly into the

src-rust/crates/tui/src/render.rs

@@ -2677,6 +2677,36 @@ fn render_footer(frame: &mut Frame, app: &App, area: Rect) {
             ));
         }
 
+        // 3c. Skills + MCP count indicator: emit only the non-zero
+        // halves so a user with skills but no MCP servers sees
+        // "3 skills" rather than "3 skills + 0 mcp".
+        if app.skill_count > 0 || app.mcp_server_count > 0 {
+            let mut label = String::new();
+            if app.skill_count > 0 {
+                label.push_str(&format!(
+                    "{} skill{}",
+                    app.skill_count,
+                    if app.skill_count == 1 { "" } else { "s" }
+                ));
+            }
+            if app.mcp_server_count > 0 {
+                if !label.is_empty() {
+                    label.push_str(" \u{00b7} ");
+                }
+                label.push_str(&format!(
+                    "{} mcp",
+                    app.mcp_server_count
+                ));
+            }
+            if !parts.is_empty() {
+                parts.push(Span::raw("  "));
+            }
+            parts.push(Span::styled(
+                label,
+                Style::default().fg(Color::DarkGray),
+            ));
+        }
+
         // 4. Rate limits
         if let Some(pct) = app.rate_limit_5h_pct {
             if pct > 0.0 {