fix(executor): a skipped stop block fails a run another branch paused, and names a Response ending

- A run whose stop block was proven unreachable fails even when another branch
  paused, instead of returning a paused run that would resume past it.
- When a Response block ended the run first, the error says so rather than
  claiming no path leads to the stop block.

Author: waleedlatif1

apps/sim/executor/execution/engine.test.ts

@@ -1117,7 +1117,10 @@ describe('ExecutionEngine', () => {
         handleNodeCompletion: vi.fn(),
       } as unknown as NodeExecutionOrchestrator
       const engine = new ExecutionEngine(
-        createMockContext({ stopAfterBlockId }),
+        createMockContext({
+          stopAfterBlockId,
+          decisions: { router: new Map(), condition: new Map() },
+        }),
         dag,
         new EdgeManager(dag),
         nodeOrchestrator
@@ -1184,6 +1187,46 @@ describe('ExecutionEngine', () => {
       expect(executed).toEqual(['start', 'router'])
     })
 
+    it('fails rather than pausing when another branch pauses after the stop block is skipped', async () => {
+      const { engine, executed } = buildRun(
+        {
+          version: '1',
+          blocks: [
+            block('start', BlockType.STARTER),
+            block('approval'),
+            block('condition', BlockType.CONDITION),
+            block('taken'),
+            block('stop'),
+          ],
+          connections: [
+            { source: 'start', target: 'approval' },
+            { source: 'start', target: 'condition' },
+            { source: 'condition', target: 'taken', sourceHandle: 'condition-if' },
+            { source: 'condition', target: 'stop', sourceHandle: 'condition-else' },
+          ],
+          loops: {},
+          parallels: {},
+        },
+        'stop',
+        {
+          approval: {
+            response: { status: 'paused' },
+            _pauseMetadata: {
+              contextId: 'pause-1',
+              blockId: 'approval',
+              response: { status: 'paused' },
+              timestamp: new Date().toISOString(),
+              pauseKind: 'hitl',
+            },
+          },
+          condition: { selectedOption: 'if' },
+        }
+      )
+
+      await expect(engine.run('start')).rejects.toThrow('Stop block "stop" (stop) was not reached')
+      expect(executed).toEqual(['start', 'approval', 'condition'])
+    })
+
     it('fails when the stop block sits on an error path the run never takes', async () => {
       const { engine, executed } = buildRun(
         {
@@ -1332,7 +1375,7 @@ describe('ExecutionEngine', () => {
 
       const pastResponse = buildRun(workflow, 'stop')
       await expect(pastResponse.engine.run('start')).rejects.toThrow(
-        'Stop block "stop" (stop) was not reached'
+        'Stop block "stop" (stop) was not reached: a Response block ended the run first'
       )
       expect(pastResponse.executed).toEqual(['start', 'respond'])
     })

apps/sim/executor/execution/engine.ts

@@ -37,6 +37,7 @@ export class ExecutionEngine {
   private stoppedEarlyFlag = false
   private stopBlockQueued = false
   private stopBlockReached = false
+  private stopBlockUnreachable = false
   private executionError: Error | null = null
   private abortPromise!: Promise<void>
   private abortResolve!: () => void
@@ -127,12 +128,13 @@ export class ExecutionEngine {
         throw this.executionError
       }
 
-      if (this.pausedBlocks.size > 0) {
-        return this.buildPausedResult(startTime)
+      /** A pause keeps a run whose stop block can still run; one proven unreachable fails. */
+      if (!this.cancelledFlag && (this.stopBlockUnreachable || this.pausedBlocks.size === 0)) {
+        this.assertStopBlockReached()
       }
 
-      if (!this.cancelledFlag) {
-        this.assertStopBlockReached()
+      if (this.pausedBlocks.size > 0) {
+        return this.buildPausedResult(startTime)
       }
 
       const endTime = performance.now()
@@ -546,6 +548,7 @@ export class ExecutionEngine {
       return
     }
     this.execLogger.info('Stopping execution: the stop block can no longer run', { stopBlockId })
+    this.stopBlockUnreachable = true
     this.stoppedEarlyFlag = true
   }
 
@@ -562,7 +565,11 @@ export class ExecutionEngine {
       : node?.block.metadata?.name
         ? `"${node.block.metadata.name}" (${stopBlockId})`
         : stopBlockId
-    throw new Error(`Stop block ${label} was not reached: no path this run took leads to it`)
+    const reason =
+      this.responseOutputLocked && !this.stopBlockUnreachable
+        ? 'a Response block ended the run first'
+        : 'no path this run took leads to it'
+    throw new Error(`Stop block ${label} was not reached: ${reason}`)
   }
 
   private setFinalOutput(nodeId: string, output: NormalizedBlockOutput): void {