fix(table): seed dispatch overlay on Run; surface batch-enqueue failures as error

- useRunColumn.onSuccess invalidates the activeDispatches query so the
  resolveCellExec queued overlay populates immediately for ahead-of-cursor
  rows (scrolled-in / refetched), instead of waiting for the first dispatch
  SSE. Targeted at activeDispatches only — the rows cache stays owned by
  useTableEventStream.
- On batchEnqueueAndWait failure, dispatcherStep now flips the orphan
  pre-stamps to a terminal `error` state and emits a cell SSE event, rather
  than deleting them. The cursor still advances past the window, but the
  dropped cells are now visible (Error pill) instead of silently empty, stay
  out of the in-flight set, and re-run on the next manual run.

Author: TheodoreSpeaks

apps/sim/hooks/queries/tables.ts

@@ -1377,9 +1377,17 @@ export function useRunColumn({ workspaceId, tableId }: RowMutationContext) {
     onError: (_err, _variables, context) => {
       if (context?.snapshots) restoreCachedWorkflowCells(queryClient, context.snapshots)
     },
-    // No reconciliation here — useTableEventStream is the source of truth for
-    // post-mutation cache state, and a refetch would race its incremental
-    // patches.
+    onSuccess: () => {
+      // Seed the active-dispatch overlay from the server. `runWorkflowColumn`
+      // inserts the dispatch row synchronously before responding, so the
+      // refetch picks it up immediately — this drives `resolveCellExec`'s
+      // queued overlay for rows ahead of the cursor (scrolled-in / refetched
+      // rows that have no real exec yet) without waiting for the first
+      // `kind: 'dispatch'` SSE. Targeted at activeDispatches only — NOT the
+      // rows cache, which `useTableEventStream` owns (a rows refetch would
+      // race its incremental patches).
+      void queryClient.invalidateQueries({ queryKey: tableKeys.activeDispatches(tableId) })
+    },
   })
 }
 

apps/sim/lib/table/dispatcher.ts

@@ -399,16 +399,21 @@ export async function dispatcherStep(dispatchId: string): Promise<DispatcherStep
       logger.error(`[${dispatchId}] batch dispatch failed`, {
         error: toError(err).message,
       })
-      // Reset the orphan pre-stamps so the cells don't render "Queued" forever.
-      // Without this sweep, `pending + null executionId` rows stay until a user
-      // re-triggers the row. The classifyEligibility carve-out lets future
-      // dispatchers re-claim, but the current dispatch has already advanced
-      // its cursor past these rows. Deleting the pre-stamps lets the next
-      // explicit Run pick them up cleanly.
+      // The enqueue failed (e.g. trigger.dev API down) — these cells never
+      // ran. The cursor still advances past this window below, so they won't
+      // be retried in this dispatch. Flip the orphan pre-stamps to a terminal
+      // `error` state (with an SSE event) instead of deleting them: the
+      // failure stays visible to the user (Error pill, not a silently-empty
+      // cell), the cells aren't stuck `pending` forever, and `error` cells
+      // re-run on the next manual run (classifyEligibility treats error as
+      // eligible for manual / incomplete). Guarded on `pending + null
+      // executionId` so we only touch our own un-claimed pre-stamps.
+      const failedAt = new Date()
       await Promise.allSettled(
-        pendingRuns.map((p) =>
-          db
-            .delete(tableRowExecutions)
+        pendingRuns.map(async (p) => {
+          const updated = await db
+            .update(tableRowExecutions)
+            .set({ status: 'error', error: 'Failed to enqueue run', updatedAt: failedAt })
             .where(
               and(
                 eq(tableRowExecutions.rowId, p.rowId),
@@ -417,7 +422,19 @@ export async function dispatcherStep(dispatchId: string): Promise<DispatcherStep
                 sql`${tableRowExecutions.executionId} IS NULL`
               )
             )
-        )
+            .returning({ rowId: tableRowExecutions.rowId })
+          if (updated.length === 0) return
+          await appendTableEvent({
+            kind: 'cell',
+            tableId: dispatch.tableId,
+            rowId: p.rowId,
+            groupId: p.groupId,
+            status: 'error',
+            executionId: null,
+            jobId: null,
+            error: 'Failed to enqueue run',
+          })
+        })
       )
     }
   }