feat(table): backend running counter, dep-aware retrigger, sidebar polish

Counter (Fix 1): top-right "X running" + per-row badge are now
backend-bootstrapped via a count on `user_table_rows.executions ->> 'status'
= 'running'` returned alongside active dispatches. SSE `kind: 'cell'` events
compute a delta from `prev → next` status to keep the cache live; cell
events for rows outside the loaded page slice trigger a run-state refetch.
On `pruned` we invalidate the cache. Counts only worker-claimed `running`
cells — optimistic queued/pending no longer inflate the badge, and rows
outside the loaded page slice are counted too.

Sidebar (Fix 2 + 3a): `Run after` no longer ticks every column by default
for new groups (empty list). Save is disabled with an inline error when
auto-run is on with zero deps. `edit-group` mode anchors the left-of-current
filter to the group's leftmost column, so a workflow can only depend on
columns to its left.

Reorder scrub (Fix 3b): `updateTableMetadata` walks the schema's workflow
groups when `columnOrder` is in the patch and drops any dep whose new
position lands at or after the group's leftmost column (uses the existing
`stripGroupDeps` helper). Metadata + schema updates land atomically.

Server returns ordered columns (Fix 3b cont'd): `getTableById` /
`listTables` now sort `schema.columns` by `metadata.columnOrder` before
returning, via a new `applyColumnOrderToSchema` helper. Every consumer
(grid, sidebar, copilot, mothership) gets one ordered list — the sidebar's
leftmost-group-column anchor now points at the right index.

Dep-aware retrigger (Fix 4): editing a value that a downstream workflow
depends on now re-runs that workflow.
- `deriveExecClearsForDataPatch` returns
  `{ executionsPatch, inFlightDownstreamGroups }`. Walks
  `schema.workflowGroups[].dependencies.columns` for every column in the
  patch, clears terminal-state downstream entries, and reports in-flight
  entries.
- `updateRow` calls `cancelWorkflowGroupRuns` + `runWorkflowColumn`
  (`mode: 'incomplete' + isManualRun: true`) for in-flight downstream
  groups, then always fires `runWorkflowColumn({ mode: 'new' })` for the
  cleared groups. Skips both when `executionsPatch` is provided by the
  caller — those are cell-task / cancel writes that would otherwise spawn
  a recursive flood of dispatches per partial-write.
- `cancelWorkflowGroupRuns(tableId, rowId, { groupIds? })` accepts a
  per-group filter so the cancel only touches the affected groups, not
  every in-flight cell on the row.
- `pickNextEligibleGroupForRow` now treats a dispatcher pre-stamp
  (`pending` + `executionId: null`) as claimable — the cascade-loop is the
  real owner. Without this, the dispatcher's pre-stamp of downstream
  groups made the cascade-loop see them as "in-flight" and skip them,
  stranding `pending` cells forever.
- `optimisticallyScheduleNewlyEligibleGroups` extends the cache patch to
  flip dep-touched groups to `pending` regardless of their current status,
  matching the server's cancel-then-rerun behavior.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: TheodoreSpeaks

apps/sim/app/api/table/[tableId]/dispatches/route.ts

@@ -5,7 +5,7 @@ import { parseRequest } from '@/lib/api/server'
 import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
-import { listActiveDispatches } from '@/lib/table/dispatcher'
+import { countRunningCells, listActiveDispatches } from '@/lib/table/dispatcher'
 import { accessError, checkAccess } from '@/app/api/table/utils'
 
 const logger = createLogger('TableDispatchesAPI')
@@ -37,7 +37,10 @@ export const GET = withRouteHandler(async (request: NextRequest, { params }: Rou
     const result = await checkAccess(tableId, authResult.userId, 'read')
     if (!result.ok) return accessError(result, requestId, tableId)
 
-    const rows = await listActiveDispatches(tableId)
+    const [rows, running] = await Promise.all([
+      listActiveDispatches(tableId),
+      countRunningCells(tableId),
+    ])
     const dispatches: ActiveDispatch[] = rows.map((r) => ({
       id: r.id,
       status: r.status as 'pending' | 'dispatching',
@@ -47,7 +50,14 @@ export const GET = withRouteHandler(async (request: NextRequest, { params }: Rou
       scope: r.scope,
     }))
 
-    return NextResponse.json({ success: true, data: { dispatches } })
+    return NextResponse.json({
+      success: true,
+      data: {
+        dispatches,
+        runningCellCount: running.total,
+        runningByRowId: running.byRowId,
+      },
+    })
   } catch (error) {
     logger.error(`[${requestId}] list-dispatches failed:`, error)
     return NextResponse.json({ error: 'Failed to list active dispatches' }, { status: 500 })

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

@@ -12,16 +12,15 @@ import { cn } from '@/lib/core/utils/cn'
 import { captureEvent } from '@/lib/posthog/client'
 import type { ColumnDefinition, TableRow as TableRowType } from '@/lib/table'
 import { TABLE_LIMITS } from '@/lib/table/constants'
-import { isExecInFlight } from '@/lib/table/deps'
 import { useUserPermissionsContext } from '@/app/workspace/[workspaceId]/providers/workspace-permissions-provider'
 import {
   useAddTableColumn,
   useBatchCreateTableRows,
-  useActiveDispatches,
   useBatchUpdateTableRows,
   useCreateTableRow,
   useDeleteColumn,
   useDeleteWorkflowGroup,
+  useTableRunState,
   useUpdateColumn,
   useUpdateTableMetadata,
   useUpdateTableRow,
@@ -74,6 +73,8 @@ import {
 
 const logger = createLogger('TableView')
 
+const EMPTY_RUNNING_BY_ROW: Readonly<Record<string, number>> = Object.freeze({})
+
 const COL_WIDTH_MIN = 80
 const COL_WIDTH_AUTO_FIT_MAX = 1000
 const SKELETON_COL_COUNT = 4
@@ -301,7 +302,10 @@ export function TableGrid({
     ensureAllRowsLoaded,
   } = useTable({ workspaceId, tableId, queryOptions })
 
-  const { data: activeDispatches } = useActiveDispatches(tableId)
+  const { data: tableRunState } = useTableRunState(tableId)
+  const activeDispatches = tableRunState?.dispatches
+  const totalRunning = tableRunState?.runningCellCount ?? 0
+  const runningByRowId = tableRunState?.runningByRowId ?? EMPTY_RUNNING_BY_ROW
 
   const fetchNextPageRef = useRef(fetchNextPage)
   fetchNextPageRef.current = fetchNextPage
@@ -2693,22 +2697,11 @@ export function TableGrid({
     return ids.length > 0 ? ids : null
   }, [rowSelection, rows])
 
-  const { runningByRowId, totalRunning } = useMemo(() => {
-    const byRow = new Map<string, number>()
-    let total = 0
-    for (const row of rows) {
-      let count = 0
-      const executions = row.executions ?? {}
-      for (const gid in executions) {
-        if (isExecInFlight(executions[gid])) count++
-      }
-      if (count > 0) {
-        byRow.set(row.id, count)
-        total += count
-      }
-    }
-    return { runningByRowId: byRow, totalRunning: total }
-  }, [rows])
+  // `runningByRowId` + `totalRunning` come from `useTableRunState` above —
+  // backend-bootstrapped via `countRunningCells` and kept live by
+  // `applyCell`'s SSE-driven delta. Counts only cells whose worker has
+  // actually claimed the cell (`status === 'running'`), ignoring optimistic
+  // queued/pending stamps.
 
   // Context-menu wrappers: act on `contextMenuRowIds`, then close the menu.
   // Mirror the action bar's Play / Refresh split: Play fills empty/failed,
@@ -2729,7 +2722,7 @@ export function TableGrid({
   // Total running/queued cells across the rows the context menu is acting on;
   // drives the "Stop N running workflows" item, shown only when > 0.
   const runningInContextSelection = contextMenuRowIds.reduce(
-    (total, rowId) => total + (runningByRowId.get(rowId) ?? 0),
+    (total, rowId) => total + (runningByRowId[rowId] ?? 0),
     0
   )
 
@@ -2760,7 +2753,7 @@ export function TableGrid({
     return []
   }, [rowSelection, normalizedSelection, rows])
   const runningInActionBarSelection = actionBarRowIds.reduce(
-    (total, rowId) => total + (runningByRowId.get(rowId) ?? 0),
+    (total, rowId) => total + (runningByRowId[rowId] ?? 0),
     0
   )
 
@@ -3152,7 +3145,7 @@ export function TableGrid({
                         onCellMouseEnter={handleCellMouseEnter}
                         isRowChecked={rowSelectionIncludes(rowSelection, row.id)}
                         onRowToggle={handleRowToggle}
-                        runningCount={runningByRowId.get(row.id) ?? 0}
+                        runningCount={runningByRowId[row.id] ?? 0}
                         hasWorkflowColumns={hasWorkflowColumns}
                         numDivWidth={numDivWidth}
                         onStopRow={onStopRow}

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/workflow-sidebar/run-settings-section.tsx

@@ -10,15 +10,22 @@ interface RunSettingsSectionProps {
   /** Column names this group waits on. */
   deps: string[]
   onChangeDeps: (next: string[]) => void
+  /** Inline validation error rendered under the picker. */
+  error?: string | null
 }
 
 /**
  * "Run after" picker: which upstream columns must be filled before this group
  * fires. Workflow output columns count the same as plain columns — once a
- * column is non-empty, the dep is satisfied. Empty selection = the group fires
- * on any row change.
+ * column is non-empty, the dep is satisfied. At least one dep is required
+ * when auto-run is on.
  */
-export function RunSettingsSection({ depOptions, deps, onChangeDeps }: RunSettingsSectionProps) {
+export function RunSettingsSection({
+  depOptions,
+  deps,
+  onChangeDeps,
+  error,
+}: RunSettingsSectionProps) {
   const options = depOptions.map((c) => ({ label: c.name, value: c.name }))
 
   return (
@@ -38,11 +45,12 @@ export function RunSettingsSection({ depOptions, deps, onChangeDeps }: RunSettin
         multiSelectValues={deps}
         onMultiSelectChange={onChangeDeps}
         overlayContent={
-          <span className='truncate text-[var(--text-primary)]'>
-            {deps.length === 0 ? 'Any row change' : `${deps.length} selected`}
+          <span className='truncate text-[var(--text-tertiary)]'>
+            {deps.length === 0 ? 'Select at least one column' : `${deps.length} selected`}
           </span>
         }
       />
+      {error && <p className='pl-0.5 text-[var(--text-danger)] text-xs'>{error}</p>}
     </div>
   )
 }

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/workflow-sidebar/workflow-sidebar.tsx

@@ -241,31 +241,42 @@ function WorkflowSidebarBody({
       ? (allColumns.find((c) => c.name === config.columnName) ?? null)
       : null
 
-  // Anchor column for "left of current" filtering. For create + edit-group we
-  // treat the anchor as missing (group config sits at the right edge of the
-  // group); for edit-output the anchor is the column being edited.
-  const anchorColumnName = config.mode === 'edit-output' ? config.columnName : null
+  // Anchor index for "left of current" filtering.
+  //   - edit-output: the column being edited.
+  //   - edit-group: the leftmost column belonging to this group (deps must be
+  //     reachable from the group's first output column).
+  //   - create: no anchor; new column sits at the right edge, so every
+  //     existing column qualifies.
+  const anchorIdx = (() => {
+    if (config.mode === 'edit-output') {
+      const idx = allColumns.findIndex((c) => c.name === config.columnName)
+      return idx === -1 ? allColumns.length : idx
+    }
+    if (config.mode === 'edit-group' && existingGroup) {
+      let leftmost = Number.POSITIVE_INFINITY
+      for (let i = 0; i < allColumns.length; i++) {
+        if (allColumns[i].workflowGroupId === existingGroup.id && i < leftmost) leftmost = i
+      }
+      return Number.isFinite(leftmost) ? leftmost : allColumns.length
+    }
+    return allColumns.length
+  })()
 
   /**
    * Columns "left of current" — these are the only valid trigger dependencies.
-   * For create + edit-group, every existing column qualifies. For edit-output,
-   * only columns physically before the anchor.
    */
-  const otherColumns = (() => {
-    if (anchorColumnName === null) return allColumns
-    const idx = allColumns.findIndex((c) => c.name === anchorColumnName)
-    if (idx === -1) return allColumns.filter((c) => c.name !== anchorColumnName)
-    return allColumns.slice(0, idx)
-  })()
+  const otherColumns = anchorIdx >= allColumns.length ? allColumns : allColumns.slice(0, anchorIdx)
+
+  // Used by the "missing workflow input" suggestion below — for edit-output
+  // we exclude the column being edited (you can't suggest it as its own
+  // input).
+  const anchorColumnName = config.mode === 'edit-output' ? config.columnName : null
 
   // Every left-of-current column is a valid dep — workflow output columns
   // included. Exclude this group's own outputs (you can't depend on yourself).
   const ownOutputNames = new Set(existingGroup?.outputs.map((o) => o.columnName) ?? [])
   const depOptions = otherColumns.filter((c) => !ownOutputNames.has(c.name))
 
-  // Default deps for a brand-new group: tick every left-of-current column.
-  const defaultDeps = depOptions.map((c) => c.name)
-
   const [selectedWorkflowId, setSelectedWorkflowId] = useState<string>(
     () => existingGroup?.workflowId ?? ''
   )
@@ -276,8 +287,11 @@ function WorkflowSidebarBody({
   const [autoRun, setAutoRun] = useState<boolean>(() =>
     existingGroup ? existingGroup.autoRun !== false : false
   )
+  // Deps default to none selected. With auto-run on, at least one is required
+  // (enforced via `depsValid` below); a legacy group with empty deps will
+  // surface the error on first open until the user picks at least one column.
   const [deps, setDeps] = useState<string[]>(
-    () => existingGroup?.dependencies?.columns ?? defaultDeps
+    () => existingGroup?.dependencies?.columns ?? []
   )
   // `selectedOutputs` is encoded `${blockId}::${path}`. Seeded once `blockOutputGroups`
   // resolves (we may not have the workflow blocks loaded at first render); see the
@@ -542,6 +556,7 @@ function WorkflowSidebarBody({
     if (!selectedWorkflowId) missing.push('a workflow')
     if (selectedWorkflowId && selectedOutputs.length === 0) missing.push('at least one output')
     if (isEditOutputMode && !trimmedName) missing.push('a column name')
+    if (autoRun && deps.length === 0) missing.push('at least one Run after column')
     if (missing.length > 0) {
       setShowValidation(true)
       return
@@ -664,8 +679,15 @@ function WorkflowSidebarBody({
     }
   }
 
+  // Auto-run requires ≥1 dependency column — without one, the dispatcher's
+  // eligibility predicate would never fire the workflow. Block Save and
+  // surface an inline error so the user picks a column.
+  const depsValid = !autoRun || deps.length > 0
   const saveDisabled =
-    addWorkflowGroup.isPending || updateWorkflowGroup.isPending || updateColumn.isPending
+    addWorkflowGroup.isPending ||
+    updateWorkflowGroup.isPending ||
+    updateColumn.isPending ||
+    !depsValid
   const titleByMode = {
     create: 'Add workflow',
     'edit-group': 'Configure workflow',
@@ -875,7 +897,14 @@ function WorkflowSidebarBody({
             {autoRun && (
               <>
                 <FieldDivider />
-                <RunSettingsSection depOptions={depOptions} deps={deps} onChangeDeps={setDeps} />
+                <RunSettingsSection
+                  depOptions={depOptions}
+                  deps={deps}
+                  onChangeDeps={setDeps}
+                  error={
+                    showValidation && deps.length === 0 ? 'Select at least one column' : null
+                  }
+                />
               </>
             )}
           </>