fix(mothership): drop the new-chat effort when the surface adopts a chat

A first send stopped before admission adopted its chat without moving the pick, so the next new chat on the same Home mount showed and sent it. adoptResolvedChatId now drops the pick when the surface leaves the new chat. The rollback restore is gone: nothing clears the pick while a send is pending, and it overwrote a pick made during the send.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.dom.test.tsx

@@ -91,6 +91,7 @@ import { MothershipHandoffStorage } from '@/lib/core/utils/browser-storage'
 import { MOTHERSHIP_STREAM_REPLAY_HEADER } from '@/lib/mothership/constants'
 import type { MothershipStreamV1EventEnvelope } from '@/lib/mothership/generated/mothership-stream-v1'
 import { getChatResourceSelectionId } from '@/lib/mothership/resources/types'
+import { ChatSurfaceProvider } from '@/app/workspace/[workspaceId]/home/components/chat-surface-context'
 import { collectCitedMessageSources } from '@/app/workspace/[workspaceId]/home/components/message-content/message-sources'
 import { ModelSelector } from '@/app/workspace/[workspaceId]/home/components/user-input/components/model-selector'
 import {
@@ -473,6 +474,77 @@ function renderHomeLikeSurface(): {
   }
 }
 
+/** Holds the chat POST of the first send until the test settles it. */
+function holdFirstSend(): PromiseWithResolvers<Response> {
+  const post = Promise.withResolvers<Response>()
+  vi.stubGlobal('fetch', (input: RequestInfo | URL, init?: RequestInit) => {
+    if (String(input) !== '/api/mothership/chat' || init?.method !== 'POST') {
+      return fetchStub(input, init)
+    }
+    state.postBodies.push(JSON.parse(String(init.body)))
+    return post.promise
+  })
+  return post
+}
+
+/**
+ * Mounts a chatless surface shaped like `home.tsx`, with real composers: the empty-state one
+ * swaps for the chat view's once messages show, and the chat view's names the resolved chat.
+ */
+function renderComposerSwap(): {
+  container: HTMLElement
+  getResult: () => ReturnType<typeof useChat>
+  shownEffort: () => string | null | undefined
+  visit: (pathname: string) => void
+} {
+  ;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+  useMothershipEffortStore.getState().reset()
+  queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+  const container = document.createElement('div')
+  const root = createRoot(container)
+  mountedRoots.push(root)
+  let result: ReturnType<typeof useChat> | undefined
+
+  function HomeLike() {
+    result = useChat('ws-1', undefined)
+    return result.messages.length > 0 ? (
+      <section key='chat'>
+        <ChatSurfaceProvider chatId={result.resolvedChatId}>
+          <ModelSelector />
+        </ChatSurfaceProvider>
+      </section>
+    ) : (
+      <main key='empty'>
+        <ModelSelector />
+      </main>
+    )
+  }
+
+  const render = () =>
+    act(() => {
+      root.render(
+        <QueryClientProvider client={queryClient}>
+          <HomeLike />
+        </QueryClientProvider>
+      )
+    })
+  render()
+
+  return {
+    container,
+    getResult: () => {
+      if (result === undefined) throw new Error('Hook result is not ready')
+      return result
+    },
+    shownEffort: () =>
+      container.querySelector('[aria-label="Reasoning effort"]')?.getAttribute('aria-description'),
+    visit: (pathname) => {
+      mockUsePathname.mockReturnValue(pathname)
+      render()
+    },
+  }
+}
+
 /**
  * Mounts the hook under StrictMode with a handoff already in storage, mirroring
  * `home.tsx`'s consume-and-auto-send effect. This is the production-shaped
@@ -4703,61 +4775,63 @@ describe('useChat remount send recovery', () => {
   })
 
   it('keeps the new-chat effort across the composer swap of a first send that fails', async () => {
-    useMothershipEffortStore.getState().reset()
-    const post = Promise.withResolvers<Response>()
-    vi.stubGlobal('fetch', (input: RequestInfo | URL, init?: RequestInit) => {
-      if (String(input) !== '/api/mothership/chat' || init?.method !== 'POST') {
-        return fetchStub(input, init)
-      }
-      state.postBodies.push(JSON.parse(String(init.body)))
-      return post.promise
-    })
-    ;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
-    queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
-    const container = document.createElement('div')
-    const root = createRoot(container)
-    mountedRoots.push(root)
-    let result: ReturnType<typeof useChat> | undefined
-    /** Like home.tsx: the empty-state composer swaps for the chat view's once messages show. */
-    function HomeLike() {
-      result = useChat('ws-1', undefined)
-      return result.messages.length > 0 ? (
-        <section key='chat'>
-          <ModelSelector />
-        </section>
-      ) : (
-        <main key='empty'>
-          <ModelSelector />
-        </main>
-      )
-    }
-    act(() => {
-      root.render(
-        <QueryClientProvider client={queryClient}>
-          <HomeLike />
-        </QueryClientProvider>
-      )
-    })
-    const shownEffort = () =>
-      container.querySelector('[aria-label="Reasoning effort"]')?.getAttribute('aria-description')
+    const post = holdFirstSend()
+    const surface = renderComposerSwap()
     act(() => useMothershipEffortStore.getState().setNewChatEffort('low'))
-    expect(shownEffort()).toBe('Low')
+    expect(surface.shownEffort()).toBe('Low')
 
     await act(async () => {
-      void result?.sendMessage('Plan the launch')
+      void surface.getResult().sendMessage('Plan the launch')
     })
     await waitFor(() => state.postBodies.length === 1)
     expect(state.postBodies[0].effort).toBe('low')
-    expect(container.querySelector('section')).not.toBeNull()
-    expect(shownEffort()).toBe('Low')
+    expect(surface.container.querySelector('section')).not.toBeNull()
+    expect(surface.shownEffort()).toBe('Low')
 
     await act(async () => {
       post.reject(new TypeError('Failed to fetch'))
     })
-    await waitFor(() => container.querySelector('main') !== null)
+    await waitFor(() => surface.container.querySelector('main') !== null)
 
     expect(useMothershipEffortStore.getState().newChatEffort).toBe('low')
-    expect(shownEffort()).toBe('Low')
+    expect(surface.shownEffort()).toBe('Low')
+  })
+
+  it('keeps a new-chat effort picked while the first send is pending when that send fails', async () => {
+    const post = holdFirstSend()
+    const surface = renderComposerSwap()
+    act(() => useMothershipEffortStore.getState().setNewChatEffort('low'))
+    await act(async () => {
+      void surface.getResult().sendMessage('Plan the launch')
+    })
+    await waitFor(() => state.postBodies.length === 1)
+    act(() => useMothershipEffortStore.getState().setNewChatEffort('medium'))
+
+    await act(async () => {
+      post.reject(new TypeError('Failed to fetch'))
+    })
+    await waitFor(() => surface.container.querySelector('main') !== null)
+
+    expect(surface.shownEffort()).toBe('Medium')
+  })
+
+  it('starts the next new chat at the default after a first send stopped before admission', async () => {
+    const surface = renderComposerSwap()
+    act(() => useMothershipEffortStore.getState().setNewChatEffort('low'))
+    await act(async () => {
+      void surface.getResult().sendMessage('Plan the launch')
+    })
+    await waitFor(() => state.postBodies.length === 1)
+    await act(async () => {
+      await surface.getResult().stopGeneration()
+    })
+    await waitFor(() => surface.getResult().resolvedChatId === DEDUPED_CHAT_ID)
+
+    surface.visit(`/workspace/ws-1/chat/${DEDUPED_CHAT_ID}`)
+    surface.visit('/workspace/ws-1/home')
+    await waitFor(() => surface.container.querySelector('main') !== null)
+
+    expect(surface.shownEffort()).toBe('High')
   })
 
   it.each(['leaves the page', 'opens another chat'] as const)(

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts

@@ -1001,7 +1001,7 @@ export function useChat(
     new Set())
   const streamReaderRef = useRef<ReadableStreamDefaultReader<Uint8Array> | null>(null)
   const chatIdRef = useRef<string | undefined>(initialChatId)
-  /** Cleared on unmount, so a late rollback cannot hand a pick to a surface the user left. */
+  /** Cleared on unmount, so late async work cannot act on a surface the user left. */
   const surfaceMountedRef = useRef(true)
   useEffect(() => {
     surfaceMountedRef.current = true
@@ -1010,8 +1010,9 @@ export function useChat(
     }
   }, [])
   /* The new-chat effort pick belongs to this surface, not to one composer: it outlives the swap
-     from the empty-state composer to the chat view during a first send, and drops only when the
-     surface leaves the new chat. */
+     from the empty-state composer to the chat view during a first send, so a withdrawn send
+     leaves it in place. It drops when the surface unmounts or switches chats, and when it adopts
+     a chat (`adoptResolvedChatId`). */
   useEffect(() => {
     if (initialChatId) return
     return () => useMothershipEffortStore.getState().setNewChatEffort(null)
@@ -1285,6 +1286,10 @@ export function useChat(
       const resolvedDesktopScopeId = desktopChatScopeId(scopeKey, chatId)
       if (wasPending) {
         useChatPanelStore.getState().migrate(pendingDesktopScopeId, resolvedDesktopScopeId)
+        // Leaving the new chat. An admitted send has already moved the pick onto its chat; any
+        // other way out (a Stop before admission, a recovered handoff) must not carry it into
+        // the next new chat.
+        useMothershipEffortStore.getState().setNewChatEffort(null)
       }
       const activeActivityTracker = resourceActivityTrackerRef.current
       if (activeActivityTracker?.generation === streamGenRef.current) {
@@ -3743,16 +3748,6 @@ export function useChat(
       }
 
       const rollbackOptimisticSend = () => {
-        // A withdrawn first send hands its pick back to the new-chat composer for the retry,
-        // only while that surface is still open on the new chat.
-        if (
-          !requestChatId &&
-          effortChoice &&
-          surfaceMountedRef.current &&
-          !chatIdRef.current &&
-          !selectedChatIdRef.current
-        )
-          useMothershipEffortStore.getState().setNewChatEffort(effortChoice)
         if (requestChatId) {
           upsertChatHistory(requestChatId, (current) => ({
             ...current,