fix(table): address bugbot/greptile review feedback

Two P1 issues + one cleanup from the bot reviewers:

1. **Double-dispatch + completed-output wipe.** Both PATCH row routes
   (`app/api/table/[tableId]/rows/[rowId]` and
   `app/api/v1/tables/[tableId]/rows/[rowId]`) were firing a second
   `runWorkflowColumn({ mode: 'incomplete' })` after `updateRow` returns.
   `updateRow` already fires `mode: 'new'` internally for user edits, so
   the second call created a concurrent dispatch. Worse, the
   `mode: 'incomplete'` path's `bulkClearWorkflowGroupCells` wipes ALL
   targeted output columns on any row where any one column is empty —
   meaning sibling-group completed outputs could be erased. Removed both
   route-level calls; auto-dispatch lives entirely in `updateRow`.

2. **`runWorkflowColumn` log-spamming on plain tables.**
   `if (targetGroups.length === 0) throw new Error(...)` fired on every
   row insert/update for tables without any workflow groups (the
   majority). Every caller wraps with `.catch(logger.error)`, so each
   PATCH produced an error-level log. Return `{ dispatchId: null }`
   silently — manual `runWorkflowColumn` callers pass `groupIds`
   explicitly so they can't reach this branch.

3. **`isManualRun` plumbed through dispatch SSE events.** Late-arriving
   `kind: 'dispatch'` events for dispatches not in the initial fetch
   were hardcoding `isManualRun: false`. Added the field to the event
   shape, emit it from `dispatcherStep` (pending → complete, dispatching
   transitions) and `markActiveDispatchesCancelled`, and consume it in
   the SSE handler with a sensible fallback for legacy emits.

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

Author: TheodoreSpeaks

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

@@ -15,7 +15,6 @@ import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import type { RowData } from '@/lib/table'
 import { deleteRow, updateRow } from '@/lib/table'
-import { runWorkflowColumn } from '@/lib/table/workflow-columns'
 import { accessError, checkAccess } from '@/app/api/table/utils'
 
 const logger = createLogger('TableRowAPI')
@@ -137,15 +136,11 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: RowR
     // Only `null` when a `cancellationGuard` is supplied and the SQL guard
     // rejects the write — this route doesn't pass one, so reaching null is a bug.
     if (!updatedRow) throw new Error('updateRow returned null without a cancellationGuard')
-    // Auto-fire any newly-eligible workflow groups (deps just became met).
-    void runWorkflowColumn({
-      tableId,
-      workspaceId: validated.workspaceId,
-      rowIds: [updatedRow.id],
-      mode: 'incomplete',
-      isManualRun: false,
-      requestId,
-    }).catch((err) => logger.error(`[${requestId}] auto-dispatch (row PATCH) failed:`, err))
+    // Auto-dispatch for user edits is handled inside `updateRow` (mode: 'new').
+    // Firing a second mode: 'incomplete' dispatch here would race with the
+    // `mode: 'new'` one AND bulk-clear sibling-group outputs (the incomplete
+    // bulk-clear wipes ALL targeted columns when any one column on the row
+    // is empty).
 
     return NextResponse.json({
       success: true,

apps/sim/app/api/v1/tables/[tableId]/rows/[rowId]/route.ts

@@ -14,7 +14,6 @@ import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import type { RowData } from '@/lib/table'
 import { updateRow } from '@/lib/table'
-import { runWorkflowColumn } from '@/lib/table/workflow-columns'
 import { accessError, checkAccess } from '@/app/api/table/utils'
 import {
   checkRateLimit,
@@ -145,14 +144,9 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: RowR
     if (!updatedRow) {
       return NextResponse.json({ error: 'Row not found' }, { status: 404 })
     }
-    void runWorkflowColumn({
-      tableId,
-      workspaceId: validated.workspaceId,
-      rowIds: [updatedRow.id],
-      mode: 'incomplete',
-      isManualRun: false,
-      requestId,
-    }).catch((err) => logger.error(`[${requestId}] auto-dispatch (v1 row update) failed:`, err))
+    // Auto-dispatch for user edits is handled inside `updateRow` (mode: 'new').
+    // Firing a second mode: 'incomplete' dispatch here would race with it AND
+    // bulk-clear sibling-group outputs.
 
     return NextResponse.json({
       success: true,

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

@@ -145,7 +145,7 @@ export function useTableEventStream({
     }
 
     const applyDispatch = (event: Extract<TableEvent, { kind: 'dispatch' }>): void => {
-      const { dispatchId, status, scope, cursor, mode } = event
+      const { dispatchId, status, scope, cursor, mode, isManualRun } = event
       queryClient.setQueryData<TableRunState>(tableKeys.activeDispatches(tableId), (prev) => {
         if (!prev) return prev
         const list = prev.dispatches
@@ -160,19 +160,23 @@ export function useTableEventStream({
           // overlay. Leave existing cache alone.
           return prev
         }
+        const idx = list.findIndex((d) => d.id === dispatchId)
+        const existing = idx === -1 ? undefined : list[idx]
+        // Prefer the event payload (current truth from server); fall back to
+        // the cached entry's value if this is a legacy emit without the
+        // field, and finally to `false` if we have nothing.
+        const resolvedManualRun = isManualRun ?? existing?.isManualRun ?? false
         const next: ActiveDispatch = {
           id: dispatchId,
           status,
           mode,
-          isManualRun: false,
+          isManualRun: resolvedManualRun,
           cursor,
           scope,
         }
-        const idx = list.findIndex((d) => d.id === dispatchId)
         if (idx === -1) return { ...prev, dispatches: [...list, next] }
         const merged = list.slice()
-        // Preserve isManualRun from the initial fetch — SSE doesn't carry it.
-        merged[idx] = { ...next, isManualRun: list[idx].isManualRun }
+        merged[idx] = next
         return { ...prev, dispatches: merged }
       })
     }

apps/sim/lib/table/dispatcher.ts

@@ -298,6 +298,7 @@ export async function dispatcherStep(dispatchId: string): Promise<DispatcherStep
       scope: dispatch.scope,
       cursor: dispatch.cursor,
       mode: dispatch.mode,
+      isManualRun: dispatch.isManualRun,
     })
     return 'done'
   }
@@ -358,6 +359,7 @@ export async function dispatcherStep(dispatchId: string): Promise<DispatcherStep
       scope: dispatch.scope,
       cursor: lastPosition,
       mode: dispatch.mode,
+      isManualRun: dispatch.isManualRun,
     }),
   ])
 
@@ -450,6 +452,7 @@ export async function markActiveDispatchesCancelled(tableId: string): Promise<Di
         scope: d.scope,
         cursor: d.cursor,
         mode: d.mode,
+        isManualRun: d.isManualRun,
       })
     )
   )

apps/sim/lib/table/events.ts

@@ -98,16 +98,17 @@ export type TableEvent =
   | {
       /** Dispatcher status signal emitted by `dispatcherStep` and the cancel
        *  path. Drives the client-side "about to run" overlay for rows the
-       *  dispatcher hasn't reached yet. `scope` + `cursor` + `mode` are
-       *  carried on every transition so the client can upsert without
-       *  refetching the dispatches list. */
+       *  dispatcher hasn't reached yet. `scope` + `cursor` + `mode` +
+       *  `isManualRun` are carried on every transition so the client can
+       *  upsert without refetching the dispatches list. */
       kind: 'dispatch'
       tableId: string
       dispatchId: string
       status: TableDispatchStatus
       scope?: { groupIds: string[]; rowIds?: string[] }
       cursor?: number
       mode?: 'all' | 'incomplete' | 'new'
+      isManualRun?: boolean
     }
 
 export interface TableEventEntry {

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

@@ -462,7 +462,11 @@ export async function runWorkflowColumn(opts: {
 
   const allGroups = table.schema.workflowGroups ?? []
   const targetGroups = groupIds ? allGroups.filter((g) => groupIds.includes(g.id)) : allGroups
-  if (targetGroups.length === 0) throw new Error('No matching workflow groups for run')
+  // Tables with no workflow groups are the majority. Auto-fire callers from
+  // every row write would otherwise produce error-level log spam on every
+  // PATCH/insert. Manual run-column callers always pass `groupIds` so they
+  // can't reach here with an empty target.
+  if (targetGroups.length === 0) return { dispatchId: null }
   const targetGroupIds = targetGroups.map((g) => g.id)
 
   // Wipe targeted output cols + executions[gid] before any cells fire so the