@auto-engineer/pipeline 1.108.0 → 1.109.0

package/package.json

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

package/src/builder/define.specs.ts

@@ -110,6 +110,14 @@ describe('settled()', () => {
     expect(descriptor.handler).toBe(handler);
   });
 
+  it('should accept handler with emit parameter', () => {
+    const handler = vi.fn((_events, _send, _emit) => undefined);
+    const pipeline = define('test').settled(['CheckTests']).dispatch({ dispatches: [] }, handler).build();
+
+    const descriptor = pipeline.descriptor.handlers[0] as SettledHandlerDescriptor;
+    expect(descriptor.handler).toBe(handler);
+  });
+
   it('should chain multiple settled handlers', () => {
     const handler1 = vi.fn();
     const handler2 = vi.fn();
@@ -165,6 +173,28 @@ describe('settled()', () => {
     expect(descriptor.sourceEventTypes).toEqual(['SliceImplemented']);
   });
 
+  it('supports maxRetries option on SettledBuilder', () => {
+    const pipeline = define('test')
+      .settled(['CheckTests'])
+      .maxRetries(0)
+      .dispatch({ dispatches: [] }, () => {})
+      .build();
+
+    const descriptor = pipeline.descriptor.handlers[0] as SettledHandlerDescriptor;
+    expect(descriptor.maxRetries).toBe(0);
+  });
+
+  it('supports maxRetries option on SettledChain', () => {
+    const pipeline = define('test')
+      .settled(['CheckTests'])
+      .dispatch({ dispatches: [] }, () => {})
+      .maxRetries(5)
+      .build();
+
+    const descriptor = pipeline.descriptor.handlers[0] as SettledHandlerDescriptor;
+    expect(descriptor.maxRetries).toBe(5);
+  });
+
   it('has no sourceEventTypes for top-level settled', () => {
     const pipeline = define('test')
       .settled(['CheckTests'])
@@ -664,4 +694,21 @@ describe('declare().accepts()', () => {
       accepts: ['ImplementComponent'],
     });
   });
+
+  it('should chain settled() from HandleChain', () => {
+    const handler = vi.fn();
+    const pipeline = define('test')
+      .on('ComponentImplemented')
+      .handle(async () => {})
+      .settled(['CheckTests', 'CheckTypes'])
+      .dispatch({ dispatches: [] }, handler)
+      .build();
+
+    expect(pipeline.descriptor.handlers).toHaveLength(2);
+    expect(pipeline.descriptor.handlers[0].type).toBe('custom');
+    expect(pipeline.descriptor.handlers[1].type).toBe('settled');
+    const settled = pipeline.descriptor.handlers[1] as SettledHandlerDescriptor;
+    expect(settled.commandTypes).toEqual(['CheckTests', 'CheckTypes']);
+    expect(settled.sourceEventTypes).toEqual(['ComponentImplemented']);
+  });
 });

package/src/builder/define.ts

@@ -11,6 +11,7 @@ import type {
   KeyExtractor,
   PipelineDescriptor,
   RunAwaitHandlerDescriptor,
+  SettledEmitFunction,
   SettledHandler,
   SettledHandlerDescriptor,
   SuccessContext,
@@ -43,11 +44,13 @@ export interface DispatchOptions<D extends readonly string[] = readonly string[]
 }
 
 export interface SettledBuilder {
+  maxRetries(n: number): SettledBuilder;
   dispatch<const D extends readonly string[]>(
     options: DispatchOptions<D>,
     handler: (
       events: Record<string, Event[]>,
       send: (commandType: D[number], data: unknown) => void,
+      emit: SettledEmitFunction,
     ) => undefined | { persist: boolean },
   ): SettledChain;
 }
@@ -56,6 +59,7 @@ export interface SettledChain {
   declare(commandType: string): DeclareBuilder;
   on(eventType: string): TriggerBuilder;
   settled(commandTypes: readonly string[], label?: string): SettledBuilder;
+  maxRetries(n: number): SettledChain;
   build(): Pipeline;
 }
 
@@ -140,6 +144,7 @@ export interface EmitChain {
 export interface HandleChain {
   declare(commandType: string): DeclareBuilder;
   on(eventType: string): TriggerBuilder;
+  settled(commandTypes: readonly string[], label?: string): SettledBuilder;
   build(): Pipeline;
 }
 
@@ -450,6 +455,11 @@ class HandleChainImpl implements HandleChain {
     return new TriggerBuilderImpl(this.parent, eventType);
   }
 
+  settled(commandTypes: readonly string[], label?: string): SettledBuilder {
+    this.finalizeHandler();
+    return new SettledBuilderImpl(this.parent, commandTypes, this.eventType, label);
+  }
+
   build(): Pipeline {
     this.finalizeHandler();
     return this.parent.build();
@@ -710,6 +720,8 @@ class PhasedTerminalImpl implements PhasedTerminal {
 }
 
 class SettledBuilderImpl implements SettledBuilder {
+  private maxRetriesValue?: number;
+
   constructor(
     private readonly parent: PipelineBuilderImpl,
     private readonly commandTypes: readonly string[],
@@ -717,11 +729,17 @@ class SettledBuilderImpl implements SettledBuilder {
     private readonly customLabel?: string,
   ) {}
 
+  maxRetries(n: number): SettledBuilder {
+    this.maxRetriesValue = n;
+    return this;
+  }
+
   dispatch<const D extends readonly string[]>(
     options: DispatchOptions<D>,
     handler: (
       events: Record<string, Event[]>,
       send: (commandType: D[number], data: unknown) => void,
+      emit: SettledEmitFunction,
     ) => undefined | { persist: boolean },
   ): SettledChain {
     return new SettledChainImpl(
@@ -731,11 +749,14 @@ class SettledBuilderImpl implements SettledBuilder {
       options.dispatches,
       this.sourceEventType,
       this.customLabel,
+      this.maxRetriesValue,
     );
   }
 }
 
 class SettledChainImpl implements SettledChain {
+  private maxRetriesValue?: number;
+
   constructor(
     private readonly parent: PipelineBuilderImpl,
     private readonly commandTypes: readonly string[],
@@ -743,7 +764,10 @@ class SettledChainImpl implements SettledChain {
     private readonly dispatches?: readonly string[],
     private readonly sourceEventType?: string,
     private readonly customLabel?: string,
-  ) {}
+    maxRetriesFromBuilder?: number,
+  ) {
+    this.maxRetriesValue = maxRetriesFromBuilder;
+  }
 
   declare(commandType: string): DeclareBuilder {
     this.finalizeHandler();
@@ -760,6 +784,11 @@ class SettledChainImpl implements SettledChain {
     return new SettledBuilderImpl(this.parent, commandTypes, undefined, label);
   }
 
+  maxRetries(n: number): SettledChain {
+    this.maxRetriesValue = n;
+    return this;
+  }
+
   build(): Pipeline {
     this.finalizeHandler();
     return this.parent.build();
@@ -776,6 +805,7 @@ class SettledChainImpl implements SettledChain {
       settledId: this.parent.nextSettledId(),
       label: settledLabel,
       sourceEventTypes: this.sourceEventType ? [this.sourceEventType] : undefined,
+      maxRetries: this.maxRetriesValue,
     };
     this.parent.addHandler(descriptor);
   }

package/src/core/descriptors.ts

@@ -75,9 +75,12 @@ export interface CustomHandlerDescriptor {
 
 type SettledSendFunction = (commandType: string, data: unknown) => void;
 
+export type SettledEmitFunction = (eventType: string, data: unknown, correlationId?: string) => void;
+
 export type SettledHandler = (
   events: Record<string, Event[]>,
   send: SettledSendFunction,
+  emit: SettledEmitFunction,
 ) => undefined | { persist: boolean };
 
 export interface SettledHandlerDescriptor {
@@ -88,6 +91,7 @@ export interface SettledHandlerDescriptor {
   settledId?: string;
   label?: string;
   sourceEventTypes?: readonly string[];
+  maxRetries?: number;
 }
 
 export interface AcceptsDescriptor {

package/src/plugins/plugin-loader.specs.ts

@@ -25,12 +25,12 @@ describe('PluginLoader', () => {
     it('should load COMMANDS from workspace package', async () => {
       const mockHandler = createMockHandler('CheckTests', ['TestsCheckPassed', 'TestsCheckFailed']);
       const deps = createMockDeps({
-        existsSync: vi.fn().mockImplementation((path: string) => path.includes('packages/server-checks')),
+        existsSync: vi.fn().mockImplementation((path: string) => path.includes('packages/checks')),
         importModule: vi.fn().mockResolvedValue({ COMMANDS: [mockHandler] }),
       });
 
       const loader = new PluginLoader('/workspace', deps);
-      const handlers = await loader.loadPlugin('@auto-engineer/server-checks');
+      const handlers = await loader.loadPlugin('@auto-engineer/checks');
 
       expect(handlers).toHaveLength(1);
       expect(handlers[0].name).toBe('CheckTests');
@@ -94,7 +94,7 @@ describe('PluginLoader', () => {
       });
 
       const loader = new PluginLoader('/workspace', deps);
-      const handlers = await loader.loadPlugin('@auto-engineer/server-checks');
+      const handlers = await loader.loadPlugin('@auto-engineer/checks');
 
       expect(handlers[0]).toEqual({
         name: 'CheckTypes',
@@ -257,7 +257,7 @@ describe('PluginLoader', () => {
   describe('integration', { timeout: 30000 }, () => {
     it('should load real package using default deps', async () => {
       const loader = new PluginLoader();
-      const handlers = await loader.loadPlugin('@auto-engineer/server-checks');
+      const handlers = await loader.loadPlugin('@auto-engineer/checks');
       const handlerNames = handlers.map((h) => h.name);
       expect(handlerNames).toContain('CheckTests');
       expect(handlerNames).toContain('CheckTypes');
@@ -267,7 +267,7 @@ describe('PluginLoader', () => {
     it('should load handlers from multiple real packages', async () => {
       const loader = new PluginLoader();
       const handlers = await loader.loadPlugins([
-        '@auto-engineer/server-checks',
+        '@auto-engineer/checks',
         '@auto-engineer/server-generator-apollo-emmett',
       ]);
       const handlerNames = handlers.map((h) => h.name);

package/src/server/pipeline-server-v2.ts

@@ -3,7 +3,12 @@ import cors from 'cors';
 import express from 'express';
 import { createPipelineEngine } from '../engine/pipeline-engine.js';
 
-export async function createPipelineServerV2(config?: { port?: number }) {
+export async function createPipelineServerV2(config?: { port?: number }): Promise<{
+  engine: Awaited<ReturnType<typeof createPipelineEngine>>;
+  app: ReturnType<typeof express>;
+  start(): Promise<number>;
+  stop(): Promise<void>;
+}> {
   const engine = await createPipelineEngine();
   const app = express();
   app.use(cors());

package/src/server/pipeline-server.ts

@@ -92,6 +92,9 @@ export class PipelineServer {
       onDispatch: (commandType, data, correlationId) => {
         void this.dispatchFromSettled(commandType, data, correlationId);
       },
+      onEmit: (eventType, data, correlationId) => {
+        void this.emitFromSettled(eventType, data, correlationId);
+      },
     });
     this.phasedBridge = createPhasedBridge({
       onDispatch: (commandType, data, correlationId) => {
@@ -1142,7 +1145,8 @@ export class PipelineServer {
     await this.updateNodeStatus(this.currentSessionId, command.type, 'running');
     const sourceEventType = this.requestIdToSourceEvent.get(command.requestId);
     this.requestIdToSourceEvent.delete(command.requestId);
-    this.settledBridge.onCommandStarted(command, this.currentSessionId, sourceEventType);
+    const settledCorrelationId = this.currentSessionId;
+    this.settledBridge.onCommandStarted(command, settledCorrelationId, sourceEventType);
 
     const ctx = this.createContext(command.correlationId, signal);
     let events: Event[];
@@ -1200,7 +1204,8 @@ export class PipelineServer {
       const sourceCommand = this.eventCommandMapper.getSourceCommand(eventWithIds.type);
       if (sourceCommand !== undefined) {
         const result = eventWithIds.type.includes('Failed') ? 'failure' : 'success';
-        this.settledBridge.onEventReceived(eventWithIds, sourceCommand, result, this.currentSessionId, sourceEventType);
+        const settledCorrelationId = this.currentSessionId;
+        this.settledBridge.onEventReceived(eventWithIds, sourceCommand, result, settledCorrelationId, sourceEventType);
       }
 
       this.routeEventToPhasedExecutor(eventWithIds);
@@ -1231,6 +1236,20 @@ export class PipelineServer {
     await this.processCommand(command);
   }
 
+  /* v8 ignore next 10 - integration callback tested via v2-runtime-bridge.specs.ts */
+  private async emitFromSettled(eventType: string, data: unknown, correlationId: string): Promise<void> {
+    const requestId = `req-${nanoid()}`;
+    const eventWithIds: EventWithCorrelation = {
+      type: eventType,
+      data: data as Record<string, unknown>,
+      correlationId,
+    };
+    await this.emitDomainEventEmitted(correlationId, requestId, eventType, data as Record<string, unknown>);
+    this.sseManager.broadcast(eventWithIds);
+    await this.messageBus.publishEvent(eventWithIds);
+    await this.routeEventToPipelines(eventWithIds);
+  }
+
   /* v8 ignore next 10 - integration callback tested via phased-bridge.specs.ts */
   private async handlePhasedComplete(event: Event, correlationId: string): Promise<void> {
     const requestId = `req-${nanoid()}`;

package/src/server/v2-runtime-bridge.specs.ts

@@ -189,6 +189,56 @@ describe('V2RuntimeBridge', () => {
 
       expect(dispatched).toEqual([{ commandType: 'NextCommand', data: { payload: true }, correlationId: 'corr-1' }]);
     });
+
+    it('passes emit function that calls onEmit with correlationId', () => {
+      const emitted: Array<{ eventType: string; data: unknown; correlationId: string }> = [];
+      const bridge = createV2RuntimeBridge({
+        onDispatch: () => {},
+        onEmit: (eventType, data, correlationId) => {
+          emitted.push({ eventType, data, correlationId });
+        },
+      });
+
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        handler: (_events, _send, emit) => {
+          emit('ChecksPassed', { component: 'Foo' }, 'graph:g1:job-a');
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1'), 'A');
+
+      expect(emitted).toEqual([
+        { eventType: 'ChecksPassed', data: { component: 'Foo' }, correlationId: 'graph:g1:job-a' },
+      ]);
+    });
+
+    it('emit uses settled correlationId when no explicit correlationId provided', () => {
+      const emitted: Array<{ eventType: string; data: unknown; correlationId: string }> = [];
+      const bridge = createV2RuntimeBridge({
+        onDispatch: () => {},
+        onEmit: (eventType, data, correlationId) => {
+          emitted.push({ eventType, data, correlationId });
+        },
+      });
+
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        handler: (_events, _send, emit) => {
+          emit('ChecksPassed', { component: 'Bar' });
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1'), 'A');
+
+      expect(emitted).toEqual([{ eventType: 'ChecksPassed', data: { component: 'Bar' }, correlationId: 'corr-1' }]);
+    });
   });
 
   describe('RetryCommands', () => {
@@ -215,6 +265,59 @@ describe('V2RuntimeBridge', () => {
     });
   });
 
+  describe('SettledFailed', () => {
+    it('invokes handler on SettledFailed after max retries exhausted', () => {
+      const handlerCalls: Record<string, Event[]>[] = [];
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+
+      bridge.registerSettled(
+        {
+          type: 'settled',
+          commandTypes: ['A'],
+          handler: (events) => {
+            handlerCalls.push(events);
+            return undefined;
+          },
+        },
+        { maxRetries: 0 },
+      );
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('AFailed', 'corr-1', { error: 'oops' }), 'A', 'failure');
+
+      expect(handlerCalls).toHaveLength(1);
+      expect(handlerCalls[0]).toEqual({
+        A: [{ type: 'AFailed', data: { error: 'oops' }, correlationId: 'corr-1' }],
+      });
+    });
+
+    it('passes send function to handler on SettledFailed', () => {
+      const dispatched: Array<{ commandType: string; data: unknown; correlationId: string }> = [];
+      const bridge = createV2RuntimeBridge({
+        onDispatch: (commandType, data, correlationId) => {
+          dispatched.push({ commandType, data, correlationId });
+        },
+      });
+
+      bridge.registerSettled(
+        {
+          type: 'settled',
+          commandTypes: ['A'],
+          handler: (_events, send) => {
+            send('RetryCommand', { retry: true });
+            return undefined;
+          },
+        },
+        { maxRetries: 0 },
+      );
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('AFailed', 'corr-1'), 'A', 'failure');
+
+      expect(dispatched).toEqual([{ commandType: 'RetryCommand', data: { retry: true }, correlationId: 'corr-1' }]);
+    });
+  });
+
   describe('persist: true resets instance', () => {
     it('allows receiving new commands after reset', () => {
       const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
@@ -334,7 +437,7 @@ describe('V2RuntimeBridge', () => {
       bridge.onEventReceived(makeEvent('AFailed', 'corr-1'), 'A', 'failure');
 
       const stats = bridge.getSettledStats('corr-1', 'template-A');
-      expect(stats).toEqual({ status: 'error', pendingCount: 0, endedCount: 0 });
+      expect(stats).toEqual({ status: 'error', pendingCount: 0, endedCount: 1 });
     });
 
     it('returns idle for unknown templateId', () => {

package/src/server/v2-runtime-bridge.ts

@@ -1,8 +1,11 @@
 import type { Command, Event } from '@auto-engineer/message-bus';
+import createDebug from 'debug';
 import type { SettledHandlerDescriptor } from '../core/descriptors.js';
 import type { SettledInput, SettledOutput, SettledState } from '../engine/workflows/settled-workflow.js';
 import { decide, evolve, initialState } from '../engine/workflows/settled-workflow.js';
 
+const debug = createDebug('auto:pipeline:settled-bridge');
+
 type NodeStatus = 'idle' | 'running' | 'success' | 'error';
 
 export interface SettledStats {
@@ -13,6 +16,7 @@ export interface SettledStats {
 
 interface V2RuntimeBridgeOptions {
   onDispatch: (commandType: string, data: unknown, correlationId: string) => void;
+  onEmit?: (eventType: string, data: unknown, correlationId: string) => void;
 }
 
 interface RegisteredSettled {
@@ -106,15 +110,33 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
   }
 
   function handleOutputs(outputs: SettledOutput[], registration: RegisteredSettled, correlationId: string): void {
+    debug(
+      'handleOutputs: templateId=%s, correlationId=%s, outputs=%o',
+      registration.templateId,
+      correlationId,
+      outputs.map((o) => o.type),
+    );
     for (const output of outputs) {
-      if (output.type === 'AllSettled') {
+      if (output.type === 'AllSettled' || output.type === 'SettledFailed') {
+        debug('  %s triggered for %s', output.type, registration.templateId);
         const events = collectBufferedEvents(registration.templateId, correlationId, registration.commandTypes);
+        debug(
+          '  collected events: %o',
+          Object.keys(events).map((k) => `${k}:${events[k].length}`),
+        );
 
         const send = (commandType: string, data: unknown) => {
+          debug('  dispatching %s with data keys: %o', commandType, Object.keys(data as object));
           options.onDispatch(commandType, data, correlationId);
         };
 
-        const handlerResult = registration.descriptor.handler(events, send);
+        const emit = (eventType: string, data: unknown, emitCorrelationId?: string) => {
+          debug('  emitting %s', eventType);
+          options.onEmit?.(eventType, data, emitCorrelationId ?? correlationId);
+        };
+
+        const handlerResult = registration.descriptor.handler(events, send, emit);
+        debug('  handler returned: %o', handlerResult);
         const persist =
           handlerResult !== null &&
           handlerResult !== undefined &&
@@ -132,6 +154,7 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
       }
 
       if (output.type === 'RetryCommands') {
+        debug('  RetryCommands: %o', output.data.commandTypes);
         for (const ct of output.data.commandTypes) {
           options.onDispatch(ct, {}, correlationId);
           eventBuffer.delete(bufferKey(registration.templateId, correlationId, ct));
@@ -151,10 +174,18 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
         templateId,
         descriptor,
         commandTypes,
-        maxRetries: config?.maxRetries ?? 3,
+        maxRetries: descriptor.maxRetries ?? config?.maxRetries ?? 3,
         sourceEventTypes: descriptor.sourceEventTypes,
       };
 
+      debug(
+        'registerSettled: templateId=%s, commandTypes=%o, sourceEventTypes=%o, label=%s',
+        templateId,
+        commandTypes,
+        descriptor.sourceEventTypes,
+        descriptor.label,
+      );
+
       registrations.set(templateId, registration);
 
       for (const ct of commandTypes) {
@@ -167,7 +198,15 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
     onCommandStarted(command: Command, sessionCorrelationId?: string, sourceEventType?: string): void {
       const { type: commandType, correlationId, requestId } = command;
 
+      debug(
+        'onCommandStarted: command=%s, sourceEventType=%s, sessionCorrelationId=%s',
+        commandType,
+        sourceEventType,
+        sessionCorrelationId,
+      );
+
       if (!isValidId(correlationId) || !isValidId(requestId)) {
+        debug('  skipping: invalid correlationId or requestId');
         return;
       }
 
@@ -175,20 +214,26 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
 
       const templateIds = commandToTemplateIds.get(commandType);
       if (!templateIds) {
+        debug('  skipping: no templateIds for command type');
         return;
       }
 
+      debug('  found %d templateIds: %o', templateIds.size, [...templateIds]);
+
       for (const templateId of templateIds) {
         const registration = registrations.get(templateId);
         if (registration) {
+          debug('  checking registration %s, sourceEventTypes=%o', templateId, registration.sourceEventTypes);
           if (
             sourceEventType &&
             registration.sourceEventTypes &&
             registration.sourceEventTypes.length > 0 &&
             !registration.sourceEventTypes.includes(sourceEventType)
           ) {
+            debug('    filtered out: sourceEventType %s not in %o', sourceEventType, registration.sourceEventTypes);
             continue;
           }
+          debug('    processing StartSettled for %s', templateId);
           const history = getHistory(templateId, keyCorrelationId);
           const input: SettledInput = {
             type: 'StartSettled',
@@ -208,7 +253,16 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
     ): void {
       const correlationId = event.correlationId;
 
+      debug(
+        'onEventReceived: event=%s, sourceCommand=%s, result=%s, sourceEventType=%s',
+        event.type,
+        sourceCommandType,
+        result,
+        sourceEventType,
+      );
+
       if (!isValidId(correlationId)) {
+        debug('  skipping: invalid correlationId');
         return;
       }
 
@@ -216,23 +270,29 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
 
       const templateIds = commandToTemplateIds.get(sourceCommandType);
       if (!templateIds) {
+        debug('  skipping: no templateIds for sourceCommand');
         return;
       }
 
+      debug('  found %d templateIds: %o', templateIds.size, [...templateIds]);
+
       for (const templateId of templateIds) {
         const registration = registrations.get(templateId)!;
+        debug('  checking registration %s, sourceEventTypes=%o', templateId, registration.sourceEventTypes);
         if (
           sourceEventType &&
           registration.sourceEventTypes &&
           registration.sourceEventTypes.length > 0 &&
           !registration.sourceEventTypes.includes(sourceEventType)
         ) {
+          debug('    filtered out: sourceEventType %s not in %o', sourceEventType, registration.sourceEventTypes);
           continue;
         }
         const existing = ensureBuffer(templateId, keyCorrelationId, sourceCommandType);
         existing.push(event);
 
         const history = getHistory(templateId, keyCorrelationId);
+        debug('    processing CommandCompleted for %s, history length=%d', templateId, history.length);
         const input: SettledInput = {
           type: 'CommandCompleted',
           data: {
@@ -243,6 +303,10 @@ export function createV2RuntimeBridge(options: V2RuntimeBridgeOptions) {
         };
         const outputs = processInput(input, history, registration.maxRetries);
 
+        debug(
+          '    outputs: %o',
+          outputs.map((o) => o.type),
+        );
         handleOutputs(outputs, registration, keyCorrelationId);
       }
     },

package/src/testing/fixtures/kanban-todo.config.ts

@@ -3,7 +3,7 @@ import { createKanbanFullPipeline } from './kanban-full.pipeline';
 
 export default pipelineConfig({
   plugins: [
-    '@auto-engineer/server-checks',
+    '@auto-engineer/checks',
     '@auto-engineer/server-generator-apollo-emmett',
     '@auto-engineer/narrative',
     '@auto-engineer/generate-react-client',