fix(executor): preserve disabled-branch execution and join readiness (#7537)

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.test.tsx

@@ -16,6 +16,7 @@ const {
   mockEndScopedExecution,
   mockExecute,
   mockExecuteFromBlock,
+  mockFindStartBlock,
   mockFetch,
   mockHandleExecutionCancelledConsole,
   mockHandleExecutionErrorConsole,
@@ -101,6 +102,7 @@ const {
     mockEndScopedExecution: vi.fn(() => true),
     mockExecute: vi.fn(),
     mockExecuteFromBlock: vi.fn(),
+    mockFindStartBlock: vi.fn(() => ({ blockId: 'start' })),
     mockFetch: vi.fn(),
     mockHandleExecutionCancelledConsole: vi.fn(),
     mockHandleExecutionErrorConsole: vi.fn(),
@@ -180,7 +182,7 @@ vi.mock('@/lib/workflows/triggers/triggers', () => ({
     EXTERNAL_TRIGGER: 'external-trigger',
   },
   TriggerUtils: {
-    findStartBlock: () => ({ blockId: 'start' }),
+    findStartBlock: mockFindStartBlock,
     getTriggerValidationMessage: () => 'Missing trigger',
   },
 }))
@@ -1097,6 +1099,7 @@ describe('useWorkflowExecution attachment uploads', () => {
     }
     executionStoreState.getLastExecutionSnapshot.mockReturnValueOnce(sourceSnapshot)
     workflowStoreState.edges.push({ source: 'start', target: 'function-1' } as never)
+    workflowStoreState.edges.push({ source: 'function-1', target: 'disabledBranch' } as never)
     const currentBlocks = {
       ...workflowBlocks,
       'function-1': {
@@ -1106,6 +1109,18 @@ describe('useWorkflowExecution attachment uploads', () => {
         enabled: true,
         subBlocks: { code: { value: 'return "current editor state"' } },
       },
+      disabledBranch: {
+        id: 'disabledBranch',
+        type: 'slack',
+        name: 'Disabled Branch',
+        enabled: false,
+        subBlocks: {},
+      },
+      disabledTrigger: {
+        ...workflowBlocks.start,
+        id: 'disabledTrigger',
+        enabled: false,
+      },
     }
     workflowStoreState.getWorkflowState.mockReturnValueOnce({
       blocks: currentBlocks,
@@ -1147,10 +1162,23 @@ describe('useWorkflowExecution attachment uploads', () => {
         ...workflowBlocks.start,
         subBlocks: { inputFormat: { value: 'current-editor-state' } },
       },
+      disabledBranch: {
+        id: 'disabledBranch',
+        type: 'slack',
+        name: 'Disabled Branch',
+        enabled: false,
+        subBlocks: {},
+      },
+      disabledTrigger: {
+        ...workflowBlocks.start,
+        id: 'disabledTrigger',
+        enabled: false,
+      },
     }
+    const currentEdges = [{ source: 'start', target: 'disabledBranch' }]
     workflowStoreState.getWorkflowState.mockReturnValueOnce({
       blocks: currentBlocks,
-      edges: [],
+      edges: currentEdges,
       loops: {},
       parallels: {},
     })
@@ -1181,12 +1209,16 @@ describe('useWorkflowExecution attachment uploads', () => {
         isClientSession: true,
         workflowStateOverride: {
           blocks: currentBlocks,
-          edges: [],
+          edges: currentEdges,
           loops: {},
           parallels: {},
         },
       })
     )
+    expect(mockResolveStartCandidates).toHaveBeenCalledWith(
+      { start: currentBlocks.start },
+      { execution: 'manual' }
+    )
     expect(mockExecute.mock.calls[0]?.[0]).not.toHaveProperty('sourceSnapshot')
     expect(mockExecuteFromBlock).not.toHaveBeenCalled()
     expect(executionStoreState.setLastExecutionSnapshot).toHaveBeenCalledWith(
@@ -1277,3 +1309,102 @@ describe('useWorkflowExecution attachment uploads', () => {
     unmount()
   })
 })
+
+describe('useWorkflowExecution workflow state override', () => {
+  beforeEach(() => {
+    resetWorkflowExecutionTestState()
+    vi.stubGlobal('fetch', mockFetch)
+    const startCandidate = {
+      blockId: 'start',
+      block: workflowBlocks.start,
+      path: 'legacy-starter',
+    }
+    mockResolveStartCandidates.mockReturnValue([startCandidate])
+    mockSelectBestTrigger.mockReturnValue([startCandidate])
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it.each(['manual', 'chat', 'run-until'] as const)(
+    'keeps disabled blocks and edges in %s payloads while excluding disabled triggers',
+    async (triggerType) => {
+      const blocks = {
+        ...workflowBlocks,
+        condition1: {
+          id: 'condition1',
+          type: 'condition',
+          name: 'Check',
+          enabled: true,
+          subBlocks: {},
+        },
+        disabledBranch: {
+          id: 'disabledBranch',
+          type: 'slack',
+          name: 'Send Empty',
+          enabled: false,
+          subBlocks: {},
+        },
+        disabledTrigger: {
+          ...workflowBlocks.start,
+          id: 'disabledTrigger',
+          enabled: false,
+        },
+      }
+      const edges = [
+        {
+          id: 'edge-1',
+          source: 'condition1',
+          target: 'disabledBranch',
+          sourceHandle: 'condition-else1',
+        },
+      ]
+      workflowStoreState.getWorkflowState.mockReturnValueOnce({
+        blocks: { ...blocks, layout: { id: 'layout' } },
+        edges,
+        loops: {},
+        parallels: {},
+      })
+      const { result, unmount } = renderWorkflowExecutionHook()
+
+      await act(async () => {
+        if (triggerType === 'run-until') {
+          await result().handleRunUntilBlock('condition1', 'workflow-1')
+          return
+        }
+        const runResult = await result().handleRunWorkflow(
+          triggerType === 'chat'
+            ? {
+                input: 'go',
+                conversationId: 'conversation-1',
+              }
+            : undefined
+        )
+        await drainStream(runResult)
+      })
+
+      expect(mockExecute).toHaveBeenCalledTimes(1)
+      const { workflowStateOverride } = mockExecute.mock.calls[0][0]
+      const sentBlockIds = new Set(Object.keys(workflowStateOverride.blocks))
+
+      expect(workflowStateOverride.blocks).toEqual(blocks)
+      expect(workflowStateOverride.edges).toEqual(edges)
+      expect(sentBlockIds.has('disabledBranch')).toBe(true)
+      for (const edge of workflowStateOverride.edges) {
+        expect(sentBlockIds.has(edge.source)).toBe(true)
+        expect(sentBlockIds.has(edge.target)).toBe(true)
+      }
+      const enabledBlocks = { start: blocks.start, condition1: blocks.condition1 }
+      if (triggerType === 'chat') {
+        expect(mockFindStartBlock).toHaveBeenCalledWith(enabledBlocks, 'chat')
+      } else {
+        expect(mockResolveStartCandidates).toHaveBeenCalledWith(enabledBlocks, {
+          execution: 'manual',
+        })
+      }
+
+      unmount()
+    }
+  )
+})

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.ts

@@ -1104,10 +1104,10 @@ export function useWorkflowExecution() {
     const workflowEdges = (executionWorkflowState?.edges ??
       latestWorkflowState.edges) as typeof currentWorkflow.edges
 
-    // Filter out blocks without type (these are layout-only blocks) and disabled blocks
+    /** Keep disabled targets available for routing; the DAG excludes them from execution. */
     const validBlocks = Object.entries(workflowBlocks).reduce(
       (acc, [blockId, block]) => {
-        if (block?.type && block.enabled !== false) {
+        if (block?.type) {
           acc[blockId] = block
         }
         return acc
@@ -1145,24 +1145,29 @@ export function useWorkflowExecution() {
       }
     })
 
-    // Filter out blocks without type and disabled blocks
     const filteredStates = Object.entries(mergedStates).reduce(
       (acc, [id, block]) => {
         if (!block || !block.type) {
           logger.warn(`Skipping block with undefined type: ${id}`, block)
           return acc
         }
-        // Skip disabled blocks to prevent them from being passed to executor
-        if (block.enabled === false) {
-          logger.warn(`Skipping disabled block: ${id}`)
-          return acc
-        }
         acc[id] = block
         return acc
       },
       {} as typeof mergedStates
     )
 
+    /** Trigger resolution must never select a disabled trigger. */
+    const enabledStates = Object.entries(filteredStates).reduce(
+      (acc, [id, block]) => {
+        if (block.enabled !== false) {
+          acc[id] = block
+        }
+        return acc
+      },
+      {} as typeof filteredStates
+    )
+
     // If this is a chat execution, get the selected outputs
     let selectedOutputs: string[] | undefined
     if (isExecutingFromChat && activeWorkflowId) {
@@ -1177,7 +1182,7 @@ export function useWorkflowExecution() {
 
     if (isExecutingFromChat) {
       // For chat execution, find the appropriate chat trigger
-      const startBlock = TriggerUtils.findStartBlock(filteredStates, 'chat')
+      const startBlock = TriggerUtils.findStartBlock(enabledStates, 'chat')
 
       if (!startBlock) {
         throw new WorkflowValidationError(
@@ -1191,7 +1196,7 @@ export function useWorkflowExecution() {
       startBlockId = startBlock.blockId
     } else {
       // Manual execution: detect and group triggers by paths
-      const candidates = resolveStartCandidates(filteredStates, {
+      const candidates = resolveStartCandidates(enabledStates, {
         execution: 'manual',
       })
 
@@ -1203,7 +1208,7 @@ export function useWorkflowExecution() {
           'Workflow Validation'
         )
         logger.error('No trigger blocks found for manual run', {
-          allBlockTypes: Object.values(filteredStates).map((b) => b.type),
+          allBlockTypes: Object.values(enabledStates).map((b) => b.type),
         })
         if (activeWorkflowId) finishOwnedExecution(activeWorkflowId, persistenceExecution)
         throw error
@@ -2034,15 +2039,15 @@ export function useWorkflowExecution() {
       const sourceExecutionId = isTriggerBlock ? undefined : effectiveSnapshot.sourceExecutionId
 
       const mergedStates = mergeSubblockState(latestWorkflowState.blocks, workflowId)
-      const executableStates = Object.entries(mergedStates).reduce(
+      const filteredStates = Object.entries(mergedStates).reduce(
         (states, [id, block]) => {
-          if (block?.type && block.enabled !== false) states[id] = block
+          if (block?.type) states[id] = block
           return states
         },
         {} as typeof mergedStates
       )
       const workflowStateOverride = workflowStateSchema.parse({
-        blocks: executableStates,
+        blocks: filteredStates,
         edges: workflowEdges,
         loops: latestWorkflowState.loops,
         parallels: latestWorkflowState.parallels,
@@ -2051,7 +2056,14 @@ export function useWorkflowExecution() {
       // Extract mock payload for trigger blocks
       let workflowInput: any
       if (isTriggerBlock) {
-        const candidates = resolveStartCandidates(executableStates, { execution: 'manual' })
+        const enabledStates = Object.entries(filteredStates).reduce(
+          (states, [id, block]) => {
+            if (block.enabled !== false) states[id] = block
+            return states
+          },
+          {} as typeof filteredStates
+        )
+        const candidates = resolveStartCandidates(enabledStates, { execution: 'manual' })
         const candidate = candidates.find((c) => c.blockId === blockId)
 
         if (candidate) {
@@ -2069,7 +2081,7 @@ export function useWorkflowExecution() {
           }
         } else {
           // Fallback: block is trigger by position but not classified as start candidate
-          const block = executableStates[blockId]
+          const block = enabledStates[blockId]
           if (block) {
             const blockConfig = getBlock(block.type)
             const hasTriggers = blockConfig?.triggers?.available?.length

apps/sim/executor/dag/construction/edges.ts

@@ -75,6 +75,8 @@ export class EdgeConstructor {
     const routerV2ConfigMap = new Map<string, RouterV2RouteConfig[]>()
 
     for (const block of workflow.blocks) {
+      if (block.enabled === false) continue
+
       const blockType = block.metadata?.id ?? ''
       blockTypeMap.set(block.id, blockType)