@pellux/goodvibes-tui 0.28.0 → 0.29.0

package/src/panels/schedule-panel.ts

@@ -1,365 +0,0 @@
-import { BasePanel } from './base-panel.ts';
-import { type Line } from '../types/grid.ts';
-import { fitDisplay, truncateDisplay } from '../utils/terminal-width.ts';
-import type { AutomationManager } from '@pellux/goodvibes-sdk/platform/automation';
-import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation';
-import type { AutomationRun } from '@pellux/goodvibes-sdk/platform/automation';
-import type { AutomationScheduleDefinition } from '@pellux/goodvibes-sdk/platform/automation';
-import {
-  buildEmptyState,
-  buildKeyboardHints,
-  buildPanelLine,
-  buildPanelWorkspace,
-  extendPalette,
-  resolveScrollablePanelSection,
-  DEFAULT_PANEL_PALETTE,
-  type PanelWorkspaceSection,
-} from './polish.ts';
-
-// ---------------------------------------------------------------------------
-// Colors
-// ---------------------------------------------------------------------------
-
-const C = extendPalette(DEFAULT_PANEL_PALETTE, {
-  enabled: '#5fd700',
-  disabled: '#6c6c6c',
-  selectedFg: '#ffffff',
-  id: '238',
-  cron: '#af87ff',
-  prompt: '250',
-  nextRun: '#87afff',
-  lastRun: '244',
-  runCount: '#ffaf00',
-  statusRunning: '#5fd700',
-  statusFailed: '#ff5f5f',
-});
-
-// ---------------------------------------------------------------------------
-// View items
-// ---------------------------------------------------------------------------
-
-type ViewItem =
-  | { kind: 'header' }
-  | { kind: 'task'; task: AutomationJob; history: AutomationRun[] }
-  | { kind: 'empty' };
-
-type ScheduleAutomationManager = Pick<
-  AutomationManager,
-  'start' | 'listJobs' | 'listRuns' | 'setEnabled' | 'runNow'
->;
-
-function formatSchedule(schedule: AutomationScheduleDefinition): string {
-  switch (schedule.kind) {
-    case 'cron':
-      return schedule.timezone ? `${schedule.expression} [${schedule.timezone}]` : schedule.expression;
-    case 'every':
-      return formatEveryInterval(schedule.intervalMs);
-    case 'at':
-      return new Date(schedule.at).toLocaleString();
-  }
-}
-
-function formatEveryInterval(intervalMs: number): string {
-  const units: ReadonlyArray<readonly [number, string]> = [
-    [86_400_000, 'd'],
-    [3_600_000, 'h'],
-    [60_000, 'm'],
-    [1_000, 's'],
-  ];
-  for (const [size, unit] of units) {
-    if (intervalMs >= size && intervalMs % size === 0) {
-      return `${intervalMs / size}${unit}`;
-    }
-  }
-  return `${intervalMs}ms`;
-}
-
-// ---------------------------------------------------------------------------
-// SchedulePanel
-// ---------------------------------------------------------------------------
-
-/**
- * SchedulePanel — displays all scheduled tasks with next run time,
- * enable/disable toggle, and run history.
- */
-export class SchedulePanel extends BasePanel {
-  private items: ViewItem[] = [];
-  private selectedIndex = 0;
-  private scrollOffset = 0;
-  private refreshTimerId: ReturnType<typeof setInterval> | null = null;
-  private readonly automationManager: ScheduleAutomationManager;
-
-  constructor(automationManager: ScheduleAutomationManager, private readonly requestRender: () => void = () => {}) {
-    super('schedule', 'Schedule', 'Z', 'agent');
-    this.automationManager = automationManager;
-  }
-
-  private _markDirtyAndRender(): void {
-    this.markDirty();
-    this.requestRender();
-  }
-
-  // -------------------------------------------------------------------------
-  // Lifecycle
-  // -------------------------------------------------------------------------
-
-  override onActivate(): void {
-    super.onActivate();
-    void this.automationManager.start().then(() => {
-      this.rebuild();
-      this._markDirtyAndRender();
-    });
-    this.rebuild();
-    this.refreshTimerId = this.registerTimer(setInterval(() => {
-      this.rebuild();
-      this._markDirtyAndRender();
-    }, 5_000));
-  }
-
-  override onDeactivate(): void {
-    if (this.refreshTimerId !== null) {
-      this.clearTimer(this.refreshTimerId);
-      this.refreshTimerId = null;
-    }
-  }
-
-  override onDestroy(): void {
-    this.onDeactivate();
-    super.onDestroy();
-  }
-
-  // -------------------------------------------------------------------------
-  // Data
-  // -------------------------------------------------------------------------
-
-  private rebuild(): void {
-    const manager = this.automationManager;
-    const tasks = manager.listJobs();
-
-    const items: ViewItem[] = [{ kind: 'header' }];
-    if (tasks.length === 0) {
-      items.push({ kind: 'empty' });
-    } else {
-      for (const task of tasks) {
-        items.push({
-          kind: 'task',
-          task,
-          history: manager.listRuns(task.id),
-        });
-      }
-    }
-    this.items = items;
-
-    if (this.selectedIndex >= this.items.length) {
-      this.selectedIndex = Math.max(0, this.items.length - 1);
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Input
-  // -------------------------------------------------------------------------
-
-  handleInput(key: string): boolean {
-    switch (key) {
-      case 'up':
-      case 'k': {
-        if (this.selectedIndex > 0) {
-          this.selectedIndex--;
-          this.markDirty();
-        }
-        return true;
-      }
-      case 'down':
-      case 'j': {
-        if (this.selectedIndex < this.items.length - 1) {
-          this.selectedIndex++;
-          this.markDirty();
-        }
-        return true;
-      }
-      case 'return':
-      case ' ': {
-        // Toggle enabled/disabled on selected task
-        const item = this.items[this.selectedIndex];
-        if (item?.kind === 'task') {
-          void this.automationManager.setEnabled(item.task.id, !item.task.enabled).then(() => {
-            this.rebuild();
-            this.markDirty();
-          });
-        }
-        return true;
-      }
-      case 'r': {
-        // Trigger immediate run of selected task
-        const item = this.items[this.selectedIndex];
-        if (item?.kind === 'task') {
-          this.automationManager.runNow(item.task.id).catch(() => {
-            // Non-fatal — error logged by scheduler
-          });
-          this.rebuild();
-          this.markDirty();
-        }
-        return true;
-      }
-      case 'R': {
-        // Refresh the view
-        this.rebuild();
-        this.markDirty();
-        return true;
-      }
-      default:
-        return false;
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Rendering
-  // -------------------------------------------------------------------------
-
-  override render(width: number, height: number): Line[] {
-    const tasks = this.automationManager.listJobs();
-    const enabled = tasks.filter((task: AutomationJob) => task.enabled).length;
-    if (tasks.length === 0) {
-      return buildPanelWorkspace(width, height, {
-        title: ' Schedule',
-        intro: 'Review recurring scheduled tasks, next run timing, recent history, and enablement state.',
-        sections: [
-          {
-            lines: buildEmptyState(
-              width,
-              ' No scheduled tasks',
-              'Create a recurring task and its next-run timing, run history, and enablement state will appear here.',
-              [
-                { command: '/schedule add cron 0 * * * * repo sweep', summary: 'create a recurring cron task' },
-                { command: '/schedule list', summary: 'inspect scheduled tasks from the shell' },
-              ],
-              DEFAULT_PANEL_PALETTE,
-            ),
-          },
-        ],
-        footerLines: [
-          buildKeyboardHints(width, [
-            { keys: '/schedule add', label: 'create a task' },
-          ], DEFAULT_PANEL_PALETTE),
-        ],
-        palette: DEFAULT_PANEL_PALETTE,
-      });
-    }
-
-    const taskItems = this.items.filter((item): item is Extract<ViewItem, { kind: 'task' }> => item.kind === 'task');
-    this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, taskItems.length - 1));
-    const dueSoon = tasks.filter((task: AutomationJob) => typeof task.nextRunAt === 'number').length;
-    const summarySection: PanelWorkspaceSection = {
-      title: 'Summary',
-      lines: [
-        buildPanelLine(width, [
-          [' Tasks ', DEFAULT_PANEL_PALETTE.label],
-          [String(tasks.length), DEFAULT_PANEL_PALETTE.value],
-          ['   Enabled ', DEFAULT_PANEL_PALETTE.label],
-          [String(enabled), enabled > 0 ? DEFAULT_PANEL_PALETTE.good : DEFAULT_PANEL_PALETTE.dim],
-          ['   Paused ', DEFAULT_PANEL_PALETTE.label],
-          [String(tasks.length - enabled), tasks.length - enabled > 0 ? DEFAULT_PANEL_PALETTE.warn : DEFAULT_PANEL_PALETTE.dim],
-          ['   Scheduled ', DEFAULT_PANEL_PALETTE.label],
-          [String(dueSoon), dueSoon > 0 ? DEFAULT_PANEL_PALETTE.info : DEFAULT_PANEL_PALETTE.dim],
-        ]),
-      ],
-    };
-    const selectedTask = taskItems[this.selectedIndex]?.task;
-    const toggleLabel = selectedTask
-      ? (selectedTask.enabled ? 'pause task' : 'enable task')
-      : 'toggle';
-    const footerLines = [
-      buildKeyboardHints(width, [
-        { keys: 'Up/Down', label: 'navigate' },
-        { keys: 'Space', label: toggleLabel },
-        { keys: 'r', label: 'run now' },
-        { keys: 'R', label: 'refresh' },
-      ], DEFAULT_PANEL_PALETTE),
-    ];
-    const scheduledTasksSection = resolveScrollablePanelSection(width, height, {
-      intro: 'Review recurring scheduled tasks, next run timing, recent history, and enablement state.',
-      footerLines,
-      palette: DEFAULT_PANEL_PALETTE,
-      beforeSections: [summarySection],
-      section: {
-        title: 'Scheduled Tasks',
-        scrollableLines: taskItems.flatMap((item, index) => this.renderTask(item.task, item.history, index === this.selectedIndex, width)),
-        selectedIndex: this.selectedIndex * 3,
-        scrollOffset: this.scrollOffset,
-        minRows: 6,
-      },
-    });
-    this.scrollOffset = scheduledTasksSection.scrollOffset;
-    const sections: PanelWorkspaceSection[] = [
-      summarySection,
-      scheduledTasksSection.section,
-    ];
-
-    return buildPanelWorkspace(width, height, {
-      title: ' Schedule',
-      intro: 'Review recurring scheduled tasks, next run timing, recent history, and enablement state.',
-      sections,
-      footerLines,
-      palette: DEFAULT_PANEL_PALETTE,
-    });
-  }
-
-  /**
-   * Render a task as 3 rows:
-   *   Row 1: [status] id  name  schedule
-   *   Row 2:          next: <date>  last: <date>  runs: N
-   *   Row 3:          prompt preview  [history]
-   */
-  private renderTask(task: AutomationJob, history: AutomationRun[], selected: boolean, width: number): Line[] {
-    const bg = selected ? C.selectBg : undefined;
-    const fgBase = selected ? C.selectedFg : undefined;
-
-    const bullet = task.enabled ? '* ' : 'o ';
-    const bulletFg = task.enabled ? C.enabled : C.disabled;
-    const nameStr = fitDisplay(task.name, 28);
-    const scheduleText = formatSchedule(task.schedule);
-    const row1 = buildPanelLine(width, [
-      [bullet, bulletFg, bg],
-      [fitDisplay(task.id, 12), fgBase ?? C.id, bg],
-      ['  ', fgBase ?? C.prompt, bg],
-      [nameStr, fgBase ?? C.prompt, bg],
-      ['  ', fgBase ?? C.prompt, bg],
-      [scheduleText, fgBase ?? C.cron, bg],
-    ]);
-
-    const indent = '    ';
-    const nextStr = task.nextRunAt
-      ? `next: ${new Date(task.nextRunAt).toLocaleString()}`
-      : 'next: unknown';
-    const lastStr = task.lastRunAt
-      ? `last: ${new Date(task.lastRunAt).toLocaleString()}`
-      : 'last: never';
-    const row2 = buildPanelLine(width, [
-      [indent, fgBase ?? C.prompt, bg],
-      [nextStr.padEnd(36), fgBase ?? C.nextRun, bg],
-      [lastStr.padEnd(32), fgBase ?? C.lastRun, bg],
-      [`runs: ${task.runCount}`, fgBase ?? C.runCount, bg],
-    ]);
-
-    const maxPromptLen = Math.max(20, width - indent.length - 30);
-    const prompt = task.execution.prompt ?? task.description ?? '';
-    const promptPreview = truncateDisplay(prompt, maxPromptLen);
-
-    // Show last 3 run statuses as colored dots
-    const recentRuns = history.slice(-3);
-    const runSegments = recentRuns.flatMap((run) => {
-      const dotFg = run.status === 'failed' ? C.statusFailed : C.statusRunning;
-      return [['\u25cf', dotFg, bg] as [string, string, string?]];
-    });
-    const row3 = buildPanelLine(width, [
-      [indent, fgBase ?? C.prompt, bg],
-      [promptPreview, fgBase ?? C.prompt, bg],
-      ...(runSegments.length > 0 ? [['  ', fgBase ?? C.prompt, bg] as [string, string, string?], ...runSegments] : []),
-    ]);
-
-    // spacer row between tasks
-    const spacer = buildPanelLine(width, [['', fgBase ?? C.prompt, bg]]);
-
-    return [row1, row2, row3, spacer];
-  }
-}

package/src/panels/watchers-panel.ts

@@ -1,213 +0,0 @@
-import type { Line } from '../types/grid.ts';
-import { createEmptyLine } from '../types/grid.ts';
-import { ScrollableListPanel } from './scrollable-list-panel.ts';
-import type { UiReadModel, UiWatchersSnapshot } from '../runtime/ui-read-models.ts';
-import { truncateDisplay } from '../utils/terminal-width.ts';
-import {
-  buildDetailBlock,
-  buildEmptyState,
-  buildGuidanceLine,
-  buildKeyValueLine,
-  buildKeyboardHints,
-  buildPanelLine,
-  buildPanelWorkspace,
-  DEFAULT_PANEL_PALETTE,
-  type PanelPalette,
-} from './polish.ts';
-
-const C = {
-  ...DEFAULT_PANEL_PALETTE,
-  header: '#94a3b8',
-  headerBg: '#1e293b',
-  ok: '#22c55e',
-  warn: '#eab308',
-  error: '#ef4444',
-  info: '#38bdf8',
-  selectBg: '#0f172a',
-} as const;
-
-function stateColor(state: string): string {
-  if (state === 'running') return C.ok;
-  if (state === 'degraded') return C.warn;
-  if (state === 'failed') return C.error;
-  return C.dim;
-}
-
-function sourceStatusColor(state?: string): string {
-  if (state === 'healthy') return C.ok;
-  if (state === 'lagging' || state === 'stale' || state === 'degraded') return C.warn;
-  if (state === 'failed') return C.error;
-  return C.dim;
-}
-
-function formatLag(value?: number): string {
-  if (!value || value <= 0) return 'n/a';
-  if (value < 1000) return `${value}ms`;
-  if (value < 60_000) return `${Math.round(value / 1000)}s`;
-  return `${Math.round(value / 60_000)}m`;
-}
-
-function formatTime(value?: number): string {
-  if (!value) return 'n/a';
-  return new Date(value).toLocaleString();
-}
-
-type WatcherEntry = UiWatchersSnapshot['watchers'][number];
-
-export class WatchersPanel extends ScrollableListPanel<WatcherEntry> {
-  private readonly readModel?: UiReadModel<UiWatchersSnapshot>;
-  private readonly unsub: (() => void) | null;
-
-  public constructor(readModel?: UiReadModel<UiWatchersSnapshot>) {
-    super('watchers', 'Watchers', 'W', 'monitoring');
-    this.showSelectionGutter = true; // I5: non-color selection affordance
-    this.filterEnabled = true;
-    this.filterLabel = 'Filter watchers';
-    this.readModel = readModel;
-    this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
-  }
-
-  protected override filterMatches(watcher: WatcherEntry, q: string): boolean {
-    return watcher.label.toLowerCase().includes(q)
-      || watcher.state.toLowerCase().includes(q)
-      || String(watcher.sourceStatus ?? '').toLowerCase().includes(q);
-  }
-
-  public override onDestroy(): void {
-    this.unsub?.();
-  }
-
-  protected override getPalette(): PanelPalette {
-    return C;
-  }
-
-  protected getItems(): readonly WatcherEntry[] {
-    if (!this.readModel) return [];
-    return this.readModel.getSnapshot().watchers;
-  }
-
-  protected renderItem(watcher: WatcherEntry, _index: number, selected: boolean, width: number): Line {
-    const bg = selected ? C.selectBg : undefined;
-    return buildPanelLine(width, [
-      [' ', C.label, bg],
-      [watcher.state.padEnd(10), stateColor(watcher.state), bg],
-      [` ${truncateDisplay(watcher.label, 18).padEnd(18)}`, C.value, bg],
-      [` ${String(watcher.sourceStatus ?? 'unknown').padEnd(10)}`, sourceStatusColor(watcher.sourceStatus), bg],
-      [` ${truncateDisplay(formatLag(watcher.sourceLagMs), Math.max(0, width - 43))}`, C.dim, bg],
-    ]);
-  }
-
-  protected override getEmptyStateMessage(): string {
-    return ' No watchers registered.';
-  }
-
-  protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
-    return [
-      { command: '/schedule list', summary: 'review automation that will consume watcher events' },
-      { command: '/services auth-review', summary: 'validate integration credentials before enabling remote watchers' },
-    ];
-  }
-
-  public render(width: number, height: number): Line[] {
-    const intro = 'Managed watchers and source health used to trigger automation, refresh routes, and surface degraded upstream conditions.';
-
-    if (!this.readModel) {
-      const workspace = buildPanelWorkspace(width, height, {
-        title: 'Watchers',
-        intro,
-        sections: [{
-          lines: buildEmptyState(
-            width,
-            ' Runtime store not wired.',
-            'This panel needs the shared runtime store to inspect watcher health and source lag.',
-            [{ command: '/services auth-review', summary: 'inspect supporting services until watcher wiring is available' }],
-            C,
-          ),
-        }],
-        palette: C,
-      });
-      while (workspace.length < height) workspace.push(createEmptyLine(width));
-      return workspace;
-    }
-
-    const snapshot = this.readModel.getSnapshot();
-    const watchers = this.getItems();
-
-    const headerLines: Line[] = [
-      buildKeyValueLine(width, [
-        { label: 'watchers', value: String(snapshot.totalWatchers), valueColor: snapshot.totalWatchers > 0 ? C.info : C.dim },
-        { label: 'active', value: String(snapshot.activeWatcherIds.length), valueColor: snapshot.activeWatcherIds.length > 0 ? C.ok : C.dim },
-        { label: 'degraded', value: String(snapshot.totalDegraded), valueColor: snapshot.totalDegraded > 0 ? C.warn : C.dim },
-        { label: 'lagged', value: String(snapshot.totalLagged), valueColor: snapshot.totalLagged > 0 ? C.warn : C.dim },
-      ], C),
-      buildGuidanceLine(width, '/schedule list', 'verify jobs consuming these sources and use daemon APIs for watcher lifecycle control', C),
-    ];
-
-    if (watchers.length === 0) {
-      return this.renderList(width, height, {
-        title: 'Watchers',
-        header: headerLines,
-        emptyMessage: ' No watchers registered.',
-      });
-    }
-
-    this.clampSelection();
-    const selected = watchers[this.selectedIndex]!;
-
-    const detailRows: Line[] = [
-      buildPanelLine(width, [
-        ['  Watcher: ', C.label],
-        [selected.label, C.value],
-        ['  Kind: ', C.label],
-        [selected.kind, C.info],
-      ]),
-      buildPanelLine(width, [
-        ['  State: ', C.label],
-        [selected.state, stateColor(selected.state)],
-        ['  Source: ', C.label],
-        [selected.source.kind, C.value],
-      ]),
-      buildPanelLine(width, [
-        ['  Source status: ', C.label],
-        [selected.sourceStatus ?? 'unknown', sourceStatusColor(selected.sourceStatus)],
-        ['  Lag: ', C.label],
-        [formatLag(selected.sourceLagMs), selected.sourceLagMs ? C.warn : C.dim],
-      ]),
-      buildPanelLine(width, [
-        ['  Heartbeat: ', C.label],
-        [formatTime(selected.lastHeartbeatAt), C.dim],
-        ['  Checkpoint: ', C.label],
-        [truncateDisplay(selected.lastCheckpoint ?? 'n/a', Math.max(0, width - 38)), C.dim],
-      ]),
-    ];
-    if (selected.degradedReason) {
-      detailRows.push(buildPanelLine(width, [
-        ['  Reason: ', C.label],
-        [truncateDisplay(selected.degradedReason, Math.max(0, width - 11)), C.warn],
-      ]));
-    }
-    if (selected.lastError) {
-      detailRows.push(buildPanelLine(width, [
-        ['  Error: ', C.label],
-        [truncateDisplay(selected.lastError, Math.max(0, width - 10)), C.error],
-      ]));
-    }
-
-    const hints = this.filterActive
-      ? [{ keys: 'type', label: 'filter' }, { keys: 'Enter', label: 'apply' }, { keys: 'Esc', label: 'clear' }]
-      : [
-          { keys: 'Up/Down', label: 'move' },
-          { keys: '/schedule list', label: 'consumers' },
-          { keys: '/', label: 'filter' },
-        ];
-
-    return this.renderList(width, height, {
-      title: 'Watchers',
-      header: headerLines,
-      footer: [
-        ...buildDetailBlock(width, `Watcher · ${selected.label}`, detailRows, C),
-        buildKeyboardHints(width, hints, C),
-      ],
-    });
-  }
-}

package/src/runtime/diagnostics/panels/panel-resources.ts

@@ -1,118 +0,0 @@
-/**
- * Panel resource diagnostics panel data provider.
- *
- * Polls the shared TUI-owned ComponentHealthMonitor and produces PanelResourceSnapshot
- * values for the diagnostics panel to render.
- */
-import type { ComponentHealthMonitor } from '../../perf/panel-health-monitor.ts';
-import type {
-  ComponentResourceEntry,
-  ComponentResourceSnapshot,
-} from '@/runtime/index.ts';
-
-const DEFAULT_POLL_INTERVAL_MS = 500;
-
-const HEALTH_ORDER: Record<string, number> = {
-  overloaded: 0,
-  warning: 1,
-  healthy: 2,
-};
-
-export class PanelResourcesPanel {
-  private readonly _pollIntervalMs: number;
-  private readonly _monitor: ComponentHealthMonitor;
-  private _current: ComponentResourceSnapshot;
-  private _timerId: ReturnType<typeof setInterval> | null = null;
-  private readonly _subscribers = new Set<() => void>();
-
-  constructor(monitor: ComponentHealthMonitor, pollIntervalMs: number = DEFAULT_POLL_INTERVAL_MS) {
-    this._monitor = monitor;
-    this._pollIntervalMs = pollIntervalMs;
-    this._current = this._buildSnapshot(Date.now());
-  }
-
-  start(): void {
-    if (this._timerId !== null) return;
-    this._timerId = setInterval(() => {
-      this._current = this._buildSnapshot(Date.now());
-      this._notify();
-    }, this._pollIntervalMs);
-  }
-
-  stop(): void {
-    if (this._timerId !== null) {
-      clearInterval(this._timerId);
-      this._timerId = null;
-    }
-  }
-
-  getSnapshot(): ComponentResourceSnapshot {
-    return this._current;
-  }
-
-  refresh(now: number = Date.now()): ComponentResourceSnapshot {
-    this._current = this._buildSnapshot(now);
-    return this._current;
-  }
-
-  subscribe(callback: () => void): () => void {
-    this._subscribers.add(callback);
-    return () => this._subscribers.delete(callback);
-  }
-
-  dispose(): void {
-    this.stop();
-    this._subscribers.clear();
-  }
-
-  private _buildSnapshot(capturedAt: number): ComponentResourceSnapshot {
-    const healthStates = this._monitor.getAllHealth();
-
-    const panels: ComponentResourceEntry[] = healthStates.map((health) => {
-      const contract = this._monitor.getContract(health.componentId);
-      return {
-        componentId: health.componentId,
-        throttleStatus: health.throttleStatus,
-        healthStatus: health.healthStatus,
-        renderP95Ms: health.renderP95Ms,
-        maxRenderMs: contract?.maxRenderMs ?? 0,
-        rendersInWindow: health.rendersInWindow,
-        maxUpdatesPerSecond: contract?.maxUpdatesPerSecond ?? 0,
-        consecutiveViolations: health.consecutiveViolations,
-        totalSuppressed: health.totalSuppressed,
-        totalPermitted: health.totalPermitted,
-        lastRenderAt: health.lastRenderAt,
-        nextAllowedAt: health.nextAllowedAt,
-      };
-    });
-
-    panels.sort((left, right) => {
-      const diff = (HEALTH_ORDER[left.healthStatus] ?? 2) - (HEALTH_ORDER[right.healthStatus] ?? 2);
-      return diff !== 0 ? diff : left.componentId.localeCompare(right.componentId);
-    });
-
-    const overloadedCount = panels.filter((panel) => panel.healthStatus === 'overloaded').length;
-    const warningCount = panels.filter((panel) => panel.healthStatus === 'warning').length;
-    const healthyCount = panels.filter((panel) => panel.healthStatus === 'healthy').length;
-    const totalSuppressed = panels.reduce((sum, panel) => sum + panel.totalSuppressed, 0);
-
-    return {
-      panels,
-      overloadedCount,
-      warningCount,
-      healthyCount,
-      totalSuppressed,
-      capturedAt,
-    };
-  }
-
-  private _notify(): void {
-    for (const callback of this._subscribers) {
-      try {
-        callback();
-      } catch {
-        // Subscriber failures must not take down diagnostics polling.
-      }
-    }
-  }
-}