Fix reconnect placing response before latest user message

When reconnecting to a service, runReconnectLoop was using
messages.last(where: .assistant) which could find an assistant message
from a *previous* exchange and write the new response into it — placing
it before the most recent user message.

Fix: only reuse an existing assistant message if it's already at the
tail of the messages array. Since each user message gets a fresh service,
if the last message is a user message a new assistant message must always
be created after it.

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

Author: mcintyre94

Wisp/ViewModels/ChatViewModel.swift

@@ -1063,7 +1063,11 @@ final class ChatViewModel {
         if let existing = currentAssistantMessage {
             assistantMessage = existing
             if !hasPriorEvents { assistantMessage.content = [] }
-        } else if let last = messages.last(where: { $0.role == .assistant }) {
+        } else if let last = messages.last, last.role == .assistant {
+            // Only reuse an assistant message if it's already at the tail — meaning
+            // the last exchange ended with a partial response that needs replaying.
+            // If the last message is a user message, fall through to create a new
+            // assistant message after it (each service is scoped to one user message).
             assistantMessage = last
             if !hasPriorEvents { assistantMessage.content = [] }
             currentAssistantMessage = last

WispTests/ChatViewModelTests.swift

@@ -1117,6 +1117,53 @@ struct ChatViewModelTests {
         }
     }
 
+    // MARK: - runReconnectLoop: assistant message placement
+
+    @Test func runReconnectLoop_appendsAssistantAfterLatestUserMessage() async throws {
+        // Regression: messages.last(where: .assistant) would find a *previous* exchange's
+        // assistant message and write the new response into it, placing it before the latest
+        // user message. The fix checks messages.last only, so a new assistant message is
+        // always created after the most recent user message.
+        let ctx = try makeModelContext()
+        let (vm, _) = makeChatViewModel(modelContext: ctx)
+
+        // Simulate a completed prior exchange already in messages
+        let prevUser = ChatMessage(role: .user, content: [.text("first question")])
+        let prevAssistant = ChatMessage(role: .assistant, content: [.text("first answer")])
+        let newUser = ChatMessage(role: .user, content: [.text("second question")])
+        vm.messages = [prevUser, prevAssistant, newUser]
+
+        let textLine = #"{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"second answer"}]}}"# + "\n"
+        let resultLine = #"{"type":"result","session_id":"s1","subtype":"success"}"# + "\n"
+        let stream = AsyncThrowingStream<ServiceLogEvent, Error> { continuation in
+            continuation.yield(ServiceLogEvent(type: .stdout, data: textLine, exitCode: nil, timestamp: nil, logFiles: nil))
+            continuation.yield(ServiceLogEvent(type: .stdout, data: resultLine, exitCode: nil, timestamp: nil, logFiles: nil))
+            continuation.finish()
+        }
+        let mock = MockServiceLogsProvider(streams: [stream], statuses: ["stopped"])
+
+        await vm.runReconnectLoop(apiClient: mock, modelContext: ctx, serviceAlreadyStopped: true)
+
+        // Should have 4 messages: prevUser, prevAssistant, newUser, newAssistant
+        #expect(vm.messages.count == 4)
+        #expect(vm.messages[0].role == .user)
+        #expect(vm.messages[1].role == .assistant)
+        #expect(vm.messages[2].role == .user)
+        #expect(vm.messages[3].role == .assistant)
+        // New response lands in the new assistant message, not the previous one
+        if case .text(let text) = vm.messages[3].content.first {
+            #expect(text == "second answer")
+        } else {
+            Issue.record("Expected text in new assistant message")
+        }
+        // Prior assistant message content is untouched
+        if case .text(let text) = vm.messages[1].content.first {
+            #expect(text == "first answer")
+        } else {
+            Issue.record("Expected prior assistant message to be unchanged")
+        }
+    }
+
     // MARK: - reconnecting → streaming status transition
 
     @Test func runReconnectLoop_transitionsReconnectingToStreamingOnStdoutData() async throws {