substrate-ai 0.8.6 → 0.10.0

package/dist/index.d.ts

@@ -619,7 +619,7 @@ interface PipelinePhaseCompleteEvent {
  * ```
  */
 type PipelineEvent = PipelineStartEvent | PipelineCompleteEvent | PipelinePreFlightFailureEvent | PipelineProfileStaleEvent | PipelineContractMismatchEvent | PipelineContractVerificationSummaryEvent | StoryPhaseEvent | StoryDoneEvent | StoryEscalationEvent | StoryWarnEvent | StoryLogEvent | PipelineHeartbeatEvent | StoryStallEvent | StoryZeroDiffEscalationEvent | StoryBuildVerificationFailedEvent | StoryBuildVerificationPassedEvent | StoryInterfaceChangeWarningEvent | StoryMetricsEvent | SupervisorPollEvent | SupervisorKillEvent | SupervisorRestartEvent | SupervisorAbortEvent | SupervisorSummaryEvent | SupervisorAnalysisCompleteEvent | SupervisorAnalysisErrorEvent | SupervisorExperimentStartEvent | SupervisorExperimentSkipEvent | SupervisorExperimentRecommendationsEvent | SupervisorExperimentCompleteEvent | SupervisorExperimentErrorEvent | RoutingModelSelectedEvent | PipelinePhaseStartEvent | PipelinePhaseCompleteEvent; //#endregion
-//#region src/core/errors.d.ts
+//#region packages/core/dist/types.d.ts
 
 /**
  * Exhaustive list of all PipelineEvent `type` discriminant strings.
@@ -629,8 +629,106 @@ type PipelineEvent = PipelineStartEvent | PipelineCompleteEvent | PipelinePreFli
  * out of sync with the actual event type definitions.
  */
 /**
- * Error definitions for Substrate
- * Provides structured error hierarchy for all toolkit operations
+ * 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$1 = string;
+/** Status of an individual task */
+
+/** Billing mode for a worker/agent */
+type BillingMode$1 = '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$1<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/dispatch/types.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 })
+ */
+
+/**
+ * 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/errors.d.ts
+//# sourceMappingURL=types.d.ts.map
+/**
+ * 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 {
@@ -639,6 +737,557 @@ declare class AdtError extends Error {
   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$1 {
+  /** 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$1 {
+  /** Path to the git worktree for this task */
+  worktreePath: string;
+  /** Billing mode to use for this execution */
+  billingMode: BillingMode$1;
+  /** 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 (passed as --max-context-tokens to Claude CLI).
+   * When set, constrains the context window to prevent runaway token usage.
+   * Used by efficiency-gated retry logic (Story 30-8) to cap context for stories
+   * that previously exhibited context spike patterns.
+   */
+  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$1 {
+  /** 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[];
+}
+/**
+ * Result returned from an adapter health check.
+ * Indicates whether the CLI binary is present and functional.
+ */
+interface AdapterHealthResult$1 {
+  /** 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$1[];
+  /** 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$2 {
+  /** 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$1;
+  };
+}
+/**
+ * Token usage estimate for budget tracking.
+ */
+interface TokenEstimate$1 {
+  /** Estimated input tokens */
+  input: number;
+  /** Estimated output tokens */
+  output: number;
+  /** Total token estimate */
+  total: number;
+}
+/**
+ * Request input for plan generation.
+ */
+interface PlanRequest$1 {
+  /** 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$1 {
+  /** Whether plan generation succeeded */
+  success: boolean;
+  /** Parsed list of planned task descriptions */
+  tasks: PlannedTask$1[];
+  /** Error message if plan generation failed */
+  error?: string;
+  /** Raw output for debugging */
+  rawOutput?: string;
+}
+/**
+ * A single task entry in a generated plan.
+ */
+interface PlannedTask$1 {
+  /** 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$1;
+  /** Display name of the adapter */
+  displayName: string;
+  /** Health check result */
+  healthResult: AdapterHealthResult$1;
+  /** 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$1 {
+  /**
+   * Unique identifier for this adapter type.
+   * Used as the Map key in AdapterRegistry.
+   * @example "claude-code"
+   */
+  readonly id: AgentId$1;
+  /**
+   * 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$1>;
+  /**
+   * 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$1): SpawnCommand$1;
+  /**
+   * 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$1, options: AdapterOptions$1): SpawnCommand$1;
+  /**
+   * 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$2;
+  /**
+   * 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$1;
+  /**
+   * 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$1;
+  /**
+   * 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$1;
+}
+
+//#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$1): void;
+  /**
+   * Retrieve a registered adapter by id.
+   * @returns The adapter, or undefined if not registered
+   */
+  get(id: AgentId$1): WorkerAdapter$1 | undefined;
+  /**
+   * Return all registered adapters as an array.
+   */
+  getAll(): WorkerAdapter$1[];
+  /**
+   * Return all registered adapters that support plan generation.
+   */
+  getPlanningCapable(): WorkerAdapter$1[];
+  /**
+   * 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$1 {
+  readonly id: AgentId$1;
+  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$1>;
+  /**
+   * 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$1): SpawnCommand$1;
+  /**
+   * Build spawn command for plan generation.
+   */
+  buildPlanningCommand(request: PlanRequest$1, options: AdapterOptions$1): SpawnCommand$1;
+  /**
+   * Parse Claude Code JSON output into a TaskResult.
+   */
+  parseOutput(stdout: string, stderr: string, exitCode: number): TaskResult$2;
+  /**
+   * Parse Claude plan generation output.
+   */
+  parsePlanOutput(stdout: string, stderr: string, exitCode: number): PlanParseResult$1;
+  /**
+   * Estimate token count using character-based heuristic.
+   */
+  estimateTokens(prompt: string): TokenEstimate$1;
+  /**
+   * Return Claude Code capabilities.
+   */
+  getCapabilities(): AdapterCapabilities$1;
+  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$1 {
+  readonly id: AgentId$1;
+  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$1>;
+  /**
+   * Build spawn command for a coding task.
+   * Uses: `codex exec --json` with prompt delivered via stdin.
+   */
+  buildCommand(prompt: string, options: AdapterOptions$1): SpawnCommand$1;
+  /**
+   * Build spawn command for plan generation.
+   * Uses codex exec with a JSON plan generation prompt via stdin.
+   */
+  buildPlanningCommand(request: PlanRequest$1, options: AdapterOptions$1): SpawnCommand$1;
+  /**
+   * Parse Codex CLI JSON output into a TaskResult.
+   */
+  parseOutput(stdout: string, stderr: string, exitCode: number): TaskResult$2;
+  /**
+   * Parse Codex plan generation output.
+   */
+  parsePlanOutput(stdout: string, stderr: string, exitCode: number): PlanParseResult$1;
+  /**
+   * Estimate token count using character-based heuristic.
+   */
+  estimateTokens(prompt: string): TokenEstimate$1;
+  /**
+   * Return Codex CLI capabilities.
+   */
+  getCapabilities(): AdapterCapabilities$1;
+  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$1 {
+  readonly id: AgentId$1;
+  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$1>;
+  /**
+   * Build spawn command for a coding task.
+   * Uses: `gemini -p <prompt> --output-format json --model <model>`
+   */
+  buildCommand(prompt: string, options: AdapterOptions$1): SpawnCommand$1;
+  /**
+   * Build spawn command for plan generation.
+   */
+  buildPlanningCommand(request: PlanRequest$1, options: AdapterOptions$1): SpawnCommand$1;
+  /**
+   * Parse Gemini CLI JSON output into a TaskResult.
+   */
+  parseOutput(stdout: string, stderr: string, exitCode: number): TaskResult$2;
+  /**
+   * Parse Gemini plan generation output.
+   */
+  parsePlanOutput(stdout: string, stderr: string, exitCode: number): PlanParseResult$1;
+  /**
+   * Estimate token count using character-based heuristic.
+   */
+  estimateTokens(prompt: string): TokenEstimate$1;
+  /**
+   * Return Gemini CLI capabilities.
+   */
+  getCapabilities(): AdapterCapabilities$1;
+  private _detectBillingModes;
+  private _buildPlanningPrompt;
+}
+
+//#endregion
+//#region src/core/errors.d.ts
+//# sourceMappingURL=gemini-adapter.d.ts.map
 /** Error thrown when task configuration is invalid */
 declare class TaskConfigError extends AdtError {
   constructor(message: string, context?: Record<string, unknown>);
@@ -667,18 +1316,10 @@ declare class BudgetExceededError extends AdtError {
 declare class GitError extends AdtError {
   constructor(message: string, context?: 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 state recovery fails */
 declare class RecoveryError 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>);
-}
 /** Error thrown when a task graph file uses an incompatible format version */
 declare class TaskGraphIncompatibleFormatError extends AdtError {
   constructor(message: string, context?: Record<string, unknown>);
@@ -754,7 +1395,6 @@ declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, baseDel
 //#endregion
 //#region src/modules/config/config-schema.d.ts
 //# sourceMappingURL=helpers.d.ts.map
-
 declare const SubstrateConfigSchema: z.ZodObject<{
   config_format_version: z.ZodEnum<{
     1: "1";
@@ -764,12 +1404,12 @@ declare const SubstrateConfigSchema: z.ZodObject<{
   }>>;
   global: z.ZodObject<{
     log_level: z.ZodEnum<{
-      fatal: "fatal";
-      error: "error";
-      warn: "warn";
-      info: "info";
-      debug: "debug";
       trace: "trace";
+      debug: "debug";
+      info: "info";
+      warn: "warn";
+      error: "error";
+      fatal: "fatal";
     }>;
     max_concurrent_tasks: z.ZodNumber;
     budget_cap_tokens: z.ZodNumber;
@@ -782,9 +1422,9 @@ declare const SubstrateConfigSchema: z.ZodObject<{
       enabled: z.ZodBoolean;
       cli_path: z.ZodOptional<z.ZodString>;
       subscription_routing: z.ZodEnum<{
-        auto: "auto";
         subscription: "subscription";
         api: "api";
+        auto: "auto";
         disabled: "disabled";
       }>;
       max_concurrent: z.ZodNumber;
@@ -799,9 +1439,9 @@ declare const SubstrateConfigSchema: z.ZodObject<{
       enabled: z.ZodBoolean;
       cli_path: z.ZodOptional<z.ZodString>;
       subscription_routing: z.ZodEnum<{
-        auto: "auto";
         subscription: "subscription";
         api: "api";
+        auto: "auto";
         disabled: "disabled";
       }>;
       max_concurrent: z.ZodNumber;
@@ -816,9 +1456,9 @@ declare const SubstrateConfigSchema: z.ZodObject<{
       enabled: z.ZodBoolean;
       cli_path: z.ZodOptional<z.ZodString>;
       subscription_routing: z.ZodEnum<{
-        auto: "auto";
         subscription: "subscription";
         api: "api";
+        auto: "auto";
         disabled: "disabled";
       }>;
       max_concurrent: z.ZodNumber;
@@ -1417,28 +2057,19 @@ interface OrchestratorEvents {
 //#region src/core/event-bus.d.ts
 //# sourceMappingURL=event-bus.types.d.ts.map
 /**
- * A typed publish-subscribe bus.
+ * Backward-compatible type alias: TypedEventBus specialized to OrchestratorEvents.
  *
- * All event names and payload types are enforced by the `OrchestratorEvents` map.
+ * Existing monolith code declares `let bus: TypedEventBus` (non-generic).
+ * This alias ensures those declarations continue to enforce OrchestratorEvents
+ * handler types rather than defaulting to Record<string, unknown>.
  */
-interface TypedEventBus {
-  /**
-   * Emit an event with a strongly-typed payload.
-   * Dispatch is synchronous — all registered handlers run before emit() returns.
-   */
-  emit<K extends keyof OrchestratorEvents>(event: K, payload: OrchestratorEvents[K]): void;
-  /**
-   * Subscribe to an event. The handler is called synchronously on each emit.
-   */
-  on<K extends keyof OrchestratorEvents>(event: K, handler: (payload: OrchestratorEvents[K]) => void): void;
-  /**
-   * Unsubscribe a previously registered handler.
-   * If the handler was not registered, this is a no-op.
-   */
-  off<K extends keyof OrchestratorEvents>(event: K, handler: (payload: OrchestratorEvents[K]) => void): void;
-}
+type TypedEventBus = TypedEventBus$1<OrchestratorEvents>;
 /**
- * Concrete implementation of TypedEventBus backed by Node.js EventEmitter.
+ * Concrete implementation specialized to OrchestratorEvents.
+ *
+ * Sub-classing the generic impl preserves the non-generic surface that
+ * existing tests and callers rely on:
+ *   bus = new TypedEventBusImpl()  // no type param needed
  *
  * @example
  * const bus = new TypedEventBusImpl()
@@ -1449,7 +2080,7 @@ interface TypedEventBus {
  */
 
 /**
- * Create a new TypedEventBus instance.
+ * Create a new TypedEventBus instance specialized to OrchestratorEvents.
  *
  * @example
  * const bus = createEventBus()
@@ -1846,221 +2477,9 @@ interface WorkerAdapter {
   getCapabilities(): AdapterCapabilities;
 }
 
-//#endregion
-//#region src/adapters/adapter-registry.d.ts
-//# sourceMappingURL=worker-adapter.d.ts.map
-/**
- * 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[];
-}
-/**
- * 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 src/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";
-  /**
-   * 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.
-   * Appends a structured planning directive to the prompt.
-   */
-  buildPlanningCommand(request: PlanRequest, options: AdapterOptions): SpawnCommand;
-  /**
-   * Parse Claude CLI JSON stdout output into TaskResult.
-   */
-  parseOutput(stdout: string, stderr: string, exitCode: number): TaskResult;
-  /**
-   * Parse plan generation output from Claude.
-   */
-  parsePlanOutput(stdout: string, stderr: string, exitCode: number): PlanParseResult;
-  /**
-   * Estimate token count using character-based heuristic.
-   * Approximation: 1 token ≈ 3 characters for English text.
-   */
-  estimateTokens(prompt: string): TokenEstimate;
-  /**
-   * Return Claude Code's capabilities.
-   */
-  getCapabilities(): AdapterCapabilities;
-  private _detectBillingModes;
-  private _buildPlanningPrompt;
-}
-
-//#endregion
-//#region src/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";
-  /**
-   * Verify the `codex` binary is installed and responsive.
-   */
-  healthCheck(): Promise<AdapterHealthResult>;
-  /**
-   * Build spawn command for a coding task.
-   * Uses: `codex exec --json` with prompt delivered via stdin.
-   */
-  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 JSON output into a TaskResult.
-   */
-  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 src/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";
-  /**
-   * 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 src/tui/app.d.ts
-//# sourceMappingURL=gemini-adapter.d.ts.map
+//# sourceMappingURL=worker-adapter.d.ts.map
 /**
  * Public interface for the TUI application.
  */