feat(meta-tools): session override UI and settings toggle (Phase 5)

Expose session overrides in the Workspaces inspector with clear controls,
wire list/clear Tauri commands, and add a settings gate for session-scope
enable/disable approval.

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

Author: crimsonsunset

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

@@ -79,6 +79,10 @@ pub struct GatewayAppState {
     /// Surfaced to the desktop Workspaces tab so users can see + act on
     /// every folder connected clients are currently operating in.
     pub session_roots: Option<Arc<mcpmux_gateway::services::SessionRootsRegistry>>,
+    /// Session-scoped server enable/disable overrides (meta-tool mutations).
+    pub session_overrides: Option<Arc<mcpmux_gateway::services::SessionOverrideRegistry>>,
+    /// Per-session list_changed bridge — used when the UI clears overrides.
+    pub mcp_notifier: Option<Arc<mcpmux_gateway::consumers::MCPNotifier>>,
 }
 
 /// Gracefully shuts down a running gateway and waits for the axum task
@@ -888,6 +892,8 @@ pub async fn start_gateway(
     let server_manager = server.server_manager();
     let grant_service = server.grant_service();
     let session_roots = server.session_roots();
+    let session_overrides = server.session_overrides();
+    let mcp_notifier = server.notification_bridge();
 
     // Subscribe to OAuth completions BEFORE spawn so we don't miss early
     // events emitted during initial auto-connect.
@@ -935,6 +941,8 @@ pub async fn start_gateway(
     state.grant_service = Some(grant_service);
     state.approval_broker = Some(approval_broker);
     state.session_roots = Some(session_roots);
+    state.session_overrides = Some(session_overrides);
+    state.mcp_notifier = Some(mcp_notifier);
     info!(
         "[Gateway] Started — url={}, event_emitter={}, grant_service={}",
         url,

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

@@ -17,6 +17,7 @@ pub mod server;
 pub mod server_discovery;
 pub mod server_feature;
 pub mod server_manager;
+pub mod session_overrides;
 pub mod settings;
 pub mod space;
 pub mod workspace_binding;
@@ -35,6 +36,7 @@ pub use server::*;
 pub use server_discovery::*;
 pub use server_feature::*;
 pub use server_manager::*;
+pub use session_overrides::*;
 pub use settings::*;
 pub use space::*;
 pub use workspace_binding::*;

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

@@ -0,0 +1,107 @@
+//! Tauri commands for inspecting and clearing session-scoped server overrides.
+
+use std::sync::Arc;
+
+use mcpmux_gateway::services::SessionOverrideEntry;
+use serde::Serialize;
+use tauri::{AppHandle, Emitter, State};
+use tokio::sync::RwLock;
+use tracing::info;
+
+use super::gateway::GatewayAppState;
+
+/// Per-session override state surfaced to the Workspaces inspector.
+#[derive(Debug, Clone, Serialize)]
+pub struct SessionOverrideDto {
+    pub session_id: String,
+    pub enabled: Vec<String>,
+    pub disabled: Vec<String>,
+    pub roots: Vec<String>,
+}
+
+impl SessionOverrideDto {
+    fn from_entry(entry: SessionOverrideEntry, roots: Vec<String>) -> Self {
+        Self {
+            session_id: entry.session_id,
+            enabled: entry.enabled,
+            disabled: entry.disabled,
+            roots,
+        }
+    }
+}
+
+fn build_dtos(gateway: &GatewayAppState) -> Vec<SessionOverrideDto> {
+    let Some(ref overrides) = gateway.session_overrides else {
+        return vec![];
+    };
+    let roots_by_session: std::collections::HashMap<String, Vec<String>> = gateway
+        .session_roots
+        .as_ref()
+        .map(|reg| {
+            reg.list_all_sessions()
+                .into_iter()
+                .collect()
+        })
+        .unwrap_or_default();
+
+    overrides
+        .list_all()
+        .into_iter()
+        .map(|entry| {
+            let roots = roots_by_session
+                .get(&entry.session_id)
+                .cloned()
+                .unwrap_or_default();
+            SessionOverrideDto::from_entry(entry, roots)
+        })
+        .collect()
+}
+
+/// List override state for one session, or every session when `session_id`
+/// is omitted. Returns an empty list when the gateway is not running.
+#[tauri::command]
+pub async fn list_session_overrides(
+    session_id: Option<String>,
+    gateway_state: State<'_, Arc<RwLock<GatewayAppState>>>,
+) -> Result<Vec<SessionOverrideDto>, String> {
+    let guard = gateway_state.read().await;
+    let mut dtos = build_dtos(&guard);
+    if let Some(sid) = session_id {
+        dtos.retain(|d| d.session_id == sid);
+    }
+    Ok(dtos)
+}
+
+/// Drop all enable/disable overrides for a session and push list_changed so
+/// the client's tool list reverts to binding-only routing.
+#[tauri::command]
+pub async fn clear_session_overrides(
+    session_id: String,
+    gateway_state: State<'_, Arc<RwLock<GatewayAppState>>>,
+    app_handle: AppHandle,
+) -> Result<(), String> {
+    let notifier = {
+        let guard = gateway_state.read().await;
+        let overrides = guard
+            .session_overrides
+            .as_ref()
+            .ok_or("Gateway is not running")?;
+        overrides.clear(&session_id);
+        guard.mcp_notifier.clone()
+    };
+
+    if let Some(notifier) = notifier {
+        notifier.notify_session_lists_changed(&session_id).await;
+    }
+
+    info!("[session_overrides] cleared overrides for session {}", session_id);
+
+    if let Err(e) = app_handle.emit(
+        "session-overrides-changed",
+        serde_json::json!({ "session_id": session_id }),
+    ) {
+        tracing::warn!("[session_overrides] failed to emit session-overrides-changed: {e}");
+    }
+
+    Ok(())
+}

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

@@ -165,6 +165,44 @@ pub async fn set_meta_tools_enabled(
     Ok(())
 }
 
+/// Whether session-scope `mcpmux_enable_server` / `mcpmux_disable_server`
+/// calls require approval. Default OFF (auto-allow).
+#[tauri::command]
+pub async fn get_session_overrides_require_approval(
+    app_state: State<'_, AppState>,
+) -> Result<bool, String> {
+    match app_state
+        .settings_repository
+        .get("gateway.session_overrides_require_approval")
+        .await
+    {
+        Ok(Some(v)) => Ok(matches!(v.as_str(), "true" | "1")),
+        _ => Ok(false),
+    }
+}
+
+/// Flip the session-override approval gate. Takes effect on the next
+/// session-scope enable/disable meta-tool call.
+#[tauri::command]
+pub async fn set_session_overrides_require_approval(
+    require_approval: bool,
+    app_state: State<'_, AppState>,
+) -> Result<(), String> {
+    app_state
+        .settings_repository
+        .set(
+            "gateway.session_overrides_require_approval",
+            if require_approval { "true" } else { "false" },
+        )
+        .await
+        .map_err(|e| format!("Failed to save session_overrides_require_approval: {}", e))?;
+    info!(
+        "[Settings] session_overrides_require_approval = {}",
+        require_approval
+    );
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

apps/desktop/src-tauri/src/lib.rs

@@ -912,6 +912,10 @@ pub fn run() {
             commands::revoke_meta_tool_grant,
             commands::get_meta_tools_enabled,
             commands::set_meta_tools_enabled,
+            commands::get_session_overrides_require_approval,
+            commands::set_session_overrides_require_approval,
+            commands::list_session_overrides,
+            commands::clear_session_overrides,
             // Config export commands
             commands::preview_config_export,
             commands::export_config_to_file,

apps/desktop/src/features/settings/SettingsPage.tsx

@@ -36,6 +36,10 @@ import {
 import { useAppStore, useTheme, useAnalyticsEnabled } from '@/stores';
 import { UpdateChecker } from './UpdateChecker';
 import { getMetaToolsEnabled, setMetaToolsEnabled } from '@/lib/api/metaTools';
+import {
+  getSessionOverridesRequireApproval,
+  setSessionOverridesRequireApproval,
+} from '@/lib/api/sessionOverrides';
 import { MetaToolAuditLog, MetaToolGrantsPanel } from '@/features/metaTools';
 import { useGatewayControl } from '@/features/gateway/useGatewayControl';
 import { CONTRIBUTE, openExternal } from '@/lib/contribute';
@@ -78,6 +82,10 @@ export function SettingsPage() {
   // Meta-tools master switch — gates the entire `mcpmux_*` namespace.
   const [metaToolsEnabled, setMetaToolsEnabledState] = useState<boolean>(true);
   const [loadingMetaTools, setLoadingMetaTools] = useState(true);
+  const [sessionOverridesRequireApproval, setSessionOverridesRequireApprovalState] =
+    useState<boolean>(false);
+  const [loadingSessionOverrideApproval, setLoadingSessionOverrideApproval] =
+    useState(true);
 
   // Gateway port — persisted user override, the default the app ships
   // with, and the port the currently-running gateway is bound to. When
@@ -181,6 +189,12 @@ export function SettingsPage() {
       .then((v) => setMetaToolsEnabledState(v))
       .catch((e) => console.error('Failed to load meta_tools_enabled', e))
       .finally(() => setLoadingMetaTools(false));
+    getSessionOverridesRequireApproval()
+      .then((v) => setSessionOverridesRequireApprovalState(v))
+      .catch((e) =>
+        console.error('Failed to load session_overrides_require_approval', e)
+      )
+      .finally(() => setLoadingSessionOverrideApproval(false));
   }, []);
 
   const handleToggleMetaTools = async (next: boolean) => {
@@ -200,6 +214,23 @@ export function SettingsPage() {
     }
   };
 
+  const handleToggleSessionOverrideApproval = async (next: boolean) => {
+    const previous = sessionOverridesRequireApproval;
+    setSessionOverridesRequireApprovalState(next);
+    try {
+      await setSessionOverridesRequireApproval(next);
+      success(
+        next ? 'Session overrides require approval' : 'Session overrides auto-allowed',
+        next
+          ? 'mcpmux_enable_server / mcpmux_disable_server (session scope) will prompt before applying.'
+          : 'Session-scope enable/disable applies immediately without a dialog.'
+      );
+    } catch (e) {
+      setSessionOverridesRequireApprovalState(previous);
+      error('Failed to save setting', e instanceof Error ? e.message : String(e));
+    }
+  };
+
   // Load logs path on mount
   useEffect(() => {
     const loadLogsPath = async () => {
@@ -632,6 +663,29 @@ export function SettingsPage() {
               data-testid="meta-tools-enabled-switch"
             />
           </div>
+          <div className="flex items-center justify-between gap-4">
+            <div className="flex items-start gap-3 flex-1 min-w-0">
+              <AlertCircle className="h-5 w-5 mt-0.5 text-[rgb(var(--muted))] flex-shrink-0" />
+              <div>
+                <label className="text-sm font-medium">
+                  Require approval for session-scope overrides
+                </label>
+                <p className="text-xs text-[rgb(var(--muted))] mt-1">
+                  When on,{' '}
+                  <code className="font-mono">mcpmux_enable_server</code> /{' '}
+                  <code className="font-mono">mcpmux_disable_server</code> with{' '}
+                  <code className="font-mono">scope: &quot;session&quot;</code> show the native
+                  approval dialog. Workspace-scope writes always require approval.
+                </p>
+              </div>
+            </div>
+            <Switch
+              checked={sessionOverridesRequireApproval}
+              onCheckedChange={handleToggleSessionOverrideApproval}
+              disabled={loadingSessionOverrideApproval || !metaToolsEnabled}
+              data-testid="session-overrides-require-approval-switch"
+            />
+          </div>
           <MetaToolGrantsPanel />
           <MetaToolAuditLog />
         </CardContent>