@pellux/goodvibes-tui 0.18.12 → 0.18.13

package/src/runtime/store/helpers/reducers/lifecycle.ts

@@ -1,440 +1 @@
-import type { CompactionEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/compaction';
-import type { PermissionEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/permissions';
-import type { TaskEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/tasks';
-import type { AgentEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/agents';
-import type { OrchestrationEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/orchestration';
-import type { SessionDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/session';
-import type {
-  PermissionDomainState,
-  PermissionDecisionMachineState,
-  PermissionDecision,
-} from '@pellux/goodvibes-sdk/platform/runtime/store/domains/permissions';
-import type { TaskDomainState, RuntimeTask, TaskLifecycleState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
-import type { AgentDomainState, RuntimeAgent, AgentLifecycleState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/agents';
-import type {
-  OrchestrationDomainState,
-  OrchestrationGraphRecord,
-  OrchestrationNodeRecord,
-} from '@pellux/goodvibes-sdk/platform/runtime/store/domains/orchestration';
-import type { PermissionCategory } from '@pellux/goodvibes-sdk/platform/permissions/manager';
-import { now, uniq, updateDomainMetadata } from '@pellux/goodvibes-sdk/platform/runtime/store/helpers/reducers/shared';
-
-function permissionMachineStateForEvent(event: PermissionEvent): PermissionDecisionMachineState {
-  switch (event.type) {
-    case 'PERMISSION_REQUESTED':
-      return 'collect_rules';
-    case 'RULES_COLLECTED':
-      return 'normalize_input';
-    case 'INPUT_NORMALIZED':
-      return 'evaluate_policy';
-    case 'POLICY_EVALUATED':
-      return 'evaluate_runtime_mode';
-    case 'MODE_EVALUATED':
-      return 'evaluate_session_override';
-    case 'SESSION_OVERRIDE_EVALUATED':
-      return 'final_safety_checks';
-    case 'SAFETY_CHECKED':
-    case 'DECISION_EMITTED':
-      return 'decision_emitted';
-  }
-}
-
-function inferPermissionCategory(toolName: string): PermissionCategory {
-  if (toolName === 'agent' || toolName === 'delegate') return 'delegate';
-  if (toolName === 'write' || toolName === 'edit' || toolName === 'apply_patch') return 'write';
-  if (toolName === 'exec' || toolName === 'precision_exec' || toolName === 'bash') return 'execute';
-  return 'read';
-}
-
-export function updateSessionState(
-  domain: SessionDomainState,
-  event: CompactionEvent,
-): SessionDomainState {
-  const base = updateDomainMetadata(domain, event.type);
-  switch (event.type) {
-    case 'COMPACTION_CHECK':
-      return { ...base, compactionState: 'checking_threshold' };
-    case 'COMPACTION_MICROCOMPACT':
-      return { ...base, compactionState: 'microcompact' };
-    case 'COMPACTION_COLLAPSE':
-      return { ...base, compactionState: 'collapse', compactionMessageCount: event.messageCount };
-    case 'COMPACTION_AUTOCOMPACT':
-      return { ...base, compactionState: 'autocompact' };
-    case 'COMPACTION_REACTIVE':
-      return { ...base, compactionState: 'reactive_compact' };
-    case 'COMPACTION_BOUNDARY_COMMIT':
-      return { ...base, compactionState: 'boundary_commit' };
-    case 'COMPACTION_DONE':
-      return { ...base, compactionState: 'done', lastCompactedAt: now() };
-    case 'COMPACTION_FAILED':
-      return { ...base, compactionState: 'failed', recoveryError: event.error };
-    case 'COMPACTION_RESUME_REPAIR':
-      return { ...base, wasRepaired: event.repaired, recoveryState: event.safeToResume ? 'ready' : domain.recoveryState };
-    case 'COMPACTION_QUALITY_SCORE':
-    case 'COMPACTION_STRATEGY_SWITCH':
-      return base;
-  }
-}
-
-export function updatePermissionState(
-  domain: PermissionDomainState,
-  event: PermissionEvent,
-): PermissionDomainState {
-  const base = updateDomainMetadata(domain, event.type);
-  switch (event.type) {
-    case 'PERMISSION_REQUESTED':
-      return { ...base, awaitingDecision: true, decisionMachineState: permissionMachineStateForEvent(event), totalChecks: domain.totalChecks + 1 };
-    case 'RULES_COLLECTED':
-    case 'INPUT_NORMALIZED':
-    case 'POLICY_EVALUATED':
-    case 'MODE_EVALUATED':
-    case 'SESSION_OVERRIDE_EVALUATED':
-    case 'SAFETY_CHECKED':
-      return { ...base, awaitingDecision: true, decisionMachineState: permissionMachineStateForEvent(event) };
-    case 'DECISION_EMITTED':
-      return {
-        ...base,
-        awaitingDecision: false,
-        decisionMachineState: permissionMachineStateForEvent(event),
-        approvalCount: domain.approvalCount + (event.approved ? 1 : 0),
-        denialCount: domain.denialCount + (event.approved ? 0 : 1),
-        lastDecision: {
-          callId: event.callId,
-          toolName: event.tool,
-          category: inferPermissionCategory(event.tool),
-          machineState: 'decision_emitted',
-          outcome: event.approved ? 'approved' : 'denied',
-          reason: (event.reasonCode as PermissionDecision['reason']) ?? (event.approved ? 'user_approved' : 'user_denied'),
-          sourceLayer: (event.sourceLayer as PermissionDecision['sourceLayer']) ?? (event.source as PermissionDecision['sourceLayer']) ?? 'config_policy',
-          persisted: event.persisted ?? false,
-          classification: event.classification,
-          riskLevel: event.riskLevel as PermissionDecision['riskLevel'],
-          summary: event.summary,
-          decidedAt: now(),
-        },
-      };
-  }
-}
-
-function updateTaskIndexes(tasks: Map<string, RuntimeTask>) {
-  const queuedIds: string[] = [];
-  const runningIds: string[] = [];
-  const blockedIds: string[] = [];
-  for (const [taskId, task] of tasks.entries()) {
-    if (task.status === 'queued') queuedIds.push(taskId);
-    if (task.status === 'running') runningIds.push(taskId);
-    if (task.status === 'blocked') blockedIds.push(taskId);
-  }
-  return { queuedIds, runningIds, blockedIds };
-}
-
-export function updateTaskState(domain: TaskDomainState, event: TaskEvent): TaskDomainState {
-  const tasks = new Map(domain.tasks);
-  const existing = tasks.get(event.taskId);
-  const timestamp = now();
-  const task: RuntimeTask =
-    existing ??
-    {
-      id: event.taskId,
-      kind: 'agentId' in event && event.agentId ? 'agent' : 'exec',
-      title: 'description' in event ? event.description : `task:${event.taskId}`,
-      status: 'queued',
-      owner: event.agentId ?? 'runtime',
-      cancellable: true,
-      childTaskIds: [],
-      queuedAt: timestamp,
-    };
-  switch (event.type) {
-    case 'TASK_CREATED':
-      tasks.set(event.taskId, task);
-      break;
-    case 'TASK_STARTED':
-      tasks.set(event.taskId, { ...task, status: 'running', startedAt: task.startedAt ?? timestamp });
-      break;
-    case 'TASK_BLOCKED':
-      tasks.set(event.taskId, { ...task, status: 'blocked', error: event.reason });
-      break;
-    case 'TASK_PROGRESS':
-      tasks.set(event.taskId, { ...task, description: event.message ?? task.description });
-      break;
-    case 'TASK_COMPLETED':
-      tasks.set(event.taskId, { ...task, status: 'completed', endedAt: timestamp, result: { durationMs: event.durationMs } });
-      break;
-    case 'TASK_FAILED':
-      tasks.set(event.taskId, { ...task, status: 'failed', endedAt: timestamp, error: event.error });
-      break;
-    case 'TASK_CANCELLED':
-      tasks.set(event.taskId, { ...task, status: 'cancelled', endedAt: timestamp, error: event.reason });
-      break;
-  }
-  const indexes = updateTaskIndexes(tasks);
-  return {
-    ...updateDomainMetadata(domain, event.type),
-    tasks,
-    ...indexes,
-    totalCreated: domain.totalCreated + (event.type === 'TASK_CREATED' ? 1 : 0),
-    totalCompleted: domain.totalCompleted + (event.type === 'TASK_COMPLETED' ? 1 : 0),
-    totalFailed: domain.totalFailed + (event.type === 'TASK_FAILED' ? 1 : 0),
-    totalCancelled: domain.totalCancelled + (event.type === 'TASK_CANCELLED' ? 1 : 0),
-  };
-}
-
-function updateTaskDomainFromRecord(domain: TaskDomainState, task: RuntimeTask, source: string): TaskDomainState {
-  const tasks = new Map(domain.tasks);
-  const previous = tasks.get(task.id);
-  tasks.set(task.id, task);
-  const indexes = updateTaskIndexes(tasks);
-
-  let { totalCreated, totalCompleted, totalFailed, totalCancelled } = domain;
-  if (!previous) totalCreated += 1;
-  if (previous?.status !== task.status) {
-    if (task.status === 'completed') totalCompleted += 1;
-    else if (task.status === 'failed') totalFailed += 1;
-    else if (task.status === 'cancelled') totalCancelled += 1;
-  }
-
-  return { ...updateDomainMetadata(domain, source), tasks, ...indexes, totalCreated, totalCompleted, totalFailed, totalCancelled };
-}
-
-function transitionTaskDomainRecord(
-  domain: TaskDomainState,
-  taskId: string,
-  status: TaskLifecycleState,
-  patch: Partial<RuntimeTask> | undefined,
-  source: string,
-): TaskDomainState {
-  const existing = domain.tasks.get(taskId);
-  if (!existing) return domain;
-  return updateTaskDomainFromRecord(domain, { ...existing, ...patch, status }, source);
-}
-
-export function updateAgentState(domain: AgentDomainState, event: AgentEvent): AgentDomainState {
-  const agents = new Map(domain.agents);
-  const timestamp = now();
-  const existing = agents.get(event.agentId);
-  const statusMap: Partial<Record<AgentEvent['type'], AgentLifecycleState>> = {
-    AGENT_SPAWNING: 'spawning',
-    AGENT_RUNNING: 'running',
-    AGENT_PROGRESS: 'running',
-    AGENT_STREAM_DELTA: 'running',
-    AGENT_AWAITING_MESSAGE: 'awaiting_message',
-    AGENT_AWAITING_TOOL: 'awaiting_tool',
-    AGENT_FINALIZING: 'finalizing',
-    AGENT_COMPLETED: 'completed',
-    AGENT_FAILED: 'failed',
-    AGENT_CANCELLED: 'cancelled',
-  };
-  const agent: RuntimeAgent =
-    existing ??
-    {
-      id: event.agentId,
-      label: 'task' in event ? event.task : event.agentId,
-      role: 'subagent',
-      status: statusMap[event.type] ?? 'running',
-      providerId: 'unknown',
-      modelId: 'unknown',
-      childAgentIds: [],
-      taskId: event.taskId,
-      turnCount: 0,
-      toolCallCount: 0,
-      latestOutput: '',
-      spawnedAt: timestamp,
-    };
-  agents.set(event.agentId, {
-    ...agent,
-    status: statusMap[event.type] ?? agent.status,
-    taskId: event.taskId ?? agent.taskId,
-    latestProgress:
-      event.type === 'AGENT_PROGRESS'
-        ? event.progress
-        : event.type === 'AGENT_AWAITING_TOOL'
-          ? `${event.tool}:${event.callId}`
-          : agent.latestProgress,
-    latestOutput:
-      event.type === 'AGENT_STREAM_DELTA'
-        ? event.accumulated
-        : event.type === 'AGENT_COMPLETED' && event.output !== undefined
-          ? event.output
-          : agent.latestOutput,
-    endedAt:
-      event.type === 'AGENT_COMPLETED' || event.type === 'AGENT_FAILED' || event.type === 'AGENT_CANCELLED'
-        ? timestamp
-        : agent.endedAt,
-    error: event.type === 'AGENT_FAILED' ? event.error : agent.error,
-    toolCallCount:
-      event.type === 'AGENT_COMPLETED' && event.toolCallsMade !== undefined
-        ? event.toolCallsMade
-        : agent.toolCallCount,
-    result:
-      event.type === 'AGENT_COMPLETED'
-        ? {
-            durationMs: event.durationMs,
-            ...(event.output !== undefined ? { output: event.output } : {}),
-            ...(event.toolCallsMade !== undefined ? { toolCallsMade: event.toolCallsMade } : {}),
-          }
-        : agent.result,
-  });
-  const activeAgentIds = [...agents.values()].filter((value) => !['completed', 'failed', 'cancelled'].includes(value.status)).map((value) => value.id);
-  return {
-    ...updateDomainMetadata(domain, event.type),
-    agents,
-    activeAgentIds,
-    totalSpawned: domain.totalSpawned + (event.type === 'AGENT_SPAWNING' ? 1 : 0),
-    totalCompleted: domain.totalCompleted + (event.type === 'AGENT_COMPLETED' ? 1 : 0),
-    totalFailed: domain.totalFailed + (event.type === 'AGENT_FAILED' ? 1 : 0),
-    peakConcurrency: Math.max(domain.peakConcurrency, activeAgentIds.length),
-  };
-}
-
-function transitionAgentDomainRecord(
-  domain: AgentDomainState,
-  agentId: string,
-  status: AgentLifecycleState,
-  patch: Partial<RuntimeAgent> | undefined,
-  source: string,
-): AgentDomainState {
-  const existing = domain.agents.get(agentId);
-  if (!existing) return domain;
-
-  const agents = new Map(domain.agents);
-  agents.set(agentId, { ...existing, ...patch, status });
-  const activeAgentIds = [...agents.values()].filter((value) => !['completed', 'failed', 'cancelled'].includes(value.status)).map((value) => value.id);
-
-  return {
-    ...updateDomainMetadata(domain, source),
-    agents,
-    activeAgentIds,
-    totalCompleted: domain.totalCompleted + (existing.status !== 'completed' && status === 'completed' ? 1 : 0),
-    totalFailed: domain.totalFailed + (existing.status !== 'failed' && status === 'failed' ? 1 : 0),
-    peakConcurrency: Math.max(domain.peakConcurrency, activeAgentIds.length),
-  };
-}
-
-function orchestrationGraphStatus(graph: OrchestrationGraphRecord): OrchestrationGraphRecord['status'] {
-  const nodes = [...graph.nodes.values()];
-  if (nodes.length === 0) return 'planning';
-  if (nodes.some((node) => node.status === 'failed')) return 'failed';
-  if (nodes.some((node) => node.status === 'blocked')) return 'blocked';
-  if (nodes.some((node) => node.status === 'running')) return 'running';
-  if (nodes.every((node) => node.status === 'cancelled')) return 'cancelled';
-  if (nodes.every((node) => node.status === 'completed')) return 'completed';
-  if (nodes.every((node) => node.status === 'pending' || node.status === 'ready')) {
-    return nodes.some((node) => node.status === 'ready') ? 'ready' : 'planning';
-  }
-  return 'running';
-}
-
-export function updateOrchestrationState(
-  domain: OrchestrationDomainState,
-  event: OrchestrationEvent,
-): OrchestrationDomainState {
-  const graphs = new Map(domain.graphs);
-  const timestamp = now();
-  const existing = 'graphId' in event ? graphs.get(event.graphId) : undefined;
-
-  switch (event.type) {
-    case 'ORCHESTRATION_GRAPH_CREATED':
-      graphs.set(event.graphId, {
-        id: event.graphId,
-        title: event.title,
-        mode: event.mode,
-        status: 'planning',
-        nodeOrder: [],
-        nodes: new Map(),
-        createdAt: timestamp,
-      });
-      break;
-    case 'ORCHESTRATION_NODE_ADDED': {
-      if (!existing) return domain;
-      const nodes = new Map(existing.nodes);
-      const previousParent = event.parentNodeId ? nodes.get(event.parentNodeId) : undefined;
-      const nextNode: OrchestrationNodeRecord = {
-        id: event.nodeId,
-        title: event.title,
-        role: event.role,
-        status: 'pending',
-        parentNodeId: event.parentNodeId,
-        childNodeIds: [],
-        dependencyNodeIds: event.dependsOn ?? [],
-        ...(event.taskId !== undefined ? { taskId: event.taskId } : {}),
-        ...(event.agentId !== undefined ? { agentId: event.agentId } : {}),
-        ...(event.contract !== undefined ? { contract: event.contract } : {}),
-      };
-      nodes.set(event.nodeId, nextNode);
-      if (previousParent) {
-        nodes.set(event.parentNodeId!, { ...previousParent, childNodeIds: uniq([...previousParent.childNodeIds, event.nodeId]) });
-      }
-      const graph: OrchestrationGraphRecord = { ...existing, nodeOrder: uniq([...existing.nodeOrder, event.nodeId]), nodes };
-      graph.status = orchestrationGraphStatus(graph);
-      graphs.set(event.graphId, graph);
-      break;
-    }
-    case 'ORCHESTRATION_NODE_READY':
-    case 'ORCHESTRATION_NODE_STARTED':
-    case 'ORCHESTRATION_NODE_PROGRESS':
-    case 'ORCHESTRATION_NODE_BLOCKED':
-    case 'ORCHESTRATION_NODE_COMPLETED':
-    case 'ORCHESTRATION_NODE_FAILED':
-    case 'ORCHESTRATION_NODE_CANCELLED':
-    case 'ORCHESTRATION_RECURSION_GUARD_TRIGGERED': {
-      if (!existing) return domain;
-      const nodes = new Map(existing.nodes);
-      const nodeId = 'nodeId' in event ? event.nodeId : undefined;
-      if (nodeId) {
-        const node = nodes.get(nodeId);
-        if (!node) return domain;
-        const updatedNode: OrchestrationNodeRecord =
-          event.type === 'ORCHESTRATION_NODE_READY'
-            ? { ...node, status: 'ready' }
-            : event.type === 'ORCHESTRATION_NODE_STARTED'
-              ? { ...node, status: 'running', startedAt: node.startedAt ?? timestamp, ...(event.taskId !== undefined ? { taskId: event.taskId } : {}), ...(event.agentId !== undefined ? { agentId: event.agentId } : {}) }
-              : event.type === 'ORCHESTRATION_NODE_PROGRESS'
-                ? { ...node, latestMessage: event.message }
-                : event.type === 'ORCHESTRATION_NODE_BLOCKED'
-                  ? { ...node, status: 'blocked', error: event.reason }
-                  : event.type === 'ORCHESTRATION_NODE_COMPLETED'
-                    ? { ...node, status: 'completed', endedAt: timestamp, latestMessage: event.summary ?? node.latestMessage }
-                    : event.type === 'ORCHESTRATION_NODE_FAILED'
-                      ? { ...node, status: 'failed', endedAt: timestamp, error: event.error }
-                      : { ...node, status: 'cancelled', endedAt: timestamp, error: event.reason };
-        nodes.set(nodeId, updatedNode);
-      }
-      const graph: OrchestrationGraphRecord = {
-        ...existing,
-        nodes,
-        ...(event.type === 'ORCHESTRATION_NODE_STARTED' ? { startedAt: existing.startedAt ?? timestamp } : {}),
-        ...(event.type === 'ORCHESTRATION_RECURSION_GUARD_TRIGGERED'
-          ? {
-              lastRecursionGuard: {
-                depth: event.depth,
-                activeAgents: event.activeAgents,
-                reason: event.reason,
-                ...(event.nodeId !== undefined ? { nodeId: event.nodeId } : {}),
-                triggeredAt: timestamp,
-              },
-            }
-          : {}),
-      };
-      graph.status = orchestrationGraphStatus(graph);
-      if (graph.status === 'completed' || graph.status === 'failed' || graph.status === 'cancelled') {
-        graph.endedAt = graph.endedAt ?? timestamp;
-      }
-      graphs.set(graph.id, graph);
-      break;
-    }
-  }
-
-  const activeGraphIds = [...graphs.values()].filter((graph) => !['completed', 'failed', 'cancelled'].includes(graph.status)).map((graph) => graph.id);
-
-  return {
-    ...updateDomainMetadata(domain, event.type),
-    graphs,
-    activeGraphIds,
-    totalGraphs: graphs.size,
-    totalCompletedGraphs: [...graphs.values()].filter((graph) => graph.status === 'completed').length,
-    totalFailedGraphs: [...graphs.values()].filter((graph) => graph.status === 'failed').length,
-    recursionGuardTrips: domain.recursionGuardTrips + (event.type === 'ORCHESTRATION_RECURSION_GUARD_TRIGGERED' ? 1 : 0),
-  };
-}
-
-export { updateTaskDomainFromRecord, transitionTaskDomainRecord, transitionAgentDomainRecord };
+export * from '@pellux/goodvibes-sdk/platform/runtime/store/helpers/reducers/lifecycle';

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,46 @@
+import type {
+  AgentEvent,
+  AnyRuntimeEvent,
+  OpsEvent,
+  PlannerEvent,
+  ProviderEvent,
+  RuntimeEventBus,
+  RuntimeEventEnvelope,
+  SessionEvent,
+  ToolEvent,
+  TurnEvent,
+  WorkflowEvent,
+} from '@pellux/goodvibes-sdk/platform/runtime/events/index';
+import { createRuntimeEventFeed, type RuntimeEventFeed } from '@pellux/goodvibes-sdk/platform/runtime/event-feeds';
+
+export type UiEventFeed<TEvent extends AnyRuntimeEvent> = RuntimeEventFeed<TEvent>;
+
+export interface UiRuntimeEvents {
+  readonly sessions: UiEventFeed<SessionEvent>;
+  readonly turns: UiEventFeed<TurnEvent>;
+  readonly tools: UiEventFeed<ToolEvent>;
+  readonly providers: UiEventFeed<ProviderEvent>;
+  readonly agents: UiEventFeed<AgentEvent>;
+  readonly workflows: UiEventFeed<WorkflowEvent>;
+  readonly planner: UiEventFeed<PlannerEvent>;
+  readonly ops: UiEventFeed<OpsEvent>;
+}
+
+function createUiEventFeed<TEvent extends AnyRuntimeEvent>(runtimeBus: RuntimeEventBus): UiEventFeed<TEvent> {
+  return createRuntimeEventFeed<TEvent>((type, listener) => (
+    runtimeBus.on(type as TEvent['type'], listener as (envelope: RuntimeEventEnvelope<TEvent['type'], TEvent>) => void)
+  ));
+}
+
+export function createUiRuntimeEvents(runtimeBus: RuntimeEventBus): UiRuntimeEvents {
+  return {
+    sessions: createUiEventFeed<SessionEvent>(runtimeBus),
+    turns: createUiEventFeed<TurnEvent>(runtimeBus),
+    tools: createUiEventFeed<ToolEvent>(runtimeBus),
+    providers: createUiEventFeed<ProviderEvent>(runtimeBus),
+    agents: createUiEventFeed<AgentEvent>(runtimeBus),
+    workflows: createUiEventFeed<WorkflowEvent>(runtimeBus),
+    planner: createUiEventFeed<PlannerEvent>(runtimeBus),
+    ops: createUiEventFeed<OpsEvent>(runtimeBus),
+  };
+}

package/src/runtime/ui-services.ts

@@ -1,7 +1,7 @@
 import type { RuntimeServices } from './services.ts';
 import type { RemoteRunnerRegistry } from '@pellux/goodvibes-sdk/platform/runtime/remote/runner-registry';
 import type { RemoteSupervisor } from '@pellux/goodvibes-sdk/platform/runtime/remote/supervisor';
-import { createUiRuntimeEvents, type UiRuntimeEvents } from '@pellux/goodvibes-sdk/platform/runtime/ui-events';
+import { createUiRuntimeEvents, type UiRuntimeEvents } from './ui-events.ts';
 import { createUiReadModels, type UiReadModels, type UiReadModelOptions } from './ui-read-models.ts';
 import type { ForensicsRegistry } from '@pellux/goodvibes-sdk/platform/runtime/forensics/index';
 import type { ControlPlaneRecentEvent } from '@pellux/goodvibes-sdk/platform/control-plane/index';

package/src/shell/ui-openers.ts

@@ -4,7 +4,7 @@ import type { CommandContext } from '../input/command-registry.ts';
 import type { InputHandler } from '../input/handler.ts';
 import type { PanelManager } from '../panels/panel-manager.ts';
 import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers/registry';
-import type { MutableRuntimeState } from '../runtime/context.ts';
+import type { MutableRuntimeState } from '@pellux/goodvibes-sdk/platform/runtime/mutable-runtime-state';
 import type { FeatureFlagManager } from '@pellux/goodvibes-sdk/platform/runtime/feature-flags/index';
 import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp/registry';
 import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config/subscriptions';