fix(resolver): Phase 1 — Root-cause and fix Tier 1 binding mismatch

When X-Mcpmux-Machine-Id names a device with no binding for the reported
root, fall through to client/local machine lookup for identified OAuth
clients instead of skipping straight to Unbound. Preserves tunnel isolation
for anonymous header-only callers.

Autonomous decisions:
- Root cause from live logs + DB: header branch `continue` skipped client
  machine fallback while binding exists on Gondor — likely stale/wrong
  machine header on native Cursor OAuth after Cloud Agents work
- Removed temporary debug instrumentation; kept fix-only diff
- Added client_icon: None to test InboundClient builders (branch WIP field)

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

Author: crimsonsunset

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

@@ -264,6 +264,12 @@ impl FeatureSetResolverService {
         request_machine_id: Option<Uuid>,
     ) -> Result<Option<mcpmux_core::WorkspaceBinding>> {
         for root in roots {
+            let registered_machine = if let Some(cid) = client_id {
+                self.client_repo.get_machine_id(cid).await?
+            } else {
+                None
+            };
+
             if let Some(header_machine) = request_machine_id {
                 if let Some(binding) = self
                     .binding_repo
@@ -275,17 +281,24 @@ impl FeatureSetResolverService {
                 if let Some(binding) = self.binding_repo.find_exact_global(root).await? {
                     return Ok(Some(binding));
                 }
-                continue;
+                // Header-only semantics when the header matches the OAuth
+                // client's registered machine (tunneled caller on the wrong
+                // box stays Unbound) or the caller is anonymous. When the
+                // header disagrees with the registered tag it is treated as
+                // stale — e.g. cloud-agent config on a native localhost
+                // session — and we fall through to client/local/global below.
+                if client_id.is_none() || registered_machine.is_some_and(|m| m == header_machine) {
+                    continue;
+                }
             }
-            if let Some(cid) = client_id {
-                if let Some(client_machine) = self.client_repo.get_machine_id(cid).await? {
-                    if let Some(binding) = self
-                        .binding_repo
-                        .find_exact_for_machine(&client_machine, root, Some(cid))
-                        .await?
-                    {
-                        return Ok(Some(binding));
-                    }
+
+            if let Some(client_machine) = registered_machine {
+                if let Some(binding) = self
+                    .binding_repo
+                    .find_exact_for_machine(&client_machine, root, client_id)
+                    .await?
+                {
+                    return Ok(Some(binding));
                 }
             }
             if let Some(local_id) = *self.local_machine_id.read().await {

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

@@ -606,6 +606,49 @@ mod tests {
         assert!(hits_other.is_empty());
     }
 
+    /// Regression: machine-scoped canonical binding (`client_id IS NULL`) must
+    /// match when the caller passes its OAuth `client_id` for the specific
+    /// lookup — the repo falls back to the machine-only row after no
+    /// client+machine row exists.
+    #[tokio::test]
+    async fn test_find_exact_for_machine_canonical_matches_registered_client() {
+        let (repo, space_id, fs_id) = fixture().await;
+        let db = repo.db.clone();
+        let machine_id = Uuid::new_v4();
+        let client_id = "mcp_36740f70";
+        let root = if cfg!(windows) {
+            "d:\\jsg-tech-check"
+        } else {
+            "/Users/joe/Desktop/Repos/Personal/jsg-tech-check"
+        };
+        let now = Utc::now().to_rfc3339();
+
+        {
+            let guard = db.lock().await;
+            guard
+                .connection()
+                .execute(
+                    "INSERT INTO machines (id, name, created_at, updated_at)
+                     VALUES (?1, 'Gondor', ?2, ?2)",
+                    params![machine_id.to_string(), now],
+                )
+                .unwrap();
+        }
+
+        let binding =
+            WorkspaceBinding::new_machine_scoped_multi(root, space_id, machine_id, vec![fs_id]);
+        repo.create(&binding).await.unwrap();
+
+        let hit = repo
+            .find_exact_for_machine(&machine_id, root, Some(client_id))
+            .await
+            .unwrap()
+            .expect("machine-scoped canonical binding should match registered client");
+        assert_eq!(hit.workspace_root, root);
+        assert_eq!(hit.machine_id, Some(machine_id));
+        assert!(hit.client_id.is_none());
+    }
+
     #[tokio::test]
     async fn test_find_exact_for_roots_is_exact_only() {
         // No ancestor inheritance: a binding on `outer` must NOT match a

tests/rust/tests/database/inbound_client.rs

@@ -40,6 +40,7 @@ fn create_test_client(name: &str) -> InboundClient {
         reports_roots: false,
         roots_capability_known: false,
         machine_id: None,
+        client_icon: None,
     }
 }
 

tests/rust/tests/integration/feature_set_resolver.rs

@@ -196,6 +196,7 @@ impl Fixture {
             reports_roots: false,
             roots_capability_known: false,
             machine_id: None,
+            client_icon: None,
         };
         self.client_repo.save_client(&c).await.unwrap();
     }
@@ -1146,6 +1147,42 @@ async fn request_machine_header_outranks_client_and_local_machine() {
     assert_eq!(with_rohan_header.feature_set_ids, vec![f.fs_b_id]);
 }
 
+#[tokio::test]
+async fn wrong_request_machine_header_falls_back_to_client_machine_binding() {
+    // Native Cursor OAuth can inherit a stale X-Mcpmux-Machine-Id (e.g. Rohan
+    // from a shared tunnel config) while the binding + client tag live on Gondor.
+    let f = Fixture::new().await;
+    let gondor_id = f.make_machine("Gondor").await;
+    let rohan_id = f.make_machine("Rohan").await;
+    let root = normalize_workspace_root(if cfg!(windows) {
+        "d:\\jsg-tech-check"
+    } else {
+        "/Users/joe/Desktop/Repos/Personal/jsg-tech-check"
+    });
+    let client_id = "mcp_36740f70";
+
+    f.make_client(client_id).await;
+    f.client_repo
+        .set_machine_id(client_id, Some(gondor_id))
+        .await
+        .unwrap();
+
+    let mut binding = WorkspaceBinding::new(root.clone(), f.space_id, f.fs_a_id.clone());
+    binding.machine_id = Some(gondor_id);
+    f.binding_repo.create(&binding).await.unwrap();
+
+    f.session_roots.set("s", [root.as_str()]);
+    f.session_roots.set_roots_capable("s", true);
+
+    let resolver = f.resolver_with_local_machine(gondor_id);
+    let r = resolver
+        .resolve(Some("s"), Some(client_id), Some(rohan_id))
+        .await
+        .unwrap();
+    assert_eq!(r.source, ResolutionSource::WorkspaceBinding);
+    assert_eq!(r.feature_set_ids, vec![f.fs_a_id]);
+}
+
 #[tokio::test]
 async fn request_machine_header_enables_deny_when_only_other_machine_bound() {
     let f = Fixture::new().await;

tests/rust/tests/streamable_http/api_key_auth.rs

@@ -109,6 +109,7 @@ impl Harness {
             reports_roots: false,
             roots_capability_known: false,
             machine_id: None,
+            client_icon: None,
         };
         client_repo.save_client(&client).await.expect("save client");
         let key_id = Uuid::new_v4().to_string();

tests/rust/tests/streamable_http/gateway_notifications.rs

@@ -159,6 +159,7 @@ impl TestGateway {
             reports_roots: false,
             roots_capability_known: false,
             machine_id: None,
+            client_icon: None,
         };
         inbound_client_repo
             .save_client(&test_client)