fix(table): preserve waiting and resume provenance

TheodoreSpeaks · TheodoreSpeaks · commit 25c197863f30 · 2026-08-11T14:34:28.000-07:00
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.test.ts b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.test.ts
@@ -76,4 +76,16 @@ describe('resolveCellRender waiting precedence', () => {
       })
     ).toEqual({ kind: 'value', text: 'kept workflow result' })
   })
+
+  it('shows Waiting for an empty ordinary workflow output with unmet dependencies', () => {
+    expect(
+      resolveCellRender({
+        value: '',
+        exec: undefined,
+        column: COLUMN,
+        waitingOnLabels: ['Dependency'],
+        isEnrichmentOutput: false,
+      })
+    ).toEqual({ kind: 'waiting', labels: ['Dependency'] })
+  })
 })
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx
@@ -79,12 +79,17 @@ export function resolveCellRender({
     if (inFlight && blockRunning) return { kind: 'running' }
 
     /**
-     * A mapped-input edit can invalidate an earlier enrichment result without
-     * deleting its stored output. Once no attempt is in flight, the actionable
-     * Waiting state must win over that stale value. Active reruns still keep
-     * showing the previous value until their replacement lands.
+     * Empty workflow outputs show their unmet dependencies. Enrichment input
+     * edits can additionally invalidate a result without deleting its stored
+     * output, so Waiting must win over that stale value once no attempt is in
+     * flight. Active reruns still show the previous value until replacement.
      */
-    if (isEnrichmentOutput && !inFlight && waitingOnLabels && waitingOnLabels.length > 0) {
+    if (
+      !inFlight &&
+      (isEnrichmentOutput || isEmpty) &&
+      waitingOnLabels &&
+      waitingOnLabels.length > 0
+    ) {
       return { kind: 'waiting', labels: waitingOnLabels }
     }
 
diff --git a/apps/sim/background/resume-execution.test.ts b/apps/sim/background/resume-execution.test.ts
@@ -13,6 +13,11 @@ const {
   mockSnapshotFromJson,
   mockCreateResumeAttemptTimeoutController,
   mockIsTimedOut,
+  mockWithCascadeLock,
+  mockGetRowById,
+  mockGetTableById,
+  mockCreateWorkflowCellProgressWriter,
+  mockWriteWorkflowGroupState,
 } = vi.hoisted(() => ({
   mockTask: vi.fn((config) => config),
   mockGetPausedExecutionById: vi.fn(),
@@ -21,6 +26,11 @@ const {
   mockSnapshotFromJson: vi.fn(),
   mockCreateResumeAttemptTimeoutController: vi.fn(),
   mockIsTimedOut: vi.fn(() => false),
+  mockWithCascadeLock: vi.fn(),
+  mockGetRowById: vi.fn(),
+  mockGetTableById: vi.fn(),
+  mockCreateWorkflowCellProgressWriter: vi.fn(),
+  mockWriteWorkflowGroupState: vi.fn(),
 }))
 
 vi.mock('@trigger.dev/sdk', () => ({ task: mockTask, timeout: { None: 'none' } }))
@@ -29,9 +39,17 @@ vi.mock('@/lib/billing/core/billing-attribution', () => ({
   assertBillingAttributionSnapshot: vi.fn((value) => value),
 }))
 
-vi.mock('@/lib/table/cascade-lock', () => ({ withCascadeLock: vi.fn() }))
+vi.mock('@/lib/table/cascade-lock', () => ({ withCascadeLock: mockWithCascadeLock }))
 vi.mock('@/lib/table/deps', () => ({ isExecCancelled: vi.fn(() => false) }))
 
+vi.mock('@/lib/table/rows/service', () => ({ getRowById: mockGetRowById }))
+vi.mock('@/lib/table/service', () => ({ getTableById: mockGetTableById }))
+vi.mock('@/lib/table/cell-write', () => ({
+  buildCancelledExecution: vi.fn(),
+  createWorkflowCellProgressWriter: mockCreateWorkflowCellProgressWriter,
+  writeWorkflowGroupState: mockWriteWorkflowGroupState,
+}))
+
 vi.mock('@/lib/table/workflow-columns', () => ({
   findCellContextByExecutionId: mockFindCellContextByExecutionId,
 }))
@@ -70,7 +88,7 @@ const payload: ResumeExecutionPayload = {
   parentExecutionId: 'parent-execution-1',
 }
 
-describe('executeResumeJob terminal errors', () => {
+describe('executeResumeJob', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockGetPausedExecutionById.mockResolvedValue({
@@ -93,6 +111,21 @@ describe('executeResumeJob terminal errors', () => {
     })
     mockFindCellContextByExecutionId.mockResolvedValue(null)
     mockIsTimedOut.mockReturnValue(false)
+    mockWithCascadeLock.mockImplementation(
+      async (_tableId: string, _rowId: string, _ownerId: string, run: () => Promise<unknown>) => ({
+        status: 'acquired',
+        result: await run(),
+      })
+    )
+    mockCreateWorkflowCellProgressWriter.mockReturnValue({
+      onBlockComplete: vi.fn(),
+      finish: vi.fn(),
+      getBlockErrors: vi.fn(() => ({})),
+      getPendingDataPatch: vi.fn(() => undefined),
+      getEventOutputs: vi.fn(() => ({})),
+      getPendingSecretProvenance: vi.fn(() => undefined),
+    })
+    mockWriteWorkflowGroupState.mockResolvedValue('wrote')
   })
 
   it('rethrows the original core-finalized resume error', async () => {
@@ -155,4 +188,47 @@ describe('executeResumeJob terminal errors', () => {
       message: 'Execution timed out after 5 seconds',
     })
   })
+
+  it('preserves manual-run provenance across a paused cell resume', async () => {
+    mockFindCellContextByExecutionId.mockResolvedValue({
+      tableId: 'table-1',
+      tableName: 'Table',
+      rowId: 'row-1',
+      groupId: 'group-1',
+      workspaceId: 'workspace-1',
+      workflowId: 'workflow-1',
+    })
+    mockGetRowById.mockResolvedValue({
+      executions: {
+        'group-1': {
+          status: 'pending',
+          executionId: payload.parentExecutionId,
+          jobId: `paused-${payload.parentExecutionId}`,
+          workflowId: 'workflow-1',
+          isManualRun: true,
+          error: null,
+        },
+      },
+    })
+    mockGetTableById.mockResolvedValue({
+      schema: {
+        columns: [],
+        workflowGroups: [{ id: 'group-1', workflowId: 'workflow-1', outputs: [] }],
+      },
+    })
+    mockStartResumeExecution.mockResolvedValue({
+      success: true,
+      status: 'paused',
+      output: undefined,
+    })
+
+    await executeResumeJob(payload)
+
+    expect(mockWriteWorkflowGroupState).toHaveBeenCalledWith(
+      expect.objectContaining({ isManualRun: true }),
+      expect.objectContaining({
+        executionState: expect.objectContaining({ status: 'pending' }),
+      })
+    )
+  })
 })
diff --git a/apps/sim/background/resume-execution.ts b/apps/sim/background/resume-execution.ts
@@ -101,6 +101,7 @@ export async function executeResumeJob(payload: ResumeExecutionPayload, signal?:
     // at the pause boundary.
     const { findCellContextByExecutionId } = await import('@/lib/table/workflow-columns')
     const cellContext = await findCellContextByExecutionId(parentExecutionId)
+    let cellIsManualRun: boolean | undefined
 
     // A paused/awaiting table cell that was cancelled by "Stop all" must not
     // resume — the cancel write is authoritative (matches the cell-write guard
@@ -113,7 +114,8 @@ export async function executeResumeJob(payload: ResumeExecutionPayload, signal?:
         cellContext.rowId,
         cellContext.workspaceId
       )
-      if (isExecCancelled(cellRow?.executions?.[cellContext.groupId])) {
+      const cellExecution = cellRow?.executions?.[cellContext.groupId]
+      if (isExecCancelled(cellExecution)) {
         logger.info('Skipping resume — table cell cancelled', {
           tableId: cellContext.tableId,
           rowId: cellContext.rowId,
@@ -130,10 +132,11 @@ export async function executeResumeJob(payload: ResumeExecutionPayload, signal?:
           executedAt: new Date().toISOString(),
         }
       }
+      cellIsManualRun = cellExecution?.isManualRun
     }
 
     const writers = cellContext
-      ? await buildResumeCellWriters(cellContext, parentExecutionId)
+      ? await buildResumeCellWriters(cellContext, parentExecutionId, cellIsManualRun)
       : null
 
     // No cell context → plain resume, no lock, no cascade continuation.
@@ -261,7 +264,8 @@ async function buildResumeCellWriters(
     groupId: string
     workflowId: string
   },
-  parentExecutionId: string
+  parentExecutionId: string,
+  isManualRun: boolean | undefined
 ): Promise<CellWriters | null> {
   const { getTableById } = await import('@/lib/table/service')
   const { buildCancelledExecution, createWorkflowCellProgressWriter, writeWorkflowGroupState } =
@@ -284,6 +288,7 @@ async function buildResumeCellWriters(
     workspaceId: cellContext.workspaceId,
     groupId: cellContext.groupId,
     executionId: parentExecutionId,
+    isManualRun,
     requestId: `wfgrp-resume-${parentExecutionId}`,
     table,
   }
