@pellux/goodvibes-tui 0.18.10 → 0.18.12

package/src/runtime/ops/index.ts

@@ -1,122 +0,0 @@
-/**
- * Operational runbook registry for the goodvibes-tui runtime.
- *
- * Provides a machine-readable playbook registry consumed by the diagnostics
- * panel. Each playbook describes symptoms, diagnostic checks, resolution
- * steps, and escalation criteria for a specific failure scenario.
- *
- * @example
- * ```ts
- * import { getPlaybookRegistry, getPlaybook } from '@pellux/goodvibes-sdk/platform/runtime/ops/index';
- *
- * const registry = getPlaybookRegistry();
- * const playbook = getPlaybook('stuck-turn');
- * if (playbook) {
- *   for (const check of playbook.checks) {
- *     const result = await check.run();
- *     console.log(check.label, result.passed ? 'PASS' : 'FAIL', result.summary);
- *   }
- * }
- * ```
- */
-
-// Re-export types
-export type {
-  DiagnosticSeverity,
-  DiagnosticCheckResult,
-  DiagnosticCheck,
-  PlaybookStepKind,
-  PlaybookStep,
-  Playbook,
-  PlaybookRegistryEntry,
-  PlaybookRegistry,
-} from '@pellux/goodvibes-sdk/platform/runtime/ops/types';
-
-// Re-export all playbooks
-export {
-  stuckTurnPlaybook,
-  reconnectFailurePlaybook,
-  permissionDeadlockPlaybook,
-  pluginDegradationPlaybook,
-  exportRecoveryPlaybook,
-  sessionUnrecoverablePlaybook,
-  compactionFailurePlaybook,
-} from '@pellux/goodvibes-sdk/platform/runtime/ops/playbooks/index';
-
-import type { Playbook, PlaybookRegistry, PlaybookRegistryEntry } from '@pellux/goodvibes-sdk/platform/runtime/ops/types';
-import {
-  stuckTurnPlaybook,
-  reconnectFailurePlaybook,
-  permissionDeadlockPlaybook,
-  pluginDegradationPlaybook,
-  exportRecoveryPlaybook,
-  sessionUnrecoverablePlaybook,
-  compactionFailurePlaybook,
-} from '@pellux/goodvibes-sdk/platform/runtime/ops/playbooks/index';
-
-/** All registered playbooks in definition order. */
-const ALL_PLAYBOOKS: readonly Playbook[] = [
-  stuckTurnPlaybook,
-  reconnectFailurePlaybook,
-  permissionDeadlockPlaybook,
-  pluginDegradationPlaybook,
-  exportRecoveryPlaybook,
-  sessionUnrecoverablePlaybook,
-  compactionFailurePlaybook,
-] as const;
-
-/** Registry version — bump when playbooks are added or updated. */
-export const REGISTRY_VERSION = '1.0.0';
-
-/**
- * Build and return the playbook registry.
- *
- * The registry is a Map keyed by playbook ID for O(1) lookup.
- */
-export function getPlaybookRegistry(): PlaybookRegistry {
-  const registry: PlaybookRegistry = new Map<string, PlaybookRegistryEntry>();
-  for (const playbook of ALL_PLAYBOOKS) {
-    registry.set(playbook.id, {
-      playbook,
-      version: REGISTRY_VERSION,
-      updatedAt: new Date().toISOString(),
-    });
-  }
-  return registry;
-}
-
-/**
- * Look up a single playbook by ID.
- *
- * @param id - The playbook ID (e.g. 'stuck-turn').
- * @returns The playbook, or undefined if not found.
- */
-export function getPlaybook(id: string): Playbook | undefined {
-  return ALL_PLAYBOOKS.find((p) => p.id === id);
-}
-
-/**
- * Find playbooks whose tags overlap with the provided set.
- *
- * @param tags - One or more tag strings to match.
- * @returns Playbooks that have at least one matching tag.
- */
-export function findPlaybooksByTag(...tags: string[]): Playbook[] {
-  const tagSet = new Set(tags);
-  return ALL_PLAYBOOKS.filter((p) => p.tags.some((t) => tagSet.has(t)));
-}
-
-/**
- * Find playbooks whose symptoms partially match the provided query string.
- *
- * @param query - A substring to search for in symptom descriptions.
- * @returns Matching playbooks, sorted by number of matching symptoms (desc).
- */
-export function findPlaybooksBySymptom(query: string): Playbook[] {
-  const lower = query.toLowerCase();
-  const scored = ALL_PLAYBOOKS.map((p) => ({
-    playbook: p,
-    matches: p.symptoms.filter((s) => s.toLowerCase().includes(lower)).length,
-  })).filter(({ matches }) => matches > 0);
-  return scored.sort((a, b) => b.matches - a.matches).map(({ playbook }) => playbook);
-}

package/src/runtime/ops/playbooks/index.ts

@@ -1,10 +0,0 @@
-/**
- * Barrel export for operational playbooks.
- */
-export { stuckTurnPlaybook } from '@pellux/goodvibes-sdk/platform/runtime/ops/playbooks/stuck-turn';
-export { reconnectFailurePlaybook } from '@pellux/goodvibes-sdk/platform/runtime/ops/playbooks/reconnect-failure';
-export { permissionDeadlockPlaybook } from '@pellux/goodvibes-sdk/platform/runtime/ops/playbooks/permission-deadlock';
-export { pluginDegradationPlaybook } from '@pellux/goodvibes-sdk/platform/runtime/ops/playbooks/plugin-degradation';
-export { exportRecoveryPlaybook } from '@pellux/goodvibes-sdk/platform/runtime/ops/playbooks/export-recovery';
-export { sessionUnrecoverablePlaybook } from '@pellux/goodvibes-sdk/platform/runtime/ops/playbooks/session-unrecoverable';
-export { compactionFailurePlaybook } from '@pellux/goodvibes-sdk/platform/runtime/ops/playbooks/compaction-failure';

package/src/runtime/ops/playbooks/session-unrecoverable.ts

@@ -1,196 +0,0 @@
-/**
- * Playbook: Session Unrecoverable
- *
- * Handles the scenario where session recovery has been exhausted and the
- * runtime has emitted SESSION_UNRECOVERABLE — triggering a full-system cascade.
- */
-import type { Playbook, DiagnosticCheckResult } from '@pellux/goodvibes-sdk/platform/runtime/ops/types';
-import { safeCheck } from '@pellux/goodvibes-sdk/platform/runtime/ops/safe-check';
-import { existsSync } from 'fs';
-import { readRecoveryFileMetadata } from '@pellux/goodvibes-sdk/platform/runtime/ops/runtime-context';
-import type { OpsRuntimeContextState } from '@pellux/goodvibes-sdk/platform/runtime/ops/runtime-context';
-
-export function createSessionUnrecoverablePlaybook(
-  getRuntimeContext: () => OpsRuntimeContextState | null = () => null,
-): Playbook {
-  return {
-  id: 'session-unrecoverable',
-  name: 'Session Unrecoverable',
-  description:
-    'Diagnoses and recovers from SESSION_UNRECOVERABLE events. ' +
-    'Fired when all session recovery attempts are exhausted, cascading to all domains.',
-  symptoms: [
-    'SESSION_UNRECOVERABLE event emitted on the runtime event bus',
-    'All domain health checks transitioning to failed or unknown',
-    'No new turns can be started; all in-flight operations cancelled',
-    'TUI shows system-wide failure banner',
-    'Session state file missing or corrupted',
-  ],
-  checks: [
-    {
-      id: 'session.recovery-attempts',
-      label: 'Session recovery attempts exhausted',
-      description: 'Confirms that all configured recovery attempts have been made before the cascade.',
-      run: async (): Promise<DiagnosticCheckResult> =>
-        safeCheck(async () => {
-          const runtime = getRuntimeContext();
-          if (!runtime) {
-            return {
-              passed: false,
-              summary: 'Ops runtime context is not configured.',
-              severity: 'warning',
-            };
-          }
-          const { session } = runtime.store.getState();
-          const exhausted = session.recoveryState === 'failed';
-          return {
-            passed: !exhausted,
-            summary: exhausted
-              ? `Session recovery is in a failed state${session.recoveryError ? `: ${session.recoveryError}` : '.'}`
-              : `Session recovery state is ${session.recoveryState}.`,
-            severity: exhausted ? 'critical' : 'info',
-            context: {
-              recoveryState: session.recoveryState,
-              recoveryError: session.recoveryError ?? '',
-            },
-          };
-        }),
-    },
-    {
-      id: 'session.state-file',
-      label: 'Session state file integrity',
-      description: 'Checks whether the session state file exists and is parseable.',
-      run: async (): Promise<DiagnosticCheckResult> =>
-        safeCheck(async () => {
-          const runtime = getRuntimeContext();
-          if (!runtime) {
-            return {
-              passed: false,
-              summary: 'Ops runtime context is not configured.',
-              severity: 'warning',
-            };
-          }
-          const recoveryMeta = readRecoveryFileMetadata(runtime.recoveryFilePath);
-          const pointerExists = existsSync(runtime.lastSessionPointerPath);
-          const passed = recoveryMeta.ok && pointerExists;
-          return {
-            passed,
-            summary: passed
-              ? 'Recovery artifact and last-session pointer are both present and readable.'
-              : `${recoveryMeta.summary}${pointerExists ? '' : ' Last-session pointer file is missing.'}`,
-            severity: passed ? 'info' : 'error',
-            context: {
-              recoveryFilePresent: existsSync(runtime.recoveryFilePath),
-              lastSessionPointerPresent: pointerExists,
-            },
-          };
-        }),
-    },
-    {
-      id: 'session.event-bus-silent',
-      label: 'Event bus silent after cascade',
-      description: 'Verifies that no further domain events are being processed after SESSION_UNRECOVERABLE.',
-      run: async (): Promise<DiagnosticCheckResult> =>
-        safeCheck(async () => {
-          const runtime = getRuntimeContext();
-          if (!runtime) {
-            return {
-              passed: false,
-              summary: 'Ops runtime context is not configured.',
-              severity: 'warning',
-            };
-          }
-          if (!runtime.sessionRecoveryFailedAt) {
-            return {
-              passed: true,
-              summary: 'No SESSION_RECOVERY_FAILED event has been observed in this runtime context.',
-              severity: 'info',
-              context: {
-                sessionRecoveryFailedCount: runtime.sessionRecoveryFailedCount,
-                sessionRecoveryFailedAt: 0,
-                lastEventAt: runtime.lastEventAt,
-              },
-            };
-          }
-          const postCascadeActivity = runtime.lastEventAt > runtime.sessionRecoveryFailedAt;
-          return {
-            passed: !postCascadeActivity,
-            summary: postCascadeActivity
-              ? 'Runtime events are still being processed after SESSION_UNRECOVERABLE.'
-              : 'No runtime events have been observed after SESSION_UNRECOVERABLE.',
-            severity: postCascadeActivity ? 'warning' : 'info',
-            context: {
-              sessionRecoveryFailedAt: runtime.sessionRecoveryFailedAt,
-              lastEventAt: runtime.lastEventAt,
-              sessionRecoveryFailedCount: runtime.sessionRecoveryFailedCount,
-            },
-          };
-        }),
-    },
-  ],
-  steps: [
-    {
-      step: 1,
-      title: 'Capture full session state dump',
-      action:
-        'Before any recovery attempt, export the full runtime state snapshot ' +
-        '(health, tasks, agents, active spans) to a diagnostic file.',
-      kind: 'observe',
-      expectedOutcome: 'State dump captured for post-mortem analysis.',
-      automatable: false,
-    },
-    {
-      step: 2,
-      title: 'Attempt graceful session restart',
-      action:
-        'Call runtime.session.restart() to attempt a clean session re-initialization. ' +
-        'This resets all domain health, clears the event queue, and reinitialises plugins.',
-      kind: 'command',
-      command: 'runtime.session.restart()',
-      expectedOutcome: 'Session health returns to healthy; all domains reinitialise.',
-      automatable: true,
-    },
-    {
-      step: 3,
-      title: 'Clear corrupted session state',
-      action:
-        'If restart fails, remove or rename the corrupted session state file and restart. ' +
-        'This loses in-progress turns but allows the runtime to boot fresh.',
-      kind: 'command',
-      command: 'runtime.session.clearState()',
-      expectedOutcome: 'Clean session state; turns must be re-submitted.',
-      automatable: true,
-    },
-    {
-      step: 4,
-      title: 'Verify plugin and MCP connectivity',
-      action:
-        'After session restart, confirm all plugins have re-connected to their MCP servers ' +
-        'and tool registrations are complete.',
-      kind: 'observe',
-      expectedOutcome: 'All plugins HEALTHY; tool registry populated.',
-      automatable: false,
-    },
-    {
-      step: 5,
-      title: 'Escalate if restart loop detected',
-      action:
-        'If the session reaches SESSION_UNRECOVERABLE again within 5 minutes, ' +
-        'escalate to human review — the root cause is not self-healing.',
-      kind: 'escalate',
-      expectedOutcome: 'Human-reviewed root cause identified and resolved.',
-      automatable: false,
-    },
-  ],
-  escalationCriteria: [
-    'SESSION_UNRECOVERABLE fires more than once within 5 minutes',
-    'Session state file cannot be written (disk full, permission denied)',
-    'All plugins fail to reconnect after session restart',
-    'Runtime process exits immediately after restart attempt',
-  ],
-  tags: ['session', 'unrecoverable', 'cascade', 'critical'],
-  };
-}
-
-/** Session unrecoverable resolution playbook. */
-export const sessionUnrecoverablePlaybook: Playbook = createSessionUnrecoverablePlaybook();

package/src/runtime/ops/playbooks/stuck-turn.ts

@@ -1,197 +0,0 @@
-/**
- * Playbook: Stuck Turn / Task
- *
- * Diagnoses and resolves turns or tasks that have stopped progressing.
- * Common causes: LLM timeout, tool deadlock, event loop stall.
- */
-import type { Playbook, DiagnosticCheckResult } from '@pellux/goodvibes-sdk/platform/runtime/ops/types';
-import { safeCheck } from '@pellux/goodvibes-sdk/platform/runtime/ops/safe-check';
-import type { OpsRuntimeContextState } from '@pellux/goodvibes-sdk/platform/runtime/ops/runtime-context';
-
-export function createStuckTurnPlaybook(
-  getRuntimeContext: () => OpsRuntimeContextState | null = () => null,
-): Playbook {
-  return {
-  id: 'stuck-turn',
-  name: 'Stuck Turn / Task',
-  description:
-    'Diagnoses turns or tasks that have stopped progressing. ' +
-    'Covers LLM timeout, tool deadlock, and event-loop stall scenarios.',
-  symptoms: [
-    'Turn has been in-flight longer than the configured timeout',
-    'No new events emitted on the task event bus for > 30 s',
-    'Spinner/progress indicator frozen in TUI',
-    'CPU near 0% with pending async operations',
-    'Health check reports degraded turn throughput',
-  ],
-  checks: [
-    {
-      id: 'turn.timeout-elapsed',
-      label: 'Turn timeout elapsed',
-      description: 'Checks whether the active turn has exceeded its configured timeout.',
-      run: async (): Promise<DiagnosticCheckResult> =>
-        safeCheck(async () => {
-          const runtime = getRuntimeContext();
-          if (!runtime) {
-            return {
-              passed: false,
-              summary: 'Ops runtime context is not configured.',
-              severity: 'warning',
-            };
-          }
-          const { conversation } = runtime.store.getState();
-          if (!conversation.currentTurnId || !conversation.turnStartedAt || conversation.turnState === 'idle') {
-            return {
-              passed: true,
-              summary: 'No active turn is currently in flight.',
-              severity: 'info',
-            };
-          }
-          const elapsedMs = runtime.now() - conversation.turnStartedAt;
-          const thresholdMs = 30_000;
-          const exceeded = elapsedMs > thresholdMs;
-          return {
-            passed: !exceeded,
-            summary: exceeded
-              ? `Active turn ${conversation.currentTurnId} has exceeded ${thresholdMs}ms (${elapsedMs}ms elapsed).`
-              : `Active turn ${conversation.currentTurnId} is still within the ${thresholdMs}ms threshold.`,
-            severity: exceeded ? 'error' : 'info',
-            context: {
-              turnId: conversation.currentTurnId,
-              turnState: conversation.turnState,
-              elapsedMs,
-              thresholdMs,
-            },
-          };
-        }),
-    },
-    {
-      id: 'turn.event-bus-silent',
-      label: 'Event bus silent',
-      description: 'Checks whether the RuntimeEventBus has emitted any events recently.',
-      run: async (): Promise<DiagnosticCheckResult> =>
-        safeCheck(async () => {
-          const runtime = getRuntimeContext();
-          if (!runtime) {
-            return {
-              passed: false,
-              summary: 'Ops runtime context is not configured.',
-              severity: 'warning',
-            };
-          }
-          const silenceMs = runtime.now() - runtime.lastEventAt;
-          const thresholdMs = 30_000;
-          const silent = silenceMs > thresholdMs;
-          return {
-            passed: !silent,
-            summary: silent
-              ? `No runtime events have been observed for ${silenceMs}ms.`
-              : `Runtime event flow is active (${silenceMs}ms since the last event).`,
-            severity: silent ? 'warning' : 'info',
-            context: {
-              silenceMs,
-              thresholdMs,
-              lastEventAt: runtime.lastEventAt,
-            },
-          };
-        }),
-    },
-    {
-      id: 'turn.pending-tool-calls',
-      label: 'Pending tool calls',
-      description: 'Checks for tool calls that have been dispatched but not yet resolved.',
-      run: async (): Promise<DiagnosticCheckResult> =>
-        safeCheck(async () => {
-          const runtime = getRuntimeContext();
-          if (!runtime) {
-            return {
-              passed: false,
-              summary: 'Ops runtime context is not configured.',
-              severity: 'warning',
-            };
-          }
-          const { conversation, permissions } = runtime.store.getState();
-          const pendingToolCalls = conversation.activeToolCalls.size;
-          const awaitingDecision = permissions.awaitingDecision;
-          const blocked = pendingToolCalls > 0 || awaitingDecision;
-          return {
-            passed: !blocked,
-            summary: blocked
-              ? `Detected ${pendingToolCalls} active tool call(s)${awaitingDecision ? ' with a permission decision still pending' : ''}.`
-              : 'No active tool calls or pending permission decisions detected.',
-            severity: blocked ? 'warning' : 'info',
-            context: {
-              pendingToolCalls,
-              awaitingDecision,
-            },
-          };
-        }),
-    },
-  ],
-  steps: [
-    {
-      step: 1,
-      title: 'Identify stuck span',
-      action:
-        'Query the active span list from the RuntimeTracer. ' +
-        'Look for spans with durationMs > turnTimeoutMs and status UNSET.',
-      kind: 'observe',
-      expectedOutcome: 'One or more spans identified as candidates.',
-      automatable: false,
-    },
-    {
-      step: 2,
-      title: 'Check for tool deadlock',
-      action:
-        'Inspect the PhasedToolExecutor queue for tools awaiting permissions or locks. ' +
-        'Cross-reference with PermissionManager.pendingRequests().',
-      kind: 'observe',
-      command: 'runtime.tools.executor.dumpState()',
-      expectedOutcome: 'Tool queue is empty or shows a specific blocked tool.',
-      automatable: false,
-    },
-    {
-      step: 3,
-      title: 'Cancel the stuck turn',
-      action:
-        'Emit a task.cancel event on the RuntimeEventBus with the stuck taskId. ' +
-        'The TaskStateMachine should transition to CANCELLED within 1 s.',
-      kind: 'command',
-      command: 'eventBus.emit("task.cancel", { taskId })',
-      expectedOutcome: 'Turn transitions to CANCELLED; health check recovers.',
-      automatable: true,
-    },
-    {
-      step: 4,
-      title: 'Restart turn with reduced timeout',
-      action:
-        'Re-submit the failed turn with a shorter LLM timeout (e.g. 30 s) and ' +
-        'tool-use disabled to isolate whether the model or a tool is the root cause.',
-      kind: 'command',
-      command: 'runtime.submitTurn({ ...turnPayload, timeoutMs: 30_000, tools: [] })',
-      expectedOutcome: 'Turn completes or fails fast with a clear error.',
-      automatable: false,
-    },
-    {
-      step: 5,
-      title: 'Review LLM provider health',
-      action:
-        'Check the provider health dashboard or call the provider status endpoint. ' +
-        'Consider switching to a fallback provider if degraded.',
-      kind: 'observe',
-      expectedOutcome: 'Provider status confirmed healthy or fallback selected.',
-      automatable: false,
-    },
-  ],
-  escalationCriteria: [
-    'Multiple consecutive turns stuck after attempting cancel+restart',
-    'Event loop stall confirmed by > 60 s with zero runtime events',
-    'Memory usage growing continuously without turns completing',
-    'Core health check reports CRITICAL for > 5 minutes',
-  ],
-  tags: ['turn', 'task', 'timeout', 'deadlock', 'llm'],
-  };
-}
-
-/** Stuck turn / task resolution playbook. */
-export const stuckTurnPlaybook: Playbook = createStuckTurnPlaybook();

package/src/runtime/ops/runtime-context.ts

@@ -1,100 +0,0 @@
-import { AsyncLocalStorage } from 'async_hooks';
-import { existsSync, readFileSync } from 'fs';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { RuntimeStore } from '../store/index.ts';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-export interface OpsRuntimeContextConfig {
-  runtimeBus: RuntimeEventBus;
-  store: RuntimeStore;
-  recoveryFilePath: string;
-  lastSessionPointerPath: string;
-  now?: () => number;
-}
-
-export interface OpsRuntimeContextState {
-  runtimeBus: RuntimeEventBus;
-  store: RuntimeStore;
-  recoveryFilePath: string;
-  lastSessionPointerPath: string;
-  now: () => number;
-  lastEventAt: number;
-  sessionRecoveryFailedAt?: number;
-  sessionRecoveryFailedCount: number;
-  detach: () => void;
-}
-
-const OBSERVED_DOMAINS = [
-  'session',
-  'turn',
-  'tools',
-  'tasks',
-  'agents',
-  'workflows',
-  'providers',
-  'permissions',
-  'planner',
-  'plugins',
-  'mcp',
-  'transport',
-  'ops',
-] as const;
-
-const scopedContext = new AsyncLocalStorage<OpsRuntimeContextState | null>();
-
-function createOpsRuntimeContextState(config: OpsRuntimeContextConfig): OpsRuntimeContextState {
-  const now = config.now ?? Date.now;
-  const unsubs = OBSERVED_DOMAINS.map((domain) =>
-    config.runtimeBus.onDomain(domain, (envelope) => {
-      state.lastEventAt = envelope.ts;
-      if (envelope.type === 'SESSION_RECOVERY_FAILED') {
-        state.sessionRecoveryFailedAt = envelope.ts;
-        state.sessionRecoveryFailedCount += 1;
-      }
-    }));
-
-  const state: OpsRuntimeContextState = {
-    runtimeBus: config.runtimeBus,
-    store: config.store,
-    recoveryFilePath: config.recoveryFilePath,
-    lastSessionPointerPath: config.lastSessionPointerPath,
-    now,
-    lastEventAt: now(),
-    sessionRecoveryFailedCount: 0,
-    detach: () => {
-      for (const unsub of unsubs) unsub();
-    },
-  };
-  return state;
-}
-
-export async function withOpsRuntimeContext<T>(
-  config: OpsRuntimeContextConfig,
-  fn: () => Promise<T> | T,
-): Promise<T> {
-  const state = createOpsRuntimeContextState(config);
-  try {
-    return await scopedContext.run(state, fn);
-  } finally {
-    state.detach();
-  }
-}
-
-export function readRecoveryFileMetadata(path: string): { ok: boolean; summary: string } {
-  if (!existsSync(path)) {
-    return { ok: false, summary: 'Recovery file does not exist.' };
-  }
-  try {
-    const [firstLine] = readFileSync(path, 'utf-8').split('\n');
-    if (!firstLine) {
-      return { ok: false, summary: 'Recovery file exists but is empty.' };
-    }
-    JSON.parse(firstLine);
-    return { ok: true, summary: 'Recovery file exists and has valid metadata.' };
-  } catch (error) {
-    return {
-      ok: false,
-      summary: `Recovery file is not parseable: ${summarizeError(error)}`,
-    };
-  }
-}

package/src/runtime/ops-api.ts

@@ -1,27 +0,0 @@
-import type { RuntimeTask } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
-import type { UiTasksSnapshot } from './ui-read-models.ts';
-import type { TaskCreateParams, TaskFailParams, TaskUpdateParams } from '@pellux/goodvibes-sdk/platform/runtime/tasks/types';
-
-export interface OpsTaskApi {
-  snapshot(): UiTasksSnapshot;
-  list(limit?: number): readonly RuntimeTask[];
-  get(taskId: string): RuntimeTask | null;
-  running(): readonly RuntimeTask[];
-  create(input: TaskCreateParams): RuntimeTask;
-  update(taskId: string, input: TaskUpdateParams): RuntimeTask;
-  complete(taskId: string, result?: unknown): RuntimeTask;
-  fail(taskId: string, input: TaskFailParams): RuntimeTask;
-  cancel(taskId: string, note?: string): void;
-  pause(taskId: string, note?: string): void;
-  resume(taskId: string, note?: string): void;
-  retry(taskId: string, note?: string): void;
-}
-
-export interface OpsAgentApi {
-  cancel(agentId: string, note?: string): void;
-}
-
-export interface OpsApi {
-  readonly tasks: OpsTaskApi;
-  readonly agents: OpsAgentApi;
-}