feat(workspaces): allow empty mappings (savable "no Space tools")

A workspace mapping may now have zero feature sets — a valid "no Space tools"
state: the folder still routes to its Space, but gets no Space tools (built-in
servers still apply per Space). Removes the non-empty invariant end to end:

- storage: create/update accept empty feature_set_ids (junction left empty);
- command: validate_fs_list no longer rejects empty;
- domain: WorkspaceBinding doc updated (was "non-empty by construction");
- ui: Apply is enabled with zero feature sets — the empty state is now an
  informational hint instead of a blocker, and edit mode no longer auto-reseeds
  a default over an intentionally-emptied selection.

Byte-proven: storage test_create_allows_empty_fs_list +
effective_features::empty_mapping_yields_zero_effective_tools.

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

Author: its-mash

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

@@ -73,10 +73,11 @@ impl From<WorkspaceBinding> for WorkspaceBindingDto {
     }
 }
 
-/// Input for creating or updating a binding. Pass at least one
-/// `feature_set_id` in `feature_set_ids` — empty is rejected.
+/// Input for creating or updating a binding.
 ///
-/// Order matters for UI rendering only; the resolver merges them.
+/// `feature_set_ids` MAY be empty — an empty list means "this folder gets no
+/// Space tools" (built-in servers still apply per Space). Order matters for UI
+/// rendering only; the resolver merges them.
 #[derive(Debug, Deserialize)]
 pub struct WorkspaceBindingInput {
     pub workspace_root: String,
@@ -88,23 +89,18 @@ fn parse_space_id(input: &WorkspaceBindingInput) -> Result<Uuid, String> {
     Uuid::parse_str(&input.space_id).map_err(|e| format!("bad space_id: {e}"))
 }
 
+/// Clean + dedup the feature-set list (preserving order). An empty result is
+/// valid — it persists as a "no Space tools" binding.
 fn validate_fs_list(input: &WorkspaceBindingInput) -> Result<Vec<String>, String> {
-    let cleaned: Vec<String> = input
+    let cleaned = input
         .feature_set_ids
         .iter()
         .map(|s| s.trim().to_string())
-        .filter(|s| !s.is_empty())
-        .collect();
-    if cleaned.is_empty() {
-        return Err("at least one feature_set_id is required".into());
-    }
+        .filter(|s| !s.is_empty());
     // Dedup while preserving order so the operator's intent ("primary then
     // overlay") survives a duplicate they may have accidentally supplied.
     let mut seen = HashSet::new();
-    let deduped: Vec<String> = cleaned
-        .into_iter()
-        .filter(|id| seen.insert(id.clone()))
-        .collect();
+    let deduped: Vec<String> = cleaned.filter(|id| seen.insert(id.clone())).collect();
     Ok(deduped)
 }
 

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

@@ -1664,20 +1664,23 @@ function BindingForm({
   }, [availableFs, fsSearch]);
 
   // When the Space changes, drop selections that aren't in the new Space's
-  // FS list. Reseed an empty selection with the default FS so the operator
-  // doesn't have to click anything for a "single-FS, default" binding.
+  // FS list. In CREATE modes only, reseed an empty selection with the default
+  // FS so the operator doesn't have to click anything for the common case.
+  // In EDIT mode we never reseed — an intentionally-empty mapping ("no Space
+  // tools") must survive reopening.
   useEffect(() => {
     if (availableFs.length === 0) {
       if (fsIds.length > 0) setFsIds([]);
       return;
     }
     const validIds = new Set(availableFs.map((f) => f.id));
     const filtered = fsIds.filter((id) => validIds.has(id));
-    if (filtered.length === 0) {
+    if (filtered.length !== fsIds.length) {
+      // Cross-space cleanup: drop ids that don't belong to this Space.
+      setFsIds(filtered);
+    } else if (filtered.length === 0 && !initial) {
       const fallback = availableFs.find(isStarterFeatureSet) ?? availableFs[0];
       setFsIds([fallback.id]);
-    } else if (filtered.length !== fsIds.length) {
-      setFsIds(filtered);
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [availableFs]);
@@ -1723,10 +1726,11 @@ function BindingForm({
     );
   }, [isEdit, initial, trimmedRoot, spaceId, fsIds]);
 
+  // Note: an empty feature-set selection is a VALID mapping ("no Space tools";
+  // built-in servers still apply per Space), so it does not block Apply.
   const canSubmit =
     !submitting &&
     !!spaceId &&
-    fsIds.length > 0 &&
     (rootValidation.state === 'ok' || !rootEditable) &&
     !duplicate &&
     dirty;
@@ -1748,10 +1752,6 @@ function BindingForm({
       onError('Pick a Space.');
       return;
     }
-    if (fsIds.length === 0) {
-      onError('Pick at least one feature set.');
-      return;
-    }
     if (savedTimerRef.current) {
       clearTimeout(savedTimerRef.current);
       savedTimerRef.current = null;
@@ -2004,20 +2004,22 @@ function BindingForm({
       {/* Saving is explicit in every mode now — nothing is written until
           Apply is pressed, so the user can keep deciding without half-saved
           state. In edit mode the button stays disabled until something
-          actually changes. */}
+          actually changes. An empty feature-set selection is valid and
+          savable. */}
       <div className="pt-1 space-y-2">
-        {spaceId && availableFs.length > 0 && fsIds.length === 0 ? (
-          // Explains *why* Apply is disabled — otherwise unselecting every
-          // feature set silently greys out the button with no reason.
-          <p className="text-[11px] text-amber-600 dark:text-amber-400">
-            Select at least one feature set to save — an empty mapping would
-            leave this folder with no tools.
+        {spaceId && fsIds.length === 0 && (
+          // Empty is allowed — explain what it means rather than blocking.
+          <p className="text-[11px] text-[rgb(var(--muted))]">
+            No feature sets selected — this folder gets <strong>no tools</strong>{' '}
+            from this Space. Built-in servers still apply per Space (see Built-in
+            Servers).
           </p>
-        ) : isEdit && dirty && !duplicate ? (
+        )}
+        {isEdit && dirty && !duplicate && (
           <p className="text-[11px] text-amber-600 dark:text-amber-400">
             Unsaved changes — press <strong>Apply changes</strong> to save.
           </p>
-        ) : null}
+        )}
         <div className="flex items-center gap-2">
           <Button
             variant="primary"

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

@@ -26,8 +26,9 @@ use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 /// A binding between a normalized workspace root and the FeatureSet(s) it
-/// resolves to. `feature_set_ids` is non-empty by construction — see
-/// [`WorkspaceBinding::new`] / `new_multi`.
+/// resolves to. `feature_set_ids` MAY be empty — an empty list is a valid
+/// "no Space tools" mapping (the folder still routes to this Space; built-in
+/// servers apply per Space).
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct WorkspaceBinding {
     pub id: Uuid,
@@ -51,9 +52,8 @@ impl WorkspaceBinding {
         Self::new_multi(workspace_root, space_id, vec![feature_set_id.into()])
     }
 
-    /// Construct a binding with one or more FeatureSets. Caller must
-    /// guarantee `feature_set_ids` is non-empty; the storage layer rejects
-    /// empties with a validation error.
+    /// Construct a binding with zero or more FeatureSets. An empty list is
+    /// allowed and persists as a "no Space tools" mapping.
     pub fn new_multi(
         workspace_root: impl Into<String>,
         space_id: Uuid,

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

@@ -198,12 +198,9 @@ impl WorkspaceBindingRepository for SqliteWorkspaceBindingRepository {
     }
 
     async fn create(&self, binding: &WorkspaceBinding) -> Result<()> {
-        if binding.feature_set_ids.is_empty() {
-            anyhow::bail!(
-                "WorkspaceBinding {} must have at least one feature_set_id",
-                binding.id
-            );
-        }
+        // An empty feature_set_ids is allowed: it means "this folder gets no
+        // Space tools" (built-in servers still apply per Space). The junction
+        // simply ends up with zero rows.
         let db = self.db.lock().await;
         let conn = db.connection();
 
@@ -225,12 +222,9 @@ impl WorkspaceBindingRepository for SqliteWorkspaceBindingRepository {
     }
 
     async fn update(&self, binding: &WorkspaceBinding) -> Result<()> {
-        if binding.feature_set_ids.is_empty() {
-            anyhow::bail!(
-                "WorkspaceBinding {} must have at least one feature_set_id",
-                binding.id
-            );
-        }
+        // Empty feature_set_ids is allowed — see `create`. Updating to empty
+        // clears the junction (the folder keeps the binding but gets no Space
+        // tools).
         let db = self.db.lock().await;
         let conn = db.connection();
 
@@ -394,12 +388,17 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_create_rejects_empty_fs_list() {
+    async fn test_create_allows_empty_fs_list() {
+        // An empty feature_set_ids is a valid "no Space tools" mapping — the
+        // folder keeps the binding (so it routes to this Space) but gets no
+        // Space tools; built-in servers still apply per Space. It round-trips
+        // as an empty list.
         let (repo, space_id, _) = fixture().await;
         let root = if cfg!(windows) { "d:\\empty" } else { "/empty" };
         let binding = WorkspaceBinding::new_multi(root, space_id, vec![]);
-        let err = repo.create(&binding).await.unwrap_err();
-        assert!(err.to_string().contains("at least one feature_set_id"));
+        repo.create(&binding).await.unwrap();
+        let got = repo.get(&binding.id).await.unwrap().unwrap();
+        assert!(got.feature_set_ids.is_empty());
     }
 
     #[tokio::test]

tests/rust/tests/integration/effective_features.rs

@@ -22,7 +22,7 @@ use mcpmux_core::{
     normalize_workspace_root, FeatureSet, FeatureSetRepository, MemberMode, ServerFeature,
     ServerFeatureRepository, SpaceRepository, WorkspaceBinding, WorkspaceBindingRepository,
 };
-use mcpmux_gateway::services::{FeatureSetResolverService, SessionRootsRegistry};
+use mcpmux_gateway::services::{FeatureSetResolverService, ResolutionSource, SessionRootsRegistry};
 use mcpmux_gateway::{FeatureService, PrefixCacheService};
 use mcpmux_storage::{
     Database, InboundClientRepository, SqliteFeatureSetRepository, SqliteServerFeatureRepository,
@@ -176,6 +176,35 @@ async fn mapping_determines_effective_tools_per_session() {
     );
 }
 
+/// An *empty* mapping (a binding with zero feature sets) is valid: the session
+/// routes to the Space (source = WorkspaceBinding) but sees zero Space tools.
+/// Built-in servers (gated per Space) are layered on by the request handler and
+/// aren't part of get_tools_for_grants.
+#[tokio::test(flavor = "multi_thread")]
+async fn empty_mapping_yields_zero_effective_tools() {
+    let ctx = Ctx::new().await;
+    let root = if cfg!(windows) {
+        "d:\\work\\none"
+    } else {
+        "/work/none"
+    };
+    ctx.binding_repo
+        .create(&WorkspaceBinding::new_multi(
+            normalize_workspace_root(root),
+            ctx.space_id,
+            vec![],
+        ))
+        .await
+        .unwrap();
+    ctx.session_roots.set("sess", [root]);
+    ctx.session_roots.set_roots_capable("sess", true);
+
+    let resolved = ctx.resolver.resolve(Some("sess"), None).await.unwrap();
+    assert_eq!(resolved.source, ResolutionSource::WorkspaceBinding);
+    assert!(resolved.feature_set_ids.is_empty());
+    assert!(ctx.effective_tools("sess").await.is_empty());
+}
+
 /// A reported root with no mapping resolves to Deny → empty feature-set list
 /// → zero effective tools. (The gateway then appends the `mcpmux_*` Tool
 /// Optimization tools only when that switch is on — covered in meta_tools.)