@pellux/goodvibes-tui 0.18.13 → 0.18.17

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';

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

@@ -1,172 +1 @@
-import { buildMcpAttackPathReview } from '@pellux/goodvibes-sdk/platform/runtime/mcp/index';
-import type { McpDecisionRecord, McpSecuritySnapshot } from '@pellux/goodvibes-sdk/platform/runtime/mcp/types';
-import type { RuntimeServices } from './services.ts';
-import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
-import { combineSubscriptions } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-model-helpers';
-import type { SecurityPanelSnapshot } from '@pellux/goodvibes-sdk/platform/runtime/diagnostics/panels/security';
-import type { PluginStatus } from '@pellux/goodvibes-sdk/platform/plugins/manager';
-
-export interface UiMcpServerSnapshot {
-  readonly name: string;
-  readonly role: string;
-  readonly trustMode: string;
-  readonly status: string;
-  readonly schemaFreshness: string;
-  readonly toolCount: number;
-  readonly lastError?: string;
-  readonly quarantineReason?: string;
-  readonly quarantineDetail?: string;
-}
-
-export interface UiSecuritySnapshot {
-  readonly audit: SecurityPanelSnapshot;
-  readonly policy: {
-    readonly preflightStatus: string;
-    readonly preflightIssueCount: number;
-    readonly lintFindingCount: number;
-  };
-  readonly deniedPermissions: number;
-  readonly incidents: ReturnType<import('@pellux/goodvibes-sdk/platform/runtime/forensics/index').ForensicsRegistry['getAll']>;
-  readonly latestIncident: ReturnType<import('@pellux/goodvibes-sdk/platform/runtime/forensics/index').ForensicsRegistry['latest']>;
-  readonly mcpServers: readonly McpSecuritySnapshot[];
-  readonly recentMcpDecisions: readonly McpDecisionRecord[];
-  readonly attackPathReview: ReturnType<typeof buildMcpAttackPathReview>;
-  readonly plugins: readonly PluginStatus[];
-  readonly quarantinedPlugins: readonly PluginStatus[];
-  readonly untrustedPlugins: readonly PluginStatus[];
-}
-
-export interface UiMcpSnapshot {
-  readonly servers: readonly UiMcpServerSnapshot[];
-  readonly connectedServerNames: readonly string[];
-  readonly availableToolCount: number;
-  readonly totalCalls: number;
-  readonly totalErrors: number;
-  readonly recentDecisions: readonly McpDecisionRecord[];
-}
-
-export interface UiLocalAuthSnapshot {
-  readonly bootstrapCredentialPresent: boolean;
-  readonly userCount: number;
-  readonly sessionCount: number;
-}
-
-export interface UiSecurityObservabilityReadModels {
-  readonly security: UiReadModel<UiSecuritySnapshot>;
-  readonly mcp: UiReadModel<UiMcpSnapshot>;
-  readonly localAuth: UiReadModel<UiLocalAuthSnapshot>;
-}
-
-export function createSecurityObservabilityReadModels(
-  runtimeServices: RuntimeServices,
-  options: import('./ui-read-models-observability-options.ts').UiObservabilityReadModelOptions = {},
-): UiSecurityObservabilityReadModels {
-  const { runtimeStore } = runtimeServices;
-
-  return {
-    security: {
-      getSnapshot() {
-        const audit = runtimeServices.tokenAuditor.auditAll(Date.now());
-        const mcpServers = [...runtimeStore.getState().mcp.servers.values()].map((server): McpSecuritySnapshot => ({
-          name: server.name,
-          role: server.role,
-          trustMode: server.trustMode,
-          allowedPaths: server.allowedPaths,
-          allowedHosts: server.allowedHosts,
-          schemaFreshness: server.schemaFreshness,
-          quarantineReason: server.quarantineReason,
-          quarantineDetail: server.quarantineDetail,
-          connected: server.status === 'connected' || server.status === 'degraded',
-        }));
-        const recentMcpDecisions = runtimeServices.mcpRegistry.listRecentSecurityDecisions(8);
-        const attackPathReview = buildMcpAttackPathReview({
-          servers: mcpServers,
-          recentDecisions: recentMcpDecisions,
-        });
-        const plugins = runtimeServices.pluginManager.list();
-        const policySnapshot = runtimeServices.policyRuntimeState.getSnapshot();
-        const snapshot: SecurityPanelSnapshot = {
-          managed: runtimeServices.tokenAuditor.isManaged,
-          totalTokens: runtimeServices.tokenAuditor.tokenCount,
-          results: audit.results,
-          blocked: audit.blocked,
-          scopeViolations: audit.scopeViolations,
-          rotationWarnings: audit.rotationWarnings,
-          rotationOverdue: audit.rotationOverdue,
-          lastAuditAt: audit.capturedAt,
-          capturedAt: new Date().toISOString(),
-        };
-        return {
-          audit: snapshot,
-          policy: {
-            preflightStatus: policySnapshot.lastPreflightReview?.status ?? 'n/a',
-            preflightIssueCount: policySnapshot.lastPreflightReview?.issueCount ?? 0,
-            lintFindingCount: policySnapshot.lintFindings.length,
-          },
-          deniedPermissions: runtimeStore.getState().permissions.denialCount,
-          incidents: options.forensicsRegistry?.getAll() ?? [],
-          latestIncident: options.forensicsRegistry?.latest(),
-          mcpServers,
-          recentMcpDecisions,
-          attackPathReview,
-          plugins,
-          quarantinedPlugins: plugins.filter((plugin) => plugin.quarantined),
-          untrustedPlugins: plugins.filter((plugin) => plugin.trustTier === 'untrusted'),
-        };
-      },
-      subscribe(listener) {
-        const unsubs: Array<() => void> = [
-          runtimeStore.subscribe(listener),
-          runtimeServices.pluginManager.subscribe(listener),
-          runtimeServices.policyRuntimeState.subscribe(listener),
-        ];
-        if (options.forensicsRegistry) {
-          unsubs.push(options.forensicsRegistry.subscribe(listener));
-        }
-        return combineSubscriptions(...unsubs);
-      },
-    },
-    mcp: {
-      getSnapshot() {
-        const state = runtimeStore.getState().mcp;
-        const servers = [...state.servers.values()]
-          .map((server): UiMcpServerSnapshot => ({
-            name: server.name,
-            role: server.role,
-            trustMode: server.trustMode,
-            status: server.status,
-            schemaFreshness: server.schemaFreshness,
-            toolCount: server.toolCount,
-            lastError: server.lastError,
-            quarantineReason: server.quarantineReason,
-            quarantineDetail: server.quarantineDetail,
-          }))
-          .sort((a, b) => a.name.localeCompare(b.name));
-        return {
-          servers,
-          connectedServerNames: state.connectedServerNames,
-          availableToolCount: state.availableToolCount,
-          totalCalls: state.totalCalls,
-          totalErrors: state.totalErrors,
-          recentDecisions: runtimeServices.mcpRegistry.listRecentSecurityDecisions(8),
-        };
-      },
-      subscribe(listener) {
-        return runtimeStore.subscribe(listener);
-      },
-    },
-    localAuth: {
-      getSnapshot() {
-        const snapshot = runtimeServices.localUserAuthManager.inspect();
-        return {
-          bootstrapCredentialPresent: snapshot.bootstrapCredentialPresent,
-          userCount: snapshot.userCount,
-          sessionCount: snapshot.sessionCount,
-        };
-      },
-      subscribe() {
-        return () => {};
-      },
-    },
-  };
-}
+export * from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-security';

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

@@ -1,217 +1 @@
-import { buildEcosystemRecommendations, type EcosystemRecommendation } from '@pellux/goodvibes-sdk/platform/runtime/ecosystem/recommendations';
-import type { RuntimeServices } from './services.ts';
-import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
-import { combineSubscriptions, 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';
-import type { PluginStatus } from '@pellux/goodvibes-sdk/platform/plugins/manager';
-
-export interface UiIntelligenceSnapshot {
-  readonly diagnosticsStatus: string;
-  readonly symbolSearchStatus: string;
-  readonly completionsStatus: string;
-  readonly hoverStatus: string;
-  readonly errorCount: number;
-  readonly warningCount: number;
-  readonly totalRequests: number;
-  readonly avgLatencyMs: number;
-  readonly hover: {
-    readonly active: boolean;
-    readonly filePath?: string;
-  };
-  readonly diagnostics: ReadonlyMap<string, readonly import('@pellux/goodvibes-sdk/platform/runtime/store/domains/intelligence').LspDiagnostic[]>;
-}
-
-export interface UiMarketplaceSnapshot {
-  readonly startupIssues: readonly string[];
-  readonly recommendations: readonly EcosystemRecommendation[];
-}
-
-export interface UiCockpitSnapshot {
-  readonly runningTasks: number;
-  readonly blockedTasks: number;
-  readonly failedTasks: number;
-  readonly activeGraphs: number;
-  readonly guardTrips: number;
-  readonly blockedMessages: number;
-  readonly pendingPermissions: number;
-  readonly deniedPermissions: number;
-  readonly preflightStatus: string;
-  readonly preflightIssueCount: number;
-  readonly lintFindingCount: number;
-  readonly tokenBlockedCount: number;
-  readonly tokenRotationOverdueCount: number;
-  readonly tokenScopeViolationCount: number;
-  readonly tokenRotationWarningCount: number;
-  readonly incidentCount: number;
-  readonly latestIncident: ReturnType<import('@pellux/goodvibes-sdk/platform/runtime/forensics/index').ForensicsRegistry['latest']>;
-  readonly elevatedMcp: number;
-  readonly unhealthyMcp: number;
-  readonly erroredPlugins: number;
-  readonly failingIntegrations: number;
-  readonly taskCount: number;
-  readonly agentCount: number;
-  readonly totalGraphs: number;
-  readonly communicationCount: number;
-  readonly mcpServerCount: number;
-  readonly pluginCount: number;
-}
-
-export interface UiHealthSnapshot {
-  readonly degradedDomains: readonly string[];
-  readonly providerProblems: readonly string[];
-  readonly degradedMcpServers: readonly string[];
-  readonly quarantinedMcpServers: readonly string[];
-  readonly integrationProblems: readonly string[];
-  readonly daemonTransportState: string;
-  readonly acpTransportState: string;
-  readonly recoveryState: string;
-}
-
-export interface UiSystemObservabilityReadModels {
-  readonly intelligence: UiReadModel<UiIntelligenceSnapshot>;
-  readonly marketplace: UiReadModel<UiMarketplaceSnapshot>;
-  readonly cockpit: UiReadModel<UiCockpitSnapshot>;
-  readonly health: UiReadModel<UiHealthSnapshot>;
-}
-
-export function createSystemObservabilityReadModels(
-  runtimeServices: RuntimeServices,
-  options: import('./ui-read-models-observability-options.ts').UiObservabilityReadModelOptions = {},
-): UiSystemObservabilityReadModels {
-  const { runtimeStore } = runtimeServices;
-
-  return {
-    intelligence: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState().intelligence;
-      return {
-        diagnosticsStatus: state.diagnosticsStatus,
-        symbolSearchStatus: state.symbolSearchStatus,
-        completionsStatus: state.completionsStatus,
-        hoverStatus: state.hoverStatus,
-        errorCount: state.errorCount,
-        warningCount: state.warningCount,
-        totalRequests: state.totalRequests,
-        avgLatencyMs: state.avgLatencyMs,
-        hover: {
-          active: state.hover.active,
-          filePath: state.hover.filePath,
-        },
-        diagnostics: state.diagnostics,
-      };
-    }),
-    marketplace: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState();
-      const startupIssues: string[] = [];
-      if (state.permissions.denialCount >= 3) {
-        startupIssues.push(`${state.permissions.denialCount} permission denials suggest a policy-pack or trust posture review.`);
-      }
-      const authRequiredServers = [...state.mcp.servers.values()].filter((server) => server.status === 'auth_required');
-      if (authRequiredServers.length > 0) {
-        startupIssues.push(`${authRequiredServers.length} MCP server${authRequiredServers.length === 1 ? '' : 's'} need auth or reconnect repair.`);
-      }
-      const staleSchemas = [...state.mcp.servers.values()].filter((server) => server.schemaFreshness !== 'fresh');
-      if (staleSchemas.length > 0) {
-        startupIssues.push(`${staleSchemas.length} MCP server schema${staleSchemas.length === 1 ? ' is' : 's are'} stale or quarantined.`);
-      }
-      return {
-        startupIssues,
-        recommendations: buildEcosystemRecommendations(runtimeStore, {
-          cwd: runtimeServices.shellPaths.workingDirectory,
-          homeDir: runtimeServices.shellPaths.homeDirectory,
-        }),
-      };
-    }),
-    cockpit: {
-      getSnapshot() {
-        const state = runtimeStore.getState();
-        const runningTasks = [...state.tasks.tasks.values()].filter((task) => task.status === 'running').length;
-        const blockedTasks = [...state.tasks.tasks.values()].filter((task) => task.status === 'blocked').length;
-        const failedTasks = [...state.tasks.tasks.values()].filter((task) => task.status === 'failed').length;
-        const audit = runtimeServices.tokenAuditor.auditAll();
-        const incidents = options.forensicsRegistry?.getAll() ?? [];
-        const plugins = runtimeServices.pluginManager.list();
-        const failingIntegrations = [...state.integrations.integrations.values()].filter((record) => record.status === 'error').length;
-        const elevatedMcp = [...state.mcp.servers.values()].filter((server) => server.trustMode === 'allow-all').length;
-        const unhealthyMcp = [...state.mcp.servers.values()].filter((server) => (
-          server.status === 'degraded'
-          || server.status === 'auth_required'
-          || server.status === 'reconnecting'
-          || server.status === 'disconnected'
-        )).length;
-        const preflight = runtimeServices.policyRuntimeState.getSnapshot().lastPreflightReview;
-        const lintFindingCount = runtimeServices.policyRuntimeState.getSnapshot().lintFindings.length;
-        return {
-          runningTasks,
-          blockedTasks,
-          failedTasks,
-          activeGraphs: state.orchestration.activeGraphIds.length,
-          guardTrips: state.orchestration.recursionGuardTrips,
-          blockedMessages: state.communication.totalBlocked,
-          pendingPermissions: state.permissions.awaitingDecision ? 1 : 0,
-          deniedPermissions: state.permissions.denialCount,
-          preflightStatus: preflight?.status ?? 'n/a',
-          preflightIssueCount: preflight?.issueCount ?? 0,
-          lintFindingCount,
-          tokenBlockedCount: audit.blocked.length,
-          tokenRotationOverdueCount: audit.rotationOverdue.length,
-          tokenScopeViolationCount: audit.scopeViolations.length,
-          tokenRotationWarningCount: audit.rotationWarnings.length,
-          incidentCount: incidents.length,
-          latestIncident: options.forensicsRegistry?.latest(),
-          elevatedMcp,
-          unhealthyMcp,
-          erroredPlugins: plugins.filter((plugin) => plugin.quarantined || !plugin.active).length,
-          failingIntegrations,
-          taskCount: state.tasks.tasks.size,
-          agentCount: state.agents.agents.size,
-          totalGraphs: state.orchestration.totalGraphs,
-          communicationCount: state.communication.records.size,
-          mcpServerCount: state.mcp.servers.size,
-          pluginCount: plugins.length,
-        };
-      },
-      subscribe(listener) {
-        const unsubs: Array<() => void> = [runtimeStore.subscribe(listener)];
-        if (options.forensicsRegistry) {
-          unsubs.push(options.forensicsRegistry.subscribe(listener));
-        }
-        return combineSubscriptions(...unsubs);
-      },
-    },
-    health: createStoreBackedReadModel(runtimeServices, () => {
-      const state = runtimeStore.getState();
-      const providerProblems = [...state.providerHealth.providers.values()]
-        .filter((provider) => provider.status !== 'healthy' && provider.status !== 'unknown')
-        .map((provider) => provider.providerId);
-      const degradedMcpServers = [...state.mcp.servers.values()]
-        .filter((server) => server.status === 'degraded' || server.status === 'auth_required' || server.schemaFreshness === 'quarantined')
-        .map((server) => server.name);
-      const quarantinedMcpServers = [...state.mcp.servers.values()]
-        .filter((server) => server.schemaFreshness === 'quarantined')
-        .map((server) => server.name);
-      const degradedDomains: string[] = [];
-      if (providerProblems.length > 0) degradedDomains.push('providerHealth');
-      if (degradedMcpServers.length > 0) degradedDomains.push('mcp');
-      if (state.integrations.problemIds.length > 0) degradedDomains.push('integrations');
-      if (state.daemon.transportState === 'degraded' || state.daemon.transportState === 'terminal_failure') degradedDomains.push('daemon');
-      if (state.acp.managerTransportState === 'degraded' || state.acp.managerTransportState === 'terminal_failure') degradedDomains.push('acp');
-      if (state.session.recoveryState === 'failed') degradedDomains.push('session');
-      return {
-        degradedDomains,
-        providerProblems,
-        degradedMcpServers,
-        quarantinedMcpServers,
-        integrationProblems: state.integrations.problemIds,
-        daemonTransportState: state.daemon.transportState,
-        acpTransportState: state.acp.managerTransportState,
-        recoveryState: state.session.recoveryState,
-      };
-    }),
-  };
-}
+export * from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-system';

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

@@ -1,59 +1 @@
-export type { UiObservabilityReadModelOptions } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-options';
-export type {
-  UiRemoteSnapshot,
-  UiRemoteReadModels,
-} from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-remote';
-export type {
-  UiIntelligenceSnapshot,
-  UiMarketplaceSnapshot,
-  UiCockpitSnapshot,
-  UiHealthSnapshot,
-  UiSystemObservabilityReadModels,
-} from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-system';
-export type {
-  UiSecuritySnapshot,
-  UiMcpServerSnapshot,
-  UiMcpSnapshot,
-  UiLocalAuthSnapshot,
-  UiSecurityObservabilityReadModels,
-} from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-security';
-export type {
-  UiSettingsSnapshot,
-  UiContinuitySnapshot,
-  UiWorktreeSnapshot,
-  UiMaintenanceObservabilityReadModels,
-} from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-maintenance';
-
-import type { RuntimeServices } from './services.ts';
-import { createRemoteReadModels, type UiRemoteReadModels } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-remote';
-import {
-  createSystemObservabilityReadModels,
-  type UiSystemObservabilityReadModels,
-} from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-system';
-import {
-  createSecurityObservabilityReadModels,
-  type UiSecurityObservabilityReadModels,
-} from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-security';
-import {
-  createMaintenanceObservabilityReadModels,
-  type UiMaintenanceObservabilityReadModels,
-} from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-maintenance';
-import type { UiObservabilityReadModelOptions } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability-options';
-
-export interface UiObservabilityReadModels
-  extends UiRemoteReadModels,
-    UiSystemObservabilityReadModels,
-    UiSecurityObservabilityReadModels,
-    UiMaintenanceObservabilityReadModels {}
-
-export function createObservabilityReadModels(
-  runtimeServices: RuntimeServices,
-  options: UiObservabilityReadModelOptions = {},
-): UiObservabilityReadModels {
-  return {
-    ...createRemoteReadModels(runtimeServices),
-    ...createSystemObservabilityReadModels(runtimeServices, options),
-    ...createSecurityObservabilityReadModels(runtimeServices, options),
-    ...createMaintenanceObservabilityReadModels(runtimeServices),
-  };
-}
+export * from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-observability';