@pellux/goodvibes-tui 0.18.4

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

@@ -0,0 +1,217 @@
+import { buildEcosystemRecommendations, type EcosystemRecommendation } from './ecosystem/recommendations.ts';
+import type { RuntimeServices } from './services.ts';
+import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
+import { combineSubscriptions, createStoreBackedReadModel } from './ui-read-model-helpers.ts';
+import type {
+  ContinuitySnapshot as IntegrationContinuitySnapshot,
+  SettingsSnapshot as IntegrationSettingsSnapshot,
+  WorktreeSnapshot as IntegrationWorktreeSnapshot,
+} from './integration/helpers.ts';
+import type { SessionReturnContextSummary } from './session-return-context.ts';
+import type { ManagedWorktreeMeta } from './worktree/registry.ts';
+import type { PluginStatus } from '../plugins/manager.ts';
+
+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('./forensics/index.ts').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,
+      };
+    }),
+  };
+}

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

@@ -0,0 +1,59 @@
+export type { UiObservabilityReadModelOptions } from './ui-read-models-observability-options.ts';
+export type {
+  UiRemoteSnapshot,
+  UiRemoteReadModels,
+} from './ui-read-models-observability-remote.ts';
+export type {
+  UiIntelligenceSnapshot,
+  UiMarketplaceSnapshot,
+  UiCockpitSnapshot,
+  UiHealthSnapshot,
+  UiSystemObservabilityReadModels,
+} from './ui-read-models-observability-system.ts';
+export type {
+  UiSecuritySnapshot,
+  UiMcpServerSnapshot,
+  UiMcpSnapshot,
+  UiLocalAuthSnapshot,
+  UiSecurityObservabilityReadModels,
+} from './ui-read-models-observability-security.ts';
+export type {
+  UiSettingsSnapshot,
+  UiContinuitySnapshot,
+  UiWorktreeSnapshot,
+  UiMaintenanceObservabilityReadModels,
+} from './ui-read-models-observability-maintenance.ts';
+
+import type { RuntimeServices } from './services.ts';
+import { createRemoteReadModels, type UiRemoteReadModels } from './ui-read-models-observability-remote.ts';
+import {
+  createSystemObservabilityReadModels,
+  type UiSystemObservabilityReadModels,
+} from './ui-read-models-observability-system.ts';
+import {
+  createSecurityObservabilityReadModels,
+  type UiSecurityObservabilityReadModels,
+} from './ui-read-models-observability-security.ts';
+import {
+  createMaintenanceObservabilityReadModels,
+  type UiMaintenanceObservabilityReadModels,
+} from './ui-read-models-observability-maintenance.ts';
+import type { UiObservabilityReadModelOptions } from './ui-read-models-observability-options.ts';
+
+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),
+  };
+}

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

@@ -0,0 +1,203 @@
+import type { ControlPlaneRecentEvent, SharedApprovalRecord, SharedSessionRecord } from '../control-plane/index.ts';
+import type { RuntimeServices } from './services.ts';
+import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
+import type { AutomationRun } from '@pellux/goodvibes-sdk/platform/automation/runs';
+import type { AutomationRouteBinding } from '@pellux/goodvibes-sdk/platform/automation/routes';
+import type { WatcherRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/watchers';
+import type { OrchestrationGraphRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/orchestration';
+import type { RuntimeCommunicationRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/communication';
+import type { ControlPlaneClientRecord } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/control-plane';
+import type { AcpConnection } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/acp';
+import { combineSubscriptions, createStoreBackedReadModel } from './ui-read-model-helpers.ts';
+import type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
+
+export interface UiAutomationSnapshot {
+  readonly jobs: readonly AutomationJob[];
+  readonly runs: readonly AutomationRun[];
+  readonly totalJobs: number;
+  readonly totalRuns: number;
+  readonly activeRunIds: readonly string[];
+  readonly totalFailed: number;
+  readonly sourceCount: number;
+  readonly deliveryTotals: {
+    readonly succeeded: number;
+    readonly failed: number;
+    readonly deadLettered: number;
+  };
+}
+
+export interface UiRoutesSnapshot {
+  readonly bindings: readonly AutomationRouteBinding[];
+  readonly bindingIdsBySurface: Readonly<Record<string, readonly string[]>>;
+  readonly totalBindings: number;
+  readonly activeBindingIds: readonly string[];
+  readonly totalResolved: number;
+  readonly totalFailures: number;
+}
+
+export interface UiWatchersSnapshot {
+  readonly watchers: readonly WatcherRecord[];
+  readonly totalWatchers: number;
+  readonly activeWatcherIds: readonly string[];
+  readonly totalDegraded: number;
+  readonly totalLagged: number;
+}
+
+export interface UiOrchestrationSnapshot {
+  readonly graphs: readonly OrchestrationGraphRecord[];
+  readonly totalGraphs: number;
+  readonly activeGraphIds: readonly string[];
+  readonly totalCompletedGraphs: number;
+  readonly totalFailedGraphs: number;
+  readonly recursionGuardTrips: number;
+}
+
+export interface UiCommunicationSnapshot {
+  readonly records: readonly RuntimeCommunicationRecord[];
+  readonly totalSent: number;
+  readonly totalDelivered: number;
+  readonly totalBlocked: number;
+}
+
+export interface UiControlPlaneSnapshot {
+  readonly connectionState: string;
+  readonly activeClientIds: readonly string[];
+  readonly requestCount: number;
+  readonly errorCount: number;
+  readonly host: string;
+  readonly port: number;
+  readonly clients: readonly ControlPlaneClientRecord[];
+  readonly approvals: readonly SharedApprovalRecord[];
+  readonly sessions: readonly SharedSessionRecord[];
+  readonly recentEvents: readonly ControlPlaneRecentEvent[];
+}
+
+export interface UiOperationsReadModels {
+  readonly automation: UiReadModel<UiAutomationSnapshot>;
+  readonly routes: UiReadModel<UiRoutesSnapshot>;
+  readonly watchers: UiReadModel<UiWatchersSnapshot>;
+  readonly orchestration: UiReadModel<UiOrchestrationSnapshot>;
+  readonly communication: UiReadModel<UiCommunicationSnapshot>;
+  readonly controlPlane: UiReadModel<UiControlPlaneSnapshot>;
+}
+
+export interface UiOperationsReadModelOptions {
+  readonly getControlPlaneRecentEvents?: (limit: number) => readonly ControlPlaneRecentEvent[];
+}
+
+export function createOperationsReadModels(
+  runtimeServices: RuntimeServices,
+  options: UiOperationsReadModelOptions = {},
+): UiOperationsReadModels {
+  const { runtimeStore } = runtimeServices;
+
+  return {
+    automation: createStoreBackedReadModel(runtimeServices, () => {
+      const state = runtimeStore.getState();
+      const jobs = state.automation.jobIds
+        .map((id) => state.automation.jobs.get(id))
+        .filter((job): job is AutomationJob => job !== undefined)
+        .sort((a, b) => (b.nextRunAt ?? 0) - (a.nextRunAt ?? 0) || a.name.localeCompare(b.name));
+      const runs = state.automation.runIds
+        .map((id) => state.automation.runs.get(id))
+        .filter((run): run is AutomationRun => run !== undefined)
+        .sort((a, b) => b.queuedAt - a.queuedAt || a.id.localeCompare(b.id));
+      return {
+        jobs,
+        runs,
+        totalJobs: state.automation.totalJobs,
+        totalRuns: state.automation.totalRuns,
+        activeRunIds: state.automation.activeRunIds,
+        totalFailed: state.automation.totalFailed,
+        sourceCount: state.automation.sourceIds.length,
+        deliveryTotals: {
+          succeeded: state.deliveries.totalSucceeded,
+          failed: state.deliveries.totalFailed,
+          deadLettered: state.deliveries.totalDeadLettered,
+        },
+      };
+    }),
+    routes: createStoreBackedReadModel(runtimeServices, () => {
+      const state = runtimeStore.getState().routes;
+      const bindings = state.bindingIds
+        .map((id) => state.bindings.get(id))
+        .filter((binding): binding is AutomationRouteBinding => binding !== undefined)
+        .sort((a, b) => b.lastSeenAt - a.lastSeenAt || a.id.localeCompare(b.id));
+      return {
+        bindings,
+        bindingIdsBySurface: state.bindingIdsBySurface,
+        totalBindings: state.totalBindings,
+        activeBindingIds: state.activeBindingIds,
+        totalResolved: state.totalResolved,
+        totalFailures: state.totalFailures,
+      };
+    }),
+    watchers: createStoreBackedReadModel(runtimeServices, () => {
+      const state = runtimeStore.getState().watchers;
+      const watchers = state.watcherIds
+        .map((id) => state.watchers.get(id))
+        .filter((watcher): watcher is WatcherRecord => watcher !== undefined)
+        .sort((a, b) => (b.lastHeartbeatAt ?? 0) - (a.lastHeartbeatAt ?? 0) || a.id.localeCompare(b.id));
+      return {
+        watchers,
+        totalWatchers: state.watcherIds.length,
+        activeWatcherIds: state.activeWatcherIds,
+        totalDegraded: state.totalDegraded,
+        totalLagged: state.totalLagged,
+      };
+    }),
+    orchestration: createStoreBackedReadModel(runtimeServices, () => {
+      const state = runtimeStore.getState().orchestration;
+      const graphs = [...state.graphs.values()].sort((a, b) => b.createdAt - a.createdAt);
+      return {
+        graphs,
+        totalGraphs: state.totalGraphs,
+        activeGraphIds: state.activeGraphIds,
+        totalCompletedGraphs: state.totalCompletedGraphs,
+        totalFailedGraphs: state.totalFailedGraphs,
+        recursionGuardTrips: state.recursionGuardTrips,
+      };
+    }),
+    communication: createStoreBackedReadModel(runtimeServices, () => {
+      const state = runtimeStore.getState().communication;
+      const records = state.recentRecordIds
+        .map((id) => state.records.get(id))
+        .filter((record): record is RuntimeCommunicationRecord => record !== undefined)
+        .sort((a, b) => b.timestamp - a.timestamp);
+      return {
+        records,
+        totalSent: state.totalSent,
+        totalDelivered: state.totalDelivered,
+        totalBlocked: state.totalBlocked,
+      };
+    }),
+    controlPlane: {
+      getSnapshot() {
+        const state = runtimeStore.getState().controlPlane;
+        const clients = state.clientIds
+          .map((id) => state.clients.get(id))
+          .filter((client): client is ControlPlaneClientRecord => client !== undefined)
+          .sort((a, b) => (b.lastSeenAt ?? 0) - (a.lastSeenAt ?? 0) || a.id.localeCompare(b.id));
+        return {
+          connectionState: state.connectionState,
+          activeClientIds: state.activeClientIds,
+          requestCount: state.requestCount,
+          errorCount: state.errorCount,
+          host: state.host,
+          port: state.port,
+          clients,
+          approvals: runtimeServices.approvalBroker.listApprovals(6),
+          sessions: runtimeServices.sessionBroker.listSessions(6),
+          recentEvents: options.getControlPlaneRecentEvents?.(6) ?? [],
+        };
+      },
+      subscribe(listener) {
+        const unsubs = [
+          runtimeStore.subscribe(listener),
+          runtimeServices.approvalBroker.subscribe(listener),
+        ];
+        return combineSubscriptions(...unsubs);
+      },
+    },
+  };
+}

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

@@ -0,0 +1,61 @@
+export type { UiReadModel } from '@pellux/goodvibes-sdk/platform/runtime/ui-read-models-base';
+export type {
+  UiCoreReadModels,
+  UiProvidersSnapshot,
+  UiSessionSnapshot,
+  UiAgentsSnapshot,
+  UiTasksSnapshot,
+} from './ui-read-models-core.ts';
+export type {
+  UiOperationsReadModels,
+  UiAutomationSnapshot,
+  UiRoutesSnapshot,
+  UiWatchersSnapshot,
+  UiOrchestrationSnapshot,
+  UiCommunicationSnapshot,
+  UiControlPlaneSnapshot,
+} from './ui-read-models-operations.ts';
+export type {
+  UiObservabilityReadModels,
+  UiRemoteSnapshot,
+  UiIntelligenceSnapshot,
+  UiMarketplaceSnapshot,
+  UiCockpitSnapshot,
+  UiSecuritySnapshot,
+  UiHealthSnapshot,
+  UiMcpServerSnapshot,
+  UiMcpSnapshot,
+  UiLocalAuthSnapshot,
+  UiSettingsSnapshot,
+  UiContinuitySnapshot,
+  UiWorktreeSnapshot,
+} from './ui-read-models-observability.ts';
+export type { UiObservabilityReadModelOptions } from './ui-read-models-observability-options.ts';
+
+import type { RuntimeServices } from './services.ts';
+import { createCoreReadModels, type UiCoreReadModels } from './ui-read-models-core.ts';
+import {
+  createOperationsReadModels,
+  type UiOperationsReadModels,
+  type UiOperationsReadModelOptions,
+} from './ui-read-models-operations.ts';
+import {
+  createObservabilityReadModels,
+  type UiObservabilityReadModels,
+  type UiObservabilityReadModelOptions,
+} from './ui-read-models-observability.ts';
+
+export type UiReadModelOptions = UiOperationsReadModelOptions & UiObservabilityReadModelOptions;
+
+export type UiReadModels = UiCoreReadModels & UiOperationsReadModels & UiObservabilityReadModels;
+
+export function createUiReadModels(
+  runtimeServices: RuntimeServices,
+  options: UiReadModelOptions = {},
+): UiReadModels {
+  return {
+    ...createCoreReadModels(runtimeServices),
+    ...createOperationsReadModels(runtimeServices, options),
+    ...createObservabilityReadModels(runtimeServices, options),
+  };
+}

package/src/runtime/ui-service-queries.ts

@@ -0,0 +1,114 @@
+import type {
+  ServiceConfig,
+  ServiceConnectionTestResult,
+  ServiceInspection,
+} from '../config/service-registry.ts';
+import type {
+  PendingSubscriptionLogin,
+  ProviderSubscription,
+} from '@pellux/goodvibes-sdk/platform/config/subscriptions';
+import type { LocalAuthSnapshot } from '@pellux/goodvibes-sdk/platform/security/user-auth';
+import type { SessionInfo } from '../sessions/manager.ts';
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { ModelDefinition } from '../providers/registry.ts';
+import type {
+  ProviderApi,
+  ProviderRuntimeSnapshot,
+} from '../providers/provider-api.ts';
+import type { ExecutionPlan } from '@pellux/goodvibes-sdk/platform/core/execution-plan';
+import type { PlannerDecision, ExecutionStrategy } from '@pellux/goodvibes-sdk/platform/core/adaptive-planner';
+
+export interface EnvironmentVariableQuery {
+  hasEnvironmentVariable(name: string): boolean;
+}
+
+export interface ServiceInspectionQuery {
+  getAll(): Record<string, ServiceConfig>;
+  inspect(name: string): Promise<ServiceInspection | null>;
+  testConnection(name: string): Promise<ServiceConnectionTestResult>;
+}
+
+export interface SubscriptionAccessQuery {
+  list(): ProviderSubscription[];
+  listPending(): PendingSubscriptionLogin[];
+  get(provider: string): ProviderSubscription | null;
+  getPending(provider: string): PendingSubscriptionLogin | null;
+  getAccessToken(provider: string): string | null;
+  logout(provider: string): void;
+}
+
+export interface LocalAuthInspectionQuery {
+  inspect(): LocalAuthSnapshot;
+}
+
+export interface SessionBrowserQuery {
+  list(): SessionInfo[];
+  search(query: string): Array<{ session: SessionInfo; matchCount: number; snippets: string[] }>;
+  delete(name: string): void;
+}
+
+export interface SessionMemoryQuery {
+  list(): readonly unknown[];
+}
+
+export interface ToolCatalogQuery {
+  list(): Tool[];
+}
+
+export interface ProviderModelCatalogQuery {
+  listModels(): ModelDefinition[];
+}
+
+export interface ProviderAccountInspectionQuery {
+  readonly providerModels: ProviderModelCatalogQuery;
+  readonly services: Pick<ServiceInspectionQuery, 'getAll' | 'inspect'>;
+  readonly subscriptions: Pick<SubscriptionAccessQuery, 'list' | 'listPending' | 'get' | 'getPending'>;
+  readonly environment: EnvironmentVariableQuery;
+}
+
+export interface ProviderRuntimeInspectionQuery {
+  listProviderIds(): readonly string[];
+  inspectAll(): Promise<readonly ProviderRuntimeSnapshot[]>;
+  inspect(providerId: string): Promise<ProviderRuntimeSnapshot | null>;
+}
+
+export interface PlanDashboardQuery {
+  getActive(): ExecutionPlan | null;
+}
+
+export interface OpsStrategyQuery {
+  getLatest(): PlannerDecision | null;
+  getMode(): ExecutionStrategy;
+  getOverride(): ExecutionStrategy | null;
+  getHistory(limit?: number): PlannerDecision[];
+}
+
+export function createEnvironmentVariableQuery(
+  environment: Readonly<Record<string, string | undefined>>,
+): EnvironmentVariableQuery {
+  return {
+    hasEnvironmentVariable(name: string): boolean {
+      return Boolean(environment[name]);
+    },
+  };
+}
+
+export function createProviderRuntimeInspectionQuery(
+  providers: Pick<ProviderApi, 'listProviderIds' | 'queryRuntimeMetadata'>,
+): ProviderRuntimeInspectionQuery {
+  return {
+    listProviderIds(): readonly string[] {
+      return providers.listProviderIds();
+    },
+
+    async inspectAll(): Promise<readonly ProviderRuntimeSnapshot[]> {
+      const result = await providers.queryRuntimeMetadata({ scope: 'all' });
+      return result.scope === 'all' ? result.snapshots : [];
+    },
+
+    async inspect(providerId: string): Promise<ProviderRuntimeSnapshot | null> {
+      const result = await providers.queryRuntimeMetadata({ scope: 'provider', providerId });
+      return result.scope === 'provider' ? result.snapshot : null;
+    },
+  };
+}