@wrongstack/core 0.277.2 → 0.280.1

package/dist/{agent-subagent-runner-BimKihiC.d.ts → agent-subagent-runner-PoqNKiR4.d.ts}

@@ -1,141 +1,479 @@
-import { c as ToolCallPipelinePayload, d as ToolWrapper, E as ExtensionRegistry, S as SystemPromptContributor, e as ToolRegistry, P as ProviderRegistry, A as AgentPipelines, f as ToolExecutorLike, g as AgentInit, h as AgentInput, R as RunResult } from './index-DJXj-dcr.js';
-import { C as Container, R as ReadonlyPipeline, a as Renderer } from './pipeline-CEjBjzVA.js';
-import { E as EventBus, a as EventName, L as Listener } from './brain-CCfuEOdp.js';
-import { R as RetryPolicy, E as ErrorHandler } from './retry-policy-Git9WF6d.js';
+import { c as ToolCallPipelinePayload, d as ToolWrapper, E as ExtensionRegistry, S as SystemPromptContributor, e as ToolRegistry, P as ProviderRegistry, A as AgentPipelines, f as ToolExecutorLike, g as AgentInit, h as AgentInput, R as RunResult } from './index-kidebiDh.js';
+import { C as Container, R as ReadonlyPipeline, a as Renderer } from './pipeline-BwAP21_4.js';
+import { E as EventBus, a as EventName, L as Listener } from './events-Bs2fmldo.js';
+import { R as RetryPolicy, E as ErrorHandler } from './retry-policy-D4feSLk3.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-DbsGOA1C.js';
-import { U as Usage, C as Context, J as JSONSchema, c as Request, d as Response, i as ContentBlock, r as TextBlock, T as Tool, P as Provider, u as RunOptions } from './context-DPlA6kid.js';
-import { W as WireFamily, H as HookEvent, f as HookMatcher, I as InProcessHook, C as Config } from './config-DAOjriz9.js';
+import { P as PermissionPolicy } from './permission-Dx6dIqS2.js';
+import { C as Context, J as JSONSchema, c as Request, d as Response, i as ContentBlock, s as TextBlock, T as Tool, P as Provider, v as RunOptions, U as Usage } from './tool-BkOgs_KL.js';
+import { W as WireFamily, H as HookEvent, f as HookMatcher, I as InProcessHook, C as Config, M as ModelsRegistry, h as ModelRuntimeConfig } from './config-Cr3312zc.js';
+import { b as Mailbox } from './mailbox-types-BGZWrYTJ.js';
+
+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>;
+}
 
 /**
- * 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.
+ * A slash command registered with the CLI or available to plugins.
+ * Plugins receive a view of the registry via PluginAPI.slashCommands.
  *
- * 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.
+ * Commands registered by plugins use a namespaced name: `pluginName:commandName`.
+ * This prevents collisions with built-in commands and other plugins.
  */
-interface FleetEvent {
-    subagentId: string;
-    taskId?: string | undefined;
-    ts: number;
+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;
-    payload: unknown;
+    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[];
 }
-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.
+ * Read-only view of the session writer. Plugins can append custom events
+ * to the JSONL session log and read the transcript path.
  *
- * 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.
+ * The `append` method accepts any JSON-serializable payload — custom
+ * event types are persisted verbatim next to the built-in events.
  */
-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;
+interface SessionWriterView {
+    readonly transcriptPath?: string | undefined;
+    append(event: Record<string, unknown> & {
+        type: string;
+        ts: string;
+    }): Promise<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").
+ * 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 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;
+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;
 }
 /**
- * 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.
+ * 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.
  */
-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);
+interface PluginLLMOptions {
+    /** System prompt for this call. */
+    system?: string | undefined;
+    /** Model override (e.g. `claude-haiku-4-5`). */
+    model?: string | 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.
+     * 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.
      */
-    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;
+    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;
 }
-
-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
+ * 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): () => 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;
+    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.
  */
@@ -450,37 +788,6 @@ declare class SubagentBudget {
     usage(): BudgetUsage;
 }
 
-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>;
-}
-
 interface SubagentConfig {
     id?: string | undefined;
     name: string;
@@ -552,6 +859,13 @@ interface SubagentConfig {
      * → 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>/`.
@@ -813,346 +1127,124 @@ interface SubagentContext {
 }
 
 /**
- * A slash command registered with the CLI or available to plugins.
- * Plugins receive a view of the registry via PluginAPI.slashCommands.
+ * 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.
  *
- * Commands registered by plugins use a namespaced name: `pluginName:commandName`.
- * This prevents collisions with built-in commands and other plugins.
+ * 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 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 {
+interface FleetEvent {
+    subagentId: string;
+    taskId?: string | undefined;
+    ts: number;
     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[];
+    payload: unknown;
 }
+type FleetHandler = (event: FleetEvent) => void;
 /**
- * Read-only view of the session writer. Plugins can append custom events
- * to the JSONL session log and read the transcript path.
+ * 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 `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).
+ * 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.
  */
-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;
-}
-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): () => 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;
+declare class FleetBus {
+    private readonly byId;
+    private readonly byType;
+    private readonly any;
     /**
-     * Emit a custom event on the agent's EventBus. Use for inter-plugin
-     * communication or to surface plugin-specific state to the host.
+     * 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.
      *
-     * 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.
+     * Returns a disposer that detaches every subscription; call on
+     * subagent teardown so the listeners don't outlive the run.
      */
-    onConfigChange(handler: (next: Readonly<Config>, prev: Readonly<Config>) => void): () => void;
+    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;
 }
 /**
- * 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.
+ * 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 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;
+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;
 }
 /**
- * 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' }]
+ * 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.
  */
-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>;
+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);
     /**
-     * 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.
+     * 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.
      */
-    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;
-    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>;
+    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;
 }
 
 /**
@@ -1225,4 +1317,4 @@ interface AgentRunnerOptions {
  */
 declare function makeAgentSubagentRunner(opts: AgentRunnerOptions): SubagentRunner;
 
-export { type TaskDelegation as $, type AgentBridge as A, type BridgeTransport as B, type CoordinatorStatus as C, type DoneCondition as D, type BudgetLimits as E, FleetBus as F, type BudgetNegotiationMode as G, type BudgetThresholdDecision as H, type BudgetThresholdHandler as I, BudgetThresholdSignal as J, type BudgetUsage as K, type CoordinatorEvents as L, type MultiAgentCoordinator as M, DECISION_TIMEOUT_MS as N, type FleetEvent as O, type PluginAPI as P, type FleetHandler as Q, SubagentBudget as R, type SubagentConfig as S, type TaskSpec as T, type SubagentContext as U, type SubagentError as V, type SubagentErrorKind as W, type SubagentRunContext as X, type SubagentRunOutcome as Y, type SubagentUsageSnapshot as Z, TIMEOUT_PREEMPT_FRACTION as _, type BridgeMessage as a, makeAgentSubagentRunner as a0, withDisabledToolFiltering as a1, type ProviderFactory as a2, type AgentBridgeConfig as b, type MultiAgentConfig as c, type SubagentRunner as d, type BudgetSessionIdSource as e, type SpawnResult as f, type TaskResult as g, Agent as h, type AgentFactory as i, type FleetUsage as j, FleetUsageAggregator as k, type SlashCommand as l, type PluginPipelines as m, type ToolRegistryView as n, type ProviderRegistryView as o, type MCPRegistryView as p, type SlashCommandRegistryView as q, type SessionWriterView as r, type MetricsSinkView as s, type PluginCapabilities as t, type PluginDependency as u, type Plugin as v, type AgentFactoryResult as w, type AgentRunnerOptions as x, BudgetExceededError as y, type BudgetKind as z };
+export { type SubagentRunOutcome as $, type AgentBridge as A, type BridgeTransport as B, type CoordinatorStatus as C, type DoneCondition as D, type BudgetKind as E, FleetBus as F, type BudgetLimits as G, type BudgetNegotiationMode as H, type BudgetThresholdDecision as I, type BudgetThresholdHandler as J, BudgetThresholdSignal as K, type BudgetUsage as L, type MultiAgentCoordinator as M, type CoordinatorEvents as N, DECISION_TIMEOUT_MS as O, type PluginAPI as P, type FleetEvent as Q, type FleetHandler as R, type SubagentConfig as S, type TaskSpec as T, type PluginLLMOptions as U, type PluginLLMResult as V, SubagentBudget as W, type SubagentContext as X, type SubagentError as Y, type SubagentErrorKind as Z, type SubagentRunContext as _, type BridgeMessage as a, type SubagentUsageSnapshot as a0, TIMEOUT_PREEMPT_FRACTION as a1, type TaskDelegation as a2, makeAgentSubagentRunner as a3, withDisabledToolFiltering as a4, type ProviderFactory as a5, type AgentBridgeConfig as b, type MultiAgentConfig as c, type SubagentRunner as d, type BudgetSessionIdSource as e, type SpawnResult as f, type TaskResult as g, Agent as h, type AgentFactory as i, type FleetUsage as j, FleetUsageAggregator as k, type SlashCommand as l, type PluginPipelines as m, type ToolRegistryView as n, type ProviderRegistryView as o, type MCPRegistryView as p, type SlashCommandRegistryView as q, type SessionWriterView as r, type MetricsSinkView as s, type PluginLLM as t, type PluginCapabilities as u, type PluginDependency as v, type Plugin as w, type AgentFactoryResult as x, type AgentRunnerOptions as y, BudgetExceededError as z };