@pellux/goodvibes-agent 1.4.4 → 1.5.1

package/src/panels/automation-control-panel.ts

@@ -1,212 +0,0 @@
-import type { Line } from '../types/grid.ts';
-import { createEmptyLine } from '../types/grid.ts';
-import { ScrollableListPanel } from './scrollable-list-panel.ts';
-import type { UiAutomationSnapshot, UiReadModel } from '../runtime/ui-read-models.ts';
-import { truncateDisplay } from '../utils/terminal-width.ts';
-import {
-  buildEmptyState,
-  buildGuidanceLine,
-  buildKeyValueLine,
-  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 formatTime(value?: number): string {
-  if (!value) return 'n/a';
-  return new Date(value).toLocaleString();
-}
-
-function runStatusColor(status: string): string {
-  if (status === 'completed') return C.ok;
-  if (status === 'failed' || status === 'dead_lettered') return C.error;
-  if (status === 'cancelled') return C.warn;
-  return C.info;
-}
-
-type AutomationRun = UiAutomationSnapshot['runs'][number];
-type AutomationJob = UiAutomationSnapshot['jobs'][number];
-
-export class AutomationControlPanel extends ScrollableListPanel<AutomationRun> {
-  private readonly readModel?: UiReadModel<UiAutomationSnapshot>;
-  private readonly unsub: (() => void) | null;
-
-  public constructor(readModel?: UiReadModel<UiAutomationSnapshot>) {
-    super('automation', 'Automation', 'M', 'monitoring');
-    this.showSelectionGutter = true; // I5: non-color selection affordance
-    this.readModel = readModel;
-    this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
-  }
-
-  public override onDestroy(): void {
-    this.unsub?.();
-  }
-
-  protected override getPalette(): PanelPalette {
-    return C;
-  }
-
-  private getJobs(): readonly AutomationJob[] {
-    if (!this.readModel) return [];
-    return this.readModel.getSnapshot().jobs;
-  }
-
-  protected getItems(): readonly AutomationRun[] {
-    if (!this.readModel) return [];
-    return this.readModel.getSnapshot().runs;
-  }
-
-  protected renderItem(run: AutomationRun, _index: number, selected: boolean, width: number): Line {
-    const bg = selected ? C.selectBg : undefined;
-    const jobs = this.getJobs();
-    const name = jobs.find((job) => job.id === run.jobId)?.name ?? run.jobId;
-    return buildPanelLine(width, [
-      [' ', C.label, bg],
-      [run.status.padEnd(11), runStatusColor(run.status), bg],
-      [` ${truncateDisplay(name, 22).padEnd(22)}`, C.value, bg],
-      [` ${truncateDisplay(run.target.kind, 12).padEnd(12)}`, C.info, bg],
-      [` ${truncateDisplay(formatTime(run.queuedAt), Math.max(0, width - 49))}`, C.dim, bg],
-    ]);
-  }
-
-  protected override getEmptyStateMessage(): string {
-    return ' No automation activity recorded.';
-  }
-
-  protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
-    return [
-      { command: '/schedule list', summary: 'inspect jobs and run history without mutating schedules' },
-      { command: '/schedule receipts', summary: 'review Agent routine promotion receipts' },
-    ];
-  }
-
-  public render(width: number, height: number): Line[] {
-    const intro = 'Automation jobs, active runs, deliveries, and failure posture across the shared runtime.';
-
-    if (!this.readModel) {
-      const workspace = buildPanelWorkspace(width, height, {
-        title: 'Automation Control',
-        intro,
-        sections: [{
-          lines: buildEmptyState(
-            width,
-            ' Connected-host automation state is unavailable.',
-            'This operator view is read-only. Use /schedule list for compact transcript output; automation stays unchanged.',
-            [{ command: '/schedule list', summary: 'review automation without starting hidden work' }],
-            C,
-          ),
-        }],
-        palette: C,
-      });
-      while (workspace.length < height) workspace.push(createEmptyLine(width));
-      return workspace;
-    }
-
-    const snapshot = this.readModel.getSnapshot();
-    const jobs = [...snapshot.jobs];
-    const runs = this.getItems();
-
-    const headerLines: Line[] = [
-      buildKeyValueLine(width, [
-        { label: 'jobs', value: String(snapshot.totalJobs), valueColor: snapshot.totalJobs > 0 ? C.info : C.dim },
-        { label: 'runs', value: String(snapshot.totalRuns), valueColor: snapshot.totalRuns > 0 ? C.value : C.dim },
-        { label: 'active', value: String(snapshot.activeRunIds.length), valueColor: snapshot.activeRunIds.length > 0 ? C.warn : C.dim },
-        { label: 'failed', value: String(snapshot.totalFailed), valueColor: snapshot.totalFailed > 0 ? C.error : C.dim },
-      ], C),
-      buildKeyValueLine(width, [
-        { label: 'deliveries ok', value: String(snapshot.deliveryTotals.succeeded), valueColor: snapshot.deliveryTotals.succeeded > 0 ? C.ok : C.dim },
-        { label: 'delivery fail', value: String(snapshot.deliveryTotals.failed), valueColor: snapshot.deliveryTotals.failed > 0 ? C.error : C.dim },
-        { label: 'dead letters', value: String(snapshot.deliveryTotals.deadLettered), valueColor: snapshot.deliveryTotals.deadLettered > 0 ? C.warn : C.dim },
-        { label: 'sources', value: String(snapshot.sourceCount), valueColor: snapshot.sourceCount > 0 ? C.info : C.dim },
-      ], C),
-      buildGuidanceLine(width, '/schedule list', 'read-only in Agent; schedule mutation/run controls remain blocked here', C),
-    ];
-
-    if (jobs.length === 0 && runs.length === 0) {
-      return this.renderList(width, height, {
-        title: 'Automation Control',
-        header: headerLines,
-        emptyMessage: ' No automation activity recorded.',
-      });
-    }
-
-    this.clampSelection();
-    const selectedRun = runs[this.selectedIndex];
-    const jobName = selectedRun ? (jobs.find((job) => job.id === selectedRun.jobId)?.name ?? selectedRun.jobId) : 'n/a';
-
-    const footerLines: Line[] = [];
-    if (selectedRun) {
-      footerLines.push(
-        buildPanelLine(width, [
-          ['  Run: ', C.label],
-          [selectedRun.id, C.value],
-          ['  Status: ', C.label],
-          [selectedRun.status, runStatusColor(selectedRun.status)],
-        ]),
-        buildPanelLine(width, [
-          ['  Job: ', C.label],
-          [jobName, C.value],
-          ['  Agent: ', C.label],
-          [selectedRun.agentId ?? 'n/a', C.info],
-        ]),
-        buildPanelLine(width, [
-          ['  Queue: ', C.label],
-          [formatTime(selectedRun.queuedAt), C.dim],
-          ['  End: ', C.label],
-          [formatTime(selectedRun.endedAt), C.dim],
-        ]),
-        buildPanelLine(width, [
-          ['  Trigger: ', C.label],
-          [selectedRun.triggeredBy.kind, C.info],
-          ['  Target: ', C.label],
-          [selectedRun.target.kind, C.value],
-        ]),
-        buildPanelLine(width, [
-          ['  Deliveries: ', C.label],
-          [String(selectedRun.deliveryIds.length), selectedRun.deliveryIds.length > 0 ? C.info : C.dim],
-          ['  Route: ', C.label],
-          [selectedRun.routeId ?? 'n/a', C.dim],
-        ]),
-      );
-      if (selectedRun.error) {
-        footerLines.push(buildPanelLine(width, [
-          ['  Error ', C.label],
-          [truncateDisplay(selectedRun.error, Math.max(0, width - 10)), C.error],
-        ]));
-      }
-    } else {
-      footerLines.push(buildPanelLine(width, [['  No run selected.', C.dim]]));
-    }
-
-    // Jobs quick view
-    if (jobs.length > 0) {
-      footerLines.push(
-        ...jobs.slice(0, 6).map((job) => buildPanelLine(width, [
-          [' ', C.label],
-          [job.enabled ? 'ENABLED ' : 'PAUSED  ', job.enabled ? C.ok : C.warn],
-          [truncateDisplay(job.name, 24).padEnd(24), C.value],
-          [` next ${truncateDisplay(formatTime(job.nextRunAt), Math.max(0, width - 43))}`, C.dim],
-        ])),
-      );
-    }
-    footerLines.push(buildPanelLine(width, [['  Up/Down move through runs', C.dim]]));
-
-    return this.renderList(width, height, {
-      title: 'Automation Control',
-      header: headerLines,
-      footer: footerLines,
-    });
-  }
-}

package/src/panels/base-panel.ts

@@ -1,254 +0,0 @@
-import type { Line } from '../types/grid.ts';
-import type { Panel, PanelCategory } from './types.ts';
-import type { ComponentResourceContract, ComponentHealthState } from '../runtime/perf/panel-contracts.ts';
-import type { ComponentHealthMonitor } from '../runtime/perf/panel-health-monitor.ts';
-import { UIFactory } from '../renderer/ui-factory.ts';
-import { SPINNER_FRAMES } from '../renderer/progress.ts';
-
-export abstract class BasePanel implements Panel {
-  public needsRender = true;
-  public isTransient = false;
-  public isPinned = false;
-  protected readonly componentHealthMonitor?: ComponentHealthMonitor;
-
-  // -------------------------------------------------------------------------
-  // Timer registry
-  // -------------------------------------------------------------------------
-
-  /** All timers registered via registerTimer(). Cleared automatically on onDestroy(). */
-  private readonly _timers: Set<ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>> = new Set();
-
-  /**
-   * Register a timer id (from setInterval or setTimeout) so it is
-   * automatically cleared when the panel is destroyed. Returns the id
-   * unchanged so the call can be chained inline:
-   *
-   * ```ts
-   * this.registerTimer(setInterval(() => this.refresh(), 5_000));
-   * ```
-   */
-  protected registerTimer<T extends ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>>(id: T): T {
-    this._timers.add(id);
-    return id;
-  }
-
-  /**
-   * Clear a specific timer and remove it from the registry.
-   * Safe to call with an unregistered or already-cleared id.
-   */
-  protected clearTimer(id: ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>): void {
-    clearInterval(id as ReturnType<typeof setInterval>);
-    this._timers.delete(id);
-  }
-
-  // -------------------------------------------------------------------------
-  // I2: Error surface slot
-  // -------------------------------------------------------------------------
-
-  /**
-   * Last error message to surface in the panel footer.
-   * Auto-cleared on the next keystroke by `ScrollableListPanel.handleInput()` (and any
-   * subclass that calls `super.handleInput()` or manually calls `this.clearError()` at
-   * the start of its handler). BasePanel itself does NOT auto-clear — only subclasses
-   * that opt into the contract do.
-   */
-  protected lastError: string | null = null;
-
-  /**
-   * Set a transient error message. Triggers a re-render.
-   * The error will be auto-cleared on the next keystroke if the panel extends
-   * `ScrollableListPanel` (which calls `clearError()` at the top of `handleInput()`).
-   */
-  protected setError(msg: string): void {
-    this.lastError = msg;
-    this.needsRender = true;
-  }
-
-  /** Clear the current error. */
-  protected clearError(): void {
-    this.lastError = null;
-  }
-
-  /**
-   * Build a single error Line for display above the hints footer.
-   * Returns null when there is no active error.
-   *
-   * Color: bold red foreground (palette-consistent: #ef4444).
-   */
-  protected renderErrorLine(width: number): Line | null {
-    if (!this.lastError) return null;
-    return UIFactory.stringToLine(
-      ` ✕ ${this.lastError}`.padEnd(width).slice(0, width),
-      width,
-      { fg: '#ef4444', bold: true },
-    );
-  }
-
-  // -------------------------------------------------------------------------
-  // I3: Loading spinner slot
-  // -------------------------------------------------------------------------
-
-  /** Tracks the loading label for the spinner (undefined = no spinner active). */
-  protected loadingState: 'idle' | 'loading' | 'error' = 'idle';
-  private _loadingLabel = '';
-
-  /** Begin loading. Triggers a re-render. */
-  protected startLoading(label = 'Loading...'): void {
-    this.loadingState = 'loading';
-    this._loadingLabel = label;
-    this.needsRender = true;
-  }
-
-  /** End loading (returns to idle). Triggers a re-render. */
-  protected stopLoading(): void {
-    this.loadingState = 'idle';
-    this._loadingLabel = '';
-    this.needsRender = true;
-  }
-
-  /**
-   * Run an async operation with the panel's loading spinner visible.
-   * The spinner is always cleared on completion, whether the operation succeeds or throws
-   * (uses try/finally). Rethrows any error so callers can handle it or forward to setError.
-   *
-   * @param label Optional label shown next to the spinner.
-   * @param fn    The async work to run.
-   *
-   * @example
-   * ```ts
-   * try {
-   *   await this.withLoading('Loading diff…', () => this.fetchDiff());
-   * } catch (err) {
-   *   this.setError(summarizeError(err));
-   * }
-   * ```
-   */
-  protected async withLoading<T>(label: string | undefined, fn: () => Promise<T>): Promise<T> {
-    this.startLoading(label);
-    try {
-      return await fn();
-    } finally {
-      this.stopLoading();
-    }
-  }
-
-  /**
-   * Build a spinner Line for the loading state.
-   * Returns null when loadingState is not 'loading'.
-   *
-   * @param width  Panel width in columns.
-   * @param frame  Current animation frame index (caller increments each render).
-   */
-  protected renderLoadingLine(width: number, frame = 0): Line | null {
-    if (this.loadingState !== 'loading') return null;
-    const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length] ?? SPINNER_FRAMES[0]!;
-    const text = ` ${spinner} ${this._loadingLabel}`;
-    return UIFactory.stringToLine(text.padEnd(width).slice(0, width), width, { fg: '135', bold: true });
-  }
-
-  /**
-   * Optional resource contract for this panel.
-   * Override in subclasses to declare a custom contract; leave undefined
-   * to use the category default enforced by ComponentHealthMonitor.
-   */
-  public resourceContract: Readonly<ComponentResourceContract> | undefined = undefined;
-
-  /**
-   * Live health state populated by ComponentHealthMonitor.
-   * Read-only from outside the monitor.
-   */
-  public get healthState(): Readonly<ComponentHealthState> | undefined {
-    return this.componentHealthMonitor?.getHealth(this.id);
-  }
-
-  constructor(
-    public readonly id: string,
-    public readonly name: string,
-    public readonly icon: string,
-    public readonly category: PanelCategory,
-    componentHealthMonitor?: ComponentHealthMonitor,
-  ) {
-    this.componentHealthMonitor = componentHealthMonitor;
-  }
-
-  onActivate(): void { this.needsRender = true; }
-  onDeactivate(): void {}
-
-  /**
-   * Called when the panel is permanently removed. Subclasses should call
-   * `super.onDestroy()` to ensure all registered timers are cleared.
-   */
-  onDestroy(): void {
-    for (const id of this._timers) {
-      clearInterval(id as ReturnType<typeof setInterval>);
-    }
-    this._timers.clear();
-  }
-
-  abstract render(width: number, height: number): Line[];
-
-  /** R2: Mark this panel dirty — it will be re-rendered on the next compositor frame. */
-  public invalidate(): void { this.needsRender = true; }
-
-  /** R2: Called by the compositor after a successful render to clear the dirty flag. */
-  public markRendered(): void { this.needsRender = false; }
-
-  protected markDirty(): void { this.needsRender = true; }
-
-  /**
-   * Check whether the panel is currently permitted to render.
-   *
-   * Consults the shared ComponentHealthMonitor. Returns true if not registered
-   * (unthrottled) or if the monitor permits a render at this moment.
-   *
-   * Call this inside render() or before invoking render() to skip
-   * expensive work when throttled:
-   *
-   * ```ts
-   * render(width, height): Line[] {
-   *   if (!this.canRenderNow()) return this._lastLines ?? [];
-   *   // ... expensive render ...
-   * }
-   * ```
-   */
-  protected canRenderNow(now: number = Date.now()): boolean {
-    return this.componentHealthMonitor?.canRender(this.id, now) ?? true;
-  }
-
-  /**
-   * Report the duration of a completed render to the health monitor.
-   * Call this at the end of render() after measuring wall-clock cost.
-   */
-  protected reportRenderDuration(durationMs: number, now: number = Date.now()): void {
-    this.componentHealthMonitor?.recordRender(this.id, durationMs, now);
-  }
-
-  /** Cache of the most recent lines produced by trackedRender. */
-  private _lastTrackedLines: Line[] = [];
-
-  /**
-   * Wrap a render body with canRenderNow throttle check, wall-clock timing,
-   * and automatic reportRenderDuration.
-   *
-   * When throttled, returns the previously cached lines (stale but correctly
-   * sized) rather than empty lines, avoiding a flicker on every skipped frame.
-   *
-   * Usage:
-   * ```ts
-   * render(width: number, height: number): Line[] {
-   *   return this.trackedRender(() => {
-   *     // expensive render logic
-   *     return lines;
-   *   });
-   * }
-   * ```
-   */
-  protected trackedRender(fn: () => Line[]): Line[] {
-    if (!this.canRenderNow()) return this._lastTrackedLines;
-    const start = Date.now();
-    const lines = fn();
-    this.reportRenderDuration(Date.now() - start);
-    this._lastTrackedLines = lines;
-    return lines;
-  }
-}

package/src/panels/builtin/agent.ts

@@ -1,58 +0,0 @@
-import type { PanelManager } from '../panel-manager.ts';
-import { ContextVisualizerPanel } from '../context-visualizer-panel.ts';
-import { ThinkingPanel } from '../thinking-panel.ts';
-import { ToolInspectorPanel } from '../tool-inspector-panel.ts';
-import { SchedulePanel } from '../schedule-panel.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-import { requireAutomationManager, requireUiServices } from './shared.ts';
-
-export function registerAgentPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  manager.registerType({
-    id: 'thinking',
-    name: 'Thinking',
-    icon: 'T',
-    category: 'ai',
-    description: 'Stream model reasoning tokens in real-time with collapsible blocks per turn',
-    preload: true,
-    factory: () => new ThinkingPanel(requireUiServices(deps).events.turns),
-  });
-
-  manager.registerType({
-    id: 'tools',
-    name: 'Tools',
-    icon: 'X',
-    category: 'ai',
-    description: 'Chronological tool call inspector with expandable args/results and filtering',
-    preload: true,
-    factory: () => {
-      const ui = requireUiServices(deps);
-      return new ToolInspectorPanel(ui.events.tools, ui.events.turns);
-    },
-  });
-
-  manager.registerType({
-    id: 'context',
-    name: 'Context',
-    icon: 'C',
-    category: 'ai',
-    description: 'Context window visualizer: stacked bar showing token usage per section',
-    preload: true,
-    factory: () => new ContextVisualizerPanel(
-      requireUiServices(deps).events.turns,
-      deps.sessionMemoryStore,
-      deps.configManager,
-      deps.getOrchestratorUsage,
-      deps.contextWindow,
-      requireUiServices(deps).readModels.session,
-    ),
-  });
-
-  manager.registerType({
-    id: 'schedule',
-    name: 'Schedule',
-    icon: 'Z',
-    category: 'agent',
-    description: 'Read-only schedule posture from the connected GoodVibes host; Agent-local schedule mutation is blocked',
-    factory: () => new SchedulePanel(requireAutomationManager(deps)),
-  });
-}

package/src/panels/builtin/knowledge.ts

@@ -1,26 +0,0 @@
-import type { PanelManager } from '../panel-manager.ts';
-import { MemoryPanel } from '../memory-panel.ts';
-import { KnowledgePanel } from '../knowledge-panel.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-
-export function registerKnowledgePanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  if (!deps.memoryRegistry) return;
-
-  const { agentKnowledgeService, memoryRegistry } = deps;
-  manager.registerType({
-    id: 'knowledge',
-    name: 'Knowledge',
-    icon: 'K',
-    category: 'agent',
-    description: 'Isolated Agent Knowledge plus local non-secret memory review',
-    factory: () => new KnowledgePanel(memoryRegistry, agentKnowledgeService ?? null),
-  });
-  manager.registerType({
-    id: 'memory',
-    name: 'Memory',
-    icon: 'M',
-    category: 'agent',
-    description: 'Project memory: decisions, constraints, incidents, and patterns with provenance links',
-    factory: () => new MemoryPanel(memoryRegistry),
-  });
-}

package/src/panels/builtin/operations.ts

@@ -1,121 +0,0 @@
-import type { PanelManager } from '../panel-manager.ts';
-import { ApprovalPanel } from '../approval-panel.ts';
-import { AutomationControlPanel } from '../automation-control-panel.ts';
-import { SubscriptionPanel } from '../subscription-panel.ts';
-import { ProviderAccountsPanel } from '../provider-accounts-panel.ts';
-import { SecurityPanel } from '../security-panel.ts';
-import { TasksPanel } from '../tasks-panel.ts';
-import { ProviderStatsPanel } from '../provider-stats-panel.ts';
-import { ProviderHealthPanel } from '../provider-health-panel.ts';
-import { createProviderAccountSnapshotQuery } from '../provider-account-snapshot.ts';
-import {
-  createEnvironmentVariableQuery,
-  createProviderRuntimeInspectionQuery,
-} from '../../runtime/ui-service-queries.ts';
-import { createRuntimeProviderApi } from '@/runtime/index.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-import { requireUiServices } from './shared.ts';
-
-export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  const ui = requireUiServices(deps);
-  const providerRuntime = createProviderRuntimeInspectionQuery(createRuntimeProviderApi({
-    benchmarkStore: ui.providers.benchmarkStore,
-    favoritesStore: ui.providers.favoritesStore,
-    providerRegistry: ui.providers.providerRegistry,
-  }));
-  const providerAccounts = createProviderAccountSnapshotQuery({
-    providerModels: deps.providerRegistry,
-    services: deps.serviceRegistry,
-    subscriptions: deps.subscriptionManager,
-    environment: createEnvironmentVariableQuery(process.env),
-  });
-
-  manager.registerType({
-    id: 'approval',
-    name: 'Approval',
-    icon: 'A',
-    category: 'monitoring',
-    description: 'Action-specific approval workspace for why-prompted, why-denied, and what-if review',
-    factory: () => new ApprovalPanel(deps.policyRuntimeState),
-  });
-
-  manager.registerType({
-    id: 'automation',
-    name: 'Automation',
-    icon: 'M',
-    category: 'monitoring',
-    description: 'Read-only automation jobs, runs, deliveries, and failure posture from the connected GoodVibes host',
-    factory: () => new AutomationControlPanel(ui.readModels.automation),
-  });
-
-  manager.registerType({
-    id: 'subscription',
-    name: 'Subscriptions',
-    icon: 'B',
-    category: 'monitoring',
-    description: 'OAuth-backed provider subscriptions and supported provider override posture',
-    factory: () => new SubscriptionPanel(deps.serviceRegistry, deps.subscriptionManager),
-  });
-
-  manager.registerType({
-    id: 'accounts',
-    name: 'Accounts',
-    icon: 'Q',
-    category: 'monitoring',
-    description: 'Provider auth routes, subscription quota-window hints, and billing-path safety notes',
-    factory: () => new ProviderAccountsPanel({ providerAccounts }),
-  });
-
-  manager.registerType({
-    id: 'security',
-    name: 'Security',
-    icon: 'U',
-    category: 'monitoring',
-    description: 'Security review workspace for token posture, policy posture, MCP quarantine, and incident pressure',
-    factory: () => new SecurityPanel(ui.readModels.security),
-  });
-
-  manager.registerType({
-    id: 'tasks',
-    name: 'Tasks',
-    icon: 'J',
-    category: 'monitoring',
-    description: 'Queued, running, blocked, failed, and completed task summaries from the connected GoodVibes host',
-    factory: () => new TasksPanel(ui.readModels.tasks),
-  });
-
-  manager.registerType({
-    id: 'providers',
-    name: 'Providers',
-    icon: 'R',
-    category: 'monitoring',
-    description: 'Per-provider performance metrics: latency, error rate, request count, sparkline trends',
-    factory: () => new ProviderStatsPanel(ui.events.turns, ui.events.providers, deps.requestRender, ui.readModels.providers),
-  });
-
-  manager.registerType({
-    id: 'provider-health',
-    name: 'Health',
-    icon: 'N',
-    category: 'monitoring',
-    description: 'Provider health dashboard: real-time status, latency, errors, and rate-limit cooldowns',
-    preload: true,
-    factory: () => new ProviderHealthPanel(
-      providerRuntime,
-      {
-        configManager: deps.configManager,
-        turnEvents: ui.events.turns,
-        providerEvents: ui.events.providers,
-        providers: ui.readModels.providers,
-        session: ui.readModels.session,
-        security: ui.readModels.security,
-        localAuth: ui.readModels.localAuth,
-        settings: ui.readModels.settings,
-        remote: ui.readModels.remote,
-        continuity: ui.readModels.continuity,
-      },
-      deps.requestRender,
-    ),
-  });
-
-}