gateway: reject revoked clients immediately instead of on token expiry

- oauth_middleware: check the client still exists in inbound_clients on
  every request, not just at JWT-signature-verify time. A deleted/revoked
  client now gets a clean 401 on its next call instead of continuing to
  work until the JWT naturally expires.
- mcp_notifier: drop a deleted client's live session bookkeeping
  immediately on ClientDeleted instead of waiting for the lazy
  is_transport_closed() GC pass, so it stops receiving notification
  fanout right away.

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

Author: crimsonsunset

crates/mcpmux-gateway/src/consumers/mcp_notifier.rs

@@ -330,6 +330,41 @@ impl MCPNotifier {
         );
     }
 
+    /// Drop bookkeeping for every live session belonging to a deleted client.
+    ///
+    /// rmcp doesn't expose a way to forcibly close a `Peer`'s underlying
+    /// transport from here (only `RunningService`, which we don't hold, can
+    /// do that) — so this can't hang up the socket. What it *can* do is stop
+    /// fanning out further notifications to it immediately, instead of
+    /// waiting on the lazy `is_transport_closed()` GC pass. The actual
+    /// connection gets cut on the client's next request via the DB-backed
+    /// revocation check in `oauth_middleware`.
+    fn drop_sessions_for_client(&self, client_id: &str) {
+        let removed: Vec<String> = {
+            let mut sessions = self.sessions.write();
+            let dead: Vec<String> = sessions
+                .iter()
+                .filter(|(_, e)| e.client_id == client_id)
+                .map(|(sid, _)| sid.clone())
+                .collect();
+            for sid in &dead {
+                sessions.remove(sid);
+            }
+            dead
+        };
+        if removed.is_empty() {
+            return;
+        }
+        for sid in &removed {
+            self.feature_set_resolver.session_roots().remove(sid);
+        }
+        info!(
+            %client_id,
+            removed = removed.len(),
+            "[MCPNotifier] 🗑️ Dropped sessions for deleted client"
+        );
+    }
+
     /// Unregister a session.
     ///
     /// Called when a client disconnects or the session closes.
@@ -523,6 +558,14 @@ impl MCPNotifier {
     /// This is enterprise-grade: consumers interpret events based on their context,
     /// not producers dictating what to do.
     async fn handle_event(&self, event: DomainEvent) {
+        // Revocation teardown runs ahead of (and regardless of) the
+        // capability-change filter below: a deleted client never implies a
+        // list_changed notification, but we still want its bookkeeping gone
+        // immediately rather than waiting for the next lazy GC pass.
+        if let DomainEvent::ClientDeleted { ref client_id } = event {
+            self.drop_sessions_for_client(client_id);
+        }
+
         // Only handle events that affect MCP capabilities
         if !event.affects_mcp_capabilities() {
             trace!(

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

@@ -123,6 +123,33 @@ pub async fn mcp_oauth_middleware(
     // key); when auth is disabled, fall back to an anonymous identity on the
     // default space.
     let authed_client_id = claims.map(|c| c.client_id).or(api_key_client_id);
+
+    // Revocation check: a JWT access token is a stateless, self-contained
+    // credential that stays cryptographically valid until it expires —
+    // deleting the client in the UI doesn't invalidate tokens it already
+    // issued. Confirm the client row still exists on every request so a
+    // revoked client is rejected on its very next call instead of continuing
+    // to work until natural token expiry.
+    let authed_client_id = match authed_client_id {
+        Some(cid) => match services
+            .dependencies
+            .inbound_client_repo
+            .get_client(&cid)
+            .await
+        {
+            Ok(Some(_)) => Some(cid),
+            Ok(None) => {
+                warn!(trace_id = %trace_id, client_id = %cid, "Client no longer registered (revoked) — rejecting");
+                None
+            }
+            Err(e) => {
+                warn!(trace_id = %trace_id, client_id = %cid, "Client lookup failed: {}", e);
+                None
+            }
+        },
+        None => None,
+    };
+
     let (client_id, space_id) = if let Some(cid) = authed_client_id {
         match services
             .space_resolver_service