fix: prevent race condition in MCP server start

Make singleton enforcement atomic by checking for existing MCP server
inside the register_mcp_serve_process() lock. This prevents two
concurrent start commands from both passing the check and spawning
duplicate processes.

Additional improvements:
- Use std::mem::forget() to document intentional process detachment
- Kill spawned process if registration fails (cleanup on race loss)
- Move singleton check comment from caller to enforcement point

Author: fardeenxyz

src-tauri/src/commands/mcp.rs

@@ -628,14 +628,6 @@ pub async fn mcp_serve(
         }
     };
 
-    // If already running, don't start another one
-    if let Ok(Some(existing)) = registry.0.get_running_mcp_serve() {
-        return Ok(format!(
-            "Claude Code MCP server already running (PID: {})",
-            existing.pid
-        ));
-    }
-
     let mut cmd = create_command_with_env(&claude_path);
     cmd.arg("mcp").arg("serve");
 
@@ -647,13 +639,34 @@ pub async fn mcp_serve(
                 return Err("MCP server started but PID is unavailable".to_string());
             }
 
-            if let Err(e) = registry.0.register_mcp_serve_process(pid) {
-                error!("Failed to register MCP server process: {}", e);
-                return Err(e);
-            }
+            // Intentionally drop the child handle - MCP server runs as detached process.
+            // We track it by PID only, allowing it to outlive the parent process.
+            std::mem::forget(child);
 
-            info!("Successfully started Claude Code MCP server (PID: {})", pid);
-            Ok(format!("Claude Code MCP server started (PID: {})", pid))
+            // Register atomically - will fail if another instance already exists
+            match registry.0.register_mcp_serve_process(pid) {
+                Ok(_run_id) => {
+                    info!("Successfully started Claude Code MCP server (PID: {})", pid);
+                    Ok(format!("Claude Code MCP server started (PID: {})", pid))
+                }
+                Err(e) => {
+                    // Registration failed (likely already running) - kill the process we just started
+                    error!("Failed to register MCP server process: {}", e);
+                    #[cfg(unix)]
+                    {
+                        use std::process::Command;
+                        let _ = Command::new("kill").arg(pid.to_string()).spawn();
+                    }
+                    #[cfg(windows)]
+                    {
+                        use std::process::Command;
+                        let _ = Command::new("taskkill")
+                            .args(["/PID", &pid.to_string(), "/F"])
+                            .spawn();
+                    }
+                    Err(e)
+                }
+            }
         }
         Err(e) => {
             error!("Failed to start MCP server: {}", e);

src-tauri/src/process/registry.rs

@@ -157,9 +157,24 @@ impl ProcessRegistry {
     /// Register a long-running MCP serve process (stores PID only, no child handle)
     ///
     /// NOTE: Only ONE MCP serve process should run at a time (singleton pattern).
-    /// The caller (mcp_serve command) is responsible for checking if a process
-    /// already exists via get_running_mcp_serve() before calling this method.
+    /// This method enforces the singleton by checking atomically within the lock.
     pub fn register_mcp_serve_process(&self, pid: u32) -> Result<i64, String> {
+        // Acquire lock first to make check-and-register atomic (prevents race conditions)
+        let mut processes = self.processes.lock().map_err(|e| e.to_string())?;
+
+        // Check if MCP serve process already exists (atomic with registration)
+        let existing_mcp = processes.values().find(|p| {
+            matches!(p.info.process_type, ProcessType::McpServe)
+        });
+
+        if let Some(existing) = existing_mcp {
+            return Err(format!(
+                "MCP server already running (PID: {})",
+                existing.info.pid
+            ));
+        }
+
+        // Now safe to register new MCP serve process
         let run_id = self.generate_id()?;
 
         let process_info = ProcessInfo {
@@ -172,9 +187,6 @@ impl ProcessRegistry {
             model: "".to_string(),
         };
 
-        // Register without child handle (like sidecar)
-        let mut processes = self.processes.lock().map_err(|e| e.to_string())?;
-
         let process_handle = ProcessHandle {
             info: process_info,
             child: Arc::new(Mutex::new(None)),