@auto-engineer/pipeline 1.68.0 → 1.69.0

package/ketchup-plan.md

@@ -2,23 +2,11 @@
 
 ## TODO
 
-### Session-Based Status Tracking (Bursts S-1 to S-4) ✅
-
-- [x] Burst S-1: E2E test — sub-commands overwrite session status (b8246300)
-- [x] Burst S-2: E2E test — sub-command items counted under unified view (b8246300)
-- [x] Burst S-3: Add sessionId and RestartPipeline (b8246300)
-- [x] Burst S-4: Track status under sessionId (b8246300)
 
 ### Graph Rendering Fix (Burst 106)
 
 - [ ] Burst 106: Show source commands whose events are listened to by the pipeline [depends: none]
 
-### Parallel Scatter-Gather in Event Router (Bursts P-1 to P-3)
-
-- [x] Burst P-1: Test that emit mapping commands run in parallel [depends: none]
-- [x] Burst P-2: Fix event router to use Promise.all [depends: P-1]
-- [x] Burst P-3: Settled scatter-gather proves parallel [depends: P-2]
-
 ### Phase 11: 100% Test Coverage (Bursts 93-102)
 
 **Goal**: Achieve 100% test coverage by testing uncovered code or removing dead code.
@@ -931,6 +919,16 @@ it("should extract graph from emit handler", () => {
 
 ## DONE
 
+### V2 Engine Internal Swap ✅
+
+- [x] Burst V2-1: Add processKeyed/getState/resetInstance to WorkflowProcessor [depends: none] (d7b0fbc6)
+- [x] Burst V2-2: V2RuntimeBridge — settled path [depends: V2-1] (867c844a)
+- [x] Burst V2-3: V2RuntimeBridge — phased path [depends: V2-1] (985add45)
+- [x] Burst V2-4: Wire bridge into PipelineServer [depends: V2-2, V2-3] (df6e6fcf)
+- [x] Burst V2-5+V2-6: Remove v1 runtime classes and update exports [depends: V2-4] (98b1025c)
+
+---
+
 ### Phase 12: Consistent Non-Blocking Dispatch (Bursts 103-105) ✅
 
 - [x] Burst 103: Add `await` to `startPhased` call in pipeline-runtime.ts (e9b391f4)

package/package.json

@@ -13,8 +13,8 @@
     "get-port": "^7.1.0",
     "jose": "^5.9.6",
     "nanoid": "^5.0.0",
-    "@auto-engineer/file-store": "1.68.0",
-    "@auto-engineer/message-bus": "1.68.0"
+    "@auto-engineer/file-store": "1.69.0",
+    "@auto-engineer/message-bus": "1.69.0"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",
@@ -23,7 +23,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.68.0",
+  "version": "1.69.0",
   "scripts": {
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts",
     "test": "vitest run --reporter=dot",

package/src/engine/workflow-processor.specs.ts

@@ -34,4 +34,105 @@ describe('WorkflowProcessor', () => {
     const result = processor.process({ type: 'Unknown', data: {} });
     expect(result).toEqual([]);
   });
+
+  it('processes keyed events independently per instanceKey', () => {
+    const processor = createWorkflowProcessor();
+    processor.register({
+      id: 'test-settled',
+      workflow: createSettledWorkflow({ commandTypes: ['A', 'B'] }),
+      inputEvents: ['StartSettled', 'CommandCompleted'],
+    });
+
+    processor.processKeyed({ type: 'StartSettled', data: { commandTypes: ['A', 'B'] } }, 'key-1');
+    processor.processKeyed({ type: 'StartSettled', data: { commandTypes: ['A', 'B'] } }, 'key-2');
+
+    processor.processKeyed(
+      { type: 'CommandCompleted', data: { commandType: 'A', result: 'success', event: {} } },
+      'key-1',
+    );
+    processor.processKeyed(
+      { type: 'CommandCompleted', data: { commandType: 'A', result: 'success', event: {} } },
+      'key-2',
+    );
+
+    const result1 = processor.processKeyed(
+      { type: 'CommandCompleted', data: { commandType: 'B', result: 'success', event: {} } },
+      'key-1',
+    );
+    expect(result1).toEqual([expect.objectContaining({ type: 'AllSettled' })]);
+
+    const result2 = processor.processKeyed(
+      { type: 'CommandCompleted', data: { commandType: 'B', result: 'failure', event: {} } },
+      'key-2',
+    );
+    expect(result2).toEqual([expect.objectContaining({ type: 'RetryCommands' })]);
+  });
+
+  it('getState returns current state for given key', () => {
+    const processor = createWorkflowProcessor();
+    processor.register({
+      id: 'test-settled',
+      workflow: createSettledWorkflow({ commandTypes: ['A'] }),
+      inputEvents: ['StartSettled', 'CommandCompleted'],
+    });
+
+    processor.processKeyed({ type: 'StartSettled', data: { commandTypes: ['A'] } }, 'key-1');
+    processor.processKeyed(
+      { type: 'CommandCompleted', data: { commandType: 'A', result: 'success', event: { v: 1 } } },
+      'key-1',
+    );
+
+    const state = processor.getState('test-settled', 'key-1');
+    expect(state).toEqual({
+      status: 'done',
+      commandTypes: ['A'],
+      completions: { A: { result: 'success', event: { v: 1 } } },
+      retryCount: 0,
+      maxRetries: 3,
+    });
+  });
+
+  it('getState returns initial state for unknown key', () => {
+    const processor = createWorkflowProcessor();
+    processor.register({
+      id: 'test-settled',
+      workflow: createSettledWorkflow({ commandTypes: ['A'] }),
+      inputEvents: ['StartSettled', 'CommandCompleted'],
+    });
+
+    const state = processor.getState('test-settled', 'unknown-key');
+    expect(state).toEqual({
+      status: 'idle',
+      commandTypes: [],
+      completions: {},
+      retryCount: 0,
+      maxRetries: 3,
+    });
+  });
+
+  it('resetInstance clears keyed history', () => {
+    const processor = createWorkflowProcessor();
+    processor.register({
+      id: 'test-settled',
+      workflow: createSettledWorkflow({ commandTypes: ['A'] }),
+      inputEvents: ['StartSettled', 'CommandCompleted'],
+    });
+
+    processor.processKeyed({ type: 'StartSettled', data: { commandTypes: ['A'] } }, 'key-1');
+    processor.processKeyed(
+      { type: 'CommandCompleted', data: { commandType: 'A', result: 'success', event: {} } },
+      'key-1',
+    );
+
+    processor.resetInstance('test-settled', 'key-1');
+
+    const state = processor.getState('test-settled', 'key-1');
+    expect(state).toEqual({
+      status: 'idle',
+      commandTypes: [],
+      completions: {},
+      retryCount: 0,
+      maxRetries: 3,
+    });
+  });
 });

package/src/engine/workflow-processor.ts

@@ -15,6 +15,7 @@ export type WorkflowRegistration = {
 export function createWorkflowProcessor() {
   const registrations = new Map<string, WorkflowRegistration>();
   const eventsByWorkflow = new Map<string, Event[]>();
+  const keyedEvents = new Map<string, Map<string, Event[]>>();
 
   function rebuildState(reg: WorkflowRegistration, events: Event[]): unknown {
     let state = reg.workflow.initialState();
@@ -24,6 +25,33 @@ export function createWorkflowProcessor() {
     return state;
   }
 
+  function getKeyedHistory(workflowId: string, instanceKey: string): Event[] {
+    let instances = keyedEvents.get(workflowId);
+    if (!instances) {
+      instances = new Map();
+      keyedEvents.set(workflowId, instances);
+    }
+    let history = instances.get(instanceKey);
+    if (!history) {
+      history = [];
+      instances.set(instanceKey, history);
+    }
+    return history;
+  }
+
+  function processWithHistory(reg: WorkflowRegistration, event: Event, history: Event[]): Event[] {
+    const outputs: Event[] = [];
+    history.push(event);
+    const state = rebuildState(reg, history);
+    const result = reg.workflow.decide(event, state);
+    const resultEvents = Array.isArray(result) ? result : [result];
+    for (const outputEvent of resultEvents) {
+      history.push(outputEvent);
+      outputs.push(outputEvent);
+    }
+    return outputs;
+  }
+
   return {
     register(registration: WorkflowRegistration): void {
       registrations.set(registration.id, registration);
@@ -37,21 +65,39 @@ export function createWorkflowProcessor() {
         if (!reg.inputEvents.includes(event.type)) {
           continue;
         }
-
         const history = eventsByWorkflow.get(id)!;
-        history.push(event);
+        outputs.push(...processWithHistory(reg, event, history));
+      }
 
-        const state = rebuildState(reg, history);
-        const result = reg.workflow.decide(event, state);
-        const resultEvents = Array.isArray(result) ? result : [result];
+      return outputs;
+    },
 
-        for (const outputEvent of resultEvents) {
-          history.push(outputEvent);
-          outputs.push(outputEvent);
+    processKeyed(event: Event, instanceKey: string): Event[] {
+      const outputs: Event[] = [];
+
+      for (const [id, reg] of registrations) {
+        if (!reg.inputEvents.includes(event.type)) {
+          continue;
         }
+        const history = getKeyedHistory(id, instanceKey);
+        outputs.push(...processWithHistory(reg, event, history));
       }
 
       return outputs;
     },
+
+    getState(workflowId: string, instanceKey: string): unknown {
+      const reg = registrations.get(workflowId);
+      if (!reg) return undefined;
+      const history = getKeyedHistory(workflowId, instanceKey);
+      return rebuildState(reg, history);
+    },
+
+    resetInstance(workflowId: string, instanceKey: string): void {
+      const instances = keyedEvents.get(workflowId);
+      if (instances) {
+        instances.delete(instanceKey);
+      }
+    },
   };
 }

package/src/index.ts

@@ -42,9 +42,7 @@ export type { AwaitEvent, AwaitTrackerDocument } from './projections/await-track
 export { AwaitTracker } from './runtime/await-tracker';
 export type { PipelineContext, RuntimeConfig } from './runtime/context';
 export { EventCommandMapper } from './runtime/event-command-map';
-export { PhasedExecutor } from './runtime/phased-executor';
 export { PipelineRuntime } from './runtime/pipeline-runtime';
-export { SettledTracker } from './runtime/settled-tracker';
 export type { CommandHandlerWithMetadata, PipelineServerConfig } from './server/pipeline-server';
 export { PipelineServer } from './server/pipeline-server';
 export { SSEManager } from './server/sse-manager';

package/src/server/phased-bridge.specs.ts

@@ -0,0 +1,272 @@
+import type { Event } from '@auto-engineer/message-bus';
+import type { ForEachPhasedDescriptor } from '../core/descriptors.js';
+import type { CommandDispatch } from '../core/types.js';
+import { createPhasedBridge } from './phased-bridge.js';
+
+interface TestItem {
+  id: string;
+  phase: string;
+}
+
+function prop(obj: unknown, key: string): string {
+  return String(Object(obj)[key]);
+}
+
+function makeEvent(type: string, correlationId: string, data: Record<string, unknown> = {}): Event {
+  return { type, data, correlationId };
+}
+
+function makeDescriptor(overrides: Partial<ForEachPhasedDescriptor> = {}): ForEachPhasedDescriptor {
+  return {
+    type: 'foreach-phased',
+    eventType: 'BuildTriggered',
+    phases: ['validate', 'compile'],
+    stopOnFailure: false,
+    itemsSelector: (event: Event): TestItem[] => {
+      const items = event.data.items;
+      if (!Array.isArray(items)) return [];
+      return items;
+    },
+    classifier: (item: unknown) => prop(item, 'phase'),
+    emitFactory: (item: unknown, phase: string, _event: Event): CommandDispatch => ({
+      commandType: `Run${phase.charAt(0).toUpperCase()}${phase.slice(1)}`,
+      data: { key: prop(item, 'id'), phase },
+    }),
+    completion: {
+      successEvent: { name: 'BuildCompleted' },
+      failureEvent: { name: 'BuildFailed' },
+      itemKey: (event: Event) => String(event.data.id),
+    },
+    ...overrides,
+  };
+}
+
+describe('PhasedBridge', () => {
+  describe('startPhased dispatches phase 0 items', () => {
+    it('calls onDispatch for each item in the first phase', () => {
+      const dispatched: Array<{ commandType: string; data: unknown; correlationId: string }> = [];
+      const bridge = createPhasedBridge({
+        onDispatch: (commandType, data, correlationId) => {
+          dispatched.push({ commandType, data, correlationId });
+        },
+        onPhasedComplete: () => {},
+      });
+
+      const descriptor = makeDescriptor();
+      bridge.registerPhased(descriptor);
+
+      const triggerEvent = makeEvent('BuildTriggered', 'corr-1', {
+        items: [
+          { id: 'item-a', phase: 'validate' },
+          { id: 'item-b', phase: 'compile' },
+        ],
+      });
+
+      bridge.startPhased(descriptor, triggerEvent, 'corr-1');
+
+      expect(dispatched).toEqual([
+        { commandType: 'RunValidate', data: { key: 'item-a', phase: 'validate' }, correlationId: 'corr-1' },
+      ]);
+    });
+  });
+
+  describe('item completion advances to next phase', () => {
+    it('dispatches next phase items after current phase completes', () => {
+      const dispatched: Array<{ commandType: string; data: unknown; correlationId: string }> = [];
+      const bridge = createPhasedBridge({
+        onDispatch: (commandType, data, correlationId) => {
+          dispatched.push({ commandType, data, correlationId });
+        },
+        onPhasedComplete: () => {},
+      });
+
+      const descriptor = makeDescriptor();
+      bridge.registerPhased(descriptor);
+
+      const triggerEvent = makeEvent('BuildTriggered', 'corr-1', {
+        items: [
+          { id: 'item-a', phase: 'validate' },
+          { id: 'item-b', phase: 'compile' },
+        ],
+      });
+
+      bridge.startPhased(descriptor, triggerEvent, 'corr-1');
+      dispatched.length = 0;
+
+      bridge.onPhasedItemEvent(makeEvent('ItemDone', 'corr-1', { id: 'item-a' }), 'item-a');
+
+      expect(dispatched).toEqual([
+        { commandType: 'RunCompile', data: { key: 'item-b', phase: 'compile' }, correlationId: 'corr-1' },
+      ]);
+    });
+  });
+
+  describe('all phases complete triggers success', () => {
+    it('calls onPhasedComplete with success event when all items finish', () => {
+      const completed: Array<{ event: Event; correlationId: string }> = [];
+      const bridge = createPhasedBridge({
+        onDispatch: () => {},
+        onPhasedComplete: (event, correlationId) => {
+          completed.push({ event, correlationId });
+        },
+      });
+
+      const descriptor = makeDescriptor();
+      bridge.registerPhased(descriptor);
+
+      const triggerEvent = makeEvent('BuildTriggered', 'corr-1', {
+        items: [
+          { id: 'item-a', phase: 'validate' },
+          { id: 'item-b', phase: 'compile' },
+        ],
+      });
+
+      bridge.startPhased(descriptor, triggerEvent, 'corr-1');
+      bridge.onPhasedItemEvent(makeEvent('ItemDone', 'corr-1', { id: 'item-a' }), 'item-a');
+      bridge.onPhasedItemEvent(makeEvent('ItemDone', 'corr-1', { id: 'item-b' }), 'item-b');
+
+      expect(completed).toEqual([
+        {
+          event: {
+            type: 'BuildCompleted',
+            correlationId: 'corr-1',
+            data: { results: ['item-a', 'item-b'], itemCount: 2 },
+          },
+          correlationId: 'corr-1',
+        },
+      ]);
+    });
+  });
+
+  describe('stopOnFailure triggers failure event', () => {
+    it('calls onPhasedComplete with failure event when item fails and stopOnFailure is true', () => {
+      const completed: Array<{ event: Event; correlationId: string }> = [];
+      const bridge = createPhasedBridge({
+        onDispatch: () => {},
+        onPhasedComplete: (event, correlationId) => {
+          completed.push({ event, correlationId });
+        },
+      });
+
+      const descriptor = makeDescriptor({ stopOnFailure: true });
+      bridge.registerPhased(descriptor);
+
+      const triggerEvent = makeEvent('BuildTriggered', 'corr-1', {
+        items: [
+          { id: 'item-a', phase: 'validate' },
+          { id: 'item-b', phase: 'validate' },
+        ],
+      });
+
+      bridge.startPhased(descriptor, triggerEvent, 'corr-1');
+      bridge.onPhasedItemEvent(makeEvent('BuildFailed', 'corr-1', { id: 'item-a' }), 'item-a');
+
+      expect(completed).toEqual([
+        {
+          event: {
+            type: 'BuildFailed',
+            correlationId: 'corr-1',
+            data: { failures: ['item-a'], completedItems: [] },
+          },
+          correlationId: 'corr-1',
+        },
+      ]);
+    });
+  });
+
+  describe('independent correlationIds', () => {
+    it('tracks two correlationIds independently', () => {
+      const dispatched: Array<{ commandType: string; data: unknown; correlationId: string }> = [];
+      const completed: Array<{ event: Event; correlationId: string }> = [];
+      const bridge = createPhasedBridge({
+        onDispatch: (commandType, data, correlationId) => {
+          dispatched.push({ commandType, data, correlationId });
+        },
+        onPhasedComplete: (event, correlationId) => {
+          completed.push({ event, correlationId });
+        },
+      });
+
+      const descriptor = makeDescriptor({
+        phases: ['validate'],
+      });
+      bridge.registerPhased(descriptor);
+
+      const trigger1 = makeEvent('BuildTriggered', 'corr-1', {
+        items: [{ id: 'item-x', phase: 'validate' }],
+      });
+      const trigger2 = makeEvent('BuildTriggered', 'corr-2', {
+        items: [{ id: 'item-y', phase: 'validate' }],
+      });
+
+      bridge.startPhased(descriptor, trigger1, 'corr-1');
+      bridge.startPhased(descriptor, trigger2, 'corr-2');
+      dispatched.length = 0;
+
+      bridge.onPhasedItemEvent(makeEvent('ItemDone', 'corr-1', { id: 'item-x' }), 'item-x');
+
+      expect(completed).toEqual([
+        {
+          event: {
+            type: 'BuildCompleted',
+            correlationId: 'corr-1',
+            data: { results: ['item-x'], itemCount: 1 },
+          },
+          correlationId: 'corr-1',
+        },
+      ]);
+
+      bridge.onPhasedItemEvent(makeEvent('ItemDone', 'corr-2', { id: 'item-y' }), 'item-y');
+
+      expect(completed).toEqual([
+        {
+          event: {
+            type: 'BuildCompleted',
+            correlationId: 'corr-1',
+            data: { results: ['item-x'], itemCount: 1 },
+          },
+          correlationId: 'corr-1',
+        },
+        {
+          event: {
+            type: 'BuildCompleted',
+            correlationId: 'corr-2',
+            data: { results: ['item-y'], itemCount: 1 },
+          },
+          correlationId: 'corr-2',
+        },
+      ]);
+    });
+  });
+
+  describe('emitFactory with function data', () => {
+    it('resolves data factory functions when dispatching', () => {
+      const dispatched: Array<{ commandType: string; data: unknown; correlationId: string }> = [];
+      const bridge = createPhasedBridge({
+        onDispatch: (commandType, data, correlationId) => {
+          dispatched.push({ commandType, data, correlationId });
+        },
+        onPhasedComplete: () => {},
+      });
+
+      const descriptor = makeDescriptor({
+        phases: ['validate'],
+        emitFactory: (item: unknown, phase: string, event: Event): CommandDispatch => ({
+          commandType: `Run${phase.charAt(0).toUpperCase()}${phase.slice(1)}`,
+          data: (_ev: Event) => ({ key: prop(item, 'id'), source: event.type }),
+        }),
+      });
+      bridge.registerPhased(descriptor);
+
+      const triggerEvent = makeEvent('BuildTriggered', 'corr-1', {
+        items: [{ id: 'item-a', phase: 'validate' }],
+      });
+
+      bridge.startPhased(descriptor, triggerEvent, 'corr-1');
+
+      expect(dispatched).toEqual([
+        { commandType: 'RunValidate', data: { key: 'item-a', source: 'BuildTriggered' }, correlationId: 'corr-1' },
+      ]);
+    });
+  });
+});

package/src/server/phased-bridge.ts

@@ -0,0 +1,130 @@
+import type { Event } from '@auto-engineer/message-bus';
+import type { ForEachPhasedDescriptor } from '../core/descriptors.js';
+import type { CommandDispatch } from '../core/types.js';
+import type { PhasedInput, PhasedOutput, PhasedState } from '../engine/workflows/phased-workflow.js';
+import { decide, evolve, initialState } from '../engine/workflows/phased-workflow.js';
+
+interface PhasedBridgeConfig {
+  onDispatch: (commandType: string, data: unknown, correlationId: string) => void;
+  onPhasedComplete: (event: Event, correlationId: string) => void;
+}
+
+interface PhasedExecution {
+  correlationId: string;
+  handler: ForEachPhasedDescriptor;
+  triggerEvent: Event;
+  items: Array<{ key: string; phase: string; original: unknown }>;
+  state: PhasedState;
+}
+
+function resolveData(dispatch: CommandDispatch, event: Event): Record<string, unknown> {
+  if (typeof dispatch.data === 'function') {
+    return dispatch.data(event);
+  }
+  return dispatch.data;
+}
+
+function processInput(execution: PhasedExecution, input: PhasedInput): PhasedOutput[] {
+  let state = evolve(execution.state, input);
+  const result = decide(input, state);
+  const outputs = Array.isArray(result) ? result : [result];
+  for (const output of outputs) {
+    state = evolve(state, output);
+  }
+  execution.state = state;
+  return outputs;
+}
+
+export function createPhasedBridge(config: PhasedBridgeConfig) {
+  const descriptors = new Map<string, ForEachPhasedDescriptor>();
+  const executions = new Map<string, PhasedExecution>();
+  const itemToExecution = new Map<string, string>();
+
+  function handleOutputs(outputs: PhasedOutput[], execution: PhasedExecution): void {
+    for (const output of outputs) {
+      if (output.type === 'DispatchItem') {
+        const itemKey = output.data.itemKey;
+        const phase = output.data.phase;
+        const itemRecord = execution.items.find((i) => i.key === itemKey);
+        if (itemRecord) {
+          const command = execution.handler.emitFactory(itemRecord.original, phase, execution.triggerEvent);
+          const data = resolveData(command, execution.triggerEvent);
+          config.onDispatch(command.commandType, data, execution.correlationId);
+        }
+      } else if (output.type === 'PhasedCompleted') {
+        const completionEvent: Event = {
+          type: execution.handler.completion.successEvent.name,
+          correlationId: execution.correlationId,
+          data: { results: output.data.completedItems, itemCount: execution.items.length },
+        };
+        config.onPhasedComplete(completionEvent, execution.correlationId);
+      } else if (output.type === 'PhasedFailed') {
+        const failureEvent: Event = {
+          type: execution.handler.completion.failureEvent.name,
+          correlationId: execution.correlationId,
+          data: { failures: output.data.failedItems, completedItems: output.data.completedItems },
+        };
+        config.onPhasedComplete(failureEvent, execution.correlationId);
+      }
+    }
+  }
+
+  return {
+    registerPhased(descriptor: ForEachPhasedDescriptor): void {
+      const handlerId = `phased-handler-${descriptor.eventType}`;
+      descriptors.set(handlerId, descriptor);
+    },
+
+    startPhased(handler: ForEachPhasedDescriptor, event: Event, correlationId: string): void {
+      const items = handler.itemsSelector(event);
+      const itemRecords: PhasedExecution['items'] = [];
+
+      for (const item of items) {
+        const data: Record<string, unknown> = Object(item);
+        const key = handler.completion.itemKey({ type: event.type, data });
+        const phase = handler.classifier(item);
+        itemRecords.push({ key, phase, original: item });
+        itemToExecution.set(key, correlationId + '|' + handler.eventType);
+      }
+
+      const execution: PhasedExecution = {
+        correlationId,
+        handler,
+        triggerEvent: event,
+        items: itemRecords,
+        state: initialState(),
+      };
+      executions.set(correlationId + '|' + handler.eventType, execution);
+
+      const startInput: PhasedInput = {
+        type: 'StartPhased',
+        data: {
+          correlationId,
+          items: itemRecords.map((i) => ({ key: i.key, phase: i.phase })),
+          phases: [...handler.phases],
+          stopOnFailure: handler.stopOnFailure,
+        },
+      };
+
+      const outputs = processInput(execution, startInput);
+      handleOutputs(outputs, execution);
+    },
+
+    onPhasedItemEvent(event: Event, itemKey: string): void {
+      const executionKey = itemToExecution.get(itemKey);
+      if (!executionKey) return;
+
+      const execution = executions.get(executionKey);
+      if (!execution) return;
+
+      const isFailure = event.type === execution.handler.completion.failureEvent.name;
+
+      const input: PhasedInput = isFailure
+        ? { type: 'ItemFailed', data: { itemKey, error: event.data } }
+        : { type: 'ItemCompleted', data: { itemKey, result: event.data } };
+
+      const outputs = processInput(execution, input);
+      handleOutputs(outputs, execution);
+    },
+  };
+}