fix(tables): dedupe usage-limit event + release rate-limited cells on cancel

Addresses PR review:
- Usage limit: only the cell that transitions the dispatch active→complete
  (via completeDispatchIfActive) emits usageLimitReached, so concurrent cells
  don't fire up to 20 identical "upgrade" toasts.
- Rate-limit retry: re-check the cancelled tombstone after each sleep so a
  Stop All mid-wait releases the concurrency slot promptly (signal never fires
  on the trigger.dev backend).

Author: TheodoreSpeaks

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

@@ -429,18 +429,25 @@ async function runWorkflowAndWriteTerminal(
           logger.warn(
             `Usage limit reached — halting dispatch (table=${tableId} row=${rowId} group=${groupId})`
           )
+          // 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.
+          let shouldEmit = true
           if (dispatchId) {
-            const { markDispatchComplete } = await import('@/lib/table/dispatcher')
-            await markDispatchComplete(dispatchId)
+            const { completeDispatchIfActive } = await import('@/lib/table/dispatcher')
+            shouldEmit = await completeDispatchIfActive(dispatchId)
+          }
+          if (shouldEmit) {
+            await appendTableEvent({
+              kind: 'usageLimitReached',
+              tableId,
+              dispatchId: dispatchId ?? '',
+              message:
+                preprocess.error?.message ??
+                'Usage limit exceeded. Please upgrade your plan to continue.',
+            })
           }
-          await appendTableEvent({
-            kind: 'usageLimitReached',
-            tableId,
-            dispatchId: dispatchId ?? '',
-            message:
-              preprocess.error?.message ??
-              'Usage limit exceeded. Please upgrade your plan to continue.',
-          })
           return 'blocked'
         }
         await writeState({
@@ -486,6 +493,12 @@ async function runWorkflowAndWriteTerminal(
           `Rate limited — waiting ${Math.round(waitMs)}ms before retry ${attempt + 1} (table=${tableId} row=${rowId} group=${groupId})`
         )
         await sleep(waitMs)
+        // Stop All can land mid-wait. On the trigger.dev backend `signal` never
+        // fires (cancelByKey is a no-op there), so re-check the DB tombstone and
+        // release this concurrency slot promptly instead of sleeping out the
+        // full retry budget.
+        const refreshed = await getRowById(tableId, rowId, workspaceId)
+        if (!refreshed || cancelledBeforeRun(refreshed.executions?.[groupId])) return 'error'
       }
 
       // SQL guard also rejects if a stop click stamped `cancelled` between this

apps/sim/lib/table/dispatcher.ts

@@ -646,6 +646,24 @@ export async function markDispatchComplete(dispatchId: string): Promise<void> {
     .where(eq(tableRunDispatches.id, dispatchId))
 }
 
+/** Complete a dispatch only if it's still active, returning whether THIS call
+ *  performed the transition. Lets concurrent cells that all hit a hard stop
+ *  (e.g. usage limit) elect a single owner — only the winner emits the
+ *  user-facing event, instead of one toast per in-flight cell. */
+export async function completeDispatchIfActive(dispatchId: string): Promise<boolean> {
+  const transitioned = await db
+    .update(tableRunDispatches)
+    .set({ status: 'complete', completedAt: new Date() })
+    .where(
+      and(
+        eq(tableRunDispatches.id, dispatchId),
+        inArray(tableRunDispatches.status, [...ACTIVE_DISPATCH_STATUSES])
+      )
+    )
+    .returning({ id: tableRunDispatches.id })
+  return transitioned.length > 0
+}
+
 export async function markDispatchCancelled(dispatchId: string): Promise<void> {
   await db
     .update(tableRunDispatches)