fix(tables): keep a cancelled dispatch cancelled when a step claims it

`dispatcherStep` reads the dispatch, then awaits the table load before writing
`dispatching`. Keying that write on the id alone resurrected a dispatch
cancelled inside that window — a Stop-all, or now the stale-dispatch sweep —
and the fresh heartbeat it writes would then buy the resurrected row another
full window before the sweep could reclaim it again.

The race predates the sweep, but the sweep is a new writer of `cancelled` that
no user action drives, so it is newly reachable without anyone touching Stop.
Re-asserting the status the step already read is the whole fix.

Author: waleedlatif1

apps/sim/lib/table/dispatcher.ts

@@ -411,7 +411,19 @@ export async function dispatcherStep(
       // cleanup sweep ages it from that rather than from `requested_at`, which
       // was stamped when the run was merely requested.
       .set({ status: 'dispatching', heartbeatAt: new Date() })
-      .where(eq(tableRunDispatches.id, dispatchId))
+      /**
+       * Re-asserts the status this step read two awaits ago. `dispatchId` alone
+       * would resurrect a dispatch cancelled in that window — a Stop-all, or now
+       * the stale-dispatch sweep — back to `dispatching`, and with a fresh
+       * heartbeat the sweep would then wait out another full window before
+       * reclaiming what it had already given up on.
+       */
+      .where(
+        and(
+          eq(tableRunDispatches.id, dispatchId),
+          inArray(tableRunDispatches.status, [...ACTIVE_DISPATCH_STATUSES])
+        )
+      )
     // Announce the dispatch the moment it starts — before the first window's
     // cells finish. Without this, auto-fired and capped dispatches (no client-
     // side optimistic seed) emit their first `dispatch` event only after window

apps/sim/lib/table/stale-dispatch-recovery.test.ts

@@ -4,15 +4,19 @@
 import { dbChainMockFns, resetDbChainMock } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockAppendTableEvent } = vi.hoisted(() => ({
+const { mockAppendTableEvent, mockGetTableById } = vi.hoisted(() => ({
   mockAppendTableEvent: vi.fn(),
+  mockGetTableById: vi.fn(),
 }))
 
 vi.mock('@/lib/table/events', () => ({
   appendTableEvent: mockAppendTableEvent,
 }))
+vi.mock('@/lib/table/service', () => ({
+  getTableById: mockGetTableById,
+}))
 
-import { cancelStaleDispatches } from '@/lib/table/dispatcher'
+import { cancelStaleDispatches, dispatcherStep } from '@/lib/table/dispatcher'
 
 const STALE_BEFORE = new Date('2026-08-21T17:00:00.000Z')
 
@@ -131,3 +135,47 @@ describe('cancelStaleDispatches', () => {
     expect(mockAppendTableEvent).not.toHaveBeenCalled()
   })
 })
+
+describe('dispatcherStep pending transition', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    resetDbChainMock()
+  })
+
+  /**
+   * The step reads the dispatch, then awaits the table load before writing
+   * `dispatching`. A cancel landing in that window — a Stop-all, or the
+   * stale-dispatch sweep — must win: keying the write on the id alone
+   * resurrected the row, and with a fresh heartbeat the sweep would then wait
+   * out another full window before reclaiming what it had already given up on.
+   */
+  it('re-asserts the status it read before claiming the dispatch', async () => {
+    mockGetTableById.mockResolvedValue({
+      id: 'table-1',
+      schema: { workflowGroups: [{ id: 'group-1' }] },
+    })
+    dbChainMockFns.limit.mockResolvedValue([{ ...ABANDONED_ROW, status: 'pending' }])
+
+    await dispatcherStep('tdsp_1').catch(() => {})
+
+    // The write must actually happen, or this asserts nothing.
+    expect(
+      dbChainMockFns.set.mock.calls.some(
+        (call) => (call[0] as Record<string, unknown> | undefined)?.status === 'dispatching'
+      )
+    ).toBe(true)
+
+    /**
+     * `set` and `where` are separate spies, so their call indexes do not pair —
+     * `readDispatch`'s own select filed a `where` first. Match on the predicate
+     * that only the claim can produce: this row's id AND its status together.
+     */
+    const claimPredicate = dbChainMockFns.where.mock.calls
+      .map((call) => collectChunks(call[0]))
+      .find(
+        (chunks) =>
+          chunks.includes('tableRunDispatches.id') && chunks.includes('tableRunDispatches.status')
+      )
+    expect(claimPredicate).toBeDefined()
+  })
+})