fix(chat): carry attachments through the cross-mount send handoff

The recoverable-abort delivery excluded attachment-bearing sends, so
they restored under the dead instance's pending key and were silently
lost. The claimable send event now carries fileAttachments end to end
(dispatcher, home listener, restore path); only the storage fallback —
whose shape cannot hold attachments — still queue-restores them.

Author: j15z

apps/sim/app/workspace/[workspaceId]/home/home.tsx

@@ -341,7 +341,7 @@ export function Home({ chatId, userName, userId, tableViewsEnabled }: HomeProps)
       const detail = (e as CustomEvent<MothershipSendMessageDetail>).detail
       if (!detail?.message) return
       e.preventDefault()
-      sendMessage(detail.message, undefined, detail.contexts)
+      sendMessage(detail.message, detail.fileAttachments, detail.contexts)
     }
     window.addEventListener(MOTHERSHIP_SEND_MESSAGE_EVENT, handler)
     return () => window.removeEventListener(MOTHERSHIP_SEND_MESSAGE_EVENT, handler)

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

@@ -144,24 +144,33 @@ describe('useChat mount-settling send recovery', () => {
   })
 
   it('delivers an aborted chatless send directly to a live replacement surface', async () => {
-    const received: string[] = []
+    const attachment = {
+      id: 'file-1',
+      key: 'uploads/file-1',
+      filename: 'notes.txt',
+      media_type: 'text/plain',
+      size: 12,
+    }
+    const received: Array<{ message: string; fileAttachments?: unknown[] }> = []
     const claim = (event: Event) => {
-      received.push((event as CustomEvent<{ message: string }>).detail.message)
+      const detail = (event as CustomEvent<{ message: string; fileAttachments?: unknown[] }>).detail
+      received.push(detail)
       event.preventDefault()
     }
     window.addEventListener('mothership-send-message', claim)
 
     try {
       const { getResult, unmount } = renderUseChat()
       await act(async () => {
-        void getResult().sendMessage('hello from the palette')
+        void getResult().sendMessage('hello from the palette', [attachment])
       })
       await waitFor(() => state.postCalls === 1)
 
       unmount()
       await waitFor(() => received.length === 1)
 
-      expect(received).toEqual(['hello from the palette'])
+      expect(received[0].message).toBe('hello from the palette')
+      expect(received[0].fileAttachments).toEqual([attachment])
       expect(window.localStorage.getItem('sim_mothership_handoff')).toBeNull()
     } finally {
       window.removeEventListener('mothership-send-message', claim)

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

@@ -4505,29 +4505,27 @@ export function useChat(
         /* A pending (chatless) surface regenerates its chat key per mount, and
            the cleanup that aborted this send belongs to a full remount — a
            queue restore would orphan the message under the dead instance's
-           key. Re-persist it as a one-shot handoff instead: the next mount's
-           consumer re-sends it. Chat-bound sends keep the queue restore (their
-           key is the stable chat id). Attachment payloads exceed what the
-           handoff carries, so they fall back to the queue restore. */
-        if (
-          recoverableCleanupAbort &&
-          dispatchChatKey.startsWith(PENDING_CHAT_KEY_PREFIX) &&
-          !msg.fileAttachments?.length
-        ) {
-          /* The settling remount has already run its mount effects by the time
-             this microtask executes, so the replacement surface's send listener
-             is live — deliver directly. The stored-handoff fallback covers a
-             real navigation away, where the next mount's consumer picks it up. */
-          if (!sendMothershipMessage(msg.content, msg.contexts)) {
+           key. Deliver to the replacement surface instead: its send listener
+           is live by the time this microtask executes, and the event carries
+           attachments. When nothing claims it (a real navigation away), a
+           one-shot handoff covers attachment-less sends for the next mount;
+           attachment payloads exceed what the handoff carries and fall back to
+           the queue restore. Chat-bound sends always keep the queue restore
+           (their key is the stable chat id). */
+        if (recoverableCleanupAbort && dispatchChatKey.startsWith(PENDING_CHAT_KEY_PREFIX)) {
+          if (sendMothershipMessage(msg.content, msg.contexts, msg.fileAttachments)) {
+            return
+          }
+          if (!msg.fileAttachments?.length) {
             MothershipHandoffStorage.store(
               {
                 message: msg.content,
                 ...(msg.contexts?.length ? { contexts: msg.contexts } : {}),
               },
               workspaceId
             )
+            return
           }
-          return
         }
         useMothershipQueueStore.getState().insertAt(dispatchChatKey, originalIndex, msg)
       }

apps/sim/lib/mothership/events.ts

@@ -1,4 +1,5 @@
 import { createLogger } from '@sim/logger'
+import type { FileAttachmentForApi } from '@/app/workspace/[workspaceId]/home/types'
 import type { ChatContext } from '@/stores/panel'
 
 const logger = createLogger('MothershipEvents')
@@ -24,6 +25,8 @@ export interface MothershipSendMessageDetail {
   message: string
   /** Structured contexts to attach — e.g. a `logs` mention tagging a run. */
   contexts?: ChatContext[]
+  /** Already-uploaded attachments riding along with the message. */
+  fileAttachments?: FileAttachmentForApi[]
 }
 
 /**
@@ -35,7 +38,11 @@ export interface MothershipSendMessageDetail {
  * was listening — callers that can fall back (e.g. cross-route navigation) use
  * this to decide whether to persist a handoff instead.
  */
-export function sendMothershipMessage(message: string, contexts?: ChatContext[]): boolean {
+export function sendMothershipMessage(
+  message: string,
+  contexts?: ChatContext[],
+  fileAttachments?: FileAttachmentForApi[]
+): boolean {
   const trimmed = message.trim()
   if (!trimmed) {
     logger.warn('sendMothershipMessage called with empty message')
@@ -44,6 +51,7 @@ export function sendMothershipMessage(message: string, contexts?: ChatContext[])
   const consumed = dispatchClaimable<MothershipSendMessageDetail>(MOTHERSHIP_SEND_MESSAGE_EVENT, {
     message: trimmed,
     contexts,
+    fileAttachments,
   })
   logger.info('Dispatched mothership message event', { messageLength: trimmed.length, consumed })
   return consumed