fix(executor): remove dead fallbacks, fix nested loop boundary detection, restore executionOrder

- Remove unreachable `?? candidateIds[0]` fallbacks in loop/parallel resolvers
- Remove arbitrary first-match fallback scan in findEffectiveContainerId
- Fix edgeCrossesLoopBoundary to use innermost loop detection for nested loops
- Add warning log for missing branch outputs in parallel aggregation
- Restore executionOrder on WorkflowNodeMetadata and pipe through child workflow notification
- Remove dead sim-drag-subflow classList.remove call
- Clean up cloned loop subflowParentMap entries in deleteParallelScopeAndClones

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx

@@ -1719,7 +1719,6 @@ const WorkflowContent = React.memo(() => {
         const containerInfo = isPointInLoopNode(position)
 
         clearDragHighlights()
-        document.body.classList.remove('sim-drag-subflow')
 
         if (data.type === 'loop' || data.type === 'parallel') {
           const id = crypto.randomUUID()

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

@@ -421,20 +421,35 @@ export class EdgeConstructor {
       return false
     }
 
-    let sourceLoopId: string | undefined
-    let targetLoopId: string | undefined
+    // Find the innermost loop for each block. In nested loops a block appears
+    // in multiple loop configs; we need the most deeply nested one.
+    const sourceLoopId = this.findInnermostLoop(source, dag)
+    const targetLoopId = this.findInnermostLoop(target, dag)
 
-    for (const [loopId, loopConfig] of dag.loopConfigs) {
-      if (loopConfig.nodes.includes(source)) {
-        sourceLoopId = loopId
-      }
+    return sourceLoopId !== targetLoopId
+  }
 
-      if (loopConfig.nodes.includes(target)) {
-        targetLoopId = loopId
+  /**
+   * Finds the innermost loop containing a block. When a block is in nested
+   * loops (A contains B, both list the block), returns B (the one that
+   * doesn't contain any other candidate loop).
+   */
+  private findInnermostLoop(blockId: string, dag: DAG): string | undefined {
+    const candidates: string[] = []
+    for (const [loopId, loopConfig] of dag.loopConfigs) {
+      if (loopConfig.nodes.includes(blockId)) {
+        candidates.push(loopId)
       }
     }
+    if (candidates.length <= 1) return candidates[0]
 
-    return sourceLoopId !== targetLoopId
+    return candidates.find((candidateId) =>
+      candidates.every((otherId) => {
+        if (otherId === candidateId) return true
+        const candidateConfig = dag.loopConfigs.get(candidateId)
+        return !candidateConfig?.nodes.includes(otherId)
+      })
+    )
   }
 
   private isEdgeReachable(

apps/sim/executor/execution/types.ts

@@ -93,6 +93,7 @@ export interface WorkflowNodeMetadata
     'loopId' | 'parallelId' | 'branchIndex' | 'branchTotal' | 'originalBlockId' | 'isLoopNode'
   > {
   nodeId: string
+  executionOrder?: number
 }
 
 export interface ChildWorkflowContext {

apps/sim/executor/handlers/workflow/workflow-handler.ts

@@ -160,7 +160,12 @@ export class WorkflowBlockHandler implements BlockHandler {
           ? (nodeMetadata.originalBlockId ?? nodeMetadata.nodeId)
           : block.id
         const iterationContext = nodeMetadata ? getIterationContext(ctx, nodeMetadata) : undefined
-        ctx.onChildWorkflowInstanceReady?.(effectiveBlockId, instanceId, iterationContext)
+        ctx.onChildWorkflowInstanceReady?.(
+          effectiveBlockId,
+          instanceId,
+          iterationContext,
+          nodeMetadata?.executionOrder
+        )
       }
 
       const subExecutor = new Executor({

apps/sim/executor/orchestrators/parallel.ts

@@ -263,8 +263,11 @@ export class ParallelOrchestrator {
 
     const results: NormalizedBlockOutput[][] = []
     for (let i = 0; i < scope.totalBranches; i++) {
-      const branchOutputs = scope.branchOutputs.get(i) || []
-      results.push(branchOutputs)
+      const branchOutputs = scope.branchOutputs.get(i)
+      if (!branchOutputs) {
+        logger.warn('Missing branch output during parallel aggregation', { parallelId, branch: i })
+      }
+      results.push(branchOutputs ?? [])
     }
     const output = { results }
     this.state.setBlockOutput(parallelId, output)

apps/sim/executor/utils/subflow-utils.ts

@@ -152,20 +152,8 @@ export function findEffectiveContainerId(
     }
   }
 
-  // Use the original ID if it exists (non-cloned or branch-0 case)
-  if (executionMap.has(originalId)) {
-    return originalId
-  }
-
-  // Fallback: scan execution map for a cloned variant
-  const prefix = `${originalId}__obranch-`
-  for (const key of executionMap.keys()) {
-    if (key.startsWith(prefix)) {
-      return key
-    }
-  }
-
-  // No clone found — return original (caller handles missing scope)
+  // Return original ID — for branch-0 (non-cloned) or when scope is missing.
+  // Callers handle the missing-scope case gracefully.
   return originalId
 }
 

apps/sim/executor/variables/resolvers/loop.ts

@@ -175,13 +175,12 @@ export class LoopResolver implements Resolver {
     if (candidateLoopIds.length === 0) return undefined
     if (candidateLoopIds.length === 1) return candidateLoopIds[0]
 
-    // Return the innermost: the loop that is not an ancestor of any other candidate
-    return (
-      candidateLoopIds.find((candidateId) =>
-        candidateLoopIds.every(
-          (otherId) => otherId === candidateId || !loops[candidateId].nodes.includes(otherId)
-        )
-      ) ?? candidateLoopIds[0]
+    // Return the innermost: the loop that is not an ancestor of any other candidate.
+    // In a valid DAG, exactly one candidate will satisfy this (circular containment is impossible).
+    return candidateLoopIds.find((candidateId) =>
+      candidateLoopIds.every(
+        (otherId) => otherId === candidateId || !loops[candidateId].nodes.includes(otherId)
+      )
     )
   }
 

apps/sim/executor/variables/resolvers/parallel.ts

@@ -152,12 +152,12 @@ export class ParallelResolver implements Resolver {
     if (candidateIds.length === 0) return undefined
     if (candidateIds.length === 1) return candidateIds[0]
 
-    return (
-      candidateIds.find((candidateId) =>
-        candidateIds.every(
-          (otherId) => otherId === candidateId || !parallels[candidateId]?.nodes.includes(otherId)
-        )
-      ) ?? candidateIds[0]
+    // Return the innermost: the parallel that is not an ancestor of any other candidate.
+    // In a valid DAG, exactly one candidate will satisfy this (circular containment is impossible).
+    return candidateIds.find((candidateId) =>
+      candidateIds.every(
+        (otherId) => otherId === candidateId || !parallels[candidateId]?.nodes.includes(otherId)
+      )
     )
   }