@pellux/goodvibes-tui 0.18.12 → 0.18.17

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

@@ -0,0 +1,118 @@
+/**
+ * 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 '@pellux/goodvibes-sdk/platform/runtime/diagnostics/types';
+
+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.
+      }
+    }
+  }
+}

package/src/runtime/perf/panel-contracts.ts

@@ -0,0 +1,32 @@
+/**
+ * Panel resource contracts — backward-compat shim.
+ *
+ * Re-exports the SDK's component contract types and helpers. TUI code that
+ * previously used local `ComponentResourceContract` / `ComponentHealthState`
+ * types (with `panelId`) now uses the SDK types (with `componentId`).
+ *
+ * Backward-compat aliases are re-exported:
+ *   - `PanelResourceContract` = `Omit<ComponentResourceContract,'componentId'> & { panelId }`
+ *   - `PanelHealthState`      = `Omit<ComponentHealthState,'componentId'> & { panelId }`
+ *
+ * These keep TUI-internal code that still uses `.panelId` compiling while
+ * the broader migration to `.componentId` proceeds.
+ */
+
+export type {
+  ComponentThrottleStatus,
+  ComponentHealthStatus,
+  ComponentResourceContract,
+  ComponentHealthState,
+  PanelThrottleStatus,
+  PanelHealthStatus,
+  PanelResourceContract,
+  PanelHealthState,
+} from '@pellux/goodvibes-sdk/platform/runtime/perf/component-contracts';
+
+export {
+  CATEGORY_CONTRACTS,
+  buildContract,
+  createInitialComponentHealthState,
+  createInitialPanelHealthState,
+} from '@pellux/goodvibes-sdk/platform/runtime/perf/component-contracts';

package/src/runtime/perf/panel-health-monitor.ts

@@ -0,0 +1,18 @@
+/**
+ * Panel health monitor — backward-compat shim.
+ *
+ * Re-exports the SDK's ComponentHealthMonitor so that the TUI and the SDK
+ * share a single class declaration. This eliminates the TypeScript nominal
+ * incompatibility that arises from two classes having separate `private`
+ * field declarations with the same name.
+ *
+ * All call-sites that previously imported the TUI-local ComponentHealthMonitor
+ * now receive the SDK's canonical class without any behavioral change —
+ * the public API is identical (register/deregister/canRender/recordRender/
+ * getHealth/getAllHealth/getContract/resetHealth).
+ */
+
+export {
+  ComponentHealthMonitor,
+  PanelHealthMonitor,
+} from '@pellux/goodvibes-sdk/platform/runtime/perf/component-health-monitor';

package/src/runtime/services.ts

@@ -1,7 +1,7 @@
 import { join } from 'node:path';
 import { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
 import { SecretsManager } from '../config/secrets.ts';
-import { ServiceRegistry } from '../config/service-registry.ts';
+import { ServiceRegistry } from '@pellux/goodvibes-sdk/platform/config/service-registry';
 import { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config/subscriptions';
 import { AutomationDeliveryManager, AutomationManager, AutomationRouteStore } from '@pellux/goodvibes-sdk/platform/automation/index';
 import { ChannelPluginRegistry, ChannelPolicyManager, RouteBindingManager, SurfaceRegistry } from '@pellux/goodvibes-sdk/platform/channels/index';
@@ -62,7 +62,7 @@ import { ProjectIndex } from '@pellux/goodvibes-sdk/platform/state/project-index
 import { IdempotencyStore } from '@pellux/goodvibes-sdk/platform/runtime/idempotency/index';
 import { OverflowHandler } from '@pellux/goodvibes-sdk/platform/tools/shared/overflow';
 import { ToolLLM } from '@pellux/goodvibes-sdk/platform/config/tool-llm';
-import { PanelHealthMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/panel-health-monitor';
+import { ComponentHealthMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/component-health-monitor';
 import { WorktreeRegistry } from '@pellux/goodvibes-sdk/platform/runtime/worktree/registry';
 import { SandboxSessionRegistry } from '@pellux/goodvibes-sdk/platform/runtime/sandbox/session-registry';
 import { createShellPathService, type ShellPathService } from '@pellux/goodvibes-sdk/platform/runtime/shell-paths';
@@ -133,7 +133,7 @@ export interface RuntimeServices {
   readonly channelPolicy: ChannelPolicyManager;
   readonly mcpRegistry: McpRegistry;
   readonly tokenAuditor: ApiTokenAuditor;
-  readonly panelHealthMonitor: PanelHealthMonitor;
+  readonly componentHealthMonitor: ComponentHealthMonitor;
   readonly worktreeRegistry: WorktreeRegistry;
   readonly sandboxSessionRegistry: SandboxSessionRegistry;
   readonly webhookNotifier: WebhookNotifier;
@@ -393,7 +393,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   mcpRegistry.setRuntimeBus(options.runtimeBus);
   mcpRegistry.setSandboxRuntime(configManager, sandboxSessionRegistry);
   const tokenAuditor = new ApiTokenAuditor({ managed: false });
-  const panelHealthMonitor = new PanelHealthMonitor();
+  const componentHealthMonitor = new ComponentHealthMonitor();
   const worktreeRegistry = new WorktreeRegistry(workingDirectory);
   const webhookNotifier = new WebhookNotifier();
   const replayEngine = new DeterministicReplayEngine(workingDirectory);
@@ -511,7 +511,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     channelPolicy,
     mcpRegistry,
     tokenAuditor,
-    panelHealthMonitor,
+    componentHealthMonitor,
     worktreeRegistry,
     sandboxSessionRegistry,
     webhookNotifier,

package/src/runtime/store/domains/domain-read-matrix.ts

@@ -1,7 +1,5 @@
 export const DOMAINS = [
-  'conversation',
   'panels',
-  'permissions',
   'ui-perf',
 ] as const;
 

package/src/runtime/store/selectors/index.ts

@@ -53,9 +53,9 @@ export function selectOverlays(state: RuntimeState): OverlayDomainState {
   return state.overlays;
 }
 
-/** Select the full panels domain slice. */
+/** Select the full panels domain slice. Casts from Record<string,unknown> to PanelDomainState. */
 export function selectPanels(state: RuntimeState): PanelDomainState {
-  return state.panels;
+  return state.panels as unknown as PanelDomainState;
 }
 
 /** Select the full permissions domain slice. */
@@ -123,11 +123,14 @@ export function selectIntelligence(state: RuntimeState): IntelligenceDomainState
   return state.intelligence;
 }
 
-/** Select the full UI performance domain slice. */
+/** Select the full surface/UI performance domain slice. */
 export function selectUiPerf(state: RuntimeState): UiPerfDomainState {
-  return state.uiPerf;
+  return state.surfacePerf;
 }
 
+/** Select the full surface performance domain slice (SDK-compatible alias). */
+export const selectSurfacePerf = selectUiPerf;
+
 // ---------------------------------------------------------------------------
 // Derived selectors
 // ---------------------------------------------------------------------------
@@ -271,7 +274,8 @@ export function selectPermissionMode(state: RuntimeState): PermissionMode {
  */
 export function selectActivePanels(state: RuntimeState): PanelState[] {
   const result: PanelState[] = [];
-  for (const panel of state.panels.panels.values()) {
+  const panelDomain = state.panels as unknown as PanelDomainState;
+  for (const panel of panelDomain.panels.values()) {
     if (panel.open) {
       result.push(panel);
     }
@@ -283,7 +287,8 @@ export function selectActivePanels(state: RuntimeState): PanelState[] {
  * Returns the panel currently holding focus.
  */
 export function selectFocusedPanel(state: RuntimeState): PanelState | undefined {
-  return state.panels.panels.get(state.panels.focusedPanelId);
+  const panelDomain = state.panels as unknown as PanelDomainState;
+  return panelDomain.panels.get(panelDomain.focusedPanelId);
 }
 
 /**

package/src/runtime/store/state.ts

@@ -33,6 +33,9 @@ import type { GitDomainState } from '@pellux/goodvibes-sdk/platform/runtime/stor
 import type { DiscoveryDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/discovery';
 import type { IntelligenceDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/intelligence';
 import type { UiPerfDomainState } from './domains/ui-perf.ts';
+// UiPerfDomainState is structurally identical to SDK's SurfacePerfDomainState.
+// Export as SurfacePerfDomainState alias for SDK compatibility.
+export type { UiPerfDomainState };
 
 import { createInitialSessionState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/session';
 import { createInitialModelState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/model';
@@ -73,7 +76,11 @@ export interface RuntimeState {
   model: ModelDomainState;
   conversation: ConversationDomainState;
   overlays: OverlayDomainState;
-  panels: PanelDomainState;
+  /**
+   * TUI panel state. Typed as Record<string,unknown> for SDK RuntimeState
+   * compatibility. Use selectPanels() which casts to PanelDomainState.
+   */
+  panels: Record<string, unknown>;
   permissions: PermissionDomainState;
   tasks: TaskDomainState;
   agents: AgentDomainState;
@@ -95,7 +102,8 @@ export interface RuntimeState {
   git: GitDomainState;
   discovery: DiscoveryDomainState;
   intelligence: IntelligenceDomainState;
-  uiPerf: UiPerfDomainState;
+  /** Surface/UI performance metrics. SDK-compatible field name. */
+  surfacePerf: UiPerfDomainState;
 }
 
 /**
@@ -110,7 +118,7 @@ export function createInitialRuntimeState(): RuntimeState {
     model: createInitialModelState(),
     conversation: createInitialConversationState(),
     overlays: createInitialOverlaysState(),
-    panels: createInitialPanelsState(),
+    panels: createInitialPanelsState() as unknown as Record<string, unknown>,
     permissions: createInitialPermissionsState(),
     tasks: createInitialTasksState(),
     agents: createInitialAgentsState(),
@@ -132,6 +140,6 @@ export function createInitialRuntimeState(): RuntimeState {
     git: createInitialGitState(),
     discovery: createInitialDiscoveryState(),
     intelligence: createInitialIntelligenceState(),
-    uiPerf: createInitialUiPerfState(),
+    surfacePerf: createInitialUiPerfState(),
   };
 }

package/src/runtime/ui-events.ts

@@ -0,0 +1 @@
+export * from '@pellux/goodvibes-sdk/platform/runtime/ui-events';

package/src/runtime/ui-read-model-helpers.ts

@@ -1,32 +1 @@
-import type { RuntimeServices } from './services.ts';
-import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
-
-export function combineSubscriptions(...teardowns: Array<() => void>): () => void {
-  return () => {
-    for (const teardown of teardowns) {
-      teardown();
-    }
-  };
-}
-
-export function createStoreBackedReadModel<TSnapshot>(
-  runtimeServices: RuntimeServices,
-  getSnapshot: () => TSnapshot,
-): UiReadModel<TSnapshot> {
-  return {
-    getSnapshot,
-    subscribe(listener) {
-      return runtimeServices.runtimeStore.subscribe(listener);
-    },
-  };
-}
-
-export function listProviderIds(runtimeServices: RuntimeServices): readonly string[] {
-  const providerIds = new Set<string>(
-    runtimeServices.providerRegistry.listProviders().map((provider) => provider.name),
-  );
-  for (const model of runtimeServices.providerRegistry.listModels()) {
-    providerIds.add(model.provider);
-  }
-  return [...providerIds].sort();
-}
+export * from '@pellux/goodvibes-sdk/platform/runtime/ui-read-model-helpers';

package/src/runtime/ui-read-models-observability-maintenance.ts

@@ -1,81 +1 @@
-import type { RuntimeServices } from './services.ts';
-import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
-import { createStoreBackedReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-model-helpers';
-import type {
-  ContinuitySnapshot as IntegrationContinuitySnapshot,
-  SettingsSnapshot as IntegrationSettingsSnapshot,
-  WorktreeSnapshot as IntegrationWorktreeSnapshot,
-} from '@pellux/goodvibes-sdk/platform/runtime/integration/helpers';
-import type { SessionReturnContextSummary } from '@pellux/goodvibes-sdk/platform/runtime/session-return-context';
-import type { ManagedWorktreeMeta } from '@pellux/goodvibes-sdk/platform/runtime/worktree/registry';
-
-export interface UiSettingsSnapshot {
-  readonly available: boolean;
-  readonly conflictCount: number;
-  readonly recentFailureCount: number;
-  readonly managedLockCount: number;
-  readonly hasStagedManagedBundle: boolean;
-}
-
-export interface UiContinuitySnapshot {
-  readonly sessionId: string;
-  readonly status: string;
-  readonly recoveryState: string;
-  readonly lastSessionPointer: string | null;
-  readonly recoveryFilePresent: boolean;
-  readonly recoveryFile: Record<string, unknown> | null;
-  readonly returnContext?: SessionReturnContextSummary;
-}
-
-export interface UiWorktreeSnapshot {
-  readonly summary: {
-    readonly total: number;
-    readonly active: number;
-    readonly paused: number;
-    readonly cleanupPending: number;
-    readonly discard: number;
-  };
-  readonly records: readonly ManagedWorktreeMeta[];
-}
-
-export interface UiMaintenanceObservabilityReadModels {
-  readonly settings: UiReadModel<UiSettingsSnapshot>;
-  readonly continuity: UiReadModel<UiContinuitySnapshot>;
-  readonly worktrees: UiReadModel<UiWorktreeSnapshot>;
-}
-
-export function createMaintenanceObservabilityReadModels(runtimeServices: RuntimeServices): UiMaintenanceObservabilityReadModels {
-  return {
-    settings: {
-      getSnapshot() {
-        const snapshot = runtimeServices.integrationHelpers.getSettingsSnapshot() as IntegrationSettingsSnapshot;
-        return {
-          available: snapshot.available,
-          conflictCount: snapshot.available ? snapshot.conflicts.length : 0,
-          recentFailureCount: snapshot.available ? snapshot.recentFailures.length : 0,
-          managedLockCount: snapshot.available ? snapshot.managedLockCount : 0,
-          hasStagedManagedBundle: snapshot.available ? Boolean(snapshot.stagedManagedBundle) : false,
-        };
-      },
-      subscribe() {
-        return () => {};
-      },
-    },
-    continuity: createStoreBackedReadModel(runtimeServices, () => {
-      const snapshot = runtimeServices.integrationHelpers.getContinuitySnapshot() as IntegrationContinuitySnapshot;
-      return snapshot;
-    }),
-    worktrees: {
-      getSnapshot() {
-        const snapshot = runtimeServices.integrationHelpers.getWorktreeSnapshot() as IntegrationWorktreeSnapshot;
-        return {
-          summary: snapshot.summary,
-          records: snapshot.records,
-        };
-      },
-      subscribe() {
-        return () => {};
-      },
-    },
-  };
-}
+export * from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-maintenance';

package/src/runtime/ui-read-models-observability-options.ts

@@ -1,5 +1 @@
-import type { ForensicsRegistry } from '@pellux/goodvibes-sdk/platform/runtime/forensics/index';
-
-export interface UiObservabilityReadModelOptions {
-  readonly forensicsRegistry?: ForensicsRegistry;
-}
+export * from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-options';

package/src/runtime/ui-read-models-observability-remote.ts

@@ -1,73 +1 @@
-import type { RuntimeServices } from './services.ts';
-import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
-import { createStoreBackedReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-model-helpers';
-import type { RemoteSupervisorSnapshot } from '@pellux/goodvibes-sdk/platform/runtime/remote/supervisor';
-import type { DistributedPendingWork, DistributedPeerRecord, DistributedRuntimePairRequest } from '@pellux/goodvibes-sdk/platform/runtime/remote/distributed-runtime-types';
-
-export interface UiRemoteSnapshot {
-  readonly daemon: {
-    readonly transportState: string;
-    readonly isRunning: boolean;
-    readonly reconnectAttempts: number;
-    readonly runningJobCount: number;
-    readonly lastError?: string;
-  };
-  readonly acp: {
-    readonly transportState: string;
-    readonly totalMessages: number;
-    readonly activeConnections: readonly import('@pellux/goodvibes-sdk/platform/runtime/store/domains/acp').AcpConnection[];
-  };
-  readonly pools: ReturnType<RuntimeServices['remoteRunnerRegistry']['listPools']>;
-  readonly contracts: ReturnType<RuntimeServices['remoteRunnerRegistry']['listContracts']>;
-  readonly artifacts: ReturnType<RuntimeServices['remoteRunnerRegistry']['listArtifacts']>;
-  readonly supervisor: RemoteSupervisorSnapshot;
-  readonly distributed: {
-    readonly pairRequests: readonly DistributedRuntimePairRequest[];
-    readonly peers: readonly DistributedPeerRecord[];
-    readonly work: readonly DistributedPendingWork[];
-  };
-}
-
-export interface UiRemoteReadModels {
-  readonly remote: UiReadModel<UiRemoteSnapshot>;
-}
-
-export function createRemoteReadModels(runtimeServices: RuntimeServices): UiRemoteReadModels {
-  const { runtimeStore } = runtimeServices;
-
-  return {
-    remote: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState();
-      const distributedRaw = runtimeServices.distributedRuntime.getSnapshot() as {
-        pairRequests?: readonly DistributedRuntimePairRequest[];
-        peers?: readonly DistributedPeerRecord[];
-        work?: readonly DistributedPendingWork[];
-      };
-      return {
-        daemon: {
-          transportState: state.daemon.transportState,
-          isRunning: state.daemon.isRunning,
-          reconnectAttempts: state.daemon.reconnectAttempts,
-          runningJobCount: state.daemon.runningJobCount,
-          lastError: state.daemon.lastError,
-        },
-        acp: {
-          transportState: state.acp.managerTransportState,
-          totalMessages: state.acp.totalMessages,
-          activeConnections: state.acp.activeConnectionIds
-            .map((id) => state.acp.connections.get(id))
-            .filter((connection): connection is import('@pellux/goodvibes-sdk/platform/runtime/store/domains/acp').AcpConnection => connection !== undefined),
-        },
-        pools: runtimeServices.remoteRunnerRegistry.listPools(),
-        contracts: runtimeServices.remoteRunnerRegistry.listContracts(),
-        artifacts: runtimeServices.remoteRunnerRegistry.listArtifacts(),
-        supervisor: runtimeServices.remoteSupervisor.getSnapshot(runtimeStore),
-        distributed: {
-          pairRequests: distributedRaw.pairRequests ?? [],
-          peers: distributedRaw.peers ?? [],
-          work: distributedRaw.work ?? [],
-        },
-      };
-    }),
-  };
-}
+export * from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-remote';