fix(copilot): bound resource-write locks and repair reorder persistence

Review follow-ups on the saved-view pinning work.

Correctness:
- Reorder persistence was parked by ANY pending write. A repeatedly failing
  update to an already-stored resource (a view pin) blocked tab ordering for
  the rest of the session; gate on unpersisted writes only, which are the
  ones the server's identity check can actually reject.
- A parked reorder body that the server rejects was re-parked verbatim, so a
  tab closed after the order was captured poisoned it permanently. Discard on
  400; keep retrying everything transient.
- adoptScope merged the provisional and chat-scoped updates in the wrong
  order, letting an older pending write overwrite a newer one.
- A view pin that arrived before the table finished its first adoption was
  dropped for good when the table data resolved after the views list. The
  stream path self-rescued through query invalidation; the restore path did
  not. Re-run the effect when adoption becomes possible.
- Reordering a chat holding a legacy duplicate row 400'd forever. Compare
  identity sets so the duplicate collapses on write instead.
- mergeChatResource aliased the caller's object into React state, the query
  cache and the pending-write queue at once. Copy it.

Robustness:
- The new copilot_chats FOR UPDATE transactions had no lock_timeout, and
  neither the pool nor the deployment sets one. finalizeAssistantTurn holds
  that same row across an assistant-message append, so a waiter could park a
  pool connection indefinitely. Bound all five writers.
- mergeChatResource's field list is now one declaration that fails to compile
  when MothershipResource gains a field, rather than silently dropping it
  from both the merge and its no-op check.
- Extraction can no longer emit viewId and clearViewId together, a pair the
  wire contract rejects and the merge would resolve to neither.
- Restrict the eager view-id URL write to embedded tables, leaving standalone
  table behaviour identical to staging.
- Drop the queue's unreachable unscoped bucket, its uncalled clear(), and its
  test-only getPendingUpdates().

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

Author: waleedlatif1

apps/sim/app/api/copilot/chat/resources/route.ts

@@ -16,7 +16,11 @@ import {
   createNotFoundResponse,
   createUnauthorizedResponse,
 } from '@/lib/copilot/request/http'
-import { type ChatResource, serializeChatResourceWrite } from '@/lib/copilot/resources/persistence'
+import {
+  type ChatResource,
+  serializeChatResourceWrite,
+  setChatResourceTxTimeouts,
+} from '@/lib/copilot/resources/persistence'
 import type { MothershipResourceUpdate } from '@/lib/copilot/resources/types'
 import {
   canonicalizeDesktopSessionResource,
@@ -57,6 +61,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
 
     const merged = await serializeChatResourceWrite(chatId, () =>
       db.transaction(async (tx) => {
+        await setChatResourceTxTimeouts(tx)
         const scope = and(
           eq(copilotChats.id, chatId),
           eq(copilotChats.userId, userId),
@@ -125,6 +130,7 @@ export const PATCH = withRouteHandler(async (req: NextRequest) => {
 
     const canonicalOrder = await serializeChatResourceWrite(chatId, () =>
       db.transaction(async (tx): Promise<ChatResource[] | null | undefined> => {
+        await setChatResourceTxTimeouts(tx)
         const scope = and(
           eq(copilotChats.id, chatId),
           eq(copilotChats.userId, userId),
@@ -191,6 +197,7 @@ export const DELETE = withRouteHandler(async (req: NextRequest) => {
 
     const merged = await serializeChatResourceWrite(chatId, () =>
       db.transaction(async (tx) => {
+        await setChatResourceTxTimeouts(tx)
         const scope = and(
           eq(copilotChats.id, chatId),
           eq(copilotChats.userId, userId),

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

@@ -18,6 +18,7 @@ import { isRecordLike } from '@sim/utils/object'
 import { backoffWithJitter } from '@sim/utils/retry'
 import { useQueryClient } from '@tanstack/react-query'
 import { usePathname, useRouter } from 'next/navigation'
+import { isApiClientError } from '@/lib/api/client/errors'
 import { requestJson } from '@/lib/api/client/request'
 import {
   addMothershipChatResourceContract,
@@ -1706,7 +1707,7 @@ export function useChat(
         while (true) {
           const pendingOrder = pendingResourceReordersRef.current.get(chatId)
           if (!pendingOrder) return
-          if (resourcePersistenceQueue.getPendingResourceKeys(chatId).size > 0) return
+          if (resourcePersistenceQueue.hasUnpersistedWrites(chatId)) return
 
           const inFlightWrites = resourcePersistenceQueue.getInFlightWrites(chatId)
           if (inFlightWrites.length > 0) {
@@ -1721,10 +1722,21 @@ export function useChat(
               body: { chatId, resources: pendingOrder },
             })
           } catch (error) {
-            if (!pendingResourceReordersRef.current.has(chatId)) {
+            // 400 is the server rejecting the body's identity set — a tab was
+            // closed after this order was captured. Replaying it verbatim can
+            // only fail again, so drop it and let the next reorder or hydration
+            // re-establish the order. Everything else (offline, 401, 5xx) is
+            // transient and keeps the body for the next retry.
+            const unsatisfiable = isApiClientError(error) && error.status === 400
+            if (!unsatisfiable && !pendingResourceReordersRef.current.has(chatId)) {
               pendingResourceReordersRef.current.set(chatId, pendingOrder)
             }
-            logger.warn('Failed to persist resource reorder; will retry on next hydration', error)
+            logger.warn(
+              unsatisfiable
+                ? 'Discarded a resource reorder the server rejected'
+                : 'Failed to persist resource reorder; will retry on next hydration',
+              error
+            )
             return
           }
         }
@@ -1891,7 +1903,7 @@ export function useChat(
       }
 
       const persistenceScopeId = persistChatId ?? pendingChatKeyRef.current
-      resourcePersistenceQueue.enqueue(resourceUpdate, persistChatId, existing, persistenceScopeId)
+      resourcePersistenceQueue.enqueue(resourceUpdate, persistChatId, persistenceScopeId, existing)
       return existing === undefined
     },
     [queryClient, resourcePersistenceQueue]

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx

@@ -666,7 +666,11 @@ export function Table({
       return
     }
 
-    if (activeView && activeViewId === null) {
+    // Embedded tables record the adopted id BEFORE the revision guard can bail:
+    // `resolveTableViewSelection` resolves a null param to the restored view, so
+    // leaving the param unwritten lets a later render drift back to the default.
+    // Standalone tables have no restored view and keep writing it below.
+    if (embedded && activeView && activeViewId === null) {
       setTableParams({ view: activeView.id })
     }
     const nextViewRevision = getTableViewRevision(activeView)
@@ -685,7 +689,7 @@ export function Table({
     if (preserved && preserved.viewId !== nextViewId) {
       preservedViewStateRef.current = null
     }
-    if (activeView && activeViewId === ALL_VIEW_PARAM) {
+    if (activeView && (activeViewId === null || activeViewId === ALL_VIEW_PARAM)) {
       setTableParams({ view: activeView.id })
     }
     const keep = preserved?.viewId === nextViewId ? preserved.keep : undefined
@@ -737,7 +741,21 @@ export function Table({
     if (!transition.nextViewId) return
     preservedViewStateRef.current = null
     setTableParams({ view: transition.nextViewId })
-  }, [embedded, viewPin, views, activeViewId, tableId, consumeViewPin, setTableParams])
+    // `viewsAvailable`/`tableAvailable` are what gate first adoption, and
+    // adoption records itself in a ref, which re-renders nothing. Without them
+    // a pin that arrives before the table is ready is never reconsidered — the
+    // restore path has no query invalidation to nudge `views` and rescue it.
+  }, [
+    embedded,
+    viewPin,
+    views,
+    activeViewId,
+    tableId,
+    viewsAvailable,
+    tableAvailable,
+    consumeViewPin,
+    setTableParams,
+  ])
 
   /**
    * Live state pruned the same way `pruneViewConfig` prunes the stored config on

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

@@ -36,8 +36,8 @@ describe('ResourcePersistenceQueue', () => {
       .mockResolvedValueOnce({ success: true })
     const queue = new ResourcePersistenceQueue({ persist, onError })
 
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1')
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, 'chat-1')
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1', 'chat-1')
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, 'chat-1', 'chat-1')
 
     await Promise.resolve()
     expect(persist).toHaveBeenCalledTimes(1)
@@ -59,12 +59,11 @@ describe('ResourcePersistenceQueue', () => {
       .mockResolvedValueOnce({ success: true })
     const queue = new ResourcePersistenceQueue({ persist, onError })
 
-    queue.enqueue({ ...TABLE_RESOURCE, clearViewId: true }, 'chat-1')
-    queue.enqueue(TABLE_RESOURCE, 'chat-1')
+    queue.enqueue({ ...TABLE_RESOURCE, clearViewId: true }, 'chat-1', 'chat-1')
+    queue.enqueue(TABLE_RESOURCE, 'chat-1', 'chat-1')
     first.reject(new Error('offline'))
     await Promise.allSettled(Array.from(queue.inFlight.values()))
 
-    expect(queue.getPendingUpdates('chat-1')).toEqual([{ ...TABLE_RESOURCE, clearViewId: true }])
     await queue.flush('chat-1')
 
     expect(persist.mock.calls[1]).toEqual(['chat-1', { ...TABLE_RESOURCE, clearViewId: true }])
@@ -81,10 +80,10 @@ describe('ResourcePersistenceQueue', () => {
     const remove = vi.fn().mockResolvedValue({ success: true })
     const queue = new ResourcePersistenceQueue({ persist, onError })
 
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1')
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1', 'chat-1')
     const removal = queue.remove(TABLE_RESOURCE.type, TABLE_RESOURCE.id, 'chat-1')
     removal.scheduleDelete('chat-1', remove)
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, 'chat-1')
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, 'chat-1', 'chat-1')
     await Promise.resolve()
 
     expect(persist).toHaveBeenCalledTimes(1)
@@ -106,7 +105,7 @@ describe('ResourcePersistenceQueue', () => {
       .mockReturnValueOnce(failed.promise)
     const queue = new ResourcePersistenceQueue({ persist, onError })
 
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1', TABLE_RESOURCE)
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1', 'chat-1', TABLE_RESOURCE)
     failed.reject(new Error('offline'))
     await Promise.allSettled(Array.from(queue.inFlight.values()))
 
@@ -125,7 +124,7 @@ describe('ResourcePersistenceQueue', () => {
       .mockReturnValueOnce(failed.promise)
     const queue = new ResourcePersistenceQueue({ persist, onError })
 
-    queue.enqueue(TABLE_RESOURCE, 'chat-1')
+    queue.enqueue(TABLE_RESOURCE, 'chat-1', 'chat-1')
     failed.reject(new Error('offline'))
     await Promise.allSettled(Array.from(queue.inFlight.values()))
 
@@ -142,13 +141,13 @@ describe('ResourcePersistenceQueue', () => {
     const remove = vi.fn().mockReturnValue(deletion.promise)
     const queue = new ResourcePersistenceQueue({ persist, onError })
 
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1', TABLE_RESOURCE)
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1', 'chat-1', TABLE_RESOURCE)
     await Promise.allSettled(Array.from(queue.inFlight.values()))
     const removal = queue.remove(TABLE_RESOURCE.type, TABLE_RESOURCE.id, 'chat-1')
     removal.scheduleDelete('chat-1', remove)
     await vi.waitFor(() => expect(remove).toHaveBeenCalledOnce())
 
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, 'chat-1')
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, 'chat-1', 'chat-1')
     await Promise.resolve()
     expect(persist).toHaveBeenCalledOnce()
 
@@ -188,10 +187,10 @@ describe('ResourcePersistenceQueue', () => {
       .mockResolvedValue({ success: true })
     const queue = new ResourcePersistenceQueue({ persist, onError })
 
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1')
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1', 'chat-1')
     await vi.waitFor(() => expect(onError).toHaveBeenCalledOnce())
 
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, 'chat-2')
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, 'chat-2', 'chat-2')
     await vi.waitFor(() => expect(persist).toHaveBeenCalledTimes(2))
 
     expect(persist.mock.calls[1]).toEqual(['chat-2', { ...TABLE_RESOURCE, viewId: 'view-b' }])
@@ -210,7 +209,7 @@ describe('ResourcePersistenceQueue', () => {
       .mockResolvedValue({ success: true })
     const queue = new ResourcePersistenceQueue({ persist, onError })
 
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, undefined, undefined, 'pending-chat-1')
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, undefined, 'pending-chat-1')
 
     expect(queue.getPendingResourceKeys('pending-chat-1')).toEqual(new Set(['table:table-1']))
     await queue.flush('chat-1', 'pending-chat-1')
@@ -220,6 +219,54 @@ describe('ResourcePersistenceQueue', () => {
     expect(queue.getPendingResourceKeys('chat-1')).toEqual(new Set())
   })
 
+  it('does not report an unpersisted write once the resource reaches the server', async () => {
+    const persist = vi
+      .fn<(chatId: string, update: MothershipResourceUpdate) => Promise<unknown>>()
+      .mockResolvedValueOnce({ success: true })
+      .mockRejectedValue(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.hasUnpersistedWrites('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)
+
+    await queue.flush('chat-1')
+    expect(queue.hasUnpersistedWrites('chat-1')).toBe(false)
+  })
+
+  it('reports an unpersisted write while a first add has never succeeded', async () => {
+    const persist = vi
+      .fn<(chatId: string, update: MothershipResourceUpdate) => Promise<unknown>>()
+      .mockRejectedValue(new Error('offline'))
+    const queue = new ResourcePersistenceQueue({ persist, onError })
+
+    queue.enqueue(TABLE_RESOURCE, 'chat-1', 'chat-1')
+    await vi.waitFor(() => expect(onError).toHaveBeenCalledOnce())
+
+    expect(queue.hasUnpersistedWrites('chat-1')).toBe(true)
+  })
+
+  it('keeps the newer chat-scoped update when a provisional scope is adopted', async () => {
+    const persist = vi
+      .fn<(chatId: string, update: MothershipResourceUpdate) => Promise<unknown>>()
+      .mockResolvedValue({ success: true })
+    const queue = new ResourcePersistenceQueue({ persist, onError })
+
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, undefined, 'pending-chat-1')
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, undefined, 'chat-1')
+    await queue.flush('chat-1', 'pending-chat-1')
+
+    expect(persist).toHaveBeenCalledTimes(1)
+    expect(persist).toHaveBeenCalledWith('chat-1', { ...TABLE_RESOURCE, viewId: 'view-b' })
+  })
+
   it('remembers a stored resource until a failed deletion eventually succeeds', async () => {
     const persist = vi
       .fn<(chatId: string, update: MothershipResourceUpdate) => Promise<unknown>>()
@@ -228,14 +275,14 @@ describe('ResourcePersistenceQueue', () => {
     const remove = vi.fn().mockRejectedValueOnce(new Error('delete failed'))
     const queue = new ResourcePersistenceQueue({ persist, onError })
 
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1', TABLE_RESOURCE)
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-a' }, 'chat-1', 'chat-1', TABLE_RESOURCE)
     await Promise.allSettled(queue.getInFlightWrites('chat-1'))
 
     const firstRemoval = queue.remove(TABLE_RESOURCE.type, TABLE_RESOURCE.id, 'chat-1')
     firstRemoval.scheduleDelete('chat-1', remove)
     await Promise.allSettled(queue.getInFlightWrites('chat-1'))
 
-    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, 'chat-1')
+    queue.enqueue({ ...TABLE_RESOURCE, viewId: 'view-b' }, 'chat-1', 'chat-1')
     await Promise.allSettled(queue.getInFlightWrites('chat-1'))
 
     const secondRemoval = queue.remove(TABLE_RESOURCE.type, TABLE_RESOURCE.id, 'chat-1')