import type { EventBus } from '../kernel/events.js';
/**
 * 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.
 */
export interface FleetEvent {
    subagentId: string;
    taskId?: string | undefined;
    ts: number;
    type: string;
    payload: unknown;
}
export 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.
 */
export 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").
 */
export interface FleetUsage {
    total: {
        input: number;
        output: number;
        cacheRead: number;
        cacheWrite: number;
        cost: number;
    };
    perSubagent: Record<string, SubagentUsageSnapshot>;
}
export 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.
 */
export 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;
}
//# sourceMappingURL=fleet-bus.d.ts.map