@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/runtime/diagnostics/panels/tool-calls.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Tool Calls diagnostic panel data provider.
+ *
+ * Subscribes to tool lifecycle events via the RuntimeEventBus and maintains
+ * a bounded buffer of ToolCallEntry records. Provides filtered snapshots
+ * for the tool-calls diagnostics panel.
+ *
+ * Phase timeline tracking allows the panel to render latency breakdowns
+ * and highlight failures at any lifecycle phase.
+ */
+import type { RuntimeEventBus } from '../../events/index.js';
+import { type ToolCallEntry, type DiagnosticFilter, type PanelConfig } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/types';
+/**
+ * ToolCallsPanel — diagnostic data provider for tool call telemetry.
+ *
+ * Listens to all tool domain events and builds a per-call timeline.
+ * Completed calls are transferred to a bounded history buffer.
+ */
+export declare class ToolCallsPanel {
+    private readonly _config;
+    private readonly _eventBus;
+    /** Active calls keyed by callId. */
+    private readonly _active;
+    /** Completed call history (oldest first). */
+    private readonly _history;
+    /** Registered change notification callbacks. */
+    private readonly _subscribers;
+    /** Unsubscribe function returned by the event bus. */
+    private _unsub;
+    constructor(eventBus: RuntimeEventBus, config?: PanelConfig);
+    /**
+     * Subscribe to the tool domain and wire up event handlers.
+     * @internal
+     */
+    private _start;
+    /**
+     * Handle a tool domain envelope, routing to the appropriate update method.
+     */
+    private _handleEnvelope;
+    /**
+     * Move a completed record from active to history.
+     */
+    private _finalize;
+    /**
+     * Return a filtered snapshot of tool call entries.
+     * Active calls are included as their current in-progress state.
+     * History is ordered most-recent first.
+     *
+     * @param filter - Optional filter to restrict entries.
+     */
+    getSnapshot(filter?: DiagnosticFilter): ToolCallEntry[];
+    /**
+     * Register a callback invoked whenever the data changes.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback: () => void): () => void;
+    /**
+     * Release all event bus subscriptions and clear internal state.
+     * After disposal the panel will no longer receive new events.
+     */
+    dispose(): void;
+    private _notify;
+}
+//# sourceMappingURL=tool-calls.d.ts.map

package/dist/_internal/platform/runtime/diagnostics/panels/tool-calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-calls.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/diagnostics/panels/tool-calls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,eAAe,EAAoB,MAAM,uBAAuB,CAAC;AAG/E,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAIjB,MAAM,0DAA0D,CAAC;AAmBlE;;;;;GAKG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,oCAAoC;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4C;IACpE,6CAA6C;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuB;IAChD,gDAAgD;IAChD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IACtD,sDAAsD;IACtD,OAAO,CAAC,MAAM,CAA6B;gBAE/B,QAAQ,EAAE,eAAe,EAAE,MAAM,GAAE,WAAkC;IAMjF;;;OAGG;IACH,OAAO,CAAC,MAAM;IASd;;OAEG;IACH,OAAO,CAAC,eAAe;IA+FvB;;OAEG;IACH,OAAO,CAAC,SAAS;IAuBjB;;;;;;OAMG;IACI,WAAW,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,aAAa,EAAE;IA4B9D;;;OAGG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKlD;;;OAGG;IACI,OAAO,IAAI,IAAI;IAQtB,OAAO,CAAC,OAAO;CAShB"}

package/dist/_internal/platform/runtime/diagnostics/panels/tool-calls.js

@@ -0,0 +1,216 @@
+import { DEFAULT_PANEL_CONFIG, applyFilter, appendBounded, } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/types';
+/**
+ * ToolCallsPanel — diagnostic data provider for tool call telemetry.
+ *
+ * Listens to all tool domain events and builds a per-call timeline.
+ * Completed calls are transferred to a bounded history buffer.
+ */
+export class ToolCallsPanel {
+    _config;
+    _eventBus;
+    /** Active calls keyed by callId. */
+    _active = new Map();
+    /** Completed call history (oldest first). */
+    _history = [];
+    /** Registered change notification callbacks. */
+    _subscribers = new Set();
+    /** Unsubscribe function returned by the event bus. */
+    _unsub = null;
+    constructor(eventBus, config = DEFAULT_PANEL_CONFIG) {
+        this._eventBus = eventBus;
+        this._config = config;
+        this._start();
+    }
+    /**
+     * Subscribe to the tool domain and wire up event handlers.
+     * @internal
+     */
+    _start() {
+        const handler = (envelope) => {
+            this._handleEnvelope(envelope);
+        };
+        this._unsub = this._eventBus.onDomain('tools', handler);
+    }
+    /**
+     * Handle a tool domain envelope, routing to the appropriate update method.
+     */
+    _handleEnvelope(envelope) {
+        const p = envelope.payload;
+        // Type narrowing is done by checking the discriminant field on payload.
+        if (!('type' in p))
+            return;
+        const type = p.type;
+        const traceId = envelope.traceId;
+        const sessionId = envelope.sessionId;
+        switch (type) {
+            case 'TOOL_RECEIVED': {
+                const evt = p;
+                this._active.set(evt.callId, {
+                    callId: evt.callId,
+                    turnId: evt.turnId,
+                    tool: evt.tool,
+                    args: evt.args,
+                    phase: 'received',
+                    receivedAt: envelope.ts,
+                    traceId,
+                    sessionId,
+                });
+                this._notify();
+                break;
+            }
+            case 'TOOL_VALIDATED':
+            case 'TOOL_PREHOOKED':
+            case 'TOOL_EXECUTING':
+            case 'TOOL_MAPPED':
+            case 'TOOL_POSTHOOKED': {
+                const evt = p;
+                const phaseMap = {
+                    TOOL_VALIDATED: 'validated',
+                    TOOL_PREHOOKED: 'prehooked',
+                    TOOL_EXECUTING: 'executing',
+                    TOOL_MAPPED: 'mapped',
+                    TOOL_POSTHOOKED: 'posthooked',
+                };
+                const record = this._active.get(evt.callId);
+                if (record) {
+                    record.phase = phaseMap[type];
+                    this._notify();
+                }
+                break;
+            }
+            case 'TOOL_PERMISSIONED': {
+                const evt = p;
+                const record = this._active.get(evt.callId);
+                if (record) {
+                    record.phase = 'permissioned';
+                    record.permissionApproved = evt.approved;
+                    this._notify();
+                }
+                break;
+            }
+            case 'TOOL_SUCCEEDED': {
+                const evt = p;
+                const record = this._active.get(evt.callId);
+                if (record) {
+                    record.phase = 'succeeded';
+                    record.completedAt = envelope.ts;
+                    record.durationMs = evt.durationMs;
+                    this._finalize(record);
+                }
+                break;
+            }
+            case 'TOOL_FAILED': {
+                const evt = p;
+                const record = this._active.get(evt.callId);
+                if (record) {
+                    record.phase = 'failed';
+                    record.completedAt = envelope.ts;
+                    record.durationMs = evt.durationMs;
+                    record.error = evt.error;
+                    this._finalize(record);
+                }
+                break;
+            }
+            case 'TOOL_CANCELLED': {
+                const evt = p;
+                const record = this._active.get(evt.callId);
+                if (record) {
+                    record.phase = 'cancelled';
+                    record.completedAt = envelope.ts;
+                    record.cancelReason = evt.reason;
+                    this._finalize(record);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    /**
+     * Move a completed record from active to history.
+     */
+    _finalize(record) {
+        this._active.delete(record.callId);
+        const entry = {
+            callId: record.callId,
+            turnId: record.turnId,
+            tool: record.tool,
+            args: record.args,
+            phase: record.phase,
+            receivedAt: record.receivedAt,
+            completedAt: record.completedAt,
+            durationMs: record.durationMs,
+            error: record.error,
+            cancelReason: record.cancelReason,
+            permission: record.permissionApproved !== undefined
+                ? { approved: record.permissionApproved }
+                : undefined,
+            traceId: record.traceId,
+            sessionId: record.sessionId,
+        };
+        appendBounded(this._history, entry, this._config.bufferLimit);
+        this._notify();
+    }
+    /**
+     * Return a filtered snapshot of tool call entries.
+     * Active calls are included as their current in-progress state.
+     * History is ordered most-recent first.
+     *
+     * @param filter - Optional filter to restrict entries.
+     */
+    getSnapshot(filter) {
+        // Convert active records to ToolCallEntry for inclusion
+        const activeEntries = [];
+        for (const record of this._active.values()) {
+            activeEntries.push({
+                callId: record.callId,
+                turnId: record.turnId,
+                tool: record.tool,
+                args: record.args,
+                phase: record.phase,
+                receivedAt: record.receivedAt,
+                completedAt: record.completedAt,
+                durationMs: record.durationMs,
+                error: record.error,
+                cancelReason: record.cancelReason,
+                permission: record.permissionApproved !== undefined
+                    ? { approved: record.permissionApproved }
+                    : undefined,
+                traceId: record.traceId,
+                sessionId: record.sessionId,
+            });
+        }
+        // Combine: history (oldest-first) + active, then apply filter
+        const combined = [...this._history, ...activeEntries];
+        return applyFilter(combined, filter, (e) => e.receivedAt);
+    }
+    /**
+     * Register a callback invoked whenever the data changes.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback) {
+        this._subscribers.add(callback);
+        return () => this._subscribers.delete(callback);
+    }
+    /**
+     * Release all event bus subscriptions and clear internal state.
+     * After disposal the panel will no longer receive new events.
+     */
+    dispose() {
+        if (this._unsub) {
+            this._unsub();
+            this._unsub = null;
+        }
+        this._subscribers.clear();
+    }
+    _notify() {
+        for (const cb of this._subscribers) {
+            try {
+                cb();
+            }
+            catch {
+                // Non-fatal: subscriber errors must not crash the provider
+            }
+        }
+    }
+}

package/dist/_internal/platform/runtime/diagnostics/provider.d.ts

@@ -0,0 +1,159 @@
+/**
+ * DiagnosticsProvider — aggregates all diagnostic panel data providers
+ * into a single unified interface.
+ *
+ * Implements the provider contract for diagnostics and the state inspector.
+ * Wire this up once during runtime initialization and pass it to all
+ * panels that need diagnostic data.
+ *
+ * Usage:
+ * ```ts
+ * import { createDiagnosticsProvider } from './diagnostics/index.js';
+ *
+ * const provider = createDiagnosticsProvider({
+ *   eventBus,
+ *   healthAggregator,
+ *   domains: [...],
+ * });
+ *
+ * const toolCalls = provider.getToolCalls({ limit: 50 });
+ * const unsubscribe = provider.subscribe('tool-calls', () => render());
+ * ```
+ */
+import type { RuntimeEventBus } from '../events/index.js';
+import type { RuntimeHealthAggregator } from '@pellux/goodvibes-sdk/platform/runtime/health/aggregator';
+import type { ToolCallEntry, AgentEntry, TaskEntry, EventEntry, RuntimeStateSnapshot, HealthDashboardData, DiagnosticFilter, PanelConfig, ToolContractEntry } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/types';
+import { type InspectableDomain } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/state-inspector';
+import { ToolContractsPanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/tool-contracts';
+import type { ContractVerificationResult } from '@pellux/goodvibes-sdk/platform/runtime/tools/contract-verifier';
+/** Configuration for creating a DiagnosticsProvider. */
+export interface DiagnosticsProviderConfig {
+    /** The runtime event bus to subscribe to. */
+    readonly eventBus: RuntimeEventBus;
+    /** The runtime health aggregator to monitor. */
+    readonly healthAggregator: RuntimeHealthAggregator;
+    /**
+     * Domain adapters to expose in the state inspector.
+     * Pass one adapter per runtime store domain.
+     */
+    readonly domains?: readonly InspectableDomain[];
+    /** Optional per-panel buffer configuration. */
+    readonly panelConfig?: PanelConfig;
+}
+/** Panel name literals for use with subscribe(). */
+export type DiagnosticPanelName = 'tool-calls' | 'agents' | 'tasks' | 'events' | 'state-inspector' | 'health' | 'tool-contracts';
+/**
+ * DiagnosticsProvider — unified data access layer for all diagnostic panels.
+ *
+ * Each panel is self-contained and subscribes to its own event sources.
+ * The provider exposes a stable interface for retrieving snapshots and
+ * registering change listeners.
+ */
+export declare class DiagnosticsProvider {
+    private readonly _toolCalls;
+    private readonly _agents;
+    private readonly _tasks;
+    private readonly _events;
+    private readonly _stateInspector;
+    private readonly _health;
+    private readonly _toolContracts;
+    constructor(config: DiagnosticsProviderConfig);
+    /**
+     * Retrieve tool call diagnostic entries.
+     *
+     * @param filter - Optional filter for domain, time range, trace/session/turn/task IDs, and limit.
+     * @returns Filtered tool call entries, most recent first.
+     */
+    getToolCalls(filter?: DiagnosticFilter): ToolCallEntry[];
+    /**
+     * Retrieve agent diagnostic entries.
+     *
+     * @param filter - Optional filter.
+     * @returns Filtered agent entries, most recent first.
+     */
+    getAgents(filter?: DiagnosticFilter): AgentEntry[];
+    /**
+     * Retrieve task diagnostic entries.
+     *
+     * @param filter - Optional filter.
+     * @returns Filtered task entries, most recent first.
+     */
+    getTasks(filter?: DiagnosticFilter): TaskEntry[];
+    /**
+     * Retrieve event timeline entries.
+     *
+     * @param filter - Optional filter. The `domains` field filters by domain name.
+     * @returns Filtered event entries, most recent first.
+     */
+    getEvents(filter?: DiagnosticFilter): EventEntry[];
+    /**
+     * Capture a point-in-time snapshot of all registered runtime domain states.
+     *
+     * @returns A RuntimeStateSnapshot with all domain states serialized.
+     */
+    getStateSnapshot(): RuntimeStateSnapshot;
+    /**
+     * Retrieve the current health dashboard data.
+     *
+     * @returns Aggregated health data sorted by severity.
+     */
+    getHealthDashboard(): HealthDashboardData;
+    /**
+     * Register a domain adapter for inclusion in state inspector snapshots.
+     *
+     * @param domain - Domain adapter implementing InspectableDomain.
+     */
+    registerDomain(domain: InspectableDomain): void;
+    /**
+     * Load (or reload) all tool contract verification results.
+     * Replaces any previously loaded results.
+     *
+     * @param results - Map of tool name → ContractVerificationResult from ToolContractVerifier.
+     */
+    loadToolContracts(results: Map<string, ContractVerificationResult>): void;
+    /**
+     * Upsert a single tool contract verification result.
+     * Use this for live updates when a single tool is re-verified.
+     *
+     * @param result - The ContractVerificationResult to upsert.
+     */
+    upsertToolContract(result: ContractVerificationResult): void;
+    /**
+     * Get the contract entry for a specific tool by name.
+     *
+     * @param toolName - Tool name to look up.
+     * @returns The entry or undefined if not verified.
+     */
+    getToolContract(toolName: string): ToolContractEntry | undefined;
+    /**
+     * Get all tool contract entries, sorted by tool name.
+     */
+    getToolContracts(): ToolContractEntry[];
+    /**
+     * Get only tools that failed their contract checks.
+     */
+    getToolContractFailures(): ToolContractEntry[];
+    /**
+     * Get summary counts across all tool contract results.
+     */
+    getToolContractSummary(): ReturnType<ToolContractsPanel['getSummary']>;
+    /**
+     * Subscribe to change notifications for a specific panel.
+     *
+     * The callback is invoked whenever the panel's data changes. Call the
+     * corresponding `get*` method inside the callback to retrieve the latest data.
+     *
+     * @param panel - The panel to subscribe to.
+     * @param callback - Called whenever the panel's data updates.
+     * @returns An unsubscribe function; call it to stop receiving notifications.
+     */
+    subscribe(panel: DiagnosticPanelName, callback: () => void): () => void;
+    /**
+     * Dispose all panel data providers, releasing event bus subscriptions
+     * and clearing all internal buffers.
+     *
+     * Call this when the diagnostics system is shut down.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/_internal/platform/runtime/diagnostics/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/runtime/diagnostics/provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0DAA0D,CAAC;AACxG,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EACV,SAAS,EACT,UAAU,EACV,oBAAoB,EACpB,mBAAmB,EACnB,gBAAgB,EAChB,WAAW,EACX,iBAAiB,EAClB,MAAM,0DAA0D,CAAC;AAKlE,OAAO,EAAuB,KAAK,iBAAiB,EAAE,MAAM,2EAA2E,CAAC;AAExI,OAAO,EAAE,kBAAkB,EAAE,MAAM,0EAA0E,CAAC;AAC9G,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gEAAgE,CAAC;AAEjH,wDAAwD;AACxD,MAAM,WAAW,yBAAyB;IACxC,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,gDAAgD;IAChD,QAAQ,CAAC,gBAAgB,EAAE,uBAAuB,CAAC;IACnD;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAChD,+CAA+C;IAC/C,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;CACpC;AAED,oDAAoD;AACpD,MAAM,MAAM,mBAAmB,GAC3B,YAAY,GACZ,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,iBAAiB,GACjB,QAAQ,GACR,gBAAgB,CAAC;AAErB;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiB;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsB;IACtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;gBAExC,MAAM,EAAE,yBAAyB;IAe7C;;;;;OAKG;IACI,YAAY,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,aAAa,EAAE;IAI/D;;;;;OAKG;IACI,SAAS,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,UAAU,EAAE;IAIzD;;;;;OAKG;IACI,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,SAAS,EAAE;IAIvD;;;;;OAKG;IACI,SAAS,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,UAAU,EAAE;IAIzD;;;;OAIG;IACI,gBAAgB,IAAI,oBAAoB;IAI/C;;;;OAIG;IACI,kBAAkB,IAAI,mBAAmB;IAIhD;;;;OAIG;IACI,cAAc,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAMtD;;;;;OAKG;IACI,iBAAiB,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,GAAG,IAAI;IAIhF;;;;;OAKG;IACI,kBAAkB,CAAC,MAAM,EAAE,0BAA0B,GAAG,IAAI;IAInE;;;;;OAKG;IACI,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAIvE;;OAEG;IACI,gBAAgB,IAAI,iBAAiB,EAAE;IAI9C;;OAEG;IACI,uBAAuB,IAAI,iBAAiB,EAAE;IAIrD;;OAEG;IACI,sBAAsB,IAAI,UAAU,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;IAM7E;;;;;;;;;OASG;IACI,SAAS,CAAC,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAc9E;;;;;OAKG;IACI,OAAO,IAAI,IAAI;CASvB"}

package/dist/_internal/platform/runtime/diagnostics/provider.js

@@ -0,0 +1,178 @@
+import { ToolCallsPanel } from './panels/tool-calls.js';
+import { AgentsPanel } from './panels/agents.js';
+import { TasksPanel } from './panels/tasks.js';
+import { EventsPanel } from './panels/events.js';
+import { StateInspectorPanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/state-inspector';
+import { HealthPanel } from './panels/health.js';
+import { ToolContractsPanel } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/tool-contracts';
+/**
+ * DiagnosticsProvider — unified data access layer for all diagnostic panels.
+ *
+ * Each panel is self-contained and subscribes to its own event sources.
+ * The provider exposes a stable interface for retrieving snapshots and
+ * registering change listeners.
+ */
+export class DiagnosticsProvider {
+    _toolCalls;
+    _agents;
+    _tasks;
+    _events;
+    _stateInspector;
+    _health;
+    _toolContracts;
+    constructor(config) {
+        const pc = config.panelConfig;
+        this._toolCalls = new ToolCallsPanel(config.eventBus, pc);
+        this._agents = new AgentsPanel(config.eventBus, pc);
+        this._tasks = new TasksPanel(config.eventBus, pc);
+        this._events = new EventsPanel(config.eventBus, pc);
+        this._stateInspector = new StateInspectorPanel(config.domains ? [...config.domains] : []);
+        this._health = new HealthPanel(config.healthAggregator);
+        this._toolContracts = new ToolContractsPanel(pc);
+    }
+    // ── Data access ──────────────────────────────────────────────────────────────
+    /**
+     * Retrieve tool call diagnostic entries.
+     *
+     * @param filter - Optional filter for domain, time range, trace/session/turn/task IDs, and limit.
+     * @returns Filtered tool call entries, most recent first.
+     */
+    getToolCalls(filter) {
+        return this._toolCalls.getSnapshot(filter);
+    }
+    /**
+     * Retrieve agent diagnostic entries.
+     *
+     * @param filter - Optional filter.
+     * @returns Filtered agent entries, most recent first.
+     */
+    getAgents(filter) {
+        return this._agents.getSnapshot(filter);
+    }
+    /**
+     * Retrieve task diagnostic entries.
+     *
+     * @param filter - Optional filter.
+     * @returns Filtered task entries, most recent first.
+     */
+    getTasks(filter) {
+        return this._tasks.getSnapshot(filter);
+    }
+    /**
+     * Retrieve event timeline entries.
+     *
+     * @param filter - Optional filter. The `domains` field filters by domain name.
+     * @returns Filtered event entries, most recent first.
+     */
+    getEvents(filter) {
+        return this._events.getSnapshot(filter);
+    }
+    /**
+     * Capture a point-in-time snapshot of all registered runtime domain states.
+     *
+     * @returns A RuntimeStateSnapshot with all domain states serialized.
+     */
+    getStateSnapshot() {
+        return this._stateInspector.getSnapshot();
+    }
+    /**
+     * Retrieve the current health dashboard data.
+     *
+     * @returns Aggregated health data sorted by severity.
+     */
+    getHealthDashboard() {
+        return this._health.getSnapshot();
+    }
+    /**
+     * Register a domain adapter for inclusion in state inspector snapshots.
+     *
+     * @param domain - Domain adapter implementing InspectableDomain.
+     */
+    registerDomain(domain) {
+        this._stateInspector.registerDomain(domain);
+    }
+    // ── Tool contracts ────────────────────────────────────────────────────────────
+    /**
+     * Load (or reload) all tool contract verification results.
+     * Replaces any previously loaded results.
+     *
+     * @param results - Map of tool name → ContractVerificationResult from ToolContractVerifier.
+     */
+    loadToolContracts(results) {
+        this._toolContracts.load(results);
+    }
+    /**
+     * Upsert a single tool contract verification result.
+     * Use this for live updates when a single tool is re-verified.
+     *
+     * @param result - The ContractVerificationResult to upsert.
+     */
+    upsertToolContract(result) {
+        this._toolContracts.upsert(result);
+    }
+    /**
+     * Get the contract entry for a specific tool by name.
+     *
+     * @param toolName - Tool name to look up.
+     * @returns The entry or undefined if not verified.
+     */
+    getToolContract(toolName) {
+        return this._toolContracts.get(toolName);
+    }
+    /**
+     * Get all tool contract entries, sorted by tool name.
+     */
+    getToolContracts() {
+        return this._toolContracts.getAll();
+    }
+    /**
+     * Get only tools that failed their contract checks.
+     */
+    getToolContractFailures() {
+        return this._toolContracts.getFailures();
+    }
+    /**
+     * Get summary counts across all tool contract results.
+     */
+    getToolContractSummary() {
+        return this._toolContracts.getSummary();
+    }
+    // ── Change subscriptions ──────────────────────────────────────────────────────
+    /**
+     * Subscribe to change notifications for a specific panel.
+     *
+     * The callback is invoked whenever the panel's data changes. Call the
+     * corresponding `get*` method inside the callback to retrieve the latest data.
+     *
+     * @param panel - The panel to subscribe to.
+     * @param callback - Called whenever the panel's data updates.
+     * @returns An unsubscribe function; call it to stop receiving notifications.
+     */
+    subscribe(panel, callback) {
+        switch (panel) {
+            case 'tool-calls': return this._toolCalls.subscribe(callback);
+            case 'agents': return this._agents.subscribe(callback);
+            case 'tasks': return this._tasks.subscribe(callback);
+            case 'events': return this._events.subscribe(callback);
+            case 'state-inspector': return this._stateInspector.subscribe(callback);
+            case 'health': return this._health.subscribe(callback);
+            case 'tool-contracts': return this._toolContracts.subscribe(callback);
+        }
+    }
+    // ── Lifecycle ─────────────────────────────────────────────────────────────────
+    /**
+     * Dispose all panel data providers, releasing event bus subscriptions
+     * and clearing all internal buffers.
+     *
+     * Call this when the diagnostics system is shut down.
+     */
+    dispose() {
+        this._toolCalls.dispose();
+        this._agents.dispose();
+        this._tasks.dispose();
+        this._events.dispose();
+        this._health.dispose();
+        this._toolContracts.dispose();
+        // StateInspectorPanel has no disposable resources (no event bus subscriptions)
+    }
+}