fix(mothership): only skip resync for a stream still running

Optimistic markers alone were the skip condition, but a finished turn can leave activeStreamId and its live-assistant message cached when finalization skips detail invalidation for a queued follow-up. That chat would then be excluded from every future resync — permanently, since only a refetch clears the markers, and the resync was the refetch.

Gate the skip on a non-terminal streamSnapshot status so it covers turns that are genuinely still streaming. Exports isTerminalStreamStatus, which was already the private check for this in effective-transcript.

Author: waleedlatif1

apps/sim/hooks/use-mothership-chat-events.test.ts

@@ -453,15 +453,29 @@ describe('resyncMothershipChatCaches', () => {
     )
   })
 
-  it('skips the detail of a chat whose stream this client is rendering locally', () => {
+  it('skips the detail of a chat this client is still streaming', () => {
     expect(
       detailPredicate()({
         messages: [{ id: 'new-stream' }, { id: 'live-assistant:new-stream' }],
         activeStreamId: 'new-stream',
+        streamSnapshot: { events: [], previewSessions: [], status: 'streaming' },
       })
     ).toBe(false)
   })
 
+  it('invalidates a chat whose stream finished but left its optimistic markers cached', () => {
+    const predicate = detailPredicate()
+    const finished = (status: string) => ({
+      messages: [{ id: 'new-stream' }, { id: 'live-assistant:new-stream' }],
+      activeStreamId: 'new-stream',
+      streamSnapshot: { events: [], previewSessions: [], status },
+    })
+
+    expect(predicate(finished('complete'))).toBe(true)
+    expect(predicate(finished('error'))).toBe(true)
+    expect(predicate(finished('cancelled'))).toBe(true)
+  })
+
   it('invalidates details with no active stream, and streams not rendered locally', () => {
     const predicate = detailPredicate()
 

apps/sim/hooks/use-mothership-chat-events.ts

@@ -2,7 +2,10 @@ import { useEffect } from 'react'
 import { createLogger } from '@sim/logger'
 import type { QueryClient } from '@tanstack/react-query'
 import { useQueryClient } from '@tanstack/react-query'
-import { getLiveAssistantMessageId } from '@/lib/copilot/chat/effective-transcript'
+import {
+  getLiveAssistantMessageId,
+  isTerminalStreamStatus,
+} from '@/lib/copilot/chat/effective-transcript'
 import { isChatEnabled } from '@/lib/core/config/env-flags'
 import { suspendDesktopChatScopes } from '@/lib/desktop/chat-scope'
 import { type MothershipChatHistory, mothershipChatKeys } from '@/hooks/queries/mothership-chats'
@@ -38,6 +41,23 @@ function isLocalOptimisticActiveStream(current: MothershipChatHistory | undefine
   return current.messages.some((message) => message.id === liveAssistantId)
 }
 
+/**
+ * True while this client is still rendering a stream for the chat.
+ *
+ * The optimistic markers alone are not enough: a finished turn can leave
+ * `activeStreamId` and its live-assistant message in the cache (finalization
+ * skips detail invalidation when a follow-up is queued), and treating those as
+ * live would exclude the chat from every future resync — permanently, since
+ * only a refetch would clear them. Requiring a non-terminal snapshot status
+ * keeps the skip to turns that are genuinely still streaming.
+ */
+function isStreamingLocally(current: MothershipChatHistory | undefined) {
+  return (
+    isLocalOptimisticActiveStream(current) &&
+    !isTerminalStreamStatus(current?.streamSnapshot?.status)
+  )
+}
+
 /**
  * Returns true when the cached active stream is known to be later in the
  * chronological transcript than the stream that emitted this status event.
@@ -139,10 +159,10 @@ export function handleMothershipChatStatusEvent(
  * delete, or completion. Invalidating the workspace lists and every chat detail
  * reconciles from the server; only queries that are currently mounted refetch.
  *
- * A chat whose stream this client is rendering locally is left alone, for the
- * same reason status events skip it: refetching mid-stream would replace the
- * optimistic transcript with a server copy that does not yet hold the in-flight
- * message. That chat reconciles when its own stream finishes.
+ * A chat this client is still streaming is left alone, for the same reason
+ * status events skip it: refetching mid-stream would replace the optimistic
+ * transcript with a server copy that does not yet hold the in-flight message.
+ * That chat reconciles when its own stream finishes.
  */
 export function resyncMothershipChatCaches(
   queryClient: Pick<QueryClient, 'invalidateQueries'>,
@@ -152,7 +172,7 @@ export function resyncMothershipChatCaches(
   queryClient.invalidateQueries({
     queryKey: mothershipChatKeys.details(),
     predicate: (query) =>
-      !isLocalOptimisticActiveStream(query.state.data as MothershipChatHistory | undefined),
+      !isStreamingLocally(query.state.data as MothershipChatHistory | undefined),
   })
 }
 

apps/sim/lib/copilot/chat/effective-transcript.ts

@@ -52,7 +52,7 @@ function asPayloadRecord(value: unknown): Record<string, unknown> | undefined {
   return isRecordLike(value) ? value : undefined
 }
 
-function isTerminalStreamStatus(status: string | null | undefined): boolean {
+export function isTerminalStreamStatus(status: string | null | undefined): boolean {
   return (
     status === MothershipStreamV1CompletionStatus.complete ||
     status === MothershipStreamV1CompletionStatus.error ||