fix(gateway): close review gaps on cache, signals, and detached stop

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

Author: crimsonsunset

apps/desktop/src-tauri/src/lib.rs

@@ -12,11 +12,11 @@ mod commands;
 mod macos_dock;
 mod macos_permissions;
 mod main_window;
-#[cfg(unix)]
-mod unix_signal;
 mod services;
 mod state;
 mod tray;
+#[cfg(unix)]
+mod unix_signal;
 
 // Re-export deep link handler
 use commands::oauth::{route_or_buffer_deep_link, PendingInitialDeepLink};
@@ -900,7 +900,9 @@ pub fn run() {
                 tauri::async_runtime::spawn(async move {
                     #[cfg(unix)]
                     {
-                        crate::unix_signal::wait_for_term().await;
+                        if !crate::unix_signal::wait_for_term().await {
+                            return;
+                        }
                     }
                     #[cfg(windows)]
                     {

apps/desktop/src-tauri/src/unix_signal.rs

@@ -17,21 +17,22 @@ static PIPE_WRITE_FD: AtomicI32 = AtomicI32::new(-1);
 
 /// Install the recorder and wait until SIGTERM or SIGINT arrives.
 ///
-/// Returns after the first termination signal. Caller should then exit.
-pub async fn wait_for_term() {
+/// Returns `true` after the first termination signal. Returns `false` if the
+/// handler could not be installed — the caller must not treat that as exit.
+pub async fn wait_for_term() -> bool {
     let read_end = match install() {
         Ok(fd) => fd,
         Err(e) => {
             tracing::warn!("[Signal] Failed to install SA_SIGINFO handler: {e}");
-            return;
+            return false;
         }
     };
 
     let mut reader = match tokio::net::UnixStream::from_std(read_end) {
         Ok(s) => s,
         Err(e) => {
             tracing::warn!("[Signal] Failed to wrap self-pipe: {e}");
-            return;
+            return false;
         }
     };
     let mut buf = [0u8; 1];
@@ -43,7 +44,11 @@ pub async fn wait_for_term() {
     let sender = SENDER_PID.load(Ordering::SeqCst);
     let sig = SIGNAL_NO.load(Ordering::SeqCst);
     let code = SIGNAL_CODE.load(Ordering::SeqCst);
-    let name = if sig == libc::SIGINT { "SIGINT" } else { "SIGTERM" };
+    let name = if sig == libc::SIGINT {
+        "SIGINT"
+    } else {
+        "SIGTERM"
+    };
 
     info!(
         pid,
@@ -54,6 +59,7 @@ pub async fn wait_for_term() {
         si_code = code,
         "[Signal] {name} — requesting exit"
     );
+    true
 }
 
 fn install() -> std::io::Result<UnixStream> {

crates/mcpmux-gateway/src/pool/features/resolution.rs

@@ -37,14 +37,21 @@ fn apply_mode_to_set(
 /// the hit so tools/prompts/resources share one entry.
 type ResolutionCacheKey = (String, Vec<String>);
 
+/// Resolved features plus an invalidation generation so a miss cannot
+/// republish a pre-event snapshot after the listener has already cleared.
+struct ResolutionCache {
+    generation: u64,
+    entries: HashMap<ResolutionCacheKey, Vec<ServerFeature>>,
+}
+
 /// Handles feature set resolution and permission evaluation
 pub struct FeatureResolutionService {
     feature_repo: Arc<dyn ServerFeatureRepository>,
     feature_set_repo: Arc<dyn FeatureSetRepository>,
     prefix_cache: Arc<PrefixCacheService>,
     /// Resolved (allow/exclude + prefix) features, invalidated when
     /// [`DomainEvent::affects_mcp_capabilities`] is true.
-    cache: Arc<RwLock<HashMap<ResolutionCacheKey, Vec<ServerFeature>>>>,
+    cache: Arc<RwLock<ResolutionCache>>,
 }
 
 impl FeatureResolutionService {
@@ -57,7 +64,10 @@ impl FeatureResolutionService {
             feature_repo,
             feature_set_repo,
             prefix_cache,
-            cache: Arc::new(RwLock::new(HashMap::new())),
+            cache: Arc::new(RwLock::new(ResolutionCache {
+                generation: 0,
+                entries: HashMap::new(),
+            })),
         }
     }
 
@@ -102,14 +112,17 @@ impl FeatureResolutionService {
     }
 
     async fn invalidate_space(&self, space_id: &str) {
-        self.cache
-            .write()
-            .await
+        let mut cache = self.cache.write().await;
+        cache.generation = cache.generation.wrapping_add(1);
+        cache
+            .entries
             .retain(|(cached_space, _), _| cached_space != space_id);
     }
 
     async fn invalidate_all(&self) {
-        self.cache.write().await.clear();
+        let mut cache = self.cache.write().await;
+        cache.generation = cache.generation.wrapping_add(1);
+        cache.entries.clear();
     }
 
     /// Get all available features for a space (optionally filtered by type)
@@ -152,16 +165,25 @@ impl FeatureResolutionService {
         sorted_ids.sort();
         let key = (space_id.to_string(), sorted_ids);
 
-        if let Some(cached) = self.cache.read().await.get(&key).cloned() {
-            return Ok(Self::apply_type_filter(cached, filter_type));
-        }
+        let generation = {
+            let cache = self.cache.read().await;
+            if let Some(cached) = cache.entries.get(&key).cloned() {
+                return Ok(Self::apply_type_filter(cached, filter_type));
+            }
+            cache.generation
+        };
 
         // ponytail: concurrent misses recompute; single-flight if cold-start
         // stampede shows up.
         let resolved = self
             .resolve_feature_sets_uncached(space_id, feature_set_ids)
             .await?;
-        self.cache.write().await.insert(key, resolved.clone());
+        {
+            let mut cache = self.cache.write().await;
+            if cache.generation == generation {
+                cache.entries.insert(key, resolved.clone());
+            }
+        }
         Ok(Self::apply_type_filter(resolved, filter_type))
     }