fix(gateway): retry call_tool after a dead backend connection

Widen reconnect beyond auth errors so a silently closed transport
gets one evict+re-resolve+retry, and reject missing feature_set_ids
before the bind FK fires.

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};

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

@@ -43,7 +43,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,

crates/mcpmux-gateway/src/admin/write_runtime.rs

@@ -11,7 +11,9 @@ use tokio::sync::RwLock;
 use tracing::warn;
 use uuid::Uuid;
 
-use crate::pool::transport::resolution::{build_transport_config, TransportResolutionOptions};
+use crate::pool::transport::resolution::{
+    build_transport_config, resolve_auto_connection_context, TransportResolutionOptions,
+};
 use crate::pool::{
     ConnectionContext, ConnectionResult, FeatureService, PoolService, ServerKey, ServerManager,
 };
@@ -180,31 +182,19 @@ impl GatewayWriteRuntime for LiveGatewayWriteRuntime {
 
     async fn retry_connection(&self, space_id: String, server_id: String) -> Result<Value> {
         let space_uuid = Uuid::parse_str(&space_id)?;
-
-        self.pool_service.remove_instance(space_uuid, &server_id);
-
-        let installed = self
-            .installed_server_repo
-            .get_by_server_id(&space_id, &server_id)
-            .await?
-            .ok_or_else(|| anyhow!("Server not found: {space_id}/{server_id}"))?;
-
-        let server_definition = installed
-            .get_definition()
-            .ok_or_else(|| anyhow!("Server {server_id} has no cached definition"))?;
+        let ctx = resolve_auto_connection_context(
+            self.installed_server_repo.as_ref(),
+            Some(&self.data_dir),
+            space_uuid,
+            &server_id,
+        )
+        .await
+        .map_err(|e| anyhow!(e))?;
 
         let key = ServerKey::new(space_uuid, &server_id);
         self.server_manager.set_connecting(&key).await;
 
-        let transport = build_transport_config(
-            &server_definition.transport,
-            &installed,
-            Some(&self.data_dir),
-            TransportResolutionOptions::default(),
-        );
-
-        let ctx = ConnectionContext::auto(space_uuid, server_id.clone(), transport);
-        let result = self.pool_service.connect_server(&ctx).await;
+        let result = self.pool_service.reconnect_fresh(&ctx).await;
 
         match result {
             ConnectionResult::Connected { features, .. } => {

crates/mcpmux-gateway/src/pool/connection.rs

@@ -48,6 +48,13 @@ pub enum ConnectionResult {
     },
 }
 
+impl ConnectionResult {
+    /// True when the attempt produced a live connection (new or reused).
+    pub fn is_connected(&self) -> bool {
+        matches!(self, Self::Connected { .. })
+    }
+}
+
 /// Connection Service handles server connection lifecycle
 pub struct ConnectionService {
     token_service: Arc<TokenService>,

crates/mcpmux-gateway/src/pool/instance.rs

@@ -484,3 +484,41 @@ impl ServerInstance {
         }
     }
 }
+
+#[cfg(test)]
+mod record_stats_tests {
+    use super::{InstanceKey, ServerInstance, TransportType};
+    use std::collections::HashMap;
+    use uuid::Uuid;
+
+    fn test_instance() -> ServerInstance {
+        ServerInstance::new(
+            InstanceKey::stdio(Uuid::new_v4(), "echo", &[], &HashMap::new()),
+            "echo".into(),
+            TransportType::Stdio,
+        )
+    }
+
+    #[test]
+    fn record_failure_increments_consecutive_failures_without_flipping_state() {
+        let instance = test_instance();
+        let before = instance.state();
+        instance.record_failure("mcp error -32000: connection closed");
+        let stats = instance.stats.read();
+        assert_eq!(stats.consecutive_failures, 1);
+        assert_eq!(
+            stats.last_error.as_deref(),
+            Some("mcp error -32000: connection closed")
+        );
+        drop(stats);
+        assert_eq!(instance.state(), before);
+    }
+
+    #[test]
+    fn record_success_increments_requests_served() {
+        let instance = test_instance();
+        instance.record_success();
+        instance.record_success();
+        assert_eq!(instance.stats.read().requests_served, 2);
+    }
+}