substrate-ai 0.20.64 → 0.20.66

package/dist/index-c924O9mj.d.ts

@@ -0,0 +1,1432 @@
+import { z } from "zod";
+
+//#region packages/core/dist/types.d.ts
+/**
+* Core types for Substrate
+* Shared type definitions used across all modules
+*/
+/** Unique identifier for a task in the DAG */
+/**
+ * Core types for Substrate
+ * Shared type definitions used across all modules
+ */
+/** Unique identifier for a task in the DAG */
+type TaskId$1 = string;
+/** Unique identifier for a worker/agent instance */
+
+/** Unique identifier for a registered agent type */
+type AgentId = string;
+/** Status of an individual task */
+
+/** Billing mode for a worker/agent */
+type BillingMode = 'subscription' | 'api' | 'free'; //#endregion
+//#region packages/core/dist/events/types.d.ts
+/** Severity level for errors and log messages */
+/**
+ * Base event type primitives for the TypedEventBus system.
+ *
+ * These types are the foundation of the event bus contract.
+ * All event maps must satisfy EventMap; all handlers must satisfy EventHandler<T>.
+ */
+/**
+ * Base constraint for event maps.
+ * Each key is an event name (string), and the value is the payload type.
+ *
+ * Using `object` (not `Record<string, unknown>`) so that TypeScript interfaces
+ * with named properties (without index signatures) satisfy the constraint.
+ * TypeScript interfaces extend `object` but may not extend `Record<string, unknown>`
+ * unless they have an explicit index signature.
+ */
+type EventMap = object;
+/**
+ * A typed event handler function for payload type T.
+ */
+type EventHandler<T> = (payload: T) => void;
+
+//#endregion
+//#region packages/core/dist/events/event-bus.d.ts
+//# sourceMappingURL=types.d.ts.map
+/**
+ * A type-safe event bus parameterized over an event map E.
+ *
+ * @example
+ * const bus: TypedEventBus<CoreEvents & SdlcEvents> = createEventBus()
+ * bus.on('orchestrator:story-complete', ({ storyKey }) => { ... })
+ */
+interface TypedEventBus<E extends EventMap> {
+  /**
+   * Emit an event with a typed payload.
+   * All registered handlers for this event key are called synchronously.
+   */
+  emit<K extends keyof E>(event: K, payload: E[K]): void;
+  /**
+   * Register a handler for an event.
+   */
+  on<K extends keyof E>(event: K, handler: EventHandler<E[K]>): void;
+  /**
+   * Unregister a previously registered handler.
+   */
+  off<K extends keyof E>(event: K, handler: EventHandler<E[K]>): void;
+}
+
+//#endregion
+//#region packages/core/dist/routing/routing-decision.d.ts
+/**
+ * Concrete implementation of TypedEventBus backed by Node.js EventEmitter.
+ *
+ * Dispatch is SYNCHRONOUS — all handlers run before emit() returns (per ADR-004).
+ * maxListeners is set to 100 to avoid spurious warnings in large systems.
+ *
+ * @example
+ * const bus = new TypedEventBusImpl<CoreEvents & SdlcEvents>()
+ * bus.on('orchestrator:story-complete', ({ storyKey }) => { ... })
+ * bus.emit('orchestrator:story-complete', { storyKey: '1-1', reviewCycles: 1 })
+ */
+/**
+ * RoutingDecision — type definition and factory for routing decisions.
+ *
+ * A RoutingDecision is the output of the RoutingEngine.routeTask() method.
+ * It captures which agent was selected, the billing mode, and the rationale
+ * for the routing choice (NFR7 — audit trail for cost tracking).
+ */
+/**
+ * Advisory recommendation from monitor agent.
+ * Defined locally to avoid importing the monitor module into core.
+ *
+ * The core fields mirror the monitor module's concrete Recommendation type
+ * (all required) so that:
+ *  1. monitor.Recommendation is structurally assignable to MonitorRecommendation ✓
+ *  2. MonitorRecommendation is structurally assignable to monitor.Recommendation ✓
+ *     (extra optional fields `model` and `rationale` are permitted by structural typing)
+ *
+ * This bidirectional compatibility prevents TypeScript errors when callers store
+ * `decision.monitorRecommendation` in a Recommendation-typed variable (AC2, Story 41-4).
+ */
+interface MonitorRecommendation {
+  task_type: string;
+  current_agent: string;
+  recommended_agent: string;
+  reason: string;
+  /** Confidence tier — 'low', 'medium', or 'high' */
+  confidence: 'low' | 'medium' | 'high';
+  current_success_rate: number;
+  recommended_success_rate: number;
+  current_avg_tokens: number;
+  recommended_avg_tokens: number;
+  improvement_percentage: number;
+  sample_size_current: number;
+  sample_size_recommended: number;
+  /** Optional model override suggestion (used in some contexts) */
+  model?: string;
+  rationale?: string;
+}
+/**
+ * The result of a routing decision for a task.
+ *
+ * @example
+ * {
+ *   taskId: 'task-1',
+ *   agent: 'claude',
+ *   billingMode: 'subscription',
+ *   rationale: 'Subscription-first: Claude subscription available, tokens within limit',
+ *   fallbackChain: ['claude', 'codex'],
+ * }
+ */
+interface RoutingDecision {
+  /** Task identifier this decision was made for */
+  taskId: string;
+  /** Selected CLI agent name (e.g., 'claude', 'codex', 'gemini') */
+  agent: string;
+  /** Billing mode for this routing decision */
+  billingMode: 'subscription' | 'api' | 'unavailable';
+  /** Optional model preference if specified in routing policy */
+  model?: string;
+  /** Human-readable rationale for the routing choice (required for NFR7 audit) */
+  rationale: string;
+  /** Agents tried in order during fallback chain evaluation */
+  fallbackChain?: string[];
+  /** Estimated cost in USD for this task (if known) */
+  estimatedCostUsd?: number;
+  /** Rate limit state at time of decision */
+  rateLimit?: {
+    tokensUsedInWindow: number;
+    limit: number;
+  };
+  /**
+   * Advisory recommendation from monitor agent (AC5, Story 8.6).
+   * Present when use_monitor_recommendations=true and a recommendation is available.
+   * This is informational only — routing policy always takes precedence.
+   */
+  monitorRecommendation?: MonitorRecommendation;
+  /**
+   * Whether the monitor agent was consulted for this routing decision (AC5).
+   * True when use_monitor_recommendations=true, regardless of whether a
+   * recommendation was available.
+   */
+  monitorInfluenced: boolean;
+}
+
+//#endregion
+//#region packages/core/dist/dispatch/types.d.ts
+/**
+ * Builder for constructing RoutingDecision objects with a fluent API.
+ *
+ * @example
+ * const decision = makeRoutingDecision('task-1')
+ *   .withAgent('claude', 'subscription')
+ *   .withRationale('Subscription-first: Claude subscription available')
+ *   .withFallbackChain(['claude', 'codex'])
+ *   .build()
+ */
+
+/**
+ * Logger interface compatible with both pino-style loggers and console.
+ * Methods accept any argument pattern: (msg: string) or (obj: unknown, msg?: string).
+ */
+interface ILogger {
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+} //#endregion
+//#region packages/core/dist/config/types.d.ts
+
+//# sourceMappingURL=types.d.ts.map
+declare const SubstrateConfigSchema: z.ZodObject<{
+  config_format_version: z.ZodEnum<{
+    1: "1";
+  }>;
+  task_graph_version: z.ZodOptional<z.ZodEnum<{
+    1: "1";
+  }>>;
+  global: z.ZodObject<{
+    log_level: z.ZodEnum<{
+      trace: "trace";
+      debug: "debug";
+      info: "info";
+      warn: "warn";
+      error: "error";
+      fatal: "fatal";
+    }>;
+    max_concurrent_tasks: z.ZodNumber;
+    budget_cap_tokens: z.ZodNumber;
+    budget_cap_usd: z.ZodNumber;
+    workspace_dir: z.ZodOptional<z.ZodString>;
+    update_check: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>;
+  providers: z.ZodObject<{
+    claude: z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodBoolean;
+      cli_path: z.ZodOptional<z.ZodString>;
+      subscription_routing: z.ZodEnum<{
+        subscription: "subscription";
+        api: "api";
+        auto: "auto";
+        disabled: "disabled";
+      }>;
+      max_concurrent: z.ZodNumber;
+      rate_limit: z.ZodOptional<z.ZodObject<{
+        tokens: z.ZodNumber;
+        window_seconds: z.ZodNumber;
+      }, z.core.$strict>>;
+      api_key_env: z.ZodOptional<z.ZodString>;
+      api_billing: z.ZodBoolean;
+    }, z.core.$strict>>;
+    codex: z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodBoolean;
+      cli_path: z.ZodOptional<z.ZodString>;
+      subscription_routing: z.ZodEnum<{
+        subscription: "subscription";
+        api: "api";
+        auto: "auto";
+        disabled: "disabled";
+      }>;
+      max_concurrent: z.ZodNumber;
+      rate_limit: z.ZodOptional<z.ZodObject<{
+        tokens: z.ZodNumber;
+        window_seconds: z.ZodNumber;
+      }, z.core.$strict>>;
+      api_key_env: z.ZodOptional<z.ZodString>;
+      api_billing: z.ZodBoolean;
+    }, z.core.$strict>>;
+    gemini: z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodBoolean;
+      cli_path: z.ZodOptional<z.ZodString>;
+      subscription_routing: z.ZodEnum<{
+        subscription: "subscription";
+        api: "api";
+        auto: "auto";
+        disabled: "disabled";
+      }>;
+      max_concurrent: z.ZodNumber;
+      rate_limit: z.ZodOptional<z.ZodObject<{
+        tokens: z.ZodNumber;
+        window_seconds: z.ZodNumber;
+      }, z.core.$strict>>;
+      api_key_env: z.ZodOptional<z.ZodString>;
+      api_billing: z.ZodBoolean;
+    }, z.core.$strict>>;
+  }, z.core.$strict>;
+  cost_tracker: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodBoolean;
+    token_rates_provider: z.ZodEnum<{
+      builtin: "builtin";
+      custom: "custom";
+    }>;
+    track_planning_costs: z.ZodBoolean;
+    savings_reporting: z.ZodBoolean;
+  }, z.core.$strict>>;
+  budget: z.ZodOptional<z.ZodObject<{
+    default_task_budget_usd: z.ZodNumber;
+    default_session_budget_usd: z.ZodNumber;
+    planning_costs_count_against_budget: z.ZodBoolean;
+    warning_threshold_percent: z.ZodNumber;
+  }, z.core.$strict>>;
+  telemetry: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    port: z.ZodDefault<z.ZodNumber>;
+    meshUrl: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  trivialOutputThreshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+type SubstrateConfig = z.infer<typeof SubstrateConfigSchema>; //#endregion
+//#region packages/core/dist/events/core-events.d.ts
+/** Unique task identifier */
+type TaskId = string;
+/** Unique worker identifier */
+type WorkerId = string;
+/** Result of a completed task */
+interface EventTaskResult {
+  output?: string;
+  exitCode?: number;
+  tokensUsed?: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  durationMs?: number;
+  costUsd?: number;
+  agent?: string;
+}
+/** Error payload for a failed task */
+interface EventTaskError {
+  message: string;
+  code?: string;
+  stack?: string;
+}
+/**
+ * Typed map of all core infrastructure events.
+ * SDLC-specific events (orchestrator:story-*, plan:*, solutioning:*, story:*, pipeline:*)
+ * are excluded and belong to SdlcEvents.
+ */
+interface CoreEvents {
+  /** Task has all dependencies satisfied and is ready to be assigned */
+  'task:ready': {
+    taskId: TaskId;
+    taskType?: string;
+  };
+  /** A worker has begun execution of a task */
+  'task:started': {
+    taskId: TaskId;
+    workerId: WorkerId;
+    agent: string;
+  };
+  /** Incremental progress report from a running task */
+  'task:progress': {
+    taskId: TaskId;
+    message: string;
+    tokensUsed?: number;
+  };
+  /** Task has completed successfully */
+  'task:complete': {
+    taskId: TaskId;
+    result: EventTaskResult;
+    taskType?: string;
+  };
+  /** Task has failed with an error */
+  'task:failed': {
+    taskId: TaskId;
+    error: EventTaskError;
+  };
+  /** Task was cancelled */
+  'task:cancelled': {
+    taskId: TaskId;
+    reason: string;
+  };
+  /** Task is being retried after a failure */
+  'task:retrying': {
+    taskId: TaskId;
+    attempt: number;
+    maxAttempts: number;
+  };
+  /** A task has been routed to an agent with billing mode decision */
+  'task:routed': {
+    taskId: TaskId;
+    decision: RoutingDecision;
+  };
+  /** Budget cap has been set for a task */
+  'task:budget-set': {
+    taskId: TaskId;
+    budgetUsd: number;
+  };
+  /** A worker subprocess was spawned */
+  'worker:spawned': {
+    workerId: WorkerId;
+    taskId: TaskId;
+    agent: string;
+  };
+  /** A worker subprocess was terminated */
+  'worker:terminated': {
+    workerId: WorkerId;
+    reason: string;
+  };
+  /** Spending is approaching the configured budget limit */
+  'budget:warning': {
+    taskId: TaskId;
+    currentSpend: number;
+    limit: number;
+  };
+  /** Spending has exceeded the configured budget limit */
+  'budget:exceeded': {
+    taskId: TaskId;
+    spend: number;
+    limit: number;
+  };
+  /** Task is approaching its budget cap (80% threshold) */
+  'budget:warning:task': {
+    taskId: TaskId;
+    currentCostUsd: number;
+    budgetUsd: number;
+    percentageUsed: number;
+  };
+  /** Task has exceeded its budget cap — force-terminate worker */
+  'budget:exceeded:task': {
+    taskId: TaskId;
+    currentCostUsd: number;
+    budgetUsd: number;
+  };
+  /** Session-wide budget is approaching the cap (80% threshold) */
+  'budget:warning:session': {
+    sessionId: string;
+    currentCostUsd: number;
+    budgetUsd: number;
+    percentageUsed: number;
+  };
+  /** Session-wide budget has been exceeded — terminate all workers */
+  'session:budget:exceeded': {
+    sessionId: string;
+    currentCostUsd: number;
+    budgetUsd: number;
+  };
+  /** Budget cap has been set for a session */
+  'session:budget-set': {
+    sessionId: string;
+    budgetUsd: number;
+  };
+  /** A task graph has been loaded and validated */
+  'graph:loaded': {
+    sessionId: string;
+    taskCount: number;
+    readyCount: number;
+  };
+  /** All tasks in the graph have completed or failed */
+  'graph:complete': {
+    totalTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    totalCostUsd: number;
+  };
+  /** Graph execution was cancelled */
+  'graph:cancelled': {
+    cancelledTasks: number;
+  };
+  /** Graph execution was paused */
+  'graph:paused': Record<string, never>;
+  /** Graph execution was resumed */
+  'graph:resumed': Record<string, never>;
+  /** A git worktree was created for a task */
+  'worktree:created': {
+    taskId: TaskId;
+    branchName: string;
+    worktreePath: string;
+    createdAt?: Date;
+  };
+  /** A task's worktree branch was merged */
+  'worktree:merged': {
+    taskId: TaskId;
+    branch: string;
+    mergedFiles: string[];
+  };
+  /** A merge conflict was detected in a task's worktree */
+  'worktree:conflict': {
+    taskId: TaskId;
+    branch: string;
+    conflictingFiles: string[];
+  };
+  /** A task's worktree was removed */
+  'worktree:removed': {
+    taskId: TaskId;
+    branchName: string;
+  };
+  /** A task's cost has been recorded by the cost tracker */
+  'cost:recorded': {
+    taskId: string;
+    sessionId: string;
+    costUsd: number;
+    savingsUsd: number;
+    billingMode: 'subscription' | 'api';
+  };
+  /** A task's metrics have been recorded by the monitor */
+  'monitor:metrics_recorded': {
+    taskId: string;
+    agent: string;
+    taskType: string;
+  };
+  /** A routing recommendation has been generated by the monitor */
+  'monitor:recommendation_generated': {
+    taskType: string;
+    recommendedAgent: string;
+    confidence: number;
+  };
+  /** Configuration has been reloaded */
+  'config:reloaded': {
+    path: string;
+    previousConfig: SubstrateConfig;
+    newConfig: SubstrateConfig;
+    changedKeys: string[];
+  };
+  /**
+   * Emitted when a sub-agent dispatch is resolved to a specific model via RoutingResolver.
+   */
+  'routing:model-selected': {
+    dispatchId: string;
+    taskType: string;
+    phase: string;
+    model: string;
+    source: 'phase' | 'override';
+  };
+  /**
+   * Emitted by RoutingTuner when it successfully applies an auto-tune downgrade.
+   */
+  'routing:auto-tuned': {
+    runId: string;
+    phase: string;
+    oldModel: string;
+    newModel: string;
+    estimatedSavingsPct: number;
+  };
+  /** A provider has become unavailable */
+  'provider:unavailable': {
+    provider: string;
+    reason: 'rate_limit' | 'disabled';
+    resetAtMs?: number;
+  };
+  /** A provider has become available */
+  'provider:available': {
+    provider: string;
+  };
+  /** A newer version of the toolkit is available */
+  'version:update_available': {
+    currentVersion: string;
+    latestVersion: string;
+    breaking: boolean;
+  };
+  /** A sub-agent subprocess was spawned by the dispatch engine */
+  'agent:spawned': {
+    dispatchId: string;
+    agent: string;
+    taskType: string;
+  };
+  /** Incremental stdout data received from a running sub-agent */
+  'agent:output': {
+    dispatchId: string;
+    data: string;
+  };
+  /** A sub-agent completed successfully */
+  'agent:completed': {
+    dispatchId: string;
+    exitCode: number;
+    output: string;
+    /** Estimated input tokens (char-length heuristic) */
+    inputTokens?: number;
+    /** Estimated output tokens (char-length heuristic) */
+    outputTokens?: number;
+  };
+  /** A sub-agent exited with a non-zero code or encountered an error */
+  'agent:failed': {
+    dispatchId: string;
+    error: string;
+    exitCode: number;
+  };
+  /** A sub-agent was killed because it exceeded its timeout */
+  'agent:timeout': {
+    dispatchId: string;
+    timeoutMs: number;
+  };
+  /**
+   * A dispatch was killed by the timeout handler.
+   * Emitted for both the initial attempt (attemptNumber: 1) and the retry
+   * attempt (attemptNumber: 2, 1.5× the initial timeout).
+   * Story 66-4: closes obs_2026-05-04_023 fix #3.
+   * Story 66-5: adds stderrTail/stdoutTail forensic capture
+   * (obs_2026-05-04_023 fix #4). Optional for backward-compat.
+   */
+  'dispatch:spawnsync-timeout': {
+    type: 'dispatch:spawnsync-timeout';
+    storyKey: string;
+    taskType: string;
+    attemptNumber: 1 | 2;
+    timeoutMs: number;
+    elapsedAtKill: number;
+    pid?: number;
+    occurredAt: string;
+    /** Tail of subprocess stderr captured at kill time (~64KB max, UTF-8) */
+    stderrTail?: string;
+    /** Tail of subprocess stdout captured at kill time (~64KB max, UTF-8) */
+    stdoutTail?: string;
+  };
+  /**
+   * Two or more concurrent stories have overlapping target file paths.
+   * Motivating incidents: Epic 66 run a832487a + Epic 67 run a59e4c96
+   * (concurrent-dispatch races that caused transient verification failures).
+   * Mirror of OrchestratorEvents['dispatch:cross-story-file-collision'];
+   * both must stay in sync.
+   */
+  'dispatch:cross-story-file-collision': {
+    storyKeys: string[];
+    collisionPaths: string[];
+    recommendedAction: 'serialize' | 'warn';
+  };
+  /**
+   * Cross-story race recovery succeeded: fresh verification passed for a story
+   * whose original verification result was recorded before a concurrent story's
+   * commit landed on overlapping files.
+   *
+   * Story 70-1. Motivating incidents: Epic 66 (run a832487a), Epic 67 (run a59e4c96).
+   * Mirror of OrchestratorEvents['pipeline:cross-story-race-recovered'];
+   * both must stay in sync.
+   */
+  'pipeline:cross-story-race-recovered': {
+    runId: string;
+    storyKey: string;
+    originalFindings: unknown[];
+    freshFindings: unknown[];
+    recoveryDurationMs: number;
+  };
+  /**
+   * Cross-story race recovery completed but fresh verification still failed:
+   * the story genuinely has issues that are not attributable to the race condition.
+   *
+   * Story 70-1. Motivating incidents: Epic 66 (run a832487a), Epic 67 (run a59e4c96).
+   * Mirror of OrchestratorEvents['pipeline:cross-story-race-still-failed'];
+   * both must stay in sync.
+   */
+  'pipeline:cross-story-race-still-failed': {
+    runId: string;
+    storyKey: string;
+    freshFindings: unknown[];
+    recoveryDurationMs: number;
+  };
+  /**
+   * Story 72-2: A critical halt decision was skipped under --non-interactive mode.
+   *
+   * Emitted when the pipeline would have prompted the operator (interactive stdin
+   * read) but --non-interactive suppressed stdin and auto-applied the default
+   * action instead. Operators reviewing the run via `substrate report` can see
+   * which halts were auto-skipped and what actions were applied.
+   *
+   * Mirror of OrchestratorEvents['decision:halt-skipped-non-interactive']; both
+   * must stay in sync.
+   */
+  'decision:halt-skipped-non-interactive': {
+    runId: string;
+    /** Halt decision type that was skipped (e.g., 'halt:escalation', 'halt:critical'). */
+    decisionType: string;
+    /** Severity of the skipped halt (e.g., 'critical'). */
+    severity: string;
+    /** Action that was applied in place of the operator prompt (e.g., 'continue'). */
+    defaultAction: string;
+    /** Human-readable reason for skipping (e.g., 'non-interactive: stdin prompt suppressed'). */
+    reason: string;
+  };
+  /**
+   * Story 72-1: A halt-able decision was routed and the policy requires halting.
+   * Emitted when routeDecision() returns halt=true for a given policy.
+   * Mirror of OrchestratorEvents['decision:halt']; both must stay in sync.
+   */
+  'decision:halt': {
+    runId: string;
+    /** The decision type that triggered the halt (e.g., 'cost-ceiling-exhausted'). */
+    decisionType: string;
+    /** Severity of the decision (e.g., 'critical', 'fatal'). */
+    severity: string;
+    /** Human-readable reason for the halt. */
+    reason: string;
+  };
+  /**
+   * Story 72-1: A halt-able decision was routed and the policy allows autonomous action.
+   * Emitted when routeDecision() returns halt=false for a given policy.
+   * Caller applies defaultAction without operator intervention.
+   * Mirror of OrchestratorEvents['decision:autonomous']; both must stay in sync.
+   */
+  'decision:autonomous': {
+    runId: string;
+    /** The decision type that was routed autonomously (e.g., 'build-verification-failure'). */
+    decisionType: string;
+    /** Severity of the decision (e.g., 'info', 'warning', 'critical'). */
+    severity: string;
+    /** The action applied autonomously (e.g., 'escalate-without-halt', 'continue-autonomous'). */
+    defaultAction: string;
+    /** Human-readable reason for autonomous action. */
+    reason: string;
+  };
+  /** Orchestrator has been fully initialized and is ready to process tasks */
+  'orchestrator:ready': Record<string, never>;
+  /** Orchestrator shutdown has been initiated */
+  'orchestrator:shutdown': {
+    reason: string;
+  };
+  /**
+   * Story 73-1: Tier A auto-retry — recovery engine re-dispatched a story
+   * with diagnosis + findings prepended to the retry prompt.
+   *
+   * Mirror of OrchestratorEvents['recovery:tier-a-retry']; both must stay in sync.
+   */
+  'recovery:tier-a-retry': {
+    runId: string;
+    storyKey: string;
+    rootCause: string;
+    attempt: number;
+    retryBudgetRemaining: number;
+  };
+  /**
+   * Story 73-1: Tier B re-scope proposal — recovery engine appended a
+   * re-scope proposal to RunManifest.pending_proposals.
+   *
+   * Mirror of OrchestratorEvents['recovery:tier-b-proposal']; both must stay in sync.
+   */
+  'recovery:tier-b-proposal': {
+    runId: string;
+    storyKey: string;
+    rootCause: string;
+    attempts: number;
+    suggestedAction: string;
+    blastRadius: string[];
+  };
+  /**
+   * Story 73-1: Tier C halt — recovery engine determined a halt is required.
+   * The orchestrator yields to the Decision Router / Interactive Prompt (Story 73-2).
+   *
+   * Mirror of OrchestratorEvents['recovery:tier-c-halt']; both must stay in sync.
+   */
+  'recovery:tier-c-halt': {
+    runId: string;
+    storyKey: string;
+    rootCause: string;
+  };
+  /**
+   * Story 73-1: Safety valve — pending_proposals count reached 5 or more.
+   * The orchestrator exits the main loop with code 1.
+   *
+   * Mirror of OrchestratorEvents['pipeline:halted-pending-proposals']; both
+   * must stay in sync.
+   */
+  'pipeline:halted-pending-proposals': {
+    runId: string;
+    pendingProposalsCount: number;
+  };
+} //#endregion
+//#region packages/core/dist/persistence/types.d.ts
+
+//# sourceMappingURL=core-events.d.ts.map
+/**
+ * Unified async database adapter interface.
+ * All persistence backends implement this interface.
+ */
+interface DatabaseAdapter {
+  /**
+   * The persistence backend powering this adapter.
+   * - 'dolt': backed by a Dolt SQL database (persists to disk)
+   * - 'memory': backed by in-memory Maps (no persistence, lost on process exit)
+   */
+  readonly backendType: 'dolt' | 'memory';
+  /**
+   * Execute a SQL query and return typed rows.
+   * @param sql - SQL query string (use ? for parameter placeholders)
+   * @param params - Optional array of parameter values
+   */
+  query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+  /**
+   * Execute a SQL statement with no return value.
+   * Suitable for DDL statements (CREATE TABLE, DROP TABLE) and DML without results.
+   * @param sql - SQL statement string
+   */
+  exec(sql: string): Promise<void>;
+  /**
+   * Execute a function within a database transaction.
+   * Commits on successful return, rolls back on thrown error.
+   * @param fn - Async function that receives the adapter and performs operations
+   */
+  transaction<T>(fn: (adapter: DatabaseAdapter) => Promise<T>): Promise<T>;
+  /**
+   * Close the database connection and release all resources.
+   */
+  close(): Promise<void>;
+  /**
+   * Query story keys from the `ready_stories` SQL view.
+   *
+   * Returns an array of story key strings (e.g. ['31-1', '31-2']) for stories
+   * whose status is `planned` or `ready` and whose hard dependencies are all
+   * `complete` in the work graph.
+   *
+   * Returns `[]` when:
+   *   - The `ready_stories` view does not exist (story 31-1 schema not applied)
+   *   - The `stories` table is empty (story 31-2 ingestion has not run)
+   *   - The adapter does not support the work graph (InMemory)
+   *
+   * Callers should treat `[]` as a signal to fall through to the legacy
+   * story discovery chain (decisions table → epic-shard → epics.md).
+   */
+  queryReadyStories(): Promise<string[]>;
+}
+
+//#endregion
+//#region packages/core/dist/config/errors.d.ts
+/**
+ * Configuration for the `createDatabaseAdapter` factory.
+ */
+/**
+ * Config-specific error classes for @substrate-ai/core.
+ *
+ * AdtError is defined here as the canonical base class. ConfigError and
+ * ConfigIncompatibleFormatError extend it. The monolith's src/core/errors.ts
+ * re-exports AdtError from here so that all error classes share the same
+ * base class instance — enabling instanceof checks to work across the
+ * monolith/core boundary.
+ */
+/** Base error class for all Substrate errors */
+declare class AdtError extends Error {
+  readonly code: string;
+  readonly context: Record<string, unknown>;
+  constructor(message: string, code: string, context?: Record<string, unknown>);
+  toJSON(): Record<string, unknown>;
+}
+/** Error thrown when configuration is invalid or missing */
+declare class ConfigError extends AdtError {
+  constructor(message: string, context?: Record<string, unknown>);
+}
+/** Error thrown when a config file uses an incompatible format version */
+declare class ConfigIncompatibleFormatError extends AdtError {
+  constructor(message: string, context?: Record<string, unknown>);
+}
+
+//#endregion
+//#region packages/core/dist/adapters/types.d.ts
+//# sourceMappingURL=errors.d.ts.map
+/**
+ * A spawn command descriptor that the orchestrator uses to invoke a CLI agent.
+ * Contains all information needed to execute an agent process.
+ */
+interface SpawnCommand {
+  /** The binary to execute (e.g., "claude", "codex", "gemini") */
+  binary: string;
+  /** Arguments to pass to the binary */
+  args: string[];
+  /** Optional environment variable overrides */
+  env?: Record<string, string>;
+  /** Optional list of environment variable keys to unset in the child process */
+  unsetEnvKeys?: string[];
+  /** Working directory for the process */
+  cwd: string;
+  /** Optional data to pipe to stdin */
+  stdin?: string;
+  /** Optional timeout in milliseconds */
+  timeoutMs?: number;
+}
+/**
+ * Options passed to adapter methods for each invocation.
+ * Controls execution context for a specific task run.
+ */
+interface AdapterOptions {
+  /** Path to the git worktree for this task */
+  worktreePath: string;
+  /** Billing mode to use for this execution */
+  billingMode: BillingMode;
+  /** Optional model identifier override */
+  model?: string;
+  /** Optional additional CLI flags to append */
+  additionalFlags?: string[];
+  /** Optional API key override (used when billingMode is 'api') */
+  apiKey?: string;
+  /** Optional maximum agentic turns (passed as --max-turns to Claude CLI) */
+  maxTurns?: number;
+  /**
+   * Optional OTLP endpoint URL for telemetry export (Story 27-9).
+   * When set, injects OTLP env vars into the spawned process so that
+   * Claude Code exports telemetry to the local IngestionServer.
+   * Example: "http://localhost:4318"
+   */
+  otlpEndpoint?: string;
+  /**
+   * Optional story key for OTEL resource attribute tagging.
+   * Injected as `substrate.story_key` via OTEL_RESOURCE_ATTRIBUTES
+   * so the telemetry pipeline can group spans/events per story.
+   */
+  storyKey?: string;
+  /**
+   * Optional maximum context tokens. Historically passed as --max-context-tokens to
+   * Claude CLI; that flag was removed in Claude Code v2.x and is now silently ignored
+   * by the claude-adapter. The field remains on the options shape for backward compat
+   * with callers (Story 30-8 efficiency-gated retry logic) but no longer constrains
+   * dispatch behavior. --max-turns continues to bound dispatch length.
+   */
+  maxContextTokens?: number;
+  /**
+   * Optional optimization directives derived from prior stories' telemetry (Story 30-6).
+   * When set, appended to the system prompt to guide the sub-agent toward efficient patterns.
+   * Generated by TelemetryAdvisor.formatOptimizationDirectives().
+   */
+  optimizationDirectives?: string;
+  /** Dispatch context: task type (create-story, dev-story, code-review, etc.) for OTLP attribution */
+  taskType?: string;
+  /** Dispatch context: unique dispatch ID for per-dispatch telemetry correlation */
+  dispatchId?: string;
+}
+/**
+ * Capabilities reported by an adapter for this CLI agent.
+ * Used for routing and planning decisions.
+ */
+interface AdapterCapabilities {
+  /** Whether the agent outputs structured JSON */
+  supportsJsonOutput: boolean;
+  /** Whether the agent supports streaming output */
+  supportsStreaming: boolean;
+  /** Whether the agent supports subscription-based billing */
+  supportsSubscriptionBilling: boolean;
+  /** Whether the agent supports API-key-based billing */
+  supportsApiBilling: boolean;
+  /** Whether the agent can generate task planning graphs */
+  supportsPlanGeneration: boolean;
+  /** Maximum context tokens the agent supports */
+  maxContextTokens: number;
+  /** Task types this agent can handle */
+  supportedTaskTypes: string[];
+  /** Programming languages the agent supports */
+  supportedLanguages: string[];
+  /**
+   * Timeout multiplier relative to default dispatch timeouts.
+   * Agents that are slower (e.g., Codex) declare a multiplier > 1.0
+   * so the dispatcher scales timeouts automatically.
+   * Default: 1.0 (no scaling).
+   */
+  timeoutMultiplier?: number;
+  /**
+   * Whether the agent supports a --system-prompt flag.
+   * Claude Code: true. Codex/Gemini: false.
+   * When false, system-level instructions must be embedded in the prompt itself.
+   */
+  supportsSystemPrompt?: boolean;
+  /**
+   * Whether the agent exports OTLP telemetry (spans, metrics, logs).
+   * Claude Code: true. Codex/Gemini: false.
+   * When false, telemetry is heuristic-only (character-based token estimates).
+   */
+  supportsOtlpExport?: boolean;
+  /**
+   * Whether the dispatcher should append a YAML output format reminder to prompts.
+   * Claude Code: false (follows methodology pack format instructions reliably).
+   * Codex/Gemini: true (need explicit final nudge to emit fenced YAML blocks).
+   */
+  requiresYamlSuffix?: boolean;
+  /**
+   * Default maximum review cycles for this agent backend.
+   * Claude Code: 2 (converges quickly). Codex: 3 (needs more iterations).
+   * Overridden by explicit --max-review-cycles CLI flag.
+   */
+  defaultMaxReviewCycles?: number;
+}
+/**
+ * Result returned from an adapter health check.
+ * Indicates whether the CLI binary is present and functional.
+ */
+interface AdapterHealthResult {
+  /** Whether the adapter is considered healthy and usable */
+  healthy: boolean;
+  /** Detected version string of the CLI binary */
+  version?: string;
+  /** Full path to the CLI binary, if resolved */
+  cliPath?: string;
+  /** Error message when healthy is false */
+  error?: string;
+  /** Detected billing mode(s) available for this adapter */
+  detectedBillingModes?: BillingMode[];
+  /** Whether the CLI supports headless/non-interactive mode */
+  supportsHeadless: boolean;
+}
+/**
+ * Parsed result from a task execution.
+ * Normalized representation from CLI agent JSON output.
+ */
+interface TaskResult {
+  /** Task identifier this result belongs to */
+  taskId?: TaskId$1;
+  /** Whether the task completed successfully */
+  success: boolean;
+  /** Primary output content from the agent */
+  output: string;
+  /** Error message if the task failed */
+  error?: string;
+  /** Raw exit code from the CLI process */
+  exitCode: number;
+  /** Execution metadata */
+  metadata?: {
+    executionTime?: number;
+    tokensUsed?: TokenEstimate;
+  };
+  /**
+   * True when the dispatcher's AdapterOutputNormalizer exhausted all
+   * normalization strategies without extracting parseable YAML.
+   * Authoritative signal for the 'adapter-format' root cause category (story 53-10).
+   * Optional — existing callers without the field continue to compile unchanged.
+   */
+  adapterError?: boolean;
+}
+/**
+ * Token usage estimate for budget tracking.
+ */
+interface TokenEstimate {
+  /** Estimated input tokens */
+  input: number;
+  /** Estimated output tokens */
+  output: number;
+  /** Total token estimate */
+  total: number;
+}
+/**
+ * Request input for plan generation.
+ */
+interface PlanRequest {
+  /** High-level goal or description of work to plan */
+  goal: string;
+  /** Additional context for the planning agent */
+  context?: string;
+  /** Maximum number of tasks to generate */
+  maxTasks?: number;
+}
+/**
+ * Parsed result from a plan generation invocation.
+ */
+interface PlanParseResult {
+  /** Whether plan generation succeeded */
+  success: boolean;
+  /** Parsed list of planned task descriptions */
+  tasks: PlannedTask[];
+  /** Error message if plan generation failed */
+  error?: string;
+  /** Raw output for debugging */
+  rawOutput?: string;
+}
+/**
+ * A single task entry in a generated plan.
+ */
+interface PlannedTask {
+  /** Task title */
+  title: string;
+  /** Detailed description */
+  description: string;
+  /** Estimated complexity (1-10) */
+  complexity?: number;
+  /** Other task titles this task depends on */
+  dependencies?: string[];
+}
+/**
+ * Result from a single adapter discovery attempt.
+ */
+interface AdapterDiscoveryResult {
+  /** Adapter id that was tried */
+  adapterId: AgentId;
+  /** Display name of the adapter */
+  displayName: string;
+  /** Health check result */
+  healthResult: AdapterHealthResult;
+  /** Whether the adapter was registered (healthy) */
+  registered: boolean;
+}
+/**
+ * Summary result from discoverAndRegister().
+ */
+interface DiscoveryReport {
+  /** Number of adapters successfully registered */
+  registeredCount: number;
+  /** Number of adapters that failed health checks */
+  failedCount: number;
+  /** Per-adapter detail results */
+  results: AdapterDiscoveryResult[];
+}
+
+//#endregion
+//#region packages/core/dist/adapters/worker-adapter.d.ts
+//# sourceMappingURL=types.d.ts.map
+/**
+ * WorkerAdapter — the interface every CLI agent adapter must implement.
+ *
+ * Adapters are responsible for:
+ * 1. Verifying their CLI binary is installed and responsive (healthCheck)
+ * 2. Constructing the spawn command to execute a task (buildCommand)
+ * 3. Constructing the spawn command for plan generation (buildPlanningCommand)
+ * 4. Parsing task result output from the CLI (parseOutput)
+ * 5. Parsing plan result output from the CLI (parsePlanOutput)
+ * 6. Estimating token usage for budget tracking (estimateTokens)
+ * 7. Reporting their capabilities for routing decisions (getCapabilities)
+ */
+interface WorkerAdapter {
+  /**
+   * Unique identifier for this adapter type.
+   * Used as the Map key in AdapterRegistry.
+   * @example "claude-code"
+   */
+  readonly id: AgentId;
+  /**
+   * Human-readable display name for the adapter.
+   * @example "Claude Code"
+   */
+  readonly displayName: string;
+  /**
+   * Semantic version of this adapter implementation.
+   * @example "1.0.0"
+   */
+  readonly adapterVersion: string;
+  /**
+   * Verify that the underlying CLI binary is installed, accessible, and
+   * able to respond in headless/non-interactive mode.
+   *
+   * This method must NOT throw — failures should be captured in the returned
+   * AdapterHealthResult.
+   *
+   * @returns A promise resolving to health check details
+   *
+   * @example
+   * ```typescript
+   * const result = await adapter.healthCheck()
+   * if (!result.healthy) console.error(result.error)
+   * ```
+   */
+  healthCheck(): Promise<AdapterHealthResult>;
+  /**
+   * Generate the spawn command to execute a coding task.
+   *
+   * The returned SpawnCommand must set `cwd` to options.worktreePath so the
+   * CLI agent operates in the correct git worktree (NFR10).
+   *
+   * @param prompt   Prompt or description of the task to execute
+   * @param options  Per-invocation execution options
+   * @returns SpawnCommand ready to be executed by the orchestrator
+   *
+   * @example
+   * ```typescript
+   * const cmd = adapter.buildCommand('Fix the failing tests', { worktreePath: '/tmp/wt', billingMode: 'api' })
+   * // spawn(cmd.binary, cmd.args, { cwd: cmd.cwd, env: { ...process.env, ...cmd.env } })
+   * ```
+   */
+  buildCommand(prompt: string, options: AdapterOptions): SpawnCommand;
+  /**
+   * Generate the spawn command to invoke the CLI agent for plan generation.
+   *
+   * @param request  Plan request with goal and context
+   * @param options  Per-invocation execution options
+   * @returns SpawnCommand for the planning invocation
+   */
+  buildPlanningCommand(request: PlanRequest, options: AdapterOptions): SpawnCommand;
+  /**
+   * Parse the raw CLI process output into a normalized TaskResult.
+   *
+   * This method must handle all output variations including:
+   * - Valid JSON stdout
+   * - Non-JSON stdout (fallback)
+   * - Non-zero exit codes
+   * - Combined stdout + stderr
+   *
+   * @param stdout    Standard output captured from the CLI process
+   * @param stderr    Standard error captured from the CLI process
+   * @param exitCode  Exit code from the CLI process
+   * @returns Normalized TaskResult
+   */
+  parseOutput(stdout: string, stderr: string, exitCode: number): TaskResult;
+  /**
+   * Parse the raw CLI output from a planning invocation into a PlanParseResult.
+   *
+   * @param stdout    Standard output from the planning invocation
+   * @param stderr    Standard error from the planning invocation
+   * @param exitCode  Exit code from the planning invocation
+   * @returns Parsed plan result
+   */
+  parsePlanOutput(stdout: string, stderr: string, exitCode: number): PlanParseResult;
+  /**
+   * Estimate the token count for a given prompt string.
+   *
+   * Used for pre-execution budget checks. Implementations may use heuristics
+   * (e.g., character count / 3) when exact tokenizers are unavailable.
+   *
+   * @param prompt  The prompt text to estimate
+   * @returns TokenEstimate with input, output, and total projections
+   *
+   * @example
+   * ```typescript
+   * const estimate = adapter.estimateTokens('Fix the failing tests in auth.ts')
+   * if (estimate.total > budgetCap) throw new BudgetExceededError(...)
+   * ```
+   */
+  estimateTokens(prompt: string): TokenEstimate;
+  /**
+   * Return the capabilities of this adapter's underlying CLI agent.
+   *
+   * The returned object is used by the orchestrator for:
+   * - Routing decisions (which adapter handles which task type)
+   * - Plan generation eligibility
+   * - Budget mode selection
+   *
+   * @returns AdapterCapabilities for this agent
+   */
+  getCapabilities(): AdapterCapabilities;
+}
+
+//#endregion
+//#region packages/core/dist/adapters/adapter-registry.d.ts
+/**
+ * AdapterRegistry — public interface for the adapter registry.
+ *
+ * Defined here (not in types.ts) to avoid a circular dependency between
+ * types.ts and worker-adapter.ts. AdapterRegistry references WorkerAdapter,
+ * which is defined in this file, so placing it here keeps the dep graph acyclic.
+ *
+ * The concrete implementation (AdapterRegistry class) lives in the monolith
+ * until Epic 41. This interface exposes only the public method surface.
+ *
+ * Usage:
+ * ```typescript
+ * const registry: AdapterRegistry = new ConcreteAdapterRegistry()
+ * const report = await registry.discoverAndRegister()
+ * const claude = registry.get('claude-code')
+ * ```
+ */
+/**
+ * AdapterRegistry manages the lifecycle of WorkerAdapter instances.
+ *
+ * Usage:
+ * ```typescript
+ * const registry = new AdapterRegistry()
+ * const report = await registry.discoverAndRegister()
+ * const claude = registry.get('claude-code')
+ * ```
+ */
+declare class AdapterRegistry {
+  private readonly _adapters;
+  /**
+   * Register an adapter by its id.
+   * Overwrites any existing adapter with the same id.
+   */
+  register(adapter: WorkerAdapter): void;
+  /**
+   * Retrieve a registered adapter by id.
+   * @returns The adapter, or undefined if not registered
+   */
+  get(id: AgentId): WorkerAdapter | undefined;
+  /**
+   * Return all registered adapters as an array.
+   */
+  getAll(): WorkerAdapter[];
+  /**
+   * Return all registered adapters that support plan generation.
+   */
+  getPlanningCapable(): WorkerAdapter[];
+  /**
+   * Instantiate all built-in adapters, run health checks sequentially,
+   * and register those that pass.
+   *
+   * Failed adapters are included in the report but do NOT prevent startup.
+   *
+   * @returns Discovery report with per-adapter results
+   */
+  discoverAndRegister(): Promise<DiscoveryReport>;
+}
+
+//#endregion
+//#region packages/core/dist/adapters/claude-adapter.d.ts
+//# sourceMappingURL=adapter-registry.d.ts.map
+/**
+ * Adapter for the Claude Code CLI agent.
+ *
+ * Capabilities: JSON output, streaming, both billing modes, plan generation.
+ * Health check: runs `claude --version` to verify install.
+ * Billing detection: detects subscription vs API via version output or env.
+ */
+declare class ClaudeCodeAdapter implements WorkerAdapter {
+  readonly id: AgentId;
+  readonly displayName = "Claude Code";
+  readonly adapterVersion = "1.0.0";
+  private readonly _logger;
+  constructor(logger?: ILogger);
+  /**
+   * Verify the `claude` binary is installed and responsive.
+   * Detects subscription vs API billing mode.
+   */
+  healthCheck(): Promise<AdapterHealthResult>;
+  /**
+   * Build spawn command for a coding task.
+   * Uses: `claude -p --model <model> --dangerously-skip-permissions --system-prompt <minimal>`
+   * Prompt is delivered via stdin (not CLI arg) to avoid E2BIG on large prompts.
+   */
+  buildCommand(prompt: string, options: AdapterOptions): SpawnCommand;
+  /**
+   * Build spawn command for plan generation.
+   */
+  buildPlanningCommand(request: PlanRequest, options: AdapterOptions): SpawnCommand;
+  /**
+   * Parse Claude Code JSON output into a TaskResult.
+   */
+  parseOutput(stdout: string, stderr: string, exitCode: number): TaskResult;
+  /**
+   * Parse Claude plan generation output.
+   */
+  parsePlanOutput(stdout: string, stderr: string, exitCode: number): PlanParseResult;
+  /**
+   * Estimate token count using character-based heuristic.
+   */
+  estimateTokens(prompt: string): TokenEstimate;
+  /**
+   * Return Claude Code capabilities.
+   */
+  getCapabilities(): AdapterCapabilities;
+  private _detectBillingModes;
+  private _buildPlanningPrompt;
+}
+
+//#endregion
+//#region packages/core/dist/adapters/codex-adapter.d.ts
+//# sourceMappingURL=claude-adapter.d.ts.map
+/**
+ * Adapter for the OpenAI Codex CLI agent.
+ *
+ * Codex CLI uses stdin for the prompt and outputs JSON when --json flag is used.
+ * Codex supports subscription billing (via `codex login`) and API key billing.
+ */
+declare class CodexCLIAdapter implements WorkerAdapter {
+  readonly id: AgentId;
+  readonly displayName = "Codex CLI";
+  readonly adapterVersion = "1.0.0";
+  private readonly _logger;
+  constructor(logger?: ILogger);
+  /**
+   * Verify the `codex` binary is installed and responsive.
+   */
+  healthCheck(): Promise<AdapterHealthResult>;
+  /**
+   * Build spawn command for a coding task.
+   * Uses: `codex exec` with prompt delivered via stdin.
+   *
+   * Do NOT use --json: it produces a JSONL event stream that prevents
+   * extractYamlBlock from finding the structured result block in stdout.
+   * Raw text output is required (same rationale as Claude adapter).
+   */
+  buildCommand(prompt: string, options: AdapterOptions): SpawnCommand;
+  /**
+   * Build spawn command for plan generation.
+   * Uses codex exec with a JSON plan generation prompt via stdin.
+   */
+  buildPlanningCommand(request: PlanRequest, options: AdapterOptions): SpawnCommand;
+  /**
+   * Parse Codex CLI output into a TaskResult.
+   *
+   * With raw text mode (no --json), stdout is the agent's direct output.
+   * YAML extraction happens in the dispatcher's extractYamlBlock, not here.
+   */
+  parseOutput(stdout: string, stderr: string, exitCode: number): TaskResult;
+  /**
+   * Parse Codex plan generation output.
+   */
+  parsePlanOutput(stdout: string, stderr: string, exitCode: number): PlanParseResult;
+  /**
+   * Estimate token count using character-based heuristic.
+   */
+  estimateTokens(prompt: string): TokenEstimate;
+  /**
+   * Return Codex CLI capabilities.
+   */
+  getCapabilities(): AdapterCapabilities;
+  private _buildPlanningPrompt;
+}
+
+//#endregion
+//#region packages/core/dist/adapters/gemini-adapter.d.ts
+//# sourceMappingURL=codex-adapter.d.ts.map
+/**
+ * Adapter for the Google Gemini CLI agent.
+ *
+ * Gemini CLI follows similar patterns to Claude Code: prompt via `-p` flag,
+ * JSON output via `--output-format json`, and model via `--model`.
+ */
+declare class GeminiCLIAdapter implements WorkerAdapter {
+  readonly id: AgentId;
+  readonly displayName = "Gemini CLI";
+  readonly adapterVersion = "1.0.0";
+  private readonly _logger;
+  constructor(logger?: ILogger);
+  /**
+   * Verify the `gemini` binary is installed and responsive.
+   * Detects subscription vs API billing mode.
+   */
+  healthCheck(): Promise<AdapterHealthResult>;
+  /**
+   * Build spawn command for a coding task.
+   * Uses: `gemini -p <prompt> --output-format json --model <model>`
+   */
+  buildCommand(prompt: string, options: AdapterOptions): SpawnCommand;
+  /**
+   * Build spawn command for plan generation.
+   */
+  buildPlanningCommand(request: PlanRequest, options: AdapterOptions): SpawnCommand;
+  /**
+   * Parse Gemini CLI JSON output into a TaskResult.
+   */
+  parseOutput(stdout: string, stderr: string, exitCode: number): TaskResult;
+  /**
+   * Parse Gemini plan generation output.
+   */
+  parsePlanOutput(stdout: string, stderr: string, exitCode: number): PlanParseResult;
+  /**
+   * Estimate token count using character-based heuristic.
+   */
+  estimateTokens(prompt: string): TokenEstimate;
+  /**
+   * Return Gemini CLI capabilities.
+   */
+  getCapabilities(): AdapterCapabilities;
+  private _detectBillingModes;
+  private _buildPlanningPrompt;
+}
+
+//#endregion
+//#region packages/core/dist/monitor/recommendation-types.d.ts
+//# sourceMappingURL=gemini-adapter.d.ts.map
+/**
+ * Recommendation Types — data structures for the routing recommendations engine.
+ * Migrated to @substrate-ai/core (Story 41-7)
+ */
+type ConfidenceLevel = 'low' | 'medium' | 'high';
+interface Recommendation {
+  task_type: string;
+  current_agent: string;
+  recommended_agent: string;
+  reason: string;
+  confidence: ConfidenceLevel;
+  current_success_rate: number;
+  recommended_success_rate: number;
+  current_avg_tokens: number;
+  recommended_avg_tokens: number;
+  improvement_percentage: number;
+  sample_size_current: number;
+  sample_size_recommended: number;
+}
+
+//#endregion
+export { AdapterDiscoveryResult, AdapterRegistry, AdtError, ClaudeCodeAdapter, CodexCLIAdapter, ConfigError, ConfigIncompatibleFormatError, CoreEvents, DatabaseAdapter, DiscoveryReport, GeminiCLIAdapter, Recommendation, TypedEventBus };
+//# sourceMappingURL=index-c924O9mj.d.ts.map