@wrongstack/core 0.284.1 → 0.285.0

package/dist/multi-agent-coordinator-4RCRZKjN.d.ts

@@ -1,1770 +0,0 @@
-import { T as ToolCallPipelinePayload, a as ToolWrapper, E as ExtensionRegistry, S as SystemPromptContributor, b as ToolRegistry, P as ProviderRegistry, A as AgentPipelines, c as ToolExecutorLike, R as ResolvedLoopDetectionConfig, d as AgentInit, e as AgentInput, f as RunResult } from './index--Gm41aBJ.js';
-import { C as Container, R as ReadonlyPipeline, a as Renderer } from './pipeline-DGDyIohT.js';
-import { E as EventBus, a as EventName, L as Listener } from './events-Bgnh43r9.js';
-import { R as RetryPolicy, E as ErrorHandler } from './retry-policy-CQ7KwXJa.js';
-import { L as Logger } from './logger-B63L5bTg.js';
-import { T as Tracer } from './observability-D-HZN_mF.js';
-import { P as PermissionPolicy } from './permission-ByDKXEcG.js';
-import { d as Context, J as JSONSchema, c as Request, e as Response, i as ContentBlock, s as TextBlock, g as Tool, P as Provider, t as RunOptions, U as Usage } from './tool-BNlnIJvo.js';
-import { b as Mailbox } from './mailbox-types-BGZWrYTJ.js';
-import { W as WireFamily, H as HookEvent, f as HookMatcher, I as InProcessHook, g as HookRegistrationOptions, j as Config, M as ModelsRegistry, k as ModelRuntimeConfig } from './config-MRqn1V-u.js';
-import { EventEmitter } from 'node:events';
-
-type BridgeMessageType = 'task' | 'result' | 'progress' | 'error' | 'heartbeat' | 'stop' | 'delegate' | 'budget_threshold';
-interface BridgeMessage<T = unknown> {
-    id: string;
-    type: BridgeMessageType;
-    from: string;
-    to?: string | undefined;
-    payload: T;
-    timestamp: number;
-    priority?: 'low' | 'normal' | 'high' | 'critical' | undefined;
-}
-interface AgentBridgeConfig {
-    agentId: string;
-    coordinatorId: string;
-    timeoutMs?: number | undefined;
-    bufferSize?: number | undefined;
-}
-interface AgentBridge {
-    readonly agentId: string;
-    readonly coordinatorId: string;
-    send(msg: BridgeMessage): Promise<void>;
-    broadcast(msg: BridgeMessage): Promise<void>;
-    subscribe(handler: (msg: BridgeMessage) => void | Promise<void>): () => void;
-    request<T>(msg: BridgeMessage, timeoutMs?: number): Promise<BridgeMessage<T>> | undefined;
-    stop(): Promise<void>;
-}
-interface BridgeTransport {
-    send(msg: BridgeMessage, to: string): Promise<void>;
-    subscribe(agentId: string, handler: (msg: BridgeMessage) => void | Promise<void>): () => void;
-    close(agentId: string): Promise<void>;
-}
-
-/**
- * A slash command registered with the CLI or available to plugins.
- * Plugins receive a view of the registry via PluginAPI.slashCommands.
- *
- * Commands registered by plugins use a namespaced name: `pluginName:commandName`.
- * This prevents collisions with built-in commands and other plugins.
- */
-interface SlashCommand {
-    /** Unique command name. For plugins: `pluginName:commandName`. */
-    name: string;
-    /** Short aliases — also prefixed automatically: `pluginName:alias`. */
-    aliases?: string[] | undefined;
-    description: string;
-    /**
-     * Category used to group commands in the slash picker. Defaults to 'App'
-     * when omitted.
-     */
-    category?: 'Run' | 'Session' | 'Inspect' | 'Agent' | 'Config' | 'App' | undefined;
-    /**
-     * Optional compact argument hint for interactive menus. This is not parsed
-     * by the registry; it only helps TUI/REPL surfaces show the expected shape,
-     * for example `[list|install <alias>|disable <name>]`.
-     */
-    argsHint?: string | undefined;
-    /**
-     * Optional detailed help shown by `/help <name>`. Use this for usage,
-     * arguments, examples, side-effects — anything that doesn't fit in
-     * `description`. Renders verbatim, so format with line breaks.
-     * If absent, `/help <name>` falls back to `description`.
-     */
-    help?: string | undefined;
-    /**
-     * When true, this command does not appear in the slash-picker list
-     * triggered by typing `/` alone. It is still dispatchable and
-     * searchable when the user types a matching prefix (e.g. `/f`).
-     * Defaults to false.
-     */
-    hidden?: boolean | undefined;
-    /**
-     * Execute the command.
-     * @param args Everything after the command name (trimmed by dispatch).
-     * @param ctx The current agent context.
-     * @returns `{ exit: true }` to quit the REPL. `{ message }` to print and
-     * continue. `{ runText }` to send a follow-up user-role message to the
-     * model immediately (e.g. `/steer <text>` builds a STEERING preamble
-     * here and asks the TUI to run it as the next turn). The TUI prints
-     * `message` first (if any) so the user sees the slash result before
-     * the model's response starts streaming. `{ metadata }` carries
-     * structured data for the REPL/TUI to act on (e.g. SDD session state).
-     */
-    run(args: string, ctx?: Context | undefined): Promise<{
-        exit?: boolean | undefined;
-        message?: string | undefined;
-        runText?: string | undefined;
-        metadata?: Record<string, unknown>;
-    } | void>;
-}
-
-interface ToolRegistryView {
-    register(t: Tool): void;
-    unregister(name: string): void;
-    /** Wrap (decorate) an existing tool. The wrapper gets the current tool and returns the decorated version. */
-    wrap(name: string, wrapper: ToolWrapper): void;
-    get(name: string): Tool | undefined;
-    list(): Tool[];
-}
-interface ProviderFactory {
-    type: string;
-    family: WireFamily;
-    create(cfg: unknown): Provider;
-}
-interface ProviderRegistryView {
-    register(f: ProviderFactory): void;
-    unregister(type: string): boolean;
-    create(cfg: {
-        type: string;
-    } & Record<string, unknown>): Provider;
-    list(): string[];
-}
-interface MCPRegistryView {
-    start(cfg: unknown): Promise<void>;
-    stop(name: string): Promise<void>;
-    restart(name: string): Promise<void>;
-    list(): {
-        name: string;
-        state: string;
-        toolCount: number;
-    }[];
-}
-interface SlashCommandRegistryView {
-    register(cmd: SlashCommand): void;
-    unregister(name: string): boolean;
-    get(name: string): SlashCommand | undefined;
-    list(): SlashCommand[];
-}
-/**
- * Read-only view of the session writer. Plugins can append custom events
- * to the JSONL session log and read the transcript path.
- *
- * The `append` method accepts any JSON-serializable payload — custom
- * event types are persisted verbatim next to the built-in events.
- */
-interface SessionWriterView {
-    readonly transcriptPath?: string | undefined;
-    append(event: Record<string, unknown> & {
-        type: string;
-        ts: string;
-    }): Promise<void>;
-}
-/**
- * Metrics sink scoped to a plugin. The host auto-prefixes metric names
- * with `plugin.<pluginName>.` so plugins don't need to namespace
- * manually. Plugins call counter/histogram/gauge directly; the values
- * flow to the host's MetricsSink (Prometheus, OTLP, or noop).
- */
-interface MetricsSinkView {
-    counter(name: string, value?: number | undefined, labels?: Record<string, string>): void;
-    histogram(name: string, value: number, labels?: Record<string, string>): void;
-    gauge(name: string, value: number, labels?: Record<string, string>): void;
-}
-/**
- * Options for a single `api.llm.complete()` call. Everything is
- * optional — omitted fields fall back first to the plugin's own
- * configured defaults (`config.extensions[<name>].llm`), then to the
- * host session's provider/model.
- */
-interface PluginLLMOptions {
-    /** System prompt for this call. */
-    system?: string | undefined;
-    /** Model override (e.g. `claude-haiku-4-5`). */
-    model?: string | undefined;
-    /**
-     * Provider override by configured provider name (a key of
-     * `config.providers`, e.g. `anthropic`, `openai`, `omniroute`).
-     * When omitted the host session's provider is used.
-     */
-    provider?: string | undefined;
-    /** Output-token cap. Default 2048, hard-capped by the host. */
-    maxTokens?: number | undefined;
-    temperature?: number | undefined;
-    /** `'json'` asks the provider for a JSON object response. */
-    responseFormat?: 'text' | 'json' | undefined;
-    /** Abort signal — plugins should pass one for cancellable work. */
-    signal?: AbortSignal | undefined;
-}
-interface PluginLLMResult {
-    /** Concatenated text blocks of the response. */
-    text: string;
-    /** The model that actually served the call. */
-    model: string;
-    /** The provider name the call was routed through. */
-    provider: string;
-    usage: {
-        input: number;
-        output: number;
-    };
-    stopReason: string;
-}
-/**
- * LLM access for plugins, routed through the host's provider layer —
- * plugins never handle API keys themselves. Resolution order for
- * provider/model on each call:
- *
- *   1. `PluginLLMOptions.provider` / `.model` (per call)
- *   2. `config.extensions[<plugin>].llm.provider` / `.model` (per plugin)
- *   3. the host session's active provider/model (default)
- *
- * Exposed as `api.llm` — `undefined` on minimal hosts (tests, the LSP
- * server) that have no provider wired. Always guard:
- * `if (!api.llm) return;`
- */
-interface PluginLLM {
-    /** The effective defaults for this plugin (after config resolution). */
-    defaults(): {
-        provider: string;
-        model: string;
-    };
-    /** One-shot completion. Throws on provider errors. */
-    complete(prompt: string, opts?: PluginLLMOptions): Promise<PluginLLMResult>;
-}
-interface PluginPipelines {
-    request: ReadonlyPipeline<Request>;
-    response: ReadonlyPipeline<Response>;
-    toolCall: ReadonlyPipeline<ToolCallPipelinePayload>;
-    userInput: ReadonlyPipeline<{
-        content: ContentBlock[];
-        text: string;
-        ctx: Context;
-    }>;
-    assistantOutput: ReadonlyPipeline<TextBlock>;
-    contextWindow: ReadonlyPipeline<Context>;
-    [k: string]: ReadonlyPipeline<any>;
-}
-interface PluginAPI {
-    container: Container;
-    pipelines: PluginPipelines;
-    events: EventBus;
-    tools: ToolRegistryView;
-    providers: ProviderRegistryView;
-    mcp: MCPRegistryView;
-    slashCommands: SlashCommandRegistryView;
-    /** Live session writer — plugins can append custom events here. */
-    session: SessionWriterView;
-    /** Scoped metrics sink — counters/histograms/gauges auto-namespaced under `plugin.<name>.` */
-    metrics: MetricsSinkView;
-    /** Registry for agent lifecycle extensions — hooks like beforeRun, beforeIteration, onError, etc. */
-    extensions: ExtensionRegistry;
-    /**
-     * Register a system prompt contributor. Plugins call this to inject
-     * ephemeral TextBlocks into the system prompt on every build.
-     * Returns an unregister function.
-     */
-    registerSystemPromptContributor(c: SystemPromptContributor): () => void;
-    /**
-     * Register an in-process lifecycle hook. `matcher` is a tool-name filter for
-     * `PreToolUse`/`PostToolUse` (`"Bash"`, `"edit|write"`, `"*"`) and ignored
-     * for other events. The hook can block, rewrite tool input, or inject extra
-     * context — see `HookOutcome`. Automatically removed when the plugin is
-     * uninstalled. Returns an unregister function.
-     */
-    registerHook(event: HookEvent, matcher: HookMatcher | undefined, hook: InProcessHook, options?: HookRegistrationOptions | undefined): () => void;
-    config: Config;
-    log: Logger;
-    /**
-     * Register a one-time event listener. The handler is automatically removed
-     * after the first emission, or when the plugin is uninstalled — whichever
-     * comes first.
-     */
-    onEvent<K extends EventName>(event: K, handler: Listener<K>): () => void;
-    /**
-     * Subscribe to all events matching a glob-style pattern.
-     * `'tool.*'` matches all tool events. `'*'` matches everything.
-     * Returns an unsubscribe function.
-     */
-    onPattern(pattern: string, handler: (event: string, payload: unknown) => void): () => void;
-    /**
-     * Emit a custom event on the agent's EventBus. Use for inter-plugin
-     * communication or to surface plugin-specific state to the host.
-     *
-     * Custom events use a `pluginName:eventName` convention to avoid
-     * collisions with built-in events (e.g. `my-plugin:cache_hit`).
-     * The payload is passed through to all subscribers.
-     */
-    emitCustom(event: string, payload: unknown): void;
-    /**
-     * Register a callback that fires when the configuration changes at
-     * runtime (e.g. via `/config` slash command or programmatic update).
-     * The handler receives the new and previous config snapshots.
-     * Returns an unsubscribe function.
-     */
-    onConfigChange(handler: (next: Readonly<Config>, prev: Readonly<Config>) => void): () => void;
-    /**
-     * The models registry (models.dev-backed catalog of providers, models,
-     * and per-token pricing). Optional — some hosts may not construct one
-     * (e.g. minimal CLI invocations, tests). Plugins that need pricing
-     * data (cost-tracker, billing reports) should treat this as the
-     * preferred source when present and fall back to a bundled table
-     * otherwise.
-     */
-    modelsRegistry?: ModelsRegistry | undefined;
-    /**
-     * The host's project-level mailbox. Optional — minimal hosts (tests,
-     * standalone CLI invocations, the LSP server) may not construct one.
-     * Plugins that publish status to other agents (todo-listener,
-     * session-recap) should treat this as the preferred source when present
-     * and gracefully no-op otherwise.
-     */
-    mailbox?: Mailbox | undefined;
-    /**
-     * LLM access routed through the host's provider layer. Optional —
-     * minimal hosts without a wired provider omit it; plugins must guard
-     * (`if (!api.llm) …`). Per-plugin provider/model defaults come from
-     * `config.extensions[<name>].llm = { provider, model }`.
-     */
-    llm?: PluginLLM | undefined;
-}
-/**
- * Capability declaration — informs the host which subsystems a plugin
- * intends to touch. Used for diagnostics and per-plugin enable/disable UX
- * (e.g. "this plugin registers tools — disable to remove them"). Not
- * enforced at runtime: a plugin that declares `tools: false` can still
- * call `api.tools.register()`, but the host can flag the discrepancy.
- */
-interface PluginCapabilities {
-    /** Will register tools via `api.tools.register()`. */
-    tools?: boolean | undefined;
-    /** Will register provider factories via `api.providers.register()`. */
-    providers?: boolean | undefined;
-    /**
-     * Pipelines the plugin hooks into. Use the standard names
-     * (`request | response | toolCall | userInput | assistantOutput | contextWindow`)
-     * or custom pipeline names exposed by other plugins.
-     */
-    pipelines?: string[] | undefined;
-    /** Will register slash commands via `api.slashCommands.register()`. */
-    slashCommands?: boolean | undefined;
-    /** Will start MCP servers via `api.mcp.start()`. */
-    mcp?: boolean | undefined;
-    /**
-     * Capabilities required to mutate (wrap, unregister, override) tools
-     * the plugin does not own. If empty or omitted, the plugin may only
-     * mutate its own tools. Official plugins bypass this check.
-     *
-     * Example: `['fs.read', 'net.outbound']` allows the plugin to wrap
-     * read-only tools, but not `fs.write` or `shell.arbitrary` tools.
-     */
-    toolMutateCapabilities?: string[] | undefined;
-    /**
-     * Will register in-process lifecycle hooks via `api.registerHook()`. When
-     * false (or omitted by a non-official plugin), the loader either logs a
-     * warning or throws — see `LoadPluginsOptions.enforceCapabilities`.
-     * Official plugins are not gated.
-     */
-    hooks?: boolean | undefined;
-}
-/**
- * Structured dependency declaration. The string form (`dependsOn: ['foo']`)
- * is shorthand for `[{ name: 'foo' }]` — both work. Use the structured form
- * when you need a version constraint:
- *
- *   dependsOn: [{ name: 'wstack-auth', version: '^1.2.0' }]
- */
-interface PluginDependency {
-    name: string;
-    /** npm-style semver range. Supports `^`, `~`, exact, and unprefixed. */
-    version?: string | undefined;
-}
-interface Plugin {
-    name: string;
-    version?: string | undefined;
-    /** One-line summary for `wstack plugins list` and error messages. */
-    description?: string | undefined;
-    /** Semver range against the kernel API version (KERNEL_API_VERSION). */
-    apiVersion: string;
-    /**
-     * Capability hints — what subsystems the plugin will register against.
-     * Optional; provided for diagnostics and UX. The loader does not enforce
-     * these, but mismatch is surfaced via logger at warn level.
-     */
-    capabilities?: PluginCapabilities | undefined;
-    /**
-     * JSON Schema for the options under `Config.plugins[<name>].options`.
-     * When present, the loader validates that section before calling `setup`
-     * and rejects the plugin with a clear error path on failure.
-     */
-    configSchema?: JSONSchema | undefined;
-    /**
-     * Mandatory plugin dependencies — loading fails if any are absent or
-     * version-incompatible. Accepts both the legacy string-array form and
-     * the structured form with version constraints.
-     */
-    dependsOn?: (string | PluginDependency)[] | undefined;
-    /** Optional plugin dependencies — silently skipped if absent. */
-    optionalDeps?: (string | PluginDependency)[] | undefined;
-    conflictsWith?: string[] | undefined;
-    /**
-     * Default configuration values, deep-merged under the plugin's options
-     * key before `configSchema` validation. User-provided values take
-     * precedence over defaults — this is a fallback, not an override.
-     *
-     * @example
-     * defaultConfig: { ttl: 3600, maxSize: 100 }
-     */
-    defaultConfig?: Record<string, unknown>;
-    /**
-     * Called by the host to activate the plugin. Receives the `PluginAPI`
-     * and an optional `AbortSignal` the plugin should respect for
-     * cancellation and timeout. `setup` must complete before the plugin is
-     * considered loaded; if it times out the plugin is rejected.
-     */
-    setup(api: PluginAPI, opts?: {
-        signal?: AbortSignal | undefined;
-    }): void | Promise<void>;
-    /**
-     * Called by the host during unload. Receives the same `PluginAPI` instance
-     * the plugin saw during `setup` and an optional `AbortSignal`. Teardown
-     * is best-effort — a timeout does not prevent other plugins from unloading.
-     */
-    teardown?(api: PluginAPI, opts?: {
-        signal?: AbortSignal | undefined;
-    }): void | Promise<void>;
-    /**
-     * Optional health check. Called by the host (e.g. `/diag plugins` slash
-     * command or health endpoint) to surface plugin status. Return
-     * `{ ok: false, message: '...' }` when the plugin is degraded.
-     */
-    health?(): Promise<{
-        ok: boolean;
-        message?: string | undefined;
-    }>;
-}
-
-declare class Agent {
-    readonly container: Container;
-    readonly tools: ToolRegistry;
-    readonly providers: ProviderRegistry;
-    readonly events: EventBus;
-    readonly pipelines: AgentPipelines;
-    readonly ctx: Context;
-    /** Max agent-loop iterations per run. Mutable so the TUI `/settings` picker
-     *  can apply a new value to the live session (takes effect next run). */
-    maxIterations: number;
-    readonly executionStrategy: 'parallel' | 'sequential' | 'smart';
-    readonly perIterationOutputCapBytes: number;
-    private readonly plugins;
-    readonly toolExecutor: ToolExecutorLike;
-    readonly autoExtendLimit: boolean;
-    /** Resolved loop-detector settings (see `tools.loopDetection`). */
-    readonly loopDetection: ResolvedLoopDetectionConfig;
-    private readonly autonomousContinue;
-    readonly tracer: Tracer | undefined;
-    readonly extensions: ExtensionRegistry;
-    private readonly _toolHandler;
-    private readonly _responseHandler;
-    private readonly _loopHandler;
-    private readonly _logger;
-    constructor(init: AgentInit);
-    get logger(): Logger;
-    get retry(): RetryPolicy;
-    get errorHandler(): ErrorHandler;
-    get permission(): PermissionPolicy;
-    get renderer(): Renderer | undefined;
-    disableInteractiveConfirmation(): void;
-    register(tool: Tool): void;
-    use(plugin: Plugin, api: PluginAPI): Promise<void>;
-    teardown(): Promise<void>;
-    run(userInput: AgentInput, opts?: RunOptions): Promise<RunResult>;
-}
-
-type BudgetKind = 'tool_calls' | 'iterations' | 'tokens' | 'timeout' | 'idle_timeout' | 'cost';
-/**
- * Fraction of the wall-clock `timeoutMs` window at which a PROACTIVE extension
- * is negotiated — BEFORE the deadline is actually crossed. The coordinator
- * watchdog (`executeWithTimeout`) arms at `timeoutMs * TIMEOUT_PREEMPT_FRACTION`
- * so a still-progressing subagent gets its ceiling raised while it is below the
- * limit, and never enters a "timed out" state. Reactive enforcement at the real
- * deadline still stands for the no-progress / denied case. Shared so the asking
- * side and any future caller agree on the same lead point.
- */
-declare const TIMEOUT_PREEMPT_FRACTION = 0.85;
-/**
- * Hard safety net for budget negotiation decisions. If no listener responds to
- * `budget.threshold_reached` within this window the negotiation defaults to
- * `'stop'`. Exported so the coordinator's watchdog can reuse the same ceiling
- * without hardcoding a second copy.
- */
-declare const DECISION_TIMEOUT_MS = 60000;
-declare class BudgetExceededError extends Error {
-    readonly kind: BudgetKind;
-    readonly limit: number;
-    readonly observed: number;
-    constructor(kind: BudgetKind, limit: number, observed: number);
-}
-interface BudgetLimits {
-    maxIterations?: number | undefined;
-    maxToolCalls?: number | undefined;
-    maxTokens?: number | undefined;
-    /** Estimated USD cost ceiling. */
-    maxCostUsd?: number | undefined;
-    /**
-     * Hard wall-clock timeout measured from `start()`. Off by default — set it
-     * explicitly only when a task must finish within an absolute window. For
-     * the everyday "don't kill an agent that's still working" guard, prefer
-     * `idleTimeoutMs`, which resets on activity.
-     */
-    timeoutMs?: number | undefined;
-    /**
-     * Idle timeout: the maximum gap (ms) between activity signals (iterations,
-     * tool calls, token usage, streamed progress) before the subagent is
-     * considered hung and reaped. Unlike `timeoutMs`, an actively-working
-     * agent continuously resets this clock via `markActivity()`, so it never
-     * trips on a long-but-productive run — only on a genuine stall.
-     */
-    idleTimeoutMs?: number | undefined;
-}
-/**
- * Controls how the budget behaves when `onThreshold` is set and a limit is hit.
- *
- * `'auto'` — emit `budget.threshold_reached` on the EventBus and wait for a
- * coordinator response (extend/stop). If no listener responds within
- * `DECISION_TIMEOUT_MS` the decision defaults to `'stop'`.
- * `'sync'` — do not emit any event; treat the threshold as a hard stop and
- * throw `BudgetExceededError` synchronously. Useful for fire-and-forget
- * subagents that have an `onThreshold` handler for logging/metrics but are
- * not wired into a coordinator.
- *
- * @default 'auto'
- */
-type BudgetNegotiationMode = 'auto' | 'sync';
-type BudgetSessionIdSource = string | (() => string | undefined);
-interface SubagentBudgetOptions {
-    sessionId?: BudgetSessionIdSource | undefined;
-}
-interface BudgetUsage {
-    iterations: number;
-    toolCalls: number;
-    tokens: {
-        input: number;
-        output: number;
-        total: number;
-    };
-    costUsd: number;
-    elapsedMs: number;
-}
-/**
- * Thrown by `SubagentBudget.record*` when a soft limit is hit and
- * an `onThreshold` handler is configured that wants to ask the
- * coordinator (via `budget.threshold_reached` event). The runner
- * catches this and awaits the embedded `decision` promise to get
- * the coordinator's extend/stop decision.
- *
- * Distinct from `BudgetExceededError` which is a hard stop.
- */
-declare class BudgetThresholdSignal extends Error {
-    readonly kind: BudgetKind;
-    readonly limit: number;
-    readonly used: number;
-    /** Resolves to 'extend' (with optional new limits) or 'stop' */
-    readonly decision: Promise<BudgetThresholdDecision>;
-    constructor(kind: BudgetKind, limit: number, used: number, decision: Promise<BudgetThresholdDecision>);
-}
-type BudgetThresholdDecision = 'stop' | {
-    extend: Partial<BudgetLimits>;
-};
-/**
- * Callback invoked when a budget limit is about to be exceeded.
- * Return 'throw' for hard stop (default — throws BudgetExceededError).
- * Return 'continue' to allow one more unit and re-check next time.
- * Return a Promise to ask the coordinator via `budget.threshold_reached`
- * event (uses the same grant/deny pattern as `iteration.limit_reached`).
- */
-type BudgetThresholdHandler = (info: {
-    kind: BudgetKind;
-    used: number;
-    limit: number;
-    requestDecision: () => Promise<BudgetThresholdDecision>;
-    /**
-     * Direct grant/deny hooks for SYNCHRONOUS policy or recording handlers that
-     * decide in-process without a wired `budget.threshold_reached` listener
-     * (e.g. the coordinator watchdog). `extend` patches the limits in place;
-     * `deny` records the intent to stop. Production listener-driven handlers use
-     * `requestDecision()` instead and can ignore these.
-     */
-    extend?: (extra: Partial<BudgetLimits>) => void;
-    deny?: () => void;
-}) => 'throw' | 'continue' | 'stop' | {
-    extend: Partial<BudgetLimits>;
-} | Promise<BudgetThresholdDecision>;
-/**
- * Per-subagent budget enforcement. Each subagent gets its own instance so a
- * runaway agent can't drain the cost ceiling of its siblings. All record/check
- * methods are O(1) and safe to call from hot paths.
- *
- * Behavior without `onThreshold`: hard stops synchronously on every limit hit.
- *
- * Behavior with `onThreshold` and `_mode === 'auto'`: emits `budget.threshold_reached`
- * on the EventBus and throws `BudgetThresholdSignal`. The coordinator's verdict
- * (extend/stop) resolves the embedded promise. If no listener responds within
- * `DECISION_TIMEOUT_MS` the decision defaults to `'stop'`.
- *
- * Behavior with `onThreshold` and `_mode === 'sync'`: throws `BudgetExceededError`
- * synchronously regardless of EventBus state or listener presence. This is useful
- * for fire-and-forget subagents that have an `onThreshold` handler for logging/metrics
- * but are not wired into a coordinator — the `'sync'` mode makes the hard-stop
- * behavior explicit and means tests can use `expect().toThrow()` even without
- * a fully-wired EventBus.
- */
-declare class SubagentBudget {
-    readonly limits: Readonly<BudgetLimits>;
-    /** Patch one or more budget limits in-place after construction.
-     * Used by the coordinator watchdog when granting an extension.
-     * All fields are optional — only provided fields are updated.
-     * This is the single write path for limit mutations so that future
-     * validation or side-effects live in one place (M1). */
-    patchLimits(ext: Partial<BudgetLimits>): void;
-    private iterations;
-    private toolCalls;
-    private tokenInput;
-    private tokenOutput;
-    private costUsd;
-    private startTime;
-    /**
-     * Timestamp of the most recent activity (iteration / tool call / token
-     * usage / streamed progress). Drives the idle timeout — reset by
-     * `markActivity()`. Initialised to `start()` time so a never-active agent
-     * still eventually trips its idle window.
-     */
-    private lastActivityTime;
-    private _onThreshold;
-    private readonly _sessionId;
-    /**
-     * Hard cap on how long `_negotiateExtension` waits for the coordinator to
-     * respond before defaulting to 'stop'. Without this fallback an absent
-     * or hung listener (Director not built / event filter detached mid-run)
-     * leaves the budget over-limit and never enforces anything.
-     */
-    private static readonly DECISION_TIMEOUT_MS;
-    /**
-     * Injected by the runner when wiring the budget to its EventBus.
-     * Used to emit `budget.threshold_reached` events in `'auto'` mode.
-     */
-    _events?: EventBus | undefined;
-    /**
-     * Guard against dual-path races between the coordinator watchdog
-     * (`executeWithTimeout`) and the budget's own `checkTimeout()`.
-     * Both paths detect `elapsed >= timeoutMs` and can emit
-     * `budget.threshold_reached` for kind `'timeout'` simultaneously.
-     * Set to the current `timeoutMs` ceiling by the coordinator BEFORE
-     * calling `onThreshold`, and cleared after the negotiation resolves.
-     * `checkTimeout()` skips its wall-clock check while this is set so
-     * the coordinator's watchdog is the sole source of wall-clock timeout
-     * events — `checkTimeout()` focuses exclusively on `idle_timeout`.
-     */
-    private _watchdogActive;
-    /** Returns the timeout ceiling currently being negotiated by the watchdog,
-     * or `undefined` when no wall-clock negotiation is in flight.
-     * Used by `executeWithTimeout` to detect a stale lock (M3). */
-    get watchdogActive(): number | undefined;
-    /** Called by the coordinator watchdog BEFORE calling `onThreshold` so that
-     * `checkTimeout()` skips its wall-clock check for this ceiling. Prevents
-     * the budget's own `checkTimeout()` from emitting a second
-     * `budget.threshold_reached` event while the watchdog is already
-     * negotiating the same wall-clock deadline (C1). */
-    setWatchdogNegotiation(timeoutMs: number): void;
-    /** Clears the watchdog guard after negotiation resolves. Called in the
-     * `finally` block of both the pre-empt and deadline branches so it fires
-     * on every exit path: grant, deny, throw, or error. */
-    clearWatchdogNegotiation(): void;
-    /**
-     * Negotiation mode — controls whether a threshold hit tries to emit
-     * `budget.threshold_reached` and wait for a coordinator decision, or
-     * falls straight through to a synchronous hard stop.
-     *
-     * `'auto'` (default) — emit on the EventBus and wait; times out to 'stop'.
-     * `'sync'` — throw `BudgetExceededError` immediately regardless of listeners.
-     */
-    private _mode;
-    /**
-     * Optional callback for soft-limit handling. When set, the budget will
-     * invoke it rather than throw immediately. The handler decides whether to
-     * throw synchronously, continue, or ask the coordinator for an extension.
-     */
-    get onThreshold(): BudgetThresholdHandler | undefined;
-    set onThreshold(fn: BudgetThresholdHandler | undefined);
-    /** Returns the current negotiation mode. */
-    get mode(): BudgetNegotiationMode;
-    constructor(limits?: BudgetLimits, mode?: BudgetNegotiationMode, options?: SubagentBudgetOptions);
-    private currentSessionId;
-    start(): void;
-    /**
-     * Reset the idle clock. Called on any sign of forward progress —
-     * iterations, tool calls, token usage, and streamed tool/text progress —
-     * so a long-but-productive subagent never trips its `idleTimeoutMs`.
-     */
-    markActivity(): void;
-    /**
-     * Milliseconds since the last activity signal. Returns 0 before `start()`
-     * (nothing to measure yet). Used by the coordinator watchdog to decide
-     * whether to re-arm (still active) or reap (genuinely idle).
-     */
-    idleMs(): number;
-    /** Returns true if we're within 10% of any limit — useful for pre-flight checks. */
-    isNearLimit(): boolean;
-    /**
-     * Synchronous budget check. Always throws synchronously so callers (especially
-     * test event handlers using `expect().toThrow()`) get an unhandled rejection
-     * when the budget is exceeded without a handler.
-     *
-     * Decision table:
-     * - no `onThreshold` handler         → throw `BudgetExceededError` (hard stop, always)
-     * - `mode === 'sync'`               → throw `BudgetExceededError` (hard stop, always)
-     * - `mode === 'auto'` + no listener  → throw `BudgetExceededError` (hard stop; no one to ask)
-     * - `mode === 'auto'` + listener     → throw `BudgetThresholdSignal` with async decision promise
-     */
-    /**
-     * Collects all exceeded budget kinds into a single NOOP-free negotiation.
-     * Called by recordIteration / recordToolCall / recordUsage — each may call
-     * this for its own kind. The first call starts the negotiation and stores
-     * the Promise in _pendingNegotiation. Subsequent calls for DIFFERENT
-     * kinds (while a negotiation is in flight) are NOOPs — they don't start
-     * new conversations with the coordinator. This prevents an EventBus flood
-     * when multiple budget kinds are exceeded simultaneously in one iteration.
-     *
-     * Returns the kinds that were found to be exceeded (for logging/debugging).
-     */
-    private checkLimits;
-    /**
-     * Invoke `onThreshold` once for `entry` on the NO-LISTENER path and report
-     * whether it decided synchronously. Returns `true` when the handler returned
-     * a synchronous decision (already honored — an `extend` patched the limits),
-     * or `false` when it returned a Promise (async; the caller hard-stops, since
-     * there is no listener to resolve the negotiation). The handler is given the
-     * full info shape (`requestDecision` plus direct `extend`/`deny`) so both
-     * recording handlers and policy handlers work without a wired listener.
-     */
-    private _invokeHandlerSync;
-    /**
-     * Emit `budget.threshold_reached` and resolve to the listener's verdict.
-     * Resolves to `'stop'` immediately when there is no listener (or no bus) so
-     * no negotiation can hang and no fallback timer leaks. Mirrors the
-     * coordinator watchdog's own request path so both agree on the no-listener
-     * default.
-     */
-    private _busRequestDecision;
-    /**
-     * Per-kind in-flight negotiation Promises. Each budget kind can have its
-     * own concurrent negotiation — e.g. iterations and timeout can both
-     * be exceeded simultaneously without blocking each other. The same kind
-     * cannot start two concurrent negotiations (dedup guard).
-     * Cleared in `_negotiateExtension`'s `finally` block.
-     */
-    private _pendingNegotiations;
-    /**
-     * Drive the threshold handler to a decision. Resolves with `'stop'`
-     * (signal the runner to abort) or `{ extend: ... }` (limits already
-     * patched in-place; the runner should not abort). Clears the
-     * per-kind slot in `_pendingNegotiations` in `finally`.
-     *
-     * The 'continue' return from a sync handler is treated as
-     * `{ extend: {} }` — keep going without patching; next overrun fires
-     * a fresh signal.
-     */
-    private _negotiateExtension;
-    recordIteration(): void;
-    recordToolCall(): void;
-    recordUsage(usage: Usage, costUsd?: number): void;
-    /**
-     * Wall-clock / idle budget check. Delegates to `checkLimits(elapsed)`, so
-     * `timeout` and `idle_timeout` follow the SAME negotiation path as the other
-     * kinds — they are NOT a special-cased hard stop. This is deliberate: a
-     * heartbeat-aware policy (see `attachAutoExtend` and `CollabSession`) grants
-     * a timeout extension only while the agent is making progress and denies it
-     * once the agent is genuinely stuck, which is safer than an unconditional
-     * hard kill of a long-but-working agent. The runner translates the resulting
-     * `BudgetThresholdSignal` decision (`extend` → patch limits in place,
-     * `stop` → abort) just like every other kind.
-     *
-     * Decision table (same as `checkLimits`):
-     * - no `onThreshold` handler        → throw `BudgetExceededError` (hard stop)
-     * - `mode === 'sync'`               → throw `BudgetExceededError` (hard stop)
-     * - `mode === 'auto'` + no listener → throw `BudgetExceededError` (no one to ask)
-     * - `mode === 'auto'` + listener    → throw `BudgetThresholdSignal` (negotiated;
-     *                                     a heartbeat-aware policy may extend the timeout)
-     */
-    checkTimeout(): void;
-    /** Returns true if a wall-clock or idle timeout has occurred without throwing. */
-    isTimedOut(): boolean;
-    usage(): BudgetUsage;
-}
-
-/** Internal, non-user-authored budget/depth inheritance for nested directors. */
-interface SubagentSpawnLineage {
-    parentDirectorId: string;
-    /** Depth of the spawned child; root Director is depth 0. */
-    spawnDepth: number;
-    /** Hard ceiling inherited by descendants. */
-    maxSpawnDepth: number;
-    fleetBudget: {
-        maxSpawns?: number | undefined;
-        remainingSpawns?: number | undefined;
-        maxTokens?: number | undefined;
-        remainingTokens?: number | undefined;
-        maxCostUsd?: number | undefined;
-        remainingCostUsd?: number | undefined;
-    };
-}
-interface SubagentConfig {
-    id?: string | undefined;
-    name: string;
-    role?: string | undefined;
-    prompt?: string | undefined;
-    maxIterations?: number | undefined;
-    maxToolCalls?: number | undefined;
-    maxTokens?: number | undefined;
-    maxCostUsd?: number | undefined;
-    /** Hard wall-clock cap (ms) from start. Opt-in; prefer `idleTimeoutMs`. */
-    timeoutMs?: number | undefined;
-    /**
-     * Idle timeout (ms): reap the subagent only after this long with no
-     * activity. Resets on every iteration / tool call / streamed progress, so
-     * an actively-working agent runs until its task naturally ends. This is the
-     * default reaper for delegated subagents (see `applyRosterBudget`).
-     */
-    idleTimeoutMs?: number | undefined;
-    /**
-     * Fraction of `timeoutMs` at which the proactive pre-empt fires (0.0–1.0).
-     * At this point the watchdog negotiates a ceiling extension while the
-     * agent is still under its limit, so a progressing agent gets its
-     * ceiling raised before ever entering a timed-out state.
-     * Defaults to `TIMEOUT_PREEMPT_FRACTION` (0.85). Lower values fire earlier;
-     * higher values fire closer to the deadline. Ignored when `timeoutMs` is unset.
-     */
-    preemptFraction?: number | undefined;
-    tools?: string[] | undefined;
-    /**
-     * Tools to explicitly disable for this subagent. These tools will be
-     * removed from the subagent's tool list even if they are normally available.
-     * Use this to enforce constraints that the baseline prompt alone cannot
-     * fully enforce (e.g., preventing delegation by removing the delegate tool).
-     */
-    disabledTools?: string[] | undefined;
-    /**
-     * Capability allowlist for this subagent's `AutoApprovePermissionPolicy`.
-     * Subagents run non-interactively, so the policy auto-approves only tools
-     * whose declared capabilities intersect this list; everything else is
-     * denied by the subagent guard. Defaults (when omitted) to the read-only
-     * safe set `['fs.read', 'net.outbound']`. Widen it per-spawn when a task
-     * legitimately needs more — e.g. `/techstack` adds `'fs.write'` so the
-     * subagent can write its report. Never grant `shell.*` unless the task
-     * truly requires arbitrary command execution.
-     */
-    allowedCapabilities?: readonly string[] | undefined;
-    model?: string | undefined;
-    priority?: number | undefined;
-    /**
-     * Director-authored recursion/budget inheritance. Director.spawn overwrites
-     * caller input so a model cannot forge a shallower depth or larger budget.
-     */
-    spawnLineage?: SubagentSpawnLineage | undefined;
-    /**
-     * Working directory for this subagent's tools. Defaults to the factory's
-     * cwd. AutoPhase sets this to a per-phase git worktree so parallel phases
-     * edit isolated checkouts instead of clobbering one shared working tree.
-     * `projectRoot` is intentionally left unchanged — tools resolve the
-     * worktree's `.git` gitlink from `cwd` while staying bounded to the repo.
-     */
-    cwd?: string | undefined;
-    /**
-     * Git-worktree isolation override for this subagent.
-     *
-     * - `undefined` / `'auto'`: follow the fleet policy. Mutating/build-capable
-     *   agents get isolated worktrees; read-only review agents can stay on the
-     *   shared checkout.
-     * - `true` / `'required'`: require an isolated worktree. If allocation fails,
-     *   the task fails instead of falling back to the shared cwd.
-     * - `false` / `'off'`: never allocate a worktree for this subagent.
-     */
-    worktree?: boolean | 'auto' | 'required' | 'off' | undefined;
-    /**
-     * Provider registry id (e.g. `'anthropic'`, `'openai'`, `'google'`).
-     * Allows a director to mix providers across siblings — for example, one
-     * subagent on a planner model and another on a verifier model. Falls back to the
-     * factory's default provider when omitted, which is the legacy
-     * single-provider behavior.
-     */
-    provider?: string | undefined;
-    /**
-     * Ordered fallback model chain for THIS subagent (entries: `model` or
-     * `provider/model`). When the subagent's primary model 429s or stream-hangs,
-     * the factory's fallback extension rotates to the next entry. Empty/undefined
-     * → the factory's own default fallback behavior (usually the leader's config).
-     */
-    fallbackModels?: string[] | undefined;
-    /**
-     * Runtime request overrides for THIS subagent. When present, these are merged
-     * over the leader's `Config.modelRuntime` before the subagent request pipeline
-     * maps reasoning/cache/parameters onto provider requests. Used by the model
-     * matrix to give roles their own reasoning effort without changing the leader.
-     */
-    modelRuntime?: ModelRuntimeConfig | undefined;
-    /**
-     * Per-subagent session JSONL path. When omitted the orchestrator-
-     * supplied factory derives a path under `<sessionRoot>/<runId>/`.
-     * Override to redirect the transcript elsewhere (long-term storage,
-     * a different filesystem, etc.).
-     */
-    sessionPath?: string | undefined;
-    /**
-     * Additional text appended to the role's base system prompt. Does not
-     * replace it. Useful for last-mile guidance like "you may only call
-     * read tools, never write" or "respond in JSON only".
-     */
-    systemPromptOverride?: string | undefined;
-    /**
-     * Domain-specific knowledge injected into the subagent's system prompt
-     * between the shared scratchpad and the override. Typically populated
-     * from SKILL.md body content matching the subagent's role (e.g. the
-     * bug-hunter skill body for a bug-hunter subagent). Keeps subagents
-     * informed of same domain patterns the host agent knows.
-     */
-    skillContent?: string | undefined;
-    /**
-     * Routing for streaming output. `'director'` (default) forwards
-     * text/tool events to the parent's FleetBus so the director can read
-     * the subagent's stream. `'silent'` keeps everything subagent-local;
-     * the director only sees the final task result. `'user'` forwards
-     * direct to the user-facing renderer (gate this behind an explicit
-     * config flag — it can confuse the chat surface).
-     */
-    textStream?: 'director' | 'silent' | 'user' | undefined;
-    toolStream?: 'director' | 'silent' | 'user' | undefined;
-}
-/**
- * Discriminator for every distinct failure mode a subagent can hit. The
- * coordinator's classifier (`classifySubagentError` in
- * coordination/multi-agent-coordinator.ts) maps raw exceptions to one of
- * these — callers (delegate tool, /agents UI, retry policies) can then
- * branch on `kind` instead of grepping `error.message`. Each kind
- * documents its retryability so an orchestrator can act on it without
- * extra knowledge.
- */
-type SubagentErrorKind = 
-/** Provider returned 5xx. Transient server-side issue — safe to retry with backoff. */
-'provider_5xx'
-/** Provider returned 429. Rate-limited — retry with `backoffMs` delay. */
- | 'provider_rate_limit'
-/** Provider call timed out at the network layer (TCP / TLS / read). Retry safe. */
- | 'provider_timeout'
-/** Provider rejected the credentials (401/403). NOT retryable — config fix required. */
- | 'provider_auth'
-/** Model returned a "context length exceeded" error. Retrying without trimming will fail again. */
- | 'context_overflow'
-/** A tool's `execute()` returned `ok:false`. Logical task failure, not a crash. */
- | 'tool_failed'
-/** A tool's `execute()` threw an exception. Often retryable but cause-dependent. */
- | 'tool_threw'
-/** Hit the per-subagent `maxIterations` budget. Either raise budget or narrow task. */
- | 'budget_iterations'
-/** Hit the per-subagent `maxToolCalls` budget. Either raise budget or narrow task. */
- | 'budget_tool_calls'
-/** Hit the per-subagent `maxTokens` budget. */
- | 'budget_tokens'
-/** Hit the per-subagent `maxCostUsd` budget. */
- | 'budget_cost'
-/** Hit the per-subagent `timeoutMs` wall-clock budget. */
- | 'budget_timeout'
-/** Parent agent's AbortController fired (user Ctrl+C, parent unwound, sibling failure cascade). */
- | 'aborted_by_parent'
-/** LLM returned end_turn with no textual content. Often a prompt issue. */
- | 'empty_response'
-/** Parent-child bridge transport failed (rare — IPC / writer crash). */
- | 'bridge_failed'
-/** Everything else. Classifier fallback — should narrow over time as new modes appear. */
- | 'unknown';
-/**
- * Structured failure envelope. Replaces the prior `error?: string` so
- * callers can switch on `kind`, respect `retryable`, and apply
- * provider-suggested `backoffMs` instead of guessing from substring
- * matches on the message.
- */
-interface SubagentError {
-    /** Discriminator — see SubagentErrorKind doc strings for semantics. */
-    kind: SubagentErrorKind;
-    /** Human-readable summary, suitable for direct UI display. Always populated. */
-    message: string;
-    /** True if the operation can be retried as-is (possibly with backoff). */
-    retryable: boolean;
-    /** Suggested backoff before retry, in ms. Set for `provider_rate_limit` and `provider_5xx`. */
-    backoffMs?: number | undefined;
-    /** Original cause snapshot for diagnostics — never used for control flow. */
-    cause?: {
-        name: string;
-        message: string;
-        stack?: string | undefined;
-    } | undefined;
-}
-/**
- * Bounded, best-effort work recovered before a non-successful task ended.
- * This is deliberately separate from `result`: callers must not mistake an
- * incomplete stream tail for a completed deliverable.
- */
-interface SubagentPartialResult {
-    /** Last useful assistant text observed, capped by the coordinator. */
-    text: string;
-    /** Where the snapshot came from. */
-    source: 'stream' | 'run_result' | 'runner';
-    capturedAt: number;
-}
-/**
- * Compact machine-readable result submitted independently from the agent's
- * human-facing final text. Additive and optional for legacy/custom runners.
- */
-interface SubagentStructuredReport {
-    summary: string;
-    findings: string[];
-    files_examined: string[];
-    /** 0.0 (uncertain) through 1.0 (fully verified). */
-    confidence: number;
-    suggested_next_steps: string[];
-}
-interface TaskResult<T = unknown> {
-    subagentId: string;
-    taskId: string;
-    status: 'success' | 'failed' | 'timeout' | 'stopped';
-    result?: T | undefined;
-    /**
-     * Structured failure envelope. Populated whenever `status !== 'success'`.
-     * Prefer reading `error.kind` over substring-matching `error.message`.
-     */
-    error?: SubagentError | undefined;
-    /** Verified control-plane report, when the subagent called submit_result. */
-    report?: SubagentStructuredReport | undefined;
-    /** Useful incomplete work captured before timeout/abort/failure. */
-    partial?: SubagentPartialResult | undefined;
-    iterations: number;
-    toolCalls: number;
-    durationMs: number;
-}
-interface TaskSpec {
-    id: string;
-    description: string;
-    subagentId?: string | undefined;
-    priority?: number | undefined;
-    maxToolCalls?: number | undefined;
-    timeoutMs?: number | undefined;
-    context?: Record<string, unknown>;
-}
-interface DoneCondition {
-    type: 'iterations' | 'tool_calls' | 'output_match' | 'custom' | 'all_tasks_done' | 'directive';
-    maxIterations?: number | undefined;
-    maxToolCalls?: number | undefined;
-    pattern?: string | undefined;
-    predicate?: string | undefined;
-    /**
-     * For `directive` type — stop when model emits [done] and keep going
-     * on [continue]/[next step]/[proceed] WITHOUT returning to the outer runner.
-     * When false (default), the runner behaves normally (one agent.run per loop).
-     * When true, the runner passes `autonomousContinue: true` to the agent and
-     * re-runs internally when the model signals continue.
-     */
-    autonomous?: boolean | undefined;
-}
-interface MultiAgentConfig {
-    coordinatorId: string;
-    leaderSystemPrompt?: string | undefined;
-    subagents?: SubagentConfig[] | undefined;
-    maxConcurrent?: number | undefined;
-    doneCondition: DoneCondition;
-    timeoutMs?: number | undefined;
-    /**
-     * Optional default budget applied to every spawned subagent. Per-subagent
-     * fields in `SubagentConfig` override these. Coordinator enforces them by
-     * constructing a `SubagentBudget` per spawn — see `SubagentRunContext.budget`.
-     */
-    defaultBudget?: {
-        maxIterations?: number | undefined;
-        maxToolCalls?: number | undefined;
-        maxTokens?: number | undefined;
-        maxCostUsd?: number | undefined;
-        timeoutMs?: number | undefined;
-        idleTimeoutMs?: number | undefined;
-    };
-}
-interface SpawnResult {
-    subagentId: string;
-    agentId: string;
-}
-interface TaskDelegation {
-    task: TaskSpec;
-    subagentId: string;
-}
-interface CoordinatorEvents {
-    'task.assigned': {
-        task: TaskSpec;
-        subagentId: string;
-    };
-    'task.completed': {
-        task: TaskSpec;
-        result: TaskResult;
-    };
-    'subagent.started': {
-        subagent: SubagentConfig;
-    };
-    'subagent.stopped': {
-        subagentId: string;
-        reason: string;
-    };
-    done: {
-        results: TaskResult[];
-        totalIterations: number;
-    };
-}
-/**
- * Result of {@link MultiAgentCoordinator.awaitTasksAny} — a partial drain of a
- * task-id batch. `completed` holds every requested id that has already
- * settled (at least one, unless `timedOut`); `pending` holds the rest, so the
- * caller can loop "handle finishers, re-await the remainder".
- */
-interface AwaitAnyResult {
-    completed: TaskResult[];
-    pending: string[];
-    /** Set when `timeoutMs` elapsed with zero completions among the requested ids. */
-    timedOut?: boolean;
-}
-interface MultiAgentCoordinator {
-    readonly coordinatorId: string;
-    readonly config: MultiAgentConfig;
-    spawn(subagent: SubagentConfig): Promise<SpawnResult>;
-    assign(task: TaskSpec): Promise<void>;
-    delegate(to: string, msg: BridgeMessage): Promise<void>;
-    stop(subagentId: string): Promise<void>;
-    stopAll(): Promise<void>;
-    /**
-     * Stop a subagent and remove it from the coordinator. Releases all
-     * associated resources. The subagent id can be reused in a future spawn.
-     */
-    remove(subagentId: string): Promise<void>;
-    getStatus(): CoordinatorStatus;
-    /**
-     * Wait for one or more tasks to complete and return their results.
-     * If a task is already done when called, returns immediately.
-     * Resolves to an array in the same order as `taskIds`.
-     */
-    awaitTasks(taskIds: string[]): Promise<TaskResult[]>;
-    /**
-     * Wait until AT LEAST ONE of the named tasks completes, then return every
-     * requested result available at that moment plus the still-pending ids.
-     * Ids that already completed resolve immediately (drain-what's-done). With
-     * `timeoutMs`, resolves (never rejects) with `timedOut: true` and zero
-     * completions when the window elapses first.
-     */
-    awaitTasksAny(taskIds: string[], opts?: {
-        timeoutMs?: number;
-    }): Promise<AwaitAnyResult>;
-    /** Snapshot of completed task results. */
-    results(): readonly TaskResult[];
-    /** Defensive snapshot of the still-queued (not yet dispatched) tasks. */
-    listPendingTasks(): readonly TaskSpec[];
-    /**
-     * Re-pin a still-pending task to a different subagent (`undefined` =
-     * unpin) and try to dispatch. Returns `false` when the task is no longer
-     * pending (dispatched/completed/unknown) or the target subagent does not
-     * exist. Running tasks can never be pulled — steer or terminate instead.
-     */
-    retargetPendingTask(taskId: string, subagentId: string | undefined): boolean;
-}
-/**
- * Caller-supplied runner that actually executes a task. The coordinator
- * provides isolated state (own budget, own AbortSignal, own bridge handle)
- * and enforces concurrency limits — the runner just runs the task and reports
- * the outcome. This is the injection seam that decouples the coordinator
- * from `Agent` so it can be tested with mocks and reused for non-Agent
- * subagents (workers, MCP-driven subagents, etc.).
- */
-type SubagentRunner = (task: TaskSpec, ctx: SubagentRunContext) => Promise<SubagentRunOutcome>;
-interface SubagentRunContext {
-    subagentId: string;
-    config: SubagentConfig;
-    budget: SubagentBudget;
-    signal: AbortSignal;
-    /** Null until `setSubagentBridge` is called for this subagent. */
-    bridge: AgentBridge | null;
-    /** Publish a bounded in-memory snapshot that survives timeout races. */
-    reportProgress?: ((partial: SubagentPartialResult) => void) | undefined;
-}
-interface SubagentRunOutcome {
-    result?: unknown | undefined;
-    report?: SubagentStructuredReport | undefined;
-    iterations: number;
-    toolCalls: number;
-}
-interface CoordinatorStatus {
-    coordinatorId: string;
-    subagents: {
-        id: string;
-        name: string;
-        status: 'running' | 'idle' | 'stopped' | 'error';
-        currentTask?: string | undefined;
-        /** Cumulative budget auto-extensions granted to this subagent, when the
-         *  status is produced by a Director that tracks them. */
-        extensions?: number | undefined;
-    }[];
-    pendingTasks: number;
-    completedTasks: number;
-    totalIterations: number;
-    done: boolean;
-}
-interface SubagentContext {
-    subagentId: string;
-    tasks: TaskSpec[];
-    /**
-     * Two-phase initialization: `spawn()` creates the subagent before the
-     * bridge is wired (`setSubagentBridge()`), so `parentBridge` is nullable
-     * by design. Readers must `hasParentBridge()`-guard or null-check before
-     * use; the prior `null as never as AgentBridge` cast was a type lie
-     * that hid this from the compiler.
-     */
-    parentBridge: AgentBridge | null;
-    doneCondition: DoneCondition;
-    maxConcurrent: number;
-}
-
-/**
- * Single fleet-wide event with subagent attribution. Whatever a child
- * agent emits on its own EventBus gets re-published here, prefixed with
- * `subagentId` so a single subscriber can multiplex across the fleet.
- *
- * The director uses `FleetBus.filter('tool.executed', …)` to see every
- * tool call across the fleet; the TUI uses
- * `FleetBus.subscribe(id, handler)` to render a per-subagent panel.
- */
-interface FleetEvent {
-    subagentId: string;
-    taskId?: string | undefined;
-    ts: number;
-    type: string;
-    payload: unknown;
-}
-type FleetHandler = (event: FleetEvent) => void;
-/**
- * Fan-in for per-subagent EventBuses. Each subagent's bus is plugged in
- * via `attach()`; the FleetBus re-emits every event with subagent
- * attribution. Detachment is automatic via the returned disposer — call
- * it when a subagent terminates so we don't leak listeners.
- *
- * The bus exposes two subscription modes: by `subagentId` (everything
- * from one child) and by `type` (one event-type across the fleet). They
- * compose — if you need a per-subagent + per-type slice, subscribe by
- * type and filter on `event.subagentId` in your handler.
- */
-declare class FleetBus {
-    private readonly byId;
-    private readonly byType;
-    private readonly any;
-    /**
-     * Hook a subagent's EventBus into the fleet. Uses `onAny()` (an alias for
-     * `onPattern('*')`) to forward all events with subagent attribution, so
-     * new kernel event types are automatically forwarded without any manual
-     * registration. `subagent.*` events are excluded because they originate
-     * from MultiAgentHost on the parent bus, not the subagent's own bus.
-     *
-     * Returns a disposer that detaches every subscription; call on
-     * subagent teardown so the listeners don't outlive the run.
-     */
-    attach(subagentId: string, bus: EventBus, taskId?: string): () => void;
-    /** Subscribe to every event from one subagent. */
-    subscribe(subagentId: string, handler: FleetHandler): () => void;
-    /** Subscribe to one event type across all subagents. */
-    filter(type: string, handler: FleetHandler): () => void;
-    /** Subscribe to literally everything. The fleet roll-up uses this. */
-    onAny(handler: FleetHandler): () => void;
-    emit(event: FleetEvent): void;
-    clear(): void;
-}
-/**
- * Roll-up of token usage + cost across an entire director run. The
- * director's `fleet` tool returns this so the model can reason
- * about budget in its next turn ("the researcher already burned $0.40,
- * lean on summaries for the next task").
- */
-interface FleetUsage {
-    total: {
-        input: number;
-        output: number;
-        cacheRead: number;
-        cacheWrite: number;
-        cost: number;
-    };
-    perSubagent: Record<string, SubagentUsageSnapshot>;
-}
-interface SubagentUsageSnapshot {
-    subagentId: string;
-    provider?: string | undefined;
-    model?: string | undefined;
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-    cost: number;
-    toolCalls: number;
-    iterations: number;
-    startedAt: number;
-    lastEventAt: number;
-}
-/**
- * Aggregates provider.response + tool.executed events from the FleetBus
- * into a live `FleetUsage` snapshot. Costs are computed by the caller
- * via a `priceLookup(subagentId)` so we don't bake provider-pricing
- * coupling into core; the CLI/tests supply a function that resolves
- * each subagent's per-token rates from the models registry.
- */
-declare class FleetUsageAggregator {
-    private readonly priceLookup?;
-    private readonly metaLookup?;
-    private readonly perSubagent;
-    private readonly total;
-    private readonly unsub;
-    constructor(bus: FleetBus, priceLookup?: ((subagentId: string, provider?: string | undefined, model?: string | undefined) => {
-        input?: number | undefined;
-        output?: number | undefined;
-        cacheRead?: number | undefined;
-        cacheWrite?: number | undefined;
-    } | undefined) | undefined, metaLookup?: ((subagentId: string) => {
-        provider?: string | undefined;
-        model?: string | undefined;
-    } | undefined) | undefined);
-    /**
-     * Remove a terminated subagent's data from the aggregator and subtract its
-     * contribution from the running totals. Call this when a subagent is removed
-     * from the fleet so the aggregator doesn't accumulate unbounded data for
-     * entities that will never emit events again.
-     */
-    removeSubagent(subagentId: string): void;
-    /** Disposes all fleet-bus subscriptions. Call when the aggregator is no longer needed. */
-    dispose(): void;
-    /** Live snapshot — safe to call from a tool's execute() body. */
-    snapshot(): FleetUsage;
-    private ensure;
-    private onProviderResponse;
-    private onToolExecuted;
-    private onIterationStarted;
-}
-
-/**
- * Caller-supplied factory that builds an isolated `Agent` for a subagent.
- * The factory MUST construct a fresh `Context` per call — sharing context
- * between subagents defeats isolation. Each Agent should also use either
- * its own `EventBus` or a forwarded view, so per-subagent metrics can be
- * attributed correctly.
- */
-type AgentFactory = (config: SubagentConfig) => Promise<AgentFactoryResult>;
-/**
- * Wrap a factory to automatically filter out disabled tools from subagent
- * configurations. This provides mechanical enforcement of tool restrictions
- * (e.g., preventing delegation) in addition to the baseline prompt constraint.
- *
- * The wrapper reads `config.disabledTools` and removes those tools from the
- * agent's tool registry before returning.
- *
- * Usage:
- *   const filteredFactory = withDisabledToolFiltering(originalFactory);
- *   const runner = makeAgentSubagentRunner({ factory: filteredFactory });
- */
-declare function withDisabledToolFiltering(factory: AgentFactory): AgentFactory;
-interface AgentFactoryResult {
-    agent: Agent;
-    /** Event bus the factory wired to this agent — required for budget hookup. */
-    events: EventBus;
-    /**
-     * Optional cleanup hook invoked in the runner's `finally` block once
-     * the task ends (success, failure, abort — same exit path). Factories
-     * that own resources scoped to a single task (per-subagent JSONL
-     * writers, transient providers, throwaway containers) implement this
-     * to close them deterministically instead of relying on GC. Errors
-     * thrown here are swallowed so a flaky cleanup can't mask the task's
-     * real result.
-     */
-    dispose?: ((() => Promise<void> | void)) | undefined;
-}
-interface AgentRunnerOptions {
-    factory: AgentFactory;
-    /**
-     * Format a TaskSpec into the user input the agent will receive. Defaults
-     * to `task.description ?? ''`. Override when subagents expect structured
-     * input (e.g. JSON contracts, role-prefixed prompts).
-     */
-    formatTaskInput?: (task: TaskSpec, config: SubagentConfig) => AgentInput;
-    /**
-     * When set, the runner attaches the subagent's EventBus to this FleetBus
-     * on task start and detaches it when the task finishes. This is the
-     * injection seam that lets the TUI fleet panel observe subagent activity
-     * live — without it, FleetBus stays empty.
-     */
-    fleetBus?: FleetBus | undefined;
-}
-/**
- * Builds a `SubagentRunner` that drives a real `Agent` per task while honoring
- * the coordinator's budget and abort signal. This is the production adapter —
- * the coordinator's `runner` option in CLI/TUI assemblies points here.
- *
- * Lifecycle per task:
- *   1. factory(config) → fresh Agent + EventBus.
- *   2. Subscribe to events to feed the budget (tool calls, token usage).
- *   3. Call agent.run(input, { signal }) — the coordinator's signal cancels.
- *   4. Map RunResult.status onto a `SubagentRunOutcome` or throw on failure.
- *   5. Unsubscribe and let the factory's resources be GC'd.
- *
- * The budget is checked synchronously from event handlers — a runaway agent
- * that crosses its tool-call limit triggers `BudgetExceededError`, which the
- * coordinator surfaces as `status: 'failed'` on the task result.
- */
-declare function makeAgentSubagentRunner(opts: AgentRunnerOptions): SubagentRunner;
-
-/**
- * Catalog types for the WrongStack agent fleet.
- *
- * An `AgentDefinition` bundles the runtime `SubagentConfig` (id/name/role/
- * prompt/tools) with two things the bare config lacks:
- *   - a per-role `budget` tier (consumed by FLEET_ROSTER_BUDGETS), and
- *   - dispatcher `capability` metadata (keywords + summary + phase) used by
- *     the smart dispatcher to route a free-form task to the best agent.
- *
- * Phase files (`phase1-discovery.ts` … `phase9-meta.ts`) each export an
- * `AgentDefinition[]`; `index.ts` aggregates them into `AGENT_CATALOG`.
- * `fleet.ts` derives `FLEET_ROSTER` + `FLEET_ROSTER_BUDGETS` from the catalog.
- */
-
-/** Lifecycle phase grouping. Drives statusline labels + dispatcher tie-breaks. */
-type AgentPhase = 'discovery' | 'planning' | 'build' | 'verify' | 'review' | 'domain' | 'knowledge' | 'delivery' | 'meta';
-/** Per-role budget tier. Same shape as fleet.ts `FleetRosterBudget`. */
-interface AgentBudgetTier {
-    timeoutMs?: number | undefined;
-    maxIterations?: number | undefined;
-    maxToolCalls?: number | undefined;
-    maxTokens?: number | undefined;
-    maxCostUsd?: number | undefined;
-}
-/** Dispatcher routing metadata. */
-interface AgentCapability {
-    phase: AgentPhase;
-    /**
-     * One-line capability summary. Fed to the LLM dispatcher classifier as the
-     * candidate's description, and shown to the user when explaining a routing
-     * decision. Keep it concrete and distinct from sibling agents.
-     */
-    summary: string;
-    /**
-     * Lowercased signal words/phrases for the heuristic dispatcher. A task whose
-     * description contains these scores toward this agent. Order doesn't matter;
-     * prefer specific terms ("graphql", "wcag") over generic ones ("code").
-     */
-    keywords: string[];
-}
-/** A single catalog entry: runtime config + budget tier + routing metadata. */
-interface AgentDefinition {
-    config: SubagentConfig;
-    budget: AgentBudgetTier;
-    capability: AgentCapability;
-}
-/**
- * Budget tiers by workload weight. Deliberately generous — the project's
- * existing roster uses multi-hour ceilings to avoid spurious timeouts on
- * monorepo-scale work, and the auto-extend handshake raises them further when
- * a subagent is still making progress.
- */
-declare const LIGHT_BUDGET: AgentBudgetTier;
-declare const MEDIUM_BUDGET: AgentBudgetTier;
-declare const HEAVY_BUDGET: AgentBudgetTier;
-/**
- * Tool allowlist presets. Agents pass the smallest set that covers their job —
- * a planning agent should not hold `write`/`bash`, a reviewer should be
- * read-only. Spread + extend per-agent where a role needs one extra tool.
- */
-declare const TOOLS: {
-    /** Pure read/inspect — safe for analysis and review agents. */
-    readonly read: readonly ["read", "grep", "glob", "search", "tree", "mailbox"];
-    /** Read + structured inspection (logs, diffs, json, dependency audit). */
-    readonly inspect: readonly ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit", "mailbox"];
-    /** Read + edit (no shell). For agents that write code/docs but don't run it. */
-    readonly write: readonly ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch", "mailbox"];
-    /** Full build loop: edit + run (lint/format/typecheck/test/bash). */
-    readonly build: readonly ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch", "bash", "exec", "lint", "format", "typecheck", "test", "mailbox"];
-    /** Version control. */
-    readonly vcs: readonly ["read", "grep", "glob", "git", "diff"];
-    /** Dependency management + CVE audit. */
-    readonly deps: readonly ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"];
-    /** Documentation authoring. */
-    readonly docs: readonly ["read", "grep", "glob", "search", "tree", "write", "edit", "document", "mailbox"];
-    /** Web research. */
-    readonly research: readonly ["read", "grep", "glob", "search", "fetch", "mailbox"];
-};
-
-/**
- * Smart agent dispatcher.
- *
- * Routes a free-form task description to the best agent in the catalog using a
- * two-stage strategy:
- *
- *   1. Heuristic — keyword/phrase scoring against each agent's `capability`
- *      metadata. Deterministic, instant, no provider call. Multi-word phrases
- *      score higher than single words (they're more specific signals).
- *
- *   2. LLM fallback — when the heuristic is ambiguous (confidence below the
- *      threshold, or no keyword hit at all) an injected `classifier` resolves
- *      the tie. The classifier is provider-agnostic: callers wire it to any
- *      `complete(prompt) => text` function via `makeLLMClassifier`, so core
- *      stays free of provider dependencies and the path is unit-testable.
- *
- * If neither stage yields a confident pick, the dispatcher falls back to the
- * `executor` generalist rather than failing.
- */
-
-/** Default agent used when nothing else matches — the generalist builder. */
-declare const DEFAULT_DISPATCH_ROLE = "executor";
-interface DispatchCandidate {
-    role: string;
-    name: string;
-    score: number;
-    /** Capability keywords that matched the task text. */
-    matched: string[];
-}
-type DispatchMethod = 'heuristic' | 'llm' | 'fallback';
-interface DispatchResult {
-    role: string;
-    definition: AgentDefinition;
-    /** 0..1 — heuristic margin, or 1 when an LLM made a definite choice. */
-    confidence: number;
-    method: DispatchMethod;
-    /** Human-readable explanation of why this agent was chosen. */
-    reason: string;
-    /** Runner-up candidates (top heuristic scorers), best-first. */
-    alternatives: DispatchCandidate[];
-}
-/**
- * Provider-agnostic classifier seam. Given the task and the candidate agents
- * (role + summary), return the chosen role (and optional reason), or null to
- * decline. Wire via `makeLLMClassifier`.
- */
-type DispatchClassifier = (task: string, candidates: {
-    role: string;
-    name: string;
-    summary: string;
-}[]) => Promise<{
-    role: string;
-    reason?: string | undefined;
-} | null>;
-interface DispatchOptions {
-    /** Optional LLM fallback for ambiguous tasks. */
-    classifier?: DispatchClassifier | undefined;
-    /** Heuristic confidence below this triggers the classifier. Default 0.4. */
-    confidenceThreshold?: number | undefined;
-    /** How many top candidates to offer the classifier. Default 6. */
-    maxCandidates?: number | undefined;
-    /** Override the catalog (testing). Defaults to the full `AGENT_CATALOG`. */
-    catalog?: Record<string, AgentDefinition> | undefined;
-}
-/**
- * Score every agent against the task. A keyword hit adds 1 point; a multi-word
- * keyword phrase adds points equal to its word count (more specific = stronger
- * signal). Returns candidates sorted best-first, zero-score agents dropped.
- */
-declare function scoreAgents(task: string, catalog?: Record<string, AgentDefinition>): DispatchCandidate[];
-/**
- * Route a task to the best agent. Async because the LLM fallback may run; the
- * pure-heuristic path resolves without awaiting anything.
- */
-declare function dispatchAgent(task: string, opts?: DispatchOptions): Promise<DispatchResult>;
-/**
- * Build a `DispatchClassifier` from a minimal `complete(prompt) => text`
- * function. The caller supplies the provider call; this owns the prompt and
- * the parsing. Keeps `dispatcher` free of any provider import.
- */
-declare function makeLLMClassifier(complete: (prompt: string) => Promise<string>): DispatchClassifier;
-
-interface MultiAgentCoordinatorOptions {
-    /**
-     * Callback that executes a task on behalf of a subagent. Required for
-     * `assign()` to actually run anything — without it, tasks queue forever.
-     * The coordinator provides per-subagent isolation (own budget, own signal,
-     * own bridge) and enforces timeout + concurrency.
-     */
-    runner?: SubagentRunner | undefined;
-    /**
-     * Session id for EventBus/FleetBus emissions produced by this coordinator.
-     * Accepts a getter so a long-lived coordinator follows session resume/new.
-     */
-    sessionId?: BudgetSessionIdSource | undefined;
-}
-declare class DefaultMultiAgentCoordinator extends EventEmitter implements MultiAgentCoordinator {
-    readonly coordinatorId: string;
-    readonly config: MultiAgentConfig;
-    private runner?;
-    private readonly sessionId;
-    private fleetBus?;
-    private readonly subagents;
-    /**
-     * Base nickname keys already handed out this run (e.g. `einstein`, `tesla`).
-     * Prevents two workers sharing a name. Direct `coordinator.spawn()` callers
-     * (parallel/eternal engine, SDD parallel run) don't go through
-     * `Director.spawn()` where nicknames are normally assigned, so the
-     * coordinator upgrades placeholder names ("Executor", "slot-ab12cd", role
-     * names) to memorable ones here — that's what surfaces in the fleet monitor.
-     */
-    private readonly usedNicknames;
-    /** Maps subagentId → nickname key (e.g. 'einstein'). Used to free the slot on remove(). */
-    private readonly subagentNicknames;
-    private pendingTasks;
-    private completedResults;
-    /** Prevents completedResults from growing unbounded in long-running coordinators. */
-    private static readonly MAX_COMPLETED_RESULTS;
-    private totalIterations;
-    private inFlight;
-    /**
-     * Subagents currently being stopped. Set on entry to `stop()`, cleared
-     * once `recordCompletion` lands the terminal TaskResult. Used by
-     * `runDispatched` and `findIdleSubagent` to refuse mid-flight dispatch
-     * to a subagent the caller has already asked to terminate — closes the
-     * assign+terminate race where a fresh task could land on a worker that
-     * was about to be killed.
-     */
-    private readonly terminating;
-    constructor(config: MultiAgentConfig, options?: MultiAgentCoordinatorOptions);
-    private currentSessionId;
-    /**
-     * Replace the runner after construction. Used when the runner depends
-     * on infrastructure (e.g. FleetBus) that isn't available until after
-     * the coordinator's owning Director is built.
-     */
-    setRunner(runner: SubagentRunner): void;
-    /**
-     * Wire a FleetBus for director-mode event emission. Call after the
-     * FleetManager is constructed so the coordinator can emit lifecycle
-     * events the TUI and monitoring tools subscribe to.
-     */
-    setFleetBus(fleet: FleetBus): void;
-    /**
-     * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
-     * preempt running tasks — already-dispatched subagents finish their
-     * current task; only future dispatches respect the new cap. Raising
-     * immediately tries to fill the freed slots from the pending queue.
-     */
-    setMaxConcurrent(n: number): void;
-    /**
-     * Upgrade a placeholder/role-derived name to a memorable scientist nickname
-     * (e.g. "Einstein (Executor)"). A name is treated as a placeholder when it is
-     * empty, equals the role (case-insensitive), is a generic default
-     * ("subagent"/"adhoc"/"generic"), or is an auto-generated `slot-…` id.
-     * Explicit, human-chosen names — including nicknames already assigned by
-     * `Director.spawn()` — are left untouched, so this never double-assigns.
-     */
-    private withNickname;
-    spawn(subagent: SubagentConfig): Promise<SpawnResult>;
-    assign(task: TaskSpec): Promise<void>;
-    delegate(to: string, msg: BridgeMessage): Promise<void>;
-    /**
-     * Wire up the communication bridge for a subagent. Call after spawn() once
-     * the caller has created the bidirectional connection.
-     */
-    setSubagentBridge(subagentId: string, bridge: AgentBridge): void;
-    stop(subagentId: string): Promise<void>;
-    stopAll(): Promise<void>;
-    /**
-     * Get current coordinator stats for monitoring/debugging.
-     */
-    getStats(): {
-        total: number;
-        running: number;
-        idle: number;
-        stopped: number;
-        inFlight: number;
-        pending: number;
-        completed: number;
-    };
-    /** Emit a reactive coordinator.stats event on FleetBus so the TUI can subscribe. */
-    private emitCoordinatorStats;
-    getStatus(): CoordinatorStatus;
-    /** Expose snapshot of completed results — useful for callers awaiting all done. */
-    results(): readonly TaskResult[];
-    /** Defensive snapshot of the still-queued (not yet dispatched) tasks. */
-    listPendingTasks(): readonly TaskSpec[];
-    /**
-     * Re-pin a still-PENDING task to a different subagent (`undefined` =
-     * unpin, any idle worker may take it), then try to dispatch. Returns
-     * `false` when the task is not in the pending queue — already
-     * dispatched, completed, or unknown. Running tasks can never be pulled;
-     * they can only be steered or terminated. The mutation is synchronous
-     * (same tick as the check), so it cannot race a concurrent dispatch:
-     * `tryDispatchNext` runs on this same call stack or a later one.
-     *
-     * The task keeps its id, so waiters, the report-back notifier, and
-     * checkpoint bookkeeping resolve unchanged when it eventually completes.
-     */
-    retargetPendingTask(taskId: string, subagentId: string | undefined): boolean;
-    /**
-     * Wait for one or more tasks to complete and return their results.
-     * If a task is already done when called, returns immediately.
-     * Resolves to an array in the same order as `taskIds`.
-     */
-    awaitTasks(taskIds: string[]): Promise<TaskResult[]>;
-    /**
-     * Wait until AT LEAST ONE of the named tasks completes. Returns every
-     * requested result already available at that moment (drain-what's-done)
-     * plus the ids still outstanding, so callers can loop "handle finishers,
-     * re-await the remainder" instead of blocking on the whole batch.
-     *
-     * Unlike `awaitTasks`, this never rejects and deliberately does NOT
-     * inherit `config.timeoutMs` — a "return whatever is done" call has no
-     * business timing out unless the caller asks for a window explicitly.
-     */
-    awaitTasksAny(taskIds: string[], opts?: {
-        timeoutMs?: number;
-    }): Promise<AwaitAnyResult>;
-    /**
-     * Manual completion — for callers that drive subagents without a runner
-     * (e.g. external orchestrators). When a runner is configured the coordinator
-     * calls this itself.
-     */
-    completeTask(result: TaskResult): void;
-    private tryDispatchNext;
-    private canDispatch;
-    private takeNextDispatchableTask;
-    private findIdleSubagent;
-    private isIdleSubagent;
-    /**
-     * Returns true iff at least one spawned subagent could still
-     * process a task. A "live" subagent is one that is not stopped
-     * AND not mid-termination — `running` workers count because they
-     * will eventually finish and become idle.
-     *
-     * When no subagent has ever been spawned, returns `true` so a
-     * pre-spawn `assign()` simply queues (legacy behaviour). The
-     * dead-end detection only fires after `stop()` has retired every
-     * spawned worker.
-     *
-     * Used by `tryDispatchNext` to detect a dead-end pending queue.
-     */
-    private hasLiveSubagent;
-    /**
-     * Drain every pending task with a synthetic `aborted_by_parent`
-     * completion event. Same shape as the `stopAll()` drain — we go
-     * around `recordCompletion` because pending tasks were never
-     * counted in `inFlight` and routing them through would trip the
-     * underflow guard on every task after the first.
-     */
-    private drainPendingAsAborted;
-    /**
-     * Emit a synthetic `stopped`/`aborted_by_parent` completion for a single
-     * PENDING task — one that was never counted in `inFlight`. This MUST bypass
-     * `recordCompletion`: that path does `inFlight--`, which for a pending task
-     * steals a decrement from a genuinely in-flight task and trips the underflow
-     * guard — suppressing that real task's `task.completed` and hanging its
-     * `awaitTasks()` caller. Pushes the result and fires the event directly.
-     */
-    private emitPendingAborted;
-    private runDispatched;
-    private executeWithTimeout;
-    private recordCompletion;
-    /**
-     * Stop a subagent and remove it from the coordinator. Releases all
-     * associated resources (AbortController, context, budget state).
-     * The subagent entry is deleted so the id can be reused in a future spawn.
-     */
-    remove(subagentId: string): Promise<void>;
-    private isDone;
-}
-
-export { type DispatchResult as $, Agent as A, type BridgeTransport as B, type CoordinatorStatus as C, type DispatchClassifier as D, type AgentBudgetTier as E, FleetBus as F, type AgentCapability as G, type AgentFactoryResult as H, type AgentRunnerOptions as I, BudgetExceededError as J, type BudgetKind as K, type BudgetLimits as L, type MultiAgentConfig as M, type BudgetNegotiationMode as N, type BudgetThresholdDecision as O, type PluginAPI as P, type BudgetThresholdHandler as Q, BudgetThresholdSignal as R, type SubagentRunner as S, type TaskSpec as T, type BudgetUsage as U, type CoordinatorEvents as V, DECISION_TIMEOUT_MS as W, DEFAULT_DISPATCH_ROLE as X, type DispatchCandidate as Y, type DispatchMethod as Z, type DispatchOptions as _, type AgentFactory as a, type FleetEvent as a0, type FleetHandler as a1, HEAVY_BUDGET as a2, LIGHT_BUDGET as a3, MEDIUM_BUDGET as a4, type MultiAgentCoordinator as a5, type MultiAgentCoordinatorOptions as a6, type PluginLLMOptions as a7, type PluginLLMResult as a8, type SpawnResult as a9, SubagentBudget as aa, type SubagentContext as ab, type SubagentError as ac, type SubagentErrorKind as ad, type SubagentPartialResult as ae, type SubagentRunContext as af, type SubagentRunOutcome as ag, type SubagentSpawnLineage as ah, type SubagentStructuredReport as ai, type SubagentUsageSnapshot as aj, TIMEOUT_PREEMPT_FRACTION as ak, type TaskDelegation as al, dispatchAgent as am, makeAgentSubagentRunner as an, makeLLMClassifier as ao, scoreAgents as ap, withDisabledToolFiltering as aq, type ProviderFactory as ar, DefaultMultiAgentCoordinator as b, type DoneCondition as c, type BridgeMessage as d, type AgentBridge as e, type AgentBridgeConfig as f, type AgentPhase as g, type AgentDefinition as h, type SubagentConfig as i, type FleetUsage as j, FleetUsageAggregator as k, type TaskResult as l, type AwaitAnyResult as m, type SlashCommand as n, type PluginPipelines as o, type ToolRegistryView as p, type ProviderRegistryView as q, type MCPRegistryView as r, type SlashCommandRegistryView as s, type SessionWriterView as t, type MetricsSinkView as u, type PluginLLM as v, type PluginCapabilities as w, type PluginDependency as x, type Plugin as y, TOOLS as z };