fix(P2): locked client honors in-Space retargeted clientId mapping

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

Author: its-mash

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

@@ -303,13 +303,15 @@ impl FeatureSetResolverService {
     }
 
     /// Resolve a client locked to Space `locked`. The Space is fixed to
-    /// `locked`; the header/roots may still pick the FeatureSet, but only when
-    /// their binding lives in `locked`. A header whose binding resolves to a
-    /// different Space — or no header at all — falls back to `locked`'s Starter.
-    /// A locked client never touches the roots-pending or client-grant tiers.
+    /// `locked`; the header/roots — or the client's own retargeted clientId
+    /// mapping — may still pick the FeatureSet, but only when that binding lives
+    /// in `locked`. A binding that resolves to a different Space (or no binding
+    /// at all) falls back to `locked`'s Starter. A locked client never touches
+    /// the roots-pending or client-grant tiers.
     async fn resolve_locked(
         &self,
         session_id: Option<&str>,
+        client_id: Option<&str>,
         locked: Uuid,
     ) -> Result<ResolvedFeatureSet> {
         if let Some(sid) = session_id {
@@ -337,7 +339,35 @@ impl FeatureSetResolverService {
                 }
             }
         }
-        // No header, or its binding is outside the locked Space → locked Starter.
+        // A locked client may still have its clientId-keyed `id` mapping
+        // retargeted from the Mapping tab. Honor that mapping's FeatureSet — but
+        // only when it stays within the locked Space, preserving
+        // lock-confinement. A mapping pointing out of the Space (or none) falls
+        // through to the locked Starter.
+        if let Some(cid) = client_id {
+            if let Some(binding) = self.binding_repo.find_by_id_key(cid).await? {
+                if binding.space_id == locked {
+                    debug!(
+                        %locked,
+                        client_id = %cid,
+                        "[FeatureSetResolver] locked client — clientId mapping within locked Space",
+                    );
+                    return Ok(ResolvedFeatureSet {
+                        feature_set_ids: binding.feature_set_ids,
+                        space_id: Some(locked),
+                        source: ResolutionSource::WorkspaceBinding,
+                    });
+                }
+                debug!(
+                    %locked,
+                    client_id = %cid,
+                    binding_space = %binding.space_id,
+                    "[FeatureSetResolver] locked client — clientId mapping in a different Space; ignored",
+                );
+            }
+        }
+
+        // No header/mapping within the locked Space → locked Starter.
         self.default_fallback(locked).await
     }
 
@@ -378,7 +408,11 @@ impl FeatureSetResolverService {
         if let Some(cid) = client_id {
             if let Some(locked) = self.client_repo.get_locked_space(cid).await? {
                 match locked.parse::<Uuid>() {
-                    Ok(locked_uuid) => return self.resolve_locked(session_id, locked_uuid).await,
+                    Ok(locked_uuid) => {
+                        return self
+                            .resolve_locked(session_id, client_id, locked_uuid)
+                            .await
+                    }
                     Err(e) => warn!(
                         client_id = %cid,
                         locked_space = %locked,

tests/rust/tests/integration/feature_set_resolver.rs

@@ -975,3 +975,75 @@ async fn locked_client_with_no_header_gets_locked_space_starter() {
     assert_eq!(r.source, ResolutionSource::SpaceDefault);
     assert_eq!(r.feature_set_ids, vec![f.starter_fs_id]);
 }
+
+#[tokio::test]
+async fn locked_client_honors_in_space_retargeted_client_id_mapping() {
+    // A locked client with no header: its clientId-keyed mapping was retargeted
+    // (from the auto-created Starter) to another FeatureSet that still lives in
+    // the locked Space. The resolver must honor that mapping — the Space stays
+    // locked, but the operator's FeatureSet choice is respected.
+    let f = Fixture::new().await;
+    f.make_client("locked-4").await;
+    f.client_repo
+        .set_locked_space("locked-4", Some(&f.space_id.to_string()))
+        .await
+        .unwrap();
+    // Retargeted clientId mapping → a non-Starter FS within the locked Space.
+    f.binding_repo
+        .create(&WorkspaceBinding::new_id(
+            "locked-4",
+            f.space_id,
+            vec![f.fs_a_id.clone()],
+        ))
+        .await
+        .unwrap();
+    // No header; explicitly rootless so we reach the clientId tier.
+    f.session_roots.set_roots_capable("s", false);
+    let r = f
+        .resolver
+        .resolve(Some("s"), Some("locked-4"))
+        .await
+        .unwrap();
+    assert_eq!(r.source, ResolutionSource::WorkspaceBinding);
+    assert_eq!(r.space_id, Some(f.space_id));
+    assert_eq!(r.feature_set_ids, vec![f.fs_a_id]);
+}
+
+#[tokio::test]
+async fn locked_client_ignores_out_of_space_client_id_mapping() {
+    // A locked client whose clientId mapping points at a DIFFERENT Space must be
+    // confined to the locked Space: the out-of-Space mapping is ignored and the
+    // client falls back to the locked Space's Starter (lock-confinement holds).
+    let f = Fixture::new().await;
+    f.make_client("locked-5").await;
+    let other_base = if cfg!(windows) {
+        "d:\\elsewhere"
+    } else {
+        "/elsewhere"
+    };
+    let (other_space, other_starter) = f.make_space_with_base_dir("Elsewhere", other_base).await;
+    f.client_repo
+        .set_locked_space("locked-5", Some(&f.space_id.to_string()))
+        .await
+        .unwrap();
+    // clientId mapping points OUT of the locked Space.
+    f.binding_repo
+        .create(&WorkspaceBinding::new_id(
+            "locked-5",
+            other_space,
+            vec![other_starter],
+        ))
+        .await
+        .unwrap();
+    // No header; explicitly rootless so we reach the clientId tier.
+    f.session_roots.set_roots_capable("s", false);
+    let r = f
+        .resolver
+        .resolve(Some("s"), Some("locked-5"))
+        .await
+        .unwrap();
+    // Confined to the locked (default) Space; the foreign mapping is ignored.
+    assert_eq!(r.space_id, Some(f.space_id));
+    assert_eq!(r.source, ResolutionSource::SpaceDefault);
+    assert_eq!(r.feature_set_ids, vec![f.starter_fs_id]);
+}