fix(executor): fail a stop-after run whose routing skips the stop block (#8635)

* fix(executor): fail a stop-after run whose routing skips the stop block

A run with stopAfterBlockId only stopped when the stop block completed. When a
router, condition, or untaken error path routed the run away from it, the stop
never triggered and the run finished every other branch, reporting success as
if it had stopped there. A static check before the run cannot see this.

- The engine ends the run as soon as every path into the stop block has been
  deactivated, before any further block starts, and fails it with
  `Stop block "<name>" (<id>) was not reached: no path this run took leads to it`.
- Any run that ends without completing its stop block fails the same way: a
  stop block missing from the executed graph, or a Response block that ended
  the run first.
- A loop or parallel stop with nothing to run completes at its start sentinel,
  whose end sentinel never runs, so that exit now counts as reaching it.
- The v2 contract and the CLI `--stop-after` help describe the failure.
- E2E: a condition fixture checks the stop on the taken branch still stops
  there, a stop on the skipped branch fails the run before the other branch's
  slow block finishes, and the CLI exits non-zero.

* 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/docs/content/docs/cli/reference.mdx

@@ -6704,7 +6704,7 @@ sim workflows run <workflowId> [options]
 | `--mock-payload` | No | Use the selected trigger's server-derived mock payload; runs the current saved workflow state (implies --manual). |
 | `--from-block <blockId>` | No | Run manually from this saved workflow block. |
 | `--source-run <runId>` | No | Prior run whose persisted state supplies upstream outputs (requires --from-block). |
-| `--stop-after <blockId>` | No | Stop the run after this saved block; with --from-block on the same block, re-runs only that block (implies --manual). |
+| `--stop-after <blockId>` | No | Stop the run after this saved block, failing it if the run takes a path that skips the block; with --from-block on the same block, re-runs only that block (implies --manual). |
 | `--follow` | No | Stream the run as it happens; progress on stderr, result on stdout. The stream reports only success and output, so the result omits the run id and timings a non-streaming run returns. |
 | `--include-thinking` | No | Show model reasoning while following (requires --follow). |
 | `--include-tool-calls` | No | Show tool calls while following (requires --follow). |

apps/docs/content/docs/cli/workflows.mdx

@@ -642,7 +642,7 @@ sim workflows run <workflowId> [options]
 | `--mock-payload` | No | Use the selected trigger's server-derived mock payload; runs the current saved workflow state (implies --manual). |
 | `--from-block <blockId>` | No | Run manually from this saved workflow block. |
 | `--source-run <runId>` | No | Prior run whose persisted state supplies upstream outputs (requires --from-block). |
-| `--stop-after <blockId>` | No | Stop the run after this saved block; with --from-block on the same block, re-runs only that block (implies --manual). |
+| `--stop-after <blockId>` | No | Stop the run after this saved block, failing it if the run takes a path that skips the block; with --from-block on the same block, re-runs only that block (implies --manual). |
 | `--follow` | No | Stream the run as it happens; progress on stderr, result on stdout. The stream reports only success and output, so the result omits the run id and timings a non-streaming run returns. |
 | `--include-thinking` | No | Show model reasoning while following (requires --follow). |
 | `--include-tool-calls` | No | Show tool calls while following (requires --follow). |

apps/docs/openapi-v2-workflows.json

@@ -12617,7 +12617,7 @@
                     ]
                   },
                   "stopAfterBlockId": {
-                    "description": "Saved workflow block after which the run stops; downstream blocks do not execute. Must not be inside a loop or parallel. With a block entry naming the same block, re-runs only that block against the source run.",
+                    "description": "Saved workflow block after which the run stops; downstream blocks do not execute. Must not be inside a loop or parallel. If a router, condition, or untaken error path routes the run away from the block, the run fails as soon as that is decided, without running the other branches. With a block entry naming the same block, re-runs only that block against the source run.",
                     "type": "string",
                     "minLength": 1
                   }

apps/sim/executor/execution/edge-manager.ts

@@ -122,6 +122,17 @@ export class EdgeManager {
     return node.incomingEdges.size === 0 || this.countActiveIncomingEdges(node) === 0
   }
 
+  /**
+   * Whether a node that has not been queued can still run: it has received an activated edge, or
+   * an incoming edge is still undecided. False means every path into it was deactivated (a router
+   * or condition chose another route, or an error path was not taken), so nothing will queue it.
+   */
+  canNodeStillRun(nodeId: string): boolean {
+    if (this.nodesWithActivatedEdge.has(nodeId)) return true
+    const node = this.dag.nodes.get(nodeId)
+    return node !== undefined && this.countActiveIncomingEdges(node) > 0
+  }
+
   restoreIncomingEdge(targetNodeId: string, sourceNodeId: string): void {
     const targetNode = this.dag.nodes.get(targetNodeId)
     if (!targetNode) {

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

@@ -21,13 +21,17 @@ vi.mock('@/lib/execution/cancellation', () => ({
   },
 }))
 
-import { EDGE } from '@/executor/constants'
-import type { DAG, DAGNode } from '@/executor/dag/builder'
-import type { EdgeManager } from '@/executor/execution/edge-manager'
+import { BlockType, EDGE } from '@/executor/constants'
+import { type DAG, DAGBuilder, type DAGNode } from '@/executor/dag/builder'
+import { EdgeManager } from '@/executor/execution/edge-manager'
 import type { NodeExecutionOrchestrator } from '@/executor/orchestrators/node'
 import type { ExecutionContext, ExecutionResult } from '@/executor/types'
 import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
-import type { SerializedBlock } from '@/serializer/types'
+import {
+  buildLoopSentinelEndId,
+  buildLoopSentinelStartId,
+} from '@/executor/utils/subflow-node-id-codec'
+import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
 import { ExecutionEngine } from './engine'
 
 const executionEngineLoggerCallIndex = loggerMock.createLogger.mock.calls.findIndex(
@@ -1088,4 +1092,309 @@ describe('ExecutionEngine', () => {
       expect(result.output).toEqual({ data: { response: true }, status: 200, headers: {} })
     })
   })
+  /**
+   * A stop-after run is a promise that the run ends with the stop block. These run the real DAG
+   * builder and edge manager, so a router or condition deciding a path is the same decision the
+   * engine makes in production.
+   */
+  describe('Stop-after block', () => {
+    function block(id: string, type = BlockType.FUNCTION): SerializedBlock {
+      return { ...createMockBlock(id), metadata: { id: type, name: id } }
+    }
+
+    function buildRun(
+      workflow: SerializedWorkflow,
+      stopAfterBlockId: string,
+      outputs: Record<string, ExecutionResult['output']> = {}
+    ) {
+      const dag = new DAGBuilder().build(workflow, { triggerBlockId: 'start' })
+      const executed: string[] = []
+      const nodeOrchestrator = {
+        executeNode: vi.fn(async (_ctx: ExecutionContext, nodeId: string) => {
+          executed.push(nodeId)
+          return { nodeId, output: outputs[nodeId] ?? {}, isFinalOutput: false }
+        }),
+        handleNodeCompletion: vi.fn(),
+      } as unknown as NodeExecutionOrchestrator
+      const engine = new ExecutionEngine(
+        createMockContext({
+          stopAfterBlockId,
+          decisions: { router: new Map(), condition: new Map() },
+        }),
+        dag,
+        new EdgeManager(dag),
+        nodeOrchestrator
+      )
+      return { engine, executed }
+    }
+
+    /** start → condition; `if` → taken → takenTail, `else` → stop → after. */
+    const conditionWorkflow: SerializedWorkflow = {
+      version: '1',
+      blocks: [
+        block('start', BlockType.STARTER),
+        block('condition', BlockType.CONDITION),
+        block('taken'),
+        block('takenTail'),
+        block('stop'),
+        block('after'),
+      ],
+      connections: [
+        { source: 'start', target: 'condition' },
+        { source: 'condition', target: 'taken', sourceHandle: 'condition-if' },
+        { source: 'condition', target: 'stop', sourceHandle: 'condition-else' },
+        { source: 'taken', target: 'takenTail' },
+        { source: 'stop', target: 'after' },
+      ],
+      loops: {},
+      parallels: {},
+    }
+
+    it('fails as soon as a condition routes away from the stop block', async () => {
+      const { engine, executed } = buildRun(conditionWorkflow, 'stop', {
+        condition: { selectedOption: 'if' },
+      })
+
+      await expect(engine.run('start')).rejects.toThrow('Stop block "stop" (stop) was not reached')
+      expect(executed).toEqual(['start', 'condition'])
+    })
+
+    it('fails as soon as a router routes away from the stop block', async () => {
+      const { engine, executed } = buildRun(
+        {
+          version: '1',
+          blocks: [
+            block('start', BlockType.STARTER),
+            block('router', BlockType.ROUTER_V2),
+            block('taken'),
+            block('takenTail'),
+            block('stop'),
+          ],
+          connections: [
+            { source: 'start', target: 'router' },
+            { source: 'router', target: 'taken', sourceHandle: 'router-route-a' },
+            { source: 'router', target: 'stop', sourceHandle: 'router-route-b' },
+            { source: 'taken', target: 'takenTail' },
+          ],
+          loops: {},
+          parallels: {},
+        },
+        'stop',
+        { router: { selectedRoute: 'route-a' } }
+      )
+
+      await expect(engine.run('start')).rejects.toThrow('Stop block "stop" (stop) was not reached')
+      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(
+        {
+          version: '1',
+          blocks: [block('start', BlockType.STARTER), block('work'), block('next'), block('stop')],
+          connections: [
+            { source: 'start', target: 'work' },
+            { source: 'work', target: 'next', sourceHandle: 'source' },
+            { source: 'work', target: 'stop', sourceHandle: 'error' },
+          ],
+          loops: {},
+          parallels: {},
+        },
+        'stop'
+      )
+
+      await expect(engine.run('start')).rejects.toThrow('Stop block "stop" (stop) was not reached')
+      expect(executed).toEqual(['start', 'work'])
+    })
+
+    it('stops after the stop block when the condition routes to it', async () => {
+      const { engine, executed } = buildRun(conditionWorkflow, 'stop', {
+        condition: { selectedOption: 'else' },
+      })
+
+      const result = await engine.run('start')
+
+      expect(result.success).toBe(true)
+      expect(executed).toEqual(['start', 'condition', 'stop'])
+    })
+
+    it('runs a join reached through one taken and one skipped branch', async () => {
+      const { engine, executed } = buildRun(
+        {
+          version: '1',
+          blocks: [
+            block('start', BlockType.STARTER),
+            block('condition', BlockType.CONDITION),
+            block('taken'),
+            block('skipped'),
+            block('stop'),
+            block('after'),
+          ],
+          connections: [
+            { source: 'start', target: 'condition' },
+            { source: 'condition', target: 'taken', sourceHandle: 'condition-if' },
+            { source: 'condition', target: 'skipped', sourceHandle: 'condition-else' },
+            { source: 'taken', target: 'stop' },
+            { source: 'skipped', target: 'stop' },
+            { source: 'stop', target: 'after' },
+          ],
+          loops: {},
+          parallels: {},
+        },
+        'stop',
+        { condition: { selectedOption: 'if' } }
+      )
+
+      const result = await engine.run('start')
+
+      expect(result.success).toBe(true)
+      expect(executed).toEqual(['start', 'condition', 'taken', 'stop'])
+    })
+
+    it('runs a loop stop block queued by a dead end inside the loop', async () => {
+      const sentinelStart = buildLoopSentinelStartId('loop')
+      const sentinelEnd = buildLoopSentinelEndId('loop')
+      const { engine, executed } = buildRun(
+        {
+          version: '1',
+          blocks: [
+            block('start', BlockType.STARTER),
+            block('loop', BlockType.LOOP),
+            block('condition', BlockType.CONDITION),
+            block('inner'),
+            block('after'),
+          ],
+          connections: [
+            { source: 'start', target: 'loop' },
+            { source: 'loop', target: 'condition', sourceHandle: 'loop-start-source' },
+            { source: 'condition', target: 'inner', sourceHandle: 'condition-if' },
+            { source: 'loop', target: 'after', sourceHandle: 'loop-end-source' },
+          ],
+          loops: { loop: { id: 'loop', nodes: ['condition', 'inner'], iterations: 1 } },
+          parallels: {},
+        },
+        sentinelEnd,
+        { condition: { selectedOption: 'else' } }
+      )
+
+      const result = await engine.run('start')
+
+      expect(result.success).toBe(true)
+      expect(executed).toEqual(['start', sentinelStart, 'condition', sentinelEnd])
+    })
+
+    it('stops after a loop stop block whose loop has nothing to run', async () => {
+      const sentinelStart = buildLoopSentinelStartId('loop')
+      const { engine, executed } = buildRun(
+        {
+          version: '1',
+          blocks: [
+            block('start', BlockType.STARTER),
+            block('loop', BlockType.LOOP),
+            block('inner'),
+            block('after'),
+          ],
+          connections: [
+            { source: 'start', target: 'loop' },
+            { source: 'loop', target: 'inner', sourceHandle: 'loop-start-source' },
+            { source: 'loop', target: 'after', sourceHandle: 'loop-end-source' },
+          ],
+          loops: { loop: { id: 'loop', nodes: ['inner'], iterations: 0 } },
+          parallels: {},
+        },
+        buildLoopSentinelEndId('loop'),
+        {
+          [sentinelStart]: { sentinelStart: true, shouldExit: true, selectedRoute: EDGE.LOOP_EXIT },
+        }
+      )
+
+      const result = await engine.run('start')
+
+      expect(result.success).toBe(true)
+      expect(executed).toEqual(['start', sentinelStart])
+    })
+
+    it('succeeds when the stop block is a Response block, and fails when one ends the run first', async () => {
+      const workflow: SerializedWorkflow = {
+        version: '1',
+        blocks: [
+          block('start', BlockType.STARTER),
+          block('respond', BlockType.RESPONSE),
+          block('stop'),
+        ],
+        connections: [
+          { source: 'start', target: 'respond' },
+          { source: 'respond', target: 'stop' },
+        ],
+        loops: {},
+        parallels: {},
+      }
+
+      const atResponse = buildRun(workflow, 'respond')
+      expect((await atResponse.engine.run('start')).success).toBe(true)
+
+      const pastResponse = buildRun(workflow, 'stop')
+      await expect(pastResponse.engine.run('start')).rejects.toThrow(
+        'Stop block "stop" (stop) was not reached: a Response block ended the run first'
+      )
+      expect(pastResponse.executed).toEqual(['start', 'respond'])
+    })
+
+    it('stops after the entry block when the stop block is the entry', async () => {
+      const { engine, executed } = buildRun(conditionWorkflow, 'start')
+
+      const result = await engine.run('start')
+
+      expect(result.success).toBe(true)
+      expect(executed).toEqual(['start'])
+    })
+
+    it('fails when the stop block is not in the graph the run executes', async () => {
+      const { engine } = buildRun(conditionWorkflow, 'missing', {
+        condition: { selectedOption: 'if' },
+      })
+
+      await expect(engine.run('start')).rejects.toThrow('Stop block missing was not reached')
+    })
+  })
 })