fix(tables): continue the cascade after a completed resume whose later step threw

A completed run's cell is completed, so its downstream workflow groups still
start; the failure is still rethrown. A pause that cannot be saved now throws a
stable message with the underlying error on cause, so API callers never see
internal persistence details.

Author: waleedlatif1

apps/sim/background/resume-execution.ts

@@ -178,13 +178,36 @@ export async function executeResumeJob(payload: ResumeExecutionPayload, signal?:
       cellContext.rowId,
       parentExecutionId,
       async () => {
+        let completedBeforeFailure = false
         const result = await runResumeAndCellTerminal(
           payload,
           pausedExecution,
           writers,
           attemptSignal,
-          attemptTimeoutController
-        )
+          attemptTimeoutController,
+          () => {
+            completedBeforeFailure = true
+          }
+        ).catch(async (error: unknown) => {
+          /**
+           * The run completed and only a later step of the attempt threw, so its
+           * cell is completed: continue the cascade as a completed run would, and
+           * still surface the failure.
+           */
+          if (completedBeforeFailure) {
+            await continueCascadeAfterResume(cellContext, billingAttribution, attemptSignal).catch(
+              (cascadeError: unknown) => {
+                logger.error(
+                  'Failed to continue the cascade after a completed resume',
+                  projectResolvedSecretDiagnosticError(cascadeError, undefined, {
+                    resumeExecutionId,
+                  })
+                )
+              }
+            )
+          }
+          throw error
+        })
         if (result.status === 'paused' || result.status === 'cancelled') return result
         await continueCascadeAfterResume(cellContext, billingAttribution, attemptSignal)
         return result
@@ -392,7 +415,8 @@ async function runResumeAndCellTerminal(
   pausedExecution: Awaited<ReturnType<typeof PauseResumeManager.getPausedExecutionById>>,
   writers: CellWriters,
   signal: AbortSignal | undefined,
-  timeoutController: ReturnType<typeof createTimeoutAbortController>
+  timeoutController: ReturnType<typeof createTimeoutAbortController>,
+  onCompletedBeforeFailure?: () => void
 ): Promise<Awaited<ReturnType<typeof PauseResumeManager.startResumeExecution>>> {
   if (!pausedExecution) throw new Error('Paused execution missing — already nulled by caller')
   const result = await PauseResumeManager.startResumeExecution({
@@ -403,7 +427,10 @@ async function runResumeAndCellTerminal(
     resumeInput: payload.resumeInput,
     userId: payload.userId,
     onBlockComplete: writers.cellOnBlockComplete,
-    onAttemptFailed: (outcome, error) => writeFailedResumeCellTerminal(writers, outcome, error),
+    onAttemptFailed: async (outcome, error) => {
+      if (outcome === 'execution_completed') onCompletedBeforeFailure?.()
+      await writeFailedResumeCellTerminal(writers, outcome, error)
+    },
     abortSignal: signal,
   })
 

apps/sim/background/resume-governed-subject.test.ts

@@ -264,6 +264,16 @@ describe('resuming a paused table cell', () => {
         executionId: 'parent-execution-1',
         error: null,
       })
+      expect(mocks.runRowCascadeLoop).toHaveBeenCalledTimes(1)
+    }, 20_000)
+
+    it('does not continue the cascade when the resume failed the execution', async () => {
+      const runFailure = new Error('Block failed')
+      failResume('execution_failed', runFailure)
+
+      await expect(executeResumeJob(PAYLOAD)).rejects.toBe(runFailure)
+
+      expect(mocks.runRowCascadeLoop).not.toHaveBeenCalled()
     }, 20_000)
 
     it('puts the cell back to paused when the pause stayed resumable', async () => {

apps/sim/lib/workflows/executor/human-in-the-loop-manager.test.ts

@@ -369,9 +369,10 @@ describe('what a failed resume did to its paused execution', () => {
       pauseRun({ snapshotSeed: createSnapshotSeed(), persistError: new Error('lock timeout') })
       const { outcomes, args } = argsReportingOutcomes()
 
-      await expect(PauseResumeManager.startResumeExecution(args)).rejects.toThrow(
-        'Failed to persist pause state: lock timeout'
-      )
+      await expect(PauseResumeManager.startResumeExecution(args)).rejects.toMatchObject({
+        message: 'Failed to persist pause state',
+        cause: new Error('lock timeout'),
+      })
       expect(outcomes).toEqual(['execution_failed'])
     })
 

apps/sim/lib/workflows/executor/human-in-the-loop-manager.ts

@@ -927,17 +927,18 @@ export class PauseResumeManager {
       if (result.status === 'paused') {
         /**
          * A pause that cannot be saved fails the execution. Fail the log with the
-         * reason, then throw so the attempt settles as failed below.
+         * reason, then throw so the attempt settles as failed below. The thrown
+         * message stays stable; the underlying error rides on `cause`.
          */
         const effectiveExecutionId = result.metadata?.executionId ?? resumeExecutionId
-        const failPause = async (message: string, cause?: unknown): Promise<never> => {
+        const failPause = async (reason: string, cause?: unknown): Promise<never> => {
           await LoggingSession.markExecutionAsFailed(
             effectiveExecutionId,
-            message,
+            cause === undefined ? reason : `${reason}: ${toError(cause).message}`,
             undefined,
             pausedExecution.workflowId
           )
-          throw new Error(message, { cause })
+          throw new Error(reason, { cause })
         }
         if (!result.snapshotSeed) {
           await failPause('Missing snapshot seed for paused execution')
@@ -952,10 +953,7 @@ export class PauseResumeManager {
               executorUserId: result.metadata?.userId,
             })
           } catch (pauseError) {
-            await failPause(
-              `Failed to persist pause state: ${toError(pauseError).message}`,
-              pauseError
-            )
+            await failPause('Failed to persist pause state', pauseError)
           }
         }
       } else {