@auto-engineer/pipeline 0.0.1

package/src/runtime/await-tracker.specs.ts

@@ -0,0 +1,52 @@
+import { AwaitTracker } from './await-tracker';
+
+describe('AwaitTracker', () => {
+  it('should track pending keys', () => {
+    const tracker = new AwaitTracker();
+    tracker.startAwaiting('corr-1', ['a', 'b']);
+    expect(tracker.isPending('corr-1')).toBe(true);
+    expect(tracker.getPendingKeys('corr-1')).toEqual(['a', 'b']);
+  });
+
+  it('should detect completion', () => {
+    const tracker = new AwaitTracker();
+    tracker.startAwaiting('c', ['a', 'b']);
+    tracker.markComplete('c', 'a', { result: 1 });
+    expect(tracker.isComplete('c')).toBe(false);
+    tracker.markComplete('c', 'b', { result: 2 });
+    expect(tracker.isComplete('c')).toBe(true);
+  });
+
+  it('should return false for unknown correlationId', () => {
+    const tracker = new AwaitTracker();
+    expect(tracker.isPending('unknown')).toBe(false);
+    expect(tracker.isComplete('unknown')).toBe(false);
+  });
+
+  it('should return empty array for unknown correlationId keys', () => {
+    const tracker = new AwaitTracker();
+    expect(tracker.getPendingKeys('unknown')).toEqual([]);
+  });
+
+  it('should collect results when all keys complete', () => {
+    const tracker = new AwaitTracker();
+    tracker.startAwaiting('c', ['x', 'y']);
+    tracker.markComplete('c', 'x', { val: 1 });
+    tracker.markComplete('c', 'y', { val: 2 });
+    const results = tracker.getResults('c');
+    expect(results).toEqual({ x: { val: 1 }, y: { val: 2 } });
+  });
+
+  it('should clear tracking after getting results', () => {
+    const tracker = new AwaitTracker();
+    tracker.startAwaiting('c', ['a']);
+    tracker.markComplete('c', 'a', {});
+    tracker.getResults('c');
+    expect(tracker.isPending('c')).toBe(false);
+  });
+
+  it('should return empty object for unknown correlationId results', () => {
+    const tracker = new AwaitTracker();
+    expect(tracker.getResults('unknown')).toEqual({});
+  });
+});

package/src/runtime/await-tracker.ts

@@ -0,0 +1,50 @@
+interface AwaitState {
+  pendingKeys: Set<string>;
+  results: Map<string, unknown>;
+}
+
+export class AwaitTracker {
+  private readonly state = new Map<string, AwaitState>();
+
+  startAwaiting(correlationId: string, keys: string[]): void {
+    this.state.set(correlationId, {
+      pendingKeys: new Set(keys),
+      results: new Map(),
+    });
+  }
+
+  isPending(correlationId: string): boolean {
+    return this.state.has(correlationId);
+  }
+
+  getPendingKeys(correlationId: string): string[] {
+    const awaitState = this.state.get(correlationId);
+    return awaitState ? Array.from(awaitState.pendingKeys) : [];
+  }
+
+  markComplete(correlationId: string, key: string, result: unknown): void {
+    const awaitState = this.state.get(correlationId);
+    if (awaitState) {
+      awaitState.pendingKeys.delete(key);
+      awaitState.results.set(key, result);
+    }
+  }
+
+  isComplete(correlationId: string): boolean {
+    const awaitState = this.state.get(correlationId);
+    return awaitState ? awaitState.pendingKeys.size === 0 : false;
+  }
+
+  getResults(correlationId: string): Record<string, unknown> {
+    const awaitState = this.state.get(correlationId);
+    if (!awaitState) {
+      return {};
+    }
+    const results: Record<string, unknown> = {};
+    for (const [key, value] of awaitState.results) {
+      results[key] = value;
+    }
+    this.state.delete(correlationId);
+    return results;
+  }
+}

package/src/runtime/context.specs.ts

@@ -0,0 +1,28 @@
+import type { PipelineContext, RuntimeConfig } from './context';
+
+describe('PipelineContext', () => {
+  it('should define PipelineContext interface', () => {
+    const ctx: PipelineContext = {
+      emit: async () => {},
+      sendCommand: async () => {},
+      correlationId: 'test-id',
+    };
+    expect(typeof ctx.emit).toBe('function');
+    expect(typeof ctx.sendCommand).toBe('function');
+    expect(ctx.correlationId).toBe('test-id');
+  });
+});
+
+describe('RuntimeConfig', () => {
+  it('should define RuntimeConfig interface', () => {
+    const config: RuntimeConfig = {
+      defaultTimeout: 30000,
+    };
+    expect(config.defaultTimeout).toBe(30000);
+  });
+
+  it('should allow optional defaultTimeout', () => {
+    const config: RuntimeConfig = {};
+    expect(config.defaultTimeout).toBeUndefined();
+  });
+});

package/src/runtime/context.ts

@@ -0,0 +1,13 @@
+import type { Event } from '@auto-engineer/message-bus';
+import type { ForEachPhasedDescriptor } from '../core/descriptors';
+
+export interface PipelineContext {
+  emit: (type: string, data: unknown) => Promise<void>;
+  sendCommand: (type: string, data: unknown) => Promise<void>;
+  correlationId: string;
+  startPhased?: (handler: ForEachPhasedDescriptor, event: Event) => void;
+}
+
+export interface RuntimeConfig {
+  defaultTimeout?: number;
+}

package/src/runtime/event-command-map.specs.ts

@@ -0,0 +1,136 @@
+import type { CommandHandler } from '@auto-engineer/message-bus';
+import { describe, expect, it } from 'vitest';
+import { EventCommandMapper } from './event-command-map';
+
+interface CommandHandlerWithEvents extends CommandHandler {
+  events?: readonly string[];
+}
+
+describe('EventCommandMapper', () => {
+  describe('basic mapping', () => {
+    it('should map events to source commands from handler metadata', () => {
+      const handlers: CommandHandlerWithEvents[] = [
+        {
+          name: 'CheckTests',
+          events: ['TestsCheckPassed', 'TestsCheckFailed'],
+          handle: async () => ({ type: 'TestsCheckPassed', data: {} }),
+        },
+        {
+          name: 'CheckTypes',
+          events: ['TypeCheckPassed', 'TypeCheckFailed'],
+          handle: async () => ({ type: 'TypeCheckPassed', data: {} }),
+        },
+      ];
+
+      const mapper = new EventCommandMapper(handlers);
+
+      expect(mapper.getSourceCommand('TestsCheckPassed')).toBe('CheckTests');
+      expect(mapper.getSourceCommand('TestsCheckFailed')).toBe('CheckTests');
+      expect(mapper.getSourceCommand('TypeCheckPassed')).toBe('CheckTypes');
+      expect(mapper.getSourceCommand('TypeCheckFailed')).toBe('CheckTypes');
+    });
+
+    it('should return undefined for unknown events', () => {
+      const handlers: CommandHandlerWithEvents[] = [
+        {
+          name: 'CheckTests',
+          events: ['TestsCheckPassed'],
+          handle: async () => ({ type: 'TestsCheckPassed', data: {} }),
+        },
+      ];
+
+      const mapper = new EventCommandMapper(handlers);
+
+      expect(mapper.getSourceCommand('UnknownEvent')).toBeUndefined();
+    });
+
+    it('should handle handlers without events array', () => {
+      const handlers: CommandHandlerWithEvents[] = [
+        {
+          name: 'SomeCommand',
+          handle: async () => ({ type: 'SomeEvent', data: {} }),
+        },
+      ];
+
+      const mapper = new EventCommandMapper(handlers);
+
+      expect(mapper.getSourceCommand('SomeEvent')).toBeUndefined();
+    });
+  });
+
+  describe('incremental updates', () => {
+    it('should allow adding handlers after construction', () => {
+      const mapper = new EventCommandMapper([]);
+
+      mapper.addHandler({
+        name: 'CheckLint',
+        events: ['LintCheckPassed', 'LintCheckFailed'],
+        handle: async () => ({ type: 'LintCheckPassed', data: {} }),
+      });
+
+      expect(mapper.getSourceCommand('LintCheckPassed')).toBe('CheckLint');
+      expect(mapper.getSourceCommand('LintCheckFailed')).toBe('CheckLint');
+    });
+
+    it('should handle duplicate event registrations gracefully', () => {
+      const handlers: CommandHandlerWithEvents[] = [
+        {
+          name: 'Handler1',
+          events: ['SharedEvent'],
+          handle: async () => ({ type: 'SharedEvent', data: {} }),
+        },
+      ];
+
+      const mapper = new EventCommandMapper(handlers);
+
+      mapper.addHandler({
+        name: 'Handler2',
+        events: ['SharedEvent'],
+        handle: async () => ({ type: 'SharedEvent', data: {} }),
+      });
+
+      const result = mapper.getSourceCommand('SharedEvent');
+      expect(['Handler1', 'Handler2']).toContain(result);
+    });
+  });
+
+  describe('query methods', () => {
+    it('should return all events for a command', () => {
+      const handlers: CommandHandlerWithEvents[] = [
+        {
+          name: 'CheckTests',
+          events: ['TestsCheckPassed', 'TestsCheckFailed', 'TestsCheckSkipped'],
+          handle: async () => ({ type: 'TestsCheckPassed', data: {} }),
+        },
+      ];
+
+      const mapper = new EventCommandMapper(handlers);
+      const events = mapper.getEventsForCommand('CheckTests');
+
+      expect(events).toEqual(['TestsCheckPassed', 'TestsCheckFailed', 'TestsCheckSkipped']);
+    });
+
+    it('should return empty array for unknown command', () => {
+      const mapper = new EventCommandMapper([]);
+      const events = mapper.getEventsForCommand('UnknownCommand');
+
+      expect(events).toEqual([]);
+    });
+
+    it('should check if event is from command', () => {
+      const handlers: CommandHandlerWithEvents[] = [
+        {
+          name: 'CheckTests',
+          events: ['TestsCheckPassed', 'TestsCheckFailed'],
+          handle: async () => ({ type: 'TestsCheckPassed', data: {} }),
+        },
+      ];
+
+      const mapper = new EventCommandMapper(handlers);
+
+      expect(mapper.isEventFromCommand('TestsCheckPassed', 'CheckTests')).toBe(true);
+      expect(mapper.isEventFromCommand('TestsCheckFailed', 'CheckTests')).toBe(true);
+      expect(mapper.isEventFromCommand('TypeCheckPassed', 'CheckTests')).toBe(false);
+    });
+  });
+});

package/src/runtime/event-command-map.ts

@@ -0,0 +1,38 @@
+import type { CommandHandler } from '@auto-engineer/message-bus';
+
+interface CommandHandlerWithEvents extends CommandHandler {
+  events?: readonly string[];
+}
+
+export class EventCommandMapper {
+  private eventToCommand = new Map<string, string>();
+  private commandToEvents = new Map<string, string[]>();
+
+  constructor(handlers: CommandHandlerWithEvents[]) {
+    for (const handler of handlers) {
+      this.addHandler(handler);
+    }
+  }
+
+  addHandler(handler: CommandHandlerWithEvents): void {
+    const events = handler.events ?? [];
+
+    for (const eventType of events) {
+      this.eventToCommand.set(eventType, handler.name);
+    }
+
+    this.commandToEvents.set(handler.name, [...events]);
+  }
+
+  getSourceCommand(eventType: string): string | undefined {
+    return this.eventToCommand.get(eventType);
+  }
+
+  getEventsForCommand(commandType: string): string[] {
+    return this.commandToEvents.get(commandType) ?? [];
+  }
+
+  isEventFromCommand(eventType: string, commandType: string): boolean {
+    return this.getSourceCommand(eventType) === commandType;
+  }
+}

package/src/runtime/phased-executor.specs.ts

@@ -0,0 +1,358 @@
+import type { Event } from '@auto-engineer/message-bus';
+import { beforeEach, describe, expect, it } from 'vitest';
+import type { ForEachPhasedDescriptor } from '../core/descriptors';
+import { PhasedExecutor } from './phased-executor';
+
+interface TestItem {
+  id: string;
+  type: 'molecule' | 'organism' | 'page';
+}
+
+function createHandler(_items: TestItem[]): ForEachPhasedDescriptor {
+  return {
+    type: 'foreach-phased',
+    eventType: 'ClientGenerated',
+    itemsSelector: (e: Event) => (e.data as { components: TestItem[] }).components,
+    phases: ['molecule', 'organism', 'page'],
+    classifier: (item: unknown) => (item as TestItem).type,
+    stopOnFailure: false,
+    emitFactory: (item: unknown, _phase: string, _event: Event) => ({
+      commandType: 'ImplementComponent',
+      data: { filePath: (item as TestItem).id },
+    }),
+    completion: {
+      successEvent: 'AllComponentsImplemented',
+      failureEvent: 'ComponentsFailed',
+      itemKey: (e: Event) => (e.data as { filePath?: string; id?: string }).filePath ?? (e.data as TestItem).id,
+    },
+  };
+}
+
+describe('PhasedExecutor', () => {
+  let executor: PhasedExecutor;
+  let dispatched: Array<{ commandType: string; data: unknown; correlationId: string }>;
+  let completed: Event[];
+
+  beforeEach(() => {
+    dispatched = [];
+    completed = [];
+    executor = new PhasedExecutor({
+      onDispatch: (commandType, data, correlationId) => {
+        dispatched.push({ commandType, data, correlationId });
+      },
+      onComplete: (event) => {
+        completed.push(event);
+      },
+    });
+  });
+
+  describe('phase gating', () => {
+    it('should dispatch only first phase items initially', () => {
+      const items: TestItem[] = [
+        { id: 'm1', type: 'molecule' },
+        { id: 'm2', type: 'molecule' },
+        { id: 'o1', type: 'organism' },
+        { id: 'p1', type: 'page' },
+      ];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      expect(dispatched).toHaveLength(2);
+      expect(dispatched.map((d) => (d.data as { filePath: string }).filePath)).toEqual(['m1', 'm2']);
+    });
+
+    it('should wait for all items in phase to complete before next phase', () => {
+      const items: TestItem[] = [
+        { id: 'm1', type: 'molecule' },
+        { id: 'm2', type: 'molecule' },
+        { id: 'o1', type: 'organism' },
+      ];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      expect(dispatched).toHaveLength(2);
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+
+      expect(dispatched).toHaveLength(2);
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm2' } }, 'm2');
+
+      expect(dispatched).toHaveLength(3);
+      expect((dispatched[2].data as { filePath: string }).filePath).toBe('o1');
+    });
+
+    it('should skip empty phases', () => {
+      const items: TestItem[] = [
+        { id: 'm1', type: 'molecule' },
+        { id: 'p1', type: 'page' },
+      ];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      expect(dispatched).toHaveLength(1);
+      expect((dispatched[0].data as { filePath: string }).filePath).toBe('m1');
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+
+      expect(dispatched).toHaveLength(2);
+      expect((dispatched[1].data as { filePath: string }).filePath).toBe('p1');
+    });
+  });
+
+  describe('completion tracking', () => {
+    it('should emit success event when all phases complete', () => {
+      const items: TestItem[] = [
+        { id: 'm1', type: 'molecule' },
+        { id: 'o1', type: 'organism' },
+      ];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'o1' } }, 'o1');
+
+      expect(completed).toHaveLength(1);
+      expect(completed[0].type).toBe('AllComponentsImplemented');
+      expect(completed[0].correlationId).toBe('c1');
+    });
+
+    it('should cleanup session after completion', () => {
+      const items: TestItem[] = [{ id: 'm1', type: 'molecule' }];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+      expect(executor.getActiveSessionCount()).toBe(1);
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+
+      expect(executor.getActiveSessionCount()).toBe(0);
+    });
+  });
+
+  describe('state queries', () => {
+    it('should report phase completion status', () => {
+      const items: TestItem[] = [
+        { id: 'm1', type: 'molecule' },
+        { id: 'o1', type: 'organism' },
+      ];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      expect(executor.isPhaseComplete('c1', 'molecule')).toBe(false);
+      expect(executor.isPhaseComplete('c1', 'organism')).toBe(false);
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+
+      expect(executor.isPhaseComplete('c1', 'molecule')).toBe(true);
+      expect(executor.isPhaseComplete('c1', 'organism')).toBe(false);
+    });
+
+    it('should return false for unknown correlationId', () => {
+      expect(executor.isPhaseComplete('unknown', 'molecule')).toBe(false);
+    });
+
+    it('should return false for unknown phase name', () => {
+      const items: TestItem[] = [{ id: 'm1', type: 'molecule' }];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      expect(executor.isPhaseComplete('c1', 'nonexistent-phase')).toBe(false);
+    });
+
+    it('should return false for future phase when current phase is earlier', () => {
+      const items: TestItem[] = [
+        { id: 'm1', type: 'molecule' },
+        { id: 'p1', type: 'page' },
+      ];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      expect(executor.isPhaseComplete('c1', 'page')).toBe(false);
+    });
+
+    it('should check correct session when multiple sessions exist with different correlationIds', () => {
+      const items1: TestItem[] = [
+        { id: 'm1', type: 'molecule' },
+        { id: 'o1', type: 'organism' },
+      ];
+      const items2: TestItem[] = [
+        { id: 'm2', type: 'molecule' },
+        { id: 'o2', type: 'organism' },
+      ];
+      const handler1 = createHandler(items1);
+      const handler2 = createHandler(items2);
+
+      executor.startPhased(
+        handler1,
+        { type: 'ClientGenerated', correlationId: 'c1', data: { components: items1 } },
+        'c1',
+      );
+      executor.startPhased(
+        handler2,
+        { type: 'ClientGenerated', correlationId: 'c2', data: { components: items2 } },
+        'c2',
+      );
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+
+      expect(executor.isPhaseComplete('c1', 'molecule')).toBe(true);
+      expect(executor.isPhaseComplete('c2', 'molecule')).toBe(false);
+    });
+  });
+
+  describe('failure handling', () => {
+    it('should stop on failure when stopOnFailure is true', () => {
+      const items: TestItem[] = [
+        { id: 'm1', type: 'molecule' },
+        { id: 'm2', type: 'molecule' },
+        { id: 'o1', type: 'organism' },
+      ];
+      const handler: ForEachPhasedDescriptor = {
+        ...createHandler(items),
+        stopOnFailure: true,
+      };
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      executor.onEventReceived({ type: 'ComponentsFailed', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+
+      expect(completed).toHaveLength(1);
+      expect(completed[0].type).toBe('ComponentsFailed');
+      expect(executor.getActiveSessionCount()).toBe(0);
+    });
+
+    it('should continue on failure when stopOnFailure is false', () => {
+      const items: TestItem[] = [
+        { id: 'm1', type: 'molecule' },
+        { id: 'm2', type: 'molecule' },
+        { id: 'o1', type: 'organism' },
+      ];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      executor.onEventReceived({ type: 'ComponentsFailed', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+
+      expect(completed).toHaveLength(0);
+      expect(executor.getActiveSessionCount()).toBe(1);
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm2' } }, 'm2');
+
+      expect(dispatched).toHaveLength(3);
+    });
+  });
+
+  describe('concurrent sessions', () => {
+    it('should track sessions independently by correlationId', () => {
+      const items: TestItem[] = [{ id: 'm1', type: 'molecule' }];
+      const handler = createHandler(items);
+
+      executor.startPhased(
+        handler,
+        { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } },
+        'c1',
+      );
+      executor.startPhased(
+        handler,
+        { type: 'ClientGenerated', correlationId: 'c2', data: { components: items } },
+        'c2',
+      );
+
+      expect(executor.getActiveSessionCount()).toBe(2);
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+
+      expect(executor.getActiveSessionCount()).toBe(1);
+      expect(completed).toHaveLength(1);
+      expect(completed[0].correlationId).toBe('c1');
+    });
+  });
+
+  describe('event deduplication', () => {
+    it('should ignore duplicate events for already completed items', () => {
+      const items: TestItem[] = [
+        { id: 'm1', type: 'molecule' },
+        { id: 'm2', type: 'molecule' },
+        { id: 'o1', type: 'organism' },
+      ];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+
+      expect(dispatched).toHaveLength(2);
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'm1' } }, 'm1');
+
+      expect(dispatched).toHaveLength(2);
+    });
+  });
+
+  describe('event edge cases', () => {
+    it('should ignore events with undefined correlationId', () => {
+      const items: TestItem[] = [{ id: 'm1', type: 'molecule' }];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      expect(dispatched).toHaveLength(1);
+
+      executor.onEventReceived({ type: 'ComponentImplemented', data: { filePath: 'm1' } }, 'm1');
+
+      expect(dispatched).toHaveLength(1);
+      expect(executor.getActiveSessionCount()).toBe(1);
+    });
+
+    it('should ignore events with empty correlationId', () => {
+      const items: TestItem[] = [{ id: 'm1', type: 'molecule' }];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      expect(dispatched).toHaveLength(1);
+
+      executor.onEventReceived({ type: 'ComponentImplemented', correlationId: '', data: { filePath: 'm1' } }, 'm1');
+
+      expect(dispatched).toHaveLength(1);
+      expect(executor.getActiveSessionCount()).toBe(1);
+    });
+
+    it('should ignore events with unknown itemKey', () => {
+      const items: TestItem[] = [{ id: 'm1', type: 'molecule' }];
+      const handler = createHandler(items);
+      const event: Event = { type: 'ClientGenerated', correlationId: 'c1', data: { components: items } };
+
+      executor.startPhased(handler, event, 'c1');
+
+      executor.onEventReceived(
+        { type: 'ComponentImplemented', correlationId: 'c1', data: { filePath: 'unknown' } },
+        'unknown',
+      );
+
+      expect(dispatched).toHaveLength(1);
+      expect(executor.getActiveSessionCount()).toBe(1);
+    });
+  });
+});