Lint

apps/sim/executor/execution/executor.ts

@@ -17,8 +17,8 @@ import { ParallelOrchestrator } from '@/executor/orchestrators/parallel'
 import type { BlockState, ExecutionContext, ExecutionResult } from '@/executor/types'
 import {
   computeDirtySet,
-  resolveContainerToSentinelStart,
   type RunFromBlockContext,
+  resolveContainerToSentinelStart,
   validateRunFromBlock,
 } from '@/executor/utils/run-from-block'
 import {
@@ -233,8 +233,6 @@ export class DAGExecutor {
       userId: this.contextExtensions.userId,
       isDeployedContext: this.contextExtensions.isDeployedContext,
       blockStates: state.getBlockStates(),
-      // For run-from-block, start with empty logs - we only want fresh execution logs for trace spans
-      // The snapshot's blockLogs are preserved separately for history
       blockLogs: overrides?.runFromBlockContext ? [] : (snapshotState?.blockLogs ?? []),
       metadata: {
         ...this.contextExtensions.metadata,
@@ -322,8 +320,6 @@ export class DAGExecutor {
         skipStarterBlockInit: true,
       })
     } else if (overrides?.runFromBlockContext) {
-      // In run-from-block mode, skip starter block initialization
-      // All block states come from the snapshot
       logger.info('Run-from-block mode: skipping starter block initialization', {
         startBlockId: overrides.runFromBlockContext.startBlockId,
       })

apps/sim/executor/orchestrators/loop.ts

@@ -281,12 +281,10 @@ export class LoopOrchestrator {
 
     // Emit onBlockComplete for the loop container so the UI can track it
     if (this.contextExtensions?.onBlockComplete) {
-      this.contextExtensions.onBlockComplete(
-        loopId,
-        'Loop',
-        'loop',
-        { output, executionTime: DEFAULTS.EXECUTION_TIME }
-      )
+      this.contextExtensions.onBlockComplete(loopId, 'Loop', 'loop', {
+        output,
+        executionTime: DEFAULTS.EXECUTION_TIME,
+      })
     }
 
     return {

apps/sim/executor/orchestrators/node.ts

@@ -31,7 +31,6 @@ export class NodeExecutionOrchestrator {
       throw new Error(`Node not found in DAG: ${nodeId}`)
     }
 
-    // In run-from-block mode, skip execution for non-dirty blocks and return cached output
     if (ctx.runFromBlockContext && !ctx.runFromBlockContext.dirtySet.has(nodeId)) {
       const cachedOutput = this.state.getBlockOutput(nodeId) || {}
       logger.debug('Skipping non-dirty block in run-from-block mode', { nodeId })
@@ -42,7 +41,6 @@ export class NodeExecutionOrchestrator {
       }
     }
 
-    // Skip hasExecuted check for dirty blocks in run-from-block mode - they need to be re-executed
     const isDirtyBlock = ctx.runFromBlockContext?.dirtySet.has(nodeId) ?? false
     if (!isDirtyBlock && this.state.hasExecuted(nodeId)) {
       const output = this.state.getBlockOutput(nodeId) || {}

apps/sim/executor/orchestrators/parallel.ts

@@ -233,12 +233,10 @@ export class ParallelOrchestrator {
 
     // Emit onBlockComplete for the parallel container so the UI can track it
     if (this.contextExtensions?.onBlockComplete) {
-      this.contextExtensions.onBlockComplete(
-        parallelId,
-        'Parallel',
-        'parallel',
-        { output, executionTime: 0 }
-      )
+      this.contextExtensions.onBlockComplete(parallelId, 'Parallel', 'parallel', {
+        output,
+        executionTime: 0,
+      })
     }
 
     return {

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

@@ -1,8 +1,8 @@
 import { describe, expect, it } from 'vitest'
 import type { DAG, DAGNode } from '@/executor/dag/builder'
 import type { DAGEdge, NodeMetadata } from '@/executor/dag/types'
-import type { SerializedLoop, SerializedParallel } from '@/serializer/types'
 import { computeDirtySet, validateRunFromBlock } from '@/executor/utils/run-from-block'
+import type { SerializedLoop, SerializedParallel } from '@/serializer/types'
 
 /**
  * Helper to create a DAG node for testing
@@ -291,7 +291,9 @@ describe('validateRunFromBlock', () => {
   })
 
   it('rejects blocks inside parallels', () => {
-    const dag = createDAG([createNode('A', [], { isParallelBranch: true, parallelId: 'parallel-1' })])
+    const dag = createDAG([
+      createNode('A', [], { isParallelBranch: true, parallelId: 'parallel-1' }),
+    ])
     const executedBlocks = new Set(['A'])
 
     const result = validateRunFromBlock('A', dag, executedBlocks)
@@ -352,9 +354,17 @@ describe('validateRunFromBlock', () => {
     const sentinelEndId = `loop-${loopId}-sentinel-end`
     const dag = createDAG([
       createNode('A', [{ target: sentinelStartId }]),
-      createNode(sentinelStartId, [{ target: 'B' }], { isSentinel: true, sentinelType: 'start', loopId }),
+      createNode(sentinelStartId, [{ target: 'B' }], {
+        isSentinel: true,
+        sentinelType: 'start',
+        loopId,
+      }),
       createNode('B', [{ target: sentinelEndId }], { isLoopNode: true, loopId }),
-      createNode(sentinelEndId, [{ target: 'C' }], { isSentinel: true, sentinelType: 'end', loopId }),
+      createNode(sentinelEndId, [{ target: 'C' }], {
+        isSentinel: true,
+        sentinelType: 'end',
+        loopId,
+      }),
       createNode('C'),
     ])
     dag.loopConfigs.set(loopId, { id: loopId, nodes: ['B'], iterations: 3, loopType: 'for' } as any)
@@ -372,9 +382,17 @@ describe('validateRunFromBlock', () => {
     const sentinelEndId = `parallel-${parallelId}-sentinel-end`
     const dag = createDAG([
       createNode('A', [{ target: sentinelStartId }]),
-      createNode(sentinelStartId, [{ target: 'B₍0₎' }], { isSentinel: true, sentinelType: 'start', parallelId }),
+      createNode(sentinelStartId, [{ target: 'B₍0₎' }], {
+        isSentinel: true,
+        sentinelType: 'start',
+        parallelId,
+      }),
       createNode('B₍0₎', [{ target: sentinelEndId }], { isParallelBranch: true, parallelId }),
-      createNode(sentinelEndId, [{ target: 'C' }], { isSentinel: true, sentinelType: 'end', parallelId }),
+      createNode(sentinelEndId, [{ target: 'C' }], {
+        isSentinel: true,
+        sentinelType: 'end',
+        parallelId,
+      }),
       createNode('C'),
     ])
     dag.parallelConfigs.set(parallelId, { id: parallelId, nodes: ['B'], count: 2 } as any)
@@ -412,9 +430,17 @@ describe('computeDirtySet with containers', () => {
     const sentinelEndId = `loop-${loopId}-sentinel-end`
     const dag = createDAG([
       createNode('A', [{ target: sentinelStartId }]),
-      createNode(sentinelStartId, [{ target: 'B' }], { isSentinel: true, sentinelType: 'start', loopId }),
+      createNode(sentinelStartId, [{ target: 'B' }], {
+        isSentinel: true,
+        sentinelType: 'start',
+        loopId,
+      }),
       createNode('B', [{ target: sentinelEndId }], { isLoopNode: true, loopId }),
-      createNode(sentinelEndId, [{ target: 'C' }], { isSentinel: true, sentinelType: 'end', loopId }),
+      createNode(sentinelEndId, [{ target: 'C' }], {
+        isSentinel: true,
+        sentinelType: 'end',
+        loopId,
+      }),
       createNode('C'),
     ])
     dag.loopConfigs.set(loopId, { id: loopId, nodes: ['B'], iterations: 3, loopType: 'for' } as any)
@@ -438,9 +464,17 @@ describe('computeDirtySet with containers', () => {
     const sentinelEndId = `parallel-${parallelId}-sentinel-end`
     const dag = createDAG([
       createNode('A', [{ target: sentinelStartId }]),
-      createNode(sentinelStartId, [{ target: 'B₍0₎' }], { isSentinel: true, sentinelType: 'start', parallelId }),
+      createNode(sentinelStartId, [{ target: 'B₍0₎' }], {
+        isSentinel: true,
+        sentinelType: 'start',
+        parallelId,
+      }),
       createNode('B₍0₎', [{ target: sentinelEndId }], { isParallelBranch: true, parallelId }),
-      createNode(sentinelEndId, [{ target: 'C' }], { isSentinel: true, sentinelType: 'end', parallelId }),
+      createNode(sentinelEndId, [{ target: 'C' }], {
+        isSentinel: true,
+        sentinelType: 'end',
+        parallelId,
+      }),
       createNode('C'),
     ])
     dag.parallelConfigs.set(parallelId, { id: parallelId, nodes: ['B'], count: 2 } as any)