@wrongstack/core 0.9.7 → 0.9.20

package/dist/{null-fleet-bus-Chrc_3Pp.d.ts → null-fleet-bus-Dnl19vmf.d.ts}

@@ -1,10 +1,11 @@
-import { c as AgentPhase, b as AgentDefinition, d as DefaultMultiAgentCoordinator, f as DispatchClassifier } from './multi-agent-coordinator-DTXF2aAl.js';
-import { n as SubagentConfig, u as TaskResult, k as CoordinatorStatus, v as TaskSpec, M as MultiAgentConfig, t as SubagentRunner } from './multi-agent-3ZnTB1aT.js';
-import { B as SessionWriter, Q as Tool, y as SessionStore } from './context-BRNbHmRM.js';
+import { c as AgentPhase, b as AgentDefinition, d as DefaultMultiAgentCoordinator, f as DispatchClassifier } from './multi-agent-coordinator-CAhsegPz.js';
+import { n as SubagentConfig, u as TaskResult, k as CoordinatorStatus, v as TaskSpec, M as MultiAgentConfig, t as SubagentRunner } from './multi-agent-DNp6lAzg.js';
+import { B as SessionWriter, Q as Tool, y as SessionStore } from './context-zkZeILpr.js';
+import { F as FleetBus, e as FleetUsage, f as FleetUsageAggregator } from './agent-subagent-runner-U-rs7kk7.js';
+import { EventEmitter } from 'node:events';
 import { a as DirectorStateSnapshot } from './director-state-BmYi3DGA.js';
-import { I as InMemoryAgentBridge } from './agent-bridge-DMVOX0cF.js';
-import { F as FleetBus, e as FleetUsage, f as FleetUsageAggregator } from './agent-subagent-runner-DaF_EgRG.js';
-import { E as EventBus } from './events-CiG9qUM_.js';
+import { I as InMemoryAgentBridge } from './agent-bridge-Dti3KXGk.js';
+import { E as EventBus } from './events-DH-9r-_C.js';
 
 /**
  * Agent catalog aggregator.
@@ -30,6 +31,237 @@ declare const AGENT_CATALOG: Record<string, AgentDefinition>;
 /** Role lookup helper. Returns undefined for unknown roles. */
 declare function getAgentDefinition(role: string): AgentDefinition | undefined;
 
+/**
+ * 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' | 'iterations' | 'tool_calls' | 'tokens' | 'cost';
+    /** Elapsed ms at time of alert */
+    elapsedMs?: number;
+    /** Limit that was hit */
+    limit?: number;
+    /** /btw notes the director has collected (may be empty) */
+    btwNotes?: string[];
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+        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[];
+    /** 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' | 'iterations' | 'tool_calls' | 'tokens' | 'cost';
+    used: number;
+    limit: number;
+    timeoutMs?: number;
+    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;
+    /** Max time to wait for the session to resolve (ms). Default: 10 min. */
+    timeoutMs?: number;
+    /**
+     * 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;
+    /**
+     * 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';
+}
+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 readonly alerts;
+    /** 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>;
+    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 buildMarkdownSummary;
+    private cleanup;
+}
+
 /**
  * Interface for a fleet coordinator. Implemented by both `Director`
  * (full LLM-driven orchestration with fleet policy) and
@@ -155,14 +387,41 @@ interface IFleetManager {
     } | undefined;
     /**
      * Called before a spawn is recorded. Returns a reason string if the
-     * spawn should be rejected (budget cap, depth limit, cost cap, etc.),
-     * or null to proceed. Director.spawn() calls this internally.
+     * 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';
+        kind: 'max_spawns' | 'max_spawn_depth' | 'max_cost_usd' | 'max_context_load';
         limit: number;
         observed: number;
     } | null;
+    /**
+     * 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)"), mark it
+     * as used so it is never reused, then record the spawn. The nickname
+     * is written back to `config.name` so the coordinator and manifest both
+     * see the human-readable name.
+     *
+     * Returns the assigned nickname string.
+     */
+    assignNicknameAndRecord(subagentId: string, config: SubagentConfig, priceLookup?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+    }): 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.
@@ -264,6 +523,19 @@ interface FleetManagerOptions {
     directorBudget?: {
         maxCostUsd?: number;
     };
+    /**
+     * 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;
+    /**
+     * Provider's max context window in tokens. Used with `maxLeaderContextLoad`
+     * to compute the absolute token threshold. Default: 128_000.
+     */
+    maxContext?: number;
 }
 /**
  * Fleet-level policy container extracted from `Director`. Owns:
@@ -290,7 +562,6 @@ declare class FleetManager implements IFleetManager {
     /** Usage rollup across all subagents. */
     readonly usage: FleetUsageAggregator;
     private readonly manifestPath?;
-    private readonly sessionsRoot?;
     private readonly directorRunId;
     /** Spawn cap (lifetime total). Infinity means unlimited. */
     readonly maxSpawns: number;
@@ -314,8 +585,16 @@ declare class FleetManager implements IFleetManager {
     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. */
+    private readonly maxContext;
     constructor(opts?: FleetManagerOptions);
     get fleetBus(): FleetBus;
     /**
@@ -335,11 +614,31 @@ declare class FleetManager implements IFleetManager {
      * 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';
+    canSpawn(_config: SubagentConfig): {
+        kind: 'max_spawns' | 'max_spawn_depth' | 'max_cost_usd' | 'max_context_load';
         limit: number;
         observed: number;
     } | null;
+    setLeaderContextPressure(tokens: number): void;
+    /**
+     * 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.
+     */
+    assignNicknameAndRecord(subagentId: string, config: SubagentConfig, priceLookup?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+    }): 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
@@ -575,6 +874,21 @@ interface DirectorOptions {
      * `makeLLMClassifier(complete)` from the dispatcher module.
      */
     dispatchClassifier?: DispatchClassifier;
+    /**
+     * 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;
+    /**
+     * 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).
+     */
+    maxContext?: number;
 }
 /**
  * Thrown by `Director.spawn()` when a configured spawn cap (`maxSpawns`,
@@ -586,7 +900,7 @@ 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);
+    constructor(kind: 'max_spawns' | 'max_spawn_depth', limit: number, observed: number, message?: string);
 }
 /**
  * Thrown by `Director.spawn()` when the fleet-wide cost cap is exceeded.
@@ -614,6 +928,20 @@ declare class Director implements ICoordinator {
      * 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;
     /**
      * Optional fleet-level policy container. When provided the Director
      * delegates spawn budgeting, manifest entries, and checkpointing to it
@@ -646,6 +974,8 @@ declare class Director implements ICoordinator {
     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;
@@ -697,6 +1027,23 @@ declare class Director implements ICoordinator {
     private taskCompletedListener;
     /** Optional LLM classifier for smart dispatch. Passed from options. */
     readonly dispatchClassifier?: DispatchClassifier;
+    /** 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. */
+    private readonly maxContext;
+    /**
+     * 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). */
+    private readonly _activeCollabSessions;
     constructor(opts: DirectorOptions);
     /**
      * Record a granted budget extension and broadcast it on the FleetBus so
@@ -706,6 +1053,75 @@ declare class Director implements ICoordinator {
     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;
@@ -890,6 +1306,14 @@ declare class Director implements ICoordinator {
      * 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
@@ -898,6 +1322,63 @@ declare class Director implements ICoordinator {
     resumeFromCheckpoint(snapshot: DirectorStateSnapshot): void;
 }
 
+declare function makeSpawnTool(director: Director, roster?: Record<string, SubagentConfig>): Tool;
+declare function makeAssignTool(director: Director): Tool;
+declare function makeAwaitTasksTool(director: Director): Tool;
+declare function makeAskTool(director: Director): Tool;
+declare function makeRollUpTool(director: Director): Tool;
+declare function makeTerminateTool(director: Director): Tool;
+declare function makeFleetStatusTool(director: Director): Tool;
+declare function makeFleetUsageTool(director: Director): Tool;
+/**
+ * Read a subagent's JSONL transcript and return the last assistant text,
+ * stop reason, and tool-use count. The director can call this on a
+ * running or timed-out subagent to see what it actually produced without
+ * having to wait for natural completion.
+ */
+declare function makeFleetSessionTool(director: Director): Tool;
+/**
+ * Health snapshot per subagent — budget pressure (how close to limits),
+ * last activity timestamp, and current status. Lets the director make
+ * smarter routing decisions without having to call fleet_usage + fleet_status separately.
+ */
+declare function makeFleetHealthTool(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.
+ * Any agent can emit any event type; the Director routes it to all listeners.
+ * 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;
+
 /**
  * Opaque host interface so this factory doesn't have to depend on the
  * CLI's `MultiAgentHost`. Any caller that exposes the same three
@@ -1065,7 +1546,7 @@ declare function makeDirectorSessionFactory(opts: DirectorSessionFactoryOptions)
  * descriptions live on the tool definitions themselves; this preamble only
  * teaches *when* to reach for them.
  */
-declare const DEFAULT_DIRECTOR_PREAMBLE = "You are the Director of a multi-agent fleet. You orchestrate worker\nsubagents by spawning them, assigning tasks, awaiting completions, and\nrolling up their outputs into your next decision.\n\nCore fleet tools available to you:\n  - spawn_subagent       \u2014 create a worker with a chosen provider / model / role\n  - assign_task          \u2014 hand a piece of work to a specific subagent\n  - await_tasks          \u2014 block until named task ids complete (parallel-safe)\n  - ask_subagent         \u2014 synchronously query a running subagent via the bridge\n  - roll_up              \u2014 aggregate finished tasks into a markdown/json summary\n  - terminate_subagent   \u2014 abort a stuck worker (use sparingly)\n  - fleet_status         \u2014 snapshot of all subagents and pending tasks\n  - fleet_usage          \u2014 token + cost breakdown per subagent and total\n\nWorking rules:\n  1. Decompose first. Before spawning, decide which sub-tasks are\n     independent and can run in parallel. Sequential work doesn't need a\n     subagent \u2014 do it yourself.\n  2. Match worker to job. Cheap/fast model for triage, capable model for\n     synthesis. Different providers per sibling is allowed and encouraged.\n  3. Always pair an assign with an await. Don't fire-and-forget; you owe\n     the user a single coherent answer at the end.\n  4. Roll up before deciding. After await_tasks resolves, call roll_up so\n     the results are folded back into your context in a compact form.\n  5. Budget is real. Check fleet_usage periodically. If a subagent is\n     thrashing, terminate it rather than letting cost climb silently.\n  6. Never claim a subagent's work as your own without verifying it. If a\n     result looks wrong, ask_subagent for clarification before passing it\n     to the user.";
+declare const DEFAULT_DIRECTOR_PREAMBLE = "You are the Director of a multi-agent fleet. You orchestrate worker\nsubagents by spawning them, assigning tasks, awaiting completions, and\nrolling up their outputs into your next decision.\n\nCore fleet tools available to you:\n  - spawn_subagent       \u2014 create a worker with a chosen provider / model / role\n  - assign_task          \u2014 hand a piece of work to a specific subagent\n  - await_tasks          \u2014 block until named task ids complete (parallel-safe)\n  - ask_subagent         \u2014 synchronously query a running subagent via the bridge\n  - roll_up              \u2014 aggregate finished tasks into a markdown/json summary\n  - terminate_subagent   \u2014 abort a stuck worker (use sparingly)\n  - fleet_status         \u2014 snapshot of all subagents and pending tasks\n  - fleet_usage          \u2014 token + cost breakdown per subagent and total\n\nWorking rules:\n  1. Decompose first. Before spawning, decide which sub-tasks are\n     independent and can run in parallel. Sequential work doesn't need a\n     subagent \u2014 do it yourself.\n  2. Match worker to job. Cheap/fast model for triage, capable model for\n     synthesis. Different providers per sibling is allowed and encouraged.\n  3. Always pair an assign with an await. Don't fire-and-forget; you owe\n     the user a single coherent answer at the end.\n  4. Roll up before deciding. After await_tasks resolves, call roll_up so\n     the results are folded back into your context in a compact form.\n  5. Budget is real. Check fleet_usage periodically. If a subagent is\n     thrashing, terminate it rather than letting cost climb silently.\n  6. Never claim a subagent's work as your own without verifying it. If a\n     result looks wrong, ask_subagent for clarification before passing it\n     to the user.\n  7. Wind down when satisfied. When the results are good enough, call\n     work_complete \u2014 no new subagents will spawn and queued tasks complete\n     as aborted. Running subagents finish naturally. Call terminate_subagent\n     only for ones you need to stop immediately.";
 /**
  * Default baseline prepended to every subagent's system prompt. Tells the
  * subagent its place in the hierarchy and the bridge contract — without
@@ -1264,4 +1745,4 @@ declare function attachAutoExtend(events: EventBus, policy?: AutoExtendPolicy):
  */
 declare const NULL_FLEET_BUS: FleetBus;
 
-export { ACP_AGENTS as A, BUG_HUNTER_AGENT as B, type CreateDelegateToolOptions as C, DEFAULT_DIRECTOR_PREAMBLE as D, createDelegateTool as E, FLEET_ROSTER as F, getAgentDefinition as G, makeDirectorSessionFactory as H, type ICoordinator as I, rosterSummaryFromConfigs as J, NULL_FLEET_BUS as N, REFACTOR_PLANNER_AGENT as R, SECURITY_SCANNER_AGENT as S, AGENTS_BY_PHASE as a, 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, DEFAULT_SUBAGENT_BASELINE as h, type DelegateHost as i, Director as j, type DirectorPromptParts as k, type DirectorSessionFactory as l, type DirectorSessionFactoryOptions as m, FLEET_ROSTER_BUDGETS as n, FLEET_ROSTER_WITHACP as o, FleetCostCapError as p, FleetManager as q, type FleetManagerOptions as r, type FleetRosterBudget as s, FleetSpawnBudgetError as t, type IFleetManager as u, type SubagentPromptParts as v, applyRosterBudget as w, attachAutoExtend as x, composeDirectorPrompt as y, composeSubagentPrompt as z };
+export { makeAskTool 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, type ICoordinator as L, type IFleetManager as M, NULL_FLEET_BUS as N, type RefactorPhase as O, type RefactorPlan as P, type SharedFileEntry as Q, REFACTOR_PLANNER_AGENT as R, SECURITY_SCANNER_AGENT as S, type SharedFileSnapshot as T, type SubagentPromptParts as U, applyRosterBudget as V, attachAutoExtend as W, composeDirectorPrompt as X, composeSubagentPrompt as Y, createDelegateTool as Z, getAgentDefinition as _, AGENTS_BY_PHASE as a, makeAssignTool as a0, makeAwaitTasksTool as a1, makeCollabDebugTool as a2, makeDirectorSessionFactory as a3, makeFleetEmitTool as a4, makeFleetHealthTool as a5, makeFleetSessionTool as a6, makeFleetStatusTool as a7, makeFleetUsageTool as a8, makeRollUpTool as a9, makeSpawnTool as aa, makeTerminateTool as ab, makeWorkCompleteTool as ac, rosterSummaryFromConfigs as ad, 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 };

package/dist/observability/index.d.ts

@@ -1,6 +1,6 @@
 import { e as MetricsSink, M as MetricLabels, f as MetricsSnapshot, b as HealthRegistry, H as HealthCheck, A as AggregateHealth, T as Tracer, S as Span } from '../observability-BhnVLBLS.js';
-import { E as EventBus } from '../events-CiG9qUM_.js';
-import '../context-BRNbHmRM.js';
+import { E as EventBus } from '../events-DH-9r-_C.js';
+import '../context-zkZeILpr.js';
 
 /**
  * In-memory metrics sink. Suitable for embedded use, tests, and /metrics

package/dist/{path-resolver-TcJfc29Y.d.ts → path-resolver-CHiBL0DD.d.ts}

@@ -1,6 +1,6 @@
-import { E as EventBus } from './events-CiG9qUM_.js';
+import { E as EventBus } from './events-DH-9r-_C.js';
 import { b as ModelsRegistry, R as ResolvedModel } from './models-registry-BcYJDKLm.js';
-import { O as TokenCounter, $ as Usage, C as CacheStats } from './context-BRNbHmRM.js';
+import { O as TokenCounter, $ as Usage, C as CacheStats } from './context-zkZeILpr.js';
 import { P as PathResolver } from './path-resolver-CPRj4bFY.js';
 
 /**

package/dist/{secret-scrubber-DttNiGYA.d.ts → permission-H35s9Evv.d.ts}

@@ -1,4 +1,4 @@
-import { Q as Tool, d as Context, P as Permission } from './context-BRNbHmRM.js';
+import { Q as Tool, d as Context, P as Permission } from './context-zkZeILpr.js';
 
 interface TrustPolicy {
     [toolNameOrPattern: string]: {
@@ -48,9 +48,4 @@ interface PermissionPolicy {
     reload(): Promise<void>;
 }
 
-interface SecretScrubber {
-    scrub(text: string): string;
-    scrubObject<T>(obj: T): T;
-}
-
-export type { PermissionDecision as P, SecretScrubber as S, TrustPolicy as T, PermissionPolicy as a };
+export type { PermissionDecision as P, TrustPolicy as T, PermissionPolicy as a };