fix(workspace-binding): Phase 2 — Persist WorkspaceNeedsBinding dismissals

Autonomous decisions:
- Put dismissal CRUD on InboundClientRepository — same db handle pattern as machines.rs; no new repo type.
- WorkspacesPage auto-open uses root-only dismissal check when client_id is unknown — matches page-load catch-up without session context.
- clear_binding_prompt_dismissals_for_root on create/update — clears all client rows for that root so a later regression re-prompts everyone.

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

Author: crimsonsunset

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

@@ -12,6 +12,7 @@ use mcpmux_core::{
     DomainEvent, FeatureSet, FeatureSetType, MemberMode, MemberType, ServerFeature,
     WorkspaceBinding, WorkspaceRootValidation,
 };
+use mcpmux_storage::InboundClientRepository;
 use serde::{Deserialize, Serialize};
 use tauri::State;
 use tokio::sync::RwLock;
@@ -23,6 +24,21 @@ use super::server_manager::ServerManagerState;
 use super::workspace_appearance::maybe_remove_orphaned_icon_file;
 use crate::state::AppState;
 
+fn inbound_client_repo(state: &AppState) -> InboundClientRepository {
+    InboundClientRepository::new(state.database())
+}
+
+/// Clear persisted prompt dismissals after a binding is saved for a root.
+async fn clear_binding_prompt_dismissals(
+    state: &AppState,
+    workspace_root: &str,
+) -> Result<(), String> {
+    inbound_client_repo(state)
+        .clear_binding_prompt_dismissals_for_root(workspace_root)
+        .await
+        .map_err(|e| e.to_string())
+}
+
 /// Publish `WorkspaceBindingChanged` on the gateway's domain bus so
 /// MCPNotifier broadcasts `list_changed` to every peer whose session now
 /// routes through the changed binding.
@@ -429,6 +445,8 @@ pub async fn create_workspace_binding(
         .await
         .map_err(|e| e.to_string())?;
 
+    clear_binding_prompt_dismissals(&state, &binding.workspace_root).await?;
+
     if binding_type == BindingType::Path {
         clear_appearance_for_bound_root(&state, &normalized).await?;
     }
@@ -533,6 +551,8 @@ pub async fn update_workspace_binding(
         .await
         .map_err(|e| e.to_string())?;
 
+    clear_binding_prompt_dismissals(&state, &updated.workspace_root).await?;
+
     if binding_type == BindingType::Path {
         clear_appearance_for_bound_root(&state, &normalized).await?;
     }
@@ -561,6 +581,40 @@ pub async fn update_workspace_binding(
     Ok(updated.into())
 }
 
+/// Record that the user closed the WorkspaceNeedsBinding panel without saving.
+#[tauri::command]
+pub async fn dismiss_workspace_binding_prompt(
+    client_id: String,
+    workspace_root: String,
+    state: State<'_, AppState>,
+) -> Result<(), String> {
+    inbound_client_repo(&state)
+        .dismiss_binding_prompt(&client_id, &workspace_root)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+/// Whether the binding prompt was dismissed for a client/root pair, or — when
+/// `client_id` is omitted — for any client on that workspace root.
+#[tauri::command]
+pub async fn is_workspace_binding_prompt_dismissed(
+    workspace_root: String,
+    client_id: Option<String>,
+    state: State<'_, AppState>,
+) -> Result<bool, String> {
+    let repo = inbound_client_repo(&state);
+    match client_id {
+        Some(cid) if !cid.is_empty() => repo
+            .is_binding_prompt_dismissed(&cid, &workspace_root)
+            .await
+            .map_err(|e| e.to_string()),
+        _ => repo
+            .is_binding_prompt_dismissed_for_root(&workspace_root)
+            .await
+            .map_err(|e| e.to_string()),
+    }
+}
+
 /// Delete a binding by id.
 #[tauri::command]
 pub async fn delete_workspace_binding(

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

@@ -1042,6 +1042,8 @@ pub fn run() {
             commands::forget_reported_root,
             commands::create_workspace_binding,
             commands::update_workspace_binding,
+            commands::dismiss_workspace_binding_prompt,
+            commands::is_workspace_binding_prompt_dismissed,
             commands::delete_workspace_binding,
             commands::validate_workspace_root,
             commands::get_workspace_effective_features,

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

@@ -49,6 +49,7 @@ import {
   clearUnmappedReportedRoots,
   forgetReportedRoot,
   getWorkspaceEffectiveFeatures,
+  isWorkspaceBindingPromptDismissed,
   listReportedWorkspaceRoots,
   listWorkspaceBindings,
   type EffectiveFeature,
@@ -412,11 +413,20 @@ export function WorkspacesPage() {
     if (isLoading || isPanelOpen) return;
     const firstUnmapped = entries.find((e) => e.kind === 'unmapped-live');
     if (!firstUnmapped) return;
-    openBindingPanel({
-      mode: 'create-from-live',
-      workspaceRoot: firstUnmapped.root,
-      appearanceIcon: resolveEntryIcon(firstUnmapped) ?? undefined,
-    });
+
+    void (async () => {
+      try {
+        const dismissed = await isWorkspaceBindingPromptDismissed(firstUnmapped.root);
+        if (dismissed || useBindingPanelStore.getState().isOpen) return;
+        openBindingPanel({
+          mode: 'create-from-live',
+          workspaceRoot: firstUnmapped.root,
+          appearanceIcon: resolveEntryIcon(firstUnmapped) ?? undefined,
+        });
+      } catch {
+        /* best-effort — skip auto-open on check failure */
+      }
+    })();
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [isLoading]);
 

apps/desktop/src/features/workspaces/workspace-binding-panel.component.tsx

@@ -20,6 +20,7 @@ import { apiCall } from '@/lib/api/transport';
 import {
   createWorkspaceBinding,
   deleteWorkspaceBinding,
+  dismissWorkspaceBindingPrompt,
   listWorkspaceBindings,
   updateWorkspaceBinding,
   validateWorkspaceRoot,
@@ -385,15 +386,6 @@ export function WorkspaceBindingPanel() {
     };
   }, [isOpen, payload, showError, t]);
 
-  useEffect(() => {
-    if (!isOpen) return;
-    const onKey = (e: KeyboardEvent) => {
-      if (e.key === 'Escape') close();
-    };
-    window.addEventListener('keydown', onKey);
-    return () => window.removeEventListener('keydown', onKey);
-  }, [isOpen, close]);
-
   const formInitial = useMemo(
     () => (payload ? buildFormInitial(payload, spaces) : null),
     [payload, spaces],
@@ -427,6 +419,27 @@ export function WorkspaceBindingPanel() {
     ? bindingMachineId(machineId)
     : machineIds[0] ?? null;
 
+  /** Close the panel; record a dismissal for create-from-live prompts with a client id. */
+  const handlePanelClose = useCallback(() => {
+    const rootToDismiss =
+      payload?.workspaceRoot ?? payload?.binding?.workspace_root ?? workspaceRoot;
+    if (payload?.mode === 'create-from-live' && payload.clientId && rootToDismiss) {
+      void dismissWorkspaceBindingPrompt(payload.clientId, rootToDismiss).catch(
+        () => undefined,
+      );
+    }
+    close();
+  }, [payload, workspaceRoot, close]);
+
+  useEffect(() => {
+    if (!isOpen) return;
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') handlePanelClose();
+    };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, [isOpen, handlePanelClose]);
+
   useEffect(() => {
     if (!isOpen || !payload || loadingData) return;
     const initial = formInitial;
@@ -898,7 +911,7 @@ export function WorkspaceBindingPanel() {
     <>
       <div
         className="fixed inset-0 bg-black/20 backdrop-blur-[2px] z-40 animate-in fade-in duration-200"
-        onClick={close}
+        onClick={handlePanelClose}
         data-testid="workspace-binding-panel-backdrop"
       />
       <div
@@ -942,7 +955,7 @@ export function WorkspaceBindingPanel() {
             />
             <button
               type="button"
-              onClick={close}
+              onClick={handlePanelClose}
               className="p-1.5 rounded-lg hover:bg-[rgb(var(--surface-hover))] transition-colors flex-shrink-0"
               aria-label={t('panel.closeAria')}
             >
@@ -1268,7 +1281,7 @@ export function WorkspaceBindingPanel() {
                 )}
                 {createSubmitLabel}
               </Button>
-              <Button variant="secondary" size="md" onClick={close} disabled={submitting}>
+              <Button variant="secondary" size="md" onClick={handlePanelClose} disabled={submitting}>
                 {t('common:actions.cancel')}
               </Button>
             </div>

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

@@ -133,6 +133,28 @@ export async function deleteWorkspaceBinding(id: string): Promise<void> {
   return apiCall('delete_workspace_binding', { id });
 }
 
+/** Persist a WorkspaceNeedsBinding panel dismissal for a client/root pair. */
+export async function dismissWorkspaceBindingPrompt(
+  clientId: string,
+  workspaceRoot: string,
+): Promise<void> {
+  return apiCall('dismiss_workspace_binding_prompt', { clientId, workspaceRoot });
+}
+
+/**
+ * True when the user previously closed the binding prompt without saving.
+ * Omit `clientId` to check whether any client dismissed that workspace root.
+ */
+export async function isWorkspaceBindingPromptDismissed(
+  workspaceRoot: string,
+  clientId?: string | null,
+): Promise<boolean> {
+  return apiCall('is_workspace_binding_prompt_dismissed', {
+    workspaceRoot,
+    ...(clientId ? { clientId } : {}),
+  });
+}
+
 /** Convenience: build a `WorkspaceBindingInput` from a binding-shaped object. */
 export function toInput(b: WorkspaceBinding): WorkspaceBindingInput {
   return {

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

@@ -155,6 +155,21 @@ impl McpMuxGatewayHandler {
                     resolved.space_id,
                     root_for_prompt,
                 ) {
+                    let dismissed = services
+                        .dependencies
+                        .inbound_client_repo
+                        .is_binding_prompt_dismissed(client_id, root)
+                        .await
+                        .unwrap_or(false);
+                    if dismissed {
+                        debug!(
+                            %client_id,
+                            workspace_root = root,
+                            "Skipping WorkspaceNeedsBinding — user dismissed this prompt"
+                        );
+                        return;
+                    }
+
                     // Lock the popup's Space field when the folder is scoped to
                     // a Space by base directory — the user shouldn't be able to
                     // bind it elsewhere.

crates/mcpmux-storage/src/database.rs

@@ -233,6 +233,11 @@ const MIGRATIONS: &[Migration] = &[
         name: "public_url_rename",
         sql: include_str!("migrations/040_public_url_rename.sql"),
     },
+    Migration {
+        version: 41,
+        name: "workspace_binding_prompt_dismissals",
+        sql: include_str!("migrations/041_workspace_binding_prompt_dismissals.sql"),
+    },
 ];
 
 /// SQLite database wrapper.
@@ -773,7 +778,7 @@ mod tests {
                 |row| row.get(0),
             )
             .unwrap();
-        assert_eq!(version, 40);
+        assert_eq!(version, 41);
 
         let v16_name: String = db
             .conn

crates/mcpmux-storage/src/migrations/041_workspace_binding_prompt_dismissals.sql

@@ -0,0 +1,15 @@
+-- Migration 041: persist WorkspaceNeedsBinding panel dismissals per client + root.
+--
+-- Closing the binding prompt without saving records (client_id, workspace_root)
+-- so reconnects do not re-fire the popup. Cleared when a binding is saved for
+-- that workspace_root so a later regression surfaces again.
+
+CREATE TABLE IF NOT EXISTS workspace_binding_prompt_dismissals (
+    client_id TEXT NOT NULL,
+    workspace_root TEXT NOT NULL,
+    dismissed_at TEXT NOT NULL,
+    PRIMARY KEY (client_id, workspace_root)
+);
+
+CREATE INDEX IF NOT EXISTS idx_wbpd_workspace_root
+    ON workspace_binding_prompt_dismissals (workspace_root);

crates/mcpmux-storage/src/repositories/inbound_client_repository.rs

@@ -1061,6 +1061,77 @@ impl InboundClientRepository {
 
         Ok(grants)
     }
+
+    /// True when the user dismissed the WorkspaceNeedsBinding prompt for this
+    /// `(client_id, workspace_root)` pair.
+    pub async fn is_binding_prompt_dismissed(
+        &self,
+        client_id: &str,
+        workspace_root: &str,
+    ) -> Result<bool> {
+        let db = self.db.lock().await;
+        let conn = db.connection();
+        let count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM workspace_binding_prompt_dismissals \
+                 WHERE client_id = ?1 AND workspace_root = ?2",
+                params![client_id, workspace_root],
+                |row| row.get(0),
+            )
+            .unwrap_or(0);
+        Ok(count > 0)
+    }
+
+    /// True when any client dismissed the prompt for this workspace root.
+    /// Used by the Workspaces page auto-open path when no client id is known.
+    pub async fn is_binding_prompt_dismissed_for_root(&self, workspace_root: &str) -> Result<bool> {
+        let db = self.db.lock().await;
+        let conn = db.connection();
+        let count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM workspace_binding_prompt_dismissals \
+                 WHERE workspace_root = ?1",
+                params![workspace_root],
+                |row| row.get(0),
+            )
+            .unwrap_or(0);
+        Ok(count > 0)
+    }
+
+    /// Record that the user closed the binding prompt without saving.
+    pub async fn dismiss_binding_prompt(
+        &self,
+        client_id: &str,
+        workspace_root: &str,
+    ) -> Result<()> {
+        let db = self.db.lock().await;
+        let conn = db.connection();
+        let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
+        conn.execute(
+            "INSERT OR REPLACE INTO workspace_binding_prompt_dismissals \
+             (client_id, workspace_root, dismissed_at) VALUES (?1, ?2, ?3)",
+            params![client_id, workspace_root, now],
+        )?;
+        debug!(
+            client_id,
+            workspace_root, "[OAuth] Dismissed workspace binding prompt"
+        );
+        Ok(())
+    }
+
+    /// Remove dismissals for a workspace root after a binding is saved.
+    pub async fn clear_binding_prompt_dismissals_for_root(
+        &self,
+        workspace_root: &str,
+    ) -> Result<()> {
+        let db = self.db.lock().await;
+        let conn = db.connection();
+        conn.execute(
+            "DELETE FROM workspace_binding_prompt_dismissals WHERE workspace_root = ?1",
+            params![workspace_root],
+        )?;
+        Ok(())
+    }
 }
 
 #[cfg(test)]