@pellux/goodvibes-agent 0.1.0

package/src/runtime/ui/provider-health/fallback-visualizer.ts

@@ -0,0 +1,71 @@
+/**
+ * Fallback chain visualization data builder.
+ *
+ * Converts the raw fallback chain from ModelDomainState and current
+ * provider health records into a structured FallbackChainData snapshot
+ * suitable for UI rendering.
+ */
+import type { ModelDomainState } from '@/runtime/index.ts';
+import type { ProviderHealthDomainState } from '@/runtime/index.ts';
+import type { FallbackChainData, FallbackChainNode } from '@/runtime/index.ts';
+
+/**
+ * Build a FallbackChainData snapshot from the current model and health state.
+ *
+ * The primary model is always node 0. Each entry in ModelDomainState.fallbackChain
+ * becomes a subsequent node. Health status is enriched from the provider health domain.
+ *
+ * @param modelState - Current model domain state.
+ * @param healthState - Current provider health domain state.
+ * @returns Immutable FallbackChainData for visualization.
+ */
+export function buildFallbackChainData(
+  modelState: ModelDomainState,
+  healthState: ProviderHealthDomainState,
+): FallbackChainData {
+  const nodes: FallbackChainNode[] = [];
+
+  // Node 0 — primary (active model)
+  const primaryRecord = healthState.providers.get(modelState.activeProviderId);
+  nodes.push({
+    registryKey: `${modelState.activeProviderId}:${modelState.activeModelId}`,
+    providerId: modelState.activeProviderId,
+    modelId: modelState.activeModelId,
+    displayName: modelState.displayName,
+    position: 0,
+    isCurrent: modelState.activeFallbackIndex === -1,
+    providerStatus: primaryRecord?.status ?? 'unknown',
+    reason: undefined,
+  });
+
+  // Nodes 1..N — fallback chain entries
+  for (let i = 0; i < modelState.fallbackChain.length; i++) {
+    const entry = modelState.fallbackChain[i];
+    const record = healthState.providers.get(entry.providerId);
+    nodes.push({
+      registryKey: `${entry.providerId}:${entry.modelId}`,
+      providerId: entry.providerId,
+      modelId: entry.modelId,
+      displayName: entry.displayName,
+      position: i + 1,
+      isCurrent: modelState.activeFallbackIndex === i,
+      providerStatus: record?.status ?? 'unknown',
+      reason: entry.reason,
+    });
+  }
+
+  const hasUnhealthyNode = nodes.some(
+    (n) =>
+      n.providerStatus === 'degraded' ||
+      n.providerStatus === 'rate_limited' ||
+      n.providerStatus === 'unavailable' ||
+      n.providerStatus === 'auth_error',
+  );
+
+  return {
+    nodes,
+    activeIndex: modelState.activeFallbackIndex,
+    falloverCount: modelState.falloverCount,
+    hasUnhealthyNode,
+  };
+}

package/src/runtime/ui/provider-health/index.ts

@@ -0,0 +1,46 @@
+/**
+ * Provider health UI data surface barrel.
+ *
+ * Re-exports all types and the ProviderHealthDataProvider class.
+ * Also provides the createProviderHealthData() factory for one-shot snapshots.
+ */
+export type {
+  ProviderStatus,
+  CompositeHealthStatus,
+  HealthTimelinePoint,
+  HealthTimeline,
+  ProviderHealthEntry,
+  FallbackChainNode,
+  FallbackChainData,
+  ProviderHealthData,
+} from '@/runtime/index.ts';
+
+export { ProviderHealthDataProvider } from '@/runtime/index.ts';
+export { buildFallbackChainData } from '@/runtime/index.ts';
+
+import type { ProviderHealthDomainState } from '@/runtime/index.ts';
+import type { ModelDomainState } from '@/runtime/index.ts';
+import { ProviderHealthDataProvider } from '@/runtime/index.ts';
+import type { ProviderHealthData } from '@/runtime/index.ts';
+
+/**
+ * Produce a one-shot ProviderHealthData snapshot without creating a long-lived provider.
+ *
+ * Use this when you need a single render pass and do not require change subscriptions.
+ * For reactive/subscription-based UIs, prefer ProviderHealthDataProvider.
+ *
+ * @param healthState - Current provider health domain state.
+ * @param modelState - Current model domain state.
+ * @returns Immutable ProviderHealthData snapshot.
+ */
+export function createProviderHealthData(
+  healthState: ProviderHealthDomainState,
+  modelState: ModelDomainState,
+): ProviderHealthData {
+  // Delegate to the data provider for consistent derivation logic,
+  // then dispose immediately since no subscriptions are needed.
+  const dp = new ProviderHealthDataProvider(healthState, modelState);
+  const snapshot = dp.getSnapshot();
+  dp.dispose();
+  return snapshot;
+}

package/src/runtime/ui/provider-health/types.ts

@@ -0,0 +1,146 @@
+/**
+ * Provider health UI data types.
+ *
+ * Purely data-oriented — no rendering logic. These types are produced by
+ * ProviderHealthDataProvider and consumed by renderers/components.
+ */
+import type { ProviderStatus, CompositeHealthStatus } from '@/runtime/index.ts';
+
+// Re-exports for convenience
+export type { ProviderStatus, CompositeHealthStatus };
+
+/**
+ * A single point in a provider health timeline.
+ * Used to render charts of success rate, latency, or error rate over time.
+ */
+export interface HealthTimelinePoint {
+  /** Epoch ms timestamp of this sample. */
+  readonly ts: number;
+  /** Observed success rate at this point (0–1). */
+  readonly successRate: number;
+  /** Observed average latency in ms at this point. */
+  readonly avgLatencyMs: number;
+  /** Observed error rate at this point (0–1). */
+  readonly errorRate: number;
+}
+
+/**
+ * Timeline data for a single provider, for chart rendering.
+ */
+export interface HealthTimeline {
+  /** Provider ID this timeline belongs to. */
+  readonly providerId: string;
+  /** Ordered timeline points (oldest first). */
+  readonly points: readonly HealthTimelinePoint[];
+  /** The number of points retained in this timeline. */
+  readonly length: number;
+}
+
+/**
+ * Full health entry for a single provider, enriched for UI consumption.
+ */
+export interface ProviderHealthEntry {
+  // ── Identity ──────────────────────────────────────────────────────────────
+  /** Provider identifier. */
+  readonly providerId: string;
+  /** Human-readable provider name. */
+  readonly displayName: string;
+
+  // ── Status ────────────────────────────────────────────────────────────────
+  /** Current health status. */
+  readonly status: ProviderStatus;
+  /** True when this provider is the active selection. */
+  readonly isActive: boolean;
+  /** True when this provider is configured with a valid API key. */
+  readonly isConfigured: boolean;
+
+  // ── Performance metrics ───────────────────────────────────────────────────
+  /** Success rate (0–1), derived from totalCalls and successCalls. */
+  readonly successRate: number;
+  /** Error rate (0–1), derived from totalCalls and errorCalls. */
+  readonly errorRate: number;
+  /** Approximate p95 latency in ms (max of recent observations). */
+  readonly p95LatencyMs: number;
+  /** Moving average latency in ms. */
+  readonly avgLatencyMs: number;
+  /** Total API calls recorded. */
+  readonly totalCalls: number;
+
+  // ── Cache metrics ─────────────────────────────────────────────────────────
+  /** Cache hit rate (0–1). Present only when cache metrics are available. */
+  readonly cacheHitRate?: number;
+  /** Cumulative cache read tokens saved. */
+  readonly cacheReadTokens?: number;
+  /** Cumulative cache write tokens. */
+  readonly cacheWriteTokens?: number;
+
+  // ── Timing ────────────────────────────────────────────────────────────────
+  /** Epoch ms of the last successful call, if any. */
+  readonly lastSuccessAt?: number;
+  /** Epoch ms of the last error, if any. */
+  readonly lastErrorAt?: number;
+  /** Most recent error message, if any. */
+  readonly lastErrorMessage?: string;
+  /** Epoch ms of the last health check. */
+  readonly lastCheckedAt?: number;
+  /** Rate limit reset time (epoch ms), if currently rate-limited. */
+  readonly rateLimitResetAt?: number;
+
+  // ── Timeline ──────────────────────────────────────────────────────────────
+  /** Timeline data for chart rendering. */
+  readonly timeline: HealthTimeline;
+}
+
+/**
+ * A single node in the fallback chain visualization.
+ */
+export interface FallbackChainNode {
+  /** Provider identifier. */
+  readonly providerId: string;
+  /** Model identifier on this provider. */
+  readonly modelId: string;
+  /** Human-readable display label. */
+  readonly displayName: string;
+  /** Position in the chain (0 = primary). */
+  readonly position: number;
+  /** Whether this node is the currently active entry in the chain. */
+  readonly isCurrent: boolean;
+  /** Current health status of this provider. */
+  readonly providerStatus: ProviderStatus;
+  /** Reason this fallback was configured. */
+  readonly reason?: string;
+}
+
+/**
+ * Fallback chain visualization data for the current model configuration.
+ */
+export interface FallbackChainData {
+  /** Ordered nodes in the fallback chain (primary first). */
+  readonly nodes: readonly FallbackChainNode[];
+  /** Index of the currently active node (-1 = primary is active). */
+  readonly activeIndex: number;
+  /** Number of fallover events since session start. */
+  readonly falloverCount: number;
+  /** True when the chain has at least one degraded or unavailable node. */
+  readonly hasUnhealthyNode: boolean;
+}
+
+/**
+ * Complete data snapshot produced by ProviderHealthDataProvider.
+ */
+export interface ProviderHealthData {
+  /** All provider health entries, sorted by status priority then name. */
+  readonly entries: readonly ProviderHealthEntry[];
+  /** Composite health status across all providers. */
+  readonly compositeStatus: CompositeHealthStatus;
+  /** Number of providers currently in a non-healthy state. */
+  readonly degradedCount: number;
+  /** Number of providers currently unavailable. */
+  readonly unavailableCount: number;
+  /** Fallback chain visualization data. */
+  readonly fallbackChain: FallbackChainData;
+  /** Warning messages from provider discovery. */
+  readonly warnings: readonly string[];
+  /** Epoch ms when this snapshot was produced. */
+  readonly snapshotAt: number;
+}

package/src/runtime/ui-events.ts

@@ -0,0 +1 @@
+export * from '@/runtime/index.ts';

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

@@ -0,0 +1 @@
+export * from '@/runtime/index.ts';

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

@@ -0,0 +1 @@
+export * from '@/runtime/index.ts';

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

@@ -0,0 +1 @@
+export * from '@/runtime/index.ts';

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

@@ -0,0 +1 @@
+export * from '@/runtime/index.ts';

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

@@ -0,0 +1 @@
+export * from '@/runtime/index.ts';

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

@@ -0,0 +1 @@
+export * from '@/runtime/index.ts';

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

@@ -0,0 +1 @@
+export * from '@/runtime/index.ts';

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

@@ -0,0 +1,61 @@
+export type { UiReadModel } from '@/runtime/index.ts';
+export type {
+  UiCoreReadModels,
+  UiProvidersSnapshot,
+  UiSessionSnapshot,
+  UiAgentsSnapshot,
+  UiTasksSnapshot,
+} from '@/runtime/index.ts';
+export type {
+  UiOperationsReadModels,
+  UiAutomationSnapshot,
+  UiRoutesSnapshot,
+  UiWatchersSnapshot,
+  UiOrchestrationSnapshot,
+  UiCommunicationSnapshot,
+  UiControlPlaneSnapshot,
+} from '@/runtime/index.ts';
+export type {
+  UiObservabilityReadModels,
+  UiRemoteSnapshot,
+  UiIntelligenceSnapshot,
+  UiMarketplaceSnapshot,
+  UiCockpitSnapshot,
+  UiSecuritySnapshot,
+  UiHealthSnapshot,
+  UiMcpServerSnapshot,
+  UiMcpSnapshot,
+  UiLocalAuthSnapshot,
+  UiSettingsSnapshot,
+  UiContinuitySnapshot,
+  UiWorktreeSnapshot,
+} from '@/runtime/index.ts';
+export type { UiObservabilityReadModelOptions } from '@/runtime/index.ts';
+
+import type { RuntimeServices } from './services.ts';
+import { createCoreReadModels, type UiCoreReadModels } from '@/runtime/index.ts';
+import {
+  createOperationsReadModels,
+  type UiOperationsReadModels,
+  type UiOperationsReadModelOptions,
+} from '@/runtime/index.ts';
+import {
+  createObservabilityReadModels,
+  type UiObservabilityReadModels,
+  type UiObservabilityReadModelOptions,
+} from '@/runtime/index.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 @@
+export * from '@/runtime/index.ts';

package/src/runtime/ui-services.ts

@@ -0,0 +1,190 @@
+import type { RuntimeServices } from './services.ts';
+import type { RemoteRunnerRegistry } from '@/runtime/index.ts';
+import type { RemoteSupervisor } from '@/runtime/index.ts';
+import { createUiRuntimeEvents, type UiRuntimeEvents } from './ui-events.ts';
+import { createUiReadModels, type UiReadModels, type UiReadModelOptions } from './ui-read-models.ts';
+import type { ForensicsRegistry } from '@/runtime/index.ts';
+import type { ControlPlaneRecentEvent } from '@pellux/goodvibes-sdk/platform/control-plane';
+import type { ApprovalBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
+import type { SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
+import type { ShellPathService } from '@/runtime/index.ts';
+import type { HostServiceStatus } from '@/runtime/index.ts';
+import type { SecretsManager } from '../config/secrets.ts';
+
+export interface UiEnvironmentServices {
+  readonly workingDirectory: string;
+  readonly homeDirectory: string;
+  readonly shellPaths: ShellPathService;
+}
+
+export interface UiShellServices {
+  readonly keybindingsManager: RuntimeServices['keybindingsManager'];
+  readonly panelManager: RuntimeServices['panelManager'];
+  readonly processManager: RuntimeServices['processManager'];
+  readonly profileManager: RuntimeServices['profileManager'];
+  readonly bookmarkManager: RuntimeServices['bookmarkManager'];
+}
+
+export interface UiAgentServices {
+  readonly agentManager: RuntimeServices['agentManager'];
+  readonly agentMessageBus: RuntimeServices['agentMessageBus'];
+  readonly wrfcController: RuntimeServices['wrfcController'];
+}
+
+export interface UiProviderServices {
+  readonly providerRegistry: RuntimeServices['providerRegistry'];
+  readonly favoritesStore: RuntimeServices['favoritesStore'];
+  readonly benchmarkStore: RuntimeServices['benchmarkStore'];
+}
+
+export interface UiSessionServices {
+  readonly sessionManager: RuntimeServices['sessionManager'];
+  readonly sessionBroker: SharedSessionBroker;
+  readonly sessionOrchestration: RuntimeServices['sessionOrchestration'];
+  readonly sessionMemoryStore: RuntimeServices['sessionMemoryStore'];
+}
+
+export interface UiPlatformServices {
+  readonly configManager: RuntimeServices['configManager'];
+  readonly localUserAuthManager: RuntimeServices['localUserAuthManager'];
+  readonly mcpRegistry: RuntimeServices['mcpRegistry'];
+  readonly serviceRegistry: RuntimeServices['serviceRegistry'];
+  readonly surfaceRegistry: RuntimeServices['surfaceRegistry'];
+  readonly subscriptionManager: RuntimeServices['subscriptionManager'];
+  readonly secretsManager: SecretsManager;
+  readonly tokenAuditor: RuntimeServices['tokenAuditor'];
+  readonly replayEngine: RuntimeServices['replayEngine'];
+  readonly webhookNotifier: RuntimeServices['webhookNotifier'];
+  readonly policyRuntimeState: RuntimeServices['policyRuntimeState'];
+  readonly externalServices?: {
+    inspect(): {
+      readonly daemonRunning: boolean;
+      readonly daemonPortInUse?: boolean;
+      readonly httpListenerRunning: boolean;
+      readonly httpListenerPortInUse?: boolean;
+      readonly daemonStatus?: HostServiceStatus;
+      readonly httpListenerStatus?: HostServiceStatus;
+    };
+    restart(): Promise<{
+      readonly daemonRunning: boolean;
+      readonly daemonPortInUse?: boolean;
+      readonly httpListenerRunning: boolean;
+      readonly httpListenerPortInUse?: boolean;
+      readonly daemonStatus?: HostServiceStatus;
+      readonly httpListenerStatus?: HostServiceStatus;
+    }>;
+  };
+}
+
+export interface UiPlanningServices {
+  readonly planManager: RuntimeServices['planManager'];
+  readonly adaptivePlanner: RuntimeServices['adaptivePlanner'];
+  readonly projectPlanningService: RuntimeServices['projectPlanningService'];
+  readonly projectPlanningProjectId: RuntimeServices['projectPlanningProjectId'];
+  readonly workPlanStore: RuntimeServices['workPlanStore'];
+}
+
+export interface UiCoordinationServices {
+  readonly approvalBroker: ApprovalBroker;
+}
+
+export interface UiRuntimeSharedServices {
+  readonly environment: UiEnvironmentServices;
+  readonly shell: UiShellServices;
+  readonly agents: UiAgentServices;
+  readonly providers: UiProviderServices;
+  readonly sessions: UiSessionServices;
+  readonly platform: UiPlatformServices;
+  readonly planning: UiPlanningServices;
+  readonly coordination: UiCoordinationServices;
+  readonly runtime: {
+    readonly distributedRuntime: RuntimeServices['distributedRuntime'];
+    readonly remoteRunnerRegistry: RuntimeServices['remoteRunnerRegistry'] & RemoteRunnerRegistry;
+    readonly remoteSupervisor: RuntimeServices['remoteSupervisor'] & RemoteSupervisor;
+  };
+}
+
+export interface UiRuntimeServices {
+  readonly environment: UiEnvironmentServices;
+  readonly shell: UiShellServices;
+  readonly agents: UiAgentServices;
+  readonly providers: UiProviderServices;
+  readonly sessions: UiSessionServices;
+  readonly platform: UiPlatformServices;
+  readonly planning: UiPlanningServices;
+  readonly coordination: UiCoordinationServices;
+  readonly runtime: UiRuntimeSharedServices['runtime'];
+  readonly events: UiRuntimeEvents;
+  readonly readModels: UiReadModels;
+}
+
+export interface UiRuntimeServicesOptions extends UiReadModelOptions {
+  readonly forensicsRegistry?: ForensicsRegistry;
+  readonly getControlPlaneRecentEvents?: (limit: number) => readonly ControlPlaneRecentEvent[];
+}
+
+export function createUiRuntimeServices(
+  runtimeServices: RuntimeServices,
+  options: UiRuntimeServicesOptions = {},
+): UiRuntimeServices {
+  return {
+    environment: {
+      workingDirectory: runtimeServices.workingDirectory,
+      homeDirectory: runtimeServices.homeDirectory,
+      shellPaths: runtimeServices.shellPaths,
+    },
+    shell: {
+      keybindingsManager: runtimeServices.keybindingsManager,
+      panelManager: runtimeServices.panelManager,
+      processManager: runtimeServices.processManager,
+      profileManager: runtimeServices.profileManager,
+      bookmarkManager: runtimeServices.bookmarkManager,
+    },
+    agents: {
+      agentManager: runtimeServices.agentManager,
+      agentMessageBus: runtimeServices.agentMessageBus,
+      wrfcController: runtimeServices.wrfcController,
+    },
+    providers: {
+      providerRegistry: runtimeServices.providerRegistry,
+      favoritesStore: runtimeServices.favoritesStore,
+      benchmarkStore: runtimeServices.benchmarkStore,
+    },
+    sessions: {
+      sessionManager: runtimeServices.sessionManager,
+      sessionBroker: runtimeServices.sessionBroker,
+      sessionOrchestration: runtimeServices.sessionOrchestration,
+      sessionMemoryStore: runtimeServices.sessionMemoryStore,
+    },
+    platform: {
+      configManager: runtimeServices.configManager,
+      localUserAuthManager: runtimeServices.localUserAuthManager,
+      mcpRegistry: runtimeServices.mcpRegistry,
+      serviceRegistry: runtimeServices.serviceRegistry,
+      surfaceRegistry: runtimeServices.surfaceRegistry,
+      subscriptionManager: runtimeServices.subscriptionManager,
+      secretsManager: runtimeServices.secretsManager,
+      tokenAuditor: runtimeServices.tokenAuditor,
+      replayEngine: runtimeServices.replayEngine,
+      webhookNotifier: runtimeServices.webhookNotifier,
+      policyRuntimeState: runtimeServices.policyRuntimeState,
+    },
+    planning: {
+      planManager: runtimeServices.planManager,
+      adaptivePlanner: runtimeServices.adaptivePlanner,
+      projectPlanningService: runtimeServices.projectPlanningService,
+      projectPlanningProjectId: runtimeServices.projectPlanningProjectId,
+      workPlanStore: runtimeServices.workPlanStore,
+    },
+    coordination: {
+      approvalBroker: runtimeServices.approvalBroker,
+    },
+    runtime: {
+      distributedRuntime: runtimeServices.distributedRuntime,
+      remoteRunnerRegistry: runtimeServices.remoteRunnerRegistry,
+      remoteSupervisor: runtimeServices.remoteSupervisor,
+    },
+    events: createUiRuntimeEvents(runtimeServices.runtimeBus),
+    readModels: createUiReadModels(runtimeServices, options),
+  };
+}

package/src/scripts/process-messages.ts

@@ -0,0 +1,42 @@
+// CLI utility script — not imported by the app. console usage is intentional.
+import { readFileSync } from 'fs';
+import { AgentMessageBus } from '@pellux/goodvibes-sdk/platform/agents';
+
+// Simple script to read messages from a file and broadcast them via the AgentMessageBus.
+// Expected file format: each line contains an optional index and a message separated by '|', e.g. "1 | Hello".
+// Empty lines or lines without a '|' are ignored.
+
+const MESSAGE_FILE = `${__dirname}/../msg_target.txt`;
+
+function parseMessages(fileContent: string): string[] {
+  const lines = fileContent.split(/\r?\n/);
+  const messages: string[] = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split('|');
+    if (parts.length < 2) continue;
+    const msg = parts[1].trim();
+    if (msg) messages.push(msg);
+  }
+  return messages;
+}
+
+function main() {
+  try {
+    const raw = readFileSync(MESSAGE_FILE, { encoding: 'utf-8' });
+    const msgs = parseMessages(raw);
+    const bus = new AgentMessageBus();
+    for (const m of msgs) {
+      bus.broadcast('system', m);
+      console.log(`Broadcasted: ${m}`);
+    }
+  } catch (err) {
+    console.error('Failed to process messages:', err);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}

package/src/shell/blocking-input.ts

@@ -0,0 +1,98 @@
+import type { ConversationManager } from '../core/conversation';
+import type { PermissionRequest } from '@pellux/goodvibes-sdk/platform/permissions';
+import type { SessionSnapshot } from '@/runtime/index.ts';
+import type { SystemMessageRouter } from '../core/system-message-router.ts';
+
+export type PendingPermissionState = PermissionRequest & {
+  resolve: (approved: boolean, remember?: boolean) => void;
+};
+
+export type BlockingInputHandlerOptions = {
+  data: string;
+  pendingPermission: PendingPermissionState | null;
+  recoveryPending: boolean;
+  abortTurn: () => void;
+  conversation: ConversationManager;
+  systemMessageRouter: SystemMessageRouter;
+  render: () => void;
+  loadRecoveryConversation: () => SessionSnapshot | null;
+  deleteRecoveryFile: () => void;
+};
+
+export type BlockingInputHandlerResult = {
+  handled: boolean;
+  pendingPermission: PendingPermissionState | null;
+  recoveryPending: boolean;
+};
+
+export function handleBlockingShellInput(
+  options: BlockingInputHandlerOptions,
+): BlockingInputHandlerResult {
+  const {
+    data,
+    pendingPermission,
+    recoveryPending,
+    abortTurn,
+    conversation,
+    systemMessageRouter,
+    render,
+    loadRecoveryConversation,
+    deleteRecoveryFile,
+  } = options;
+
+  if (pendingPermission) {
+    const req = pendingPermission;
+    const key = data.toLowerCase().trim();
+
+    if (key === 'y') {
+      req.resolve(true, false);
+      render();
+      return { handled: true, pendingPermission: null, recoveryPending };
+    }
+
+    if (key === 'a') {
+      req.resolve(true, true);
+      render();
+      return { handled: true, pendingPermission: null, recoveryPending };
+    }
+
+    if (key === 'n' || data === '\x1b' || data === '\x03') {
+      req.resolve(false, false);
+      abortTurn();
+      render();
+      return { handled: true, pendingPermission: null, recoveryPending };
+    }
+
+    render();
+    return { handled: true, pendingPermission, recoveryPending };
+  }
+
+  if (recoveryPending) {
+    if (data === '\x12') {
+      const recovery = loadRecoveryConversation();
+      if (recovery) {
+        conversation.fromJSON({ messages: recovery.messages as Parameters<typeof conversation.fromJSON>[0]['messages'] });
+        systemMessageRouter.high('[Recovery] Session restored.');
+      } else {
+        systemMessageRouter.high('[Recovery] Failed to restore saved data.');
+      }
+      deleteRecoveryFile();
+      render();
+      return { handled: true, pendingPermission: null, recoveryPending: false };
+    }
+
+    if (data === '\x1b' || data === '\x03') {
+      systemMessageRouter.high('[Recovery] Discarded recovery data.');
+      deleteRecoveryFile();
+      render();
+      return { handled: true, pendingPermission: null, recoveryPending: false };
+    }
+
+    systemMessageRouter.high('[Recovery] Ignored saved session; starting a new prompt.');
+    deleteRecoveryFile();
+    render();
+    return { handled: false, pendingPermission: null, recoveryPending: false };
+  }
+
+  return { handled: false, pendingPermission, recoveryPending };
+}