@auto-engineer/pipeline 1.68.0 → 1.70.0

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

@@ -465,6 +465,44 @@ describe('PipelineServer', () => {
       await server.stop();
     });
 
+    it('should show settled node success after command dispatched via /command completes', async () => {
+      const handler = {
+        name: 'CheckTests',
+        events: ['TestsPassed'],
+        handle: async () => ({ type: 'TestsPassed', data: {} }),
+      };
+      const pipeline = define('test')
+        .on('Start')
+        .emit('CheckTests', {})
+        .settled(['CheckTests'])
+        .dispatch({ dispatches: [] }, () => {})
+        .build();
+      const server = new PipelineServer({ port: 0 });
+      server.registerCommandHandlers([handler]);
+      server.registerPipeline(pipeline);
+      await server.start();
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'CheckTests', data: {} }),
+      });
+
+      await new Promise((r) => setTimeout(r, 100));
+
+      const data = await fetchAs<PipelineResponse>(`http://localhost:${server.port}/pipeline`);
+      const settledNode = data.nodes.find((n) => n.id === 'settled:CheckTests');
+      expect(settledNode).toEqual({
+        id: 'settled:CheckTests',
+        type: 'settled',
+        label: 'Settled',
+        status: 'success',
+        pendingCount: 0,
+        endedCount: 1,
+      });
+      await server.stop();
+    });
+
     it('should show running status for command being executed', async () => {
       let resolveHandler: () => void = () => {};
       const handlerPromise = new Promise<void>((resolve) => {
@@ -2400,4 +2438,60 @@ describe('PipelineServer', () => {
       await server.stop();
     });
   });
+
+  describe('emit-before-broadcast ordering', () => {
+    it('should write to event store before broadcasting PipelineRunStarted via SSE', async () => {
+      const server = new PipelineServer({ port: 0 });
+
+      const serverAny = server as unknown as {
+        eventStoreContext: {
+          eventStore: {
+            appendToStream: (
+              streamName: string,
+              events: Array<{ type: string; data: unknown }>,
+              options?: unknown,
+            ) => Promise<unknown>;
+          };
+        };
+        sseManager: {
+          broadcast: (event: unknown) => void;
+        };
+      };
+
+      await server.start();
+
+      const callOrder: string[] = [];
+
+      const originalAppend = serverAny.eventStoreContext.eventStore.appendToStream.bind(
+        serverAny.eventStoreContext.eventStore,
+      );
+      serverAny.eventStoreContext.eventStore.appendToStream = async (streamName, events, options) => {
+        const result = await originalAppend(streamName, events, options);
+        if (events.some((e) => e.type === 'PipelineRunStarted')) {
+          callOrder.push('emit');
+        }
+        return result;
+      };
+
+      const originalBroadcast = serverAny.sseManager.broadcast.bind(serverAny.sseManager);
+      serverAny.sseManager.broadcast = (event: { type?: string }) => {
+        if (event.type === 'PipelineRunStarted') {
+          callOrder.push('broadcast');
+        }
+        originalBroadcast(event);
+      };
+
+      await fetch(`http://localhost:${server.port}/command`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ type: 'RestartPipeline', data: {} }),
+      });
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(callOrder).toEqual(['emit', 'broadcast']);
+
+      await server.stop();
+    });
+  });
 });

package/src/server/pipeline-server.ts

@@ -18,11 +18,11 @@ import type { FilterOptions, GraphIR, GraphNode, NodeStatus, NodeType } from '..
 import type { PipelineContext } from '../runtime/context';
 import type { EventDefinition } from '../runtime/event-command-map';
 import { EventCommandMapper } from '../runtime/event-command-map';
-import { PhasedExecutor } from '../runtime/phased-executor';
 import { PipelineRuntime } from '../runtime/pipeline-runtime';
-import { SettledTracker } from '../runtime/settled-tracker';
 import { createPipelineEventStore, type PipelineEventStoreContext } from '../store/pipeline-event-store';
+import { createPhasedBridge } from './phased-bridge';
 import { SSEManager } from './sse-manager';
+import { createV2RuntimeBridge } from './v2-runtime-bridge';
 
 export type { EventDefinition };
 
@@ -54,9 +54,9 @@ export class PipelineServer {
   private readonly runtimes: Map<string, PipelineRuntime> = new Map();
   private actualPort: number;
   private readonly requestedPort: number;
-  private readonly settledTracker: SettledTracker;
+  private readonly settledBridge: ReturnType<typeof createV2RuntimeBridge>;
   private readonly eventCommandMapper: EventCommandMapper;
-  private readonly phasedExecutor: PhasedExecutor;
+  private readonly phasedBridge: ReturnType<typeof createPhasedBridge>;
   private readonly sseManager: SSEManager;
   private readonly eventStoreContext: PipelineEventStoreContext;
   private readonly itemKeyExtractors = new Map<string, (data: unknown) => string | undefined>();
@@ -76,35 +76,18 @@ export class PipelineServer {
     this.messageBus = createMessageBus();
     this.eventStoreContext = createPipelineEventStore();
     this.eventCommandMapper = new EventCommandMapper([]);
-    this.settledTracker = new SettledTracker({
-      readModel: this.eventStoreContext.readModel,
-      /* v8 ignore next 3 - integration callback tested via settled-tracker.specs.ts */
+    this.settledBridge = createV2RuntimeBridge({
       onDispatch: (commandType, data, correlationId) => {
         void this.dispatchFromSettled(commandType, data, correlationId);
       },
-      /* v8 ignore next 4 - integration callback tested via settled-tracker.specs.ts */
-      onEventEmit: async (event) => {
-        const correlationId = event.data.correlationId;
-        await this.eventStoreContext.eventStore.appendToStream(`pipeline-${correlationId}`, [event]);
-      },
     });
-    this.phasedExecutor = new PhasedExecutor({
-      readModel: this.eventStoreContext.readModel,
-      /* v8 ignore next 3 - integration callback tested via phased-executor.specs.ts */
+    this.phasedBridge = createPhasedBridge({
       onDispatch: (commandType, data, correlationId) => {
         void this.dispatchFromSettled(commandType, data, correlationId);
       },
-      /* v8 ignore next 3 - integration callback tested via phased-executor.specs.ts */
-      onComplete: (event, correlationId) => {
+      onPhasedComplete: (event, correlationId) => {
         void this.handlePhasedComplete(event, correlationId);
       },
-      /* v8 ignore next 5 - integration callback tested via phased-executor.specs.ts */
-      onEventEmit: async (event) => {
-        const data = event.data as Record<string, unknown>;
-        const correlationId =
-          (data.correlationId as string) ?? (data.executionId as string)?.split('-')[1] ?? 'default';
-        await this.eventStoreContext.eventStore.appendToStream(`pipeline-${correlationId}`, [event]);
-      },
     });
     this.sseManager = new SSEManager();
   }
@@ -143,12 +126,9 @@ export class PipelineServer {
 
     for (const handler of pipeline.descriptor.handlers) {
       if (handler.type === 'settled') {
-        this.settledTracker.registerHandler({
-          commandTypes: handler.commandTypes,
-          handler: handler.handler,
-        });
+        this.settledBridge.registerSettled(handler);
       } else if (handler.type === 'foreach-phased') {
-        this.phasedExecutor.registerHandler(handler);
+        this.phasedBridge.registerPhased(handler);
       }
     }
   }
@@ -521,13 +501,13 @@ export class PipelineServer {
     };
   }
 
-  private async addStatusToSettledNode(node: GraphNode, correlationId?: string): Promise<GraphNode> {
+  private addStatusToSettledNode(node: GraphNode, correlationId?: string): GraphNode {
     if (correlationId === undefined) {
       return { ...node, status: 'idle' as NodeStatus, pendingCount: 0, endedCount: 0 };
     }
     const commandTypes = node.id.replace(/^settled:/, '');
     const templateId = `template-${commandTypes}`;
-    const stats = await this.eventStoreContext.readModel.computeSettledStats(correlationId, templateId);
+    const stats = this.settledBridge.getSettledStats(correlationId, templateId);
     return {
       ...node,
       status: stats.status,
@@ -663,13 +643,13 @@ export class PipelineServer {
   }
 
   private async broadcastPipelineRunStarted(correlationId: string, triggerCommand: string): Promise<void> {
+    await this.emitPipelineRunStarted(correlationId, triggerCommand);
     const event: Event & { correlationId: string } = {
       type: 'PipelineRunStarted',
       data: { correlationId, triggerCommand },
       correlationId,
     };
     this.sseManager.broadcast(event);
-    await this.emitPipelineRunStarted(correlationId, triggerCommand);
   }
 
   private extractItemKey(commandType: string, data: unknown, requestId: string): string {
@@ -997,7 +977,7 @@ export class PipelineServer {
     await this.getOrCreateItemStatus(this.currentSessionId, command.type, itemKey, command.requestId);
 
     await this.updateNodeStatus(this.currentSessionId, command.type, 'running');
-    await this.settledTracker.onCommandStarted(command);
+    this.settledBridge.onCommandStarted(command, this.currentSessionId);
 
     const ctx = this.createContext(command.correlationId);
     let events: Event[];
@@ -1043,10 +1023,11 @@ export class PipelineServer {
 
       const sourceCommand = this.eventCommandMapper.getSourceCommand(eventWithIds.type);
       if (sourceCommand !== undefined) {
-        await this.settledTracker.onEventReceived(eventWithIds, sourceCommand);
+        const result = eventWithIds.type.includes('Failed') ? 'failure' : 'success';
+        this.settledBridge.onEventReceived(eventWithIds, sourceCommand, result, this.currentSessionId);
       }
 
-      await this.routeEventToPhasedExecutor(eventWithIds);
+      this.routeEventToPhasedExecutor(eventWithIds);
     }
 
     await Promise.all(eventsWithIds.map((e) => this.routeEventToPipelines(e)));
@@ -1061,7 +1042,7 @@ export class PipelineServer {
     return 'success';
   }
 
-  /* v8 ignore next 11 - integration path tested via settled-tracker.specs.ts */
+  /* v8 ignore next 11 - integration callback tested via v2-runtime-bridge.specs.ts */
   private async dispatchFromSettled(commandType: string, data: unknown, correlationId: string): Promise<void> {
     const requestId = `req-${nanoid()}`;
     const command: Command & { correlationId: string; requestId: string } = {
@@ -1074,7 +1055,7 @@ export class PipelineServer {
     await this.processCommand(command);
   }
 
-  /* v8 ignore next 10 - integration path tested via phased-executor.specs.ts */
+  /* 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()}`;
     const eventWithIds: EventWithCorrelation = {
@@ -1118,22 +1099,20 @@ export class PipelineServer {
         await this.emitCommandDispatched(effectiveCorrelationId, requestId, type, data as Record<string, unknown>);
         void this.processCommand(command);
       },
-      /* v8 ignore next 3 - integration path tested via pipeline-runtime.specs.ts */
       startPhased: async (handler, event) => {
-        await this.phasedExecutor.startPhased(handler, event, correlationId);
+        this.phasedBridge.startPhased(handler, event, correlationId);
       },
       eventStore: this.eventStoreContext.eventStore,
       messageBus: this.messageBus,
     };
   }
 
-  /* v8 ignore next 10 - integration path tested via phased-executor.specs.ts */
-  private async routeEventToPhasedExecutor(event: EventWithCorrelation): Promise<void> {
+  private routeEventToPhasedExecutor(event: EventWithCorrelation): void {
     for (const pipeline of this.pipelines.values()) {
       for (const handler of pipeline.descriptor.handlers) {
         if (handler.type === 'foreach-phased') {
           const itemKey = handler.completion.itemKey(event);
-          await this.phasedExecutor.onEventReceived(event, itemKey);
+          this.phasedBridge.onPhasedItemEvent(event, itemKey);
         }
       }
     }

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

@@ -0,0 +1,347 @@
+import type { Command, Event } from '@auto-engineer/message-bus';
+import type { SettledHandlerDescriptor } from '../core/descriptors.js';
+import { createV2RuntimeBridge } from './v2-runtime-bridge.js';
+
+function makeCommand(type: string, correlationId: string, requestId = 'req-1'): Command {
+  return { type, data: {}, correlationId, requestId };
+}
+
+function makeEvent(type: string, correlationId: string, data: Record<string, unknown> = {}): Event {
+  return { type, data, correlationId };
+}
+
+describe('V2RuntimeBridge', () => {
+  describe('registerSettled', () => {
+    it('creates workflow in processor that accepts keyed events', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      const descriptor: SettledHandlerDescriptor = {
+        type: 'settled',
+        commandTypes: ['CheckTests', 'CheckTypes'],
+        handler: () => undefined,
+      };
+
+      bridge.registerSettled(descriptor);
+
+      const stats = bridge.getSettledStats('corr-1', 'template-CheckTests,CheckTypes');
+      expect(stats).toEqual({ status: 'idle', pendingCount: 0, endedCount: 0 });
+    });
+  });
+
+  describe('onCommandStarted', () => {
+    it('emits StartSettled for relevant groups only', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A', 'B'],
+        handler: () => undefined,
+      });
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['C', 'D'],
+        handler: () => undefined,
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+
+      const statsAB = bridge.getSettledStats('corr-1', 'template-A,B');
+      expect(statsAB).toEqual({ status: 'running', pendingCount: 1, endedCount: 0 });
+
+      const statsCD = bridge.getSettledStats('corr-1', 'template-C,D');
+      expect(statsCD).toEqual({ status: 'idle', pendingCount: 0, endedCount: 0 });
+    });
+
+    it('ignores commands with invalid correlationId or requestId', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        handler: () => undefined,
+      });
+
+      bridge.onCommandStarted(makeCommand('A', ''));
+      bridge.onCommandStarted(makeCommand('A', 'corr-1', ''));
+
+      const stats1 = bridge.getSettledStats('', 'template-A');
+      expect(stats1).toEqual({ status: 'idle', pendingCount: 0, endedCount: 0 });
+
+      const stats2 = bridge.getSettledStats('corr-1', 'template-A');
+      expect(stats2).toEqual({ status: 'idle', pendingCount: 0, endedCount: 0 });
+    });
+
+    it('ignores commands for unregistered command types', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        handler: () => undefined,
+      });
+
+      bridge.onCommandStarted(makeCommand('Z', 'corr-1'));
+
+      const stats = bridge.getSettledStats('corr-1', 'template-A');
+      expect(stats).toEqual({ status: 'idle', pendingCount: 0, endedCount: 0 });
+    });
+  });
+
+  describe('onEventReceived', () => {
+    it('translates to CommandCompleted and buffers event', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      const handlerCalls: Record<string, Event[]>[] = [];
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        handler: (events) => {
+          handlerCalls.push(events);
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ACompleted', 'corr-1', { value: 42 }), 'A');
+
+      expect(handlerCalls).toHaveLength(1);
+      expect(handlerCalls[0]).toEqual({
+        A: [{ type: 'ACompleted', data: { value: 42 }, correlationId: 'corr-1' }],
+      });
+    });
+
+    it('ignores events for unregistered command types', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      const handlerCalls: unknown[] = [];
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        handler: (events) => {
+          handlerCalls.push(events);
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('XCompleted', 'corr-1'), 'X');
+
+      expect(handlerCalls).toHaveLength(0);
+    });
+
+    it('ignores events with empty correlationId', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      const handlerCalls: unknown[] = [];
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        handler: (events) => {
+          handlerCalls.push(events);
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ACompleted', ''), 'A');
+
+      expect(handlerCalls).toHaveLength(0);
+    });
+  });
+
+  describe('AllSettled fires v1 callback', () => {
+    it('invokes handler with correct buffered events grouped by commandType', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      const handlerCalls: Record<string, Event[]>[] = [];
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A', 'B'],
+        handler: (events) => {
+          handlerCalls.push(events);
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onCommandStarted(makeCommand('B', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1', { a: 1 }), 'A');
+      bridge.onEventReceived(makeEvent('BDone', 'corr-1', { b: 2 }), 'B');
+
+      expect(handlerCalls).toHaveLength(1);
+      expect(handlerCalls[0]).toEqual({
+        A: [{ type: 'ADone', data: { a: 1 }, correlationId: 'corr-1' }],
+        B: [{ type: 'BDone', data: { b: 2 }, correlationId: 'corr-1' }],
+      });
+    });
+
+    it('passes send function that dispatches via onDispatch', () => {
+      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('NextCommand', { payload: true });
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1'), 'A');
+
+      expect(dispatched).toEqual([{ commandType: 'NextCommand', data: { payload: true }, correlationId: 'corr-1' }]);
+    });
+  });
+
+  describe('RetryCommands', () => {
+    it('triggers onDispatch for each failed commandType', () => {
+      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', 'B'],
+        handler: () => undefined,
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onCommandStarted(makeCommand('B', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1'), 'A');
+      bridge.onEventReceived(makeEvent('BFailed', 'corr-1'), 'B', 'failure');
+
+      expect(dispatched).toEqual([{ commandType: 'B', data: {}, correlationId: 'corr-1' }]);
+    });
+  });
+
+  describe('persist: true resets instance', () => {
+    it('allows receiving new commands after reset', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      const handlerCalls: Record<string, Event[]>[] = [];
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        handler: (events) => {
+          handlerCalls.push(events);
+          return { persist: true };
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1', { round: 1 }), 'A');
+
+      expect(handlerCalls).toHaveLength(1);
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1', { round: 2 }), 'A');
+
+      expect(handlerCalls).toHaveLength(2);
+      expect(handlerCalls[1]).toEqual({
+        A: [{ type: 'ADone', data: { round: 2 }, correlationId: 'corr-1' }],
+      });
+    });
+  });
+
+  describe('independent correlationIds', () => {
+    it('tracks two correlationIds independently', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      const handlerCalls: Array<{ correlationId: string; events: Record<string, Event[]> }> = [];
+
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A', 'B'],
+        handler: (events) => {
+          const corrId = Object.values(events).flat()[0]?.correlationId ?? '';
+          handlerCalls.push({ correlationId: corrId, events });
+          return undefined;
+        },
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onCommandStarted(makeCommand('B', 'corr-1'));
+      bridge.onCommandStarted(makeCommand('A', 'corr-2'));
+      bridge.onCommandStarted(makeCommand('B', 'corr-2'));
+
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1', { v: 1 }), 'A');
+      bridge.onEventReceived(makeEvent('ADone', 'corr-2', { v: 2 }), 'A');
+      bridge.onEventReceived(makeEvent('BDone', 'corr-1', { v: 3 }), 'B');
+
+      expect(handlerCalls).toHaveLength(1);
+      expect(handlerCalls[0].correlationId).toBe('corr-1');
+
+      bridge.onEventReceived(makeEvent('BDone', 'corr-2', { v: 4 }), 'B');
+
+      expect(handlerCalls).toHaveLength(2);
+      expect(handlerCalls[1].correlationId).toBe('corr-2');
+    });
+  });
+
+  describe('getSettledStats', () => {
+    it('returns idle for unknown correlationId', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        handler: () => undefined,
+      });
+
+      const stats = bridge.getSettledStats('unknown', 'template-A');
+      expect(stats).toEqual({ status: 'idle', pendingCount: 0, endedCount: 0 });
+    });
+
+    it('returns running while waiting for completions', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A', 'B'],
+        handler: () => undefined,
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+
+      const stats = bridge.getSettledStats('corr-1', 'template-A,B');
+      expect(stats).toEqual({ status: 'running', pendingCount: 1, endedCount: 0 });
+    });
+
+    it('returns success after AllSettled', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      bridge.registerSettled({
+        type: 'settled',
+        commandTypes: ['A'],
+        handler: () => undefined,
+      });
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      bridge.onEventReceived(makeEvent('ADone', 'corr-1'), 'A');
+
+      const stats = bridge.getSettledStats('corr-1', 'template-A');
+      expect(stats).toEqual({ status: 'success', pendingCount: 0, endedCount: 1 });
+    });
+
+    it('returns error after SettledFailed', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+      bridge.registerSettled(
+        {
+          type: 'settled',
+          commandTypes: ['A'],
+          handler: () => undefined,
+        },
+        { maxRetries: 0 },
+      );
+
+      bridge.onCommandStarted(makeCommand('A', 'corr-1'));
+      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 });
+    });
+
+    it('returns idle for unknown templateId', () => {
+      const bridge = createV2RuntimeBridge({ onDispatch: () => {} });
+
+      const stats = bridge.getSettledStats('corr-1', 'template-Unknown');
+      expect(stats).toEqual({ status: 'idle', pendingCount: 0, endedCount: 0 });
+    });
+  });
+});