feat(voice): VoiceMetricsReporter typed event bus with isolated listeners

Fans out the 5 lifecycle event types (provider_selected, provider_failed,
provider_failover, provider_degraded, provider_unavailable) to
subscribers. Listener exceptions are caught so one bad subscriber can't
break the others. Host apps pipe these to WebSocket frames for client
UX, to log aggregators for ops visibility, or to metrics systems.

Task 6/17.

Author: jddunn

src/voice-pipeline/VoiceMetricsReporter.ts

@@ -0,0 +1,71 @@
+/**
+ * @module voice-pipeline/VoiceMetricsReporter
+ *
+ * Typed pub/sub bus for voice-pipeline lifecycle events. Chains and
+ * circuit breakers emit structured events here; host applications
+ * subscribe to forward them to clients (WebSocket frames), metrics
+ * systems (Prometheus, Datadog), or logs.
+ *
+ * Listener errors are swallowed — one bad subscriber must not poison the
+ * fan-out path for others.
+ */
+
+import type { HealthErrorClass } from './VoicePipelineError.js';
+
+export type VoiceMetricEvent =
+  | {
+      type: 'provider_selected';
+      kind: 'stt' | 'tts';
+      providerId: string;
+      attempt: number;
+    }
+  | {
+      type: 'provider_failed';
+      kind: 'stt' | 'tts';
+      providerId: string;
+      errorClass: HealthErrorClass;
+      message: string;
+    }
+  | {
+      type: 'provider_failover';
+      kind: 'stt' | 'tts';
+      from: string;
+      to: string;
+      reason: HealthErrorClass;
+      lostMs: number;
+    }
+  | {
+      type: 'provider_degraded';
+      kind: 'stt' | 'tts';
+      providerId: string;
+      latencyMs: number;
+      thresholdMs: number;
+    }
+  | {
+      type: 'provider_unavailable';
+      kind: 'stt' | 'tts';
+      checkedProviders: string[];
+    };
+
+export type VoiceMetricListener = (event: VoiceMetricEvent) => void;
+
+export class VoiceMetricsReporter {
+  private readonly listeners = new Set<VoiceMetricListener>();
+
+  subscribe(fn: VoiceMetricListener): () => void {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+
+  emit(event: VoiceMetricEvent): void {
+    for (const fn of this.listeners) {
+      try {
+        fn(event);
+      } catch {
+        /* swallow — one bad listener must not poison the rest */
+      }
+    }
+  }
+}

src/voice-pipeline/__tests__/VoiceMetricsReporter.spec.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi } from 'vitest';
+import { VoiceMetricsReporter } from '../VoiceMetricsReporter.js';
+
+describe('VoiceMetricsReporter', () => {
+  it('fans out events to all subscribers', () => {
+    const r = new VoiceMetricsReporter();
+    const a = vi.fn();
+    const b = vi.fn();
+    r.subscribe(a);
+    r.subscribe(b);
+    r.emit({
+      type: 'provider_selected',
+      kind: 'stt',
+      providerId: 'deepgram',
+      attempt: 1,
+    });
+    expect(a).toHaveBeenCalledOnce();
+    expect(b).toHaveBeenCalledOnce();
+    expect(a.mock.calls[0][0].providerId).toBe('deepgram');
+  });
+
+  it('unsubscribe removes a listener', () => {
+    const r = new VoiceMetricsReporter();
+    const a = vi.fn();
+    const unsub = r.subscribe(a);
+    unsub();
+    r.emit({
+      type: 'provider_failover',
+      kind: 'tts',
+      from: 'elevenlabs',
+      to: 'openai',
+      reason: 'network',
+      lostMs: 120,
+    });
+    expect(a).not.toHaveBeenCalled();
+  });
+
+  it('swallows listener errors without breaking fan-out', () => {
+    const r = new VoiceMetricsReporter();
+    const good = vi.fn();
+    r.subscribe(() => {
+      throw new Error('boom');
+    });
+    r.subscribe(good);
+    r.emit({
+      type: 'provider_unavailable',
+      kind: 'stt',
+      checkedProviders: ['deepgram', 'elevenlabs'],
+    });
+    expect(good).toHaveBeenCalledOnce();
+  });
+});