feat(gateway): push tools/list_changed when Tool Optimization switch toggles

The mcpmux_* (Tool Optimization) master switch is appended to every session
regardless of space, but flipping it previously took effect only on a client's
next list_tools. Add DomainEvent::MetaToolsEnabledChanged, emit it from
set_meta_tools_enabled, and have MCPNotifier fan out tools/list_changed to every
connected session (global, cross-space) so the mcpmux_* namespace appears /
disappears immediately. Also forwarded to the desktop UI as `meta-tools-changed`.

Signed-off-by: Mohammod Al Amin Ashik <maa.ashik00@gmail.com>

Author: its-mash

apps/desktop/src-tauri/src/commands/gateway.rs

@@ -699,6 +699,15 @@ fn map_domain_event_to_ui(event: &DomainEvent) -> (&'static str, serde_json::Val
                 "space_id": space_id,
             }),
         ),
+
+        // The global Tool Optimization (mcpmux_*) master switch flipped. The
+        // gateway-side MCPNotifier handles the `tools/list_changed` push to
+        // connected MCP clients; this forwards the new value to the desktop UI
+        // so any open Built-in Servers / Settings view reflects it live.
+        DomainEvent::MetaToolsEnabledChanged { enabled } => (
+            "meta-tools-changed",
+            serde_json::json!({ "enabled": enabled }),
+        ),
     }
 }
 

apps/desktop/src-tauri/src/commands/settings.rs

@@ -1,10 +1,15 @@
 //! Settings commands for auto-start and system tray behavior
 
+use std::sync::Arc;
+
+use mcpmux_core::DomainEvent;
 use serde::{Deserialize, Serialize};
 use tauri::State;
 use tauri_plugin_autostart::AutoLaunchManager;
+use tokio::sync::RwLock;
 use tracing::{debug, info};
 
+use super::gateway::GatewayAppState;
 use crate::state::AppState;
 
 /// Startup and system tray settings
@@ -152,6 +157,7 @@ pub async fn get_meta_tools_enabled(app_state: State<'_, AppState>) -> Result<bo
 pub async fn set_meta_tools_enabled(
     enabled: bool,
     app_state: State<'_, AppState>,
+    gateway_state: State<'_, Arc<RwLock<GatewayAppState>>>,
 ) -> Result<(), String> {
     app_state
         .settings_repository
@@ -162,6 +168,20 @@ pub async fn set_meta_tools_enabled(
         .await
         .map_err(|e| format!("Failed to save meta_tools_enabled: {}", e))?;
     info!("[Settings] meta_tools_enabled = {}", enabled);
+
+    // Push tools/list_changed to every connected session so the mcpmux_*
+    // namespace appears / disappears immediately instead of on their next
+    // list_tools. Best-effort: the gateway not running (no subscribers) is a
+    // normal condition and must not fail the toggle.
+    {
+        let gw_state = gateway_state.read().await;
+        if let Some(ref gw) = gw_state.gateway_state {
+            gw.read()
+                .await
+                .emit_domain_event(DomainEvent::MetaToolsEnabledChanged { enabled });
+        }
+    }
+
     Ok(())
 }
 

crates/mcpmux-core/src/domain/event.rs

@@ -395,6 +395,16 @@ pub enum DomainEvent {
         /// Redacted summary of the payload the LLM supplied (no secrets).
         summary: String,
     },
+
+    // ════════════════════════════════════════════════════════════════════════
+    // BUILT-IN SERVERS
+    // ════════════════════════════════════════════════════════════════════════
+    /// The global "Tool Optimization" (self-management `mcpmux_*`) master
+    /// switch was toggled. The meta-tools are appended to *every* session's
+    /// `tools/list` regardless of space, so flipping this changes what every
+    /// connected client sees — the notifier re-pushes `tools/list_changed`
+    /// to all sessions rather than scoping to one space.
+    MetaToolsEnabledChanged { enabled: bool },
 }
 
 // ============================================================================
@@ -435,6 +445,7 @@ impl DomainEvent {
             Self::WorkspaceNeedsBinding { .. } => "workspace_needs_binding",
             Self::SessionRootsChanged => "session_roots_changed",
             Self::MetaToolInvoked { .. } => "meta_tool_invoked",
+            Self::MetaToolsEnabledChanged { .. } => "meta_tools_enabled_changed",
         }
     }
 
@@ -462,6 +473,9 @@ impl DomainEvent {
             | Self::ResourcesChanged { .. } => true,
             // Binding changes reshuffle every peer's resolution in the space
             Self::WorkspaceBindingChanged { .. } => true,
+            // The meta-tools master switch adds/removes the mcpmux_* namespace
+            // from every session's tool list.
+            Self::MetaToolsEnabledChanged { .. } => true,
             // WorkspaceNeedsBinding is a UI prompt — doesn't itself change what
             // tools a client sees, just invites the user to configure.
             // All other events don't affect MCP capabilities
@@ -502,7 +516,8 @@ impl DomainEvent {
             | Self::GatewayStarted { .. }
             | Self::GatewayStopped
             | Self::SessionRootsChanged
-            | Self::MetaToolInvoked { .. } => None,
+            | Self::MetaToolInvoked { .. }
+            | Self::MetaToolsEnabledChanged { .. } => None,
         }
     }
 

crates/mcpmux-gateway/src/consumers/mcp_notifier.rs

@@ -458,6 +458,19 @@ impl MCPNotifier {
                 self.notify_all_list_changed(space_id, true).await;
             }
 
+            // The global meta-tools master switch flipped. The mcpmux_* tools
+            // are appended to every session regardless of space, so a per-space
+            // fanout would miss sessions in other spaces. Push tools/list_changed
+            // to every session so each refetches and the namespace appears /
+            // disappears immediately instead of on its next list_tools.
+            DomainEvent::MetaToolsEnabledChanged { enabled } => {
+                info!(
+                    enabled,
+                    "[MCPNotifier] 📨 MetaToolsEnabledChanged - notifying ALL sessions (tools/list_changed)"
+                );
+                self.notify_all_sessions_tools_changed().await;
+            }
+
             // ============ Backend Server Notifications (Pass-through with Throttling) ============
             // IMPORTANT: These events come from backend MCP servers. Some servers are "chatty" and
             // emit list_changed when queried (not just when features actually change). Our throttling
@@ -725,6 +738,52 @@ impl MCPNotifier {
         }
     }
 
+    /// Push `tools/list_changed` to EVERY session with an active stream,
+    /// regardless of space. Used for global, cross-space changes (the
+    /// meta-tools master switch) that alter every session's tool list.
+    ///
+    /// Deliberately bypasses the per-space content hash + throttle: those are
+    /// keyed by space-feature content and have no visibility into the
+    /// `mcpmux_*` namespace, so they'd wrongly dedupe this away. The trigger
+    /// is a rare, explicit user action, so unconditional fanout is safe.
+    async fn notify_all_sessions_tools_changed(&self) {
+        if DISABLE_ALL_NOTIFICATIONS {
+            trace!("[MCPNotifier] 🚫 NOTIFICATIONS DISABLED - skipping global tools/list_changed");
+            return;
+        }
+
+        let targets: Vec<(String, String, Arc<Peer<RoleServer>>)> = {
+            let sessions = self.sessions.read();
+            sessions
+                .iter()
+                .filter(|(_, e)| e.has_active_stream)
+                .map(|(sid, e)| (sid.clone(), e.client_id.clone(), e.peer.clone()))
+                .collect()
+        };
+
+        if targets.is_empty() {
+            debug!("[MCPNotifier] No sessions with active streams for global tools/list_changed");
+            return;
+        }
+
+        info!(
+            session_count = targets.len(),
+            "[MCPNotifier] 📤 Sending tools/list_changed to all {} session(s)",
+            targets.len()
+        );
+
+        for (session_id, client_id, peer) in targets {
+            if let Err(e) = peer.notify_tool_list_changed().await {
+                warn!(
+                    %session_id,
+                    %client_id,
+                    error = ?e,
+                    "[MCPNotifier] Failed to send global tools/list_changed to session"
+                );
+            }
+        }
+    }
+
     /// Internal method to actually send tools/list_changed notification (no throttling)
     async fn send_tools_list_changed(&self, space_id: Uuid, _timestamp: Instant) {
         // DEBUG: Kill switch to disable all notifications