@wrongstack/core 0.284.1 → 0.285.0

package/dist/null-fleet-bus-CFoNVQEK.d.ts

@@ -1,2127 +0,0 @@
-import { B as BridgeTransport, d as BridgeMessage, e as AgentBridge, f as AgentBridgeConfig, g as AgentPhase, h as AgentDefinition, S as SubagentRunner, T as TaskSpec, i as SubagentConfig, F as FleetBus, j as FleetUsage, k as FleetUsageAggregator, b as DefaultMultiAgentCoordinator, l as TaskResult, C as CoordinatorStatus, D as DispatchClassifier, M as MultiAgentConfig, m as AwaitAnyResult } from './multi-agent-coordinator-4RCRZKjN.js';
-import { E as EventBus, B as BrainArbiter } from './events-Bgnh43r9.js';
-import { b as SessionWriter, g as Tool, k as SessionStore } from './tool-BNlnIJvo.js';
-import { EventEmitter } from 'node:events';
-import { D as DirectorStateSnapshot } from './director-state-CMS_bMs4.js';
-import { F as FleetConfig, a as ModelMatrixEntry } from './config-MRqn1V-u.js';
-import { L as Logger } from './logger-B63L5bTg.js';
-import { W as WorktreeManager } from './worktree-manager-DzwxKE35.js';
-
-/**
- * In-memory pub/sub transport for agent-to-agent messaging.
- * Subscribers register by agentId and receive messages via callback.
- */
-declare class InMemoryBridgeTransport implements BridgeTransport {
-    private readonly subs;
-    send(msg: BridgeMessage, to: string): Promise<void>;
-    subscribe(agentId: string, handler: (msg: BridgeMessage) => void): () => void;
-    close(agentId: string): Promise<void>;
-}
-
-declare class InMemoryAgentBridge implements AgentBridge {
-    readonly agentId: string;
-    readonly coordinatorId: string;
-    private readonly transport;
-    private readonly subscriptions;
-    private readonly pendingRequests;
-    private stopped;
-    private timeoutMs;
-    /** Guards request() so concurrent calls on the same id can't silently overwrite. */
-    private readonly inflightGuards;
-    /** Stores the transport unsubscribe function so it can be called on stop(). */
-    private _transportUnsubscribe?;
-    constructor(config: AgentBridgeConfig, transport: BridgeTransport);
-    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>>;
-    stop(): Promise<void>;
-}
-declare function createMessage<T = unknown>(type: BridgeMessage['type'], from: string, payload: T, to?: string | undefined): BridgeMessage<T>;
-
-/**
- * Agent catalog aggregator.
- *
- * Collects every phase's `AgentDefinition[]` into:
- *   - `ALL_AGENT_DEFINITIONS` — flat list, catalog order (phase 1 → 9)
- *   - `AGENT_CATALOG`         — keyed by role for O(1) lookup
- *   - `AGENTS_BY_PHASE`       — grouped for statusline / dispatcher tie-breaks
- *
- * `fleet.ts` derives `FLEET_ROSTER` + `FLEET_ROSTER_BUDGETS` from this, and the
- * dispatcher routes free-form tasks against `capability` metadata here.
- */
-
-/** Every catalog agent, in phase order. */
-declare const ALL_AGENT_DEFINITIONS: AgentDefinition[];
-/** Phase → its agents, for grouped display and dispatcher fallbacks. */
-declare const AGENTS_BY_PHASE: Record<AgentPhase, AgentDefinition[]>;
-/**
- * Role → definition. Built once at module load. Throws on a duplicate role so
- * a copy-paste collision fails loudly at startup instead of silently shadowing.
- */
-declare const AGENT_CATALOG: Record<string, AgentDefinition>;
-/** Role lookup helper. Returns undefined for unknown roles. */
-declare function getAgentDefinition(role: string): AgentDefinition | undefined;
-
-/**
- * Default auto-extend policy for subagent budgets.
- *
- * The budget's soft-limit path (`SubagentBudget` → `budget.threshold_reached`)
- * only negotiates an extension when SOMETHING listens on the EventBus. Under a
- * `Director`, that listener is the director's own auto-extend handler. On the
- * plain coordinator path (e.g. a bare `/spawn` with no director) nothing
- * listens, so the budget falls back to a hard stop and the subagent dies the
- * moment it crosses a soft limit.
- *
- * `attachAutoExtend` is the additive fix: wire it to a subagent's EventBus and
- * budget overruns are auto-granted headroom instead of killing the run. It is
- * heartbeat-aware for the timeout kind — wall-clock time always advances, so a
- * naive "extend timeout forever" would let a wedged agent run indefinitely.
- * Instead, a timeout extension is granted only when the agent has executed a
- * new tool call or started a new iteration since the last timeout extension.
- * No progress since last time ⇒ the agent is genuinely stuck ⇒ deny and let it
- * fail. The non-timeout kinds (iterations/tool_calls/tokens/cost) extend up to
- * a per-kind cap, then deny — those ceilings are the real runaway guard.
- */
-
-interface AutoExtendCeiling {
-    maxIterations?: number | undefined;
-    maxToolCalls?: number | undefined;
-    maxTokens?: number | undefined;
-    maxCostUsd?: number | undefined;
-    timeoutMs?: number | undefined;
-}
-interface AutoExtendPolicy {
-    /** Multiplier applied to the tripped limit when extending. Default 0.5 (+50%). */
-    factor?: number | undefined;
-    /**
-     * Max extensions per NON-timeout kind before denying. Timeout is governed by
-     * the heartbeat check, not this cap, so it can extend indefinitely while the
-     * agent makes progress. Default 8.
-     */
-    maxExtensionsPerKind?: number | undefined;
-    /** Absolute ceilings — an extension never pushes a limit past these. */
-    ceiling?: AutoExtendCeiling | undefined;
-}
-/**
- * Attach an auto-extend policy to a subagent's EventBus. Returns an unsubscribe
- * function that detaches all listeners — call it when the subagent task ends.
- */
-declare function attachAutoExtend(events: EventBus, policy?: AutoExtendPolicy): () => void;
-
-type FleetWorktreePolicy = NonNullable<FleetConfig['worktrees']>;
-type WorktreeIsolationDecision = 'off' | 'optional' | 'required';
-interface WorktreeTaskStateUpdate {
-    taskId: string;
-    subagentId: string;
-    handleId: string;
-    dir: string;
-    branch: string;
-    baseBranch: string;
-    status: 'allocated' | 'fallback' | 'committed' | 'merged' | 'kept' | 'released' | 'conflict' | 'failed';
-    commitSha?: string | undefined;
-    conflictFiles?: string[] | undefined;
-    error?: string | undefined;
-}
-interface WorktreeTaskRunnerOptions {
-    runner: SubagentRunner;
-    worktrees?: WorktreeManager | undefined;
-    policy?: FleetWorktreePolicy | undefined;
-    conflictResolver?: ((info: {
-        task: TaskSpec;
-        config: SubagentConfig;
-        conflictFiles: string[];
-        cwd: string;
-    }) => Promise<boolean>) | undefined;
-    onUpdate?: ((update: WorktreeTaskStateUpdate) => void) | undefined;
-}
-declare class WorktreeIntegrationError extends Error {
-    readonly taskId: string;
-    readonly subagentId: string;
-    readonly branch?: string | undefined;
-    readonly conflictFiles?: string[] | undefined;
-    constructor(message: string, opts: {
-        taskId: string;
-        subagentId: string;
-        branch?: string | undefined;
-        conflictFiles?: string[] | undefined;
-    });
-}
-declare function subagentNeedsWorktree(config: SubagentConfig): boolean;
-declare function resolveSubagentWorktreeDecision(config: SubagentConfig, policy?: FleetWorktreePolicy | undefined): WorktreeIsolationDecision;
-declare function wrapSubagentRunnerWithWorktrees(opts: WorktreeTaskRunnerOptions): SubagentRunner;
-
-/**
- * Interface for fleet-level lifecycle and policy. Covers:
- * - Spawn lifecycle hooks (canSpawn check, recordSpawn after-effects)
- * - Budget enforcement (fleet-wide cost cap, spawn count/depth caps)
- * - Fleet manifest assembly and writing
- * - Subagent metadata and usage tracking
- *
- * `FleetBus` is pure event fan-out and implements no policy.
- * `FleetManager` encapsulates all fleet-level policy decisions.
- * `Director` currently owns all of this — this interface lets us
- * extract it into a swappable component in Phase 5.
- */
-interface IFleetManager {
-    /** The FleetBus this manager publishes lifecycle events to. */
-    readonly fleetBus: FleetBus;
-    /**
-     * Snapshot of fleet-wide token usage and cost rollup.
-     * Safe to call from a tool's execute() body.
-     */
-    snapshot(): FleetUsage;
-    /**
-     * Per-subagent metadata captured at spawn time (provider/model/name).
-     * Returns undefined if the subagent is not known to this manager.
-     */
-    getSubagentMeta(id: string): {
-        provider?: string | undefined;
-        model?: string | undefined;
-        name?: string | undefined;
-    } | undefined;
-    /**
-     * Called before a spawn is recorded. Returns a reason string if the
-     * spawn should be rejected (budget cap, depth limit, cost cap, context
-     * overload, etc.), or null to proceed. Director.spawn() calls this
-     * internally.
-     */
-    canSpawn(config: SubagentConfig): {
-        kind: 'max_spawns' | 'max_spawn_depth' | 'max_cost_usd' | 'max_tokens' | 'max_context_load';
-        limit: number;
-        observed: number;
-    } | null;
-    /** Current fleet-wide token/cost ceiling and remaining headroom. */
-    budgetSnapshot?: (() => {
-        maxSpawns: number;
-        usedSpawns: number;
-        remainingSpawns: number;
-        maxTokens: number;
-        usedTokens: number;
-        remainingTokens: number;
-        maxCostUsd: number;
-        usedCostUsd: number;
-        remainingCostUsd: number;
-    }) | undefined;
-    /**
-     * Update the leader agent's current context pressure (tokens used in the
-     * full API request: messages + systemPrompt + toolDefs). The fleet manager
-     * checks this before allowing a new spawn to prevent the leader from
-     * overflowing its context window while orchestrating subagents.
-     */
-    setLeaderContextPressure(tokens: number): void;
-    /**
-     * Assign a memorable nickname (e.g. "Einstein (Bug Hunter)") and mark it
-     * as used so it is never reused. The nickname is written back to `config.name`
-     * so the coordinator and manifest both see the human-readable name.
-     *
-     * NOTE: This only assigns the nickname. The caller MUST call `recordSpawn`
-     * after `coordinator.spawn()` returns with the real subagentId.
-     *
-     * Returns the assigned nickname string.
-     */
-    assignNicknameAndRecord(config: SubagentConfig): string;
-    /**
-     * Readonly view of already-assigned nickname keys. Used by `Director.spawn()`
-     * to avoid assigning the same nickname twice across the fleet.
-     */
-    readonly usedNicknames: ReadonlySet<string>;
-    /**
-     * Called after a spawn succeeds. Records metadata for the usage
-     * aggregator and manifest.
-     *
-     * @param priceLookup Per-token rate lookup for cost calculation.
-     *   When omitted the cost column in usage snapshots stays at 0.
-     */
-    recordSpawn(subagentId: string, config: SubagentConfig, priceLookup?: Record<string, number>): void;
-    /**
-     * Write the fleet manifest to disk. Returns the path written
-     * or null when no manifest path is configured.
-     */
-    writeManifest(): Promise<string | null>;
-    /**
-     * Bypass the debounce timer and write the manifest immediately.
-     * Clears any pending debounce timer before writing.
-     */
-    flushManifest(): Promise<void>;
-    /**
-     * Aggregate fleet-wide status: pending tasks with descriptions and
-     * live subagent snapshot from the coordinator. Used by
-     * `MultiAgentHost.status()` to eliminate host-side state duplication.
-     */
-    getFleetStatus(): {
-        pending: {
-            taskId: string;
-            description: string;
-            subagentId: string;
-        }[];
-        live: {
-            subagentId: string;
-            status: string;
-            task?: string | undefined;
-        }[];
-    };
-    /**
-     * Register a pending task with its description. Called by
-     * `MultiAgentHost.spawn()` after `_spawnAndAssign()` returns so
-     * the description is available in `status()` without host-side storage.
-     */
-    addPendingTask(taskId: string, subagentId: string, description: string): void;
-    /** Record the latest git-worktree lifecycle state for a task. */
-    recordTaskWorktree(update: WorktreeTaskStateUpdate): void;
-    /**
-     * Remove a pending task. Called when the task completes so the
-     * pending list stays accurate.
-     */
-    removePendingTask(taskId: string): void;
-    /**
-     * Wire the coordinator so `getFleetStats()` can delegate to it.
-     * Called by `Director` after constructing the coordinator so
-     * FleetManager's stats reflect live subagent data.
-     */
-    setCoordinator(coordinator: {
-        getStats(): {
-            total: number;
-            running: number;
-            idle: number;
-            stopped: number;
-            inFlight: number;
-            pending: number;
-            completed: number;
-        };
-    }): void;
-    /**
-     * Coordinator stats snapshot for the TUI and monitoring tools.
-     * Returns actionable counts (total/running/idle/stopped/inFlight/
-     * pending/completed) plus per-subagent status details.
-     * Delegates to the coordinator when available; returns zeros
-     * if the coordinator has not yet been set.
-     */
-    getFleetStats(): {
-        total: number;
-        running: number;
-        idle: number;
-        stopped: number;
-        inFlight: number;
-        pending: number;
-        completed: number;
-        subagentStatuses: {
-            subagentId: string;
-            taskId: string;
-            status: string;
-            assigned: boolean;
-        }[];
-    };
-    /**
-     * Called when a subagent is removed so the fleet manager can clean up
-     * associated state (nickname slots, pending tasks, etc.).
-     */
-    removeSubagent(subagentId: string): void;
-    /**
-     * Release all resources held by the fleet manager.
-     * Clears any pending manifest debounce timer and disposes the usage aggregator.
-     * Call this when the fleet manager is no longer needed (e.g. process shutdown).
-     */
-    dispose(): void;
-}
-
-/** Options for constructing a FleetManager. */
-interface FleetManagerOptions {
-    manifestPath?: string | undefined;
-    sessionsRoot?: string | undefined;
-    directorRunId?: string | undefined;
-    maxSpawns?: number | undefined;
-    maxSpawnDepth?: number | undefined;
-    spawnDepth?: number | undefined;
-    stateCheckpointPath?: string | undefined;
-    sessionWriter?: SessionWriter | undefined;
-    manifestDebounceMs?: number | undefined;
-    checkpointDebounceMs?: number | undefined;
-    directorBudget?: {
-        maxCostUsd?: number | undefined;
-        maxTokens?: number | undefined;
-    } | undefined;
-    /**
-     * Maximum context load (as a fraction of maxContext) the leader agent
-     * is allowed to reach before a new spawn is rejected. Default: 0.85.
-     * When the leader's context pressure exceeds this threshold, spawning
-     * a new subagent is refused — the leader must compact first.
-     * Set to 1.0 to disable this check.
-     */
-    maxLeaderContextLoad?: number | undefined;
-    /**
-     * Provider's max context window in tokens. Used with `maxLeaderContextLoad`
-     * to compute the absolute token threshold. Default: 128_000.
-     *
-     * A function may be supplied when the leader can switch models at runtime;
-     * canSpawn() reads it lazily so the spawn threshold follows the active model.
-     */
-    maxContext?: number | (() => number | undefined) | undefined;
-}
-/**
- * Fleet-level policy container extracted from `Director`. Owns:
- * - FleetBus + FleetUsageAggregator
- * - Spawn caps and counters
- * - Manifest entries and debounced writing
- * - State checkpointing
- *
- * This lets the `Director` focus on orchestration (spawn/assign/await/ask)
- * while fleet-level decisions live in one place. The class implements
- * `IFleetManager` so it remains swappable in future.
- *
- * @example
- * ```typescript
- * const fm = new FleetManager({ manifestPath: '/tmp/fleet.json' });
- * const err = fm.canSpawn({ name: 'worker' });
- * if (!err) fm.recordSpawn('sub-1', { name: 'worker' });
- * await fm.writeManifest();
- * ```
- */
-declare class FleetManager implements IFleetManager {
-    /** The fleet-wide event bus. */
-    readonly fleet: FleetBus;
-    /** Usage rollup across all subagents. */
-    readonly usage: FleetUsageAggregator;
-    private readonly manifestPath?;
-    private readonly directorRunId;
-    /** Spawn cap (lifetime total). Infinity means unlimited. */
-    readonly maxSpawns: number;
-    /** Nesting cap. */
-    readonly maxSpawnDepth: number;
-    /** This director's depth in a director chain. Root = 0. */
-    readonly spawnDepth: number;
-    /** Live spawn counter. */
-    private spawnCount;
-    private readonly stateCheckpoint;
-    private readonly sessionWriter;
-    private manifestTimer;
-    private manifestWriteChain;
-    private disposed;
-    private readonly manifestDebounceMs;
-    /** Fleet-wide cost cap. Infinity = no cap. Distinct from SubagentBudget limits,
-     *  which track per-subagent spend — this field caps the entire fleet total. */
-    private readonly maxFleetCostUsd;
-    /** Fleet-wide input+output token ceiling. Infinity = no cap. */
-    private readonly maxFleetTokens;
-    private readonly manifestEntries;
-    /** Pending tasks with their descriptions — populated by `addPendingTask`
-     *  and cleared by `removePendingTask`. Replaces the host-side `pending`
-     *  Map so task descriptions live in one place (FleetManager). */
-    private readonly pendingTasks;
-    private readonly subagentMeta;
-    private readonly priceLookups;
-    /** Tracks which nickname keys are already assigned — prevents collisions. */
-    private readonly _usedNicknames;
-    /** The coordinator (wired via setCoordinator by Director after construction). */
-    private coordinator;
-    /** Leader agent's current context pressure (full request tokens). */
-    private leaderContextPressure;
-    /** Maximum context load fraction before spawn is refused. */
-    private readonly maxLeaderContextLoad;
-    /** Provider's max context window in tokens, or a live resolver for runtime model switches. */
-    private readonly maxContext;
-    constructor(opts?: FleetManagerOptions);
-    get fleetBus(): FleetBus;
-    /**
-     * Wire the coordinator after Director construction. The coordinator
-     * is not available when FleetManager is constructed standalone.
-     * Once set, `getFleetStats()` delegates to `coordinator.getStats()`.
-     */
-    setCoordinator(coordinator: DefaultMultiAgentCoordinator): void;
-    snapshot(): FleetUsage;
-    getSubagentMeta(id: string): {
-        provider?: string | undefined;
-        model?: string | undefined;
-        name?: string | undefined;
-    } | undefined;
-    /**
-     * Returns null if the spawn is allowed, or an object describing
-     * which cap was exceeded. Does NOT throw — the caller decides
-     * how to surface the rejection.
-     */
-    canSpawn(_config: SubagentConfig): {
-        kind: 'max_spawns' | 'max_spawn_depth' | 'max_cost_usd' | 'max_tokens' | 'max_context_load';
-        limit: number;
-        observed: number;
-    } | null;
-    budgetSnapshot(): {
-        maxSpawns: number;
-        usedSpawns: number;
-        remainingSpawns: number;
-        maxTokens: number;
-        usedTokens: number;
-        remainingTokens: number;
-        maxCostUsd: number;
-        usedCostUsd: number;
-        remainingCostUsd: number;
-    };
-    setLeaderContextPressure(tokens: number): void;
-    private resolveMaxContext;
-    /**
-     * Assign a memorable nickname (e.g. "Einstein (Bug Hunter)") to the config,
-     * record it so the same name is never reused, then record the spawn.
-     *
-     * Call this INSTEAD of `recordSpawn` when you want automatic nicknames.
-     * The nickname is written back to `config.name` BEFORE the coordinator
-     * sees the config, so the manifest, logs, and fleet UI all show it.
-     *
-     * NOTE: This method ONLY assigns the nickname and marks it used.
-     * The caller MUST call `recordSpawn(subagentId, config, priceLookup)` AFTER
-     * `coordinator.spawn()` returns with the real subagentId. This is because
-     * the subagentId is not known until after the coordinator creates the subagent.
-     */
-    assignNicknameAndRecord(config: SubagentConfig): string;
-    /**
-     * Returns the set of already-assigned nickname keys — useful for debugging
-     * and testing.
-     */
-    get usedNicknames(): ReadonlySet<string>;
-    /**
-     * Records a spawn: increments counter, stores metadata, updates state checkpoint,
-     * and schedules a debounced manifest write. Call AFTER the coordinator
-     * has successfully spawned the subagent.
-     *
-     * @param subagentId The subagent's id (from coordinator.spawn result)
-     * @param config The SubagentConfig that was used
-     * @param priceLookup Optional per-subagent pricing data
-     */
-    recordSpawn(subagentId: string, config: SubagentConfig, priceLookup?: {
-        input?: number | undefined;
-        output?: number | undefined;
-        cacheRead?: number | undefined;
-        cacheWrite?: number | undefined;
-    }): void;
-    writeManifest(): Promise<string | null>;
-    private writeManifestNow;
-    /**
-     * Attach task ids to an already-spawned subagent. Called by
-     * `Director.assign()` after the coordinator assigns a task.
-     */
-    addTaskToSubagent(subagentId: string, taskId: string): void;
-    recordTaskWorktree(update: WorktreeTaskStateUpdate): void;
-    /**
-     * Debounced manifest write. Call after any state mutation
-     * (spawn, assign, complete) so a burst collapses into one write.
-     * When `manifestDebounceMs` is 0, writes are synchronous (no debounce).
-     */
-    scheduleManifest(): void;
-    /**
-     * Bypass the debounce timer and write the manifest immediately.
-     * Clears any pending debounce timer before writing.
-     */
-    flushManifest(): Promise<void>;
-    private clearManifestTimer;
-    /** Best-effort session event writer. Swallows failures. */
-    private appendSessionEvent;
-    addPendingTask(taskId: string, subagentId: string, description: string): void;
-    removePendingTask(taskId: string): void;
-    getFleetStats(): {
-        total: number;
-        running: number;
-        idle: number;
-        stopped: number;
-        inFlight: number;
-        pending: number;
-        completed: number;
-        subagentStatuses: {
-            subagentId: string;
-            taskId: string;
-            status: string;
-            assigned: boolean;
-        }[];
-    };
-    getFleetStatus(): {
-        pending: {
-            taskId: string;
-            description: string;
-            subagentId: string;
-        }[];
-        live: {
-            subagentId: string;
-            status: string;
-            task?: string | undefined;
-        }[];
-    };
-    /**
-     * Clean up all fleet-manager state associated with a removed subagent:
-     * - Frees the nickname slot so the same name can be reused
-     * - Removes any pending tasks for this subagent
-     */
-    removeSubagent(subagentId: string): void;
-    /** Release all resources: clear the manifest debounce timer and dispose the usage aggregator. */
-    dispose(): void;
-}
-
-/**
- * Interface for a fleet coordinator. Implemented by both `Director`
- * (full LLM-driven orchestration with fleet policy) and
- * `DefaultMultiAgentCoordinator` (direct API-driven, no fleet policy).
- *
- * External callers — CLI slash commands, tests, the delegate tool —
- * use this to stay agnostic to the orchestration mode.
- *
- * The interface captures the **orchestration contract**: spawn, assign,
- * terminate, await, and query. Fleet-level policy (cost caps, manifest
- * writing, checkpointing) lives behind this surface and is optional
- * from the caller's perspective.
- *
- * @example
- * ```typescript
- * let coordinator: ICoordinator = isDirectorMode
- *   ? new Director({ config, ... })
- *   : new DefaultMultiAgentCoordinator(config);
- * const id = await coordinator.spawn({ name: 'worker', role: 'researcher' });
- * await coordinator.assign({ id: 't-1', description: 'research X', subagentId: id });
- * const results = await coordinator.awaitTasks(['t-1']);
- * ```
- */
-interface ICoordinator {
-    /** Stable identifier for this coordinator instance. */
-    readonly coordinatorId: string;
-    /**
-     * Spawn a new subagent and return its id. In director mode this
-     * enforces fleet-wide spawn caps and cost limits; in raw coordinator
-     * mode it is a direct pass-through.
-     */
-    spawn(config: SubagentConfig): Promise<string>;
-    /**
-     * Assign a task to a subagent (or to the fleet for auto-routing).
-     * Returns the assigned task id.
-     */
-    assign(task: {
-        id: string;
-        description: string;
-        subagentId?: string | undefined;
-    }): Promise<string>;
-    /**
-     * Synchronously ask a subagent something via the in-memory bridge.
-     * The subagent must have been spawned and must handle `bridge.subscribe()`
-     * in its task loop. Returns the reply payload or throws on timeout.
-     *
-     * Only available in director mode — raw coordinator has no bridge.
-     */
-    ask<T = unknown>(subagentId: string, payload: unknown, timeoutMs?: number): Promise<T> | undefined;
-    /**
-     * 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[]>;
-    /**
-     * Gracefully stop a single subagent. The subagent finishes its current
-     * in-flight work and exits cleanly — it does not hard-kill.
-     */
-    terminate(subagentId: string): Promise<void>;
-    /**
-     * Stop all subagents. In-flight tasks are allowed to complete;
-     * no new tasks are dispatched.
-     */
-    terminateAll(): Promise<void>;
-    /**
-     * Stop a subagent and remove it from the coordinator. Releases all
-     * associated resources (AbortController, budget state). The subagent
-     * entry is deleted so the id can be reused in a future spawn.
-     */
-    remove(subagentId: string): Promise<void>;
-    /**
-     * Live coordinator status — subagent list, pending task count,
-     * completed task count, iteration totals.
-     */
-    status(): CoordinatorStatus;
-    /**
-     * Snapshot of completed task results. In director mode this returns
-     * every `TaskResult` from the fleet; in raw coordinator mode this
-     * may return an empty array if the coordinator doesn't cache results.
-     */
-    completedResults(): TaskResult[];
-    /**
-     * Subscribe to coordinator lifecycle events. Currently supports
-     * `task.completed` — the payload carries the task spec and result.
-     *
-     * Returns a disposer function; call it to unsubscribe.
-     */
-    on(event: 'task.completed', handler: (payload: {
-        task: TaskSpec;
-        result: TaskResult;
-    }) => void): () => void;
-}
-
-declare class LargeAnswerStore {
-    /**
-     * Responses above this size (in characters) are stored out-of-context.
-     * Below this, the full answer is returned inline (no overhead).
-     * Default: 2000 chars ≈ 400-600 tokens.
-     */
-    readonly sizeThreshold: number;
-    private readonly store;
-    constructor(sizeThreshold?: number);
-    /**
-     * Store a value, returning a summary + key for inline use.
-     * If the value is below sizeThreshold, returns it as-is (no store entry).
-     */
-    storeAnswer(value: unknown): {
-        key?: string | undefined;
-        summary: string;
-        inline: boolean;
-    };
-    /**
-     * Retrieve a previously stored answer by its key.
-     * Returns undefined if the key is unknown or the store was cleared.
-     */
-    retrieveAnswer(key: string): unknown | undefined;
-    /**
-     * Check if a key exists in the store.
-     */
-    hasAnswer(key: string): boolean;
-    /** Number of stored entries. */
-    get size(): number;
-    /** Total characters stored. */
-    get totalChars(): number;
-    /** Clear all stored entries. Call at the end of a director run. */
-    clear(): void;
-}
-
-/**
- * Director-specific error types. Extracted to keep the Director class
- * focused on orchestration logic.
- */
-declare class FleetSpawnBudgetError extends Error {
-    readonly kind: 'max_spawns' | 'max_spawn_depth';
-    readonly limit: number;
-    readonly observed: number;
-    constructor(kind: 'max_spawns' | 'max_spawn_depth', limit: number, observed: number, message?: string | undefined);
-}
-declare class FleetCostCapError extends Error {
-    readonly kind: 'max_cost_usd';
-    readonly limit: number;
-    readonly observed: number;
-    constructor(limit: number, observed: number);
-}
-declare class FleetTokenCapError extends Error {
-    readonly kind: 'max_tokens';
-    readonly limit: number;
-    readonly observed: number;
-    constructor(limit: number, observed: number);
-}
-
-/**
- * Director — high-level orchestrator that owns a `MultiAgentCoordinator`,
- * a `FleetBus`, and a `FleetUsageAggregator`. Exposes a small imperative
- * API (`spawn`, `assign`, `awaitTasks`, `terminate`, `status`, `usage`)
- * that's easy to test, and a `tools()` factory that wraps the same API
- * as agent-callable `Tool`s so an LLM can drive the orchestration.
- *
- * This class is intentionally *not* an `Agent`. It's a coordinator +
- * observability surface. To make it LLM-driven, construct an Agent
- * with `director.tools()` registered. That keeps the construction
- * symmetric with how other agents are built and avoids smuggling a
- * heavy LLM dependency into core just for the director path.
- */
-/**
- * Payload handed to {@link DirectorOptions.taskResultNotifier} when a
- * fire-and-forget task completes (no `awaitTasks` waiter was pending).
- */
-interface TaskResultNotification {
-    taskId: string;
-    /** Task description (or task id when no description was recorded). */
-    title: string;
-    status: TaskResult['status'];
-    subagentId: string;
-    /** Human-readable subagent name from the fleet manifest, when known. */
-    subagentName?: string | undefined;
-    /** The subagent's textual result (stringified when structured). */
-    resultText?: string | undefined;
-    /** Flattened `kind: message` error string for non-success statuses. */
-    errorText?: string | undefined;
-    /** Bounded incomplete text recovered before a non-successful exit. */
-    partialText?: string | undefined;
-    /** Machine-readable result submitted through submit_result. */
-    report?: TaskResult['report'] | undefined;
-    iterations: number;
-    toolCalls: number;
-    durationMs: number;
-}
-interface DirectorOptions {
-    config: MultiAgentConfig;
-    runner?: SubagentRunner | undefined;
-    /** Optional Brain arbiter above the director for policy/decision escalation. */
-    brain?: BrainArbiter | undefined;
-    /**
-     * Called when a task completes with NO pending `awaitTasks` waiter —
-     * i.e. a fire-and-forget `assign_task`. Wire this to the project
-     * mailbox so the result reaches the leader's conversation automatically
-     * instead of waiting for a poll. Synchronous `delegate` calls attach a
-     * waiter up front, so they never double-report through this hook.
-     * Internal tasks (shadow passes) are excluded. Errors are swallowed.
-     */
-    taskResultNotifier?: ((n: TaskResultNotification) => void | Promise<void>) | undefined;
-    /** Optional logger for structured debug/error logging. Falls back to console if omitted. */
-    logger?: Logger | undefined;
-    /**
-     * When set, the director writes a `fleet.json` manifest to this path
-     * recording every spawned subagent (id, provider, model, role, task
-     * ids). Used by `wstack replay <runId>` to rehydrate a fleet. Pass an
-     * absolute file path — the directory must already exist (the
-     * director-session factory creates it when used together).
-     */
-    manifestPath?: string | undefined;
-    /**
-     * Optional roster used by `leaderSystemPrompt()` to render a roles
-     * summary into the leader's preamble. Same shape as the roster passed
-     * to `tools()` — typically the same value.
-     */
-    roster?: Record<string, SubagentConfig>;
-    /**
-     * Override the built-in fleet preamble (see `DEFAULT_DIRECTOR_PREAMBLE`).
-     * Pass an empty string to suppress the preamble entirely.
-     */
-    directorPreamble?: string | undefined;
-    /**
-     * Override the built-in subagent baseline (see
-     * `DEFAULT_SUBAGENT_BASELINE`). Pass an empty string to suppress.
-     */
-    subagentBaseline?: string | undefined;
-    /**
-     * Absolute path to a directory the fleet can use as a shared scratchpad
-     * (read + write by every subagent). When set, the director creates it on
-     * construction and `subagentSystemPrompt()` automatically injects a
-     * "Shared notes" block telling subagents where to drop their findings.
-     * This is the cheap fleet-coordination channel — agents don't need each
-     * other's transcripts, just each other's conclusions.
-     *
-     * Convention: under a fleet run rooted at `<sessionsRoot>/<runId>/`,
-     * pass `<sessionsRoot>/<runId>/shared/` here.
-     */
-    sharedScratchpadPath?: string | undefined;
-    /**
-     * Maximum number of spawns this director can perform across its
-     * lifetime. Default: unlimited. Acts as a hard fleet-wide cost cap —
-     * a runaway leader that keeps spawning workers gets cut off cleanly
-     * instead of burning provider tokens until the user kills the
-     * process. The N+1-th spawn call rejects with a `FleetSpawnBudgetError`.
-     */
-    maxSpawns?: number | undefined;
-    /**
-     * Maximum nesting depth for spawns. The director constructed by the
-     * user is at depth `spawnDepth` (default 0); any subagent that itself
-     * acts as a director would construct its own `Director` with
-     * `spawnDepth: parent.spawnDepth + 1`. When `spawnDepth >= maxSpawnDepth`,
-     * `spawn()` rejects. The process-wide hard ceiling is 2; configuration can
-     * narrow it but cannot widen it. Default: 2 (root director can spawn workers; a
-     * worker that becomes a sub-director cannot itself spawn further).
-     * This stops infinite recursive director chains from a hostile or
-     * confused prompt.
-     */
-    maxSpawnDepth?: number | undefined;
-    /**
-     * Current spawn-chain depth for this director instance. Defaults to 0.
-     * A nested director should pass `parent.spawnDepth + 1`. Together with
-     * `maxSpawnDepth` this bounds the chain.
-     */
-    spawnDepth?: number | undefined;
-    /**
-     * Absolute path to a director-state checkpoint file. When set, the
-     * director writes an incremental snapshot of pending/running/completed
-     * tasks + spawned subagents on every state mutation. Distinct from
-     * `manifestPath`: the manifest is a final record written on shutdown,
-     * the checkpoint is a live mirror useful for crash recovery and the
-     * `wstack resume` "you had N tasks in flight" banner.
-     */
-    stateCheckpointPath?: string | undefined;
-    /**
-     * Session writer the director should forward task lifecycle events to
-     * (`agent_spawned`, `task_created`, `task_completed`, `task_failed`).
-     * When omitted these events stay in-memory only — useful for tests but
-     * lossy in production. Production callers (the CLI) pass the same
-     * writer the host Agent uses so all events land in a single JSONL.
-     */
-    sessionWriter?: SessionWriter | undefined;
-    /**
-     * Session id for live fleet/coordinator events. Defaults to
-     * `sessionWriter.id` when a writer is available; accepts a getter so
-     * embedding surfaces can follow session swaps.
-     */
-    sessionId?: string | (() => string | undefined) | undefined;
-    /**
-     * Debounce window for periodic manifest writes triggered by spawn/
-     * assign/complete events. Default: 2000ms. Pass 0 to disable periodic
-     * writes (the manifest will then only be written on `shutdown()`).
-     */
-    manifestDebounceMs?: number | undefined;
-    /**
-     * Fleet-wide cost ceiling. When set, `spawn()` refuses any new subagent
-     * that would push the fleet's total cost above this limit. The cap
-     * is checked BEFORE the spawn is recorded — a refused spawn must not
-     * leak partial state into the manifest or fleet bus. Let in-flight
-     * tasks complete; refuse new spawns only. When omitted or Infinity,
-     * no cost cap applies.
-     *
-     * Distinct from SubagentBudget.maxCostUsd (per-subagent spend) — this
-     * field caps the *entire fleet* total.
-     */
-    directorBudget?: {
-        /**
-         * Maximum total USD the fleet may spend across all subagents.
-         * Default: Infinity (no cap).
-         */
-        maxCostUsd?: number | undefined;
-        /** Maximum cumulative input+output tokens across the fleet. */
-        maxTokens?: number | undefined;
-    } | undefined;
-    /**
-     * Maximum auto-extensions per subagent per budget kind before the
-     * director denies further extensions. A subagent hitting the same
-     * soft limit repeatedly (e.g. 3× budget.threshold_reached for
-     * tool_calls) is likely looping on a prompt/config issue, not
-     * making legitimate progress. Default: 5. Set to Infinity to
-     * disable the cap (use with caution — a misconfigured subagent
-     * could burn unlimited budget).
-     */
-    maxBudgetExtensions?: number | undefined;
-    /**
-     * Debounce window for state-checkpoint writes. Default: 250ms.
-     * Bursts of spawn/assign/complete events collapse into one disk
-     * hit. Higher values reduce write amplification on fast machines;
-     * lower values improve crash-recovery fidelity (less state lost
-     * on sudden process exit).
-     */
-    checkpointDebounceMs?: number | undefined;
-    /**
-     * Sessions root directory for per-subagent JSONL transcripts.
-     * When set, the director can read subagent transcripts directly for
-     * `fleet` tool (action: session) — no bridge round-trip needed. Path convention:
-     * `<sessionsRoot>/<directorRunId>/<subagentId>.jsonl`.
-     */
-    sessionsRoot?: string | undefined;
-    /**
-     * Director run id — namespaced under `sessionsRoot` to locate per-subagent
-     * JSONLs. Defaults to the director's own `id` when omitted.
-     */
-    directorRunId?: string | undefined;
-    /**
-     * Pre-built fleet manager. When provided the Director delegates all
-     * fleet-level policy (spawn budgets, manifest assembly, checkpointing)
-     * to this instance and takes ownership of the coordinator + bridge
-     * layer only. This enables unit-testing fleet policy in isolation
-     * and swapping implementations without changing the Director surface.
-     *
-     * When omitted the Director creates its own fleet infrastructure
-     * (same behavior as before this field was added).
-     */
-    fleetManager?: FleetManager | undefined;
-    /**
-     * Optional LLM classifier for the smart dispatcher. When set, the
-     * `spawn_subagent` tool can accept a free-form `description` field
-     * and the director will automatically route to the best-matching
-     * catalog agent using `dispatchAgent()`. When omitted, routing is
-     * pure heuristic (no provider call) — sufficient for most tasks.
-     *
-     * Build from a `complete(prompt) => string` function using
-     * `makeLLMClassifier(complete)` from the dispatcher module.
-     */
-    dispatchClassifier?: DispatchClassifier | undefined;
-    /**
-     * Maximum context load (as a fraction of maxContext) the leader agent
-     * is allowed to reach before a new spawn is rejected. Default: 0.85.
-     * When the leader's context pressure exceeds this threshold, spawning
-     * a new subagent is refused — the leader must compact first.
-     * Only used when no `fleetManager` is provided (inline mode).
-     * Set to 1.0 to disable this check.
-     */
-    maxLeaderContextLoad?: number | undefined;
-    /**
-     * Provider's max context window in tokens. Used with `maxLeaderContextLoad`
-     * to compute the absolute token threshold. Default: 128_000.
-     * Only used when no `fleetManager` is provided (inline mode).
-     *
-     * A function may be supplied when the leader can switch models at runtime;
-     * spawn() reads it lazily so the threshold follows the active model.
-     */
-    maxContext?: number | (() => number | undefined) | undefined;
-    /**
-     * Per-task model matrix (Config.modelMatrix). When set, a spawn whose
-     * config has no explicit `model` is resolved against this matrix by role
-     * (→ phase → `*`) before the subagent is built — so the spawned event,
-     * manifest, and the agent itself all run the matched model. Explicit
-     * per-spawn `model` overrides always win.
-     *
-     * Pass a **function** (not a snapshot) when the matrix can change at
-     * runtime (the CLI passes `() => configStore.get().modelMatrix`) so a
-     * mid-session `/setmodel` takes effect on the next spawn. A static record
-     * is also accepted for tests and one-shot runs.
-     */
-    modelMatrix?: ModelMatrixSource | undefined;
-    /**
-     * Optional git-worktree manager for Director fleet isolation. When supplied,
-     * task runners can execute side-effectful subagents in per-task worktrees and
-     * squash-merge successful branches back into the base checkout.
-     */
-    worktrees?: WorktreeManager | undefined;
-    /** Worktree policy. Defaults to `auto` when `worktrees` is provided. */
-    worktreePolicy?: FleetWorktreePolicy | undefined;
-    /**
-     * Optional guarded merge-conflict resolver invoked by WorktreeManager when a
-     * successful task branch cannot squash-merge cleanly.
-     */
-    worktreeConflictResolver?: ((info: {
-        task: TaskSpec;
-        config: SubagentConfig;
-        conflictFiles: string[];
-        cwd: string;
-    }) => Promise<boolean>) | undefined;
-}
-/** Either a static matrix or a live getter (re-read on every spawn). */
-type ModelMatrixSource = Record<string, ModelMatrixEntry> | (() => Record<string, ModelMatrixEntry> | undefined);
-
-declare class Director implements ICoordinator {
-    /** Alias for the ICoordinator contract. `id` is retained for backward compatibility. */
-    get coordinatorId(): string;
-    readonly id: string;
-    /**
-     * The fleet event bus. Backed by `fleetManager?.fleet` when a FleetManager
-     * is injected; otherwise own FleetBus instance (preserves existing behavior).
-     */
-    readonly fleet: FleetBus;
-    /**
-     * Usage rollup. Backed by `fleetManager?.usage` when a FleetManager is
-     * injected; otherwise own FleetUsageAggregator.
-     */
-    readonly usage: FleetUsageAggregator;
-    /**
-     * Update the leader agent's current context pressure (full request tokens:
-     * messages + systemPrompt + toolDefs). The director checks this before every
-     * spawn — if the pressure exceeds `maxLeaderContextLoad * maxContext`,
-     * spawning is refused with a `FleetContextOverflowError`.
-     *
-     * Call this after each leader agent iteration to keep the pressure current.
-     * The compactor's `CompactReport.fullRequestTokensAfter` is a natural source.
-     */
-    setLeaderContextPressure(tokens: number): void;
-    /**
-     * Read the leader agent's current context pressure.
-     */
-    getLeaderContextPressure(): number;
-    /**
-     * Remaining USD budget for the entire fleet (when a cap is configured).
-     * Returns `undefined` when no cap was set (Infinity).
-     */
-    getRemainingBudgetUsd(): number | undefined;
-    private resolveMaxContext;
-    private currentSessionId;
-    /** Optional Brain arbiter for director-level policy decisions. */
-    private readonly brain?;
-    /**
-     * Optional fleet-level policy container. When provided the Director
-     * delegates spawn budgeting, manifest entries, and checkpointing to it
-     * instead of managing those internally. All other behavior is unchanged.
-     */
-    readonly fleetManager: FleetManager | undefined;
-    /**
-     * Director-side bridge endpoint. Subagents are wired to the same
-     * in-memory transport so the director can `ask()` them synchronously
-     * and they can `send()` progress back. Exposed so external code (e.g.
-     * the TUI) can subscribe to inbound messages.
-     */
-    readonly bridge: InMemoryAgentBridge;
-    private readonly transport;
-    private readonly coordinator;
-    /** Resolves with the matching `TaskResult` the first time the
-     *  coordinator emits `task.completed` for a given task id. Each entry
-     *  is created lazily on first poll/await and cleared once consumed. */
-    private readonly taskWaiters;
-    /** First-completion waiters registered by `awaitTasksAny`. Kept separate
-     *  from `taskWaiters` on purpose: a `taskWaiters` entry marks a result as
-     *  "will be delivered in-band" and suppresses the fire-and-forget
-     *  report-back — but an any-await only consumes ONE of its ids, so the
-     *  losers must stay eligible for the mailbox notifier. Entries carry an
-     *  optional timeout timer so `shutdown()` can clear them. */
-    private readonly anyWaiters;
-    /** Cache of completed results in case the consumer asks AFTER the
-     *  coordinator already fired the event — `awaitTasks(['t-1'])` after
-     *  t-1 finished should resolve immediately, not hang. */
-    private readonly completed;
-    /** Prevents the completed Map from growing unbounded in long-running directors. */
-    private static readonly MAX_COMPLETED;
-    /** Per-subagent provider/model metadata, captured at spawn time so the
-     *  FleetUsageAggregator's metaLookup can surface readable rows. */
-    private readonly subagentMeta;
-    private readonly priceLookups;
-    /** Bridge endpoints we created per subagent (so we can `stop()` them
-     *  on shutdown and free transport subscriptions). */
-    private readonly subagentBridges;
-    /** Tracks per-spawn config + assigned task ids for manifest writing. */
-    private readonly manifestEntries;
-    /** Tracks assigned nicknames so the same name is never reused in one fleet. */
-    private readonly _usedNicknames;
-    private readonly manifestPath?;
-    private readonly roster?;
-    private readonly directorPreamble;
-    private readonly subagentBaseline;
-    /** See {@link DirectorOptions.taskResultNotifier}. */
-    private readonly taskResultNotifier?;
-    /** Absolute path to the fleet's shared scratchpad directory, or null
-     *  when none was configured. Exposed as a readonly getter for callers
-     *  that need to surface the path to the user (e.g. the CLI logging
-     *  the location after `--director` boots). */
-    readonly sharedScratchpadPath: string | null;
-    /** Spawn cap (lifetime total). Infinity means unlimited. */
-    readonly maxSpawns: number;
-    /** Nesting cap. The N-th director in a chain has `spawnDepth = N-1`. */
-    readonly maxSpawnDepth: number;
-    /** This director's position in a director chain. Root director = 0. */
-    readonly spawnDepth: number;
-    /** Live spawn counter for `maxSpawns` enforcement. */
-    private spawnCount;
-    /** Optional checkpoint mirror — writes the live task graph + roster to disk. */
-    private readonly stateCheckpoint;
-    /** Optional session writer for emitting task_* / agent_* lifecycle events. */
-    private readonly sessionWriter;
-    private readonly sessionIdSource;
-    /** Debounce timer for periodic manifest writes. */
-    private manifestTimer;
-    private manifestWriteChain;
-    private readonly manifestDebounceMs;
-    /** Fleet-wide cost cap (entire fleet total, distinct from SubagentBudget limits). Infinity means no cap. */
-    private readonly maxFleetCostUsd;
-    /** Fleet-wide input+output token cap. Infinity means no cap. */
-    private readonly maxFleetTokens;
-    /** Max auto-extensions per subagent per budget kind before denying. */
-    private readonly maxBudgetExtensions;
-    /** Sessions root for direct subagent JSONL reads (fleet tool, action: session). */
-    private readonly sessionsRoot?;
-    /** Director run id for JSONL path resolution. */
-    private readonly directorRunId;
-    /** Optional logger for structured logging. Falls back to noop when omitted. */
-    private readonly logger;
-    /** Resolves task descriptions back from `assign()` so completion events
-     *  can also carry a human-readable title. */
-    private readonly taskDescriptions;
-    /** Latest worktree state per task id (allocated/committed/merged/conflict/etc.). */
-    private readonly taskWorktrees;
-    /** Snapshot of which subagent owns each task — drives state-checkpoint
-     *  status updates without re-walking the manifest. */
-    private readonly taskOwners;
-    /** Infrastructure-owned task ids that should not appear in user-visible
-     *  manifest/session/checkpoint/rollup state. */
-    private readonly internalTaskIds;
-    /** Cumulative auto-extension grants per subagent (all budget kinds). Lets
-     *  /fleet render "⚡ extended ×N" without replaying the event stream. */
-    private readonly extendTotals;
-    /**
-     * Handle to the coordinator-side `task.completed` listener so we can
-     * unsubscribe in `shutdown()`. Without this, repeated Director
-     * construction (e.g. tests, hot reloads) accumulates listeners on a
-     * cached coordinator and slowly drifts the EventEmitter past its
-     * default cap.
-     */
-    private taskCompletedListener;
-    /**
-     * Unsub handles for the two `FleetBus.filter()` calls installed in the
-     * constructor for timeout-heartbeat tracking. Without capturing these
-     * and calling them in `shutdown()`, repeated Director construction
-     * (tests, hot reloads, `--director` restarts) accumulates 2 dangling
-     * listeners per Director on the FleetBus, slowly drifting the
-     * EventEmitter past its default cap. Mirrors the rationale on
-     * `taskCompletedListener` above.
-     */
-    private toolExecFilter;
-    private budgetFilter;
-    /** Optional LLM classifier for smart dispatch. Passed from options. */
-    readonly dispatchClassifier?: DispatchClassifier | undefined;
-    /** Leader agent's current context pressure (full request tokens). */
-    private leaderContextPressure;
-    /** Maximum context load fraction before spawn is refused. */
-    private readonly maxLeaderContextLoad;
-    /** Provider's max context window in tokens, or a live resolver for runtime model switches. */
-    private readonly maxContext;
-    /** Per-task model matrix (static record or live getter); resolved
-     *  per-spawn when no explicit model is set. */
-    private readonly modelMatrix?;
-    /**
-     * When set by `workComplete()`, the director stops dispatching new tasks
-     * and terminates all running subagents. Used when the director's LLM decides
-     * the goal is satisfied and no further spawns are needed — prevents the
-     * coordinator from keeping workers alive for tasks that will never arrive.
-     */
-    private workCompleteFlag;
-    /** Pending /btw notes stashed by the leader agent (see setLeaderBtwNote). */
-    private _leaderBtwNotes;
-    /** Active collab sessions tracked by sessionId (see spawnCollab).
-     *  The tuple holds the session and its Director-registered listener unsubs.
-     *  Calling the unsubs on cancel/premature-cleanup prevents listener accumulation
-     *  on CollabSession (EventEmitter) across many spawnCollab() calls. */
-    private readonly _activeCollabSessions;
-    /** Prevents large `ask_subagent` answers from bloating the leader's context window. */
-    readonly largeAnswerStore: LargeAnswerStore;
-    constructor(opts: DirectorOptions);
-    /**
-     * Record a granted budget extension and broadcast it on the FleetBus so
-     * the host can re-emit `subagent.budget_extended` for live UI badges.
-     * Called from both the timeout heartbeat path and the per-kind grant path.
-     */
-    private recordExtension;
-    /** Cumulative auto-extension count for one subagent (0 when never extended). */
-    extensionsFor(subagentId: string): number;
-    /**
-     * Signal that the director's work is done. Once called:
-     * - `spawn()` throws `FleetSpawnBudgetError('max_spawns', …)` — no new
-     *   subagents can be created
-     * - Running subagents are NOT forcibly stopped — they finish naturally,
-     *   but no new tasks are dispatched to them
-     *
-     * This lets the director LLM say "I'm satisfied with the results, stop
-     * spawning and wind down" — without killing in-flight work mid-execution.
-     * Call `terminateAll()` separately if you need immediate teardown.
-     *
-     * Idempotent — calling twice is a no-op.
-     */
-    workComplete(): void;
-    /** Returns true if `workComplete()` has been called on this director. */
-    isWorkComplete(): boolean;
-    /**
-     * Stashes a /btw note on the leader agent's context. The leader's agent loop
-     * calls `consumeBtwNotes()` at each iteration boundary and folds pending notes
-     * into the conversation as a visible block — no abort, no restart, just a
-     * "by the way" nudge the model picks up on its next turn.
-     *
-     * This is the entry point for the host (CLI, TUI) to inject /btw notes
-     * programmatically without going through the slash-command path.
-     */
-    setLeaderBtwNote(note: string): number;
-    /**
-     * Read and clear all pending /btw notes the leader has stashed.
-     * Returns them in FIFO order (empty array when none).
-     *
-     * Called by CollabSession when a budget threshold event fires so the
-     * Director can inspect accumulated /btw notes before deciding whether
-     * to cancel the collab session or let it continue.
-     */
-    getLeaderBtwNotes(): string[];
-    /**
-     * Peek at pending /btw notes without consuming them.
-     * Useful for UI to show "N pending notes" without clearing them.
-     */
-    peekLeaderBtwNotes(): string[];
-    /**
-     * Drain (read + clear) all /btw notes in one call.
-     * Alias for getLeaderBtwNotes() — kept for symmetry with consumeBtwNotes()
-     * in the agent's btw.ts. The Director calls this at the point where it
-     * makes a cancellation decision, not on every budget event.
-     */
-    drainLeaderBtwNotes(): string[];
-    /**
-     * Cancel an active collab session by its id.
-     * Emits `director.cancel_collab` on the FleetBus so the session's agents
-     * finish early with a 'cancelled' disposition.
-     *
-     * Returns silently if the session id is not tracked or already settled.
-     * The CollabDebugReport will reflect 'cancelled' disposition when awaited.
-     */
-    cancelCollabSession(sessionId: string, reason?: string): void;
-    /**
-     * Subscribe a callback to be notified whenever a collab session raises
-     * an alert (warning level). The callback receives the full DirectorAlert
-     * payload so the host (CLI, TUI) can display it to the user.
-     * Returns an unsubscribe function.
-     */
-    onCollabAlert(handler: (alert: DirectorAlert) => void): () => void;
-    /**
-     * Returns all active (not yet settled) collab session ids.
-     * Useful for the TUI to render a "N active sessions" badge and for
-     * the host to know what can be cancelled.
-     */
-    activeCollabSessions(): string[];
-    /** Best-effort session-writer append. Swallows failures — the director
-     *  must not break a fleet run because the session JSONL handle closed. */
-    private appendSessionEvent;
-    /** Debounced manifest writer. A burst of spawn/assign/complete events
-     *  collapses into one write. Set `manifestDebounceMs` to 0 to write
-     *  synchronously (no debounce); set to negative to disable entirely. */
-    private scheduleManifest;
-    private clearManifestTimer;
-    private recordWorktreeTaskUpdate;
-    /**
-     * Spawn a subagent. Identical to the coordinator's `spawn()` but
-     * captures provider/model metadata for the usage aggregator and
-     * lets the FleetBus attach to the runner's EventBus when the task
-     * actually runs (see `attachSubagentBus`).
-     *
-     * Caller-supplied `priceLookup` is optional but recommended — without
-     * it the `cost` column in `usage.snapshot()` stays at 0.
-     */
-    spawn(callerConfig: SubagentConfig, priceLookup?: {
-        input?: number | undefined;
-        output?: number | undefined;
-        cacheRead?: number | undefined;
-        cacheWrite?: number | undefined;
-    }): Promise<string>;
-    /**
-     * Synchronously ask a subagent something via the bridge. Sends a
-     * `task` message addressed to the subagent and awaits a matching
-     * reply (matched by message id). Subagent runners that handle these
-     * requests subscribe to `ctx.bridge` and reply with a message whose
-     * `id` equals the incoming request's id (see `InMemoryAgentBridge`'s
-     * `request<T>` implementation).
-     *
-     * Returns the response payload directly (the bridge wrapper is
-     * unwrapped for ergonomics). Times out after `timeoutMs` (default
-     * matches the bridge's own default of 30s) — surface those rejections
-     * to the caller as actionable errors instead of letting tools hang.
-     */
-    ask<T = unknown>(subagentId: string, payload: unknown, timeoutMs?: number): Promise<T>;
-    /**
-     * Read completed task results and format them as a structured text
-     * block the director's LLM can paste into its own context. The
-     * Director keeps every completed `TaskResult` in `completed` so this
-     * is a pure read — no bridge round-trip, cheap to call.
-     *
-     * The returned string is intentionally markdown-flavored: headers per
-     * subagent, a one-line meta row (iter / tools / ms), and the task's
-     * result text. Pass `style: 'json'` for a programmatic shape instead
-     * (useful when the director model is doing structured-output work).
-     */
-    rollUp(taskIds: string[], style?: 'markdown' | 'json'): string;
-    /**
-     * Write the fleet manifest to `manifestPath`. Returns the path written
-     * or null when no path was configured. Captures every spawn + its
-     * assigned tasks — paired with per-subagent JSONLs, this is enough to
-     * replay an entire director run.
-     */
-    writeManifest(): Promise<string | null>;
-    private writeManifestNow;
-    /**
-     * Tear down the director: stop every subagent, close every bridge
-     * endpoint, and (when configured) write the final manifest. Idempotent
-     * — calling shutdown twice is a no-op on the second invocation.
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Funnel for shutdown-phase errors. We can't throw — `shutdown()` is
-     * called from process-exit paths where an uncaught throw would lose
-     * the manifest write that comes after. But we MUST NOT silently
-     * swallow either — a persistent bridge-close failure would otherwise
-     * mask a real bug. `process.emitWarning` is the right tier:
-     * surfaces on stderr by default, lets the host plug a warning
-     * listener for structured collection, and never affects exit code.
-     */
-    private logShutdownError;
-    /**
-     * Hand a task to the coordinator. Returns the assigned task id so
-     * callers can wait on it via `awaitTasks([id])`. The coordinator's
-     * concurrency limit applies — the task may queue before running.
-     */
-    assign(task: TaskSpec): Promise<string>;
-    /**
-     * Assign infrastructure-owned work directly to the coordinator without
-     * manifest/session/checkpoint bookkeeping. The task still uses the normal
-     * subagent runner, budget, and completion events, but it is excluded from
-     * rollups and persisted fleet task history.
-     */
-    assignInternal(task: TaskSpec): Promise<string>;
-    /**
-     * Block until every task id resolves. Returns results in the same
-     * order as the input. If any task hasn't completed by the time this
-     * is called, the promise hangs until it does — pair with a timeout
-     * at the caller if that's a concern. Resolves immediately for ids
-     * whose results were already cached.
-     */
-    awaitTasks(taskIds: string[]): Promise<TaskResult[]>;
-    /**
-     * Wait until AT LEAST ONE of the named tasks completes, then return every
-     * requested result already cached plus the still-pending ids. This is the
-     * leader's "handle whichever finishes next" primitive — unlike
-     * `awaitTasks` it never blocks on the slowest sibling, and the siblings
-     * that complete later still reach the leader through the fire-and-forget
-     * report-back (see the consumed-in-band rule in `taskCompletedListener`).
-     *
-     * Deliberately does NOT register `taskWaiters` entries for the pending
-     * ids: a `taskWaiters` entry would mark those results as in-band-consumed
-     * and silence the mailbox notifier for results this caller never receives.
-     *
-     * With `timeoutMs`, resolves (never rejects) `{timedOut: true}` and zero
-     * completions when the window elapses first.
-     */
-    awaitTasksAny(taskIds: string[], opts?: {
-        timeoutMs?: number;
-    }): Promise<AwaitAnyResult>;
-    /** Defensive snapshot of tasks still queued (not yet dispatched). */
-    listPendingTasks(): readonly TaskSpec[];
-    /**
-     * Re-pin a still-pending task to a different subagent (`undefined` =
-     * unpin) — the rebalancing primitive used by the FleetSupervisor and
-     * available to hosts. Only queued tasks can move; a dispatched task
-     * returns `false` (steer or terminate its worker instead). Keeps
-     * ownership bookkeeping (taskOwners, checkpoint, fleet manifest) in
-     * sync with the coordinator's queue.
-     */
-    retargetPendingTask(taskId: string, subagentId: string | undefined): boolean;
-    terminate(subagentId: string): Promise<void>;
-    terminateAll(): Promise<void>;
-    remove(subagentId: string): Promise<void>;
-    status(): CoordinatorStatus;
-    /**
-     * Subscribe to coordinator events. Currently only `task.completed` is
-     * exposed (the others are internal lifecycle). Returns an unsubscribe
-     * function. External callers (e.g. the CLI's `MultiAgentHost`) use this
-     * to drive their own pending/results tracking without poking the
-     * coordinator directly.
-     */
-    on(event: 'task.completed', handler: (payload: {
-        task: TaskSpec;
-        result: TaskResult;
-    }) => void): () => void;
-    /**
-     * Snapshot of every task that has resolved (success, failed, timeout,
-     * stopped) since the director started. Returned in completion order
-     * via the internal map's iteration order. Used by `/fleet status` to
-     * paint the completed table without reaching into private state.
-     */
-    completedResults(): TaskResult[];
-    /**
-     * Inject a previously-saved checkpoint snapshot. Call this right after
-     * constructing a Director during a `--resume` run so the in-memory state
-     * (subagents, tasks, waiters) reflects the pre-crash reality instead of
-     * starting from a blank slate. The director then resumes from there —
-     * completing any in-flight tasks and ignoring tasks that already reached
-     * a terminal state in the prior run.
-     */
-    setCheckpointState(snapshot: DirectorStateSnapshot): void;
-    /**
-     * Read a subagent's JSONL transcript directly from disk (no bridge
-     * round-trip needed). Returns the last assistant text, stop reason,
-     * tool-use count, and line count — or null if the file is unavailable.
-     * Requires `sessionsRoot` to be set on construction.
-     */
-    readSession(subagentId: string, tail?: number | undefined): Promise<{
-        lastAssistantText?: string | undefined;
-        lastStopReason?: string | undefined;
-        toolUsesObserved: number;
-        events: number;
-        path?: string | undefined;
-    } | null>;
-    snapshot(): FleetUsage;
-    /**
-     * Look up provider/model metadata for a spawned subagent. Returns
-     * undefined when the subagent id is unknown (not yet spawned, or
-     * already torn down). Callers — notably the TUI fleet panel — use
-     * this to render human-readable provider/model tags next to each
-     * subagent row without reaching into private state.
-     */
-    getSubagentMeta(id: string): {
-        provider?: string | undefined;
-        model?: string | undefined;
-        name?: string | undefined;
-    } | undefined;
-    /**
-     * Compose the leader/director-agent system prompt: fleet preamble +
-     * (optional) roster summary + user base prompt. Pass the result to your
-     * leader Agent's `ctx.systemPrompt` when constructing it.
-     *
-     * `basePrompt` defaults to `config.leaderSystemPrompt` so callers can
-     * use the no-arg form when the multi-agent config already carries it.
-     */
-    leaderSystemPrompt(basePrompt?: string): string;
-    /**
-     * Compose a subagent's system prompt for a given `SubagentConfig`:
-     * baseline + role + task + per-spawn override. Returned by value — does
-     * not mutate the config. Factories (the user-supplied `AgentFactory`)
-     * should call this when building each subagent's Agent so the bridge
-     * contract, role context, and override are all surfaced.
-     *
-     * When `taskBrief` is omitted the Task section is dropped. Pass the
-     * actual task description here to reinforce it in the system prompt
-     * (the runner already passes it as user input — duplicating in the
-     * system prompt is optional but improves anchoring on small models).
-     */
-    subagentSystemPrompt(config: SubagentConfig, taskBrief?: string): string;
-    /**
-     * Build the tool set the LLM-driven director uses to orchestrate.
-     * Returns an array of `Tool` definitions; register these on the
-     * director's `Agent` to expose `spawn_subagent`, `assign_task`, etc.
-     * Each tool's `execute()` delegates straight to the matching method
-     * above.
-     *
-     * Tools all carry `permission: 'auto'` — the *user* has already
-     * approved running the director when they kicked off the run, so
-     * gating individual orchestration calls behind a confirm prompt
-     * would just be noise. The actual subagent tools they spawn are
-     * still permission-checked normally.
-     */
-    tools(roster?: Record<string, SubagentConfig>): Tool[];
-    /**
-     * Attempt to acquire the checkpoint lock. Must be called before
-     * resuming — if another director process is alive, this returns
-     * false and the caller should not proceed with the resume.
-     */
-    acquireCheckpointLock(): Promise<boolean>;
-    /**
-     * Start a collaborative debugging session: BugHunter, RefactorPlanner,
-     * and Critic run in parallel on the same target files, with findings
-     * flowing through the FleetBus (bug.found → refactor.plan →
-     * critic.evaluation). Returns a structured CollabDebugReport when all
-     * three agents complete or the session times out.
-     */
-    spawnCollab(options: CollabSessionOptions): Promise<CollabDebugReport>;
-    /**
-     * Resume from a prior checkpoint snapshot (loaded via
-     * `loadDirectorState()`). Re-attach to the fleet mid-flight so
-     * subsequent spawn/assign calls update the checkpoint normally.
-     */
-    resumeFromCheckpoint(snapshot: DirectorStateSnapshot): void;
-}
-
-/**
- * Alert levels the Director can emit when a collab session needs attention.
- * These flow through the FleetBus so the host can display them in the UI.
- */
-declare enum DirectorAlertLevel {
-    /** The agent is still making progress but has hit a soft budget limit. */
-    WARNING = "warning",
-    /** The agent has hit a hard limit and the session cannot continue. */
-    CRITICAL = "critical",
-    /** The Director has decided to cancel the session (user request or policy). */
-    CANCELLED = "cancelled"
-}
-interface DirectorAlert {
-    sessionId: string;
-    subagentId: string;
-    role: string;
-    level: DirectorAlertLevel;
-    /** Human-readable message for UI/logs */
-    message: string;
-    /** Budget kind that triggered this alert, if any */
-    budgetKind?: 'timeout' | 'idle_timeout' | 'iterations' | 'tool_calls' | 'tokens' | 'cost' | undefined;
-    /** Elapsed ms at time of alert */
-    elapsedMs?: number | undefined;
-    /** Limit that was hit */
-    limit?: number | undefined;
-    /** /btw notes the director has collected (may be empty) */
-    btwNotes?: string[] | undefined;
-}
-/**
- * Immutable snapshot of target files at the start of a collab session.
- * All agents in the session read from this snapshot — they see the same baseline.
- */
-interface SharedFileSnapshot {
-    id: string;
-    createdAt: string;
-    files: SharedFileEntry[];
-}
-interface SharedFileEntry {
-    path: string;
-    content: string;
-    language?: string | undefined;
-    snapshotMtimeMs?: number | undefined;
-    snapshotSizeBytes?: number | undefined;
-}
-/**
- * Bug finding emitted by BugHunter and consumed by RefactorPlanner + Critic.
- */
-interface BugFinding {
-    id: string;
-    type: string;
-    severity: 'critical' | 'high' | 'medium' | 'low';
-    location: {
-        file: string;
-        line: number;
-    };
-    description: string;
-    suggestedFix?: string | undefined;
-}
-/**
- * Refactoring plan emitted by RefactorPlanner, consuming BugFinding(s).
- */
-interface RefactorPlan {
-    id: string;
-    basedOnBugIds: string[];
-    phases: RefactorPhase[];
-    riskScore: 'low' | 'medium' | 'high';
-    estimatedChangeCount: number;
-    rollbackStrategy: string;
-}
-/** One phase within a refactor plan. */
-interface RefactorPhase {
-    number: number;
-    title: string;
-    tasks: string[];
-    risk: 'low' | 'medium' | 'high';
-}
-/**
- * Critic evaluation of a bug finding or refactor plan.
- */
-interface CriticEvaluation {
-    id: string;
-    subjectType: 'bug_finding' | 'refactor_plan';
-    subjectId: string;
-    score: number;
-    verdict: 'approve' | 'needs_revision' | 'reject';
-    strengths: string[];
-    weaknesses: string[];
-    concerns: CriticConcern[];
-}
-interface CriticConcern {
-    description: string;
-    location?: {
-        file: string | undefined;
-        line: number;
-    };
-    severity: 'blocking' | 'advisory';
-}
-/**
- * Full structured report produced when a CollabSession resolves.
- */
-interface CollabDebugReport {
-    sessionId: string;
-    startedAt: string;
-    completedAt: string;
-    targetPaths: string[];
-    /** How the session ended. 'completed' = all agents finished normally.
-     * 'cancelled' = Director called cancelCollabSession().
-     * 'timeout' = session-level timeout elapsed before all agents finished.
-     * 'critical_alert' = Director escalated a warning to a cancel decision.
-     */
-    disposition: 'completed' | 'cancelled' | 'timeout' | 'critical_alert';
-    bugs: BugFinding[];
-    refactorPlans: RefactorPlan[];
-    evaluations: CriticEvaluation[];
-    /** Alerts that were raised during the session (may be empty). */
-    alerts: DirectorAlert[];
-    /** Files modified after the initial static snapshot was captured. */
-    snapshotWarnings?: string[] | undefined;
-    /** Overall verdict from the Critic across all evaluated subjects. */
-    overallVerdict: 'approve' | 'needs_revision' | 'reject';
-    /** Markdown-formatted summary for the director's context window. */
-    summary: string;
-}
-/**
- * Per-agent budget configuration for collab sessions.
- * Allows the caller (Director) to control the exact limits instead of
- * using hard-coded defaults that may not match the director's policy.
- */
-interface CollabBudgetConfig {
-    maxIterations: number;
-    maxToolCalls: number;
-    timeoutMs: number;
-}
-/**
- * Budget overrides for specific roles in a collab session.
- * When a role is not present in the map, the default budget is used.
- */
-type CollabBudgetOverrides = Partial<Record<string, CollabBudgetConfig>>;
-/**
- * Emitted by a collab agent when it hits a soft budget limit.
- * The Director's fleet handler receives this and calls collabAlert().
- */
-interface CollabBudgetWarningPayload {
-    sessionId: string;
-    role: string;
-    kind: 'timeout' | 'idle_timeout' | 'iterations' | 'tool_calls' | 'tokens' | 'cost';
-    used: number;
-    limit: number;
-    timeoutMs?: number | undefined;
-    elapsedMs: number;
-}
-/**
- * Emitted by the Director to cancel all agents in a collab session.
- * CollabSession listens for this and causes its agent pool to finish early.
- */
-interface DirectorCancelCollabPayload {
-    sessionId: string;
-    reason: string;
-    cancelledAt: string;
-}
-interface CollabSessionOptions {
-    /** Paths to scan — used to build the SharedFileSnapshot. */
-    targetPaths: string[];
-    /** Files already read and snapshot. When provided, snapshot is skipped. */
-    prebuiltSnapshot?: SharedFileSnapshot | undefined;
-    /** Max time to wait for the session to resolve (ms). Default: 10 min. */
-    timeoutMs?: number | undefined;
-    /**
-     * Maximum number of files to include in the snapshot.
-     * - If set explicitly: use this value (hard override).
-     * - If `contextWindow` is set: calculate dynamically from estimated token budget.
-     * - If neither: use `DEFAULT_MAX_TARGET_FILES` (30).
-     */
-    maxTargetFiles?: number | undefined;
-    /**
-     * Context window size (in tokens) of the model running the subagents.
-     * When provided and `maxTargetFiles` is not set, the limit is computed
-     * dynamically: `floor((contextWindow * 0.4) / AVG_TOKENS_PER_FILE)`.
-     * If not provided, `DEFAULT_MAX_TARGET_FILES` is used as the fallback.
-     */
-    contextWindow?: number | undefined;
-    /**
-     * Budget overrides per role. When provided, these override the hard-coded
-     * defaults so the Director can enforce fleet-wide budget policy.
-     * Keys must match role names: 'bug-hunter', 'refactor-planner', 'critic'.
-     */
-    budgetOverrides?: CollabBudgetOverrides | undefined;
-    /**
-     * Called by the Director when a collab agent hits a soft budget limit.
-     * The Director uses this to decide whether to cancel the session or extend.
-     * Return 'cancel' to stop the session immediately; 'extend' to continue
-     * with the agent's proposed new limits; 'ignore' to let the default
-     * auto-extend logic handle it.
-     */
-    onBudgetWarning?: ((alert: DirectorAlert) => 'cancel' | 'extend' | 'ignore') | undefined;
-}
-declare class CollabSession extends EventEmitter {
-    readonly sessionId: string;
-    readonly options: CollabSessionOptions;
-    readonly snapshot: SharedFileSnapshot;
-    private readonly director;
-    private readonly fleetBus;
-    private readonly subagentIds;
-    private readonly bugs;
-    private readonly plans;
-    private readonly evaluations;
-    private readonly disposers;
-    private settled;
-    private readonly timeoutMs;
-    private cancelled;
-    private _raceResolved;
-    private readonly alerts;
-    private snapshotWarnings;
-    /** Tracks tool call counts per subagent for progress-based timeout decisions. */
-    private readonly progressBySubagent;
-    /** Last tool call count when a timeout warning was handled. */
-    private readonly lastTimeoutProgress;
-    /** Session-level timeout timer handle (cleared on cancel or natural completion). */
-    private _timeoutTimer?;
-    constructor(director: Director, fleetBus: FleetBus, options: CollabSessionOptions);
-    get id(): string;
-    getSessionAlerts(): DirectorAlert[];
-    isCancelled(): boolean;
-    /**
-     * Snapshot of role → subagentId map. The Director calls coordinator.stop()
-     * for each agent when cancelling the session, using this map to enumerate
-     * all three collab agents.
-     */
-    getSubagentIds(): ReadonlyMap<string, string>;
-    /**
-     * Returns the effective file limit for this session.
-     * Priority: explicit `maxTargetFiles` > dynamic from `contextWindow` > `DEFAULT_MAX_TARGET_FILES`.
-     */
-    effectiveFileLimit(): number;
-    buildSnapshot(): Promise<SharedFileSnapshot>;
-    /**
-     * Cancel the session. Emits director.cancel_collab on the FleetBus so all
-     * collab agents finish early. The session-level timeout timer is also cleared.
-     * Safe to call multiple times (idempotent after first call).
-     */
-    cancel(reason?: string): void;
-    start(): Promise<CollabDebugReport>;
-    private parseAndEmit;
-    private extractJsonObjects;
-    private budgetForRole;
-    private spawnAgent;
-    private buildBugHunterTask;
-    private buildRefactorPlannerTask;
-    private buildCriticTask;
-    private wireFleetBus;
-    private roleFromSubagentId;
-    private assembleReport;
-    private checkSnapshotFreshness;
-    private buildMarkdownSummary;
-    private cleanup;
-}
-
-/**
- * Opaque host interface so this factory doesn't have to depend on the
- * CLI's `MultiAgentHost`. Any caller that exposes the same three
- * methods can wire `delegate` — including test doubles.
- */
-interface DelegateHost {
-    /** True if a Director is already attached and running. */
-    isDirectorMode(): boolean;
-    /** Build (or return the cached) Director when director mode is on. */
-    ensureDirector(): Promise<Director | null>;
-    /**
-     * Force-promote a non-director session into director mode at runtime.
-     * Returns the Director, or null when promotion is impossible (e.g. a
-     * non-director coordinator has already spawned subagents in the
-     * legacy code path).
-     */
-    promoteToDirector(): Promise<Director | null>;
-    /**
-     * Optional: when promotion fails, return the human-readable reason.
-     * Used to render an actionable error to the calling model instead of
-     * the prior opaque "Director could not be activated" message.
-     * Implementations may return null when they don't track the reason.
-     */
-    getPromotionBlockReason?(): string | null;
-}
-interface CreateDelegateToolOptions {
-    host: DelegateHost;
-    /**
-     * Roster used to resolve `role` strings into full `SubagentConfig`s.
-     * Typically `FLEET_ROSTER`. When omitted, `delegate({ role })` calls
-     * fail and only the explicit `name + provider + model` path works.
-     */
-    roster?: Record<string, SubagentConfig>;
-    /**
-     * Default await timeout in milliseconds. `delegate` blocks until the
-     * subagent's task resolves; without a cap, a stuck worker would hang
-     * the host indefinitely. Set generously (default: 4 hours) so the
-     * orchestrator can run multi-step refactors / monorepo audits
-     * without being killed for being slow — the orchestrator must
-     * decide per-call when a task needs to be cut short.
-     */
-    defaultTimeoutMs?: number | undefined;
-    /**
-     * Absolute directory under which per-subagent JSONL transcripts live —
-     * matches `MultiAgentHostOptions.sessionsRoot`. When set, the delegate
-     * tool reads the subagent's transcript on timeout / budget-exhaustion
-     * to extract partial output, so the host LLM gets *something* useful
-     * back instead of just an error.
-     */
-    sessionsRoot?: string | undefined;
-    /**
-     * The directorRunId used to namespace transcripts (typically the host
-     * session id). Combined with `sessionsRoot` to locate per-subagent
-     * JSONLs at `<sessionsRoot>/<runId>/<subagentId>.jsonl`.
-     */
-    directorRunId?: string | undefined;
-    /**
-     * Buffer subtracted from the caller's `timeoutMs` before passing it
-     * to the subagent. Gives the host a window to detect a subagent that
-     * has gone silent and surface a partial result rather than a generic
-     * timeout. Default: 60_000 ms (raised from 30s to give subagents
-     * more headroom before the host kills them).
-     */
-    subagentTimeoutBufferMs?: number | undefined;
-    /**
-     * Host EventBus. When supplied, `delegate` emits `delegate.started`
-     * (before it blocks on the subagent) and `delegate.completed` (once the
-     * subagent settles) so UIs / the Telegram bridge can render readable
-     * start/finish lines instead of inferring them from the truncated
-     * `tool.executed` JSON preview. Optional — emits are best-effort and a
-     * missing bus never affects delegation behaviour.
-     */
-    events?: EventBus | undefined;
-}
-/**
- * `delegate` — the only multi-agent tool a regular (non-director) agent
- * ever needs. It bundles spawn + assign + await into a single call and
- * transparently auto-promotes the host into director mode on first use.
- *
- * The model never has to ask "are we in director mode?" — it just calls
- * `delegate({ role, task })` and gets back a `TaskResult`. The cost of
- * that ergonomic packaging is that `delegate` cannot be used for
- * parallel work as-is; the model must fire multiple `delegate` calls in
- * parallel through the provider's parallel-tool-call surface, or escalate
- * to the explicit `spawn_subagent` + `assign_task` + `await_tasks` flow
- * when it wants fan-out it controls itself.
- */
-declare function createDelegateTool(opts: CreateDelegateToolOptions): Tool;
-
-/**
- * System-prompt composition helpers for the Director ecosystem.
- *
- * Two callers need composed prompts:
- *
- *   1. The **leader** (the director's own Agent) — needs a preamble that
- *      explains the fleet protocol: when to spawn, when to await, how to
- *      roll up, and the eight orchestration tools it owns.
- *
- *   2. Each **subagent** — needs a baseline that explains it has a parent
- *      it can call via the bridge, a role-specific block, the task brief,
- *      and finally any per-spawn `systemPromptOverride` from `SubagentConfig`.
- *
- * Both composers are pure functions: feed them parts, they return a string.
- * No I/O, no side effects, no implicit defaults beyond the ones exported
- * here. Callers (CLI multi-agent factory, Director itself) decide which
- * parts to fill in — that keeps the composition seam visible and testable.
- */
-/**
- * Default fleet-protocol preamble injected at the **front** of the
- * director-agent's system prompt.
- */
-declare const DEFAULT_DIRECTOR_PREAMBLE: string;
-/**
- * Default baseline prepended to every subagent's system prompt.
- */
-declare const DEFAULT_SUBAGENT_BASELINE: string;
-/** Parts the leader-prompt composer accepts. All optional. */
-interface DirectorPromptParts {
-    /** The user's existing leader system prompt — typically what was passed
-     *  via `MultiAgentConfig.leaderSystemPrompt`. */
-    basePrompt?: string | undefined;
-    /** Override the built-in fleet preamble. Pass empty string to suppress. */
-    directorPreamble?: string | undefined;
-    /** Optional roster summary block — a short list of pre-configured roles
-     *  the director can spawn (e.g. "researcher, coder, reviewer"). Helps
-     *  small models discover the available shapes without scanning tools. */
-    rosterSummary?: string | undefined;
-}
-/**
- * Compose the leader/director's system prompt. Order:
- *   1. Director preamble (fleet protocol)
- *   2. Roster summary (optional, when provided)
- *   3. User base prompt (the per-project leader prompt)
- *
- * Sections are separated by a blank line. Empty parts are skipped so the
- * output never contains stray blank-line runs.
- */
-declare function composeDirectorPrompt(parts?: DirectorPromptParts): string;
-/** Parts the subagent-prompt composer accepts. Layered from generic to
- *  specific; later layers override earlier ones when they conflict. */
-interface SubagentPromptParts {
-    /** Base persona/identity for *every* subagent. Defaults to the bridge
-     *  contract baseline. Pass empty string to suppress. */
-    baseline?: string | undefined;
-    /** Role-specific block, e.g. "You are a code reviewer. Focus on…". */
-    role?: string | undefined;
-    /** Task brief — usually the same string the runner passes as user input,
-     *  but exposed here in case the factory wants it duplicated in the
-     *  system prompt for reinforcement. */
-    task?: string | undefined;
-    /**
-     * Absolute path to a shared scratchpad directory the whole fleet can
-     * read/write. When set, the composer adds a "Shared notes" block that
-     * tells the subagent where to drop findings and where to look for
-     * sibling output. This is the cheap fleet-coordination channel —
-     * agents don't need each other's transcripts, just each other's
-     * conclusions. Falls between `task` and `override` so the override
-     * can still narrow or replace it.
-     */
-    sharedScratchpad?: string | undefined;
-    /**
-     * Optional skill body content injected into the subagent's system prompt.
-     * Use this to provide domain-specific knowledge (SKILL.md bodies) to
-     * subagents that need it. Placed after `sharedScratchpad` and before
-     * `override` so the override can still narrow or replace it.
-     */
-    skills?: string | undefined;
-    /** Final per-spawn override from `SubagentConfig.systemPromptOverride`.
-     *  Added last so it wins on conflict — that's by design: the spawn site
-     *  knows the most about what this specific subagent should do. */
-    override?: string | undefined;
-}
-/**
- * Compose a subagent's system prompt. Order:
- *   1. Baseline (bridge contract)
- *   2. Role
- *   3. Task brief
- *   4. Shared scratchpad
- *   5. Skills (domain knowledge from SKILL.md)
- *   6. Per-spawn override
- *
- * Same blank-line-separated joining as the director composer.
- *
- * Layering rationale: the baseline never needs to change between
- * subagents; the role is the "what kind of worker is this"; the task is
- * the "what should you do *now*"; skills provide reusable domain knowledge
- * (e.g. bug-hunting patterns, security scanning rules); the override is
- * the spawn-site escape hatch ("…and respond only in JSON"). Putting
- * override last means it never gets squashed by something earlier in the chain.
- */
-declare function composeSubagentPrompt(parts?: SubagentPromptParts): string;
-/**
- * Render a short bullet list summarising a roster — useful for stuffing
- * into `composeDirectorPrompt({ rosterSummary })` so the director model
- * can see available roles without scanning tool descriptions.
- *
- * Each entry: `- <role-id>: <name>[ (provider/model)] — <prompt-headline>`
- * The prompt headline is the first non-empty line of `config.prompt`,
- * truncated to 80 chars. Skipped entirely when the role has no prompt.
- */
-declare function rosterSummaryFromConfigs(roster: Record<string, {
-    name: string;
-    provider?: string | undefined;
-    model?: string | undefined;
-    prompt?: string | undefined;
-    role?: string | undefined;
-}>): string;
-
-/**
- * Per-subagent session factory.
- *
- * Director runs produce many parallel transcripts — one per spawned
- * subagent — and we want them all rooted under the same director-run
- * directory so a future `wstack replay <runId>` can rehydrate the whole
- * fleet from a single tree.
- *
- * The factory builds (or accepts) a `SessionStore` whose `dir` points at
- * `<sessionsRoot>/<directorRunId>/`, and returns a small `create()`
- * function that the orchestration layer calls per-spawn. Each call
- * yields a fresh `SessionWriter` whose JSONL file lives in that
- * directory, named by either the caller-supplied `subagentId` (preferred,
- * so the file name is human-readable) or a derived id.
- *
- * **Why a thin factory instead of plumbing options through every spawn
- * site?** Because the director is the only caller that needs this
- * isolation pattern, and shoving `sessionStore` options into
- * `SubagentConfig` would leak storage details into a config shape that
- * agents and the coordinator have no business knowing about.
- */
-interface DirectorSessionFactoryOptions {
-    /**
-     * Either a parent directory where `<directorRunId>/` will be created,
-     * or a pre-built `SessionStore` whose `dir` already points at the
-     * director run directory. Tests pass an in-memory store for isolation;
-     * production code passes the path under `~/.wrongstack/sessions/`.
-     */
-    store?: SessionStore | undefined;
-    sessionsRoot?: string | undefined;
-    /**
-     * Director run id — namespaces all subagent JSONLs under one folder.
-     * Defaults to a timestamped id; supplied explicitly when resuming a
-     * prior fleet manifest.
-     */
-    directorRunId?: string | undefined;
-    /**
-     * Session-level trace ID for correlating subagent storage events with
-     * the parent session's trace in observability pipelines.
-     */
-    traceId?: string | undefined;
-}
-interface DirectorSessionFactory {
-    /** Absolute directory where this director run's transcripts live. */
-    readonly dir: string;
-    /** The director run id used to namespace the directory. */
-    readonly directorRunId: string;
-    /**
-     * Create a fresh `SessionWriter` for the named subagent. Each
-     * subagent gets its own JSONL file. The writer's `id` matches the
-     * supplied `subagentId` so disk paths line up with in-memory ids.
-     */
-    createSubagentSession(args: {
-        subagentId: string;
-        provider?: string | undefined;
-        model?: string | undefined;
-        title?: string | undefined;
-    }): Promise<SessionWriter>;
-}
-/**
- * Build a `DirectorSessionFactory`. Pass either a pre-configured
- * `SessionStore` (tests) or a `sessionsRoot` path (production). When
- * neither is supplied the factory throws — there's no sane default for
- * "where do these JSONLs live".
- */
-declare function makeDirectorSessionFactory(opts: DirectorSessionFactoryOptions): DirectorSessionFactory;
-
-declare function makeSpawnTool(director: Director, roster?: Record<string, SubagentConfig>): Tool;
-declare function makeQualityGateTool(director: Director, roster?: Record<string, SubagentConfig>): Tool;
-declare function makeAssignTool(director: Director): Tool;
-declare function makeKanbanQueueTool(director: Director, roster?: Record<string, SubagentConfig>): Tool;
-declare function makeAwaitTasksTool(director: Director): Tool;
-declare function makeAskTool(director: Director): Tool;
-/**
- * Retrieve a previously stored `ask_subagent` answer by its store key.
- * The key was returned as `_answerKey` in the ask_subagent response.
- * Use this only for large responses that were stored out-of-context.
- */
-declare function makeAskResultTool(director: Director): Tool;
-declare function makeRollUpTool(director: Director): Tool;
-declare function makeTerminateTool(director: Director): Tool;
-declare function makeTerminateAllTool(director: Director): Tool;
-/**
- * Unified fleet observation tool — consolidates the former fleet_status,
- * fleet_usage, fleet_session, and fleet_health tools under a single `action`
- * parameter (status, usage, health, session).
- *
- * These four are all read-only fleet queries; merging them into one tool
- * reduces tool-schema token overhead (4 × ~150 tokens → 1 × ~250 tokens)
- * and eliminates model confusion when choosing between similar tools.
- */
-declare function makeFleetTool(director: Director): Tool;
-/**
- * Collaborative debugging session: BugHunter, RefactorPlanner, and Critic
- * run in parallel on the same target files, with findings flowing through
- * the FleetBus (bug.found → refactor.plan → critic.evaluation).
- *
- * Returns a structured CollabDebugReport containing all bug findings,
- * refactor plans, critic evaluations, and an overall verdict.
- */
-declare function makeCollabDebugTool(director: Director): Tool;
-/**
- * Tool for subagents to emit structured events on the FleetBus.
- * Custom event types are extensible; known collab events are schema-validated
- * and restricted to their owning role before the Director routes them.
- * Common event types in collaborative sessions:
- *   bug.found        — BugHunter emits per-finding
- *   refactor.plan    — RefactorPlanner emits per-plan
- *   critic.evaluation — Critic emits per-evaluation
- *
- * The payload structure is event-type-specific. Use null for empty payloads.
- */
-declare function makeFleetEmitTool(director: Director): Tool;
-/**
- * Signal that the director's work is satisfied and the fleet should wind down.
- *
- * Once called:
- * - `spawn_subagent` throws — no new subagents can be created
- * - `assign_task` synthesizes an immediate `aborted_by_parent` completion
- *   for any queued task (callers awaiting those tasks unblock immediately)
- * - Running subagents are NOT killed — they finish naturally; no new
- *   tasks are dispatched to them
- *
- * Use this when you are satisfied with the results and want the fleet to
- * stop spawning without forcibly stopping in-flight work. Call
- * `terminate_subagent` separately for any subagent you need to stop immediately.
- */
-declare function makeWorkCompleteTool(director: Director): Tool;
-
-/**
- * Pre-built subagent role configurations for the WrongStack fleet.
- * These can be passed to `MultiAgentHost.spawn()` or used as templates
- * for the director's roster.
- */
-
-/**
- * Audit Log Agent — analyzes session logs, event streams, and traces.
- * Use for: post-mortems, trend analysis, operational insights.
- */
-declare const AUDIT_LOG_AGENT: SubagentConfig;
-/**
- * Bug Hunter Agent — systematic bug and code smell detection.
- * Use for: pre-refactoring health checks, code review, regression prevention.
- */
-declare const BUG_HUNTER_AGENT: SubagentConfig;
-/**
- * Refactor Planner Agent — structured refactoring planning.
- * Use for: large rewrites, technical debt reduction, architecture improvements.
- */
-declare const REFACTOR_PLANNER_AGENT: SubagentConfig;
-/**
- * Security Scanner Agent — vulnerability and secret detection.
- * Use for: CI checks, pre-release audits, dependency vulnerability scanning.
- */
-declare const SECURITY_SCANNER_AGENT: SubagentConfig;
-/**
- * All agents in a map for easy lookup by role. The four legacy pre-built
- * agents plus the phase 1-9 catalog (`ALL_AGENT_DEFINITIONS`). Catalog roles
- * are guaranteed collision-free by the catalog builder; none overlap the
- * legacy four.
- */
-declare const FLEET_ROSTER: Record<string, SubagentConfig>;
-interface FleetRosterBudget {
-    timeoutMs?: number | undefined;
-    /** Idle reap window (ms). Resets on activity — see `applyRosterBudget`. */
-    idleTimeoutMs?: number | undefined;
-    maxIterations?: number | undefined;
-    maxToolCalls?: number | undefined;
-    maxTokens?: number | undefined;
-    maxCostUsd?: number | undefined;
-}
-declare const FLEET_ROSTER_BUDGETS: Record<string, FleetRosterBudget>;
-declare function applyRosterBudget(cfg: SubagentConfig): SubagentConfig;
-/** Quick-access list for spawning all at once. */
-declare const ALL_FLEET_AGENTS: SubagentConfig[];
-/** All ACP external agents. */
-declare const ACP_AGENTS: SubagentConfig[];
-/** Extended roster including ACP agents. */
-declare const FLEET_ROSTER_WITHACP: Record<string, SubagentConfig>;
-
-/**
- * A no-op FleetBus that discards all events. Used when no real fleet
- * bus is available (non-director mode) so the runner's `fleetBus`
- * field is always valid and the `attach()` call is always safe.
- *
- * One singleton instance is sufficient — it has no state to reset.
- */
-declare const NULL_FLEET_BUS: FleetBus;
-
-export { WorktreeIntegrationError as $, ACP_AGENTS as A, BUG_HUNTER_AGENT as B, type CollabBudgetConfig as C, DEFAULT_DIRECTOR_PREAMBLE as D, FLEET_ROSTER_WITHACP as E, FLEET_ROSTER as F, FleetCostCapError as G, FleetManager as H, type FleetManagerOptions as I, type FleetRosterBudget as J, FleetSpawnBudgetError as K, FleetTokenCapError as L, type FleetWorktreePolicy as M, type ICoordinator as N, type IFleetManager as O, InMemoryAgentBridge as P, InMemoryBridgeTransport as Q, LargeAnswerStore as R, NULL_FLEET_BUS as S, REFACTOR_PLANNER_AGENT as T, type RefactorPhase as U, type RefactorPlan as V, SECURITY_SCANNER_AGENT as W, type SharedFileEntry as X, type SharedFileSnapshot as Y, type SubagentPromptParts as Z, type TaskResultNotification as _, AGENTS_BY_PHASE as a, type WorktreeIsolationDecision as a0, type WorktreeTaskRunnerOptions as a1, type WorktreeTaskStateUpdate as a2, applyRosterBudget as a3, attachAutoExtend as a4, composeDirectorPrompt as a5, composeSubagentPrompt as a6, createDelegateTool as a7, createMessage as a8, getAgentDefinition as a9, makeAskResultTool as aa, makeAskTool as ab, makeAssignTool as ac, makeAwaitTasksTool as ad, makeCollabDebugTool as ae, makeDirectorSessionFactory as af, makeFleetEmitTool as ag, makeFleetTool as ah, makeKanbanQueueTool as ai, makeQualityGateTool as aj, makeRollUpTool as ak, makeSpawnTool as al, makeTerminateAllTool as am, makeTerminateTool as an, makeWorkCompleteTool as ao, resolveSubagentWorktreeDecision as ap, rosterSummaryFromConfigs as aq, subagentNeedsWorktree as ar, wrapSubagentRunnerWithWorktrees as as, AGENT_CATALOG as b, ALL_AGENT_DEFINITIONS as c, ALL_FLEET_AGENTS as d, AUDIT_LOG_AGENT as e, type AutoExtendCeiling as f, type AutoExtendPolicy as g, type BugFinding as h, type CollabBudgetOverrides as i, type CollabBudgetWarningPayload as j, type CollabDebugReport as k, CollabSession as l, type CollabSessionOptions as m, type CreateDelegateToolOptions as n, type CriticConcern as o, type CriticEvaluation as p, DEFAULT_SUBAGENT_BASELINE as q, type DelegateHost as r, Director as s, type DirectorAlert as t, DirectorAlertLevel as u, type DirectorCancelCollabPayload as v, type DirectorPromptParts as w, type DirectorSessionFactory as x, type DirectorSessionFactoryOptions as y, FLEET_ROSTER_BUDGETS as z };