fix(gateway,ui): collapse describe tools, fire list_changed on Connect, badge denominator

* Collapse `mcpmux_describe_resolution` into `mcpmux_describe_workspace`.
  The split surfaced two reads with overlapping output and shipped a redundant
  tool to LLMs. `describe_workspace` now returns a `resolution` block with
  `feature_set_id`, `feature_set_name`, `source`, and `resolved_tool_count`.

* Fire `list_changed` on `ServerStatusChanged(Connected)`, not just
  Disconnected. Reconnect flips per-feature `is_available`, which
  `get_all_features_for_space` filters on, so the content hash legitimately
  changes both ways. Without this, a backend reconnect after the client's
  initial `tools/list` left the client view stuck without the freshly-available
  tools. Loop concern mooted by the existing hash dedup.

* `WorkspacesPage` per-server badge now reads `{mapped}/{server total}` —
  backend returns `server_totals` (HashMap of server_id -> per-type counts)
  computed before the FS filter is applied. The old `3/3` was
  `mapped/mapped`; the new badge tells the user "this FS includes 3 of the
  10 cloudflare-docs tools available."

* `WorkspacesPage` listens for `workspace-binding-changed` so popup-driven
  binding saves refresh the page live (previously stayed on `UNMAPPED`
  until the user navigated away and back).

* Migration 008 enforces the default-space invariant: the seeded `My Space`
  row is the canonical default; every other row gets `is_default = 0`.
  Repairs DBs corrupted by the older `if no spaces exist, set_default()`
  branch (now removed from `SpaceAppService::create`).

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

Author: its-mash

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

@@ -320,6 +320,17 @@ pub struct EffectiveFeatureDto {
     pub available: bool,
 }
 
+/// Per-server total counts in the resolved Space, regardless of the
+/// FeatureSet filter. The UI shows badges like "3 / {total}" — the right
+/// side is the total the server exposes in the Space, so the user can see
+/// "this FS includes 3 of the 10 cloudflare-docs tools available."
+#[derive(Debug, Clone, Serialize)]
+pub struct ServerFeatureTotalsDto {
+    pub tools: usize,
+    pub prompts: usize,
+    pub resources: usize,
+}
+
 /// Top-level DTO: the resolved (Space, FeatureSet) pair for a given root,
 /// plus its full configured tool/prompt/resource lists with availability.
 #[derive(Debug, Clone, Serialize)]
@@ -342,6 +353,10 @@ pub struct WorkspaceEffectiveFeaturesDto {
     pub tools: Vec<EffectiveFeatureDto>,
     pub prompts: Vec<EffectiveFeatureDto>,
     pub resources: Vec<EffectiveFeatureDto>,
+    /// `server_id -> totals` over every feature the server exposes in the
+    /// resolved Space (no FS filter applied). Used by the UI to render
+    /// "{mapped} / {server total}" badges.
+    pub server_totals: HashMap<String, ServerFeatureTotalsDto>,
 }
 
 /// Walk a FeatureSet's members (with nested-FS recursion) to compute the
@@ -518,14 +533,32 @@ pub async fn get_workspace_effective_features(
     let mut visited = HashSet::<String>::new();
     collect_member_ids(&fs, &fs_lookup, &mut allowed, &mut excluded, &mut visited);
 
-    // 7. Pull every feature in the Space, then keep only those that pass
-    //    the FS filter — without the `is_available` gate, so we can show
-    //    "configured but disconnected" rows.
+    // 7. Pull every feature in the Space, compute per-server totals (the
+    //    badge denominator), then keep only the FS-filtered subset for the
+    //    rendered list. The `is_available` gate is intentionally not
+    //    applied here — disconnected features still appear, dimmed.
     let all_features = state
         .server_feature_repository_core
         .list_for_space(&space_id.to_string())
         .await
         .map_err(|e| e.to_string())?;
+
+    let mut server_totals: HashMap<String, ServerFeatureTotalsDto> = HashMap::new();
+    for f in &all_features {
+        let entry = server_totals
+            .entry(f.server_id.clone())
+            .or_insert(ServerFeatureTotalsDto {
+                tools: 0,
+                prompts: 0,
+                resources: 0,
+            });
+        match f.feature_type {
+            mcpmux_core::FeatureType::Tool => entry.tools += 1,
+            mcpmux_core::FeatureType::Prompt => entry.prompts += 1,
+            mcpmux_core::FeatureType::Resource => entry.resources += 1,
+        }
+    }
+
     let filtered: Vec<ServerFeature> = all_features
         .into_iter()
         .filter(|f| {
@@ -598,5 +631,6 @@ pub async fn get_workspace_effective_features(
         tools,
         prompts,
         resources,
+        server_totals,
     })
 }

apps/desktop/src/features/workspaces/WorkspacesPage.tsx

@@ -109,13 +109,21 @@ export function WorkspacesPage() {
     void loadData().finally(() => setIsLoading(false));
   }, [loadData]);
 
-  // Refresh the list whenever a session reports (or changes) its roots.
+  // Refresh whenever something the table reflects changes outside the page:
+  //   • `session-roots-changed` — a connected client newly reported a root.
+  //   • `workspace-binding-changed` — a binding was created/updated/deleted
+  //     by another surface (e.g. the new-workspace popup or the meta-tool).
+  // Without the binding listener, popup-driven saves leave this page showing
+  // the stale "UNMAPPED" badge until the user navigates away and back.
   useEffect(() => {
-    const un = listen('session-roots-changed', () => {
+    const reload = () => {
       void loadData();
-    });
+    };
+    const unRoots = listen('session-roots-changed', reload);
+    const unBinding = listen('workspace-binding-changed', reload);
     return () => {
-      un.then((fn) => fn());
+      unRoots.then((fn) => fn());
+      unBinding.then((fn) => fn());
     };
   }, [loadData]);
 
@@ -942,15 +950,23 @@ interface ServerGroup {
   tools: EffectiveFeature[];
   prompts: EffectiveFeature[];
   resources: EffectiveFeature[];
-  total: number;
-  unavailable_total: number;
+  /** Mapped count for this server in the resolved FS (= tools+prompts+resources lengths). */
+  mapped: number;
+  /** Total count of features the server exposes in the resolved Space, regardless of FS. */
+  server_total: number;
+  /** Of `mapped`, how many are unavailable because the server is disconnected. */
+  unavailable_mapped: number;
 }
 
 function buildServerGroups(data: WorkspaceEffectiveFeatures): ServerGroup[] {
   const map = new Map<string, ServerGroup>();
   const place = (item: EffectiveFeature, kind: 'tool' | 'prompt' | 'resource') => {
     let g = map.get(item.server_id);
     if (!g) {
+      const totals = data.server_totals[item.server_id];
+      const server_total = totals
+        ? totals.tools + totals.prompts + totals.resources
+        : 0;
       g = {
         server_id: item.server_id,
         server_alias: item.server_alias ?? item.server_id,
@@ -961,16 +977,17 @@ function buildServerGroups(data: WorkspaceEffectiveFeatures): ServerGroup[] {
         tools: [],
         prompts: [],
         resources: [],
-        total: 0,
-        unavailable_total: 0,
+        mapped: 0,
+        server_total,
+        unavailable_mapped: 0,
       };
       map.set(item.server_id, g);
     }
     if (kind === 'tool') g.tools.push(item);
     else if (kind === 'prompt') g.prompts.push(item);
     else g.resources.push(item);
-    g.total += 1;
-    if (!item.available) g.unavailable_total += 1;
+    g.mapped += 1;
+    if (!item.available) g.unavailable_mapped += 1;
   };
   for (const t of data.tools) place(t, 'tool');
   for (const p of data.prompts) place(p, 'prompt');
@@ -1063,7 +1080,7 @@ function EffectiveFeaturesContent({
   const groups = useMemo(() => (data ? buildServerGroups(data) : []), [data]);
   const totalCount = data ? data.tools.length + data.prompts.length + data.resources.length : 0;
   const availableCount = useMemo(
-    () => groups.reduce((acc, g) => acc + (g.total - g.unavailable_total), 0),
+    () => groups.reduce((acc, g) => acc + (g.mapped - g.unavailable_mapped), 0),
     [groups]
   );
 
@@ -1203,9 +1220,13 @@ function ServerGroupRow({
   onToggle: () => void;
 }) {
   const issue = serverStatusIssue(group.server_status);
-  const availableCount = group.total - group.unavailable_total;
-  const allAvailable = group.total > 0 && availableCount === group.total;
-  const someAvailable = availableCount > 0 && availableCount < group.total;
+  const availableCount = group.mapped - group.unavailable_mapped;
+  // Badge denominator is the server's *total* feature count in the Space,
+  // not the mapped count — the user wants to see "3 of 10 cloudflare-docs
+  // tools are in this FS" rather than "3 of 3 mapped tools work".
+  const denominator = group.server_total > 0 ? group.server_total : group.mapped;
+  const allAvailable = group.mapped > 0 && availableCount === group.mapped;
+  const someAvailable = availableCount > 0 && availableCount < group.mapped;
   const noneAvailable = availableCount === 0;
 
   // Strip reverse-DNS prefix so display reads "cloudflare-bindings" not
@@ -1252,7 +1273,7 @@ function ServerGroupRow({
                       : 'bg-amber-100 dark:bg-amber-900/30 text-amber-700 dark:text-amber-300 border border-amber-300/70 dark:border-amber-700/70',
                 ].join(' ')}
               >
-                {availableCount}/{group.total}
+                {group.mapped}/{denominator}
               </span>
               {issue && (
                 <span
@@ -1285,8 +1306,8 @@ function ServerGroupRow({
                 ].join(' ')}
                 style={{
                   width:
-                    group.total > 0
-                      ? `${(availableCount / group.total) * 100}%`
+                    group.mapped > 0
+                      ? `${(availableCount / group.mapped) * 100}%`
                       : '0%',
                 }}
               />

apps/desktop/src/lib/api/workspaceBindings.ts

@@ -123,6 +123,16 @@ export interface EffectiveFeature {
   available: boolean;
 }
 
+/**
+ * Per-server total feature counts in the resolved Space, regardless of FS
+ * filter. The right-hand side of the "{mapped} / {total}" badges.
+ */
+export interface ServerFeatureTotals {
+  tools: number;
+  prompts: number;
+  resources: number;
+}
+
 export interface WorkspaceEffectiveFeatures {
   workspace_root: string;
   /** `binding` when a saved WorkspaceBinding matched; `fallback` for the default Space's Default FS. */
@@ -136,6 +146,8 @@ export interface WorkspaceEffectiveFeatures {
   tools: EffectiveFeature[];
   prompts: EffectiveFeature[];
   resources: EffectiveFeature[];
+  /** `server_id -> totals` for every server installed in the resolved Space. */
+  server_totals: Record<string, ServerFeatureTotals>;
 }
 
 /**

crates/mcpmux-core/src/application/space.rs

@@ -51,19 +51,18 @@ impl SpaceAppService {
 
     /// Create a new space
     ///
+    /// User-created spaces are NEVER marked as default — the canonical
+    /// default is the seeded "My Space" row, restored by migration 008 if
+    /// it goes missing. The previous "first-created becomes default" branch
+    /// caused durable corruption on installs that hit it.
+    ///
     /// Emits: `SpaceCreated`
     pub async fn create(&self, name: &str, icon: Option<String>) -> Result<Space> {
         let mut space = Space::new(name);
         if let Some(icon) = &icon {
             space = space.with_icon(icon);
         }
 
-        // If no spaces exist, make this one the default
-        let existing = self.space_repo.list().await?;
-        if existing.is_empty() {
-            space = space.set_default();
-        }
-
         // Persist
         self.space_repo.create(&space).await?;
 

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

@@ -484,25 +484,40 @@ impl MCPNotifier {
             } => {
                 use mcpmux_core::ConnectionStatus;
 
-                // Only notify if server disconnected (features unavailable)
-                // We DO NOT notify on Connect because:
-                // 1. If it's a new server, ToolsChanged will fire separately if needed
-                // 2. If it's a reconnect, hashing will handle it
-                // 3. Most importantly: Client connections trigger auto-connects, which would cause loops
-                if matches!(status, ConnectionStatus::Disconnected) {
+                // Disconnect AND reconnect both flip the per-feature
+                // `is_available` flag, which `get_all_features_for_space`
+                // filters on — so the content hash actually changes both
+                // ways. We notify on each so the client's effective tool
+                // list reflects "configured but unavailable" features
+                // dropping out (on Disconnect) and coming back in (on
+                // Connect). `force=false` lets the hash dedup absorb the
+                // intermediate transient states (Connecting / Refreshing /
+                // AuthRequired) without spamming.
+                //
+                // Loop concern (the old comment): a client `tools/list`
+                // query that triggers a lazy backend connect would chain
+                // Connected -> list_changed -> client refetch. Hashing
+                // breaks that chain on the second iteration: the second
+                // refetch sees the same hash as the first and dedupes.
+                let should_notify = matches!(
+                    status,
+                    ConnectionStatus::Connected | ConnectionStatus::Disconnected
+                );
+                if should_notify {
                     info!(
                         server_id = %server_id,
                         space_id = %space_id,
                         status = ?status,
-                        "[MCPNotifier] ServerStatusChanged (Disconnected) - notifying clients to clear features"
+                        "[MCPNotifier] ServerStatusChanged ({:?}) - re-checking effective list",
+                        status,
                     );
                     self.notify_all_list_changed(space_id, false).await;
                 } else {
                     debug!(
                         server_id = %server_id,
                         space_id = %space_id,
                         status = ?status,
-                        "[MCPNotifier] ServerStatusChanged - ignoring (not a disconnection)"
+                        "[MCPNotifier] ServerStatusChanged - transient state, no notify"
                     );
                 }
             }

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

@@ -77,7 +77,10 @@ pub fn build_default_registry(
     // Reads — no approval needed.
     registry.register(Box::new(tools::ListAllToolsTool));
     registry.register(Box::new(tools::ListFeatureSetsTool));
-    registry.register(Box::new(tools::DescribeResolutionTool));
+    // `describe_workspace` also returns the resolution fields the older
+    // `describe_resolution` tool used to expose — the split was confusing
+    // for LLMs (two reads with overlapping output) and trimming it shrinks
+    // the toolbar visible to the caller.
     registry.register(Box::new(tools::DescribeWorkspaceTool));
     // Writes — gated by ApprovalBroker.
     registry.register(Box::new(tools::CreateFeatureSetTool));