@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/runtime/diagnostics/panels/agents.js

@@ -0,0 +1,204 @@
+import { DEFAULT_PANEL_CONFIG, applyFilter, appendBounded, } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/types';
+/**
+ * AgentsPanel — diagnostic data provider for agent lifecycle telemetry.
+ *
+ * Active agents are tracked in a live map; terminal agents are moved
+ * to the history buffer for filtering and display.
+ */
+export class AgentsPanel {
+    _config;
+    _eventBus;
+    /** Active agents keyed by agentId. */
+    _active = new Map();
+    /** Completed agent history (oldest first). */
+    _history = [];
+    /** Registered change notification callbacks. */
+    _subscribers = new Set();
+    /** Unsubscribe function from the event bus. */
+    _unsub = null;
+    constructor(eventBus, config = DEFAULT_PANEL_CONFIG) {
+        this._eventBus = eventBus;
+        this._config = config;
+        this._start();
+    }
+    _start() {
+        const handler = (envelope) => {
+            this._handleEnvelope(envelope);
+        };
+        this._unsub = this._eventBus.onDomain('agents', handler);
+    }
+    _handleEnvelope(envelope) {
+        const p = envelope.payload;
+        if (!('type' in p))
+            return;
+        const type = p.type;
+        const traceId = envelope.traceId;
+        const sessionId = envelope.sessionId;
+        switch (type) {
+            case 'AGENT_SPAWNING': {
+                const evt = p;
+                this._active.set(evt.agentId, {
+                    agentId: evt.agentId,
+                    taskId: evt.taskId,
+                    task: evt.task,
+                    state: 'spawning',
+                    spawnedAt: envelope.ts,
+                    traceId,
+                    sessionId,
+                });
+                this._notify();
+                break;
+            }
+            case 'AGENT_RUNNING': {
+                const evt = p;
+                const record = this._active.get(evt.agentId);
+                if (record) {
+                    record.state = 'running';
+                    record.blockedOnCallId = undefined;
+                    record.blockedOnTool = undefined;
+                    this._notify();
+                }
+                break;
+            }
+            case 'AGENT_AWAITING_MESSAGE': {
+                const evt = p;
+                const record = this._active.get(evt.agentId);
+                if (record) {
+                    record.state = 'awaiting_message';
+                    this._notify();
+                }
+                break;
+            }
+            case 'AGENT_AWAITING_TOOL': {
+                const evt = p;
+                const record = this._active.get(evt.agentId);
+                if (record) {
+                    record.state = 'awaiting_tool';
+                    record.blockedOnCallId = evt.callId;
+                    record.blockedOnTool = evt.tool;
+                    this._notify();
+                }
+                break;
+            }
+            case 'AGENT_FINALIZING': {
+                const evt = p;
+                const record = this._active.get(evt.agentId);
+                if (record) {
+                    record.state = 'finalizing';
+                    this._notify();
+                }
+                break;
+            }
+            case 'AGENT_COMPLETED': {
+                const evt = p;
+                const record = this._active.get(evt.agentId);
+                if (record) {
+                    record.state = 'completed';
+                    record.completedAt = envelope.ts;
+                    record.durationMs = evt.durationMs;
+                    this._finalize(record);
+                }
+                break;
+            }
+            case 'AGENT_FAILED': {
+                const evt = p;
+                const record = this._active.get(evt.agentId);
+                if (record) {
+                    record.state = 'failed';
+                    record.completedAt = envelope.ts;
+                    record.durationMs = evt.durationMs;
+                    record.error = evt.error;
+                    this._finalize(record);
+                }
+                break;
+            }
+            case 'AGENT_CANCELLED': {
+                const evt = p;
+                const record = this._active.get(evt.agentId);
+                if (record) {
+                    record.state = 'cancelled';
+                    record.completedAt = envelope.ts;
+                    record.error = evt.reason;
+                    this._finalize(record);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    _finalize(record) {
+        this._active.delete(record.agentId);
+        const entry = {
+            agentId: record.agentId,
+            taskId: record.taskId,
+            task: record.task,
+            state: record.state,
+            spawnedAt: record.spawnedAt,
+            completedAt: record.completedAt,
+            durationMs: record.durationMs,
+            error: record.error,
+            blockedOnCallId: record.blockedOnCallId,
+            blockedOnTool: record.blockedOnTool,
+            traceId: record.traceId,
+            sessionId: record.sessionId,
+        };
+        appendBounded(this._history, entry, this._config.bufferLimit);
+        this._notify();
+    }
+    /**
+     * Return a filtered snapshot combining active agents and completed history.
+     * Ordered most-recent first.
+     *
+     * @param filter - Optional filter to restrict entries.
+     */
+    getSnapshot(filter) {
+        const activeEntries = [];
+        for (const record of this._active.values()) {
+            activeEntries.push({
+                agentId: record.agentId,
+                taskId: record.taskId,
+                task: record.task,
+                state: record.state,
+                spawnedAt: record.spawnedAt,
+                completedAt: record.completedAt,
+                durationMs: record.durationMs,
+                error: record.error,
+                blockedOnCallId: record.blockedOnCallId,
+                blockedOnTool: record.blockedOnTool,
+                traceId: record.traceId,
+                sessionId: record.sessionId,
+            });
+        }
+        const combined = [...this._history, ...activeEntries];
+        return applyFilter(combined, filter, (e) => e.spawnedAt);
+    }
+    /**
+     * 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.
+     */
+    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/panels/events.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Events diagnostic panel data provider.
+ *
+ * Subscribes to ALL runtime event domains via the RuntimeEventBus and maintains
+ * a bounded buffer of EventEntry records. Provides the typed event timeline
+ * with full trace/session/turn/task/agent correlation context.
+ *
+ * This panel powers the "Events/Diagnostics" view.
+ */
+import type { RuntimeEventBus } from '../../events/index.js';
+import { type EventEntry, type DiagnosticFilter, type PanelConfig } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/types';
+/**
+ * EventsPanel — diagnostic data provider for the full event timeline.
+ *
+ * Captures every envelope emitted across all domains, building a chronological
+ * log with full tracing context. The buffer is bounded to prevent unbounded
+ * memory growth in long-running sessions.
+ */
+export declare class EventsPanel {
+    private readonly _config;
+    private readonly _eventBus;
+    /** Monotonic sequence counter for ordering within a session. */
+    private _seq;
+    /** Event history buffer (oldest first). */
+    private readonly _buffer;
+    /** Registered change notification callbacks. */
+    private readonly _subscribers;
+    /** Per-domain unsubscribe functions. */
+    private readonly _unsubs;
+    constructor(eventBus: RuntimeEventBus, config?: PanelConfig);
+    private _start;
+    private _handleEnvelope;
+    /**
+     * Return a filtered snapshot of event timeline entries.
+     * Ordered most-recent first.
+     *
+     * @param filter - Optional filter. Supports: domains (as `domains` strings),
+     *   since/until time range, traceId/sessionId/turnId/taskId correlation,
+     *   and limit.
+     */
+    getSnapshot(filter?: DiagnosticFilter): EventEntry[];
+    /**
+     * Register a callback invoked whenever a new event is captured.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback: () => void): () => void;
+    /**
+     * Release all event bus subscriptions and clear internal state.
+     */
+    dispose(): void;
+    private _notify;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/_internal/platform/runtime/diagnostics/panels/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/diagnostics/panels/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,eAAe,EAAoB,MAAM,uBAAuB,CAAC;AAG/E,OAAO,EACL,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAGjB,MAAM,0DAA0D,CAAC;AAoClE;;;;;;GAMG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,gEAAgE;IAChE,OAAO,CAAC,IAAI,CAAK;IACjB,2CAA2C;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,gDAAgD;IAChD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IACtD,wCAAwC;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;gBAErC,QAAQ,EAAE,eAAe,EAAE,MAAM,GAAE,WAAkC;IAMjF,OAAO,CAAC,MAAM;IAad,OAAO,CAAC,eAAe;IAqBvB;;;;;;;OAOG;IACI,WAAW,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,UAAU,EAAE;IAqC3D;;;OAGG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKlD;;OAEG;IACI,OAAO,IAAI,IAAI;IAQtB,OAAO,CAAC,OAAO;CAShB"}

package/dist/_internal/platform/runtime/diagnostics/panels/events.js

@@ -0,0 +1,161 @@
+import { DEFAULT_PANEL_CONFIG, appendBounded, } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/types';
+/** All domains observed by the events panel. */
+const ALL_DOMAINS = [
+    'session',
+    'turn',
+    'tools',
+    'tasks',
+    'agents',
+    'permissions',
+    'plugins',
+    'mcp',
+    'transport',
+    'compaction',
+    'ui',
+];
+/**
+ * Produce a condensed human-readable summary of an event payload.
+ * Extracts the most diagnostic fields without exposing full payloads.
+ */
+function summarizePayload(type, payload) {
+    if (typeof payload !== 'object' || payload === null)
+        return type;
+    const p = payload;
+    // Extract common correlation fields for a concise summary line
+    const parts = [];
+    if (typeof p['tool'] === 'string')
+        parts.push(`tool=${p['tool']}`);
+    if (typeof p['callId'] === 'string')
+        parts.push(`call=${p['callId'].slice(0, 8)}`);
+    if (typeof p['agentId'] === 'string')
+        parts.push(`agent=${p['agentId'].slice(0, 8)}`);
+    if (typeof p['taskId'] === 'string')
+        parts.push(`task=${p['taskId'].slice(0, 8)}`);
+    if (typeof p['error'] === 'string')
+        parts.push(`err=${p['error'].slice(0, 40)}`);
+    if (typeof p['durationMs'] === 'number')
+        parts.push(`${p['durationMs']}ms`);
+    if (typeof p['progress'] === 'number')
+        parts.push(`${p['progress']}%`);
+    return parts.length > 0 ? `${type} ${parts.join(' ')}` : type;
+}
+/**
+ * EventsPanel — diagnostic data provider for the full event timeline.
+ *
+ * Captures every envelope emitted across all domains, building a chronological
+ * log with full tracing context. The buffer is bounded to prevent unbounded
+ * memory growth in long-running sessions.
+ */
+export class EventsPanel {
+    _config;
+    _eventBus;
+    /** Monotonic sequence counter for ordering within a session. */
+    _seq = 0;
+    /** Event history buffer (oldest first). */
+    _buffer = [];
+    /** Registered change notification callbacks. */
+    _subscribers = new Set();
+    /** Per-domain unsubscribe functions. */
+    _unsubs = [];
+    constructor(eventBus, config = DEFAULT_PANEL_CONFIG) {
+        this._eventBus = eventBus;
+        this._config = config;
+        this._start();
+    }
+    _start() {
+        for (const domain of ALL_DOMAINS) {
+            const d = domain;
+            const handler = (envelope) => {
+                this._handleEnvelope(d, envelope);
+            };
+            const unsub = this._eventBus.onDomain(d, handler);
+            this._unsubs.push(unsub);
+        }
+    }
+    _handleEnvelope(domain, envelope) {
+        const entry = {
+            seq: this._seq++,
+            type: envelope.type,
+            domain,
+            ts: envelope.ts,
+            traceId: envelope.traceId,
+            sessionId: envelope.sessionId,
+            turnId: envelope.turnId,
+            agentId: envelope.agentId,
+            taskId: envelope.taskId,
+            source: envelope.source,
+            summary: summarizePayload(envelope.type, envelope.payload),
+        };
+        appendBounded(this._buffer, entry, this._config.bufferLimit);
+        this._notify();
+    }
+    /**
+     * Return a filtered snapshot of event timeline entries.
+     * Ordered most-recent first.
+     *
+     * @param filter - Optional filter. Supports: domains (as `domains` strings),
+     *   since/until time range, traceId/sessionId/turnId/taskId correlation,
+     *   and limit.
+     */
+    getSnapshot(filter) {
+        let result = [...this._buffer];
+        if (filter) {
+            if (filter.domains && filter.domains.length > 0) {
+                const domainSet = new Set(filter.domains);
+                result = result.filter((e) => domainSet.has(e.domain));
+            }
+            if (filter.traceId !== undefined) {
+                result = result.filter((e) => e.traceId === filter.traceId);
+            }
+            if (filter.sessionId !== undefined) {
+                result = result.filter((e) => e.sessionId === filter.sessionId);
+            }
+            if (filter.turnId !== undefined) {
+                result = result.filter((e) => e.turnId === filter.turnId);
+            }
+            if (filter.taskId !== undefined) {
+                result = result.filter((e) => e.taskId === filter.taskId);
+            }
+            if (filter.since !== undefined) {
+                const since = filter.since;
+                result = result.filter((e) => e.ts >= since);
+            }
+            if (filter.until !== undefined) {
+                const until = filter.until;
+                result = result.filter((e) => e.ts <= until);
+            }
+        }
+        // Most recent first
+        result.reverse();
+        const limit = filter?.limit ?? this._config.bufferLimit;
+        return result.slice(0, limit);
+    }
+    /**
+     * Register a callback invoked whenever a new event is captured.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback) {
+        this._subscribers.add(callback);
+        return () => this._subscribers.delete(callback);
+    }
+    /**
+     * Release all event bus subscriptions and clear internal state.
+     */
+    dispose() {
+        for (const unsub of this._unsubs) {
+            unsub();
+        }
+        this._unsubs.length = 0;
+        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/panels/health.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Health diagnostic panel data provider.
+ *
+ * Subscribes to the RuntimeHealthAggregator and produces HealthDashboardData
+ * snapshots for the health dashboard diagnostics panel.
+ *
+ * Implements the health visualization layer for diagnostics.
+ * SLO status rows are included when an SloCollector is attached.
+ * Remediation actions are included when a CascadeTimer is attached.
+ */
+import type { RuntimeHealthAggregator } from '@pellux/goodvibes-sdk/platform/runtime/health/aggregator';
+import type { HealthDashboardData } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/types';
+import type { SloCollector } from '../../perf/slo-collector.js';
+import type { CascadeTimer } from '@pellux/goodvibes-sdk/platform/runtime/health/cascade-timing';
+export declare class HealthPanel {
+    private readonly _aggregator;
+    private readonly _sloCollector;
+    private readonly _cascadeTimer;
+    private _current;
+    /** Registered change notification callbacks. */
+    private readonly _subscribers;
+    /** Unsubscribe function from the aggregator. */
+    private _unsub;
+    /**
+     * @param aggregator - The runtime health aggregator to subscribe to.
+     * @param sloCollector - Optional SLO collector for SLO status rows.
+     *   When provided, SLO rows are included in every dashboard snapshot.
+     * @param cascadeTimer - Optional CascadeTimer for remediation action rows.
+     *   When provided, active failed domains are evaluated and remediation
+     *   playbook IDs are surfaced in every dashboard snapshot.
+     */
+    constructor(aggregator: RuntimeHealthAggregator, sloCollector?: SloCollector | null, cascadeTimer?: CascadeTimer | null);
+    /**
+     * Build a HealthDashboardData snapshot from a CompositeHealth record.
+     */
+    private _buildDashboard;
+    /**
+     * Build remediation action rows by evaluating cascade rules for all
+     * currently-failed domains using the CascadeTimer.
+     *
+     * Returns an empty array when no CascadeTimer is attached or when
+     * no domains are in the failed state.
+     */
+    private _buildRemediationActions;
+    /**
+     * Build SLO status rows from the current SloCollector snapshot.
+     * Returns an empty array when no SloCollector is attached.
+     */
+    private _buildSloRows;
+    /**
+     * Return the current health dashboard snapshot.
+     * This is updated synchronously when the aggregator fires.
+     */
+    getSnapshot(): HealthDashboardData;
+    /**
+     * Register a callback invoked whenever health data changes.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback: () => void): () => void;
+    /**
+     * Release the aggregator subscription.
+     */
+    dispose(): void;
+    private _notify;
+}
+//# sourceMappingURL=health.d.ts.map

package/dist/_internal/platform/runtime/diagnostics/panels/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../../../../../src/_internal/platform/runtime/diagnostics/panels/health.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0DAA0D,CAAC;AAExG,OAAO,KAAK,EAAE,mBAAmB,EAAiE,MAAM,0DAA0D,CAAC;AACnK,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAC;AAkCjG,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA0B;IACtD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsB;IACpD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAsB;IACpD,OAAO,CAAC,QAAQ,CAAsB;IACtC,gDAAgD;IAChD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IACtD,gDAAgD;IAChD,OAAO,CAAC,MAAM,CAA6B;IAE3C;;;;;;;OAOG;gBAED,UAAU,EAAE,uBAAuB,EACnC,YAAY,GAAE,YAAY,GAAG,IAAW,EACxC,YAAY,GAAE,YAAY,GAAG,IAAW;IAa1C;;OAEG;IACH,OAAO,CAAC,eAAe;IA6BvB;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IAqChC;;;OAGG;IACH,OAAO,CAAC,aAAa;IA0CrB;;;OAGG;IACI,WAAW,IAAI,mBAAmB;IAIzC;;;OAGG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAKlD;;OAEG;IACI,OAAO,IAAI,IAAI;IAQtB,OAAO,CAAC,OAAO;CAShB"}

package/dist/_internal/platform/runtime/diagnostics/panels/health.js

@@ -0,0 +1,202 @@
+import { SLO_METRICS } from '../../perf/slo-collector.js';
+import { DEFAULT_BUDGETS } from '@pellux/goodvibes-sdk/platform/runtime/perf/budgets';
+/**
+ * Human-readable names for playbooks, keyed by playbook ID.
+ * Used to populate RemediationAction.playbookName in the health dashboard.
+ */
+const PLAYBOOK_NAMES = new Map([
+    ['stuck-turn', 'Stuck Turn / Task'],
+    ['reconnect-failure', 'Reconnect Failure'],
+    ['permission-deadlock', 'Permission Deadlock'],
+    ['plugin-degradation', 'Plugin Degradation'],
+    ['export-recovery', 'Export Recovery'],
+    ['session-unrecoverable', 'Session Unrecoverable'],
+    ['compaction-failure', 'Compaction Failure'],
+]);
+/**
+ * HealthPanel — diagnostic data provider for runtime health telemetry.
+ *
+ * Subscribes to health aggregator updates and maintains a current
+ * HealthDashboardData snapshot for the panel to render.
+ */
+/** Warn threshold: 20% above the SLO target triggers a 'warn' status. */
+const SLO_WARN_FACTOR = 1.2;
+/** SLO budget metadata needed for row construction, keyed by metric name. */
+const SLO_BUDGET_META = new Map(DEFAULT_BUDGETS
+    .filter((b) => b.metric.startsWith('slo.'))
+    .map((b) => [b.metric, { name: b.name, targetMs: b.threshold }]));
+export class HealthPanel {
+    _aggregator;
+    _sloCollector;
+    _cascadeTimer;
+    _current;
+    /** Registered change notification callbacks. */
+    _subscribers = new Set();
+    /** Unsubscribe function from the aggregator. */
+    _unsub = null;
+    /**
+     * @param aggregator - The runtime health aggregator to subscribe to.
+     * @param sloCollector - Optional SLO collector for SLO status rows.
+     *   When provided, SLO rows are included in every dashboard snapshot.
+     * @param cascadeTimer - Optional CascadeTimer for remediation action rows.
+     *   When provided, active failed domains are evaluated and remediation
+     *   playbook IDs are surfaced in every dashboard snapshot.
+     */
+    constructor(aggregator, sloCollector = null, cascadeTimer = null) {
+        this._aggregator = aggregator;
+        this._sloCollector = sloCollector;
+        this._cascadeTimer = cascadeTimer;
+        // Capture the initial snapshot before subscribing
+        this._current = this._buildDashboard(aggregator.getCompositeHealth());
+        this._unsub = aggregator.subscribe((health) => {
+            this._current = this._buildDashboard(health);
+            this._notify();
+        });
+    }
+    /**
+     * Build a HealthDashboardData snapshot from a CompositeHealth record.
+     */
+    _buildDashboard(composite) {
+        const domains = [];
+        for (const [, dh] of composite.domains) {
+            domains.push({
+                domain: dh.domain,
+                status: dh.status,
+                lastTransitionAt: dh.lastTransitionAt,
+                degradedCapabilities: dh.degradedCapabilities ?? [],
+                failureReason: dh.failureReason,
+                recoveryAttempts: dh.recoveryAttempts,
+            });
+        }
+        // Sort: failed first, then degraded, then healthy, alphabetically within tier
+        domains.sort((a, b) => {
+            const order = { failed: 0, degraded: 1, healthy: 2, unknown: 3 };
+            const diff = (order[a.status] ?? 3) - (order[b.status] ?? 3);
+            return diff !== 0 ? diff : a.domain.localeCompare(b.domain);
+        });
+        return {
+            overall: composite.overall,
+            domains,
+            degradedDomains: composite.degradedDomains,
+            failedDomains: composite.failedDomains,
+            lastUpdatedAt: composite.lastUpdatedAt,
+            sloRows: this._buildSloRows(),
+            remediationActions: this._buildRemediationActions(composite),
+        };
+    }
+    /**
+     * Build remediation action rows by evaluating cascade rules for all
+     * currently-failed domains using the CascadeTimer.
+     *
+     * Returns an empty array when no CascadeTimer is attached or when
+     * no domains are in the failed state.
+     */
+    _buildRemediationActions(composite) {
+        if (this._cascadeTimer === null || composite.failedDomains.length === 0) {
+            return [];
+        }
+        const actions = [];
+        const seen = new Set(); // deduplicate by playbookId+ruleId
+        for (const domain of composite.failedDomains) {
+            const { cascades } = this._cascadeTimer.evaluate(domain, 'failed');
+            for (const cascade of cascades) {
+                for (const playbookId of cascade.remediationPlaybookIds) {
+                    const key = `${playbookId}:${cascade.ruleId}`;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    actions.push({
+                        playbookId,
+                        playbookName: PLAYBOOK_NAMES.get(playbookId) ?? playbookId,
+                        ruleId: cascade.ruleId,
+                        sourceDomain: cascade.source,
+                        severity: cascade.severity ?? 'low',
+                    });
+                }
+            }
+        }
+        // Sort by severity: critical first, then high, medium, low
+        const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+        actions.sort((a, b) => (severityOrder[a.severity] ?? 3) - (severityOrder[b.severity] ?? 3));
+        return actions;
+    }
+    /**
+     * Build SLO status rows from the current SloCollector snapshot.
+     * Returns an empty array when no SloCollector is attached.
+     */
+    _buildSloRows() {
+        if (this._sloCollector === null)
+            return [];
+        const metrics = this._sloCollector.getMetrics();
+        const counts = this._sloCollector.getSampleCounts();
+        const SLO_ORDER = [
+            SLO_METRICS.TURN_START,
+            SLO_METRICS.CANCEL,
+            SLO_METRICS.RECONNECT_RECOVERY,
+            SLO_METRICS.PERMISSION_DECISION,
+        ];
+        return SLO_ORDER.map((metricKey) => {
+            const metric = metrics.find((m) => m.name === metricKey);
+            const meta = SLO_BUDGET_META.get(metricKey);
+            const p95Ms = metric?.value ?? 0;
+            const targetMs = meta?.targetMs ?? 0;
+            const sampleCount = counts[metricKey] ?? 0;
+            let status;
+            if (sampleCount === 0) {
+                status = 'no_data';
+            }
+            else if (p95Ms > targetMs) {
+                status = 'violated';
+            }
+            else if (p95Ms > targetMs / SLO_WARN_FACTOR) {
+                status = 'warn';
+            }
+            else {
+                status = 'ok';
+            }
+            return {
+                metric: metricKey,
+                name: meta?.name ?? metricKey,
+                p95Ms,
+                targetMs,
+                sampleCount,
+                status,
+            };
+        });
+    }
+    /**
+     * Return the current health dashboard snapshot.
+     * This is updated synchronously when the aggregator fires.
+     */
+    getSnapshot() {
+        return this._current;
+    }
+    /**
+     * Register a callback invoked whenever health data changes.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback) {
+        this._subscribers.add(callback);
+        return () => this._subscribers.delete(callback);
+    }
+    /**
+     * Release the aggregator subscription.
+     */
+    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
+            }
+        }
+    }
+}