fix(mothership): answer a send superseded at admission as a duplicate

Admission's superseded conflict (another attempt with this id re-took the
claim) went out as a bare 409, which the client reads as a busy refusal and
marks the message editable. The claim's 60s in-progress TTL can run out
before admission, since branch, attachment and context preparation precede
it, so that attempt may admit the turn. The route now answers it as a
duplicate naming the send's id, and the client keeps the message under it.

Author: waleedlatif1

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

@@ -4053,10 +4053,9 @@ export function useChat(
                   exact: true,
                   refetchType: 'none',
                 })
-              /* Admission's "superseded" conflict (another attempt re-took this id's
-                 claim) also lands here with no stream named. That needs this attempt to
-                 hold its claim past the 60s in-progress TTL before admitting, which a
-                 lock wait of at most 5s does not reach. */
+              /* Only the chat lock refuses without naming this id. Admission's
+                 "superseded" conflict, where another attempt took this id's claim and may
+                 admit it, is answered as a duplicate naming this id instead. */
               return { userMessageId, busy: true, notAdmitted: true }
             }
             /* "Already sent" with no stream for it means the earlier attempt is still

apps/sim/lib/mothership/chat/application/admit-turn.ts

@@ -12,6 +12,7 @@ import { requireOrganizationSearchAvailable } from '@/lib/knowledge/access/avail
 import { insertRunSegment, withRunAdmissionLock } from '@/lib/mothership/async-runs/repository'
 import { defineAuthorizedChatUseCase } from '@/lib/mothership/chat/application/authorized-chat-use-case'
 import { resolveOwnedChatContext } from '@/lib/mothership/chat/application/context'
+import { ChatSendSupersededError } from '@/lib/mothership/chat/application/send-superseded'
 import { withChatEffortChoice } from '@/lib/mothership/chat/intent'
 import { appendCopilotChatMessages } from '@/lib/mothership/chat/messages-store'
 import { authorizeOrganizationChat } from '@/lib/mothership/chat/organization-chats'
@@ -167,8 +168,7 @@ export const admitChatTurn = defineAuthorizedChatUseCase({
           )
         )
         .returning({ key: idempotencyKey.key })
-      if (!claim)
-        throw new OrchestrationError('conflict', 'This send was superseded; retry the message')
+      if (!claim) throw new ChatSendSupersededError()
       return run
     })
   },

apps/sim/lib/mothership/chat/application/send-superseded.ts

@@ -0,0 +1,15 @@
+import { OrchestrationError } from '@/lib/core/orchestration/types'
+
+/**
+ * Admission found this send's claim taken by another attempt with the same
+ * `userMessageId`: this attempt held its in-progress claim past the 60s TTL
+ * before admitting (branch, attachment and context preparation can run that
+ * long), and a retry re-claimed it. That attempt may admit the turn, so the
+ * client must treat this like a duplicate, not a refusal.
+ */
+export class ChatSendSupersededError extends OrchestrationError {
+  constructor() {
+    super('conflict', 'This send was superseded; retry the message')
+    this.name = 'ChatSendSupersededError'
+  }
+}

apps/sim/lib/mothership/chat/post.test.ts

@@ -216,6 +216,7 @@ vi.mock('@/lib/permission-groups/config-scope.server', () => permissionGroupScop
 vi.mock('@/lib/mothership/chat-status', () => mothershipChatStatusMock)
 
 import { chatOperations } from '@/lib/mothership/application/operations'
+import { ChatSendSupersededError } from '@/lib/mothership/chat/application/send-superseded'
 import { DEFAULT_PERMISSION_GROUP_CONFIG } from '@/lib/permission-groups/fields'
 import { handleUnifiedChatPost } from './post'
 
@@ -1689,6 +1690,29 @@ describe('handleUnifiedChatPost', () => {
       expect(response.headers.get('x-mothership-chat-id')).toBeNull()
     })
 
+    /**
+     * Another attempt with this id took the claim while this one was still
+     * preparing, and may admit the turn. The client must keep the message under
+     * this id, so the answer names it, as a duplicate's does.
+     */
+    it('answers a send superseded at admission as a duplicate naming its id', async () => {
+      admitTurn.mockRejectedValueOnce(new ChatSendSupersededError())
+      const response = await handleUnifiedChatPost(
+        new NextRequest('http://localhost/api/mothership/chat', {
+          method: 'POST',
+          body: JSON.stringify({
+            message: 'Hello',
+            workspaceId: 'ws-1',
+            userMessageId: 'msg-1',
+            createNewChat: true,
+          }),
+        })
+      )
+      expect(response.status).toBe(409)
+      await expect(response.json()).resolves.toMatchObject({ activeStreamId: 'msg-1' })
+      expect(createSSEStream).not.toHaveBeenCalled()
+    })
+
     it('keeps the claim once a turn is actually streaming', async () => {
       const response = await handleUnifiedChatPost(
         new NextRequest('http://localhost/api/mothership/chat', {

apps/sim/lib/mothership/chat/post.ts

@@ -32,6 +32,7 @@ import { loadCopilotSearchIntegrations } from '@/lib/mothership/application/load
 import { chatOperations } from '@/lib/mothership/application/operations'
 import { resolveInvocationWorkspace } from '@/lib/mothership/application/workspace-target'
 import { admitChatTurn } from '@/lib/mothership/chat/application/admit-turn'
+import { ChatSendSupersededError } from '@/lib/mothership/chat/application/send-superseded'
 import {
   type AssistantImageContent,
   prepareOrganizationChatAttachments,
@@ -1627,6 +1628,15 @@ export async function handleUnifiedChatPost(req: NextRequest) {
     }
 
     const applicationError = asOrchestrationError(error)
+    /* Another attempt with this id holds its claim and may admit the turn. Answer
+       as a duplicate (naming this id), so the client keeps the message under it
+       rather than reading a refusal it could edit into a second turn. */
+    if (applicationError instanceof ChatSendSupersededError) {
+      return NextResponse.json(
+        { error: 'This message was already sent.', activeStreamId: userMessageId },
+        { status: 409 }
+      )
+    }
     if (applicationError?.code === 'forbidden' || applicationError?.code === 'not_found') {
       return NextResponse.json({ error: 'Conversation access denied' }, { status: 403 })
     }