fix(provenance): keep the post-run crossing window out of the never-started claim

Review round 1, both findings accepted.

The post-run crossing runs inside the same try as the executor call, so
when that import is what throws, the catch sees an error carrying no
execution result — the same evidence a run that never started leaves.
The previous condition read that as "nothing crossed" and vouched for
it, when in fact an execution exists and its provenance was never
imported, which is exactly the content that cannot be vouched for.

Record whether the executor returned and require both facts before
claiming the absence: not past the executor, and no result attached.
Everything else hands back whatever envelope it has, and an incomplete
one still latches.

The executor test also could not fail against the old gated attach: a
block failure is normalized on the way in, so its rejection already
arrived as an Error. Drive it through the cancellation subscribe run()
awaits before the queue instead, which is its own synchronous work and
reaches the catch untouched — the case the total attach exists for.

Author: icecrasher321

apps/sim/executor/execution/engine.test.ts

@@ -277,9 +277,11 @@ describe('ExecutionEngine', () => {
 
     /**
      * The crossing at the copilot boundary reads the absence of an attached result as "no block
-     * ran". That inference is only total if every throw out of `run` carries one.
+     * ran", so the attach has to be total. A block failure is normalized on the way in, so only
+     * a non-Error raised by `run`'s own work — here the cancellation subscribe it awaits before
+     * the queue — reaches the catch untouched and exercises the guarantee.
      */
-    it('attaches the execution result to every throw out of a failed run', async () => {
+    it('attaches the execution result to a non-Error thrown by its own work', async () => {
       const node = createMockNode('function-1', 'function')
       const registry = new ResolvedSecretTraceRegistry([
         { name: 'TOKEN', plaintext: 'secret-value-1234', encryptedValue: 'ciphertext' },
@@ -289,14 +291,13 @@ describe('ExecutionEngine', () => {
         decisions: { router: new Map(), condition: new Map() },
         resolvedSecretTraceRegistry: registry,
       })
-      const nodeOrchestrator = createMockNodeOrchestrator()
-      vi.mocked(nodeOrchestrator.executeNode).mockRejectedValue(new Error('block exploded'))
+      mockIsExecutionCancelled.mockRejectedValueOnce('cancellation lookup exploded')
 
       const engine = new ExecutionEngine(
         context,
         createMockDAG([node]),
         createMockEdgeManager(),
-        nodeOrchestrator
+        createMockNodeOrchestrator()
       )
 
       const thrown = await engine.run(node.id).catch((error: unknown) => error)

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

@@ -440,6 +440,37 @@ describe('Copilot workflow run application commands', () => {
       )
     })
 
+    /**
+     * The post-run crossing is inside the same try, so its failure reaches the catch with no
+     * execution result — the same evidence a never-started run leaves. An execution exists and
+     * its provenance was never imported, so this must not be vouched for.
+     */
+    it('does not vouch when the crossing threw after the run returned', async () => {
+      const importCrossingProvenance = vi
+        .fn()
+        .mockImplementationOnce(() => {
+          throw new Error('crossing import failed')
+        })
+        .mockResolvedValue(true)
+
+      await runExpectingFailure({
+        lifecycle: {
+          resolvedSecretTraceRegistry: {
+            exportProvenanceForValue: vi.fn(() => undefined),
+            beginPendingActivation: vi.fn(() => vi.fn()),
+            importCrossingProvenance,
+          },
+        },
+      })
+
+      expect(importCrossingProvenance).toHaveBeenNthCalledWith(
+        2,
+        undefined,
+        expect.objectContaining({ thrownMessage: 'crossing import failed' }),
+        expect.objectContaining({ origin: 'copilotWorkflowMutation.failedRunCrossing' })
+      )
+    })
+
     /** A run that did execute and could not vouch still hands back its incomplete envelope. */
     it('passes through an incomplete envelope from a run that did execute', async () => {
       const { importCrossingProvenance, lifecycle: tracked } = trackingLifecycle()

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

@@ -253,6 +253,12 @@ async function executeCopilotRun(params: {
     params.executionInput
   )
   const completePendingActivation = registry?.beginPendingActivation()
+  /**
+   * Whether the executor returned. The post-run crossing is inside the same `try`, so its own
+   * failure lands in the catch carrying no execution result — indistinguishable, on that
+   * evidence alone, from a run that never started. This records the difference the error cannot.
+   */
+  let executed = false
   /**
    * The executor call is the first statement of this `try`, so everything caught below is
    * post-dispatch by construction, while authorization, admission and provenance export all
@@ -305,6 +311,7 @@ async function executeCopilotRun(params: {
       },
       childExecutionId
     )
+    executed = true
     if (registry) {
       await registry.importCrossingProvenance(
         result.executionState?.resolvedSecretTraceProvenance,
@@ -331,21 +338,21 @@ async function executeCopilotRun(params: {
       const executionResult = hasExecutionResult(error) ? error.executionResult : undefined
       try {
         /**
-         * A run that never reached the engine carried nothing back: the executor attaches its
-         * result to every throw, so its absence means no block ran, and the three content fields
-         * below are all undefined. The only content is `thrownMessage`, which this layer produced
-         * — an admission, validation, or setup failure — and which the tool boundary still
-         * projects against this registry before any of it reaches a model.
+         * A run that never started carried nothing back, and saying so keeps the caller's
+         * failure reason instead of reducing the tool result to "result unavailable" for a
+         * message that named no secret because none had been resolved yet.
          *
-         * Reporting that as unvouchable cost the caller the reason its run failed: the crossing
-         * latched, and the tool result was reduced to "result unavailable" for a message that
-         * named no secret because none had been resolved yet. An engine that did run and could
-         * not vouch still hands back an incomplete envelope, and that still latches.
+         * Both conditions are required to claim it. `executed` rules out the post-run window,
+         * where the crossing import is what threw: an execution exists and its provenance was
+         * never imported, so its content is exactly what cannot be vouched for. The absent
+         * execution result then rules out the engine having run at all — it attaches one to
+         * every throw. Anything else hands back whatever envelope it has, and an incomplete one
+         * still latches.
          */
         await registry.importCrossingProvenance(
-          executionResult
-            ? executionResult.executionState?.resolvedSecretTraceProvenance
-            : emptyResolvedSecretTraceProvenance(),
+          !executed && !executionResult
+            ? emptyResolvedSecretTraceProvenance()
+            : executionResult?.executionState?.resolvedSecretTraceProvenance,
           {
             output: executionResult?.output,
             logs: executionResult?.logs,