feat(gateway): Phase 2 — repo-name matching for declared rootless roots

Autonomous decisions:
- Match workspace_root basenames only (not Bundle display names) — simpler query via existing list() scan
- ASCII case-insensitive basename comparison — aligns with Windows-normalized paths and tolerates cloud declare casing drift

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

Author: crimsonsunset

crates/mcpmux-core/src/repository/mod.rs

@@ -311,6 +311,17 @@ pub trait WorkspaceBindingRepository: Send + Sync {
         candidate_roots: &[String],
     ) -> RepoResult<Option<WorkspaceBinding>>;
 
+    /// Best-effort basename match for declared workspace roots.
+    ///
+    /// Compares the last path segment of each candidate against path-type
+    /// bindings' `workspace_root` basenames (ASCII case-insensitive). Does not
+    /// change exact-match semantics — used only for rootless declare-root
+    /// fall-through when no exact path binding matched.
+    async fn find_by_basename_for_roots(
+        &self,
+        candidate_roots: &[String],
+    ) -> RepoResult<Option<WorkspaceBinding>>;
+
     /// Exact match for a machine-scoped binding on `workspace_root`.
     ///
     /// Matches bindings where `machine_id` equals the given value AND either:

crates/mcpmux-gateway/src/services/feature_set_resolver.rs

@@ -531,9 +531,33 @@ impl FeatureSetResolverService {
                 if roots_capable_known == Some(false) {
                     // True rootless client declared a root (e.g. via
                     // `mcpmux_set_workspace_root`) but it didn't exact-match any
-                    // binding — fall through to Tier 3 grant lookup instead of
-                    // hard-denying. The pre-Tier-3 gate treats the declared root
-                    // as the identity signal it was waiting for.
+                    // binding — try repo-name (basename) match, then fall through
+                    // to Tier 3 grant lookup. The pre-Tier-3 gate treats the
+                    // declared root as the identity signal it was waiting for.
+                    if let Some(binding) = self
+                        .binding_repo
+                        .find_by_basename_for_roots(&reported_roots)
+                        .await?
+                    {
+                        if Self::binding_matches_space_lock(&binding, space_lock) {
+                            debug!(
+                                workspace_root = %binding.workspace_root,
+                                space_id = %binding.space_id,
+                                feature_sets = ?binding.feature_set_ids,
+                                "[FeatureSetResolver] rootless session resolved via basename WorkspaceBinding",
+                            );
+                            return Ok(ResolvedFeatureSet {
+                                feature_set_ids: binding.feature_set_ids,
+                                space_id: Some(binding.space_id),
+                                source: ResolutionSource::WorkspaceBinding,
+                            });
+                        }
+                        debug!(
+                            binding_space = %binding.space_id,
+                            ?space_lock,
+                            "[FeatureSetResolver] basename binding outside locked Space — ignored",
+                        );
+                    }
                     debug!(
                         session_id = %sid,
                         "[FeatureSetResolver] rootless session declared root but no binding matched — fall through to Tier 3",

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

@@ -162,6 +162,20 @@ impl SqliteWorkspaceBindingRepository {
     const SELECT_COLS: &'static str =
         "id, workspace_root, space_id, created_at, updated_at, client_id, machine_id, label, icon, binding_type";
 
+    /// Last path segment of a normalized workspace root for basename matching.
+    fn workspace_root_basename(normalized: &str) -> Option<String> {
+        if normalized.is_empty() {
+            return None;
+        }
+        let sep = if normalized.contains('\\') { '\\' } else { '/' };
+        normalized
+            .trim_end_matches(sep)
+            .rsplit(sep)
+            .next()
+            .filter(|segment| !segment.is_empty())
+            .map(str::to_ascii_lowercase)
+    }
+
     /// Fetch bindings + their FeatureSet lists in two queries.
     /// `where_clause` is appended to the binding SELECT (use `""` for none);
     /// `string_params` are bound to its placeholders in order.
@@ -326,6 +340,30 @@ impl WorkspaceBindingRepository for SqliteWorkspaceBindingRepository {
         Ok(None)
     }
 
+    async fn find_by_basename_for_roots(
+        &self,
+        candidate_roots: &[String],
+    ) -> Result<Option<WorkspaceBinding>> {
+        if candidate_roots.is_empty() {
+            return Ok(None);
+        }
+
+        let bindings = self.list().await?;
+        for root in candidate_roots {
+            let Some(declared) = Self::workspace_root_basename(root) else {
+                continue;
+            };
+            if let Some(binding) = bindings.iter().find(|b| {
+                b.binding_type == BindingType::Path
+                    && Self::workspace_root_basename(&b.workspace_root)
+                        .is_some_and(|basename| basename == declared)
+            }) {
+                return Ok(Some(binding.clone()));
+            }
+        }
+        Ok(None)
+    }
+
     async fn find_exact_for_machine(
         &self,
         machine_id: &Uuid,

tests/rust/tests/integration/feature_set_resolver.rs

@@ -624,6 +624,72 @@ async fn rootless_declared_unmatched_root_falls_through_to_grant() {
     assert_eq!(r.feature_set_ids, vec![f.fs_a_id]);
 }
 
+#[tokio::test]
+async fn rootless_declared_root_basename_match_routes_to_binding_not_grant() {
+    // Phase 2: a declared cloud path whose basename matches a desktop binding
+    // resolves to that binding's FeatureSet(s), not the blanket grant.
+    let f = Fixture::new().await;
+    let client_id = "rootless.example/basename-match";
+    f.make_client(client_id).await;
+    f.client_repo
+        .grant_feature_set(client_id, &f.space_id.to_string(), &f.starter_fs_id)
+        .await
+        .unwrap();
+
+    let desktop_root = if cfg!(windows) {
+        "d:\\users\\joe\\desktop\\repos\\personal\\mcp-mux"
+    } else {
+        "/Users/joe/Desktop/Repos/Personal/mcp-mux"
+    };
+    f.binding_repo
+        .create(&WorkspaceBinding::new(
+            normalize_workspace_root(desktop_root),
+            f.space_id,
+            f.fs_a_id.clone(),
+        ))
+        .await
+        .unwrap();
+
+    let cloud_root = if cfg!(windows) {
+        "d:\\workspace\\mcp-mux"
+    } else {
+        "/workspace/mcp-mux"
+    };
+    f.session_roots.set_roots_capable("s", false);
+    f.session_roots.set("s", [cloud_root]);
+    let r = f
+        .resolver
+        .resolve(Some("s"), Some(client_id), None)
+        .await
+        .unwrap();
+    assert_eq!(r.source, ResolutionSource::WorkspaceBinding);
+    assert_eq!(r.feature_set_ids, vec![f.fs_a_id]);
+    assert_ne!(r.feature_set_ids, vec![f.starter_fs_id]);
+}
+
+#[tokio::test]
+async fn rootless_declared_unmatched_root_without_grant_is_unbound() {
+    // Regression: basename miss with no grant still denies (Phase 1 + Phase 2).
+    let f = Fixture::new().await;
+    let client_id = "rootless.example/no-grant-unmatched";
+    f.make_client(client_id).await;
+
+    let cloud_root = if cfg!(windows) {
+        "d:\\workspace\\unknown-repo"
+    } else {
+        "/workspace/unknown-repo"
+    };
+    f.session_roots.set_roots_capable("s", false);
+    f.session_roots.set("s", [cloud_root]);
+    let r = f
+        .resolver
+        .resolve(Some("s"), Some(client_id), None)
+        .await
+        .unwrap();
+    assert_eq!(r.source, ResolutionSource::Unbound);
+    assert!(r.feature_set_ids.is_empty());
+}
+
 #[tokio::test]
 async fn roots_capable_unmapped_root_stays_unbound_not_grant() {
     // Regression: Tier 1b hard-deny for roots-capable sessions is unchanged.