fix(tables): unstick cells + resync counter on usage-limit halt

Addresses PR review:
- Clear each blocked cell's pre-stamp on a 402 so it reverts to un-run instead
  of being stuck "Queued" (no error/cancelled badge); covers auto-fire cells
  with no owning dispatch.
- Client re-syncs run-state counts and refetches rows on usageLimitReached so
  the stale "X running" / Stop-all control clears and queued cells drop.
- Make usageLimitReached.dispatchId optional; client only touches the dispatch
  overlay when present.

Author: TheodoreSpeaks

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/hooks/use-table-event-stream.ts

@@ -46,7 +46,7 @@ interface UseTableEventStreamArgs {
   enabled?: boolean
   /** Fired when the server halts a dispatch because the billed account is over
    *  its usage limit. The page surfaces an upgrade prompt + redirect. */
-  onUsageLimitReached?: (event: { dispatchId: string; message: string }) => void
+  onUsageLimitReached?: (event: { dispatchId?: string; message: string }) => void
 }
 
 /**
@@ -215,12 +215,23 @@ export function useTableEventStream({
 
     const applyUsageLimit = (event: Extract<TableEvent, { kind: 'usageLimitReached' }>): void => {
       // Drop the halted dispatch from the overlay so the "running" UI clears
-      // immediately (the dispatcher was marked complete server-side).
-      queryClient.setQueryData<TableRunState>(tableKeys.activeDispatches(tableId), (prev) => {
-        if (!prev) return prev
-        const filtered = prev.dispatches.filter((d) => d.id !== event.dispatchId)
-        return filtered.length === prev.dispatches.length ? prev : { ...prev, dispatches: filtered }
-      })
+      // immediately (the dispatcher was marked complete server-side). Cascade /
+      // auto-fire events carry no dispatchId — nothing to remove.
+      if (event.dispatchId) {
+        queryClient.setQueryData<TableRunState>(tableKeys.activeDispatches(tableId), (prev) => {
+          if (!prev) return prev
+          const filtered = prev.dispatches.filter((d) => d.id !== event.dispatchId)
+          return filtered.length === prev.dispatches.length
+            ? prev
+            : { ...prev, dispatches: filtered }
+        })
+      }
+      // Blocked cells are left `queued` in the DB with no terminal cell event,
+      // so `runningByRowId` would otherwise stay non-zero (stale "X running").
+      // Re-sync the server counts, and refetch rows so cells whose pre-stamps
+      // the server cleared drop their "Queued" state.
+      scheduleDispatchInvalidate()
+      void queryClient.invalidateQueries({ queryKey: tableKeys.rowsRoot(tableId) })
       onUsageLimitReachedRef.current?.({ dispatchId: event.dispatchId, message: event.message })
     }
 

apps/sim/background/workflow-column-execution.ts

@@ -429,10 +429,24 @@ async function runWorkflowAndWriteTerminal(
           logger.warn(
             `Usage limit reached — halting dispatch (table=${tableId} row=${rowId} group=${groupId})`
           )
+          // Don't leave the cell stuck on its `pending` pre-stamp. Clear this
+          // cell's exec so it reverts to un-run (no error/cancelled badge —
+          // matching "don't mark"; re-runnable after upgrade). Each blocked
+          // cell clears its own.
+          const { updateRow } = await import('@/lib/table/service')
+          await updateRow(
+            { tableId, rowId, data: {}, workspaceId, executionsPatch: { [groupId]: null } },
+            table,
+            requestId
+          ).catch((err) =>
+            logger.warn(`Failed to clear cell pre-stamp on usage limit`, {
+              error: toError(err).message,
+            })
+          )
           // With up to 20 concurrent cells all hitting the limit at once, only
-          // the cell that actually transitions the dispatch active→complete
-          // emits the event — otherwise the user sees a toast per in-flight
-          // cell. Cells with no owning dispatch (auto-fire) always emit.
+          // the cell that transitions the dispatch active→complete emits the
+          // event — otherwise the user sees a toast per in-flight cell. Cells
+          // with no owning dispatch (auto-fire) always emit.
           let shouldEmit = true
           if (dispatchId) {
             const { completeDispatchIfActive } = await import('@/lib/table/dispatcher')
@@ -442,7 +456,7 @@ async function runWorkflowAndWriteTerminal(
             await appendTableEvent({
               kind: 'usageLimitReached',
               tableId,
-              dispatchId: dispatchId ?? '',
+              ...(dispatchId ? { dispatchId } : {}),
               message:
                 preprocess.error?.message ??
                 'Usage limit exceeded. Please upgrade your plan to continue.',

apps/sim/lib/table/events.ts

@@ -116,11 +116,12 @@ export type TableEvent =
   | {
       /** A dispatch was stopped because the billed account is over its usage
        *  limit. The client surfaces an upgrade prompt and redirects to billing.
-       *  Cells are intentionally left untouched (no error/cancelled marking);
-       *  the dispatch is halted via `markDispatchComplete`. */
+       *  The dispatch is halted via `markDispatchComplete` and the blocked
+       *  cells' pre-stamps are cleared so they revert to un-run. `dispatchId`
+       *  is absent for cascade/auto-fire payloads with no owning dispatch. */
       kind: 'usageLimitReached'
       tableId: string
-      dispatchId: string
+      dispatchId?: string
       message: string
     }