@codemation/core 0.8.1 → 0.10.0

package/src/events/index.ts

@@ -1,3 +1,4 @@
+export { ConnectionInvocationEventPublisher } from "./ConnectionInvocationEventPublisher";
 export { NodeEventPublisher } from "./NodeEventPublisher";
 export { InMemoryRunEventBus } from "./InMemoryRunEventBusRegistry";
 export { EventPublishingWorkflowExecutionRepository } from "./EventPublishingWorkflowExecutionRepository";

package/src/events/runEvents.ts

@@ -1,5 +1,18 @@
+import type { TestSuiteRunId } from "../contracts/testTriggerTypes";
+import type { ConnectionInvocationRecord } from "../contracts/runTypes";
 import type { NodeExecutionSnapshot, ParentExecutionRef, PersistedRunState, RunId, WorkflowId } from "../types";
 
+/**
+ * Outcome of a single test case (one workflow run dispatched by the test-suite orchestrator).
+ * - `running`: workflow still in flight
+ * - `succeeded`: workflow completed AND all assertions passed (or no assertions)
+ * - `failed`: workflow failed OR (workflow completed but ≥1 assertion failed)
+ * - `errored` / `cancelled`: workflow itself errored or was cancelled
+ */
+export type TestCaseRunStatus = "running" | "succeeded" | "failed" | "errored" | "cancelled";
+/** Aggregate outcome of a TestSuiteRun. */
+export type TestSuiteRunStatus = "succeeded" | "failed" | "partial" | "errored" | "cancelled";
+
 export type RunEvent =
   | Readonly<{ kind: "runCreated"; runId: RunId; workflowId: WorkflowId; parent?: ParentExecutionRef; at: string }>
   | Readonly<{
@@ -41,6 +54,67 @@ export type RunEvent =
       parent?: ParentExecutionRef;
       at: string;
       snapshot: NodeExecutionSnapshot;
+    }>
+  | Readonly<{
+      kind: "connectionInvocationStarted";
+      runId: RunId;
+      workflowId: WorkflowId;
+      parent?: ParentExecutionRef;
+      at: string;
+      record: ConnectionInvocationRecord;
+    }>
+  | Readonly<{
+      kind: "connectionInvocationCompleted";
+      runId: RunId;
+      workflowId: WorkflowId;
+      parent?: ParentExecutionRef;
+      at: string;
+      record: ConnectionInvocationRecord;
+    }>
+  | Readonly<{
+      kind: "connectionInvocationFailed";
+      runId: RunId;
+      workflowId: WorkflowId;
+      parent?: ParentExecutionRef;
+      at: string;
+      record: ConnectionInvocationRecord;
+    }>
+  | Readonly<{
+      kind: "testSuiteStarted";
+      testSuiteRunId: TestSuiteRunId;
+      workflowId: WorkflowId;
+      triggerNodeId: string;
+      triggerNodeName?: string;
+      concurrency: number;
+      at: string;
+    }>
+  | Readonly<{
+      kind: "testSuiteFinished";
+      testSuiteRunId: TestSuiteRunId;
+      workflowId: WorkflowId;
+      status: TestSuiteRunStatus;
+      totalCases: number;
+      passedCases: number;
+      failedCases: number;
+      at: string;
+    }>
+  | Readonly<{
+      kind: "testCaseStarted";
+      testSuiteRunId: TestSuiteRunId;
+      testCaseIndex: number;
+      runId: RunId;
+      workflowId: WorkflowId;
+      testCaseLabel?: string;
+      at: string;
+    }>
+  | Readonly<{
+      kind: "testCaseCompleted";
+      testSuiteRunId: TestSuiteRunId;
+      testCaseIndex: number;
+      runId: RunId;
+      workflowId: WorkflowId;
+      status: TestCaseRunStatus;
+      at: string;
     }>;
 
 export interface RunEventSubscription {

package/src/execution/ChildExecutionScopeFactory.ts

@@ -0,0 +1,55 @@
+import type {
+  ActivationIdFactory,
+  ConnectionInvocationId,
+  NodeExecutionContext,
+  NodeId,
+  RunnableNodeConfig,
+  TelemetrySpanScope,
+} from "../types";
+
+/**
+ * Builds a re-rooted child execution context for sub-agent (and other deeply-nested) invocations.
+ *
+ * At the orchestrator's `agent.tool.call` boundary the inner runtime needs a ctx whose:
+ * - `nodeId` is the tool's connection node id (so inner LLM/tool connection ids derive correctly),
+ * - `activationId` is fresh (so its connection-invocation rows are uniquely identifiable),
+ * - `telemetry` parents children under the tool-call span (not the orchestrator's node span),
+ * - `binary` is scoped to the new (nodeId, activationId),
+ * - `parentInvocationId` points back to the tool-call invocation for downstream lineage.
+ *
+ * Registered via factory in {@link EngineRuntimeRegistrar} so constructors stay free of parameter
+ * decorators (Next/SWC and coverage tooling cannot parse them on in-repo sources).
+ */
+export class ChildExecutionScopeFactory {
+  constructor(private readonly activationIdFactory: ActivationIdFactory) {}
+
+  forSubAgent<TConfig extends RunnableNodeConfig<any, any>>(
+    args: Readonly<{
+      parentCtx: NodeExecutionContext<TConfig>;
+      childNodeId: NodeId;
+      childConfig: TConfig;
+      parentInvocationId: ConnectionInvocationId;
+      parentSpan: TelemetrySpanScope;
+    }>,
+  ): NodeExecutionContext<TConfig> {
+    const childActivationId = this.activationIdFactory.makeActivationId();
+    const childTelemetry = args.parentSpan.asNodeTelemetry({
+      nodeId: args.childNodeId,
+      activationId: childActivationId,
+    });
+    const childBinary = args.parentCtx.binary.forNode({
+      nodeId: args.childNodeId,
+      activationId: childActivationId,
+    });
+    return {
+      ...args.parentCtx,
+      nodeId: args.childNodeId,
+      activationId: childActivationId,
+      config: args.childConfig,
+      telemetry: childTelemetry,
+      binary: childBinary,
+      parentInvocationId: args.parentInvocationId,
+      iterationId: undefined,
+    };
+  }
+}

package/src/execution/DefaultExecutionContextFactory.ts

@@ -1,5 +1,6 @@
 import type {
   BinaryStorage,
+  CollectionsContext,
   CostTrackingTelemetryFactory,
   ExecutionContext,
   ExecutionContextFactory,
@@ -8,6 +9,7 @@ import type {
   ParentExecutionRef,
   RunDataSnapshot,
   RunId,
+  RunTestContext,
   WorkflowId,
 } from "../types";
 import { NoOpCostTrackingTelemetryFactory, NoOpExecutionTelemetryFactory } from "../types";
@@ -26,6 +28,7 @@ export class DefaultExecutionContextFactory implements ExecutionContextFactory {
     private readonly telemetryFactory: ExecutionTelemetryFactory = new NoOpExecutionTelemetryFactory(),
     private readonly costTrackingFactory: CostTrackingTelemetryFactory = new NoOpCostTrackingTelemetryFactory(),
     private readonly currentDate: () => Date = () => new Date(),
+    private readonly collections?: CollectionsContext,
   ) {}
 
   create(args: {
@@ -40,6 +43,7 @@ export class DefaultExecutionContextFactory implements ExecutionContextFactory {
     nodeState?: NodeExecutionStatePublisher;
     telemetry?: ExecutionContext["telemetry"];
     getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+    testContext?: RunTestContext;
   }): ExecutionContext {
     const baseTelemetry =
       args.telemetry ??
@@ -66,6 +70,8 @@ export class DefaultExecutionContextFactory implements ExecutionContextFactory {
       telemetry,
       binary: new DefaultExecutionBinaryService(this.binaryStorage, args.workflowId, args.runId, this.currentDate),
       getCredential: args.getCredential,
+      testContext: args.testContext,
+      collections: this.collections,
     };
   }
 }

package/src/execution/ExecutionTelemetryCostTrackingDecoratorFactory.ts

@@ -62,6 +62,15 @@ export class ExecutionTelemetryCostTrackingDecoratorFactory {
           costTracking: args.costTracking.forScope(nodeTelemetry),
         });
       },
+      asNodeTelemetry: (
+        rescope: Readonly<{ nodeId: NodeId; activationId: NodeActivationId }>,
+      ): NodeExecutionTelemetry => {
+        const nodeTelemetry = args.telemetry.asNodeTelemetry(rescope);
+        return this.decorateNodeExecutionTelemetry({
+          telemetry: nodeTelemetry,
+          costTracking: args.costTracking.forScope(nodeTelemetry),
+        });
+      },
     };
   }
 
@@ -79,6 +88,15 @@ export class ExecutionTelemetryCostTrackingDecoratorFactory {
         artifact: TelemetryArtifactAttachment,
       ): Promise<TelemetryArtifactReference> | TelemetryArtifactReference => args.scope.attachArtifact(artifact),
       end: (endArgs?: TelemetrySpanEnd) => args.scope.end(endArgs),
+      asNodeTelemetry: (
+        rescope: Readonly<{ nodeId: NodeId; activationId: NodeActivationId }>,
+      ): NodeExecutionTelemetry => {
+        const nodeTelemetry = args.scope.asNodeTelemetry(rescope);
+        return this.decorateNodeExecutionTelemetry({
+          telemetry: nodeTelemetry,
+          costTracking: args.costTracking.forScope(nodeTelemetry),
+        });
+      },
     };
   }
 }

package/src/execution/NodeExecutor.ts

@@ -13,6 +13,7 @@ import type {
   TriggerNode,
   WorkflowNodeInstanceFactory,
 } from "../types";
+import { NodeIterationIdFactory } from "../workflow/definition/NodeIterationIdFactory";
 
 import { FanInMergeByOriginMerger } from "./FanInMergeByOriginMerger";
 import { ItemExprResolver } from "./ItemExprResolver";
@@ -158,13 +159,20 @@ export class NodeExecutor {
       const parsed = inputSchema.parse(item.json);
       const runnableCtx = request.ctx as NodeExecutionContext<RunnableNodeConfig>;
       const resolvedCtx = await this.itemExprResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
-      const ctx = this.pickExecutionContext(runnableCtx, resolvedCtx);
+      const baseCtx = this.pickExecutionContext(runnableCtx, resolvedCtx);
+      // Mint a per-item iteration id and stamp it (with the item index) onto the ctx so connection
+      // invocations and telemetry written from inside `node.execute` carry the per-item identity.
+      const iterationCtx = {
+        ...baseCtx,
+        iterationId: NodeIterationIdFactory.create(),
+        itemIndex: i,
+      } as NodeExecutionContext<RunnableNodeConfig>;
       const args: RunnableNodeExecuteArgs = {
         input: parsed,
         item,
         itemIndex: i,
         items: inputBatch,
-        ctx,
+        ctx: iterationCtx,
       };
       const raw = await Promise.resolve(node.execute(args));
       const normalized = this.outputNormalizer.normalizeExecuteResult({

package/src/execution/NodeInstanceFactory.ts

@@ -4,6 +4,7 @@ import type { NodeId, NodeResolver, WorkflowDefinition, WorkflowNodeInstanceFact
 import { MissingRuntimeNode, MissingRuntimeTrigger } from "../workflowSnapshots";
 import { MissingRuntimeNodeToken } from "../workflowSnapshots/MissingRuntimeNodeToken";
 import { MissingRuntimeTriggerToken } from "../workflowSnapshots/MissingRuntimeTriggerToken";
+import { NodeInstantiationError } from "./NodeInstantiationError";
 
 export class NodeInstanceFactory implements WorkflowNodeInstanceFactory {
   constructor(private readonly nodeResolver: NodeResolver) {}
@@ -11,7 +12,18 @@ export class NodeInstanceFactory implements WorkflowNodeInstanceFactory {
   createNodes(workflow: WorkflowDefinition): Map<NodeId, unknown> {
     const nodeInstances = new Map<NodeId, unknown>();
     for (const definition of workflow.nodes) {
-      nodeInstances.set(definition.id, this.createNode(definition));
+      try {
+        nodeInstances.set(definition.id, this.createNode(definition));
+      } catch (err) {
+        if (err instanceof NodeInstantiationError) {
+          throw err;
+        }
+        throw new NodeInstantiationError(
+          definition.id,
+          typeof definition.type === "function" ? definition.type.name : String(definition.type),
+          err instanceof Error ? err : new Error(String(err)),
+        );
+      }
     }
     return nodeInstances;
   }

package/src/execution/NodeInstantiationError.ts

@@ -0,0 +1,16 @@
+import type { NodeId } from "../types";
+
+export class NodeInstantiationError extends Error {
+  readonly name = "NodeInstantiationError";
+  readonly originalError: Error;
+
+  constructor(
+    readonly nodeId: NodeId,
+    readonly nodeType: string,
+    originalError: Error,
+  ) {
+    super(`Failed to instantiate node "${nodeId}" (type ${nodeType}): ${originalError.message}`);
+    this.originalError = originalError;
+    this.stack = originalError.stack;
+  }
+}

package/src/execution/NodeRunStateWriter.ts

@@ -28,6 +28,7 @@ export class NodeRunStateWriter implements NodeExecutionStatePublisher {
       kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed",
       snapshot: NodeExecutionSnapshot,
     ) => Promise<void>,
+    private readonly publishConnectionInvocationEvent?: (record: ConnectionInvocationRecord) => Promise<void>,
   ) {}
 
   markQueued(args: {
@@ -148,11 +149,17 @@ export class NodeRunStateWriter implements NodeExecutionStatePublisher {
         startedAt: args.startedAt,
         finishedAt: args.finishedAt,
         updatedAt,
+        iterationId: args.iterationId,
+        itemIndex: args.itemIndex,
+        parentInvocationId: args.parentInvocationId,
       };
       await this.workflowExecutionRepository.save({
         ...state,
         connectionInvocations: [...(state.connectionInvocations ?? []), record],
       });
+      if (this.publishConnectionInvocationEvent) {
+        await this.publishConnectionInvocationEvent(record);
+      }
     });
   }
 

package/src/execution/NodeRunStateWriterFactory.ts

@@ -6,16 +6,20 @@ import type {
   WorkflowId,
 } from "../types";
 
+import { ConnectionInvocationEventPublisher } from "../events/ConnectionInvocationEventPublisher";
 import { NodeEventPublisher } from "../events/NodeEventPublisher";
+import type { RunEventBus } from "../events/runEvents";
 import { NodeRunStateWriter } from "./NodeRunStateWriter";
 
 export class NodeRunStateWriterFactory {
   constructor(
     private readonly workflowExecutionRepository: WorkflowExecutionRepository,
     private readonly nodeEventPublisher: NodeEventPublisher,
+    private readonly eventBus?: RunEventBus,
   ) {}
 
   create(runId: RunId, workflowId: WorkflowId, parent: ParentExecutionRef | undefined): NodeExecutionStatePublisher {
+    const connectionInvocationEventPublisher = new ConnectionInvocationEventPublisher(this.eventBus, parent);
     return new NodeRunStateWriter(
       this.workflowExecutionRepository,
       runId,
@@ -24,6 +28,9 @@ export class NodeRunStateWriterFactory {
       async (kind, snapshot) => {
         await this.nodeEventPublisher.publish(kind, snapshot);
       },
+      async (record) => {
+        await connectionInvocationEventPublisher.publish(record);
+      },
     );
   }
 }

package/src/execution/WorkflowRunExecutionContextFactory.ts

@@ -5,6 +5,7 @@ import type {
   ParentExecutionRef,
   RunDataFactory,
   RunId,
+  RunTestContext,
   WorkflowId,
 } from "../types";
 
@@ -30,6 +31,7 @@ export class WorkflowRunExecutionContextFactory {
     engineMaxSubworkflowDepth: number;
     data: ReturnType<RunDataFactory["create"]>;
     nodeState?: NodeExecutionStatePublisher;
+    testContext?: RunTestContext;
   }) {
     return this.executionContextFactory.create({
       runId: args.runId,
@@ -42,6 +44,7 @@ export class WorkflowRunExecutionContextFactory {
       data: args.data,
       nodeState: args.nodeState,
       getCredential: this.credentialResolverFactory.create(args.workflowId, args.nodeId),
+      testContext: args.testContext,
     });
   }
 }

package/src/execution/index.ts

@@ -1,6 +1,8 @@
 export { ActivationEnqueueService } from "./ActivationEnqueueService";
+export { ChildExecutionScopeFactory } from "./ChildExecutionScopeFactory";
 export { NodeActivationRequestInputPreparer } from "./NodeActivationRequestInputPreparer";
 export { NodeInputContractError } from "./NodeInputContractError";
+export { NodeInstantiationError } from "./NodeInstantiationError";
 export { CredentialResolverFactory } from "./CredentialResolverFactory";
 export { DefaultAsyncSleeper } from "./DefaultAsyncSleeper";
 export { DefaultExecutionContextFactory } from "./DefaultExecutionContextFactory";

package/src/index.ts

@@ -14,6 +14,7 @@ export * from "./runtime-types/runtimeTypeDecorators.types";
 export * from "./serialization/ItemsInputNormalizer";
 export { DefaultExecutionBinaryService, UnavailableBinaryStorage } from "./binaries";
 export {
+  ChildExecutionScopeFactory,
   CredentialResolverFactory,
   DefaultAsyncSleeper,
   DefaultExecutionContextFactory,
@@ -26,3 +27,10 @@ export { EngineExecutionLimitsPolicy, type EngineExecutionLimitsPolicyConfig } f
 export { InMemoryBinaryStorage, InMemoryRunDataFactory } from "./runStorage";
 export { InMemoryLiveWorkflowRepository, RunIntentService } from "./runtime";
 export * from "./types";
+export { PollingTriggerRuntime, PollingTriggerDedupWindow, NoOpPollingTriggerLogger } from "./triggers/polling";
+export type {
+  PollingTriggerLogger,
+  PollingRunCycleArgs,
+  PollingRunCycleResult,
+  PollingTriggerStartArgs,
+} from "./triggers/polling";

package/src/orchestration/AbortControllerFactory.ts

@@ -0,0 +1,9 @@
+/**
+ * Mints fresh {@link AbortController}s. Injected (rather than direct `new`) to honor the
+ * codebase's no-direct-construction rule and to give tests a seam for substituting a fake.
+ */
+export class AbortControllerFactory {
+  create(): AbortController {
+    return new AbortController();
+  }
+}

package/src/orchestration/NodeExecutionRequestHandlerService.ts

@@ -77,6 +77,7 @@ export class NodeExecutionRequestHandlerService implements NodeExecutionRequestH
       engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
       data,
       nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, resolvedParent),
+      testContext: state.executionOptions?.testContext,
     });
 
     const inputsByPort = pendingExecution.inputsByPort;

package/src/orchestration/RunContinuationService.ts

@@ -141,6 +141,7 @@ export class RunContinuationService {
       engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
       data,
       nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent),
+      testContext: state.executionOptions?.testContext,
     });
 
     data.setOutputs(args.nodeId, args.outputs);
@@ -755,6 +756,7 @@ export class RunContinuationService {
       engineMaxSubworkflowDepth: webhookLimits.engineMaxSubworkflowDepth,
       data,
       nodeState: this.nodeStatePublisherFactory.create(args.state.runId, args.state.workflowId, args.state.parent),
+      testContext: args.state.executionOptions?.testContext,
     });
     const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
       next,
@@ -859,6 +861,7 @@ export class RunContinuationService {
       engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
       data,
       nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent),
+      testContext: state.executionOptions?.testContext,
     });
     const activationId = pendingExecution.activationId;
     return {

package/src/orchestration/RunStartService.ts

@@ -34,8 +34,12 @@ import { RunPolicySnapshotFactory } from "../policies/storage/RunPolicySnapshotF
 import { ActivationEnqueueService } from "../execution/ActivationEnqueueService";
 import { NodeRunStateWriterFactory } from "../execution/NodeRunStateWriterFactory";
 import { NodeActivationRequestComposer } from "../execution/NodeActivationRequestComposer";
+import { NodeExecutionSnapshotFactory } from "../execution/NodeExecutionSnapshotFactory";
+import { NodeInstantiationError } from "../execution/NodeInstantiationError";
+import { PersistedRunStateTerminalBuilder } from "../execution/PersistedRunStateTerminalBuilder";
 import { RunStateSemantics } from "../execution/RunStateSemantics";
 import { WorkflowRunExecutionContextFactory } from "../execution/WorkflowRunExecutionContextFactory";
+import { NodeEventPublisher } from "../events/NodeEventPublisher";
 
 export class RunStartService {
   constructor(
@@ -52,6 +56,8 @@ export class RunStartService {
     private readonly waiters: EngineWaiters,
     private readonly workflowPolicyRuntimeDefaults: WorkflowPolicyRuntimeDefaults | undefined,
     private readonly executionLimitsPolicy: EngineExecutionLimitsPolicy,
+    private readonly nodeEventPublisher: NodeEventPublisher,
+    private readonly persistedRunStateTerminalBuilder: PersistedRunStateTerminalBuilder,
   ) {}
 
   async runWorkflow(
@@ -96,8 +102,29 @@ export class RunStartService {
       engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth!,
       data,
       nodeState: this.nodeStatePublisherFactory.create(runId, workflow.id, parent),
+      testContext: mergedExecutionOptions.testContext,
     });
-    const { topology, planner } = this.planningFactory.create(workflow);
+    let planning: Readonly<ReturnType<EngineWorkflowPlanningFactory["create"]>>;
+    try {
+      planning = this.planningFactory.create(workflow);
+    } catch (err) {
+      if (err instanceof NodeInstantiationError) {
+        return await this.failRunDuringPlanning({
+          runId,
+          workflowId: workflow.id,
+          startedAt,
+          parent,
+          executionOptions: mergedExecutionOptions,
+          control: undefined,
+          workflowSnapshot,
+          mutableState,
+          policySnapshot,
+          err,
+        });
+      }
+      throw err;
+    }
+    const { topology, planner } = planning;
     const startDefinition = topology.defsById.get(startAt);
     if (!startDefinition) {
       throw new Error(`Unknown start nodeId: ${startAt}`);
@@ -183,7 +210,27 @@ export class RunStartService {
       engineCounters: { completedNodeActivations: 0 },
     });
 
-    const { topology, planner } = this.planningFactory.create(request.workflow);
+    let planningFromState: Readonly<ReturnType<EngineWorkflowPlanningFactory["create"]>>;
+    try {
+      planningFromState = this.planningFactory.create(request.workflow);
+    } catch (err) {
+      if (err instanceof NodeInstantiationError) {
+        return await this.failRunDuringPlanning({
+          runId,
+          workflowId: request.workflow.id,
+          startedAt,
+          parent: request.parent,
+          executionOptions: mergedExecutionOptions,
+          control,
+          workflowSnapshot,
+          mutableState,
+          policySnapshot,
+          err,
+        });
+      }
+      throw err;
+    }
+    const { topology, planner } = planningFromState;
     const plan = CurrentStateFrontierPlanner.createFromTopology(topology).plan({
       currentState: this.createRunCurrentState(request.currentState, mutableState),
       stopCondition: control.stopCondition,
@@ -206,6 +253,7 @@ export class RunStartService {
       engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth!,
       data,
       nodeState: this.nodeStatePublisherFactory.create(runId, request.workflow.id, request.parent),
+      testContext: mergedExecutionOptions.testContext,
     });
 
     return await this.scheduleInitialPlan({
@@ -229,10 +277,17 @@ export class RunStartService {
     currentState: RunCurrentState | undefined,
     mutableState: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["mutableState"],
   ): RunCurrentState {
+    // Each `ConnectionInvocationRecord` represents a single, auditable LLM/tool call
+    // that must belong to exactly one run. Reruns start from a fresh invocation
+    // ledger so the new run only records what it actually invokes. The prior run's
+    // invocations remain queryable on that run's persisted state (their true owner).
+    // Carrying them over here would write duplicate `ExecutionInstance` rows whose
+    // primary key (`invocationId`) already exists under the previous run, causing a
+    // `Unique constraint failed on the fields: (instance_id)` violation on first save.
     return {
       outputsByNode: { ...(currentState?.outputsByNode ?? {}) },
       nodeSnapshotsByNodeId: { ...(currentState?.nodeSnapshotsByNodeId ?? {}) },
-      connectionInvocations: currentState?.connectionInvocations ? [...currentState.connectionInvocations] : undefined,
+      connectionInvocations: [],
       mutableState: mutableState ?? currentState?.mutableState,
     };
   }
@@ -448,4 +503,68 @@ export class RunStartService {
     this.waiters.resolveRunCompletion(result);
     return result;
   }
+
+  private async failRunDuringPlanning(args: {
+    runId: RunId;
+    workflowId: WorkflowId;
+    startedAt: string;
+    parent?: ParentExecutionRef;
+    executionOptions?: RunExecutionOptions;
+    control?: PersistedRunControlState;
+    workflowSnapshot: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
+    mutableState: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["mutableState"];
+    policySnapshot: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["policySnapshot"];
+    err: NodeInstantiationError;
+  }): Promise<RunResult> {
+    const finishedAt = new Date().toISOString();
+    const failedSnapshot = NodeExecutionSnapshotFactory.failed({
+      previous: undefined,
+      runId: args.runId,
+      workflowId: args.workflowId,
+      nodeId: args.err.nodeId,
+      activationId: "planning_failure",
+      parent: args.parent,
+      finishedAt,
+      inputsByPort: {},
+      error: args.err,
+    });
+    const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+      state: {
+        runId: args.runId,
+        workflowId: args.workflowId,
+        startedAt: args.startedAt,
+        parent: args.parent,
+        executionOptions: args.executionOptions,
+        control: args.control,
+        workflowSnapshot: args.workflowSnapshot,
+        mutableState: args.mutableState,
+        policySnapshot: args.policySnapshot,
+        engineCounters: { completedNodeActivations: 0 },
+        status: "pending",
+        pending: undefined,
+        queue: [],
+        outputsByNode: {},
+        nodeSnapshotsByNodeId: {},
+        connectionInvocations: [],
+      },
+      engineCounters: { completedNodeActivations: 0 },
+      status: "failed",
+      queue: [],
+      outputsByNode: {},
+      nodeSnapshotsByNodeId: { [args.err.nodeId]: failedSnapshot },
+      finishedAtIso: finishedAt,
+    });
+    await this.workflowExecutionRepository.save(failedState);
+    await this.nodeEventPublisher.publish("nodeFailed", failedSnapshot);
+
+    const result: RunResult = {
+      runId: args.runId,
+      workflowId: args.workflowId,
+      startedAt: args.startedAt,
+      status: "failed",
+      error: { message: args.err.message },
+    };
+    this.waiters.resolveRunCompletion(result);
+    return result;
+  }
 }