fix(enrichment): track manual table attempts

Author: TheodoreSpeaks

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

@@ -19,7 +19,7 @@ import {
   SELECTION_TINT_BG,
 } from './constants'
 import type { DisplayColumn } from './types'
-import { type NormalizedSelection, resolveCellExec } from './utils'
+import { hasAttemptedManualRun, type NormalizedSelection, resolveCellExec } from './utils'
 
 export interface DataRowProps {
   row: TableRowType
@@ -203,9 +203,8 @@ export const DataRow = React.memo(function DataRow({
         for (const id of unmet.columns) labels.add(nameByColumnId.get(id) ?? id)
       }
 
-      const hasAttemptedManualRun =
-        group.autoRun === false && row.executions?.[group.id] !== undefined
-      if (group.type === 'enrichment' && (group.autoRun !== false || hasAttemptedManualRun)) {
+      const manuallyAttempted = hasAttemptedManualRun(row, group)
+      if (group.type === 'enrichment' && (group.autoRun !== false || manuallyAttempted)) {
         const enrichment = getEnrichment(group.enrichmentId)
         if (enrichment) {
           const readiness = getEnrichmentRowReadiness(enrichment, group, row.data, schemaColumns)

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/utils.test.ts

@@ -15,6 +15,7 @@ import {
   canWriteRowsWithChip,
   chipRowCount,
   drainTargetForChip,
+  hasAttemptedManualRun,
   resolveCellExec,
   selectedColumnIds,
 } from './utils'
@@ -196,3 +197,63 @@ describe('resolveCellExec', () => {
     expect(resolveCellExec(pendingRow, group, [dispatch], true)).toBeUndefined()
   })
 })
+
+describe('hasAttemptedManualRun', () => {
+  const group: WorkflowGroup = {
+    id: 'group-1',
+    workflowId: '',
+    type: 'enrichment',
+    autoRun: false,
+    outputs: [{ blockId: '', path: '', outputId: 'email', columnName: 'email' }],
+  }
+  const row: TableRow = {
+    id: 'row-1',
+    data: {},
+    executions: {},
+    position: 0,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  }
+
+  it('does not treat an earlier automatic execution as a manual attempt', () => {
+    expect(
+      hasAttemptedManualRun(
+        {
+          ...row,
+          executions: {
+            [group.id]: {
+              status: 'completed',
+              executionId: 'execution-1',
+              jobId: null,
+              workflowId: '',
+              isManualRun: false,
+              error: null,
+            },
+          },
+        },
+        group
+      )
+    ).toBe(false)
+  })
+
+  it('recognizes an explicit manual attempt', () => {
+    expect(
+      hasAttemptedManualRun(
+        {
+          ...row,
+          executions: {
+            [group.id]: {
+              status: 'completed',
+              executionId: 'execution-2',
+              jobId: null,
+              workflowId: '',
+              isManualRun: true,
+              error: null,
+            },
+          },
+        },
+        group
+      )
+    ).toBe(true)
+  })
+})

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

@@ -218,6 +218,13 @@ export function readExecution(
   return row?.executions?.[groupId]
 }
 
+export function hasAttemptedManualRun(
+  row: Pick<TableRowType, 'executions'>,
+  group: WorkflowGroup
+): boolean {
+  return group.autoRun === false && row.executions?.[group.id]?.isManualRun === true
+}
+
 /**
  * Resolves a cell's execution state with the "about to run" overlay applied:
  * for cells in an active dispatch's scope ahead of its cursor whose deps are

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

@@ -106,6 +106,16 @@ describe('applyCellEventToRow', () => {
     }
   )
 
+  it('carries the authoritative manual-run origin through cell events', () => {
+    const row = createRow(null, 'pending', { isManualRun: true })
+
+    expect(
+      applyCellEventToRow(row, createCellEvent('running', 'execution-new', { isManualRun: true }))
+    ).toMatchObject({
+      executions: { [GROUP_ID]: { isManualRun: true } },
+    })
+  })
+
   it('ignores a delayed id-less pre-stamp after a terminal state', () => {
     const row = createRow('execution-old', 'completed')
 

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

@@ -121,6 +121,11 @@ export function applyCellEventToRow(
     jobId: event.jobId,
     // Preserve workflowId from cache; SSE payload doesn't carry it.
     workflowId: prevExec?.workflowId ?? '',
+    ...(event.isManualRun !== undefined
+      ? { isManualRun: event.isManualRun }
+      : prevExec?.isManualRun !== undefined
+        ? { isManualRun: prevExec.isManualRun }
+        : {}),
     error: event.error,
     ...(event.runningBlockIds ? { runningBlockIds: event.runningBlockIds } : {}),
     ...(event.blockErrors ? { blockErrors: event.blockErrors } : {}),

apps/sim/background/resume-execution.ts

@@ -401,7 +401,9 @@ async function continueCascadeAfterResume(
 ): Promise<void> {
   const { getTableById } = await import('@/lib/table/service')
   const { getRowById } = await import('@/lib/table/rows/service')
-  const { pickNextEligibleGroupForRow } = await import('@/lib/table/workflow-columns')
+  const { isManualQueuedMarker, pickNextEligibleGroupForRow } = await import(
+    '@/lib/table/workflow-columns'
+  )
   const { runRowCascadeLoop } = await import('@/background/workflow-column-execution')
 
   const freshTable = await getTableById(cellContext.tableId)
@@ -410,6 +412,7 @@ async function continueCascadeAfterResume(
   if (!freshRow) return
   const next = pickNextEligibleGroupForRow(freshTable, freshRow, cellContext.groupId)
   if (!next) return
+  const nextExec = freshRow.executions?.[next.id]
   await runRowCascadeLoop(
     {
       tableId: cellContext.tableId,
@@ -419,6 +422,7 @@ async function continueCascadeAfterResume(
       groupId: next.id,
       workflowId: next.workflowId,
       executionId: generateId(),
+      isManualRun: isManualQueuedMarker(nextExec),
       billingAttribution,
     },
     signal

apps/sim/background/workflow-column-execution.ts

@@ -51,6 +51,7 @@ import type {
 } from '@/lib/table/types'
 import {
   buildWorkflowGroupExecutionCorrelation,
+  isManualQueuedMarker,
   type QueuedWorkflowGroupCellPayload,
   type WorkflowGroupCellPayload,
 } from '@/lib/table/workflow-columns'
@@ -133,6 +134,7 @@ export async function terminalizeAbortedQueuedCarrierMarker(
       executionId: executionState.executionId,
       jobId: executionState.jobId,
       workflowId: executionState.workflowId,
+      isManualRun: payload.isManualRun,
       error: executionState.error,
       runningBlockIds: executionState.runningBlockIds,
       updatedAt: new Date(),
@@ -162,6 +164,7 @@ export async function terminalizeAbortedQueuedCarrierMarker(
     executionId: executionState.executionId ?? null,
     jobId: null,
     error: executionState.error ?? null,
+    isManualRun: payload.isManualRun,
   })
   return true
 }
@@ -278,8 +281,8 @@ export async function executeWorkflowGroupCellJob(
       if (!freshRow) break
       const next = pickNextEligibleGroupForRow(freshTable, freshRow)
       if (!next) break
-      // Only re-drive a genuine queued marker (an explicit run request whose
-      // cell-task bailed during our release window). The inner cascade loop has
+      // Only re-drive a genuine queued marker (a dispatched run whose cell-task
+      // bailed during our release window). The inner cascade loop has
       // already drained every auto-eligible group, so re-driving a non-marker
       // group here would re-run forever — e.g. a group that completed with empty
       // outputs stays auto-eligible (the inner loop excludes it via
@@ -294,6 +297,7 @@ export async function executeWorkflowGroupCellJob(
         // Re-derive so a workflow group after an enrichment group doesn't keep a stale enrichmentId.
         enrichmentId: next.enrichmentId,
         executionId: generateId(),
+        isManualRun: isManualQueuedMarker(nextExec),
       }
     }
   } finally {
@@ -315,6 +319,7 @@ export async function runRowCascadeLoop(
 
   let currentGroupId = payload.groupId
   let currentWorkflowId = payload.workflowId
+  let currentIsManualRun = payload.isManualRun
   // Fresh executionId per iteration: SQL guard rejects writes whose id ≠
   // row.executions[gid].executionId, so we need a new claim per group.
   let currentExecutionId = payload.executionId
@@ -327,6 +332,7 @@ export async function runRowCascadeLoop(
           groupId: currentGroupId,
           workflowId: currentWorkflowId,
           executionId: currentExecutionId,
+          isManualRun: currentIsManualRun,
         },
         signal
       )
@@ -350,6 +356,7 @@ export async function runRowCascadeLoop(
         groupId: currentGroupId,
         workflowId: currentWorkflowId,
         executionId: currentExecutionId,
+        isManualRun: currentIsManualRun,
       },
       signal,
       freshTable,
@@ -366,6 +373,8 @@ export async function runRowCascadeLoop(
     if (!freshRow) break
     const next = pickNextEligibleGroupForRow(freshTable, freshRow, currentGroupId)
     if (!next) break
+    const nextExec = freshRow.executions?.[next.id]
+    currentIsManualRun = isManualQueuedMarker(nextExec)
     currentGroupId = next.id
     currentWorkflowId = next.workflowId
     currentExecutionId = generateId()
@@ -411,7 +420,16 @@ async function runWorkflowAndWriteTerminal(
       )
       const { stashCellContextForResume } = await import('@/lib/table/workflow-columns')
 
-      const cellCtx = { tableId, rowId, workspaceId, groupId, executionId, requestId, table }
+      const cellCtx = {
+        tableId,
+        rowId,
+        workspaceId,
+        groupId,
+        executionId,
+        isManualRun: payload.isManualRun,
+        requestId,
+        table,
+      }
       const writeState = (
         executionState: RowExecutionMetadata,
         dataPatch?: RowData,

apps/sim/hooks/queries/tables.ts

@@ -2333,6 +2333,7 @@ function buildPendingExec(
     executionId: prev?.executionId ?? null,
     jobId: null,
     workflowId: prev?.workflowId ?? workflowIdFallback ?? '',
+    isManualRun: true,
     error: null,
   }
 }

apps/sim/lib/table/cell-write.test.ts

@@ -130,6 +130,25 @@ describe('writeWorkflowGroupState', () => {
     })
   })
 
+  it('persists and emits the attempt origin from the write context', async () => {
+    const executionState = { ...RUNNING_STATE, isManualRun: true }
+
+    await expect(
+      writeWorkflowGroupState({ ...CONTEXT, isManualRun: true }, { executionState: RUNNING_STATE })
+    ).resolves.toBe('wrote')
+
+    expect(mockWriteExecutionsPatch).toHaveBeenCalledWith(
+      expect.anything(),
+      TABLE.id,
+      CONTEXT.rowId,
+      { [GROUP.id]: executionState },
+      { groupId: GROUP.id, executionId: CONTEXT.executionId }
+    )
+    expect(mockAppendTableEvent).toHaveBeenCalledWith(
+      expect.objectContaining({ isManualRun: true })
+    )
+  })
+
   it('writes only changed data while emitting cumulative outputs', async () => {
     const secretProvenance = {
       complete: true,

apps/sim/lib/table/cell-write.ts

@@ -40,6 +40,8 @@ export interface WriteWorkflowGroupContext {
   workspaceId: string
   groupId: string
   executionId: string
+  /** Authoritative origin of the current cell attempt. */
+  isManualRun?: boolean
   /** Preloaded, column-bounded table definition used to validate data patches. */
   table: TableDefinition
   /** Used as the `requestId` passed to `updateRow` for log correlation. */
@@ -68,16 +70,20 @@ export async function writeWorkflowGroupState(
 ): Promise<'wrote' | 'skipped'> {
   const { tableId, rowId, workspaceId, groupId, executionId, table } = ctx
   const requestId = ctx.requestId ?? `wfgrp-${executionId}`
-  const isCancelStamp = payload.executionState.status === 'cancelled'
-  const isQueuedStamp = payload.executionState.status === 'queued'
+  const executionState =
+    ctx.isManualRun === undefined
+      ? payload.executionState
+      : { ...payload.executionState, isManualRun: ctx.isManualRun }
+  const isCancelStamp = executionState.status === 'cancelled'
+  const isQueuedStamp = executionState.status === 'queued'
   const cancellationGuard = isCancelStamp
     ? undefined
     : {
         groupId,
         executionId,
         ...(isQueuedStamp ? { allowNewExecution: true } : {}),
       }
-  const executionsPatch = { [groupId]: payload.executionState }
+  const executionsPatch = { [groupId]: executionState }
   const dataPatch = payload.dataPatch
   const hasDataPatch = Boolean(dataPatch && Object.keys(dataPatch).length > 0)
 
@@ -141,17 +147,20 @@ export async function writeWorkflowGroupState(
   const hasOutputs = rawEventOutputs && Object.keys(rawEventOutputs).length > 0
   const eventOutputs = hasOutputs ? { ...rawEventOutputs } : rawEventOutputs
   if (hasOutputs && eventOutputs) coerceRowValues(eventOutputs, table.schema)
-  const runningBlockIds = payload.executionState.runningBlockIds
-  const blockErrors = payload.executionState.blockErrors
+  const runningBlockIds = executionState.runningBlockIds
+  const blockErrors = executionState.blockErrors
   void appendTableEvent({
     kind: 'cell',
     tableId,
     rowId,
     groupId,
-    status: payload.executionState.status,
-    executionId: payload.executionState.executionId ?? null,
-    jobId: payload.executionState.jobId ?? null,
-    error: payload.executionState.error ?? null,
+    status: executionState.status,
+    executionId: executionState.executionId ?? null,
+    jobId: executionState.jobId ?? null,
+    error: executionState.error ?? null,
+    ...(executionState.isManualRun !== undefined
+      ? { isManualRun: executionState.isManualRun }
+      : {}),
     ...(hasOutputs ? { outputs: eventOutputs } : {}),
     ...(runningBlockIds && runningBlockIds.length > 0 ? { runningBlockIds } : {}),
     ...(blockErrors && Object.keys(blockErrors).length > 0 ? { blockErrors } : {}),
@@ -380,13 +389,14 @@ export async function markWorkflowGroupPickedUp(
  *  tombstone the dispatcher reads to skip re-runs of cells the user killed
  *  mid-cascade. */
 export function buildCancelledExecution(
-  prev: Pick<RowExecutionMetadata, 'executionId' | 'workflowId' | 'blockErrors'>
+  prev: Pick<RowExecutionMetadata, 'executionId' | 'workflowId' | 'isManualRun' | 'blockErrors'>
 ): RowExecutionMetadata {
   return {
     status: 'cancelled',
     executionId: prev.executionId ?? null,
     jobId: null,
     workflowId: prev.workflowId,
+    ...(prev.isManualRun !== undefined ? { isManualRun: prev.isManualRun } : {}),
     error: 'Cancelled',
     cancelledAt: new Date().toISOString(),
     ...(prev.blockErrors ? { blockErrors: prev.blockErrors } : {}),