fix(table): row-scoped Refresh cancels in-flight; counter includes queued/pending

- runWorkflowColumn now cancels prior in-flight cells for row-scoped manual
  runs too (context-menu Refresh on a row subset, action-bar Refresh on
  selected rows). Previously only the table-wide path cancelled, so a
  row-scoped Refresh would bulk-clear running sidecar rows without aborting
  workers. Per-row cancel skips markActiveDispatchesCancelled so unrelated
  dispatches keep running.
- countRunningCells now counts all in-flight statuses (queued / running /
  pending) instead of just running. The row gutter Run/Stop button reads
  this map — with the old behavior, clicking Play during the queued window
  would re-enqueue an already-queued cell. SSE applyCell handler updated
  to use isExecInFlight so client deltas track the same semantics.

Author: TheodoreSpeaks

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

@@ -5,6 +5,7 @@ import { createLogger } from '@sim/logger'
 import { useQueryClient } from '@tanstack/react-query'
 import type { ActiveDispatch } from '@/lib/api/contracts/tables'
 import type { RowData, RowExecutionMetadata, RowExecutions } from '@/lib/table'
+import { isExecInFlight } from '@/lib/table/deps'
 import type { TableEvent, TableEventEntry } from '@/lib/table/events'
 import { snapshotAndMutateRows, type TableRunState, tableKeys } from '@/hooks/queries/tables'
 
@@ -74,11 +75,11 @@ export function useTableEventStream({
 
     const updateRunStateCounters = (
       rowId: string,
-      wasRunning: boolean,
-      isRunning: boolean
+      wasInFlight: boolean,
+      isInFlight: boolean
     ): void => {
-      if (wasRunning === isRunning) return
-      const delta = isRunning ? 1 : -1
+      if (wasInFlight === isInFlight) return
+      const delta = isInFlight ? 1 : -1
       queryClient.setQueryData<TableRunState>(tableKeys.activeDispatches(tableId), (prev) => {
         if (!prev) return prev
         const prevForRow = prev.runningByRowId[rowId] ?? 0
@@ -106,14 +107,18 @@ export function useTableEventStream({
         runningBlockIds,
         blockErrors,
       } = event
-      let wasRunning: boolean | null = null
+      let wasInFlight: boolean | null = null
       void snapshotAndMutateRows(
         queryClient,
         tableId,
         (row) => {
           if (row.id !== rowId) return null
           const prevExec = row.executions?.[groupId]
-          if (wasRunning === null) wasRunning = prevExec?.status === 'running'
+          // In-flight = queued | running | pending. Server's countRunningCells
+          // counts all three (the gutter Run/Stop button reads this map and
+          // needs Stop visible during queued too, else clicking Play would
+          // re-enqueue a cell that's already queued).
+          if (wasInFlight === null) wasInFlight = isExecInFlight(prevExec)
           const nextExec: RowExecutionMetadata = {
             status,
             executionId: executionId ?? null,
@@ -133,14 +138,18 @@ export function useTableEventStream({
         },
         { cancelInFlight: false }
       )
-      if (wasRunning === null) {
+      if (wasInFlight === null) {
         // Row outside the loaded page slice — can't compute the delta locally.
         // Refetch the run-state snapshot from the server. Cheap and rare.
         void queryClient.invalidateQueries({
           queryKey: tableKeys.activeDispatches(tableId),
         })
       } else {
-        updateRunStateCounters(rowId, wasRunning, status === 'running')
+        updateRunStateCounters(
+          rowId,
+          wasInFlight,
+          isExecInFlight({ status } as RowExecutionMetadata)
+        )
       }
     }
 

apps/sim/lib/table/dispatcher.ts

@@ -160,20 +160,27 @@ export async function insertDispatch(input: {
  *  active dispatch's scope ahead of its cursor are rendered as queued even
  *  before the dispatcher has reached them, so refresh during a long Run-all
  *  doesn't lose the queued indicators. */
-/** Counts cells across the entire table whose execution `status === 'running'`
- *  — the authoritative source for the "X running" badge. Cache-derived
- *  counters miss in-flight cells on rows outside the loaded page slice. */
+/** Counts in-flight cells (queued / running / pending) across the entire
+ *  table — the authoritative source for the "X running" badge and the per-row
+ *  gutter Run/Stop button. All three statuses are user-cancellable, so the
+ *  gutter must surface Stop whenever any of them are present (else clicking
+ *  Play during the queued window would re-run an already-queued cell).
+ *  Hits the `(table_id, status)` partial index on table_row_executions. */
 export async function countRunningCells(
   tableId: string
 ): Promise<{ total: number; byRowId: Record<string, number> }> {
-  // Hits the `(table_id, status)` partial index on table_row_executions.
   const rows = await db
     .select({
       rowId: tableRowExecutions.rowId,
       runningCount: sql<number>`count(*)::int`,
     })
     .from(tableRowExecutions)
-    .where(and(eq(tableRowExecutions.tableId, tableId), eq(tableRowExecutions.status, 'running')))
+    .where(
+      and(
+        eq(tableRowExecutions.tableId, tableId),
+        inArray(tableRowExecutions.status, ['queued', 'running', 'pending'])
+      )
+    )
     .groupBy(tableRowExecutions.rowId)
   let total = 0
   const byRowId: Record<string, number> = {}

apps/sim/lib/table/workflow-columns.ts

@@ -488,19 +488,31 @@ export async function runWorkflowColumn(opts: {
     './dispatcher'
   )
 
-  // For table-wide manual runs (Run all rows / Run column), cancel any prior
-  // active dispatches AND their in-flight cells before clearing. Without this:
+  // For manual runs (Run all rows / Run column / Refresh-row / Refresh-cell),
+  // cancel any prior active dispatches AND in-flight cells in scope before
+  // clearing. Without this:
   //  - Two dispatcher loops would walk overlapping rows and burn duplicate work.
   //  - mode:'all' bulk-clear deletes in-flight sidecar rows without aborting
   //    workers — those would keep writing into the wiped state.
-  // Row-scoped callers (dep-edit cascade in `updateRow`) already cancel their
-  // specific scope before calling here, so we skip to avoid cancelling
-  // unrelated dispatches on other rows. Auto-fire (`mode:'new'`) is harmless
-  // overlap-wise since the NOT EXISTS filter excludes already-attempted rows.
-  const cancelPriorRuns =
-    isManualRun && (!rowIds || rowIds.length === 0) && (mode === 'all' || mode === 'incomplete')
+  // Scope: table-wide cancel when rowIds is empty (also cancels active
+  // dispatches via markActiveDispatchesCancelled), per-row cancel otherwise
+  // (no dispatch cancel — other rows' dispatches keep running). Dep-edit
+  // cascade in `updateRow` already cancels its own scope before calling,
+  // so the duplicate work here is a cheap no-op for that caller.
+  // Auto-fire (`mode:'new'`) is harmless overlap-wise — the NOT EXISTS
+  // filter excludes already-attempted rows.
+  const cancelPriorRuns = isManualRun && (mode === 'all' || mode === 'incomplete')
   if (cancelPriorRuns) {
-    await cancelWorkflowGroupRuns(tableId, undefined, { groupIds: targetGroupIds })
+    if (!rowIds || rowIds.length === 0) {
+      await cancelWorkflowGroupRuns(tableId, undefined, { groupIds: targetGroupIds })
+    } else {
+      // Per-row cancel — sequential so we don't fan out N parallel
+      // markActiveDispatchesCancelled calls (it's a no-op when rowId is set,
+      // but each call still touches the DB).
+      for (const rowId of rowIds) {
+        await cancelWorkflowGroupRuns(tableId, rowId, { groupIds: targetGroupIds })
+      }
+    }
   }
 
   // Wipe targeted output cols + executions[gid] before any cells fire so the