@pellux/goodvibes-tui 0.18.11 → 0.18.13

package/src/runtime/telemetry/instrumentation/domain-bridge-plugin-mcp.ts

@@ -1,200 +0,0 @@
-import type { McpEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/mcp';
-import type { PluginEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/plugins';
-import { endMcpSpan, recordMcpPhase, startMcpSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/mcp';
-import { endPluginSpan, recordPluginPhase, startPluginSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/plugin';
-import type { DomainBridgeAttachmentInput, Env, SpanMap } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/instrumentation/domain-bridge-shared';
-
-export function attachPluginDomain(
-  { bus, helpers }: DomainBridgeAttachmentInput,
-  pluginSpans: SpanMap,
-): () => void {
-  const unsubs: Array<() => void> = [];
-
-  unsubs.push(
-    bus.on('PLUGIN_DISCOVERED', (env: Env<Extract<PluginEvent, { type: 'PLUGIN_DISCOVERED' }>>) => {
-      helpers.safe(() => {
-        const span = startPluginSpan(helpers.tracer, {
-          pluginId: env.payload.pluginId,
-          path: env.payload.path,
-          version: env.payload.version,
-          traceId: env.traceId,
-        });
-        pluginSpans.set(env.payload.pluginId, span);
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('PLUGIN_LOADING', (env: Env<Extract<PluginEvent, { type: 'PLUGIN_LOADING' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(pluginSpans, env.payload.pluginId, (span) => recordPluginPhase(span, 'loading'));
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('PLUGIN_LOADED', (env: Env<Extract<PluginEvent, { type: 'PLUGIN_LOADED' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(pluginSpans, env.payload.pluginId, (span) => {
-          recordPluginPhase(span, 'loaded', {
-            'plugin.capability_count': env.payload.capabilities.length,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('PLUGIN_ACTIVE', (env: Env<Extract<PluginEvent, { type: 'PLUGIN_ACTIVE' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(pluginSpans, env.payload.pluginId, (span) => recordPluginPhase(span, 'active'));
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('PLUGIN_DEGRADED', (env: Env<Extract<PluginEvent, { type: 'PLUGIN_DEGRADED' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(pluginSpans, env.payload.pluginId, (span) => {
-          recordPluginPhase(span, 'degraded', {
-            'plugin.degraded_reason': env.payload.reason,
-            'plugin.affected_capability_count': env.payload.affectedCapabilities.length,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('PLUGIN_ERROR', (env: Env<Extract<PluginEvent, { type: 'PLUGIN_ERROR' }>>) => {
-      helpers.safe(() => {
-        helpers.closeSpan(pluginSpans, env.payload.pluginId, (span) => {
-          endPluginSpan(span, {
-            outcome: 'error',
-            error: env.payload.error,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('PLUGIN_UNLOADING', (env: Env<Extract<PluginEvent, { type: 'PLUGIN_UNLOADING' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(pluginSpans, env.payload.pluginId, (span) => recordPluginPhase(span, 'unloading'));
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('PLUGIN_DISABLED', (env: Env<Extract<PluginEvent, { type: 'PLUGIN_DISABLED' }>>) => {
-      helpers.safe(() => {
-        helpers.closeSpan(pluginSpans, env.payload.pluginId, (span) => {
-          endPluginSpan(span, {
-            outcome: 'disabled',
-            reason: env.payload.reason,
-          });
-        });
-      });
-    }),
-  );
-
-  return () => unsubs.forEach((unsub) => unsub());
-}
-
-export function attachMcpDomain(
-  { bus, helpers }: DomainBridgeAttachmentInput,
-  mcpSpans: SpanMap,
-): () => void {
-  const unsubs: Array<() => void> = [];
-
-  unsubs.push(
-    bus.on('MCP_CONFIGURED', (env: Env<Extract<McpEvent, { type: 'MCP_CONFIGURED' }>>) => {
-      helpers.safe(() => {
-        const span = startMcpSpan(helpers.tracer, {
-          serverId: env.payload.serverId,
-          transport: env.payload.transport,
-          url: env.payload.url,
-          traceId: env.traceId,
-        });
-        mcpSpans.set(env.payload.serverId, span);
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('MCP_CONNECTING', (env: Env<Extract<McpEvent, { type: 'MCP_CONNECTING' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(mcpSpans, env.payload.serverId, (span) => recordMcpPhase(span, 'connecting'));
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('MCP_CONNECTED', (env: Env<Extract<McpEvent, { type: 'MCP_CONNECTED' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(mcpSpans, env.payload.serverId, (span) => {
-          recordMcpPhase(span, 'connected', {
-            'mcp.tool_count': env.payload.toolCount,
-            'mcp.resource_count': env.payload.resourceCount,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('MCP_DEGRADED', (env: Env<Extract<McpEvent, { type: 'MCP_DEGRADED' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(mcpSpans, env.payload.serverId, (span) => {
-          recordMcpPhase(span, 'degraded', {
-            'mcp.degraded_reason': env.payload.reason,
-            'mcp.available_tool_count': env.payload.availableTools.length,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('MCP_AUTH_REQUIRED', (env: Env<Extract<McpEvent, { type: 'MCP_AUTH_REQUIRED' }>>) => {
-      helpers.safe(() => {
-        helpers.closeSpan(mcpSpans, env.payload.serverId, (span) => {
-          recordMcpPhase(span, 'auth_required', {
-            'mcp.auth_type': env.payload.authType,
-          });
-          endMcpSpan(span, { outcome: 'auth_failed' });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('MCP_RECONNECTING', (env: Env<Extract<McpEvent, { type: 'MCP_RECONNECTING' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(mcpSpans, env.payload.serverId, (span) => {
-          recordMcpPhase(span, 'reconnecting', {
-            'mcp.reconnect_attempt': env.payload.attempt,
-            'mcp.reconnect_max_attempts': env.payload.maxAttempts,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('MCP_DISCONNECTED', (env: Env<Extract<McpEvent, { type: 'MCP_DISCONNECTED' }>>) => {
-      helpers.safe(() => {
-        helpers.closeSpan(mcpSpans, env.payload.serverId, (span) => {
-          endMcpSpan(span, {
-            outcome: 'disconnected',
-            reason: env.payload.reason,
-            willRetry: env.payload.willRetry,
-          });
-        });
-      });
-    }),
-  );
-
-  return () => unsubs.forEach((unsub) => unsub());
-}

package/src/runtime/telemetry/instrumentation/domain-bridge-shared.ts

@@ -1,18 +0,0 @@
-import type { RuntimeEventBus, RuntimeEventEnvelope } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { RuntimeTracer } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/tracer';
-import type { Span } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/types';
-
-export type Env<T extends { type: string }> = RuntimeEventEnvelope<T['type'], T>;
-export type SpanMap = Map<string, Span>;
-
-export interface DomainBridgeHelpers {
-  readonly tracer: RuntimeTracer;
-  readonly safe: (action: () => void) => void;
-  readonly withSpan: (map: SpanMap, key: string, action: (span: Span) => void) => void;
-  readonly closeSpan: (map: SpanMap, key: string, action: (span: Span) => void) => void;
-}
-
-export interface DomainBridgeAttachmentInput {
-  readonly bus: RuntimeEventBus;
-  readonly helpers: DomainBridgeHelpers;
-}

package/src/runtime/telemetry/instrumentation/domain-bridge-transport-task.ts

@@ -1,204 +0,0 @@
-import type { TaskEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/tasks';
-import type { TransportEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/transport';
-import { endTaskSpan, recordTaskPhase, startTaskSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/task';
-import { endTransportSpan, recordTransportPhase, startTransportSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/transport';
-import type { DomainBridgeAttachmentInput, Env, SpanMap } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/instrumentation/domain-bridge-shared';
-
-export function attachTransportDomain(
-  { bus, helpers }: DomainBridgeAttachmentInput,
-  transportSpans: SpanMap,
-): () => void {
-  const unsubs: Array<() => void> = [];
-
-  unsubs.push(
-    bus.on('TRANSPORT_INITIALIZING', (env: Env<Extract<TransportEvent, { type: 'TRANSPORT_INITIALIZING' }>>) => {
-      helpers.safe(() => {
-        const span = startTransportSpan(helpers.tracer, {
-          transportId: env.payload.transportId,
-          protocol: env.payload.protocol,
-          traceId: env.traceId,
-        });
-        transportSpans.set(env.payload.transportId, span);
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TRANSPORT_AUTHENTICATING', (env: Env<Extract<TransportEvent, { type: 'TRANSPORT_AUTHENTICATING' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(transportSpans, env.payload.transportId, (span) => recordTransportPhase(span, 'authenticating'));
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TRANSPORT_CONNECTED', (env: Env<Extract<TransportEvent, { type: 'TRANSPORT_CONNECTED' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(transportSpans, env.payload.transportId, (span) => {
-          recordTransportPhase(span, 'connected', {
-            'transport.endpoint': env.payload.endpoint,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TRANSPORT_SYNCING', (env: Env<Extract<TransportEvent, { type: 'TRANSPORT_SYNCING' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(transportSpans, env.payload.transportId, (span) => recordTransportPhase(span, 'syncing'));
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TRANSPORT_DEGRADED', (env: Env<Extract<TransportEvent, { type: 'TRANSPORT_DEGRADED' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(transportSpans, env.payload.transportId, (span) => {
-          recordTransportPhase(span, 'degraded', {
-            'transport.degraded_reason': env.payload.reason,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TRANSPORT_RECONNECTING', (env: Env<Extract<TransportEvent, { type: 'TRANSPORT_RECONNECTING' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(transportSpans, env.payload.transportId, (span) => {
-          recordTransportPhase(span, 'reconnecting', {
-            'transport.reconnect_attempt': env.payload.attempt,
-            'transport.reconnect_max_attempts': env.payload.maxAttempts,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TRANSPORT_DISCONNECTED', (env: Env<Extract<TransportEvent, { type: 'TRANSPORT_DISCONNECTED' }>>) => {
-      helpers.safe(() => {
-        helpers.closeSpan(transportSpans, env.payload.transportId, (span) => {
-          endTransportSpan(span, {
-            outcome: 'disconnected',
-            reason: env.payload.reason,
-            willRetry: env.payload.willRetry,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TRANSPORT_TERMINAL_FAILURE', (env: Env<Extract<TransportEvent, { type: 'TRANSPORT_TERMINAL_FAILURE' }>>) => {
-      helpers.safe(() => {
-        helpers.closeSpan(transportSpans, env.payload.transportId, (span) => {
-          endTransportSpan(span, {
-            outcome: 'terminal_failure',
-            reason: env.payload.error,
-          });
-        });
-      });
-    }),
-  );
-
-  return () => unsubs.forEach((unsub) => unsub());
-}
-
-export function attachTaskDomain(
-  { bus, helpers }: DomainBridgeAttachmentInput,
-  taskSpans: SpanMap,
-): () => void {
-  const unsubs: Array<() => void> = [];
-
-  unsubs.push(
-    bus.on('TASK_CREATED', (env: Env<Extract<TaskEvent, { type: 'TASK_CREATED' }>>) => {
-      helpers.safe(() => {
-        const span = startTaskSpan(helpers.tracer, {
-          taskId: env.payload.taskId,
-          agentId: env.payload.agentId,
-          description: env.payload.description,
-          priority: env.payload.priority,
-          traceId: env.traceId,
-        });
-        taskSpans.set(env.payload.taskId, span);
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TASK_STARTED', (env: Env<Extract<TaskEvent, { type: 'TASK_STARTED' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(taskSpans, env.payload.taskId, (span) => recordTaskPhase(span, 'started'));
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TASK_BLOCKED', (env: Env<Extract<TaskEvent, { type: 'TASK_BLOCKED' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(taskSpans, env.payload.taskId, (span) => {
-          recordTaskPhase(span, 'blocked', {
-            'task.blocked_reason': env.payload.reason,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TASK_PROGRESS', (env: Env<Extract<TaskEvent, { type: 'TASK_PROGRESS' }>>) => {
-      helpers.safe(() => {
-        helpers.withSpan(taskSpans, env.payload.taskId, (span) => {
-          recordTaskPhase(span, 'progress', {
-            'task.progress': env.payload.progress,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TASK_COMPLETED', (env: Env<Extract<TaskEvent, { type: 'TASK_COMPLETED' }>>) => {
-      helpers.safe(() => {
-        helpers.closeSpan(taskSpans, env.payload.taskId, (span) => {
-          endTaskSpan(span, {
-            outcome: 'completed',
-            durationMs: env.payload.durationMs,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TASK_FAILED', (env: Env<Extract<TaskEvent, { type: 'TASK_FAILED' }>>) => {
-      helpers.safe(() => {
-        helpers.closeSpan(taskSpans, env.payload.taskId, (span) => {
-          endTaskSpan(span, {
-            outcome: 'failed',
-            durationMs: env.payload.durationMs,
-            error: env.payload.error,
-          });
-        });
-      });
-    }),
-  );
-
-  unsubs.push(
-    bus.on('TASK_CANCELLED', (env: Env<Extract<TaskEvent, { type: 'TASK_CANCELLED' }>>) => {
-      helpers.safe(() => {
-        helpers.closeSpan(taskSpans, env.payload.taskId, (span) => {
-          endTaskSpan(span, {
-            outcome: 'cancelled',
-            durationMs: 0,
-            reason: env.payload.reason,
-          });
-        });
-      });
-    }),
-  );
-
-  return () => unsubs.forEach((unsub) => unsub());
-}

package/src/runtime/telemetry/instrumentation/domain-bridge.ts

@@ -1,125 +0,0 @@
-/**
- * DomainBridge — bridges RuntimeEventBus events to OTel span creation.
- *
- * Subscribes to all domain channels on the RuntimeEventBus and routes
- * lifecycle events to the appropriate span helper functions. Maintains
- * an active span map keyed by entity ID so that start events open spans
- * and terminal events close them with outcome context.
- *
- * Design principles:
- * - Span creation is purely observational — bridge failures must not
- *   affect the domain logic that emits events.
- * - All map lookups are safe — missing spans on terminal events are no-ops.
- * - The bridge is opt-in: calling `attach()` wires it; `detach()` unwires.
- */
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { RuntimeTracer } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/tracer';
-import type { Span } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/types';
-import type { CascadeAppliedEvent } from '@pellux/goodvibes-sdk/platform/runtime/health/types';
-import { recordHealthCascadeSpan } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/spans/health';
-import { attachAgentDomain, attachCompactionDomain, attachPermissionDomain, attachSessionDomain } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/instrumentation/domain-bridge-agent-session';
-import { attachPluginDomain, attachMcpDomain } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/instrumentation/domain-bridge-plugin-mcp';
-import { type DomainBridgeHelpers, type SpanMap } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/instrumentation/domain-bridge-shared';
-import { attachTaskDomain, attachTransportDomain } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/instrumentation/domain-bridge-transport-task';
-
-/**
- * DomainBridge wires the RuntimeEventBus to the OTel span system.
- *
- * Usage:
- * ```ts
- * const bridge = new DomainBridge(tracer);
- * const detach = bridge.attach(bus);
- * // later:
- * detach();
- * ```
- */
-export class DomainBridge {
-  private readonly _tracer: RuntimeTracer;
-
-  /** Active spans per domain, keyed by entity ID. */
-  private readonly _pluginSpans: SpanMap = new Map();
-  private readonly _mcpSpans: SpanMap = new Map();
-  private readonly _transportSpans: SpanMap = new Map();
-  private readonly _taskSpans: SpanMap = new Map();
-  private readonly _agentSpans: SpanMap = new Map();
-  private readonly _permissionSpans: SpanMap = new Map();
-  private readonly _sessionSpans: SpanMap = new Map();
-  private readonly _compactionSpans: SpanMap = new Map();
-
-  constructor(tracer: RuntimeTracer) {
-    this._tracer = tracer;
-  }
-
-  /**
-   * Attach the bridge to the given event bus.
-   *
-   * Subscribes to all domain channels. Returns a cleanup function that
-   * unsubscribes all listeners when called.
-   *
-   * @param bus - The RuntimeEventBus to subscribe to.
-   * @returns A `detach` function that unsubscribes all domain listeners.
-   */
-  public attach(bus: RuntimeEventBus): () => void {
-    const helpers = this._helpers();
-    const unsubs: Array<() => void> = [
-      attachPluginDomain({ bus, helpers }, this._pluginSpans),
-      attachMcpDomain({ bus, helpers }, this._mcpSpans),
-      attachTransportDomain({ bus, helpers }, this._transportSpans),
-      attachTaskDomain({ bus, helpers }, this._taskSpans),
-      attachAgentDomain({ bus, helpers }, this._agentSpans),
-      attachPermissionDomain({ bus, helpers }, this._permissionSpans),
-      attachSessionDomain({ bus, helpers }, this._sessionSpans),
-      attachCompactionDomain({ bus, helpers }, this._compactionSpans),
-    ];
-
-    return () => {
-      for (const unsub of unsubs) {
-        unsub();
-      }
-    };
-  }
-
-  /**
-   * Record a health cascade event as a point-in-time span.
-   *
-   * Called by the caller when CASCADE_APPLIED events are produced by the
-   * CascadeEngine. The caller is responsible for providing the trace ID
-   * from their current operational context.
-   *
-   * @param event - The CASCADE_APPLIED event.
-   * @param traceId - Trace ID to use for correlation.
-   */
-  public recordCascade(event: CascadeAppliedEvent, traceId: string): void {
-    this._safe(() => {
-      recordHealthCascadeSpan(this._tracer, event, { traceId });
-    });
-  }
-
-  private _safe(action: () => void): void {
-    try {
-      action();
-    } catch {
-      // Bridge failure must not propagate — non-fatal, swallowed intentionally
-    }
-  }
-
-  private _withSpan(map: SpanMap, key: string, action: (span: Span) => void): void {
-    const span = map.get(key);
-    if (span) action(span);
-  }
-
-  private _closeSpan(map: SpanMap, key: string, action: (span: Span) => void): void {
-    const span = map.get(key);
-    if (!span) return;
-    action(span);
-    map.delete(key);
-  }
-  private _helpers(): DomainBridgeHelpers {
-    return {
-      tracer: this._tracer,
-      safe: (action) => this._safe(action),
-      withSpan: (map, key, action) => this._withSpan(map, key, action),
-      closeSpan: (map, key, action) => this._closeSpan(map, key, action),
-    };
-  }
-}

package/src/runtime/telemetry/instrumentation/index.ts

@@ -1,67 +0,0 @@
-/**
- * Telemetry instrumentation — barrel and factory.
- *
- * Provides `createInstrumentation()` which wires the DomainBridge to
- * a RuntimeEventBus and returns a handle for detaching and cascade recording.
- *
- * @example
- * ```ts
- * import { createInstrumentation } from './instrumentation/index.ts';
- *
- * const { detach, recordCascade } = createInstrumentation(tracer, bus);
- *
- * // When a cascade fires:
- * recordCascade(cascadeAppliedEvent, currentTraceId);
- *
- * // On shutdown:
- * detach();
- * ```
- */
-import type { RuntimeTracer } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/tracer';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { CascadeAppliedEvent } from '@pellux/goodvibes-sdk/platform/runtime/health/types';
-import { DomainBridge } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/instrumentation/domain-bridge';
-
-export { DomainBridge } from '@pellux/goodvibes-sdk/platform/runtime/telemetry/instrumentation/domain-bridge';
-
-/** Handle returned by `createInstrumentation()`. */
-export interface InstrumentationHandle {
-  /**
-   * Detach all event listeners from the bus.
-   * Call during graceful shutdown to prevent listener leaks.
-   */
-  detach: () => void;
-
-  /**
-   * Record a health cascade event as a point-in-time span.
-   *
-   * @param event - The CASCADE_APPLIED event from the CascadeEngine.
-   * @param traceId - Trace ID to correlate with the active operational context.
-   */
-  recordCascade: (event: CascadeAppliedEvent, traceId: string) => void;
-}
-
-/**
- * Create and attach domain instrumentation to a RuntimeEventBus.
- *
- * Subscribes to all domain channels (plugin, mcp, transport, task, agent,
- * permission, session, compaction) and creates OTel spans for each
- * lifecycle state machine transition.
- *
- * @param tracer - The RuntimeTracer to use for span creation.
- * @param bus - The RuntimeEventBus to subscribe to.
- * @returns An InstrumentationHandle for cleanup and cascade recording.
- */
-export function createInstrumentation(
-  tracer: RuntimeTracer,
-  bus: RuntimeEventBus
-): InstrumentationHandle {
-  const bridge = new DomainBridge(tracer);
-  const detach = bridge.attach(bus);
-
-  return {
-    detach,
-    recordCascade: (event: CascadeAppliedEvent, traceId: string) =>
-      bridge.recordCascade(event, traceId),
-  };
-}