fix(workflows): refuse a disabled stop block, or one reached only through one

The executor omits disabled blocks from its graph, so a disabled stop target,
or one whose only path runs through a disabled block, is never reached and
the run would finish everything after the entry.

Author: Waleed Latif

apps/sim/lib/workflows/application/execute-manual-workflow.test.ts

@@ -377,6 +377,37 @@ describe('manual workflow execution application operations', () => {
     expect(mocks.executeService).not.toHaveBeenCalled()
   })
 
+  it('rejects a disabled stop block, or one reached only through a disabled block', async () => {
+    mockLoadManualState.mockResolvedValue({
+      blocks: {
+        'trigger-1': {},
+        'agent-1': { enabled: false },
+        'agent-2': {},
+      },
+      edges: [
+        { source: 'trigger-1', target: 'agent-1' },
+        { source: 'agent-1', target: 'agent-2' },
+      ],
+    })
+
+    await expect(
+      executeManualWorkflowOperation.execute({
+        principal,
+        input: { ...baseInput, useMockPayload: false, stopAfterBlockId: 'agent-1' },
+      })
+    ).rejects.toMatchObject({ code: 'validation', message: expect.stringContaining('is disabled') })
+    await expect(
+      executeManualWorkflowOperation.execute({
+        principal,
+        input: { ...baseInput, useMockPayload: false, stopAfterBlockId: 'agent-2' },
+      })
+    ).rejects.toMatchObject({
+      code: 'validation',
+      message: expect.stringContaining('not reachable'),
+    })
+    expect(mocks.executeService).not.toHaveBeenCalled()
+  })
+
   it('rejects a stop block named by an inherited object key', async () => {
     await expect(
       executeManualWorkflowOperation.execute({

apps/sim/lib/workflows/application/execute-manual-workflow.ts

@@ -50,6 +50,7 @@ async function loadManualState(workflowId: string) {
 
 type ManualWorkflowState = Awaited<ReturnType<typeof loadManualState>>
 
+/** Blocks a run entering at `entryBlockId` can reach; the executor skips disabled blocks. */
 function reachableFrom(state: ManualWorkflowState, entryBlockId: string): Set<string> {
   const targetsBySource = new Map<string, string[]>()
   for (const edge of state.edges) {
@@ -61,7 +62,7 @@ function reachableFrom(state: ManualWorkflowState, entryBlockId: string): Set<st
   const queue = [entryBlockId]
   for (let next = queue.pop(); next !== undefined; next = queue.pop()) {
     for (const target of targetsBySource.get(next) ?? []) {
-      if (reached.has(target)) continue
+      if (reached.has(target) || state.blocks[target]?.enabled === false) continue
       reached.add(target)
       queue.push(target)
     }
@@ -72,10 +73,10 @@ function reachableFrom(state: ManualWorkflowState, entryBlockId: string): Set<st
 /**
  * The engine stops only when it completes a node whose id equals the target, so
  * a target the run cannot reach would silently run everything after the entry:
- * an unknown id, a block upstream of the entry, or a block inside a loop or
- * parallel (which would stop after its first iteration or never). All are
- * refused, matching the editor, which offers "Run until block" only outside
- * subflows.
+ * an unknown or disabled block, a block upstream of the entry or only behind a
+ * disabled one, or a block inside a loop or parallel (which would stop after its
+ * first iteration or never). All are refused, matching the editor, which offers
+ * "Run until block" only outside subflows.
  */
 function assertStopAfterBlock(
   state: ManualWorkflowState,
@@ -90,6 +91,12 @@ function assertStopAfterBlock(
       `run.stopAfterBlockId "${blockId}" is not a block in the current saved workflow.`
     )
   }
+  if (block.enabled === false) {
+    throw new OrchestrationError(
+      'validation',
+      `run.stopAfterBlockId "${blockId}" is disabled, so the run never executes it.`
+    )
+  }
   if (block.data?.parentId) {
     throw new OrchestrationError(
       'validation',