AI: instant SIGKILL replaces 5s graceful shutdown

App shutdown was slow, and the Settings UI froze when stopping the server. This commit should fix this.

- Replace `stop_process` (SIGTERM → 5s poll → SIGKILL) with `kill_process` (instant SIGKILL) and `kill_and_reap_in_background` (SIGKILL + bg thread `waitpid`)
- llama-server is stateless — macOS reclaims all GPU/Metal/mmap resources on process death regardless of signal (llama.cpp's own test suite uses SIGKILL)
- App quit and orphan cleanup use fire-and-forget `kill_process`; normal stop/switch use `kill_and_reap_in_background` to avoid zombie accumulation
- Fixes: close button freezing for ~5s, UI freeze when switching from "Local LLM" to "Cloud / API" in settings

Author: vdavid

apps/desktop/src-tauri/src/ai/CLAUDE.md

@@ -15,7 +15,7 @@ Three provider modes:
 | `manager.rs` | Central coordinator. Global `Mutex<Option<ManagerState>>` singleton. Most Tauri commands live here. Stores provider + OpenAI config in `ManagerState`. |
 | `download.rs` | HTTP streaming download with Range-based resume. Emits `ai-download-progress` events (200ms throttle). Cooperative cancellation via function parameter (`Fn() -> bool`). |
 | `extract.rs` | Copies bundled `llama-server` binary + dylibs from `resources/ai/` to the AI data dir. Sets Unix permissions, handles symlinks. |
-| `process.rs` | Spawns child process with `DYLD_LIBRARY_PATH` set. SIGTERM -> 5s wait -> SIGKILL. Port discovery via `bind(:0)`. Takes `ctx_size` param. |
+| `process.rs` | Spawns child process with `DYLD_LIBRARY_PATH` set. Instant SIGKILL to stop (llama-server is stateless; macOS reclaims all GPU/mmap resources). `kill_process` for fire-and-forget (quit, orphans), `kill_and_reap_in_background` for normal operation (reaps zombie in bg thread). Port discovery via `bind(:0)`. Takes `ctx_size` param. |
 | `client.rs` | reqwest client with `AiBackend` enum: `Local { port }` or `OpenAi { api_key, base_url, model }`. Routes requests accordingly. |
 | `suggestions.rs` | Builds few-shot prompt from listing cache, routes to configured backend, sanitizes response. |
 

apps/desktop/src-tauri/src/ai/manager.rs

@@ -8,8 +8,8 @@
 use super::download::{cleanup_partial, download_file};
 use super::extract::{LLAMA_SERVER_BINARY, REQUIRED_DYLIB, extract_bundled_llama_server};
 use super::process::{
-    SERVER_LOG_FILENAME, find_available_port, is_process_alive, log_diagnostics, read_log_tail, spawn_llama_server,
-    stop_process,
+    SERVER_LOG_FILENAME, find_available_port, is_process_alive, kill_and_reap_in_background, kill_process,
+    log_diagnostics, read_log_tail, spawn_llama_server,
 };
 use super::{AiState, AiStatus, ModelInfo, get_default_model, get_model_by_id, is_local_ai_supported};
 use crate::ignore_poison::IgnorePoison;
@@ -79,7 +79,7 @@ pub fn init<R: Runtime>(app: &AppHandle<R>) {
     {
         if is_process_alive(pid) {
             log::info!("AI manager: stopping orphaned llama-server (PID {pid}) from previous session");
-            stop_process(pid);
+            kill_process(pid); // Can't reap — it's a child of the old app process, not ours
         } else {
             log::debug!("AI manager: clearing dead PID {pid} from previous session");
         }
@@ -97,12 +97,13 @@ pub fn init<R: Runtime>(app: &AppHandle<R>) {
 }
 
 /// Shuts down the AI server. Called on app quit.
+/// Fire-and-forget SIGKILL — the app is exiting so no need to reap the zombie.
 pub fn shutdown() {
     let mut manager = MANAGER.lock_ignore_poison();
     if let Some(ref mut m) = *manager
         && let Some(pid) = m.child_pid.take()
     {
-        stop_process(pid);
+        kill_process(pid);
     }
 }
 
@@ -199,7 +200,7 @@ pub fn cancel_ai_download() {
 }
 
 /// Uninstalls the AI model and binary, resets state.
-/// Async because `stop_process` can block up to 5 seconds (SIGTERM + wait + SIGKILL).
+/// Async because file deletion may block briefly.
 #[tauri::command]
 pub async fn uninstall_ai() {
     tauri::async_runtime::spawn_blocking(uninstall_ai_sync).await.ok();
@@ -210,7 +211,7 @@ fn uninstall_ai_sync() {
     if let Some(ref mut m) = *manager {
         // Stop server if running
         if let Some(pid) = m.child_pid.take() {
-            stop_process(pid);
+            kill_and_reap_in_background(pid);
         }
 
         // Delete files
@@ -517,7 +518,7 @@ pub fn configure_ai<R: Runtime>(
         if let Some(ref mut m) = *manager
             && let Some(pid) = m.child_pid.take()
         {
-            stop_process(pid);
+            kill_and_reap_in_background(pid);
             m.state.port = None;
             m.state.pid = None;
             save_state(&m.ai_dir, &m.state);
@@ -557,7 +558,7 @@ pub fn stop_ai_server() {
         && let Some(pid) = m.child_pid.take()
     {
         log::info!("AI: stopping server (PID {pid})");
-        stop_process(pid);
+        kill_and_reap_in_background(pid);
         m.state.port = None;
         m.state.pid = None;
         save_state(&m.ai_dir, &m.state);

apps/desktop/src-tauri/src/ai/process.rs

@@ -102,40 +102,34 @@ pub fn find_available_port() -> Option<u16> {
         .map(|addr| addr.port())
 }
 
-/// Gracefully stops a process by PID, escalating to SIGKILL if needed.
-pub fn stop_process(pid: u32) {
+/// Sends SIGKILL to a process. Returns immediately (~0.5ms).
+///
+/// Use for fire-and-forget scenarios (app quit, orphan cleanup from previous sessions).
+/// llama-server is stateless — SIGKILL is safe. macOS reclaims all GPU/Metal/mmap resources
+/// on process death regardless of signal. The llama.cpp test suite itself uses SIGKILL.
+pub fn kill_process(pid: u32) {
     #[cfg(unix)]
-    {
-        use std::time::Duration;
-
-        // Send SIGTERM
-        unsafe {
-            libc::kill(pid as i32, libc::SIGTERM);
-        }
-
-        // Wait up to 5s for graceful shutdown
-        let start = std::time::Instant::now();
-        while start.elapsed() < Duration::from_secs(5) {
-            // Check if process is still alive
-            let result = unsafe { libc::kill(pid as i32, 0) };
-            if result != 0 {
-                return; // Process is gone
-            }
-            std::thread::sleep(Duration::from_millis(100));
-        }
-
-        // Force kill
-        unsafe {
-            libc::kill(pid as i32, libc::SIGKILL);
-        }
+    unsafe {
+        libc::kill(pid as i32, libc::SIGKILL);
     }
-
     #[cfg(not(unix))]
     {
         let _ = pid;
     }
 }
 
+/// Sends SIGKILL and reaps the zombie in a background thread.
+///
+/// Use during normal operation (settings switch, explicit stop) so zombies don't
+/// accumulate over long-running sessions.
+pub fn kill_and_reap_in_background(pid: u32) {
+    kill_process(pid);
+    #[cfg(unix)]
+    std::thread::spawn(move || unsafe {
+        libc::waitpid(pid as i32, std::ptr::null_mut(), 0);
+    });
+}
+
 /// Returns true if the process with the given PID is still running.
 pub fn is_process_alive(pid: u32) -> bool {
     #[cfg(unix)]