feat(core): add kero logger integration to AsyncEventBus

- Add optional logger parameter to AsyncEventBusOptions
- Use kero logger for all debug/error logging when provided
- Graceful fallback to console.* when no logger provided
- Add comprehensive logger integration tests

Benefits:
- Consistent structured logging across core components
- Proper log levels and error context
- Better test isolation with logger mocking
- Aligns with scanner/observability logging patterns

All 601 core tests passing (added 3 new tests).

Author: prosdev

packages/core/src/events/__tests__/event-bus.test.ts

@@ -257,6 +257,92 @@ describe('AsyncEventBus', () => {
       consoleErrorSpy.mockRestore();
     });
   });
+
+  describe('logger integration', () => {
+    it('should use kero logger when provided', async () => {
+      const mockLogger = {
+        trace: vi.fn(),
+        debug: vi.fn(),
+        info: vi.fn(),
+        success: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        fatal: vi.fn(),
+        child: vi.fn(),
+        startTimer: vi.fn(() => vi.fn()),
+        isLevelEnabled: vi.fn(() => true),
+        level: 'debug' as const,
+      };
+
+      const busWithLogger = new AsyncEventBus({ debug: true, logger: mockLogger });
+
+      // Test debug logging for subscription
+      busWithLogger.on('test.event', vi.fn());
+      expect(mockLogger.debug).toHaveBeenCalledWith('Subscribed to "test.event" (priority: 0)');
+
+      // Test debug logging for emit
+      await busWithLogger.emit('test.event', { data: 'test' });
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        expect.objectContaining({ payload: { data: 'test' } }),
+        'Emitting "test.event"'
+      );
+
+      busWithLogger.removeAllListeners();
+    });
+
+    it('should use kero logger for error handling', async () => {
+      const mockLogger = {
+        trace: vi.fn(),
+        debug: vi.fn(),
+        info: vi.fn(),
+        success: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        fatal: vi.fn(),
+        child: vi.fn(),
+        startTimer: vi.fn(() => vi.fn()),
+        isLevelEnabled: vi.fn(() => true),
+        level: 'debug' as const,
+      };
+
+      const busWithLogger = new AsyncEventBus({ logger: mockLogger });
+
+      const error = new Error('Test error');
+      const errorHandler = vi.fn().mockRejectedValue(error);
+      busWithLogger.on('error.event', errorHandler);
+
+      await busWithLogger.emit('error.event', {});
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(mockLogger.error).toHaveBeenCalledWith(error, 'Handler error for "error.event"');
+
+      busWithLogger.removeAllListeners();
+    });
+
+    it('should fallback to console when no logger provided', async () => {
+      const consoleDebugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const busWithoutLogger = new AsyncEventBus({ debug: true });
+
+      busWithoutLogger.on('test.event', vi.fn());
+      expect(consoleDebugSpy).toHaveBeenCalledWith(
+        '[EventBus] Subscribed to "test.event" (priority: 0)'
+      );
+
+      const errorHandler = vi.fn().mockRejectedValue(new Error('Test error'));
+      busWithoutLogger.on('error.event', errorHandler);
+
+      await busWithoutLogger.emit('error.event', {});
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(consoleErrorSpy).toHaveBeenCalled();
+
+      consoleDebugSpy.mockRestore();
+      consoleErrorSpy.mockRestore();
+      busWithoutLogger.removeAllListeners();
+    });
+  });
 });
 
 describe('createTypedEventBus', () => {

packages/core/src/events/event-bus.ts

@@ -7,6 +7,7 @@
 
 import { randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
+import type { Logger } from '@lytics/kero';
 import type {
   EmitOptions,
   EventBus,
@@ -37,6 +38,8 @@ export interface AsyncEventBusOptions {
   source?: string;
   /** Enable debug logging */
   debug?: boolean;
+  /** Optional kero logger for structured logging */
+  logger?: Logger;
 }
 
 /**
@@ -52,7 +55,8 @@ export interface AsyncEventBusOptions {
 export class AsyncEventBus implements EventBus {
   private emitter: EventEmitter;
   private handlers: Map<string, HandlerEntry[]> = new Map();
-  private options: Required<AsyncEventBusOptions>;
+  private options: Required<Omit<AsyncEventBusOptions, 'logger'>>;
+  private logger?: Logger;
 
   constructor(options: AsyncEventBusOptions = {}) {
     this.options = {
@@ -61,6 +65,7 @@ export class AsyncEventBus implements EventBus {
       source: options.source ?? 'event-bus',
       debug: options.debug ?? false,
     };
+    this.logger = options.logger;
 
     this.emitter = new EventEmitter();
     this.emitter.setMaxListeners(this.options.maxListeners);
@@ -103,7 +108,11 @@ export class AsyncEventBus implements EventBus {
     (entry as HandlerEntry & { _wrapped: typeof wrappedHandler })._wrapped = wrappedHandler;
 
     if (this.options.debug) {
-      console.debug(`[EventBus] Subscribed to "${eventName}" (priority: ${entry.priority})`);
+      if (this.logger) {
+        this.logger.debug(`Subscribed to "${eventName}" (priority: ${entry.priority})`);
+      } else {
+        console.debug(`[EventBus] Subscribed to "${eventName}" (priority: ${entry.priority})`);
+      }
     }
 
     // Return unsubscribe function
@@ -135,7 +144,11 @@ export class AsyncEventBus implements EventBus {
       handlerList.splice(index, 1);
 
       if (this.options.debug) {
-        console.debug(`[EventBus] Unsubscribed from "${eventName}"`);
+        if (this.logger) {
+          this.logger.debug(`Unsubscribed from "${eventName}"`);
+        } else {
+          console.debug(`[EventBus] Unsubscribed from "${eventName}"`);
+        }
       }
     }
   }
@@ -151,7 +164,11 @@ export class AsyncEventBus implements EventBus {
     };
 
     if (this.options.debug) {
-      console.debug(`[EventBus] Emitting "${eventName}"`, { payload, meta });
+      if (this.logger) {
+        this.logger.debug({ payload, meta }, `Emitting "${eventName}"`);
+      } else {
+        console.debug(`[EventBus] Emitting "${eventName}"`, { payload, meta });
+      }
     }
 
     if (options.waitForHandlers) {
@@ -211,7 +228,12 @@ export class AsyncEventBus implements EventBus {
     }
 
     if (this.options.debug) {
-      console.debug(`[EventBus] Removed all listeners${eventName ? ` for "${eventName}"` : ''}`);
+      const message = `Removed all listeners${eventName ? ` for "${eventName}"` : ''}`;
+      if (this.logger) {
+        this.logger.debug(message);
+      } else {
+        console.debug(`[EventBus] ${message}`);
+      }
     }
   }
 
@@ -233,7 +255,15 @@ export class AsyncEventBus implements EventBus {
       // Handle promise rejection
       if (result instanceof Promise) {
         result.catch((error) => {
-          console.error(`[EventBus] Handler error for "${eventName}":`, error);
+          if (this.logger) {
+            if (error instanceof Error) {
+              this.logger.error(error, `Handler error for "${eventName}"`);
+            } else {
+              this.logger.error({ error }, `Handler error for "${eventName}"`);
+            }
+          } else {
+            console.error(`[EventBus] Handler error for "${eventName}":`, error);
+          }
         });
       }
     };
@@ -260,7 +290,15 @@ export class AsyncEventBus implements EventBus {
       try {
         await entry.handler(payload);
       } catch (error) {
-        console.error(`[EventBus] Handler error for "${eventName}":`, error);
+        if (this.logger) {
+          if (error instanceof Error) {
+            this.logger.error(error, `Handler error for "${eventName}"`);
+          } else {
+            this.logger.error({ error }, `Handler error for "${eventName}"`);
+          }
+        } else {
+          console.error(`[EventBus] Handler error for "${eventName}":`, error);
+        }
       }
     });