Add app-wide ChatSessionManager to keep streams alive across navigation

Previously ChatViewModel was recreated on every chat switch, cancelling
the active stream and requiring a reconnect on return. ChatSessionManager
is an @observable cache keyed by chat UUID, injected app-wide, so VMs
(and their streams) survive switching chats or navigating between sprites.

switchToChat now looks up the cached VM instead of creating a new one.
The scenePhase handler resumes all cached VMs on foreground, not just the
active one. clearAllChats detaches all VMs before wiping the chat list.

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

Author: mcintyre94

Wisp/App/WispApp.swift

@@ -5,6 +5,7 @@ import SwiftUI
 struct WispApp: App {
     @State private var apiClient = SpritesAPIClient()
     @State private var browserCoordinator = InAppBrowserCoordinator()
+    @State private var chatSessionManager = ChatSessionManager()
     @AppStorage("theme") private var theme: String = "system"
 
     init() {
@@ -27,6 +28,7 @@ struct WispApp: App {
             RootView()
                 .environment(apiClient)
                 .environment(browserCoordinator)
+                .environment(chatSessionManager)
                 .preferredColorScheme(preferredColorScheme)
                 .onChange(of: apiClient.isAuthenticated, initial: true) {
                     browserCoordinator.authToken = apiClient.spritesToken

Wisp/Services/ChatSessionManager.swift

@@ -0,0 +1,58 @@
+import Foundation
+import SwiftData
+
+/// App-wide cache of ChatViewModels, keyed by chat UUID.
+/// Keeps streams alive across chat switches and sprite navigation so connections
+/// are only torn down on explicit actions (interrupt, chat deletion, app termination).
+@Observable
+@MainActor
+final class ChatSessionManager {
+    private var cache: [UUID: ChatViewModel] = [:]
+
+    /// Returns the cached VM for a chat, or creates and loads a new one.
+    func viewModel(
+        for chat: SpriteChat,
+        spriteName: String,
+        apiClient: SpritesAPIClient,
+        modelContext: ModelContext
+    ) -> ChatViewModel {
+        if let existing = cache[chat.id] {
+            return existing
+        }
+        let vm = ChatViewModel(
+            spriteName: spriteName,
+            chatId: chat.id,
+            currentServiceName: chat.currentServiceName,
+            workingDirectory: chat.workingDirectory
+        )
+        vm.loadSession(apiClient: apiClient, modelContext: modelContext)
+        cache[chat.id] = vm
+        return vm
+    }
+
+    func isStreaming(chatId: UUID) -> Bool {
+        cache[chatId]?.isStreaming ?? false
+    }
+
+    /// Called when the app returns to the foreground — reconnects any VM that had a live stream.
+    func resumeAllAfterBackground(apiClient: SpritesAPIClient, modelContext: ModelContext) {
+        for vm in cache.values {
+            vm.resumeAfterBackground(apiClient: apiClient, modelContext: modelContext)
+            vm.reconnectIfNeeded(apiClient: apiClient, modelContext: modelContext)
+        }
+    }
+
+    /// Removes and detaches a VM when its chat is deleted.
+    func remove(chatId: UUID, modelContext: ModelContext) {
+        cache[chatId]?.detach(modelContext: modelContext)
+        cache.removeValue(forKey: chatId)
+    }
+
+    /// Detaches and removes all cached VMs. Call when clearing all chats.
+    func detachAll(modelContext: ModelContext) {
+        for vm in cache.values {
+            vm.detach(modelContext: modelContext)
+        }
+        cache.removeAll()
+    }
+}

Wisp/Views/SpriteDetail/SpriteDetailView.swift

@@ -9,11 +9,11 @@ struct SpriteDetailView: View {
     @State private var checkpointsViewModel: CheckpointsViewModel
     @State private var showChatSwitcher = false
     @State private var showStaleChatsAlert = false
-    @State private var knownStreamingChatIds: Set<UUID> = []
     @State private var showCopiedFeedback = false
     @State private var pendingFork: (checkpointId: String, messageId: UUID)? = nil
     @State private var isForking = false
     @Environment(SpritesAPIClient.self) private var apiClient
+    @Environment(ChatSessionManager.self) private var chatSessionManager
     @Environment(\.modelContext) private var modelContext
     @Environment(\.scenePhase) private var scenePhase
     @Environment(\.horizontalSizeClass) private var sizeClass
@@ -203,15 +203,16 @@ struct SpriteDetailView: View {
         }
         .onChange(of: scenePhase) { _, newPhase in
             if newPhase == .active {
-                chatViewModel?.resumeAfterBackground(apiClient: apiClient, modelContext: modelContext)
-                chatViewModel?.reconnectIfNeeded(apiClient: apiClient, modelContext: modelContext)
+                chatSessionManager.resumeAllAfterBackground(apiClient: apiClient, modelContext: modelContext)
             }
         }
         .sheet(isPresented: $showChatSwitcher) {
             ChatSwitcherSheet(viewModel: chatListViewModel)
         }
         .alert("Sprite Recreated", isPresented: $showStaleChatsAlert) {
             Button("Start Fresh", role: .destructive) {
+                chatSessionManager.detachAll(modelContext: modelContext)
+                chatViewModel = nil
                 chatListViewModel.clearAllChats(apiClient: apiClient, modelContext: modelContext)
                 let chat = chatListViewModel.createChat(modelContext: modelContext)
                 switchToChat(chat)
@@ -240,29 +241,18 @@ struct SpriteDetailView: View {
     private func switchToChat(_ chat: SpriteChat) {
         guard chatViewModel?.chatId != chat.id else { return }
 
-        // Detach old VM (cancel stream but keep service running)
-        if let oldVM = chatViewModel {
-            let wasStreaming = oldVM.detach(modelContext: modelContext)
-            if wasStreaming {
-                knownStreamingChatIds.insert(oldVM.chatId)
-            }
-        }
-
-        let vm = ChatViewModel(
+        // Look up or create a VM from the app-wide cache — old VM keeps streaming in background
+        let vm = chatSessionManager.viewModel(
+            for: chat,
             spriteName: sprite.name,
-            chatId: chat.id,
-            currentServiceName: chat.currentServiceName,
-            workingDirectory: chat.workingDirectory
+            apiClient: apiClient,
+            modelContext: modelContext
         )
-        vm.loadSession(apiClient: apiClient, modelContext: modelContext)
         chatViewModel = vm
         chatListViewModel.activeChatId = chat.id
 
-        // Always try reconnect — checks service status first, so it's
-        // cheap for old chats where the service has already stopped.
-        // This handles both switching between chats and navigating
-        // back to the sprite after the view was destroyed.
-        knownStreamingChatIds.remove(chat.id)
+        // Reconnect if idle with a service that may have new events.
+        // Guards on !isStreaming internally, so safe to call on an already-streaming VM.
         vm.reconnectIfNeeded(apiClient: apiClient, modelContext: modelContext)
     }