@pellux/goodvibes-tui 0.18.4

package/src/runtime/store/state.ts

@@ -0,0 +1,137 @@
+/**
+ * RuntimeState — the canonical top-level state shape for the goodvibes-tui
+ * runtime store. All domain slices are defined here.
+ *
+ * Each domain includes revision, lastUpdatedAt, and source metadata fields.
+ * These are defined per-domain in the domain files.
+ */
+
+import type { SessionDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/session';
+import type { ModelDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/model';
+import type { ConversationDomainState } from './domains/conversation.ts';
+import type { OverlayDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/overlays';
+import type { PanelDomainState } from './domains/panels.ts';
+import type { PermissionDomainState } from './domains/permissions.ts';
+import type { TaskDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
+import type { AgentDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/agents';
+import type { OrchestrationDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/orchestration';
+import type { CommunicationDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/communication';
+import type { ProviderHealthDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/provider-health';
+import type { McpDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/mcp';
+import type { PluginDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/plugins';
+import type { DaemonDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/daemon';
+import type { AutomationDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/automation';
+import type { AcpDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/acp';
+import type { RoutesDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/routes';
+import type { ControlPlaneDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/control-plane';
+import type { DeliveryDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/deliveries';
+import type { WatcherDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/watchers';
+import type { SurfaceDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/surfaces';
+import type { IntegrationDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/integrations';
+import type { TelemetryDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/telemetry';
+import type { GitDomainState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/git';
+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';
+
+import { createInitialSessionState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/session';
+import { createInitialModelState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/model';
+import { createInitialConversationState } from './domains/conversation.ts';
+import { createInitialOverlaysState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/overlays';
+import { createInitialPanelsState } from './domains/panels.ts';
+import { createInitialPermissionsState } from './domains/permissions.ts';
+import { createInitialTasksState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
+import { createInitialAgentsState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/agents';
+import { createInitialOrchestrationState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/orchestration';
+import { createInitialCommunicationState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/communication';
+import { createInitialProviderHealthState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/provider-health';
+import { createInitialMcpState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/mcp';
+import { createInitialPluginsState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/plugins';
+import { createInitialDaemonState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/daemon';
+import { createInitialAutomationState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/automation';
+import { createInitialAcpState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/acp';
+import { createInitialRoutesState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/routes';
+import { createInitialControlPlaneState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/control-plane';
+import { createInitialDeliveryState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/deliveries';
+import { createInitialWatcherState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/watchers';
+import { createInitialSurfaceState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/surfaces';
+import { createInitialIntegrationsState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/integrations';
+import { createInitialTelemetryState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/telemetry';
+import { createInitialGitState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/git';
+import { createInitialDiscoveryState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/discovery';
+import { createInitialIntelligenceState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/intelligence';
+import { createInitialUiPerfState } from './domains/ui-perf.ts';
+
+/**
+ * RuntimeState — the complete state shape managed by the runtime store.
+ *
+ * Domain slices, each with revision/lastUpdatedAt/source metadata.
+ * All mutations must go through typed domain dispatch APIs.
+ */
+export interface RuntimeState {
+  session: SessionDomainState;
+  model: ModelDomainState;
+  conversation: ConversationDomainState;
+  overlays: OverlayDomainState;
+  panels: PanelDomainState;
+  permissions: PermissionDomainState;
+  tasks: TaskDomainState;
+  agents: AgentDomainState;
+  orchestration: OrchestrationDomainState;
+  communication: CommunicationDomainState;
+  providerHealth: ProviderHealthDomainState;
+  mcp: McpDomainState;
+  plugins: PluginDomainState;
+  daemon: DaemonDomainState;
+  automation: AutomationDomainState;
+  routes: RoutesDomainState;
+  controlPlane: ControlPlaneDomainState;
+  deliveries: DeliveryDomainState;
+  watchers: WatcherDomainState;
+  surfaces: SurfaceDomainState;
+  acp: AcpDomainState;
+  integrations: IntegrationDomainState;
+  telemetry: TelemetryDomainState;
+  git: GitDomainState;
+  discovery: DiscoveryDomainState;
+  intelligence: IntelligenceDomainState;
+  uiPerf: UiPerfDomainState;
+}
+
+/**
+ * Creates and returns a fully initialized RuntimeState with all domains
+ * set to their default initial values.
+ *
+ * This is the factory used by `createRuntimeStore()` and test harnesses.
+ */
+export function createInitialRuntimeState(): RuntimeState {
+  return {
+    session: createInitialSessionState(),
+    model: createInitialModelState(),
+    conversation: createInitialConversationState(),
+    overlays: createInitialOverlaysState(),
+    panels: createInitialPanelsState(),
+    permissions: createInitialPermissionsState(),
+    tasks: createInitialTasksState(),
+    agents: createInitialAgentsState(),
+    orchestration: createInitialOrchestrationState(),
+    communication: createInitialCommunicationState(),
+    providerHealth: createInitialProviderHealthState(),
+    mcp: createInitialMcpState(),
+    plugins: createInitialPluginsState(),
+    daemon: createInitialDaemonState(),
+    automation: createInitialAutomationState(),
+    routes: createInitialRoutesState(),
+    controlPlane: createInitialControlPlaneState(),
+    deliveries: createInitialDeliveryState(),
+    watchers: createInitialWatcherState(),
+    surfaces: createInitialSurfaceState(),
+    acp: createInitialAcpState(),
+    integrations: createInitialIntegrationsState(),
+    telemetry: createInitialTelemetryState(),
+    git: createInitialGitState(),
+    discovery: createInitialDiscoveryState(),
+    intelligence: createInitialIntelligenceState(),
+    uiPerf: createInitialUiPerfState(),
+  };
+}

package/src/runtime/tasks/adapters/acp-adapter.ts

@@ -0,0 +1,211 @@
+/**
+ * AcpTaskAdapter — bridges ACP remote subagent tasks (managed by AcpManager)
+ * into the unified RuntimeTask registry.
+ *
+ * Each spawned ACP subagent gets a corresponding RuntimeTask of kind 'acp'.
+ * The adapter maps SubagentStatus strings to task lifecycle transitions.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { createDomainDispatch } from '../../store/index.ts';
+import type { RuntimeStore, DomainDispatch } from '../../store/index.ts';
+import type { RuntimeTask } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
+import type { SubagentStatus } from '@pellux/goodvibes-sdk/platform/acp/protocol';
+import type { AcpManager } from '../../../acp/manager.ts';
+
+/**
+ * Maps an ACP SubagentStatus to a RuntimeTask lifecycle state.
+ *
+ * @param status - SubagentStatus from the ACP protocol.
+ * @returns Corresponding task lifecycle state.
+ */
+function mapAcpStatusToTask(
+  status: SubagentStatus,
+): 'running' | 'completed' | 'failed' | 'cancelled' {
+  switch (status) {
+    case 'running':
+      return 'running';
+    case 'complete':
+      return 'completed';
+    case 'error':
+      return 'failed';
+    case 'cancelled':
+      return 'cancelled';
+  }
+}
+
+/** Terminal ACP statuses. */
+const TERMINAL_ACP_STATUSES: ReadonlySet<SubagentStatus> = new Set([
+  'complete',
+  'error',
+  'cancelled',
+]);
+
+/**
+ * Bridges ACP remote subagent tasks into the RuntimeTask registry.
+ *
+ * NOTE: This adapter writes directly to the Zustand store for performance,
+ * bypassing TaskManager. Lifecycle validation is the caller's responsibility.
+ * This is intentional — adapters are authoritative sources for their subsystem.
+ *
+ * @example
+ * ```ts
+ * const adapter = new AcpTaskAdapter(store);
+ * const taskId = adapter.wrapRemoteTask(acpId, 'Refactor auth module');
+ * adapter.handleRemoteUpdate(acpId, 'complete');
+ * ```
+ */
+export class AcpTaskAdapter {
+  /** Maps ACP remote ID → task ID. */
+  private readonly _remoteToTask = new Map<string, string>();
+  /** Maps task ID → ACP remote ID. */
+  private readonly _taskToRemote = new Map<string, string>();
+
+  private readonly _dispatch: DomainDispatch;
+
+  constructor(private readonly _store: RuntimeStore) {
+    this._dispatch = createDomainDispatch(_store);
+  }
+
+  // ── Core API ────────────────────────────────────────────────────────────────
+
+  /**
+   * Wrap an ACP remote subagent task as a RuntimeTask.
+   *
+   * @param remoteId - The ACP subagent ID from AcpManager.spawn().
+   * @param title - Human-readable title for display in the task monitor.
+   * @returns The new task ID.
+   */
+  wrapRemoteTask(remoteId: string, title: string): string {
+    // Idempotent: return existing task ID if already wrapped
+    const existing = this._remoteToTask.get(remoteId);
+    if (existing !== undefined) return existing;
+
+    const taskId = randomUUID();
+    const now = Date.now();
+
+    const task: RuntimeTask = {
+      id: taskId,
+      kind: 'acp',
+      title: title.length > 80 ? `${title.slice(0, 77)}...` : title,
+      description: title,
+      status: 'running',
+      owner: remoteId,
+      cancellable: true,
+      childTaskIds: [],
+      queuedAt: now,
+      startedAt: now,
+      correlationId: remoteId,
+    };
+
+    this._remoteToTask.set(remoteId, taskId);
+    this._taskToRemote.set(taskId, remoteId);
+
+    this._upsertTask(task);
+    return taskId;
+  }
+
+  /**
+   * Handle an ACP status update and transition the task accordingly.
+   *
+   * @param remoteId - The ACP subagent ID.
+   * @param status - New status string (SubagentStatus).
+   */
+  handleRemoteUpdate(remoteId: string, status: SubagentStatus): void {
+    const taskId = this._remoteToTask.get(remoteId);
+    if (taskId === undefined) return;
+
+    const acpStatus = status;
+    const taskStatus = mapAcpStatusToTask(acpStatus);
+    const isTerminal = TERMINAL_ACP_STATUSES.has(acpStatus);
+
+    this._transitionTask(taskId, taskStatus, {
+      isTerminal,
+      error: acpStatus === 'error' ? `ACP subagent ${remoteId} reported an error` : undefined,
+    });
+
+    if (isTerminal) {
+      this._remoteToTask.delete(remoteId);
+      this._taskToRemote.delete(taskId);
+    }
+  }
+
+  /**
+   * Cancel an ACP remote task by task ID.
+   * Cancels the underlying ACP connection via AcpManager and marks the task cancelled.
+   *
+   * @param taskId - The RuntimeTask ID to cancel.
+   * @param manager - The AcpManager instance to use for cancellation.
+   */
+  cancelRemote(taskId: string, manager?: AcpManager): void {
+    const remoteId = this._taskToRemote.get(taskId);
+    if (remoteId === undefined) return;
+
+    if (manager) {
+      // Fire-and-forget cancellation; errors are non-fatal
+      void manager.cancel(remoteId).catch(() => {
+        // Non-fatal: process may have already exited
+      });
+    }
+
+    this._transitionTask(taskId, 'cancelled', { isTerminal: true });
+    this._remoteToTask.delete(remoteId);
+    this._taskToRemote.delete(taskId);
+  }
+
+  /**
+   * Reconcile adapter state with the current AcpManager snapshot.
+   *
+   * @param manager - The AcpManager whose active subagents to sync from.
+   */
+  sync(manager: AcpManager): void {
+    const active = manager.getActive();
+    const liveIds = new Set(active.map((a) => a.id));
+
+    // Wrap newly discovered subagents
+    for (const subagent of active) {
+      if (!this._remoteToTask.has(subagent.id)) {
+        this.wrapRemoteTask(subagent.id, subagent.task);
+      }
+
+      // Sync status if non-running
+      if (subagent.status !== 'running') {
+        this.handleRemoteUpdate(subagent.id, subagent.status);
+      }
+    }
+
+    // Mark stale tracked subagents as cancelled
+    const staleRemoteIds: string[] = [];
+    for (const [remoteId] of this._remoteToTask.entries()) {
+      if (!liveIds.has(remoteId)) staleRemoteIds.push(remoteId);
+    }
+    for (const remoteId of staleRemoteIds) {
+      const taskId = this._remoteToTask.get(remoteId)!;
+      this._transitionTask(taskId, 'cancelled', { isTerminal: true });
+      this._remoteToTask.delete(remoteId);
+      this._taskToRemote.delete(taskId);
+    }
+  }
+
+  // ── Private helpers ─────────────────────────────────────────────────────────
+
+  private _upsertTask(task: RuntimeTask): void {
+    this._dispatch.syncRuntimeTask(task, 'acp-adapter');
+  }
+
+  private _transitionTask(
+    taskId: string,
+    status: 'running' | 'completed' | 'failed' | 'cancelled',
+    opts: { isTerminal?: boolean; error?: string },
+  ): void {
+    this._dispatch.transitionRuntimeTask(
+      taskId,
+      status,
+      {
+        endedAt: opts.isTerminal ? Date.now() : undefined,
+        error: opts.error,
+      },
+      'acp-adapter',
+    );
+  }
+}

package/src/runtime/tasks/adapters/agent-adapter.ts

@@ -0,0 +1,208 @@
+/**
+ * AgentTaskAdapter — bridges agent sessions (AgentOrchestrator / WRFC agents)
+ * into the unified RuntimeTask registry.
+ *
+ * Each running agent gets a corresponding RuntimeTask of kind 'agent'. The
+ * adapter maps agent lifecycle state strings to task lifecycle transitions.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { createDomainDispatch } from '../../store/index.ts';
+import type { RuntimeStore, DomainDispatch } from '../../store/index.ts';
+import type { RuntimeTask } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
+import type { AgentLifecycleState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/agents';
+
+/** Owner context for an agent task. */
+export interface AgentOwner {
+  /** Session ID that spawned this agent. */
+  sessionId: string;
+}
+
+/** Terminal agent lifecycle states that map to terminal task states. */
+const TERMINAL_STATES: ReadonlySet<AgentLifecycleState> = new Set([
+  'completed',
+  'failed',
+  'cancelled',
+]);
+
+/** Active (non-terminal, non-queued) agent states that map to 'running'. */
+const RUNNING_STATES: ReadonlySet<AgentLifecycleState> = new Set([
+  'running',
+  'awaiting_message',
+  'awaiting_tool',
+  'finalizing',
+]);
+
+/**
+ * Maps an agent lifecycle state string to a RuntimeTask lifecycle state.
+ *
+ * @param state - Agent lifecycle state from AgentLifecycleState.
+ * @returns Corresponding task lifecycle state.
+ */
+function mapAgentStateToTask(
+  state: AgentLifecycleState,
+): 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' {
+  if (state === 'spawning') return 'queued';
+  if (RUNNING_STATES.has(state)) return 'running';
+  if (state === 'completed') return 'completed';
+  if (state === 'failed') return 'failed';
+  if (state === 'cancelled') return 'cancelled';
+  return 'running'; // fallback for unknown states
+}
+
+/**
+ * Bridges agent sessions into the RuntimeTask registry.
+ *
+ * @example
+ * ```ts
+ * const adapter = new AgentTaskAdapter(store);
+ * const taskId = adapter.wrapAgent('agent_1', 'Fix the linting errors', { sessionId: 'sess_1' });
+ * adapter.handleAgentStateChange('agent_1', 'running');
+ * adapter.handleAgentStateChange('agent_1', 'completed');
+ * ```
+ */
+export class AgentTaskAdapter {
+  /** Maps agent ID → task ID. */
+  private readonly _agentToTask = new Map<string, string>();
+  /** Maps task ID → agent ID. */
+  private readonly _taskToAgent = new Map<string, string>();
+
+  private readonly _dispatch: DomainDispatch;
+
+  constructor(private readonly _store: RuntimeStore) {
+    this._dispatch = createDomainDispatch(_store);
+  }
+
+  // ── Core API ────────────────────────────────────────────────────────────────
+
+  /**
+   * Wrap an agent session as a RuntimeTask.
+   *
+   * @param agentId - Unique agent ID from the agent system.
+   * @param task - Human-readable description of what the agent is doing.
+   * @param owner - Session that spawned this agent.
+   * @returns The new task ID.
+   */
+  wrapAgent(agentId: string, task: string, owner: AgentOwner): string {
+    // Idempotent: return existing task ID if already wrapped
+    const existing = this._agentToTask.get(agentId);
+    if (existing !== undefined) return existing;
+
+    const taskId = randomUUID();
+    const now = Date.now();
+
+    const runtimeTask: RuntimeTask = {
+      id: taskId,
+      kind: 'agent',
+      title: task.length > 80 ? `${task.slice(0, 77)}...` : task,
+      description: task,
+      status: 'queued',
+      owner: agentId,
+      cancellable: true,
+      childTaskIds: [],
+      queuedAt: now,
+      correlationId: owner.sessionId,
+    };
+
+    this._agentToTask.set(agentId, taskId);
+    this._taskToAgent.set(taskId, agentId);
+
+    this._upsertTask(runtimeTask);
+    return taskId;
+  }
+
+  /**
+   * Handle an agent lifecycle state change and transition the task accordingly.
+   *
+   * @param agentId - The agent whose state changed.
+   * @param state - New agent lifecycle state (AgentLifecycleState string).
+   */
+  handleAgentStateChange(agentId: string, state: AgentLifecycleState): void {
+    const taskId = this._agentToTask.get(agentId);
+    if (taskId === undefined) return;
+
+    const agentState = state;
+    const taskStatus = mapAgentStateToTask(agentState);
+
+    this._transitionTask(taskId, taskStatus, {
+      isTerminal: TERMINAL_STATES.has(agentState),
+      error: agentState === 'failed' ? `Agent ${agentId} failed` : undefined,
+    });
+
+    // Clean up mappings once terminal
+    if (TERMINAL_STATES.has(agentState)) {
+      this._agentToTask.delete(agentId);
+      this._taskToAgent.delete(taskId);
+    }
+  }
+
+  /**
+   * Cancel an agent task by task ID.
+   * Marks the task as cancelled in the store. The caller is responsible for
+   * actually stopping the agent session.
+   *
+   * @param taskId - The RuntimeTask ID to cancel.
+   */
+  cancelAgent(taskId: string): void {
+    const agentId = this._taskToAgent.get(taskId);
+    if (agentId === undefined) return;
+
+    this._transitionTask(taskId, 'cancelled', { isTerminal: true });
+    this._agentToTask.delete(agentId);
+    this._taskToAgent.delete(taskId);
+  }
+
+  /**
+   * Reconcile adapter state with an external agent registry snapshot.
+   *
+   * @param activeAgents - Current snapshot of active agents: agentId → task description.
+   * @param owner - Default owner context for auto-wrapped agents.
+   */
+  sync(activeAgents: ReadonlyMap<string, string>, owner: AgentOwner = { sessionId: 'system' }): void {
+    const liveIds = new Set(activeAgents.keys());
+
+    // Wrap newly discovered agents
+    for (const [agentId, task] of activeAgents.entries()) {
+      if (!this._agentToTask.has(agentId)) {
+        this.wrapAgent(agentId, task, owner);
+      }
+    }
+
+    // Mark stale tracked agents as cancelled
+    const staleAgentIds: string[] = [];
+    for (const [agentId] of this._agentToTask.entries()) {
+      if (!liveIds.has(agentId)) staleAgentIds.push(agentId);
+    }
+    for (const agentId of staleAgentIds) {
+      const taskId = this._agentToTask.get(agentId)!;
+      this._transitionTask(taskId, 'cancelled', { isTerminal: true });
+      this._agentToTask.delete(agentId);
+      this._taskToAgent.delete(taskId);
+    }
+  }
+
+  // ── Private helpers ─────────────────────────────────────────────────────────
+
+  private _upsertTask(task: RuntimeTask): void {
+    this._dispatch.syncRuntimeTask(task, 'agent-adapter');
+  }
+
+  private _transitionTask(
+    taskId: string,
+    status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled',
+    opts: { isTerminal?: boolean; error?: string },
+  ): void {
+    const current = this._store.getState().tasks.tasks.get(taskId);
+    const timestamp = Date.now();
+    this._dispatch.transitionRuntimeTask(
+      taskId,
+      status,
+      {
+        startedAt: status === 'running' && current?.startedAt === undefined ? timestamp : current?.startedAt,
+        endedAt: opts.isTerminal ? timestamp : current?.endedAt,
+        error: opts.error,
+      },
+      'agent-adapter',
+    );
+  }
+}

package/src/runtime/tasks/adapters/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Task adapter barrel — re-exports all subsystem-to-RuntimeTask bridge adapters.
+ *
+ * Each adapter converts a subsystem-specific task representation into the
+ * unified RuntimeTask model and handles lifecycle transitions.
+ */
+
+export { ProcessTaskAdapter } from './process-adapter.ts';
+export type { ProcessOwner } from './process-adapter.ts';
+
+export { AgentTaskAdapter } from './agent-adapter.ts';
+export type { AgentOwner } from './agent-adapter.ts';
+
+export { AcpTaskAdapter } from './acp-adapter.ts';
+
+export { SchedulerTaskAdapter } from './scheduler-adapter.ts';