fix(copilot): report the run from the engine, and never let recovery erase it

Two findings, both real.

Firing before `engine.run` was still one step early: the engine's
cancellation subscription is fallible and rejects having run nothing, so
that failure claimed a run. The signal now fires inside the engine,
immediately before the loop that processes blocks and past every startup
step that can refuse a request — DAG construction, pipeline assembly and
the subscription. The executor no longer guesses at the line from outside;
the engine states it.

Separately, the copilot catch path could throw while recording the failed
crossing or releasing the execution slot. Either one propagated a
different error — one the dispatched-run id was never recorded against —
so an existing run reported itself as never started and invited the
duplicate the id exists to prevent. Both are recovery work and neither may
replace the failure it is describing, so both are contained and logged.
Contained with try/catch rather than a rejection handler, since a
synchronous throw has to be caught too.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

apps/sim/executor/execution/engine.ts

@@ -107,6 +107,15 @@ export class ExecutionEngine {
       this.initializeQueue(triggerBlockId)
       await this.subscribeToCancellationSignal()
 
+      /**
+       * Past every fallible startup step — DAG construction, pipeline assembly and the
+       * cancellation subscription above all reject having run nothing — and immediately
+       * before the loop that processes blocks. This is the line a caller means by "could a
+       * side effect have occurred"; anything earlier reports a run for a request that was
+       * merely refused.
+       */
+      this.context.onBlocksMayRun?.()
+
       while (this.hasWork()) {
         if (this.checkCancellation() || this.errorFlag || this.stoppedEarlyFlag) {
           break

apps/sim/executor/execution/executor.ts

@@ -101,7 +101,6 @@ export class DAGExecutor {
     this.registerRestoredClonedSubflows(context.subflowParentMap, restoredClonedSubflows)
 
     const engine = this.buildExecutionPipeline(context, dag, state)
-    this.contextExtensions.onBlocksMayRun?.()
     return await engine.run(triggerBlockId)
   }
 
@@ -259,7 +258,6 @@ export class DAGExecutor {
     context.subflowParentMap = this.buildSubflowParentMap(dag)
 
     const engine = this.buildExecutionPipeline(context, dag, state, filteredSnapshot)
-    this.contextExtensions.onBlocksMayRun?.()
     const result = await engine.run()
     if (result.metadata) {
       result.metadata.largeValueKeys = context.largeValueKeys
@@ -417,6 +415,7 @@ export class DAGExecutor {
 
     const context: ExecutionContext = {
       workflowId,
+      onBlocksMayRun: this.contextExtensions.onBlocksMayRun,
       workspaceId: this.contextExtensions.workspaceId,
       executionId: this.contextExtensions.executionId,
       largeValueExecutionIds: this.contextExtensions.largeValueExecutionIds,

apps/sim/executor/types.ts

@@ -372,6 +372,8 @@ export interface ExecutorDelegationOrigin {
 }
 
 export interface ExecutionContext {
+  /** See {@link ContextExtensions.onBlocksMayRun}. Fired by the engine, once. */
+  onBlocksMayRun?: () => void
   workflowId: string
   workspaceId?: string
   executionId?: string

apps/sim/lib/workflows/application/run-workflow-from-copilot.ts

@@ -1,4 +1,5 @@
 import { type Principal, requirePrincipalSubjectUserId } from '@sim/auth/principal'
+import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
 import { generateId } from '@sim/utils/id'
 import { mergeSubblockStateWithValues } from '@sim/workflow-persistence/subblocks'
@@ -29,6 +30,9 @@ import {
 import type { SerializableExecutionState } from '@/executor/execution/types'
 import type { ExecutionResult } from '@/executor/types'
 import { attachAttemptedExecutionId } from '@/executor/utils/errors'
+
+const logger = createLogger('CopilotWorkflowRun')
+
 import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 
 export interface CopilotWorkflowRunLifecycle {
@@ -305,6 +309,12 @@ async function executeCopilotRun(params: {
      * what threw and an execution certainly exists.
      */
     if (runReturned) attachAttemptedExecutionId(error, childExecutionId)
+    /**
+     * Recovery must never replace the failure it is describing. Both steps below run only to
+     * record and release, and either throwing would propagate a different error — one the
+     * dispatched-run id was never recorded against — so an existing run would report itself
+     * as never started and invite the duplicate this id exists to prevent.
+     */
     if (registry) {
       const executionResult =
         typeof error === 'object' &&
@@ -313,18 +323,34 @@ async function executeCopilotRun(params: {
         typeof error.executionResult === 'object'
           ? (error.executionResult as ExecutionResult)
           : undefined
-      await registry.importCrossingProvenance(
-        executionResult?.executionState?.resolvedSecretTraceProvenance,
-        {
-          output: executionResult?.output,
-          logs: executionResult?.logs,
-          error: executionResult?.error,
-          thrownMessage: toError(error).message,
-        },
-        { trusted: true, origin: 'copilotWorkflowMutation.failedRunCrossing' }
-      )
+      try {
+        await registry.importCrossingProvenance(
+          executionResult?.executionState?.resolvedSecretTraceProvenance,
+          {
+            output: executionResult?.output,
+            logs: executionResult?.logs,
+            error: executionResult?.error,
+            thrownMessage: toError(error).message,
+          },
+          { trusted: true, origin: 'copilotWorkflowMutation.failedRunCrossing' }
+        )
+      } catch (importError) {
+        logger.error('Failed to record provenance for a failed Copilot run', {
+          executionId: childExecutionId,
+          error: toError(importError).message,
+        })
+      }
+    }
+    if (admission.targetReservation) {
+      try {
+        await releaseExecutionSlot(childExecutionId)
+      } catch (releaseError) {
+        logger.error('Failed to release the execution slot for a failed Copilot run', {
+          executionId: childExecutionId,
+          error: toError(releaseError).message,
+        })
+      }
     }
-    if (admission.targetReservation) await releaseExecutionSlot(childExecutionId)
     throw error
   } finally {
     completePendingActivation?.()