fix(copilot): hold a reorder for pending deletes too

The reorder gate landed one case short: a delete that has not reached the
server leaves the server holding a resource the client's order omits, so the
order fails its identity check exactly as an unlanded add does. Gating only
on unpersisted adds let that order fire and be discarded as unsatisfiable,
losing the tab order until the next reorder or hydration.

Name the predicate for what it actually decides — whether a pending write
changes WHICH resources the chat holds — and cover both directions. A failing
update to an already-stored resource still does not park the order, which is
what the gate was narrowed for.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FwmaLmAXSK2hsPBGZmkPnT

Author: waleedlatif1

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

@@ -1707,7 +1707,7 @@ export function useChat(
         while (true) {
           const pendingOrder = pendingResourceReordersRef.current.get(chatId)
           if (!pendingOrder) return
-          if (resourcePersistenceQueue.hasUnpersistedWrites(chatId)) return
+          if (resourcePersistenceQueue.hasPendingIdentityChanges(chatId)) return
 
           const inFlightWrites = resourcePersistenceQueue.getInFlightWrites(chatId)
           if (inFlightWrites.length > 0) {

apps/sim/lib/copilot/resources/client-persistence-queue.test.ts

@@ -219,7 +219,27 @@ describe('ResourcePersistenceQueue', () => {
     expect(queue.getPendingResourceKeys('chat-1')).toEqual(new Set())
   })
 
-  it('does not report an unpersisted write once the resource reaches the server', async () => {
+  it('reports a pending identity change while a deletion has not landed', async () => {
+    const persist = vi
+      .fn<(chatId: string, update: MothershipResourceUpdate) => Promise<unknown>>()
+      .mockResolvedValue({ success: true })
+    const remove = vi.fn<() => Promise<unknown>>().mockRejectedValueOnce(new Error('offline'))
+    const queue = new ResourcePersistenceQueue({ persist, onError })
+
+    queue.enqueue(TABLE_RESOURCE, 'chat-1', 'chat-1')
+    await Promise.allSettled(queue.getInFlightWrites('chat-1'))
+    expect(queue.hasPendingIdentityChanges('chat-1')).toBe(false)
+
+    // The server still holds a resource the client has dropped, so an order
+    // built from client state would not match and must wait for the delete.
+    const removal = queue.remove(TABLE_RESOURCE.type, TABLE_RESOURCE.id, 'chat-1')
+    removal.scheduleDelete('chat-1', remove)
+    await vi.waitFor(() => expect(onError).toHaveBeenCalledOnce())
+
+    expect(queue.hasPendingIdentityChanges('chat-1')).toBe(true)
+  })
+
+  it('does not report an identity change for a failing update to a stored resource', async () => {
     const persist = vi
       .fn<(chatId: string, update: MothershipResourceUpdate) => Promise<unknown>>()
       .mockResolvedValueOnce({ success: true })
@@ -228,17 +248,17 @@ describe('ResourcePersistenceQueue', () => {
 
     queue.enqueue(TABLE_RESOURCE, 'chat-1', 'chat-1')
     await Promise.allSettled(queue.getInFlightWrites('chat-1'))
-    expect(queue.hasUnpersistedWrites('chat-1')).toBe(false)
+    expect(queue.hasPendingIdentityChanges('chat-1')).toBe(false)
 
     // A pin update for the same, already-stored resource keeps failing. The
     // resource is on the server, so a reorder naming it stays valid.
     queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1', 'chat-1')
     await vi.waitFor(() => expect(onError).toHaveBeenCalledOnce())
     expect(queue.getPendingResourceKeys('chat-1')).toEqual(new Set(['table:table-1']))
-    expect(queue.hasUnpersistedWrites('chat-1')).toBe(false)
+    expect(queue.hasPendingIdentityChanges('chat-1')).toBe(false)
 
     await queue.flush('chat-1')
-    expect(queue.hasUnpersistedWrites('chat-1')).toBe(false)
+    expect(queue.hasPendingIdentityChanges('chat-1')).toBe(false)
   })
 
   it('reports an unpersisted write while a first add has never succeeded', async () => {
@@ -250,7 +270,7 @@ describe('ResourcePersistenceQueue', () => {
     queue.enqueue(TABLE_RESOURCE, 'chat-1', 'chat-1')
     await vi.waitFor(() => expect(onError).toHaveBeenCalledOnce())
 
-    expect(queue.hasUnpersistedWrites('chat-1')).toBe(true)
+    expect(queue.hasPendingIdentityChanges('chat-1')).toBe(true)
   })
 
   it('keeps the newer chat-scoped update when a provisional scope is adopted', async () => {

apps/sim/lib/copilot/resources/client-persistence-queue.ts

@@ -117,15 +117,19 @@ export class ResourcePersistenceQueue {
   }
 
   /**
-   * Whether a pending write would add a resource the server does not store yet.
+   * Whether a pending write would change which resources the chat holds — an
+   * add the server has not accepted yet, or a delete that has not landed.
    *
-   * Only these may hold a reorder back — the server rejects an order naming a
-   * resource it has never seen. A pending UPDATE to a resource it already
-   * stores (a saved-view pin) must not: that write can fail indefinitely, and
-   * gating on it would park tab ordering for the rest of the session.
+   * Only these may hold a reorder back, because only these make the client's
+   * identity set disagree with the server's, and the server validates a reorder
+   * against exactly that. A pending UPDATE to a resource it already stores (a
+   * saved-view pin) must NOT: such a write can fail indefinitely, and gating on
+   * it would park tab ordering for the rest of the session.
    */
-  hasUnpersistedWrites(scopeId: string): boolean {
-    return this.getScopedKeys(this.pendingKeys, scopeId).some((key) => !this.persistedKeys.has(key))
+  hasPendingIdentityChanges(scopeId: string): boolean {
+    return this.getScopedKeys(this.pendingKeys, scopeId).some(
+      (key) => !this.persistedKeys.has(key) || this.pendingRemovals.has(key)
+    )
   }
 
   getPendingResourceKeys(scopeId: string): Set<string> {