@wrongstack/cli 0.284.1 → 0.285.0

package/dist/fleet/host.d.ts

@@ -0,0 +1,533 @@
+import type { BrainArbiter, SubagentRunner } from '@wrongstack/core';
+import { type AgentFactory, type Config, type ConfigStore, type Container, Director, EventBus, type ModelsRegistry, type ProviderRegistry, type SessionWriter, type SystemPromptBuilder, type TaskResult, type TokenCounter, ToolRegistry } from '@wrongstack/core';
+export interface MultiAgentDeps {
+    container: Container;
+    toolRegistry: ToolRegistry;
+    providerRegistry: ProviderRegistry;
+    configStore: ConfigStore;
+    /**
+     * Models catalog used to resolve a subagent provider's real context
+     * window. Without it, an `openai-compatible` subagent (DeepSeek, Groq,
+     * …) falls back to the 32k family default and the fleet panel reports
+     * the wrong window per subagent. Optional so callers/tests that don't
+     * wire it still build providers (the family default applies).
+     */
+    modelsRegistry?: ModelsRegistry | undefined;
+    events: EventBus;
+    systemPromptBuilder: SystemPromptBuilder;
+    session: SessionWriter;
+    tokenCounter: TokenCounter;
+    projectRoot: string;
+    cwd: string;
+    secretScrubber: import('@wrongstack/core').SecretScrubber;
+    renderer?: import('@wrongstack/core').Renderer | undefined;
+}
+/**
+ * Per-session options that flip the orchestration mode. Director mode
+ * routes lifecycle through a `Director`, which unlocks manifest writing
+ * and FleetBus observability. When Director mode is off, public subagent
+ * spawn/delegate surfaces stay disabled until an explicit `/director`
+ * promotion flips the flag.
+ */
+export interface MultiAgentHostOptions {
+    /**
+     * Enable Director-backed orchestration. The host still exposes the same
+     * `spawn` / `status` / `usage` / `kill` API; under the hood, calls flow
+     * through a `Director` so manifest writing works and the FleetBus is
+     * available for future observability hooks.
+     */
+    directorMode?: boolean | undefined;
+    /**
+     * Absolute file path the director writes its fleet manifest to on
+     * shutdown (and on-demand via `manifest()`). Only meaningful when
+     * `directorMode` is true; ignored otherwise.
+     */
+    manifestPath?: string | undefined;
+    /**
+     * Absolute path to the fleet's shared scratchpad directory. When set,
+     * subagent system prompts are augmented with a "Shared notes" block
+     * pointing here so agents can pass conclusions through the filesystem
+     * without going through the bridge. Directory is created on first
+     * spawn. Only meaningful in director mode.
+     */
+    sharedScratchpadPath?: string | undefined;
+    /**
+     * Absolute path to the directory under which per-subagent JSONL
+     * transcripts land — typically
+     * `<projectSessions>/<date>/sess_<ULID>/subagents/`.
+     * When set, the host builds a `DirectorSessionFactory` rooted there and
+     * each spawned subagent gets its own session writer (instead of sharing
+     * the parent session). Director mode only.
+     */
+    sessionsRoot?: string | undefined;
+    /**
+     * Director run id for namespacing per-subagent JSONLs. Defaults to the
+     * coordinator id when omitted. Pass an explicit id when resuming from a
+     * prior fleet manifest.
+     */
+    directorRunId?: string | undefined;
+    /**
+     * Base directory for fleet artifacts (manifest, shared scratchpad,
+     * subagent sessions). When set and director mode is promoted at runtime
+     * (via /director), paths are derived as:
+     *   <fleetRoot>/fleet.json        (manifest)
+     *   <fleetRoot>/shared/           (scratchpad)
+     *   <fleetRoot>/subagents/        (per-subagent JSONL)
+     */
+    fleetRoot?: string | undefined;
+    /**
+     * Absolute path the director writes its live state checkpoint to. Distinct
+     * from `manifestPath` (final record) — the checkpoint mirrors pending /
+     * running / completed tasks on every mutation so `wstack resume` can show
+     * a "you had N tasks in flight" banner after a crash. Only meaningful in
+     * director mode.
+     */
+    stateCheckpointPath?: string | undefined;
+    /**
+     * Fleet-wide cost ceiling for the director. When set, the director
+     * refuses any new spawn that would push total fleet spend above this
+     * limit. In-flight subagents complete normally; only new spawns are
+     * blocked. Only meaningful in director mode.
+     */
+    directorBudget?: {
+        maxCostUsd?: number | undefined;
+        maxTokens?: number | undefined;
+    };
+    /** Lifetime spawn cap for this Director. CLI default: 64. */
+    maxSpawns?: number | undefined;
+    /**
+     * Maximum auto-extensions per subagent per budget kind before the
+     * director denies further extensions. Default: 2. Only meaningful in
+     * director mode.
+     */
+    maxBudgetExtensions?: number | undefined;
+    /** Optional global Brain arbiter for director-level policy decisions. */
+    brain?: BrainArbiter | undefined;
+    /**
+     * Maximum number of subagent tasks that may run concurrently. Extra
+     * tasks queue in the coordinator's pending list and dispatch as slots
+     * free. Default: 4. Raising this lets more work proceed in parallel
+     * at the cost of provider rate-limit pressure (each subagent makes
+     * its own API calls).
+     */
+    maxConcurrent?: number | undefined;
+    /**
+     * Maximum time a spawned/between-task subagent may remain idle before it is
+     * removed from the Director and every live registry surface. Default: 30s.
+     */
+    subagentIdleTimeoutMs?: number | undefined;
+    /** Retire a completed one-shot subagent immediately when it stays idle. */
+    retireSubagentOnTaskComplete?: boolean | undefined;
+    /**
+     * Live max context window for the leader model. Director spawn guards read
+     * this lazily so runtime provider/model switches do not leave the fleet
+     * using the launch-time family default.
+     */
+    getLeaderMaxContext?: (() => number) | undefined;
+    /**
+     * Debounce window for state-checkpoint writes in milliseconds.
+     * Default: 250. Only meaningful in director mode.
+     */
+    checkpointDebounceMs?: number | undefined;
+    /**
+     * Session writer the director forwards task lifecycle events to
+     * (agent_spawned, task_created, task_completed, task_failed). The CLI
+     * passes the same writer the host Agent uses so all events land in one
+     * JSONL. Optional — when omitted, those events stay in-memory.
+     */
+    sessionWriter?: import('@wrongstack/core').SessionWriter | undefined;
+    /**
+     * Root session trace ID for correlating subagent storage events with
+     * the parent session's trace in observability pipelines.
+     */
+    traceId?: string | undefined;
+    /**
+     * Optional AgentMonitorService for tracking subagent conversations.
+     * When set, the host calls trackSubagent on spawn and completeSubagent
+     * on completion, and starts the monitor's FleetBus listener.
+     */
+    agentMonitor?: import('@wrongstack/core/coordination').AgentMonitorService | undefined;
+    /**
+     * Called when the host auto-starts the Shadow Agent. The CLI uses this to
+     * keep /shadow duplicate checks in sync with the background auto-start path.
+     */
+    onShadowAgentStarted?: ((subagentId: string) => void) | undefined;
+    /**
+     * Called when the tracked Shadow Agent stops, so command surfaces do not keep
+     * treating a stale subagent id as active.
+     */
+    onShadowAgentStopped?: ((subagentId: string) => void) | undefined;
+    /**
+     * Resolved shared-mailbox project directory (`~/.wrongstack/projects/<slug>`)
+     * — the SAME directory the leader's mailbox checker attaches to (see
+     * `resolveProjectDir` + `wstackGlobalRoot`). Used for the fire-and-forget
+     * task-result report-back and the subagent online-agents block. When
+     * omitted, both fall back to `resolveProjectDir(deps.projectRoot, ...)`
+     * computed here.
+     */
+    mailboxProjectDir?: string | undefined;
+    /**
+     * Mailbox id of THIS session's leader, for task-result report-back.
+     * Defaults to `leader@<sessionTag(session.id)>` — the exact identity the
+     * CLI leader registers under (wiring/session.ts pins agentId: 'leader').
+     * Override for embedders whose leader uses a custom base id.
+     */
+    getLeaderMailboxId?: (() => string | undefined) | undefined;
+}
+/**
+ * Lazy holder — created on first /spawn call, reused across the session
+ * so /agents can list everyone running.
+ */
+export declare class MultiAgentHost {
+    private readonly deps;
+    private director?;
+    /** Own FleetManager — created in buildDirector(), used for pending task
+     *  tracking so status() can show descriptions without host-side state. */
+    private fleetManager?;
+    /** Own FleetEmitTool — created in buildDirector() so subagents in director
+     *  mode can publish structured events (bug.found, refactor.plan,
+     *  critic.evaluation) onto the fleet bus without needing the tool registered
+     *  in the host's ToolRegistry. */
+    private fleetEmitTool?;
+    /** Director-owned tools available to scoped subagents even when the leader
+     * ToolRegistry was not populated because director mode was promoted lazily. */
+    private directorToolsByName;
+    /** Lazily built alongside the director — produces per-subagent JSONL
+     *  writers under `<sessionsRoot>/<runId>/`. Null without sessionsRoot. */
+    private sessionFactory?;
+    private readonly opts;
+    /**
+     * Populated by `promoteToDirector` when it refuses to promote. The delegate
+     * tool reads this through `getPromotionBlockReason` to render an
+     * actionable error instead of a generic "Director could not be activated".
+     */
+    private promotionBlockReason;
+    /** Guards `buildDirector` from overwriting a runner set by `spawnACP`. */
+    private directorRunnerSet;
+    /** Event-bus off-handles registered in `buildDirector` — cleaned up in `dispose()`. */
+    private readonly directorOffHandles;
+    /** Coordinator task.assigned listener — cleaned up in `dispose()`. */
+    private coordinatorOffHandle;
+    /** ACP runner cache — keyed by role/subagentId, reused across tasks to avoid
+     *  creating a new transport process on every ACP task dispatch. Stores the
+     *  pending promise so concurrent calls for the same subagentId share one spawn.
+     *  Bounded to 20 entries with LRU eviction to prevent unbounded memory growth. */
+    private readonly acpRunnerCache;
+    private readonly acpRunnerAccessOrder;
+    private static readonly ACP_CACHE_MAX;
+    /** Adaptive concurrency controller — created in buildDirector() when config has
+     *  adaptiveConcurrency.enabled = true. Monitors FleetBus for 429 errors and
+     *  automatically adjusts maxConcurrent to prevent rate limiting. */
+    private adaptiveConcurrencyController?;
+    /** Active Shadow Agent spawned by the host or /shadow start. */
+    private shadowAgentId;
+    /** Assigned monitoring task for the active Shadow Agent. */
+    private shadowTaskId;
+    /** All internal Shadow Agent startup/heartbeat task ids, excluded from fleet summaries. */
+    private readonly shadowTaskIds;
+    /** Shadow task ids assigned but not yet completed. Prevents heartbeat backlog. */
+    private readonly shadowOutstandingTaskIds;
+    /** Shadow task ids whose subagent should stop immediately after the one-shot pass. */
+    private readonly shadowStopAfterTaskIds;
+    private shadowHeartbeatIntervalMs;
+    /** Suppresses buildDirector() auto-start while /shadow start is explicitly spawning one. */
+    private shadowAutoStartSuppressions;
+    private shadowObservedWorkDepth;
+    private shadowPassInFlight;
+    private shadowQueuedProblem;
+    private readonly shadowActivityOffHandles;
+    /** Peer-awareness status broadcaster (mailbox `status` mails on subagent
+     *  transitions + rich registry heartbeats). Started in buildDirector(),
+     *  stopped in dispose(). */
+    private statusBroadcaster;
+    /** Brain-gated FleetSupervisor over this director's fleet. Built in
+     *  buildDirector() (when a BrainArbiter is available), stopped in
+     *  dispose(). Also published to the supervisor registry for /supervisor. */
+    private fleetSupervisor;
+    constructor(deps: MultiAgentDeps, opts?: MultiAgentHostOptions);
+    /**
+     * Force the lazy build path to run *now* and return the live Director,
+     * or null when director mode is off. Used by the CLI to register the
+     * fleet's LLM-callable orchestration tools (spawn_subagent,
+     * assign_task, await_tasks, ask_subagent, roll_up, terminate_subagent,
+     * fleet, fleet) into the leader's ToolRegistry before the
+     * agent starts — without this, the leader literally cannot see the
+     * orchestration tools and `--director` becomes a no-op.
+     */
+    ensureDirector(): Promise<Director | null>;
+    /** Access the Director's internal coordinator. Returns the concrete
+     *  `DefaultMultiAgentCoordinator` so callers can use class-only surface
+     *  (`on`, `setRunner`) that isn't part of the `MultiAgentCoordinator`
+     *  interface. */
+    private getCoordinator;
+    /** Public accessor for the Director — used by buildRoutingRunner. */
+    getDirector(): Director | undefined;
+    private ensureCoordinator;
+    private buildDirector;
+    /**
+     * Arm host-owned Shadow observation. Healthy work windows stay fully
+     * deterministic; a one-shot LLM Shadow pass runs only after problematic work
+     * finishes, or when the user explicitly invokes /shadow start.
+     */
+    private armShadowAgentIfNeeded;
+    private recordShadowAgent;
+    private clearShadowAgent;
+    private markShadowTask;
+    private isActiveSubagent;
+    private noteShadowWorkStarted;
+    private noteShadowWorkCompleted;
+    private requestShadowPass;
+    private runShadowPass;
+    private stopShadowAfterTask;
+    /**
+     * Returns the FleetEmitTool for director-mode subagents, if the director
+     * has been built. Used by makeSubagentFactory to inject the tool into
+     * the filtered tool registry so collab session agents can emit fleet events.
+     */
+    getFleetEmitTool(): import('@wrongstack/core').Tool | undefined;
+    /**
+     * Build a per-role subagent factory: given a SubagentConfig, construct a
+     * fresh, isolated Agent with the role's filtered tools and (when the config
+     * carries one) the role's persona as an appended system-prompt block. Public
+     * so the autonomy-parallel engine can reuse the exact same agent-construction
+     * path the director/spawn flow uses — each parallel slot then runs as a real,
+     * specialized, concurrency-safe agent instead of sharing the leader's Context.
+     */
+    makeSubagentFactory(config: Config): AgentFactory;
+    /**
+     * Build the per-subagent runner.
+     *
+     * ACP agents (provider: 'acp') get their own runner via
+     * makeACPSubagentRunner — they run external processes and don't go
+     * through the Agent factory. Regular agents use the standard
+     * makeAgentSubagentRunner path.
+     */
+    buildSubagentRunner(config: Config): Promise<SubagentRunner>;
+    buildACPRunner(subagentId: string): Promise<SubagentRunner>;
+    /**
+     * Build a Provider for a subagent. When `overrideId` is supplied (from
+     * `SubagentConfig.provider`), looks that provider up in
+     * `config.providers` and constructs it with its own apiKey/baseUrl.
+     * Falls back to the leader's provider when `overrideId` is absent or
+     * not configured (so a typo doesn't crash the whole run — we just
+     * use the leader and the calling code can decide to error later).
+     */
+    private buildSubagentProvider;
+    private resolveSubagentReasoningConfig;
+    spawnACP(subagentId: string, task: string, config: Config): Promise<string>;
+    /** Returns a tool slice for the subagent — full set unless restricted. */
+    private filterTools;
+    /**
+     * Resolve the capability allowlist for a subagent's auto-approve policy.
+     *
+     * Precedence:
+     *   1. Explicit `subCfg.allowedCapabilities` — the spawn site knows best
+     *      (e.g. `/techstack` grants exactly `fs.write` on top of the safe set).
+     *   2. A scoped `subCfg.tools` slice — the granted tool slice IS the intended
+     *      capability grant. The leader/roster deliberately chose these tools, so
+     *      allow exactly the capabilities they declare (plus the read-only safe
+     *      floor). Without this, a role given the `write`/`build` tool presets
+     *      could *see* those tools but the policy would deny execution (`fs.write`
+     *      and `shell.*` are not in the read-only default), silently crippling
+     *      every code-writing / build role in the catalog.
+     *   3. No tool restriction (full registry) → the WIDE working set
+     *      (`WIDE_SUBAGENT_CAPABILITIES`: read, write, net, shell, install,
+     *      session todo, tool metadata, read-only memory). The user authorized full
+     *      developer work when they invoked the leader, so a delegated agent runs
+     *      the same toolchain end-to-end. The genuinely blast-radius-escaping
+     *      capabilities (fs.write.outside-project, tool.mutate.any, memory writes,
+     *      mcp.proxy, subagent.spawn, config.mutate) stay off and need an explicit
+     *      (1) grant.
+     */
+    private resolveSubagentCapabilities;
+    /** Resolved shared-mailbox project dir — same as the leader's checker. */
+    private mailboxProjectDir;
+    /**
+     * Construct + start the brain-gated FleetSupervisor over this director's
+     * fleet. Requires a BrainArbiter (production always wires one); without
+     * it there is no safe decision path, so supervision stays off. All
+     * actions flow through Director APIs — the supervisor never touches
+     * coordinator internals or budget negotiation.
+     */
+    private buildFleetSupervisor;
+    /**
+     * Fire-and-forget report-back (wired as the Director's
+     * `taskResultNotifier`): posts a non-awaited task's outcome to THIS
+     * session's leader via the project mailbox. The leader's mailbox checker
+     * injects it inline before the next step, so `assign_task`-without-await
+     * results reach the conversation without polling. The body carries a
+     * short excerpt only — the full result stays in the director's completed
+     * cache, retrievable via `await_tasks`/`roll_up`.
+     */
+    private reportTaskResultToLeader;
+    private subagentToolRegistry;
+    /**
+     * Spawn a fresh subagent and assign a single task. Returns task id.
+     *
+     * Optional `opts` lets the caller (a `/spawn` slash command or the
+     * future director surface) override the subagent's provider, model,
+     * and tool slice on a per-spawn basis. Without options, the legacy
+     * behavior holds: the subagent uses the leader's provider/model and
+     * the full tool registry.
+     */
+    spawn(description: string, opts?: {
+        provider?: string | undefined;
+        model?: string | undefined;
+        fallbackModels?: string[] | undefined;
+        tools?: string[] | undefined;
+        name?: string | undefined;
+        allowedCapabilities?: readonly string[] | undefined;
+        shadowIntervalMs?: number | undefined;
+    }): Promise<{
+        subagentId: string;
+        taskId: string;
+    }>;
+    /**
+     * Spawn a fresh subagent, assign a task, and **await** its completion.
+     *
+     * Unlike `spawn()`, which returns immediately with spawn metadata, this
+     * method blocks until the subagent finishes (success, failure, or timeout)
+     * and returns the full `TaskResult`. Use this when the caller needs the
+     * subagent's actual output — e.g. `/techstack` displaying the generated report
+     * in chat, or `/spawn` showing the result inline.
+     *
+     * Optional `opts` lets the caller override the subagent's provider, model,
+     * and tool slice per spawn.
+     */
+    spawnAndWait(description: string, opts?: {
+        provider?: string | undefined;
+        model?: string | undefined;
+        fallbackModels?: string[] | undefined;
+        tools?: string[] | undefined;
+        name?: string | undefined;
+        allowedCapabilities?: readonly string[] | undefined;
+    }): Promise<TaskResult>;
+    /**
+     * Common spawn + assign logic shared by both director mode and raw
+     * coordinator mode. Extracts the identical body from the two branches
+     * in `spawn()` so future changes (e.g. adding a new field to both
+     * paths) are made in one place.
+     *
+     * Returns `{ subagentId, taskId }`. Caller holds `pending` tracking
+     * and event emission — the helper only talks to the coordinator.
+     */
+    private _spawnAndAssign;
+    /**
+     * Relay a `task.completed` notification (from either the Director or
+     * the raw coordinator) to the EventBus so non-director TUIs and any
+     * other observer can react. We forward the full result shape rather
+     * than mutating the existing `task.completed` schema — coordination
+     * code already binds to that event, and adding subscribers there
+     * would change ordering semantics for those listeners.
+     */
+    private emitLifecycleCompleted;
+    status(): {
+        pending: {
+            taskId: string;
+            description: string;
+            subagentId: string;
+        }[];
+        completed: TaskResult[];
+        live: {
+            subagentId: string;
+            status: string;
+            task?: string | undefined;
+        }[];
+        summary: string;
+    };
+    /**
+     * Roll up per-subagent runtime cost from completed TaskResults. We don't
+     * yet have FleetUsageAggregator wired into the simple MultiAgentHost
+     * path (that lives on `Director`), so this aggregates iterations / tool
+     * calls / duration which we *do* have — enough to spot a thrashing
+     * worker without paying for a heavier orchestrator on every /spawn.
+     *
+     * Returns rows sorted by total duration descending (slowest first) so
+     * the table renders the most interesting subagent at the top.
+     */
+    usage(): {
+        rows: Array<{
+            subagentId: string;
+            tasks: number;
+            iterations: number;
+            toolCalls: number;
+            durationMs: number;
+            status: string;
+        }>;
+        totals: {
+            tasks: number;
+            iterations: number;
+            toolCalls: number;
+            durationMs: number;
+        };
+    };
+    /**
+     * Force the director to write its manifest to disk and return the path,
+     * or `null` when director mode is off (the simple coordinator path has
+     * no manifest). Callers should fall back to a friendly user message
+     * when `null` is returned — e.g. `/fleet manifest` does this already.
+     *
+     * The returned string is the absolute path of the manifest file. The
+     * file contents are JSON; readers can `JSON.parse(fs.readFileSync(...))`
+     * to consume.
+     */
+    manifest(): Promise<string | null>;
+    /**
+     * Promote a non-director session to director mode at runtime. Only
+     * succeeds when no subagents have been spawned yet — once a coordinator
+     * is running, the state cannot be migrated. Returns the live Director
+     * so the caller can register orchestration tools into the ToolRegistry.
+     *
+     * Idempotent: calling promoteToDirector on an already-promoted host
+     * returns the existing director without side effects.
+     */
+    promoteToDirector(): Promise<Director | null>;
+    /**
+     * True when this host is running in director mode. Surfaces the mode
+     * to slash commands and tests without exposing the underlying Director
+     * (which would let callers bypass the host's coordination layer).
+     */
+    isDirectorMode(): boolean;
+    /**
+     * Why the most recent `promoteToDirector` call returned null. Cleared
+     * implicitly on the next successful promotion. The delegate tool reads
+     * this so the LLM sees the actual blocker (e.g. "3 running subagents,
+     * wait or /fleet kill") instead of a generic "Director could not be
+     * activated" message that gives no path forward.
+     */
+    getPromotionBlockReason(): string | null;
+    /**
+     * Terminate a single subagent. Returns true when the subagent existed
+     * (regardless of whether stop() succeeded or it was already idle),
+     * false when no coordinator has been created yet — meaning the user
+     * called /fleet kill before any /spawn, and there's nothing to do.
+     */
+    kill(subagentId: string): Promise<boolean>;
+    stopAll(): Promise<void>;
+    /**
+     * Current effective concurrent-subagent ceiling. Reads the live
+     * coordinator config when the director is built; otherwise falls back
+     * to the constructor option (or the default of 4 that buildDirector
+     * will apply on first /spawn).
+     */
+    getMaxConcurrent(): number;
+    /**
+     * Change the concurrent-subagent ceiling at runtime. Updates the
+     * constructor option (so lazy-built director picks it up) and, if the
+     * coordinator already exists, mutates its live config + triggers a
+     * dispatch pass so newly-allowed slots fill immediately.
+     *
+     * Throws on non-positive values; the caller is expected to validate
+     * user input first.
+     */
+    setMaxConcurrent(n: number): void;
+    /**
+     * Clean up all listeners and resources held by the host.
+     * Unregisters all EventBus/FleetBus listeners registered in `buildDirector`
+     * and stops the Director and its coordinator.
+     *
+     * Safe to call multiple times — subsequent calls are no-ops.
+     */
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=host.d.ts.map

package/dist/fleet/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/fleet/host.ts"],"names":[],"mappings":"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"}

package/dist/fleet/routing.d.ts

@@ -0,0 +1,8 @@
+import type { SubagentRunner } from '@wrongstack/core';
+import { type Config } from '@wrongstack/core';
+import type { MultiAgentHost } from './host.js';
+/**
+ * Routing runner — dispatches tasks to standard or ACP runner based on provider.
+ */
+export declare function buildRoutingRunner(config: Config, host: MultiAgentHost): SubagentRunner;
+//# sourceMappingURL=routing.d.ts.map

package/dist/fleet/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/fleet/routing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,cAAc,EAAY,MAAM,kBAAkB,CAAC;AACrF,OAAO,EACL,KAAK,MAAM,EAKZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,cAAc,CAevF"}

package/dist/fleet/status-broadcast.d.ts

@@ -0,0 +1,42 @@
+/**
+ * status-broadcast — mailbox broadcasts on meaningful subagent transitions.
+ *
+ * The third leg of peer awareness (with the fleet-pulse digest and the
+ * fleet_status tool): when a fleet subagent joins, completes a task, or
+ * hits budget pressure, a low-priority `type:'status'` broadcast lands in
+ * the project mailbox so every OTHER agent — including agents in other
+ * processes on the same project — sees it on its next iteration.
+ *
+ * It also keeps the mailbox registry heartbeat rich: task start/stop
+ * transitions push `currentTask`/`status` into the registry, which is what
+ * makes the fleet-pulse digest and `fleet_status` show WHAT each fleet
+ * worker is doing cross-process (the plain interval heartbeat only proves
+ * liveness).
+ *
+ * Spam control:
+ *   - per-subagent min interval (terminal statuses coalesce: the newest
+ *     replaces the pending one rather than being dropped)
+ *   - global per-minute cap (excess dropped + counted; the next allowed
+ *     broadcast reports how many were dropped)
+ *   - one-shot events (spawned, budget_warning per kind) dedup themselves
+ *
+ * @module fleet/status-broadcast
+ */
+import type { EventBus, Mailbox } from '@wrongstack/core';
+import type { FleetConfig } from '@wrongstack/core';
+export interface FleetStatusBroadcasterOptions {
+    /** Host EventBus carrying the re-emitted `subagent.*` lifecycle events. */
+    events: EventBus;
+    /** Lazily construct the project mailbox (created once, on first use). */
+    mailboxFactory: () => Mailbox;
+    /** Session tag provider for the `fleet@<tag>` sender identity. */
+    sessionTag: () => string;
+    /** Nickname lookup for a subagent id (falls back to the raw id). */
+    subagentName?: ((subagentId: string) => string | undefined) | undefined;
+    config?: FleetConfig['statusBroadcasts'] | undefined;
+}
+export declare function createFleetStatusBroadcaster(opts: FleetStatusBroadcasterOptions): {
+    start(): void;
+    stop(): void;
+};
+//# sourceMappingURL=status-broadcast.d.ts.map

package/dist/fleet/status-broadcast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-broadcast.d.ts","sourceRoot":"","sources":["../../src/fleet/status-broadcast.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,WAAW,6BAA6B;IAC5C,2EAA2E;IAC3E,MAAM,EAAE,QAAQ,CAAC;IACjB,yEAAyE;IACzE,cAAc,EAAE,MAAM,OAAO,CAAC;IAC9B,kEAAkE;IAClE,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,oEAAoE;IACpE,YAAY,CAAC,EAAE,CAAC,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;IACxE,MAAM,CAAC,EAAE,WAAW,CAAC,kBAAkB,CAAC,GAAG,SAAS,CAAC;CACtD;AAYD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,6BAA6B,GAAG;IACjF,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;CACd,CA0JA"}

package/dist/fleet/supervisor-registry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * supervisor-registry — process-wide handle to the active FleetSupervisor.
+ *
+ * The supervisor is built lazily inside `MultiAgentHost.buildDirector()`
+ * (the Director itself is lazy), long after the slash commands were
+ * registered — so `/supervisor` cannot receive it by constructor
+ * injection. This module is the same indirection `getSddRun` uses for the
+ * live SDD run: the host sets the handle when the supervisor starts,
+ * clears it on dispose, and the slash command reads it at execution time.
+ *
+ * @module fleet/supervisor-registry
+ */
+import type { FleetSupervisor } from '@wrongstack/core';
+export declare function setActiveFleetSupervisor(supervisor: FleetSupervisor | null): void;
+export declare function getActiveFleetSupervisor(): FleetSupervisor | null;
+//# sourceMappingURL=supervisor-registry.d.ts.map

package/dist/fleet/supervisor-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-registry.d.ts","sourceRoot":"","sources":["../../src/fleet/supervisor-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAIxD,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,GAAG,IAAI,CAEjF;AAED,wBAAgB,wBAAwB,IAAI,eAAe,GAAG,IAAI,CAEjE"}