Fix orphaned whisper-server processes accumulating across app sessions

Kill stale whisper-server processes before spawning a new one and
terminate the managed server on app exit via applicationShouldTerminate
with terminateLater to ensure async shutdown completes.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jorgensandhaug

macos/Sources/Quedo/AppController.swift

@@ -228,6 +228,7 @@ actor AppControllerActor {
     func shutdown() async {
         await audioEngine.cancelRecording()
         hotkeyManager.deactivate()
+        await transcriptionPipeline.shutdown()
         try? await lifecycle.transition(to: .shuttingDown)
         await pushUI()
     }

macos/Sources/Quedo/AppDelegate.swift

@@ -31,17 +31,23 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         }
     }
 
-    func applicationWillTerminate(_ notification: Notification) {
-        _ = notification
+    func applicationShouldTerminate(_ sender: NSApplication) -> NSApplication.TerminateReply {
         if let didBecomeActiveObserver {
             NotificationCenter.default.removeObserver(didBecomeActiveObserver)
             self.didBecomeActiveObserver = nil
         }
         permissionRecoveryTask?.cancel()
         permissionRecoveryTask = nil
+
+        guard let appController else {
+            return .terminateNow
+        }
+
         Task {
-            await appController?.shutdown()
+            await appController.shutdown()
+            sender.reply(toApplicationShouldTerminate: true)
         }
+        return .terminateLater
     }
 
     private func bootstrap(menuBar: MenuBarController) async {

macos/Sources/QuedoCore/Providers/WhisperCppProvider.swift

@@ -48,6 +48,11 @@ public struct WhisperCppProvider: TranscriptionProvider {
         return try await transcribe(request: request, modelURL: modelURL, runtime: runtime)
     }
 
+    /// Stops any managed whisper-server process.
+    public func shutdownServer() async {
+        await serverManager.shutdown()
+    }
+
     /// Checks if configured whisper.cpp runtime is reachable.
     public func checkHealth(timeoutSeconds: Int) async -> Bool {
         let timeout = max(1, timeoutSeconds)
@@ -433,6 +438,7 @@ private actor WhisperCppServerManager {
         }
 
         stopServer()
+        await killOrphanedServers()
 
         for port in candidatePorts() {
             let baseURL = URL(string: "http://127.0.0.1:\(port)")!
@@ -468,6 +474,21 @@ private actor WhisperCppServerManager {
         throw ProviderError.networkFailure
     }
 
+    func shutdown() {
+        stopServer()
+    }
+
+    private func killOrphanedServers() async {
+        let killProcess = Process()
+        killProcess.executableURL = URL(fileURLWithPath: "/usr/bin/pkill")
+        killProcess.arguments = ["-x", "whisper-server"]
+        killProcess.standardOutput = FileHandle.nullDevice
+        killProcess.standardError = FileHandle.nullDevice
+        try? killProcess.run()
+        // Give processes time to exit and release ports.
+        try? await Task.sleep(for: .milliseconds(200))
+    }
+
     private func stopServer() {
         if let process, process.isRunning {
             process.terminate()

macos/Sources/QuedoCore/TranscriptionPipeline.swift

@@ -159,6 +159,15 @@ public actor TranscriptionPipeline {
         }
     }
 
+    /// Shuts down any provider-managed background processes.
+    public func shutdown() async {
+        for provider in providers.values {
+            if let whisper = provider as? WhisperCppProvider {
+                await whisper.shutdownServer()
+            }
+        }
+    }
+
     /// Performs a provider connectivity probe with 6-second timeout budget.
     public func connectivityCheck(primary: ProviderKind, fallback: ProviderKind) async -> (primaryOK: Bool, fallbackOK: Bool) {
         guard let primaryProvider = providers[primary], let fallbackProvider = providers[fallback] else {