fix(executor): name the outermost container and catch parallel children by workflow id

Author: waleedlatif1

apps/sim/executor/utils/run-from-block.test.ts

@@ -333,6 +333,53 @@ describe('validateRunFromBlock', () => {
     expect(result.error).toContain(outerParallelId)
   })
 
+  it('names the outermost container for a block in a nested loop, since the inner loop is refused too', () => {
+    const dag = createDAG([
+      createNode('B', [], { isLoopNode: true, subflowId: 'inner-loop', subflowType: 'loop' }),
+    ])
+    dag.loopConfigs.set('outer-loop', {
+      id: 'outer-loop',
+      nodes: ['inner-loop'],
+      iterations: 2,
+      loopType: 'for',
+    } as any)
+    dag.loopConfigs.set('inner-loop', {
+      id: 'inner-loop',
+      nodes: ['B'],
+      iterations: 2,
+      loopType: 'for',
+    } as any)
+
+    const result = validateRunFromBlock('B', dag, new Set())
+
+    expect(result.valid).toBe(false)
+    expect(result.refusal).toEqual({
+      kind: 'inside_subflow',
+      blockId: 'B',
+      subflowId: 'outer-loop',
+      subflowType: 'loop',
+    })
+  })
+
+  it('refuses a parallel child by its workflow id as inside the parallel, not as missing', () => {
+    // The DAG holds parallel children only as branch clones, never under the workflow id.
+    const dag = createDAG([
+      createNode('P₍0₎', [], { isParallelBranch: true, subflowId: 'par', subflowType: 'parallel' }),
+    ])
+    dag.parallelConfigs.set('par', { id: 'par', nodes: ['P'], count: 2 } as any)
+
+    const result = validateRunFromBlock('P', dag, new Set(), new Map([['par', 'Fan out']]))
+
+    expect(result.valid).toBe(false)
+    expect(result.error).toContain('inside parallel: Fan out')
+    expect(result.refusal).toEqual({
+      kind: 'inside_subflow',
+      blockId: 'P',
+      subflowId: 'par',
+      subflowType: 'parallel',
+    })
+  })
+
   it('rejects container when sentinel-start upstream dependency was not executed', () => {
     const loopId = 'loop-container-1'
     const sentinelStartId = `loop-${loopId}-sentinel-start`

apps/sim/executor/utils/run-from-block.ts

@@ -201,6 +201,9 @@ export function validateRunFromBlock(
     }
   }
 
+  const container = findOutermostContainer(blockId, dag)
+  if (container) return insideSubflow(container.id, container.type)
+
   const node = dag.nodes.get(blockId)
   const isLoopContainer = dag.loopConfigs.has(blockId)
   const isParallelContainer = dag.parallelConfigs.has(blockId)
@@ -216,12 +219,6 @@ export function validateRunFromBlock(
   }
 
   if (isContainer) {
-    const parentLoopId = findParentLoop(blockId, dag)
-    if (parentLoopId) return insideSubflow(parentLoopId, 'loop')
-
-    const parentParallelId = findParentParallel(blockId, dag)
-    if (parentParallelId) return insideSubflow(parentParallelId, 'parallel')
-
     const sentinelStartId = resolveContainerToSentinelStart(blockId, dag)
     if (!sentinelStartId || !dag.nodes.has(sentinelStartId)) {
       return {
@@ -265,6 +262,33 @@ export function validateRunFromBlock(
   return { valid: true }
 }
 
+/**
+ * The top-level loop or parallel a block sits in, however deeply nested. A nested container
+ * is refused as a start too, so naming the immediate parent would point at another refusal.
+ * Parallel children are matched by their workflow id, which the DAG only holds as branch clones.
+ */
+function findOutermostContainer(
+  blockId: string,
+  dag: DAG
+): { id: string; type: 'loop' | 'parallel' } | undefined {
+  let outermost: { id: string; type: 'loop' | 'parallel' } | undefined
+  const visited = new Set([blockId])
+  let current = blockId
+  while (true) {
+    const loopId = findParentLoop(current, dag)
+    const parallelId = loopId ? undefined : findParentParallel(current, dag)
+    const parent = loopId
+      ? { id: loopId, type: 'loop' as const }
+      : parallelId
+        ? { id: parallelId, type: 'parallel' as const }
+        : undefined
+    if (!parent || visited.has(parent.id)) return outermost
+    visited.add(parent.id)
+    outermost = parent
+    current = parent.id
+  }
+}
+
 function findParentLoop(blockId: string, dag: DAG): string | undefined {
   for (const [loopId, config] of dag.loopConfigs) {
     if (loopId !== blockId && config.nodes?.includes(blockId)) {