fix(web): remove failed optimistic row on send error

Address PR review (Major #2): the mutation onError was leaving the
optimistic message in the visible thread as `failed`, which duplicated
the restored composer text -- operator saw a failed bubble plus the
same text in the composer, and could stack a stale failed turn next
to a fresh send.

The composer-restore + inline alert is the single retry surface for
this failure mode now, so the optimistic row is dropped via
removeOptimisticMessage() in the same handler. retryMessage stays
exposed for any future code path that still produces failed rows.

Test pins the new behaviour: the row is removed (not flipped to
failed) on send failure.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: heavygee

web/src/hooks/mutations/useSendMessage.test.tsx

@@ -9,6 +9,7 @@ vi.mock('@/lib/message-window-store', () => ({
     appendOptimisticMessage: vi.fn(),
     getMessageWindowState: vi.fn(() => ({ messages: [], pending: [] })),
     updateMessageStatus: vi.fn(),
+    removeOptimisticMessage: vi.fn(),
 }))
 
 vi.mock('@/hooks/usePlatform', () => ({
@@ -278,6 +279,38 @@ describe('useSendMessage', () => {
             const info = onError.mock.calls[0][0] as { scheduledAt: number | null }
             expect(info.scheduledAt).toBeNull()
         })
+
+        it('removes the optimistic row on failure so the composer-restore path is the single retry surface', async () => {
+            // Without this, the thread keeps a stale `failed` bubble next to
+            // the restored composer text, and the operator can stack a
+            // duplicate by retrying from either surface.
+            const onError = vi.fn()
+            const api = createMockApi(async () => {
+                throw new Error('HTTP 503')
+            })
+
+            const { removeOptimisticMessage, updateMessageStatus } = await import('@/lib/message-window-store')
+            const removeMock = vi.mocked(removeOptimisticMessage)
+            const updateMock = vi.mocked(updateMessageStatus)
+
+            const { result } = renderHook(
+                () => useSendMessage(api, 'session-A', { onError }),
+                { wrapper: createWrapper() },
+            )
+
+            act(() => {
+                result.current.sendMessage('hello')
+            })
+
+            await waitFor(() => {
+                expect(onError).toHaveBeenCalledTimes(1)
+            })
+            // The optimistic row is removed instead of being kept as failed.
+            expect(removeMock).toHaveBeenCalledWith('session-A', 'local-id-1')
+            // Defensive: nothing else should have transitioned the row to
+            // 'failed' on this path -- we removed it outright.
+            expect(updateMock.mock.calls.some((call) => call[2] === 'failed')).toBe(false)
+        })
     })
 
     it('does not call onSuccess when blocked', () => {

web/src/hooks/mutations/useSendMessage.ts

@@ -6,6 +6,7 @@ import { makeClientSideId } from '@/lib/messages'
 import {
     appendOptimisticMessage,
     getMessageWindowState,
+    removeOptimisticMessage,
     updateMessageStatus,
 } from '@/lib/message-window-store'
 import { usePlatform } from '@/hooks/usePlatform'
@@ -137,7 +138,15 @@ export function useSendMessage(
             options?.onSuccess?.(input.sessionId)
         },
         onError: (error, input) => {
-            updateMessageStatus(input.sessionId, input.localId, 'failed')
+            // Drop the optimistic row from the thread.  The composer
+            // restore path (see onError below) puts the original text
+            // back into the input + surfaces an inline error, so leaving
+            // the row as `failed` would visually duplicate the message
+            // (failed bubble in thread + same text in composer) and let
+            // the operator stack a stale failed turn next to a fresh
+            // send.  The composer affordance is the single retry surface
+            // for this failure mode.
+            removeOptimisticMessage(input.sessionId, input.localId)
             haptic.notification('error')
             // Surface the original text + scheduledAt so the composer can
             // restore both.  assistant-ui clears the composer eagerly when