feat(executor): add nested loop iteration context and named loop variable resolution

Introduce ParentIteration to track ancestor loop state, build a
loopParentMap during DAG construction, and propagate parent iterations
through block execution and child workflow contexts.

Extend LoopResolver to support named loop references (e.g. <loop1.index>)
and add output property resolution (<loop1.result>). Named references
use the block's display name normalized to a tag-safe identifier,
enabling blocks inside nested loops to reference any ancestor loop's
iteration state.

NOTE: loop-in-loop nesting only; parallel nesting is not yet supported.
Made-with: Cursor

Author: abram0v1ch

apps/sim/executor/execution/block-executor.ts

@@ -40,7 +40,6 @@ import { isJSONString } from '@/executor/utils/json'
 import { filterOutputForLog } from '@/executor/utils/output-filter'
 import type { VariableResolver } from '@/executor/variables/resolver'
 import type { SerializedBlock } from '@/serializer/types'
-import type { SubflowType } from '@/stores/workflows/workflow/types'
 import { SYSTEM_SUBBLOCK_IDS } from '@/triggers/constants'
 
 const logger = createLogger('BlockExecutor')
@@ -499,47 +498,58 @@ export class BlockExecutor {
     }
   }
 
-  private createIterationContext(
-    iterationCurrent: number,
-    iterationType: SubflowType,
-    iterationContainerId?: string,
-    iterationTotal?: number
-  ): IterationContext {
-    return {
-      iterationCurrent,
-      iterationTotal,
-      iterationType,
-      iterationContainerId,
-    }
-  }
-
   private getIterationContext(ctx: ExecutionContext, node: DAGNode): IterationContext | undefined {
     if (!node?.metadata) return undefined
 
     if (node.metadata.branchIndex !== undefined && node.metadata.branchTotal !== undefined) {
-      return this.createIterationContext(
-        node.metadata.branchIndex,
-        'parallel',
-        node.metadata.parallelId,
-        node.metadata.branchTotal
-      )
+      return {
+        iterationCurrent: node.metadata.branchIndex,
+        iterationTotal: node.metadata.branchTotal,
+        iterationType: 'parallel',
+        iterationContainerId: node.metadata.parallelId,
+      }
     }
 
     if (node.metadata.isLoopNode && node.metadata.loopId) {
       const loopScope = ctx.loopExecutions?.get(node.metadata.loopId)
       if (loopScope && loopScope.iteration !== undefined) {
-        return this.createIterationContext(
-          loopScope.iteration,
-          'loop',
-          node.metadata.loopId,
-          loopScope.maxIterations
-        )
+        const parentIterations = this.buildParentIterations(ctx, node.metadata.loopId)
+        const result: IterationContext = {
+          iterationCurrent: loopScope.iteration,
+          iterationTotal: loopScope.maxIterations,
+          iterationType: 'loop',
+          iterationContainerId: node.metadata.loopId,
+          ...(parentIterations.length > 0 && { parentIterations }),
+        }
+        return result
       }
     }
 
     return undefined
   }
 
+  private buildParentIterations(
+    ctx: ExecutionContext,
+    loopId: string
+  ): IterationContext['parentIterations'] & object {
+    const parents: NonNullable<IterationContext['parentIterations']> = []
+    let currentLoopId = loopId
+    while (ctx.loopParentMap?.has(currentLoopId)) {
+      const parentLoopId = ctx.loopParentMap.get(currentLoopId)!
+      const parentScope = ctx.loopExecutions?.get(parentLoopId)
+      if (parentScope && parentScope.iteration !== undefined) {
+        parents.unshift({
+          iterationCurrent: parentScope.iteration,
+          iterationTotal: parentScope.maxIterations,
+          iterationType: 'loop',
+          iterationContainerId: parentLoopId,
+        })
+      }
+      currentLoopId = parentLoopId
+    }
+    return parents
+  }
+
   private preparePauseResumeSelfReference(
     ctx: ExecutionContext,
     node: DAGNode,

apps/sim/executor/execution/executor.ts

@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { StartBlockPath } from '@/lib/workflows/triggers/triggers'
+import type { DAG } from '@/executor/dag/builder'
 import { DAGBuilder } from '@/executor/dag/builder'
 import { BlockExecutor } from '@/executor/execution/block-executor'
 import { EdgeManager } from '@/executor/execution/edge-manager'
@@ -67,6 +68,7 @@ export class DAGExecutor {
       savedIncomingEdges,
     })
     const { context, state } = this.createExecutionContext(workflowId, triggerBlockId)
+    context.loopParentMap = this.buildLoopParentMap(dag)
 
     const resolver = new VariableResolver(this.workflow, this.workflowVariables, state)
     const loopOrchestrator = new LoopOrchestrator(dag, state, resolver)
@@ -208,6 +210,7 @@ export class DAGExecutor {
       snapshotState: filteredSnapshot,
       runFromBlockContext,
     })
+    context.loopParentMap = this.buildLoopParentMap(dag)
 
     const resolver = new VariableResolver(this.workflow, this.workflowVariables, state)
     const loopOrchestrator = new LoopOrchestrator(dag, state, resolver)
@@ -371,6 +374,24 @@ export class DAGExecutor {
     return { context, state }
   }
 
+  /**
+   * Builds a child-loop -> parent-loop mapping for nested loop iteration tracking.
+   *
+   * NOTE: This currently handles loop-in-loop nesting only.
+   * Parallel-in-loop and parallel-in-parallel nesting is not yet supported.
+   */
+  private buildLoopParentMap(dag: DAG): Map<string, string> {
+    const parentMap = new Map<string, string>()
+    for (const [loopId, config] of dag.loopConfigs) {
+      for (const nodeId of config.nodes) {
+        if (dag.loopConfigs.has(nodeId)) {
+          parentMap.set(nodeId, loopId)
+        }
+      }
+    }
+    return parentMap
+  }
+
   private initializeStarterBlock(
     context: ExecutionContext,
     state: ExecutionState,

apps/sim/executor/execution/types.ts

@@ -49,11 +49,24 @@ export interface SerializableExecutionState {
   completedPauseContexts?: string[]
 }
 
+/**
+ * Represents the iteration state of an ancestor loop in a nested loop chain.
+ * Used to propagate parent iteration context through SSE events.
+ * Currently only covers loop-in-loop nesting; parallel nesting is not yet supported.
+ */
+export interface ParentIteration {
+  iterationCurrent: number
+  iterationTotal?: number
+  iterationType: SubflowType
+  iterationContainerId: string
+}
+
 export interface IterationContext {
   iterationCurrent: number
   iterationTotal?: number
   iterationType: SubflowType
   iterationContainerId?: string
+  parentIterations?: ParentIteration[]
 }
 
 export interface ChildWorkflowContext {

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

@@ -290,18 +290,42 @@ export class WorkflowBlockHandler implements BlockHandler {
     if (nodeMetadata.isLoopNode && nodeMetadata.loopId) {
       const loopScope = ctx.loopExecutions?.get(nodeMetadata.loopId)
       if (loopScope && loopScope.iteration !== undefined) {
+        const parentIterations = this.buildParentIterations(ctx, nodeMetadata.loopId)
         return {
           iterationCurrent: loopScope.iteration,
           iterationTotal: loopScope.maxIterations,
           iterationType: 'loop',
           iterationContainerId: nodeMetadata.loopId,
+          ...(parentIterations.length > 0 && { parentIterations }),
         }
       }
     }
 
     return undefined
   }
 
+  private buildParentIterations(
+    ctx: ExecutionContext,
+    loopId: string
+  ): NonNullable<IterationContext['parentIterations']> {
+    const parents: NonNullable<IterationContext['parentIterations']> = []
+    let currentLoopId = loopId
+    while (ctx.loopParentMap?.has(currentLoopId)) {
+      const parentLoopId = ctx.loopParentMap.get(currentLoopId)!
+      const parentScope = ctx.loopExecutions?.get(parentLoopId)
+      if (parentScope && parentScope.iteration !== undefined) {
+        parents.unshift({
+          iterationCurrent: parentScope.iteration,
+          iterationTotal: parentScope.maxIterations,
+          iterationType: 'loop',
+          iterationContainerId: parentLoopId,
+        })
+      }
+      currentLoopId = parentLoopId
+    }
+    return parents
+  }
+
   /**
    * Builds a cleaner error message for nested workflow errors.
    * Parses nested error messages to extract workflow chain and root error.

apps/sim/executor/types.ts

@@ -192,6 +192,12 @@ export interface ExecutionContext {
 
   completedLoops: Set<string>
 
+  /**
+   * Maps child loop IDs to their parent loop IDs for nested loop iteration tracking.
+   * Only covers loop-in-loop nesting; parallel nesting is not yet supported.
+   */
+  loopParentMap?: Map<string, string>
+
   loopExecutions?: Map<
     string,
     {