fix(table): waiting state, optimistic UX, schema-mutation polling, exec cleanup

A bundle of small UX + correctness fixes around workflow-cell run state.

cell-render.tsx
- In-flight (queued/running/pending) now wins over the existing value, so
  re-runs surface immediately instead of looking like nothing happened until
  the worker writes the new value.
- "Waiting on X" wins over a stale `cancelled` / `error` exec when deps are
  unmet — clearing a dep now reads as actionable instead of stuck.

useRunColumn (hooks/queries/tables.ts)
- onSettled now cancels in-flight polls before invalidating. Stops a poll
  that landed mid-mutation from clobbering the optimistic state with stale
  data, which produced the queued → cancelled → queued flicker.

addWorkflowGroup / updateWorkflowGroup (autoRun toggle on)
- Awaits scheduleRunsForTable instead of fire-and-forget. The route returned
  before the queued exec stamps committed, so the post-mutation refetch saw
  no in-flight cells and polling never started — cells looked stuck even
  though the server eventually stamped them.

deleteColumn / deleteColumns
- Strip orphaned executions[gid] keys when deleting a column orphans its
  parent group. Without this, stale running/queued exec records lingered on
  every row forever and inflated the page-header "N running" counter even
  on tables with no actually-running cells.

UI
- Action-bar leading label: "Selected N workflow cell(s)".
- Context menu: Run / Refresh items mirror the action bar's Play / Refresh
  split, gated on the same selection-status flags so both surfaces show the
  actions that match the current state.

Author: TheodoreSpeaks

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/context-menu/context-menu.tsx

@@ -12,6 +12,7 @@ import {
   Eye,
   Pencil,
   PlayOutline,
+  RefreshCw,
   Square,
   Trash,
 } from '@/components/emcn/icons'
@@ -29,8 +30,12 @@ interface ContextMenuProps {
   canViewExecution?: boolean
   canEditCell?: boolean
   selectedRowCount?: number
-  /** Fires every workflow group on the row(s) the context menu is acting on. */
+  /** Fires every workflow group on the row(s), skipping already-completed
+   *  cells. Mirrors the action bar's Play. */
   onRunWorkflows?: () => void
+  /** Re-runs every workflow group on the row(s), including already-completed
+   *  cells. Mirrors the action bar's Refresh. */
+  onRefreshWorkflows?: () => void
   /** Cancels every running/queued execution on the row(s) the context menu is acting on. */
   onStopWorkflows?: () => void
   /** Total running/queued executions across the row(s) under the context menu. Drives the Stop label and visibility. */
@@ -55,6 +60,7 @@ export function ContextMenu({
   canEditCell = true,
   selectedRowCount = 1,
   onRunWorkflows,
+  onRefreshWorkflows,
   onStopWorkflows,
   runningInSelectionCount = 0,
   hasWorkflowColumns = false,
@@ -64,7 +70,11 @@ export function ContextMenu({
 }: ContextMenuProps) {
   const deleteLabel = selectedRowCount > 1 ? `Delete ${selectedRowCount} rows` : 'Delete row'
   const runLabel =
-    selectedRowCount > 1 ? `Run workflows on ${selectedRowCount} rows` : 'Run workflows on row'
+    selectedRowCount > 1
+      ? `Run empty or failed cells on ${selectedRowCount} rows`
+      : 'Run empty or failed cells'
+  const refreshLabel =
+    selectedRowCount > 1 ? `Re-run all cells on ${selectedRowCount} rows` : 'Re-run all cells'
   const stopLabel =
     runningInSelectionCount === 1
       ? 'Stop running workflow'
@@ -114,6 +124,12 @@ export function ContextMenu({
             {runLabel}
           </DropdownMenuItem>
         )}
+        {hasWorkflowColumns && onRefreshWorkflows && (
+          <DropdownMenuItem disabled={disableEdit} onSelect={onRefreshWorkflows}>
+            <RefreshCw />
+            {refreshLabel}
+          </DropdownMenuItem>
+        )}
         {hasWorkflowColumns && onStopWorkflows && runningInSelectionCount > 0 && (
           <DropdownMenuItem disabled={disableEdit} onSelect={onStopWorkflows}>
             <Square className='h-[14px] w-[14px] text-[var(--text-icon)]' />

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-action-bar/table-action-bar.tsx

@@ -90,7 +90,9 @@ export function TableActionBar({
         >
           <div className='pointer-events-auto flex items-center gap-2 rounded-[10px] border border-[var(--border)] bg-[var(--surface-2)] px-2 py-1.5'>
             <span className='px-1 text-[var(--text-secondary)] text-small'>
-              {selectedCellCount === 1 ? 'Cell' : `${selectedCellCount} cells`}
+              {selectedCellCount === 1
+                ? 'Selected 1 workflow cell'
+                : `Selected ${selectedCellCount} workflow cells`}
             </span>
 
             <div className='flex items-center gap-[5px]'>

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx

@@ -75,8 +75,12 @@ export function resolveCellRender({
     const groupHasBlockErrors = !!(exec?.blockErrors && Object.keys(exec.blockErrors).length > 0)
 
     if (blockError) return { kind: 'block-error' }
-    if (!isNull) return { kind: 'value', text: stringifyValue(value) }
 
+    // In-flight wins over the existing value: when the group is being re-run,
+    // the current value is about to be overwritten — surface the run state so
+    // the user sees the cell is changing. Without this, a queued / running
+    // re-run on a previously-completed cell looks like nothing happened until
+    // the new value lands.
     const inFlight =
       exec?.status === 'running' || exec?.status === 'queued' || exec?.status === 'pending'
     if (inFlight && !(groupHasBlockErrors && !blockRunning)) {
@@ -87,11 +91,17 @@ export function resolveCellRender({
       return { kind: 'pending-upstream' }
     }
 
-    if (exec?.status === 'cancelled') return { kind: 'cancelled' }
-    if (exec?.status === 'error') return { kind: 'error' }
+    if (!isNull) return { kind: 'value', text: stringifyValue(value) }
+
+    // Waiting wins over a stale terminal state: if deps are unmet right now,
+    // the prior `cancelled` / `error` is informational at best — the cell
+    // can't actually run until the user fills the missing input. Surface the
+    // actionable state instead of the stale one.
     if (waitingOnLabels && waitingOnLabels.length > 0) {
       return { kind: 'waiting', labels: waitingOnLabels }
     }
+    if (exec?.status === 'cancelled') return { kind: 'cancelled' }
+    if (exec?.status === 'error') return { kind: 'error' }
     return { kind: 'empty' }
   }
 

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx

@@ -2581,13 +2581,16 @@ export function TableGrid({
   }, [rows])
 
   // Context-menu wrappers: act on `contextMenuRowIds`, then close the menu.
-  // `'incomplete'` mirrors the per-row gutter Play button — both gestures mean
-  // "fill in what's missing." Use the action bar's explicit Rerun button when
-  // re-running already-completed cells is wanted.
+  // Mirror the action bar's Play / Refresh split: Play fills empty/failed,
+  // Refresh re-runs everything (including completed cells).
   const handleRunWorkflowsOnSelection = () => {
     onRunRows(contextMenuRowIds, 'incomplete')
     closeContextMenu()
   }
+  const handleRefreshWorkflowsOnSelection = () => {
+    onRunRows(contextMenuRowIds, 'all')
+    closeContextMenu()
+  }
   const handleStopWorkflowsOnSelection = () => {
     onStopRows(contextMenuRowIds)
     closeContextMenu()
@@ -2668,6 +2671,31 @@ export function TableGrid({
     [tableWorkflowGroups]
   )
 
+  // Status mix across the (row, group) cells the context menu is acting on.
+  // Drives Run vs Refresh visibility in the dropdown — same shape the action
+  // bar uses for its selectionStats so both surfaces stay in sync.
+  const contextMenuStats = useMemo(() => {
+    let hasIncompleteOrFailed = false
+    let hasCompleted = false
+    if (contextMenuRowIds.length === 0 || tableWorkflowGroupIds.length === 0) {
+      return { hasIncompleteOrFailed, hasCompleted }
+    }
+    const rowIdSet = new Set(contextMenuRowIds)
+    for (const row of rows) {
+      if (!rowIdSet.has(row.id)) continue
+      for (const groupId of tableWorkflowGroupIds) {
+        const status = readExecution(row, groupId)?.status
+        if (status === 'queued' || status === 'running' || status === 'pending') continue
+        if (status === 'completed') hasCompleted = true
+        else hasIncompleteOrFailed = true
+        if (hasIncompleteOrFailed && hasCompleted) {
+          return { hasIncompleteOrFailed, hasCompleted }
+        }
+      }
+    }
+    return { hasIncompleteOrFailed, hasCompleted }
+  }, [contextMenuRowIds, rows, tableWorkflowGroupIds])
+
   // Run scope is derived from one of two selection sources:
   //   - checkedRows (whole-row selection) → those rows × every workflow group
   //   - normalizedSelection rectangle covering workflow-output columns →
@@ -3099,7 +3127,14 @@ export function TableGrid({
         canEditCell={!contextMenuIsWorkflowColumn}
         selectedRowCount={selectedRowCount}
         onRunWorkflows={
-          userPermissions.canEdit && hasWorkflowColumns ? handleRunWorkflowsOnSelection : undefined
+          userPermissions.canEdit && hasWorkflowColumns && contextMenuStats.hasIncompleteOrFailed
+            ? handleRunWorkflowsOnSelection
+            : undefined
+        }
+        onRefreshWorkflows={
+          userPermissions.canEdit && hasWorkflowColumns && contextMenuStats.hasCompleted
+            ? handleRefreshWorkflowsOnSelection
+            : undefined
         }
         onStopWorkflows={
           userPermissions.canEdit && hasWorkflowColumns ? handleStopWorkflowsOnSelection : undefined

apps/sim/hooks/queries/tables.ts

@@ -1186,8 +1186,13 @@ export function useRunColumn({ workspaceId, tableId }: RowMutationContext) {
     onError: (_err, _variables, context) => {
       if (context?.snapshots) restoreCachedWorkflowCells(queryClient, context.snapshots)
     },
-    onSettled: () => {
-      queryClient.invalidateQueries({ queryKey: tableKeys.rowsRoot(tableId) })
+    onSettled: async () => {
+      // Cancel any in-flight poll first — without this, a poll started during
+      // the mutation but lands AFTER it resolves can clobber the optimistic
+      // patch with stale data, producing a queued → cancelled → queued flicker
+      // before the authoritative refetch arrives.
+      await queryClient.cancelQueries({ queryKey: tableKeys.rowsRoot(tableId) })
+      await queryClient.invalidateQueries({ queryKey: tableKeys.rowsRoot(tableId) })
     },
   })
 }

apps/sim/lib/table/service.ts

@@ -2425,6 +2425,15 @@ export async function deleteColumn(
     await trx.execute(
       sql`UPDATE user_table_rows SET data = data - ${actualName}::text WHERE table_id = ${data.tableId} AND data ? ${actualName}::text`
     )
+    // If deleting this column orphaned its parent group (last output gone),
+    // strip the group's exec entries from every row. Otherwise stale
+    // running/queued exec records linger forever and inflate the
+    // "N running" counter.
+    if (groupRemovedId) {
+      await trx.execute(
+        sql`UPDATE user_table_rows SET executions = executions - ${groupRemovedId}::text WHERE table_id = ${data.tableId} AND executions ? ${groupRemovedId}::text`
+      )
+    }
   })
 
   logger.info(`[${requestId}] Deleted column "${actualName}" from table ${data.tableId}`)
@@ -2527,6 +2536,13 @@ export async function deleteColumns(
         sql`UPDATE user_table_rows SET data = data - ${name}::text WHERE table_id = ${data.tableId} AND data ? ${name}::text`
       )
     }
+    // Strip exec entries for any group orphaned by these column deletes —
+    // see `deleteColumn` for rationale.
+    for (const gid of removedGroupIds) {
+      await trx.execute(
+        sql`UPDATE user_table_rows SET executions = executions - ${gid}::text WHERE table_id = ${data.tableId} AND executions ? ${gid}::text`
+      )
+    }
   })
 
   logger.info(
@@ -2781,10 +2797,15 @@ export async function addWorkflowGroup(
   // Schedule existing rows so already-filled deps trigger immediately. Skipped
   // when the caller opted out (Mothership stages groups silently — `autoRun:
   // false` — so the AI can compose multiple changes without firing rows mid-edit).
+  // Awaited (not `void`) so the response includes the queued exec state — the
+  // client's post-mutation refetch otherwise lands before the stamps commit
+  // and the rows query polling never starts.
   if (data.autoRun !== false) {
-    void scheduleRunsForTable(updatedTable).catch((err) => {
+    try {
+      await scheduleRunsForTable(updatedTable)
+    } catch (err) {
       logger.error(`[${requestId}] Failed to schedule runs after group add:`, err)
-    })
+    }
   }
 
   return updatedTable
@@ -3068,11 +3089,14 @@ export async function updateWorkflowGroup(
 
   // autoRun toggled false → true: fire deps-satisfied rows now. Mirrors the
   // post-add scheduling path so re-enabling auto-fire doesn't require manual
-  // run clicks for rows that are already eligible.
+  // run clicks for rows that are already eligible. Awaited so the post-
+  // mutation refetch sees the queued exec stamps.
   if (group.autoRun === false && data.autoRun === true) {
-    void scheduleRunsForTable(updatedTable, { groupId: data.groupId }).catch((err) => {
+    try {
+      await scheduleRunsForTable(updatedTable, { groupId: data.groupId })
+    } catch (err) {
       logger.error(`[${requestId}] Failed to schedule runs after autoRun toggled on:`, err)
-    })
+    }
   }
 
   return updatedTable