fix(tables): address PR review on dispatch cap + cascade drain

- Don't consume the row cap when batchEnqueueAndWait fails; a transient
  failure no longer completes a capped dispatch with zero rows started.
- Outer cascade-drain loop only re-drives a genuine queued marker, not any
  eligible group, so an empty-output group can't re-run forever.
- completeDispatch forwards limit on the terminal SSE event.
- Extract shared LIMITED_RUN_PRESETS for the Run-N-rows menu items.

Author: TheodoreSpeaks

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/headers/workflow-group-meta-cell.tsx

@@ -31,6 +31,11 @@ import type { DisplayColumn } from '../types'
 
 const WORKFLOW_META_BG_ALPHA = 12 // 0–255
 
+/** Fixed row-cap presets for the "Run N empty rows" shortcuts. Shared by the
+ *  group-header options menu and the inline quick-run dropdown so the two
+ *  surfaces stay in sync. */
+const LIMITED_RUN_PRESETS = [10, 1000] as const
+
 interface ColumnOptionsMenuProps {
   open: boolean
   onOpenChange: (open: boolean) => void
@@ -133,16 +138,12 @@ export function ColumnOptionsMenu({
                 <DropdownMenuItem onSelect={() => onRunColumnIncomplete?.()}>
                   Run empty rows
                 </DropdownMenuItem>
-                {onRunColumnLimited && (
-                  <>
-                    <DropdownMenuItem onSelect={() => onRunColumnLimited(10)}>
-                      Run 10 empty rows
-                    </DropdownMenuItem>
-                    <DropdownMenuItem onSelect={() => onRunColumnLimited(1000)}>
-                      Run 1,000 empty rows
+                {onRunColumnLimited &&
+                  LIMITED_RUN_PRESETS.map((max) => (
+                    <DropdownMenuItem key={max} onSelect={() => onRunColumnLimited(max)}>
+                      {`Run ${max.toLocaleString()} empty rows`}
                     </DropdownMenuItem>
-                  </>
-                )}
+                  ))}
               </DropdownMenuSubContent>
             </DropdownMenuSub>
             <DropdownMenuSeparator />
@@ -448,12 +449,11 @@ export function WorkflowGroupMetaCell({
               )}
               <DropdownMenuItem onSelect={handleRunAll}>Run all rows</DropdownMenuItem>
               <DropdownMenuItem onSelect={handleRunIncomplete}>Run empty rows</DropdownMenuItem>
-              <DropdownMenuItem onSelect={() => handleRunLimited(10)}>
-                Run 10 empty rows
-              </DropdownMenuItem>
-              <DropdownMenuItem onSelect={() => handleRunLimited(1000)}>
-                Run 1,000 empty rows
-              </DropdownMenuItem>
+              {LIMITED_RUN_PRESETS.map((max) => (
+                <DropdownMenuItem key={max} onSelect={() => handleRunLimited(max)}>
+                  {`Run ${max.toLocaleString()} empty rows`}
+                </DropdownMenuItem>
+              ))}
             </DropdownMenuContent>
           </DropdownMenu>
         )}

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

@@ -57,6 +57,15 @@ export async function executeWorkflowGroupCellJob(
     if (!freshRow) break
     const next = pickNextEligibleGroupForRow(freshTable, freshRow)
     if (!next) break
+    // Only re-drive a genuine queued marker (an explicit run request whose
+    // cell-task bailed during our release window). The inner cascade loop has
+    // already drained every auto-eligible group, so re-driving a non-marker
+    // group here would re-run forever — e.g. a group that completed with empty
+    // outputs stays auto-eligible (the inner loop excludes it via
+    // `excludeGroupId`, but this outer pass has no such anchor).
+    const nextExec = freshRow.executions?.[next.id]
+    const hasQueuedMarker = nextExec?.status === 'pending' && nextExec.executionId == null
+    if (!hasQueuedMarker) break
     currentPayload = {
       ...currentPayload,
       groupId: next.id,

apps/sim/lib/table/dispatcher.ts

@@ -492,6 +492,13 @@ export async function dispatcherStep(dispatchId: string): Promise<DispatcherStep
       logger.error(`[${dispatchId}] batch dispatch failed`, {
         error: toError(err).message,
       })
+      // These rows never actually ran, so they must not consume the row cap —
+      // otherwise a transient failure on the only window of a `max: N` run would
+      // exhaust the budget and complete the dispatch with zero rows started.
+      // The cursor still advances past the window (cells are flipped to a
+      // re-runnable `error` below), so later windows fulfill the remaining cap.
+      dispatchedRows = 0
+      budgetExhausted = false
       // Cursor advances past this window, so flip the un-claimed pre-stamps to
       // terminal `error` (+ SSE) — visible, not stuck pending, re-runnable.
       const failedAt = new Date()
@@ -573,6 +580,7 @@ async function completeDispatch(dispatch: DispatchRow, cursor: number): Promise<
     cursor,
     mode: dispatch.mode,
     isManualRun: dispatch.isManualRun,
+    ...(dispatch.limit ? { limit: dispatch.limit } : {}),
   })
 }