feat(meta-tools): add session-scope enable/disable server tools (Phase 3)

mcpmux_enable_server and mcpmux_disable_server mutate SessionOverrideRegistry,
audit as session_override when auto-allowed, and notify the calling session.

Signed-off-by: crimsonsunset <jsangio1@gmail.com>

Author: crimsonsunset

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

@@ -1064,45 +1064,100 @@ impl MCPNotifier {
         );
 
         for (session_id, peer) in &live {
-            match peer.notify_tool_list_changed().await {
-                Ok(_) => debug!(
-                    %session_id,
-                    %client_id,
-                    "[MCPNotifier] ✅ Sent tools/list_changed to session (per-client)"
-                ),
-                Err(e) => warn!(
-                    %session_id,
-                    %client_id,
-                    error = ?e,
-                    "[MCPNotifier] failed tools/list_changed"
-                ),
-            }
-            match peer.notify_prompt_list_changed().await {
-                Ok(_) => debug!(
-                    %session_id,
-                    %client_id,
-                    "[MCPNotifier] ✅ Sent prompts/list_changed to session (per-client)"
-                ),
-                Err(e) => warn!(
-                    %session_id,
-                    %client_id,
-                    error = ?e,
-                    "[MCPNotifier] failed prompts/list_changed"
-                ),
-            }
-            match peer.notify_resource_list_changed().await {
-                Ok(_) => debug!(
-                    %session_id,
-                    %client_id,
-                    "[MCPNotifier] ✅ Sent resources/list_changed to session (per-client)"
-                ),
-                Err(e) => warn!(
-                    %session_id,
-                    %client_id,
-                    error = ?e,
-                    "[MCPNotifier] failed resources/list_changed"
-                ),
-            }
+            self.send_all_lists_changed_to_peer(session_id, client_id, peer)
+                .await;
+        }
+    }
+
+    /// Send all three list_changed notifications to one session, bypassing
+    /// space-level hash dedup. Used after session-scoped override mutations
+    /// so only the calling session refreshes its tool list.
+    pub async fn notify_session_lists_changed(&self, session_id: &str) {
+        if DISABLE_ALL_NOTIFICATIONS {
+            trace!(
+                %session_id,
+                "[MCPNotifier] 🚫 disabled — skipping session list_changed"
+            );
+            return;
+        }
+
+        let snapshot: Option<(String, Arc<Peer<RoleServer>>)> = {
+            let sessions = self.sessions.read();
+            sessions.get(session_id).and_then(|entry| {
+                if entry.has_active_stream {
+                    Some((entry.client_id.clone(), entry.peer.clone()))
+                } else {
+                    None
+                }
+            })
+        };
+
+        let Some((client_id, peer)) = snapshot else {
+            debug!(
+                %session_id,
+                "[MCPNotifier] no active stream — skipping session list_changed"
+            );
+            return;
+        };
+
+        if self.reap_dead_sessions(&[(session_id.to_string(), peer.clone())]).contains(&session_id.to_string()) {
+            return;
+        }
+
+        info!(
+            %session_id,
+            %client_id,
+            "[MCPNotifier] 📤 session list_changed (override mutated)"
+        );
+        self.send_all_lists_changed_to_peer(session_id, &client_id, &peer)
+            .await;
+    }
+
+    /// Push tools/prompts/resources list_changed to a single peer.
+    async fn send_all_lists_changed_to_peer(
+        &self,
+        session_id: &str,
+        client_id: &str,
+        peer: &Peer<RoleServer>,
+    ) {
+        match peer.notify_tool_list_changed().await {
+            Ok(_) => debug!(
+                %session_id,
+                %client_id,
+                "[MCPNotifier] ✅ Sent tools/list_changed to session"
+            ),
+            Err(e) => warn!(
+                %session_id,
+                %client_id,
+                error = ?e,
+                "[MCPNotifier] failed tools/list_changed"
+            ),
+        }
+        match peer.notify_prompt_list_changed().await {
+            Ok(_) => debug!(
+                %session_id,
+                %client_id,
+                "[MCPNotifier] ✅ Sent prompts/list_changed to session"
+            ),
+            Err(e) => warn!(
+                %session_id,
+                %client_id,
+                error = ?e,
+                "[MCPNotifier] failed prompts/list_changed"
+            ),
+        }
+        match peer.notify_resource_list_changed().await {
+            Ok(_) => debug!(
+                %session_id,
+                %client_id,
+                "[MCPNotifier] ✅ Sent resources/list_changed to session"
+            ),
+            Err(e) => warn!(
+                %session_id,
+                %client_id,
+                error = ?e,
+                "[MCPNotifier] failed resources/list_changed"
+            ),
         }
     }
 }

crates/mcpmux-gateway/src/mcp/handler.rs

@@ -752,7 +752,19 @@ impl ServerHandler for McpMuxGatewayHandler {
                 .call(&params.name, &oauth_ctx.client_id, session_id, args)
                 .await
             {
-                Ok(result) => Ok(result),
+                Ok(result) => {
+                    if matches!(
+                        params.name.as_ref(),
+                        "mcpmux_enable_server" | "mcpmux_disable_server"
+                    ) {
+                        if let Some(sid) = session_id {
+                            self.notification_bridge
+                                .notify_session_lists_changed(sid)
+                                .await;
+                        }
+                    }
+                    Ok(result)
+                }
                 Err(e) => Ok(e.into_call_tool_result()),
             };
         }

crates/mcpmux-gateway/src/services/meta_tools/mod.rs

@@ -30,7 +30,10 @@ pub use approval::{
     ApprovalScope,
 };
 pub use diff::ToolDiff;
-pub use registry::{MetaToolContext, MetaToolError, MetaToolRegistry, META_TOOLS_ENABLED_KEY};
+pub use registry::{
+    MetaToolContext, MetaToolError, MetaToolRegistry, META_TOOLS_ENABLED_KEY,
+    SESSION_OVERRIDES_REQUIRE_APPROVAL_KEY,
+};
 
 /// Every built-in tool's name must start with this prefix so the handler
 /// can intercept it before routing to backend servers.
@@ -80,10 +83,9 @@ pub fn build_default_registry(
     registry.register(Box::new(tools::ListAllToolsTool));
     registry.register(Box::new(tools::ListFeatureSetsTool));
     registry.register(Box::new(tools::ListServersTool));
-    // Both `describe_resolution` and `describe_workspace` were removed by
-    // user request — the read surface is just the two list_* tools above,
-    // which an LLM can stitch into the same picture without an extra hop.
-    // Writes — gated by ApprovalBroker.
+    // Writes — gated by ApprovalBroker (or auto-allowed for session overrides).
+    registry.register(Box::new(tools::EnableServerTool));
+    registry.register(Box::new(tools::DisableServerTool));
     registry.register(Box::new(tools::CreateFeatureSetTool));
     registry.register(Box::new(tools::BindCurrentWorkspaceTool));
     std::sync::Arc::new(registry)

crates/mcpmux-gateway/src/services/meta_tools/registry.rs

@@ -5,7 +5,7 @@
 //! `tools/list` response.
 
 use std::collections::HashMap;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 use async_trait::async_trait;
 use mcpmux_core::{
@@ -27,6 +27,11 @@ use crate::services::{
 /// Present + "false" → hidden; missing or anything else → enabled.
 pub const META_TOOLS_ENABLED_KEY: &str = "gateway.meta_tools_enabled";
 
+/// When `"true"`, session-scope enable/disable routes through the approval
+/// broker. Default (missing / unparseable): auto-allow.
+pub const SESSION_OVERRIDES_REQUIRE_APPROVAL_KEY: &str =
+    "gateway.session_overrides_require_approval";
+
 /// Context injected into every meta-tool invocation.
 ///
 /// Cheap to clone (all `Arc`s); the registry holds one and hands references
@@ -63,6 +68,9 @@ pub struct MetaToolCall<'a> {
     /// JSON arguments supplied in `CallToolRequestParams.arguments`.
     pub args: Value,
     pub ctx: &'a MetaToolContext,
+    /// Write tools set this before returning `Ok` to override the default
+    /// `"allow_once"` audit decision (e.g. `"session_override"`).
+    pub audit_decision: Arc<Mutex<Option<&'static str>>>,
 }
 
 /// Errors a meta tool can surface that map cleanly to `CallToolResult::error`.
@@ -223,16 +231,25 @@ impl MetaToolRegistry {
             .get(name)
             .ok_or_else(|| MetaToolError::InvalidArgument(format!("unknown meta tool: {name}")))?;
         let is_write = tool.is_write();
+        let audit_decision = Arc::new(Mutex::new(None));
         let call = MetaToolCall {
             client_id,
             session_id,
             args: args.clone(),
             ctx: &self.ctx,
+            audit_decision: audit_decision.clone(),
         };
         let result = tool.call(call).await;
 
         let (decision, summary) = match &result {
-            Ok(_) if is_write => ("allow_once", format!("{name} succeeded")),
+            Ok(_) if is_write => (
+                audit_decision
+                    .lock()
+                    .ok()
+                    .and_then(|g| *g)
+                    .unwrap_or("allow_once"),
+                format!("{name} succeeded"),
+            ),
             Ok(_) => ("read", format!("{name} read")),
             Err(MetaToolError::ApprovalDenied) => ("deny", format!("{name} denied by user")),
             Err(MetaToolError::ApprovalTimedOut) => ("timeout", format!("{name} timed out")),