@wrongstack/core 0.284.0 → 0.285.0

package/dist/coordination/index.d.ts

@@ -1,2587 +1,78 @@
-import { H as FleetManager, s as Director } from '../null-fleet-bus-CFoNVQEK.js';
-export { A as ACP_AGENTS, a as AGENTS_BY_PHASE, b as AGENT_CATALOG, c as ALL_AGENT_DEFINITIONS, d as ALL_FLEET_AGENTS, e as AUDIT_LOG_AGENT, f as AutoExtendCeiling, g as AutoExtendPolicy, B as BUG_HUNTER_AGENT, h as BugFinding, C as CollabBudgetConfig, i as CollabBudgetOverrides, j as CollabBudgetWarningPayload, k as CollabDebugReport, l as CollabSession, m as CollabSessionOptions, n as CreateDelegateToolOptions, o as CriticConcern, p as CriticEvaluation, D as DEFAULT_DIRECTOR_PREAMBLE, q as DEFAULT_SUBAGENT_BASELINE, r as DelegateHost, t as DirectorAlert, u as DirectorAlertLevel, v as DirectorCancelCollabPayload, w as DirectorPromptParts, x as DirectorSessionFactory, y as DirectorSessionFactoryOptions, F as FLEET_ROSTER, z as FLEET_ROSTER_BUDGETS, E as FLEET_ROSTER_WITHACP, G as FleetCostCapError, I as FleetManagerOptions, J as FleetRosterBudget, K as FleetSpawnBudgetError, L as FleetTokenCapError, M as FleetWorktreePolicy, N as ICoordinator, O as IFleetManager, P as InMemoryAgentBridge, Q as InMemoryBridgeTransport, R as LargeAnswerStore, S as NULL_FLEET_BUS, T as REFACTOR_PLANNER_AGENT, U as RefactorPhase, V as RefactorPlan, W as SECURITY_SCANNER_AGENT, X as SharedFileEntry, Y as SharedFileSnapshot, Z as SubagentPromptParts, _ as TaskResultNotification, $ as WorktreeIntegrationError, a0 as WorktreeIsolationDecision, a1 as WorktreeTaskRunnerOptions, a2 as WorktreeTaskStateUpdate, a3 as applyRosterBudget, a4 as attachAutoExtend, a5 as composeDirectorPrompt, a6 as composeSubagentPrompt, a7 as createDelegateTool, a8 as createMessage, a9 as getAgentDefinition, aa as makeAskResultTool, ab as makeAskTool, ac as makeAssignTool, ad as makeAwaitTasksTool, ae as makeCollabDebugTool, af as makeDirectorSessionFactory, ag as makeFleetEmitTool, ah as makeFleetHealthTool, ah as makeFleetSessionTool, ah as makeFleetTool, ah as makeFleetUsageTool, ai as makeKanbanQueueTool, aj as makeQualityGateTool, ak as makeRollUpTool, al as makeSpawnTool, am as makeTerminateAllTool, an as makeTerminateTool, ao as makeWorkCompleteTool, ap as resolveSubagentWorktreeDecision, aq as rosterSummaryFromConfigs, ar as subagentNeedsWorktree, as as wrapSubagentRunnerWithWorktrees } from '../null-fleet-bus-CFoNVQEK.js';
-import { h as AgentDefinition, F as FleetBus, T as TaskSpec, ai as SubagentStructuredReport } from '../multi-agent-coordinator-4RCRZKjN.js';
-export { z as AGENT_TOOL_PRESETS, E as AgentBudgetTier, G as AgentCapability, a as AgentFactory, H as AgentFactoryResult, g as AgentPhase, I as AgentRunnerOptions, J as BudgetExceededError, K as BudgetKind, L as BudgetLimits, N as BudgetNegotiationMode, O as BudgetThresholdDecision, Q as BudgetThresholdHandler, R as BudgetThresholdSignal, U as BudgetUsage, W as DECISION_TIMEOUT_MS, X as DEFAULT_DISPATCH_ROLE, b as DefaultMultiAgentCoordinator, Y as DispatchCandidate, D as DispatchClassifier, Z as DispatchMethod, _ as DispatchOptions, $ as DispatchResult, a0 as FleetEvent, a1 as FleetHandler, j as FleetUsage, k as FleetUsageAggregator, a2 as HEAVY_BUDGET, a3 as LIGHT_BUDGET, a4 as MEDIUM_BUDGET, a6 as MultiAgentCoordinatorOptions, aa as SubagentBudget, aj as SubagentUsageSnapshot, ak as TIMEOUT_PREEMPT_FRACTION, am as dispatchAgent, an as makeAgentSubagentRunner, ao as makeLLMClassifier, ap as scoreAgents, aq as withDisabledToolFiltering } from '../multi-agent-coordinator-4RCRZKjN.js';
-import { E as EventBus, B as BrainArbiter, f as BrainDecisionOption, k as BrainRisk, h as BrainDecisionRequest, e as BrainDecision, i as BrainDecisionSource } from '../events-Bgnh43r9.js';
-export { g as BrainDecisionQueue, j as BrainFallback, D as DefaultBrainArbiter, l as DefaultBrainArbiterOptions, H as HumanEscalatingBrainArbiter, O as ObservableBrainArbiter, w as formatHumanPrompt } from '../events-Bgnh43r9.js';
-import { b as Mailbox, c as MailboxSendInput, M as MailboxMessage, d as MailboxQuery, e as MailboxAckInput, f as MailboxAckBatchInput, a as MailboxAgentStatus, A as AgentRegistrationInput, g as AgentHeartbeatInput, P as PurgeOptions, j as PurgeResult, C as ClientRegistrationInput, h as ClientHeartbeatInput, i as ClientStatus } from '../mailbox-types-BGZWrYTJ.js';
-export { k as ClientSource, l as MailboxMessageType, m as MailboxTaskContext, R as ReadReceipts, n as RegisteredAgent, o as normalizeRecipient } from '../mailbox-types-BGZWrYTJ.js';
-import { A as AgentEntry } from '../session-registry-Dvg7i_IA.js';
-import { d as Context, g as Tool } from '../tool-BNlnIJvo.js';
-import { O as FleetSupervisorConfig, a as ModelMatrixEntry, j as Config, A as AdaptiveConcurrencyConfig } from '../config-MRqn1V-u.js';
-import { G as GlobalMailbox } from '../global-mailbox-sZwyI6CS.js';
-export { aA as resolveProjectDir } from '../global-mailbox-sZwyI6CS.js';
-import { L as Logger } from '../logger-B63L5bTg.js';
-import 'node:events';
-import '../director-state-CMS_bMs4.js';
-import '../worktree-manager-DzwxKE35.js';
-import '../index--Gm41aBJ.js';
-import '../pipeline-DGDyIohT.js';
-import '../permission-ByDKXEcG.js';
-import '../observability-D-HZN_mF.js';
-import '../secret-scrubber-3MHDDAtm.js';
-import '../retry-policy-CQ7KwXJa.js';
-
-/** Phase 1 · Discovery — map the territory before any work begins. */
-declare const DISCOVERY_AGENTS: AgentDefinition[];
-
-/** Phase 2 · Planning — turn intent into requirements, plans, and architecture. */
-declare const PLANNING_AGENTS: AgentDefinition[];
-
-/** Phase 3 · Build — write, refactor, migrate, and fix code. */
-declare const BUILD_AGENTS: AgentDefinition[];
-
-/** Phase 4 · Verify — prove the code works under normal, end-to-end, and adverse conditions. */
-declare const VERIFY_AGENTS: AgentDefinition[];
-
-/** Phase 5 · Review — read-only quality, security, a11y, and compliance gates. */
-declare const REVIEW_AGENTS: AgentDefinition[];
-
-/** Phase 6 · Domain — specialists for the major slices of a system. */
-declare const DOMAIN_AGENTS: AgentDefinition[];
-
-/** Phase 7 · Knowledge — documentation, diagrams, localization, and prompts. */
-declare const KNOWLEDGE_AGENTS: AgentDefinition[];
-
-/** Phase 8 · Delivery & Ops — ship it, run it, keep it healthy. */
-declare const DELIVERY_AGENTS: AgentDefinition[];
-
-/** Phase 9 · Meta — agents that improve the agent system itself. */
-declare const META_AGENTS: AgentDefinition[];
-
-/**
- * BrainMonitor — the Brain's SELF-ACTIVATION layer.
- *
- * The BrainArbiter alone is reactive: subsystems (director, autophase,
- * eternal engine) ask it questions. The monitor closes the loop the other
- * way — it WATCHES the live EventBus for distress signals, consults the
- * Brain proactively, and when the decision calls for it, INTERVENES in the
- * running work by delivering a corrective steer to the working agent
- * (steers are folded into the agent's conversation before its next step
- * via the mailbox loop, so no new plumbing is needed).
- *
- * Watched signals (v1):
- *   - tool-failure streak — the same tool failing N times consecutively
- *     (default 3). Classic stuck-loop: the agent keeps retrying an
- *     approach that does not work.
- *   - error storm — N `error` events within a sliding window (default
- *     4 in 60s). Something is systematically wrong.
- *
- * Decision contract: every consultation offers [steer | continue] with
- * fallback `continue`, at `medium` risk. Degradation is safe by design:
- *   - tiered brain with an LLM layer → a real judgement call, with the
- *     LLM's rationale becoming the steer text;
- *   - policy-only brain → fallback `continue` → observe, never interfere.
- *
- * Every engagement (whether or not it intervened) emits
- * `brain.intervention` for the TUI/WebUI surfaces, and is rate-limited by
- * a per-signal cooldown so the Brain never spams the agent.
- *
- * @module brain-monitor
- */
-
-interface BrainInterventionInput {
-    subject: string;
-    body: string;
-}
-interface BrainMonitorOptions {
-    events: EventBus;
-    brain: BrainArbiter;
-    /** Active host session id, read lazily so resume/new-session switches are reflected. */
-    sessionId?: (() => string | undefined) | undefined;
-    /**
-     * Deliver a corrective steer to the working agent(s). Hosts typically
-     * send a `steer` mail to this session's leader via the project
-     * GlobalMailbox — the agent loop injects it before the next LLM call.
-     */
-    intervene: (input: BrainInterventionInput) => Promise<void>;
-    /** Consecutive failures of the SAME tool before engaging. Default 3. */
-    toolFailureStreak?: number | undefined;
-    /** Number of `error` events within the window before engaging. Default 4. */
-    errorStormCount?: number | undefined;
-    /** Sliding window for the error storm signal (ms). Default 60_000. */
-    errorStormWindowMs?: number | undefined;
-    /** Minimum gap between engagements of the same signal kind (ms). Default 120_000. */
-    cooldownMs?: number | undefined;
-}
-declare class BrainMonitor {
-    private readonly opts;
-    private readonly failStreaks;
-    private errorTimestamps;
-    private readonly lastEngagedAt;
-    private readonly unsubscribers;
-    private engaging;
-    private readonly toolFailureStreak;
-    private readonly errorStormCount;
-    private readonly errorStormWindowMs;
-    private readonly cooldownMs;
-    constructor(opts: BrainMonitorOptions);
-    start(): void;
-    stop(): void;
-    private engage;
-    private maybeIntervene;
-}
-
-/**
- * dep-watcher — File-change → Mailbox bridge for dependency monitoring.
- *
- * Watches dependency manifest files (package.json, go.mod, Cargo.toml, etc.)
- * and when they change (create/update), posts a message to the inter-agent
- * mailbox. A tech-stack analysis agent can then pick up the message and
- * run a full tech-stack validation, feeding results back to the coding LLM.
- *
- * This module is a *config factory*, not a watcher itself. It produces
- * configuration that the file-watcher plugin (`watch_start`) can consume,
- * plus a callback that posts to a Mailbox instance.
- *
- * Usage:
- *   const cfg = makeDependencyWatcherConfig({
- *     projectRoot: '/path/to/project',
- *     mailbox,
- *     targetAgent: 'tech-stack-agent',
- *   });
- *   // cfg.watchPaths   → pass to watch_start
- *   // cfg.onChange     → call on file-watcher:changed events
- *
- * @module dep-watcher
- */
-
-/**
- * Files that declare project dependencies. When any of these change
- * (create/update), a mailbox message triggers a tech-stack audit.
- */
-declare const DEPENDENCY_FILE_PATTERNS: ReadonlyArray<string>;
-interface DepWatchEntry {
-    /** Relative path from project root that changed. */
-    path: string;
-    /** Event type from the file watcher: 'change', 'add', 'delete' (rare). */
-    event: string;
-    /** ISO8601 timestamp of when the change was detected. */
-    timestamp: string;
-}
-interface DependencyWatcherConfig {
-    /** Paths to pass to `watch_start` — the project-root-relative dependency files. */
-    watchPaths: string[];
-    /** Callback to invoke when a dependency file changes. Posts to mailbox. */
-    onChange: (entry: DepWatchEntry) => Promise<void>;
-    /** Debounce window in ms — multiple changes to the same file within this window are collapsed. */
-    debounceMs: number;
-    /** Cancel all in-flight debounce timers. Call when the file watcher is
-     *  stopped (session end / project switch) so pending setTimeouts — each
-     *  holding a closure over the mailbox + entry — don't leak. */
-    dispose: () => void;
-}
-interface DependencyWatcherOptions {
-    /** Absolute path to the project root. */
-    projectRoot: string;
-    /** The mailbox instance where messages will be posted. */
-    mailbox: Mailbox;
-    /** Agent id that should receive the tech-stack audit task. */
-    targetAgent?: string | undefined;
-    /** Agent id of the watcher (sender). */
-    watcherAgentId?: string | undefined;
-    /** Debounce window in ms. Default: 3000 (3 seconds). */
-    debounceMs?: number | undefined;
-    /** Only watch these specific patterns. Defaults to DEPENDENCY_FILE_PATTERNS. */
-    patterns?: string[] | undefined;
-}
-/**
- * Build a dependency watcher configuration. The returned `watchPaths` can be
- * passed directly to the `watch_start` tool, and `onChange` should be wired
- * to the `file-watcher:changed` custom event.
- *
- * When a dependency file changes, `onChange` posts a high-priority `assign`
- * message to the mailbox targeting the tech-stack agent, with the changed
- * file path and event type in the body.
- */
-declare function makeDependencyWatcherConfig(opts: DependencyWatcherOptions): DependencyWatcherConfig;
-
-/**
- * dep-watcher-bridge — Bridges the file-watcher plugin's custom events
- * to the dependency watcher → mailbox pipeline.
- *
- * The file-watcher plugin emits `file-watcher:changed` custom events
- * when files change. This module subscribes to those events, filters
- * for dependency manifests (package.json, go.mod, etc.), and posts
- * assign messages to the inter-agent mailbox for tech-stack audit.
- *
- * Returns a dispose function that unsubscribes from the event bus.
- *
- * @module dep-watcher-bridge
- */
-
-interface DepWatcherBridgeOptions {
-    /** The event bus to subscribe to (same bus the file-watcher plugin emits on). */
-    events: EventBus;
-    /** The mailbox instance where dep-change notifications will be posted. */
-    mailbox: Mailbox;
-    /** Absolute project root — used to build watch paths and match file patterns. */
-    projectRoot: string;
-    /** Agent id the tech-stack audit tasks should target. Default: 'tech-stack'. */
-    targetAgent?: string | undefined;
-    /** Agent id of the watcher/sender. Default: 'dep-watcher'. */
-    watcherAgentId?: string | undefined;
-    /** Debounce window in ms. Default: 3000 (3 seconds). */
-    debounceMs?: number | undefined;
-}
-/**
- * Wire the file-watcher's `file-watcher:changed` events into the
- * dependency watcher → mailbox pipeline.
- *
- * Returns a dispose function. Call it to unsubscribe when the
- * session ends or the watcher is no longer needed.
- *
- * Usage:
- *   const dispose = attachDepWatcherBridge({
- *     events: ctx.events,
- *     mailbox: new DefaultMailbox(sessionDir),
- *     projectRoot: ctx.projectRoot,
- *   });
- *   // ... session runs ...
- *   dispose(); // clean up on exit
- */
-declare function attachDepWatcherBridge(opts: DepWatcherBridgeOptions): () => void;
-
-/**
- * mailbox-tool — Tool that exposes the inter-agent mailbox to agents.
- *
- * Sub-commands: check, send, ack, query, status, online, unread
- *
- * Uses the project-level GlobalMailbox for cross-session communication.
- * Agents are auto-registered on first use with heartbeat tracking.
- * Read receipts track who read each message and when.
- *
- * @module mailbox-tool
- */
-
-type MailboxResolver = (ctx: Context) => Mailbox;
-interface MailboxToolOptions {
-    /**
-     * How to obtain a Mailbox instance given the execution Context.
-     * Default: derives project dir from ctx and creates a GlobalMailbox.
-     */
-    resolveMailbox?: MailboxResolver | undefined;
-    /**
-     * Agent id of the caller — used as default "from" on send.
-     * Default: 'leader' for the main agent, or derived from ctx.meta.
-     */
-    agentId?: string | undefined;
-    /** Session id for cross-session communication. Default: derived from ctx. */
-    sessionId?: string | undefined;
-    /**
-     * Project directory where the mailbox is stored.
-     * Default: derived from ctx.projectRoot (may differ from wpaths.projectDir).
-     * For correct cross-session sharing, pass `wpaths.projectDir` from the caller.
-     */
-    projectDir?: string | undefined;
-    /**
-     * EventBus for emitting mailbox.agent_registered and mailbox.agent_heartbeat
-     * events so the TUI/WebUI can update the online agent count in the status bar.
-     * When omitted, events are not emitted and the status bar count stays at 0.
-     */
-    events?: EventBus | undefined;
-}
-/**
- * Compact, deterministic tag for a session id — 8 hex chars of its sha256.
- * Session ids are date-sharded paths ("2026-06-11/sess_<ULID>");
- * the tag keeps mailbox identities short, filesystem-safe, and stable for
- * the lifetime of the session (including across process restarts/resumes).
- */
-declare function mailboxSessionTag(sessionId: string): string;
-/**
- * Resolve the caller's mailbox identity from the execution Context.
- *
- * Shared by the `mailbox` power-tool, the thin `mail_send`/`mail_inbox`
- * tools, the agent-loop checker, and the /mailbox slash command so every
- * surface agrees on who is talking:
- * - base id: ctx.meta.agentId → ctx.agentId field (subagents) → fallback
- * - unique id: `<base>@<sessionTag>` — SESSION-bound, not pid-bound. Every
- *   session has its own id, so two leader sessions on the same project
- *   never collide (pids can be recycled by the OS), and a resumed session
- *   keeps its identity: read state survives a restart instead of
- *   re-flooding old broadcasts. Derived LIVE from ctx.session.id so an
- *   in-process session swap (resume / session.new / project switch) moves
- *   the identity with it. `ctx.meta.globalAgentId` remains an explicit
- *   override for hosts that manage identity themselves.
- */
-declare function resolveMailboxIdentity(ctx: Context, fallbackBase?: string): {
-    baseId: string;
-    callerId: string;
-    name: string;
-    role?: string | undefined;
-    sessionId: string;
-};
-declare function makeMailboxTool(opts?: MailboxToolOptions): Tool;
-
-/**
- * fleet-status-tool — read-only live peer snapshot for any agent.
- *
- * The pull half of peer awareness (the push half is the fleet-pulse
- * digest): any agent — leader or fleet subagent — can ask "who else is
- * working on this project right now, and on what?" before starting work
- * that might overlap, or when deciding whether to wait or proceed.
- *
- * Data source: the project mailbox registry (`getAgentStatuses`), which is
- * cross-process by construction. When the host passes `getLocalAgents`
- * (an AgentStatusTracker view), same-process entries are enriched with the
- * richer live fields the registry doesn't carry (ctxPct, costUsd,
- * partialText tail).
- *
- * @module fleet-status-tool
- */
-
-interface FleetStatusToolOptions {
-    /** How to obtain a Mailbox given the execution Context (tests). */
-    resolveMailbox?: MailboxResolver | undefined;
-    /** Project dir for the shared mailbox. Prefer wpaths.projectDir. */
-    projectDir?: string | undefined;
-    /** EventBus for mailbox registration surface events. */
-    events?: EventBus | undefined;
-    /**
-     * Same-process rich agent state (AgentStatusTracker snapshot). Merged
-     * into registry rows by name when provided — cross-process peers keep
-     * registry-only fields.
-     */
-    getLocalAgents?: (() => AgentEntry[]) | undefined;
-}
-declare function makeFleetStatusTool(opts?: FleetStatusToolOptions): Tool;
-
-/**
- * FleetSupervisor — brain-gated shadow watcher over the generic fleet.
- *
- * The Director gives a leader agent orchestration TOOLS; this module gives
- * the fleet a SUPERVISOR that works even while the leader is deep in its
- * own task: it continuously watches queue shape + worker activity, detects
- * imbalance (a pending task starving behind a busy worker while a sibling
- * idles, a deep backlog, a stuck or repeatedly-failing worker), and — after
- * clearing every proposal through the tiered BrainArbiter (policy → LLM →
- * human, honoring the /brain risk ceiling) — acts: retargets pending
- * tasks ("I'm reducing your workload"), spawns a helper, steers an agent
- * by mail, notifies the leader, or (opt-in) terminates.
- *
- * Design lineage: BrainMonitor (watch bus → decide → intervene, cooldowns,
- * single engagement in flight) generalized from "steer the leader" to the
- * full fleet action set; SddSupervisor's brain-verdict contract reused for
- * the decision step. The SDD subsystem itself is untouched.
- *
- * Non-interference guarantees (also pinned by tests):
- *   - never calls extend/deny on budget negotiations — the Director's
- *     budgetFilter remains the sole negotiator; we only OBSERVE events
- *   - never preempts a RUNNING task — only still-pending tasks move
- *   - never flips autonomy mode
- *   - dormant once the director declares work complete
- *
- * @module fleet-supervisor
- */
-
-/** One subagent row of the snapshot the supervisor reasons over. */
-interface SupervisedSubagent {
-    id: string;
-    name: string;
-    status: 'running' | 'idle' | 'stopped' | 'error';
-    currentTask?: string | undefined;
-}
-/** Read port — implemented over Director/coordinator state by the host. */
-interface FleetSupervisorSource {
-    subagents(): SupervisedSubagent[];
-    listPendingTasks(): readonly TaskSpec[];
-    isWorkComplete(): boolean;
-}
-/** Action port — every mutation the supervisor may perform, brain-gated. */
-interface FleetSupervisorActions {
-    /** Move a still-pending task to another (or any idle) worker. */
-    retargetPendingTask(taskId: string, subagentId: string | undefined): boolean | Promise<boolean>;
-    /** Spawn an additional helper worker. Return {error} to degrade gracefully. */
-    spawnHelper(input: {
-        reason: string;
-        /** Oldest queued task used to route the helper's role/tool profile. */
-        task?: TaskSpec | undefined;
-    }): Promise<{
-        subagentId: string;
-    } | {
-        error: string;
-    }>;
-    /** High-priority steer mail to one agent. */
-    steerAgent(subagentId: string, subject: string, body: string): Promise<void>;
-    /** Status/steer mail to the session leader. */
-    notifyLeader(subject: string, body: string): Promise<void>;
-    /** Abort a subagent (only used when config.allowTerminate). */
-    terminate(subagentId: string): Promise<void>;
-}
-interface FleetSupervisorOptions {
-    events: EventBus;
-    fleet: FleetBus;
-    brain: BrainArbiter;
-    source: FleetSupervisorSource;
-    actions: FleetSupervisorActions;
-    /** Active host session id, read lazily (resume/session-swap safe). */
-    sessionId?: (() => string | undefined) | undefined;
-    config?: FleetSupervisorConfig | undefined;
-    /** Injectable clock for tests. Default Date.now. */
-    now?: (() => number) | undefined;
-}
-interface SupervisorLogEntry {
-    at: number;
-    kind: string;
-    subagentId?: string | undefined;
-    taskId?: string | undefined;
-    proposedAction: string;
-    outcome: 'approved' | 'denied' | 'escalated' | 'skipped' | 'error';
-    detail: string;
-}
-interface ResolvedSupervisorConfig {
-    enabled: boolean;
-    intervalMs: number;
-    cooldownMs: number;
-    maxInterventionsPerSubagent: number;
-    pinnedWaitMs: number;
-    overloadPinnedThreshold: number;
-    backlogFactor: number;
-    stuckMs: number;
-    failureStreak: number;
-    allowSpawn: boolean;
-    allowTerminate: boolean;
-}
-declare class FleetSupervisor {
-    private readonly opts;
-    private readonly cfg;
-    private readonly now;
-    private timer;
-    private readonly offHandles;
-    private engaging;
-    private stopped;
-    /** taskId → first tick timestamp we saw it pending. */
-    private readonly pendingSince;
-    /** subagentId → last observable fleet event timestamp. */
-    private readonly lastActivityAt;
-    /** subagentId → consecutive non-success completions. */
-    private readonly failStreaks;
-    /** Consecutive ticks the backlog condition held. */
-    private backlogTicks;
-    /** `${kind}|${subject}` → last engagement ts. */
-    private readonly lastEngagedAt;
-    private readonly interventionsBySubagent;
-    /** Tasks already retargeted once — never bounced twice. */
-    private readonly retargetedTasks;
-    private readonly log;
-    constructor(opts: FleetSupervisorOptions);
-    /** Idempotent; also re-arms after a stop() so `/supervisor on` works. */
-    start(): void;
-    stop(): void;
-    history(): readonly SupervisorLogEntry[];
-    /** True while the evaluation loop is armed. */
-    isRunning(): boolean;
-    /** Resolved (defaulted) configuration — for status surfaces. */
-    configSnapshot(): Readonly<ResolvedSupervisorConfig>;
-    private nudgeTimer;
-    private scheduleNudge;
-    private isCollab;
-    /** One evaluation pass. Public for tests; production runs it on the tick. */
-    evaluate(): Promise<void>;
-    private cooldownOk;
-    private interventionBudgetOk;
-    private recordIntervention;
-    private emitSignal;
-    private record;
-    private emitAction;
-    /**
-     * Ask the brain to approve a proposal. Same contract as BrainMonitor:
-     * `source:'system'`, the rule's proposal `recommended:true`, fallback
-     * 'ask_human' (routes to the LLM tier under the risk ceiling before any
-     * human). Returns the chosen option id, or null for deny/escalate.
-     */
-    private decide;
-    private engageRebalance;
-    private engageBacklog;
-    private engageStuck;
-    private engageFailureStreak;
-    private engageIdleWithWork;
-}
-
-/** Absolute recursion ceiling. Configuration may narrow this, never widen it. */
-declare const HARD_MAX_SPAWN_DEPTH = 2;
-/** CLI fleet default; core embedders retain their historical Infinity default. */
-declare const DEFAULT_MAX_FLEET_SPAWNS = 64;
-declare function resolveMaxSpawnDepth(requested?: number | undefined): number;
-
-/** Context metadata key used to hand the submitted report to the task runner. */
-declare const SUBAGENT_STRUCTURED_REPORT_META_KEY = "subagentStructuredReport";
-declare const MAX_SUBAGENT_STRUCTURED_REPORT_CHARS = 8000;
-/**
- * Validate and normalize a model-supplied structured result. The tool executor
- * already applies JSON Schema validation, but this guard keeps direct callers,
- * custom executors, and data read back from Context metadata honest too.
- */
-declare function normalizeSubagentStructuredReport(value: unknown): SubagentStructuredReport | undefined;
-declare function readSubagentStructuredReport(ctx: Pick<Context, 'meta'> | {
-    meta?: Record<string, unknown>;
-} | undefined): SubagentStructuredReport | undefined;
-/** Stable compact text form for mailbox/roll-up surfaces. */
-declare function formatSubagentStructuredReport(report: SubagentStructuredReport): string;
-/** Safe, task-local handoff channel from a subagent to its Director. */
-declare function makeSubagentResultTool(): Tool;
-
-/**
- * mail-tools — thin, high-affordance wrappers over the project mailbox.
- *
- * These are the PREFERRED mailbox tools for agents. The multi-action `mailbox`
- * tool is the low-level power surface for advanced queries and agent status;
- * `mail_send` and `mail_inbox` exist because explicit verbs ("send a mail",
- * "read my inbox") are what makes agents USE the mailbox autonomously — a model
- * reaches for `mail_send` mid-task far more readily than for
- * `mailbox action=send ...`.
- *
- *   mail_send  — message one agent (`to: "leader@a1b2c3d4"`), every leader
- *                (`to: "leader"`), or everyone (`to: "*"`)
- *   mail_inbox — read unread mail (unique id + base alias + broadcasts),
- *                marking it read so it isn't re-injected next iteration
- *
- * Both share the identity convention with the agent-loop checker
- * (`<base>@<sessionTag>`, see mailbox-attach) via `resolveMailboxIdentity`.
- *
- * @module mail-tools
- */
-
-interface MailToolsOptions {
-    /** How to obtain a Mailbox given the execution Context (tests). */
-    resolveMailbox?: MailboxResolver | undefined;
-    /** Project dir for the shared mailbox. Prefer wpaths.projectDir. */
-    projectDir?: string | undefined;
-    /** EventBus for mailbox.agent_registered / heartbeat surface events. */
-    events?: EventBus | undefined;
-}
-declare function makeMailSendTool(opts?: MailToolsOptions): Tool;
-declare function makeMailInboxTool(opts?: MailToolsOptions): Tool;
-
-/**
- * DefaultMailbox — append-only JSONL inter-agent mailbox (per-session).
- *
- * Stores messages under `<sessionDir>/_mailbox.jsonl`. Every send appends
- * one line. Query reads and filters all lines. Ack rewrites changed
- * messages in-place via atomic write.
- *
- * For cross-session communication, use GlobalMailbox instead.
- *
- * @module DefaultMailbox
- */
-
-declare class DefaultMailbox implements Mailbox {
-    private readonly filePath;
-    private _messageCache;
-    private _messageCacheMtime;
-    private _messageCacheSize;
-    /** Primary index: recipient → Set of messages (points into _messageCache). */
-    private _byTo;
-    /** Secondary index: sender → Set of messages (points into _messageCache). */
-    private _byFrom;
-    /** Counts malformed JSONL lines skipped during parsing for observability. */
-    private _corruptionCount;
-    constructor(sessionDir: string);
-    get mailboxPath(): string;
-    /** Returns the count of malformed JSONL lines encountered during reads. */
-    get corruptionCount(): number;
-    send(input: MailboxSendInput): Promise<MailboxMessage>;
-    query(q: MailboxQuery): Promise<MailboxMessage[]>;
-    ack(input: MailboxAckInput): Promise<MailboxMessage | null>;
-    softDelete(_mailId: string, _by: string): Promise<MailboxMessage | null>;
-    restore(_mailId: string): Promise<MailboxMessage | null>;
-    ackMany(input: MailboxAckBatchInput): Promise<MailboxMessage[]>;
-    getAgentStatuses(): Promise<MailboxAgentStatus[]>;
-    getOnlineAgents(): Promise<MailboxAgentStatus[]>;
-    registerAgent(_input: AgentRegistrationInput): Promise<void>;
-    deregisterAgent(_agentId: string): Promise<void>;
-    heartbeat(_input: AgentHeartbeatInput): Promise<void>;
-    unreadCount(forAgentId: string): Promise<number>;
-    close(): Promise<void>;
-    clearAll(): Promise<void>;
-    purgeStale(opts?: PurgeOptions): Promise<PurgeResult>;
-    registerClient(_input: ClientRegistrationInput): Promise<void>;
-    clientHeartbeat(_input: ClientHeartbeatInput): Promise<void>;
-    getClientStatuses(): Promise<ClientStatus[]>;
-    private _readAll;
-    /**
-     * Read only newly-appended bytes from the file and append them to the
-     * in-memory cache, avoiding a full re-read when the file only grew.
-     */
-    private _readNewMessagesOnly;
-    /** Parse a JSONL string into MailboxMessage[], including migration. */
-    private _parseLines;
-    /**
-     * Stat the mailbox file under the assumption that we are holding the
-     * file lock, and that a write to the file has just completed. Returns
-     * the (mtimeMs, size) pair, or (-1, -1) if the file does not exist
-     * (e.g. ackMany/purgeStale on a session that has never sent a message).
-     */
-    private _statUnderLockOrAbsent;
-    private _readAllCached;
-    private _setMessageCache;
-    private _pushToCache;
-    /** Rebuild both indexes from a full message list. */
-    private _buildIndexes;
-    /** Add a single message to both indexes. */
-    private _indexMsg;
-}
-
-/**
- * Mailbox message action helpers (skeleton).
- *
- * Phase 1 skeleton: declares the {@link MailboxMessageAction} union
- * (the verb that a user or agent issues against a single message) and
- * the per-action input shapes. The actual implementations
- * ({@link GlobalMailbox.markRead}, {@link GlobalMailbox.acknowledge},
- * {@link GlobalMailbox.softDelete}, {@link GlobalMailbox.restore}) are
- * added in Phase 2 alongside the corresponding `GlobalMailbox`
- * methods.
- *
- * Keeping the verb+input types in their own file means the WebUI
- * client (Phase 3) and the server route handlers (Phase 4) can
- * import them independently of the `GlobalMailbox` implementation,
- * and a future "message actions" CLI subcommand only has to add
- * one verb to a single place.
- */
-
-/**
- * High-level verbs the WebUI/server route handlers expose. The
- * mapping to underlying `MailboxAckInput` is straightforward:
- *   - `mark-read`  → `ack({ read: true,  completed: false })`
- *   - `acknowledge`→ `ack({ read: true,  completed: true  })`
- *   - `reopen`     → `ack({ read: false, completed: false })`
- *   - `soft-delete`→ not an `ack` — a separate `Mailbox.softDelete()`
- *     that flips `deletedAt` to "now" (recoverable) and is filtered
- *     out of the default `query()`.
- *   - `restore`    → the inverse of `soft-delete`. Undoes a
- *     `softDelete` by clearing `deletedAt`.
- */
-type MailboxMessageAction = 'mark-read' | 'acknowledge' | 'reopen' | 'soft-delete' | 'restore';
-/** Per-action request body sent from the WebUI → server route. */
-interface MailboxActionInput {
-    action: MailboxMessageAction;
-    mailId: string;
-    /** Acting agent / user. Required by the server to stamp
-     *  `readBy` / `completedBy`. */
-    readerId: string;
-    /** Optional human note (e.g. "triaged — will follow up"). */
-    note?: string | undefined;
-    /** Optional idempotency key so retried requests don't double-apply
-     *  the action. Phase 4 wires this through to the CLI. */
-    requestId?: string | undefined;
-}
-/** Per-action response. Echoes the action + the resulting message
- *  state so the UI can reconcile optimistic updates. */
-interface MailboxActionResult {
-    action: MailboxMessageAction;
-    mailId: string;
-    /** Updated message snapshot. `null` if the message was already in
-     *  the target state (e.g. `mark-read` on a message the user has
-     *  already read) — the WebUI can ignore the result in that case. */
-    message: MailboxMessage | null;
-    /** True if the action actually mutated state; false if it was a
-     *  no-op. Lets the WebUI decide whether to update its local copy. */
-    changed: boolean;
-}
-/**
- * Convert a high-level action into the underlying
- * {@link MailboxAckInput} the existing `GlobalMailbox.ack` already
- * supports. `soft-delete` and `restore` do NOT go through `ack` —
- * the caller must dispatch them to `GlobalMailbox.softDelete` /
- * `GlobalMailbox.restore` instead. This helper returns `null` for
- * those two so the type signature forces the caller to handle them
- * separately.
- */
-declare function actionToAckInput(action: Exclude<MailboxMessageAction, 'soft-delete' | 'restore'>, input: MailboxActionInput): MailboxAckInput;
-
-/**
- * MailboxHealthWatchdog — probes the mailbox HTTP bridge and posts a
- * status message when it goes down.
- *
- * Designed to be embedded inside the WrongStack REPL/TUI/WebUI process —
- * NOT a standalone agent. WrongStack has its own cross-agent
- * coordination channel, so the cheapest reliable signal is "ask the
- * bridge if it's alive, and if it's not, tell the rest of the team
- * via the same channel the bridge exposes."
- *
- * Usage:
- *
- *   const mailbox = new GlobalMailbox(projectDir);
- *   const watchdog = new MailboxHealthWatchdog({
- *     mailbox,
- *     url: 'http://127.0.0.1:7788',
- *     probeIntervalMs: 15_000,
- *     onAlert: (event) => console.warn(event),
- *   });
- *   await watchdog.start();
- *   // ...later...
- *   await watchdog.stop();
- *
- * The watchdog is a passive observer: it does NOT start the bridge.
- * Starting the bridge is the user's job (`wstack mailbox serve` or
- * `/mailbox-serve`). The watchdog then reports on what the user did.
- */
-
-interface MailboxHealthWatchdogOptions {
-    /** Project mailbox to probe-and-report on. Required. */
-    mailbox: GlobalMailbox;
-    /** URL of the mailbox bridge (no trailing slash). Required. */
-    url: string;
-    /** Probe interval in milliseconds. Default: 15_000. */
-    probeIntervalMs?: number;
-    /** Per-probe timeout in milliseconds. Default: 3_000. */
-    probeTimeoutMs?: number;
-    /**
-     * After this many consecutive failures the watchdog posts an alert.
-     * Default: 2 (so a single transient timeout doesn't trigger spam).
-     */
-    failureThreshold?: number;
-    /**
-     * Optional callback for local observability — fired on every state
-     * transition. The mailbox post is independent of this callback.
-     */
-    onAlert?: ((event: MailboxHealthEvent) => void) | undefined;
-    /**
-     * Agent id used to post the alert message. Default: 'mailbox-bridge-watchdog'.
-     */
-    from?: string;
-}
-type MailboxHealthEvent = {
-    kind: 'probe-failed';
-    status?: number;
-    error?: string;
-} | {
-    kind: 'alert-posted';
-    consecutiveFailures: number;
-} | {
-    kind: 'recovery-posted';
-    downtimeMs: number;
-} | {
-    kind: 'started';
-    intervalMs: number;
-} | {
-    kind: 'stopped';
-};
-declare const MAILBOX_HEALTH_DEFAULT_INTERVAL_MS = 15000;
-declare const MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS = 3000;
-declare const MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD = 2;
-declare const MAILBOX_HEALTH_DEFAULT_FROM = "mailbox-bridge-watchdog";
-declare class MailboxHealthWatchdog {
-    private readonly mailbox;
-    private readonly url;
-    private readonly intervalMs;
-    private readonly timeoutMs;
-    private readonly failureThreshold;
-    private readonly from;
-    private readonly onAlert?;
-    private timer;
-    private consecutiveFailures;
-    private downSince;
-    private alerting;
-    private inFlight;
-    private aborted;
-    constructor(opts: MailboxHealthWatchdogOptions);
-    /** Start probing on `intervalMs`. Idempotent — second call is a no-op. */
-    start(): Promise<void>;
-    /** Stop probing. Safe to call multiple times. */
-    stop(): Promise<void>;
-    /** True between start() and stop(). */
-    isRunning(): boolean;
-    /** Number of consecutive failed probes since the last successful probe. */
-    get currentFailureStreak(): number;
-    /** True iff the watchdog currently considers the bridge down. */
-    isBridgeDown(): boolean;
-    private emit;
-    private tick;
-    private probe;
-    private recordSuccess;
-    private recordFailure;
-    private postDown;
-    private postRecovery;
-}
-interface DownAlertInput {
-    from: string;
-    url: string;
-    consecutiveFailures: number;
-}
-declare function buildDownAlert(input: DownAlertInput): MailboxSendInput;
-interface RecoveryAlertInput {
-    from: string;
-    url: string;
-    downtimeMs: number;
-    consecutiveFailures: number;
-}
-declare function buildRecoveryAlert(input: RecoveryAlertInput): MailboxSendInput;
-interface WatchdogConfig {
-    probeIntervalMs: number;
-    probeTimeoutMs: number;
-    failureThreshold: number;
-}
-/**
- * Throws if the watchdog config is invalid. Called from the
- * MailboxHealthWatchdog constructor so misconfiguration fails fast
- * (at startup), not silently after the first probe.
- */
-declare function validateWatchdogOptions(cfg: WatchdogConfig): void;
-
-/**
- * mailbox-hooks — Tool-execution hooks for mailbox integration.
- *
- * 1. Before each tool call, checks the mailbox for unread high-priority
- *    steer messages and emits a `mailbox.unread_count` event.
- * 2. After each tool call, updates the agent heartbeat so other agents
- *    know this one is still alive.
- *
- * This gives near-real-time mailbox checking (every tool call, not just
- * iteration boundaries) and powers the "new mail" badge in the WebUI/TUI.
- *
- * @module mailbox-hooks
- */
-
-interface MailboxHooksOptions {
-    /** The mailbox instance. */
-    mailbox: Mailbox;
-    /** Agent id for read-receipt and unread-check purposes. */
-    agentId: string;
-    /** Whether to emit new-mail notifications. Default: true. */
-    notifyNewMail?: boolean | undefined;
-    /** Whether to update heartbeat. Default: true. */
-    heartbeat?: boolean | undefined;
-}
-/**
- * Create a pair of hooks for the tool execution pipeline.
- *
- * Usage:
- *   const hooks = createMailboxHooks({ mailbox, agentId });
- *   // In the tool executor, before each tool call:
- *   await hooks.beforeTool({ events });
- *   // After each tool call:
- *   await hooks.afterTool();
- *
- * The `beforeTool` hook checks for unread messages and emits
- * `mailbox.unread_count` events. The `afterTool` hook updates
- * the agent heartbeat.
- */
-declare function createMailboxHooks(opts: MailboxHooksOptions): {
-    /**
-     * Call before each tool execution. Checks mailbox and emits events.
-     * @param events — EventBus-like object with emit method.
-     */
-    beforeTool(events: {
-        emit: (type: string, payload: unknown) => void;
-    }): Promise<void>;
-    /**
-     * Call after each tool execution. Updates heartbeat and optionally
-     * current tool status.
-     */
-    afterTool(toolName?: string): Promise<void>;
-    /** Reset the cached unread count (e.g., after the agent checks manually). */
-    reset(): void;
-};
-
-/**
- * Per-task model matrix resolution.
- *
- * The matrix (Config.modelMatrix) maps a catalog **role**, a **phase** name, or
- * the `*` default to a {@link ModelMatrixEntry} (model + optional provider).
- * At subagent spawn time we resolve the most specific match so different task
- * types can run on different models — e.g. `security-scanner` on one model,
- * `documentation` on another — while the leader keeps its own model.
- *
- * Resolution precedence (most → least specific):
- *   1. exact role          (matrix["security-scanner"])
- *   2. the role's phase     (matrix["review"])
- *   3. the `*` default      (matrix["*"])
- *   4. undefined            (caller falls back to the leader model)
- *
- * Set via the `/setmodel` slash command; this module is the single source of
- * truth both that command and the spawn path use to validate + resolve keys.
- */
-
-/** All valid phase keys, in catalog order. */
-declare const MATRIX_PHASE_KEYS: readonly string[];
-/** The phase a catalog role belongs to, or undefined for unknown roles. */
-declare function phaseForRole(role: string | undefined): string | undefined;
-type ModelMatrixResolutionSource = 'role' | 'phase' | 'default';
-interface ModelMatrixResolution {
-    entry: ModelMatrixEntry;
-    source: ModelMatrixResolutionSource;
-    key: string;
-}
-/**
- * Resolve the matrix entry plus the key tier it came from. Use this when the
- * caller needs to distinguish an explicit role/phase pin from the global `*`
- * default.
- */
-declare function resolveModelMatrixResolution(matrix: Record<string, ModelMatrixEntry> | undefined, role: string | undefined): ModelMatrixResolution | undefined;
-/**
- * Resolve the matrix entry for a subagent role. Returns the most specific
- * match (role → phase → `*`), or undefined when nothing matches.
- */
-declare function resolveModelMatrix(matrix: Record<string, ModelMatrixEntry> | undefined, role: string | undefined): ModelMatrixEntry | undefined;
-interface ResolvedModelTarget {
-    provider?: string | undefined;
-    model?: string | undefined;
-    modelRuntime?: Config['modelRuntime'] | undefined;
-    fallbackModels?: string[] | undefined;
-    fallbackProfile?: string | undefined;
-}
-interface ResolvedSubagentModelTarget extends ResolvedModelTarget {
-    /** Where the concrete provider/model came from. */
-    source: 'matrix' | 'diversity' | 'none';
-    /** Matrix tier used before any reviewer diversity adjustment. */
-    matrixSource?: ModelMatrixResolutionSource | undefined;
-    /** True when a reviewer model was shifted away from the implementation model. */
-    diversified?: boolean | undefined;
-}
-/**
- * Expand a matrix entry into a concrete primary model plus optional fallback
- * chain. A profile-only matrix entry treats the first profile model as primary
- * and the remaining profile entries as that subagent's fallback chain.
- */
-declare function resolveModelTargetFromEntry(config: Config, entry: ModelMatrixEntry | undefined): ResolvedModelTarget | undefined;
-interface ModelReference {
-    provider?: string | undefined;
-    model?: string | undefined;
-}
-/**
- * Roles whose output is meant to challenge an implementer. When these roles
- * would otherwise use the same provider/model as the implementation path,
- * WrongStack tries to pick a different available model to reduce correlated
- * model-family mistakes. Exact role/phase `/setmodel` entries still win.
- */
-declare function roleNeedsIndependentReviewModel(role: string | undefined): boolean;
-/**
- * Resolve a subagent's matrix target with the reviewer diversity rule applied.
- *
- * Precedence:
- *   1. Exact role or phase matrix entry.
- *   2. Global `*` matrix entry when it is already different from the
- *      implementation model.
- *   3. A different configured provider/model for review roles.
- *   4. The matrix/leader fallback.
- */
-declare function resolveSubagentModelTarget(config: Config, role: string | undefined, opts?: {
-    implementationTarget?: ModelReference | undefined;
-}): ResolvedSubagentModelTarget | undefined;
-/**
- * Resolve the default implementation lane. The generic Executor is the closest
- * stable proxy for "the implementer" when a reviewer is spawned without a
- * concrete sibling id.
- */
-declare function resolveImplementationModelTarget(config: Config): ModelReference;
-declare function sameModelReference(a: ModelReference | undefined, b: ModelReference | undefined): boolean;
-type MatrixKeyKind = 'role' | 'phase' | 'default' | 'unknown';
-/** Classify a matrix key so `/setmodel` can reject typos before persisting. */
-declare function matrixKeyKind(key: string): MatrixKeyKind;
-/** True when `key` is a usable matrix key (role, phase, or `*`). */
-declare function isValidMatrixKey(key: string): boolean;
-
-/**
- * package-author-tracker — Tracks which agent added which package to which manifest.
- *
- * Stores a per-project JSON log in the global project directory:
- *   ~/.wrongstack/projects/<slug-hash>/package-authors.json
- *
- * Each entry records: manifest path, package name, version range at time of add,
- * agent id/name, timestamp, and session id.
- *
- * Used by the tech-stack agent and outdated-watcher to route outdated-package
- * notifications back to the agent that originally added the package.
- *
- * @module package-author-tracker
- */
-interface PackageAuthorEntry {
-    /** Absolute or relative path to the manifest (package.json, go.mod, etc.). */
-    manifestPath: string;
-    /** Exact package name as it appears in the manifest. */
-    packageName: string;
-    /** Version specifier at time of install (e.g. "^1.2.0", "latest", "file:..."). */
-    versionSpec: string;
-    /** Ecosystem: 'npm', 'cargo', 'go', 'pip', 'gem', 'composer', 'nuget', etc. */
-    ecosystem: string;
-    /** Agent id that performed the install (e.g. 'leader', 'executor', 'tech-stack'). */
-    agentId: string;
-    /** Human-readable agent name. */
-    agentName?: string | undefined;
-    /** Session that performed the install. */
-    sessionId?: string | undefined;
-    /** ISO8601 timestamp. */
-    timestamp: string;
-    /** Whether this package is currently flagged as outdated. */
-    outdated?: boolean | undefined;
-    /** Latest version available (set by outdated checker). */
-    latestVersion?: string | undefined;
-}
-interface PackageAuthorLog {
-    /** Project root this log belongs to. */
-    projectRoot: string;
-    /** All entries, newest last. */
-    entries: PackageAuthorEntry[];
-    /** Last time the log was compacted. */
-    lastCompactedAt?: string | undefined;
-}
-interface PackageAuthorTrackerOptions {
-    /** Directory where the JSON log is stored. Usually the global project dir. */
-    storageDir: string;
-    /** Project root for reference. */
-    projectRoot: string;
-    /** Max entries before auto-compaction. Default: 10000. */
-    maxEntries?: number | undefined;
-}
-/**
- * Detect the ecosystem from a manifest filename.
- */
-declare function detectEcosystem(manifestPath: string): string;
-/**
- * Record that an agent added (or updated) a package to a manifest file.
- *
- * If the same (manifestPath, packageName) entry already exists, the previous
- * entry is kept (for audit trail) and a new entry is appended.
- */
-declare function recordPackageAction(opts: PackageAuthorTrackerOptions, entry: Omit<PackageAuthorEntry, 'timestamp'>): Promise<void>;
-/**
- * Get the most recent author entry for a given (manifest, package) pair.
- * Returns undefined if no entry exists.
- */
-declare function getPackageAuthor(opts: Pick<PackageAuthorTrackerOptions, 'storageDir' | 'projectRoot'>, manifestPath: string, packageName: string): Promise<PackageAuthorEntry | undefined>;
-/**
- * Get all packages in a manifest that have an author on record.
- */
-declare function getManifestPackages(opts: Pick<PackageAuthorTrackerOptions, 'storageDir' | 'projectRoot'>, manifestPath: string): Promise<PackageAuthorEntry[]>;
-/**
- * Get all packages last tracked by a specific agent.
- * Returns a Map from (manifestPath, packageName) → entry.
- */
-declare function getPackagesByAgent(opts: Pick<PackageAuthorTrackerOptions, 'storageDir' | 'projectRoot'>, agentId: string): Promise<Map<string, PackageAuthorEntry>>;
-/**
- * Update the outdated status of a package entry (adds or replaces the entry
- * for the given manifest+package, appending to the log for audit).
- */
-declare function updatePackageOutdatedStatus(opts: PackageAuthorTrackerOptions, manifestPath: string, packageName: string, outdated: boolean, latestVersion?: string | undefined): Promise<void>;
-/**
- * Return the full log (for debugging/auditing).
- */
-declare function getFullPackageLog(opts: Pick<PackageAuthorTrackerOptions, 'storageDir' | 'projectRoot'>): Promise<PackageAuthorLog>;
-
-/**
- * package-outdated-watcher — Periodically checks installed packages for outdated
- * versions and notifies the agent that originally added each package.
- *
- * Architecture:
- *   1. Polls the mailbox for `assign` messages from the tech-stack agent
- *      containing outdated package results.
- *   2. For each outdated package, looks up the original author via
- *      `package-author-tracker`.
- *   3. Sends a high-priority `note` message to the original author (or
- *      broadcasts to `*` if the author is unknown or no longer online).
- *
- * The watcher can also be triggered directly via `checkOutdated` for
- * on-demand checks (e.g. on a timer, or when the user requests it).
- *
- * Usage:
- *   const dispose = startPackageOutdatedWatcher({
- *     mailbox,
- *     storageDir: wpaths.globalDir,
- *     projectRoot,
- *     pollIntervalMs: 60 * 60 * 1000, // 1 hour
- *     onNotify: async (msg) => mailbox.send(msg),
- *     onLog: (m) => console.log(`[pkg-outdated-watcher] ${m}`),
- *   });
- *
- * @module package-outdated-watcher
- */
-
-interface PackageOutdatedEntry {
-    /** Package name. */
-    name: string;
-    /** Currently installed version. */
-    currentVersion: string;
-    /** Latest stable version available. */
-    latestVersion: string;
-    /** semver major.minor.patch wanted range (from lockfile). */
-    wantedVersion: string;
-    /** Manifest file this package belongs to. */
-    manifestPath: string;
-    /** Ecosystem: 'npm', 'cargo', 'go', etc. */
-    ecosystem: string;
-}
-interface PackageOutdatedResult {
-    /** All outdated entries. */
-    outdated: PackageOutdatedEntry[];
-    /** Packages that are up-to-date. */
-    upToDate: string[];
-    /** Whether the check failed. */
-    checkFailed: boolean;
-}
-interface PackageOutdatedWatcherOptions {
-    /** The mailbox for sending notifications and receiving tech-stack results. */
-    mailbox: Mailbox;
-    /** Package-author-tracker options. */
-    packageTrackerOpts: Pick<PackageAuthorTrackerOptions, 'storageDir' | 'projectRoot'>;
-    /** Polling interval in ms. Default: 60 * 60 * 1000 (1 hour). */
-    pollIntervalMs?: number | undefined;
-    /** Agent id that runs this watcher. Default: 'pkg-outdated-watcher'. */
-    watcherAgentId?: string | undefined;
-    /** Agent id of the tech-stack agent to watch for results. Default: 'tech-stack'. */
-    techStackAgentId?: string | undefined;
-    /** Called to send a notification to an agent. */
-    onNotify: (msg: OutdatedNotifyMessage) => Promise<void>;
-    /** Called for log output. */
-    onLog?: ((msg: string) => void) | undefined;
-    /** Called on errors. */
-    onError?: ((err: unknown) => void) | undefined;
-}
-interface OutdatedNotifyMessage {
-    from: string;
-    to: string;
-    subject: string;
-    body: string;
-    priority: 'high' | 'normal' | 'low';
-}
-/**
- * Start the package outdated watcher.
- *
- * Returns a dispose function that stops polling and cleans up.
- */
-declare function startPackageOutdatedWatcher(opts: PackageOutdatedWatcherOptions): () => void;
-
-/**
- * Single-instance mailbox-bridge lock.
- *
- * Per-project isolation: each project (resolved via
- * `resolveProjectDir`) gets its own lock file under
- * `<projectDir>/.mailbox-bridge.lock`. Two projects on the same
- * machine never collide — different slugs, different lock files,
- * and (with default port 0) different OS-assigned ports.
- *
- * The lock holds:
- *  - pid          process id of the owning `wstack mailbox serve`
- *  - host, port   what the owner actually bound (port may be OS-assigned)
- *  - url          convenience copy for callers
- *  - token        the bearer token (so external agents don't have to
- *                 re-read it from .mailbox.token separately)
- *  - generation   monotonically increasing counter; bumped on every
- *                 acquire. Lets a release() call identify whether the
- *                 current lock file still belongs to *this* process
- *                 (e.g. after a stale cleanup raced with us).
- *  - spawnedAt    ISO timestamp — for observability, not load-bearing.
- *
- * Concurrency model:
- *  - `acquireOrJoin` is atomic via rename(2). Two concurrent spawns
- *    race to write a tmpfile then rename; one wins, the other reads
- *    the winner's lock and joins.
- *  - PID liveness is checked via `process.kill(pid, 0)` (POSIX) or
- *    `tasklist` (Windows). A live PID means another instance owns
- *    this project; a dead PID means the lock is stale and gets cleaned.
- *  - `release` is best-effort: a missing lock file at shutdown is
- *    fine (someone else already took over). A generation mismatch means
- *    we lost the race and another instance owns it now — also fine.
- *
- * Token persistence: the token in the lock always matches the token in
- * `.mailbox.token`, so an external agent that reads either file gets the
- * same value. While an instance stays alive, every joining caller
- * (`kind: 'joined'`) reuses that one token. A cold (re)start — no lock,
- * or a lock whose owner PID is dead/unhealthy — mints a FRESH token and
- * rewrites both files atomically. External agents must therefore re-read
- * `.mailbox.token` after a bridge restart (a stale token returns 401).
- */
-declare const MAILBOX_BRIDGE_LOCK_FILENAME = ".mailbox-bridge.lock";
-declare const MAILBOX_BRIDGE_TOKEN_FILENAME = ".mailbox.token";
-interface MailboxBridgeLock {
-    pid: number;
-    host: string;
-    port: number;
-    url: string;
-    token: string;
-    generation: number;
-    spawnedAt: string;
-}
-type AcquireResult = {
-    kind: 'acquired';
-    lock: MailboxBridgeLock;
-    tokenPath: string;
-} | {
-    kind: 'joined';
-    lock: MailboxBridgeLock;
-    tokenPath: string;
-} | {
-    kind: 'port-conflict';
-    existing: MailboxBridgeLock;
-};
-interface AcquireOptions {
-    /** Project dir (already resolved by caller via resolveProjectDir). */
-    projectDir: string;
-    /** Bind host. Required when acquiring. */
-    host: string;
-    /** Explicit port. Pass null/undefined to mean "OS-assigned" (read it after listen). */
-    requestedPort: number | null;
-    /** When true, fail loud on EADDRINUSE. When false, fall back to OS-assigned. */
-    strictPort: boolean;
-}
-/**
- * Try to acquire the mailbox-bridge lock for `projectDir`. If another
- * instance is already alive and healthy, join it. Otherwise claim
- * the slot for ourselves.
- *
- * Two-phase contract:
- *  1. Caller invokes `acquireOrJoin(...)` BEFORE calling
- *     `server.listen()`. The returned lock either:
- *       - `kind: 'joined'`     → another instance is alive, the caller
- *                                should NOT bind; just print the URL/token
- *                                and exit cleanly (return 0).
- *       - `kind: 'acquired'`   → caller is the owner, proceeds to bind.
- *       - `kind: 'port-conflict'` → caller asked for an explicit port
- *                                that's already taken by an unrelated
- *                                process; we return the existing owner
- *                                but the caller decides what to do
- *                                (loud-fail).
- *  2. After `server.listen()` resolves with a real port, the caller
- *     invokes `finalize(lock, boundPort)` to atomically write the
- *     final lock + token file with the OS-assigned port.
- *
- * The two-phase split keeps the listen() call out of the lock module —
- * the caller owns the HTTP server instance; the lock module owns
- * the on-disk contract.
- */
-declare function acquireOrJoin(opts: AcquireOptions): Promise<AcquireResult>;
-/**
- * Phase 2 — after server.listen() resolves, write the final lock
- * with the actually-bound port and the same token. Also writes the
- * .mailbox.token file with mode 0600 so external agents can read it.
- *
- * Returns the finalized lock so the caller can use the resolved URL.
- */
-declare function finalize(projectDir: string, tentative: MailboxBridgeLock, boundPort: number): Promise<MailboxBridgeLock>;
-/**
- * Phase 3 — best-effort cleanup on shutdown. Removes the lock + token
- * files IF this process is still the recorded owner (generation match).
- *
- * If the generation doesn't match, another acquire() has already
- * superseded us — we must NOT delete their lock.
- */
-declare function release(projectDir: string, generation: number): Promise<void>;
-/**
- * Read the lock file and return it, with enough information for the
- * caller to distinguish:
- *  - 'live'        — PID alive, /healthz reachable; safe to use.
- *  - 'probe-failed' — PID alive (or recently was) but /healthz
- *                     unreachable. Caller can still return the URL
- *                     + token to the host so its request layer can
- *                     retry; the host's fetch timeout will surface
- *                     the real error if the bridge is truly dead.
- *  - 'absent'      — no lock file existed, or it was malformed
- *                     (cleaned up best-effort).
- *
- * Distinguishing 'probe-failed' from 'absent' matters for the
- * "joined vs spawned" decision in tryAcquireMailboxBridge — we
- * don't want to spawn a second bridge just because /healthz flaked.
- */
-type LiveLockResult = {
-    kind: 'live';
-    lock: MailboxBridgeLock;
-}
-/**
- * The lock exists but isn't usable. `pidAlive` tells the caller
- * which recovery to pick:
- *  - `pidAlive: false` — the owning process is dead (stale lock).
- *    Callers should treat this like `absent` and spawn a fresh
- *    bridge rather than surfacing a dead URL.
- *  - `pidAlive: true`  — the process is alive but /healthz didn't
- *    respond (booting/wedged/PID-reuse). Callers may return the
- *    recorded URL/token and let a real request confirm liveness.
- */
- | {
-    kind: 'probe-failed';
-    lock: MailboxBridgeLock;
-    pidAlive: boolean;
-} | {
-    kind: 'absent';
-};
-declare function readLiveLock(projectDir: string): Promise<LiveLockResult>;
-
-/**
- * Adaptive Concurrency Controller
- *
- * Automatically adjusts `maxConcurrent` based on:
- * - Rate limit (429) errors → decrease concurrency
- * - Sustained successful requests → increase concurrency
- *
- * This provides automatic backpressure without manual tuning.
- */
-
-interface AdaptiveConcurrencyState {
-    current: number;
-    min: number;
-    max: number;
-    consecutiveSuccesses: number;
-    consecutiveFailures: number;
-    totalDecreases: number;
-    totalIncreases: number;
-    enabled: boolean;
-}
-/**
- * Adaptive Concurrency Controller
- *
- * Monitors fleet events for rate-limit (429) errors and adjusts concurrency
- * automatically to prevent overwhelming the API provider.
- */
-declare class AdaptiveConcurrencyController {
-    private readonly config;
-    private state;
-    private readonly disposers;
-    private stateChangeHandlers;
-    private readonly logger;
-    constructor(fleetBus: FleetBus, setMaxConcurrent: (n: number) => void, config?: Partial<AdaptiveConcurrencyConfig>, onStateChange?: (state: AdaptiveConcurrencyState) => void, logger?: Pick<Logger, 'warn'>);
-    private setupEventHandlers;
-    /**
-     * Handle a rate limit (429) error - decrease concurrency
-     */
-    private handleRateLimit;
-    /**
-     * Force a decrease (e.g., manual trigger or other error types)
-     */
-    decrease(target?: number): void;
-    /**
-     * Get the current state
-     */
-    getState(): AdaptiveConcurrencyState;
-    /**
-     * Update configuration at runtime
-     */
-    updateConfig(config: Partial<AdaptiveConcurrencyConfig>): void;
-    /**
-     * Dispose of the controller and clean up event listeners
-     */
-    dispose(): void;
-    private notifyStateChange;
-    /**
-     * Register a state change handler
-     */
-    onStateChange(handler: (state: AdaptiveConcurrencyState) => void): () => void;
-}
-
-interface AgentTimelineEntry {
-    /** Unique entry id (ULID or timestamp-based). */
-    id: string;
-    /** Subagent id this entry belongs to. */
-    subagentId: string;
-    /** Human-readable agent name/role. */
-    agentName: string;
-    /** ISO 8601 timestamp. */
-    ts: string;
-    /** Content type. */
-    kind: 'text' | 'thinking' | 'tool_use' | 'tool_result' | 'error' | 'status' | 'system';
-    /** The message content (text, tool summary, error message, status text). */
-    content: string;
-    /** Iteration index within the subagent's run. */
-    iteration: number;
-    /** For tool entries: tool name. */
-    toolName?: string | undefined;
-    /** For tool entries: whether the tool succeeded. */
-    toolOk?: boolean | undefined;
-    /** Running cost estimate. */
-    costUsd?: number | undefined;
-}
-interface AgentVirtualSession {
-    subagentId: string;
-    agentName: string;
-    createdAt: string;
-    status: string;
-    task?: string | undefined;
-    /** Ordered transcript entries (newest last). */
-    transcript: AgentTimelineEntry[];
-}
-interface AgentMonitorOptions {
-    /** Parent/host session id for emitted agent timeline/status events. */
-    sessionId?: string | undefined;
-    /** The FleetBus to listen on for subagent events. Optional — set via `setFleetBus()` before `start()`. */
-    fleetBus?: FleetBus | undefined;
-    /** Local EventBus for emitting agent.timeline.* and agent.status_changed events. */
-    events: EventBus;
-    /** Directory where per-subagent JSONL transcripts will be written. */
-    transcriptsDir: string;
-    /** Maximum in-memory entries per subagent (ring buffer). Default 500. */
-    maxEntriesPerAgent?: number;
-    /** Whether agent stream is initially enabled. Default false. */
-    streamEnabled?: boolean;
-    /** Called for each new timeline entry — used by HQ publisher bridge. */
-    onEntry?: ((entry: AgentTimelineEntry) => void) | undefined;
-}
-declare class AgentMonitorService {
-    private _fleetBus;
-    private readonly _events;
-    private readonly _sessionId;
-    private readonly _transcriptsDir;
-    private readonly _maxEntries;
-    private _streamEnabled;
-    private _onEntry;
-    /** Per-subagent virtual sessions. */
-    private readonly _sessions;
-    /** Disposers for FleetBus subscriptions, keyed by subagentId. */
-    private readonly _subscriptions;
-    /** Generic fleet-wide subscription disposer. */
-    private _fleetDisposer;
-    /** Track whether service is running. */
-    private _started;
-    constructor(opts: AgentMonitorOptions);
-    /** Set the FleetBus to listen on. Must be called before `start()`. */
-    setFleetBus(bus: FleetBus): void;
-    get streamEnabled(): boolean;
-    /** Enable/disable streaming agent conversations to the main chat timeline. */
-    setStreamEnabled(enabled: boolean): void;
-    /** Get a snapshot of all known agent sessions. */
-    getAllSessions(): AgentVirtualSession[];
-    /** Get a specific agent's virtual session, or undefined. */
-    getSession(subagentId: string): AgentVirtualSession | undefined;
-    /** Get transcript entries for a specific agent, newest first. */
-    getTranscript(subagentId: string, limit?: number): AgentTimelineEntry[];
-    /** Set a callback for each new timeline entry (HQ bridge). */
-    setOnEntry(handler: ((entry: AgentTimelineEntry) => void) | undefined): void;
-    /** Start listening to FleetBus events. */
-    start(): void;
-    /** Stop listening and clean up all subscriptions. */
-    stop(): void;
-    /** Ensure a subagent is being tracked. Called when a subagent spawns. */
-    trackSubagent(subagentId: string, agentName: string, task?: string): void;
-    /** Mark a subagent as completed/failed/etc. Called on subagent finish. */
-    completeSubagent(subagentId: string, status: 'completed' | 'failed' | 'timeout' | 'stopped' | 'budget_exhausted', summary?: string): void;
-    private _routeEvent;
-    private _addEntry;
-    private _appendToFile;
-    private _uid;
-    private _formatToolUse;
-    private _formatToolResult;
-    private _stringifyForTimeline;
-    private _capTimelineText;
-}
-declare function createAgentMonitorService(opts: AgentMonitorOptions): AgentMonitorService;
-
-type NodeType = 'fact' | 'goal' | 'decision' | 'change' | 'vote';
-type FactCategory = 'bug' | 'refactor' | 'security' | 'test' | 'perf' | 'deps' | 'architecture' | 'quality';
-type GoalStatus = 'pending' | 'in_progress' | 'blocked' | 'done' | 'failed';
-type GoalPriority = 'critical' | 'high' | 'medium' | 'low';
-type ChangeStatus = 'proposed' | 'approved' | 'rejected' | 'applied' | 'rolled_back';
-type VoteValue = 'approve' | 'reject' | 'abstain';
-type DecisionType = 'spawn' | 'assign' | 'approve_change' | 'reject_change' | 'escalate' | 'rollback' | 'merge_results';
-interface FactNode {
-    id: string;
-    type: 'fact';
-    category: FactCategory;
-    subject: string;
-    detail: string;
-    file?: string;
-    line?: number;
-    severity?: 'critical' | 'high' | 'medium' | 'low';
-    discoveredBy: string;
-    discoveredAt: string;
-    tags: string[];
-    /** Stable key — dedup facts about the same subject */
-    key: string;
-    /** References to other nodes this fact relates to */
-    related: string[];
-}
-interface GoalNode {
-    id: string;
-    type: 'goal';
-    title: string;
-    description: string;
-    status: GoalStatus;
-    priority: GoalPriority;
-    assignee?: string;
-    blockedBy: string[];
-    dependsOn: string[];
-    createdBy: string;
-    createdAt: string;
-    updatedAt: string;
-    tags: string[];
-    /** Sub-goals spawned from this goal */
-    children: string[];
-    /** The top-level goal this belongs to (for hierarchy) */
-    parentGoal?: string;
-    result?: string;
-}
-interface DecisionNode {
-    id: string;
-    type: 'decision';
-    decisionType: DecisionType;
-    question: string;
-    options: {
-        id: string;
-        label: string;
-        risk?: string;
-    }[];
-    chosen: string;
-    rationale: string;
-    madeBy: string;
-    madeAt: string;
-    context?: string;
-}
-interface ChangeNode {
-    id: string;
-    type: 'change';
-    title: string;
-    description: string;
-    files: {
-        path: string;
-        action: 'create' | 'modify' | 'delete';
-    }[];
-    status: ChangeStatus;
-    proposedBy: string;
-    proposedAt: string;
-    approvedBy: string[];
-    rejectedBy: string[];
-    appliedAt?: string;
-    rolledBackAt?: string;
-    rollbackReason?: string;
-    votes: VoteRecord[];
-    qualityGate: QualityGateResult;
-    /** Goals satisfied by this change */
-    satisfiesGoals: string[];
-}
-interface VoteRecord {
-    agentId: string;
-    agentName: string;
-    value: VoteValue;
-    rationale?: string | undefined;
-    votedAt: string;
-}
-interface QualityGateResult {
-    passed: boolean;
-    checks: QualityCheck[];
-}
-interface QualityCheck {
-    name: string;
-    passed: boolean;
-    detail?: string;
-}
-interface VoteNode {
-    id: string;
-    type: 'vote';
-    changeId: string;
-    voterId: string;
-    voterName: string;
-    value: VoteValue;
-    rationale?: string;
-    votedAt: string;
-}
-type GraphNode = FactNode | GoalNode | DecisionNode | ChangeNode | VoteNode;
-interface GraphSubscription {
-    id: string;
-    agentId: string;
-    /** JSONPath-like filter */
-    filter: NodeFilter;
-    /** Channel for this specific subscription */
-    channel: string;
-}
-interface NodeFilter {
-    type?: NodeType;
-    category?: FactCategory;
-    status?: GoalStatus | ChangeStatus;
-    tags?: string[];
-    assignee?: string;
-    discoveredBy?: string;
-    proposedBy?: string;
-    /** Only nodes added after this timestamp */
-    since?: string;
-}
-declare class KnowledgeGraph {
-    private readonly nodes;
-    private readonly index;
-    private readonly subs;
-    private readonly pendingDeliveries;
-    private readonly filePath;
-    private readonly graphFilePath;
-    /**
-     * Stable per-node insertion sequence. `nodes` (a Map) preserves insertion
-     * order even across `update()` (Map.set on an existing key keeps its slot),
-     * but the type index's `Set<string>` does NOT — `update()` removes then
-     * re-adds a node's id, moving it to the set's tail. Index-routed queries sort
-     * by this sequence so they return nodes in creation order, matching the old
-     * `nodes.values()` scan that callers like decision-history `slice(-10)` rely on.
-     */
-    private readonly seq;
-    private seqCounter;
-    /** Assign a stable insertion sequence the first time a node id is seen. */
-    private _trackSeq;
-    /** Exposed for unit-testing only: read current index contents. */
-    getIndex(): ReadonlyMap<string, ReadonlySet<string>>;
-    constructor(sessionDir: string);
-    /**
-     * Add a node. Fires to all matching subscriptions synchronously.
-     * Returns the node with its assigned id.
-     */
-    add(node: Omit<GraphNode, 'id'>): Promise<GraphNode>;
-    /** Update an existing node by id. Returns updated node or null if not found. */
-    update(id: string, patch: Partial<GraphNode>): Promise<GraphNode | null>;
-    get(id: string): GraphNode | undefined;
-    getAll(filter?: NodeFilter): GraphNode[];
-    getGoals(filter?: Partial<{
-        status: GoalStatus;
-        assignee: string;
-        priority: GoalPriority;
-    }>): GoalNode[];
-    getFacts(filter?: Partial<{
-        category: FactCategory;
-        severity: string;
-    }>): FactNode[];
-    getChanges(filter?: Partial<{
-        status: ChangeStatus;
-    }>): ChangeNode[];
-    getOpenGoals(): GoalNode[];
-    getTopLevelGoals(): GoalNode[];
-    getBlockedGoals(): GoalNode[];
-    getPendingChanges(): ChangeNode[];
-    getDecisions(since?: string): DecisionNode[];
-    searchFacts(query: string): FactNode[];
-    getRelatedFacts(factId: string): FactNode[];
-    /**
-     * Subscribe to nodes matching a filter. Returns a channel id that can be
-     * used to poll for new nodes since the last check.
-     */
-    subscribe(agentId: string, filter: NodeFilter): string;
-    /**
-     * Poll for new nodes delivered to a channel since last check.
-     * Clears the delivery buffer after reading.
-     */
-    poll(channel: string): GraphNode[];
-    unsubscribe(channel: string): void;
-    /**
-     * Create a quality gate result. Call this when a change is being proposed
-     * so the change node carries the gate result.
-     */
-    static makeQualityGate(checks: {
-        name: string;
-        passed: boolean;
-        detail?: string;
-    }[]): QualityGateResult;
-    /** Pure: compute the set of index keys a node would belong to. */
-    private _indexKeys;
-    /** Mutate the index: add a node's id to every set for the given keys. */
-    private _addToIndex;
-    /** Remove a node's id from all index sets for the given keys. */
-    private _removeFromIndex;
-    private _matches;
-    private _deliver;
-    private _persist;
-    private _append;
-    /** Rebuild in-memory state from the log file. Call on startup. */
-    load(): Promise<void>;
-    /** Snapshot for serialization. */
-    snapshot(): {
-        nodes: GraphNode[];
-        subs: number;
-    };
-}
-
-type AutonomousDecisionType = 'spawn' | 'approve_change' | 'reject_change' | 'prioritize_goals' | 'escalate_task' | 'rollback_change' | 'retry_task' | 'merge_results' | 'decompose_goal' | 'assign_task';
-interface AutonomousDecisionRequest {
-    id: string;
-    source: BrainDecisionSource;
-    decisionType: AutonomousDecisionType;
-    question: string;
-    context: {
-        /** Relevant facts from the knowledge graph */
-        facts?: FactNode[];
-        /** Goals relevant to this decision */
-        goals?: GoalNode[];
-        /** Change being reviewed (for approval decisions) */
-        change?: ChangeNode;
-        /** Current fleet status */
-        fleetStatus?: {
-            running: number;
-            idle: number;
-            total: number;
-            costSoFar: number;
-        };
-        /** Task that triggered this decision */
-        taskDescription?: string;
-        /** Error that triggered escalation, if any */
-        error?: string;
-        /** Number of times this task has been attempted */
-        attempts?: number;
-    };
-    options: BrainDecisionOption[];
-    risk: BrainRisk;
-    /** Whether this decision requires consensus */
-    requiresConsensus: boolean;
-}
-interface SpawnDecision {
-    role: string;
-    budget: {
-        timeoutMs?: number;
-        maxIterations?: number;
-        maxToolCalls?: number;
-        maxCostUsd?: number;
-    };
-    rationale: string;
-}
-interface ApprovalDecision {
-    approved: boolean;
-    rationale: string;
-    waivers?: string[];
-    conditions?: string[];
-}
-interface PrioritizationDecision {
-    orderedGoals: string[];
-    rationale: string;
-}
-interface EscalationDecision {
-    action: 'retry' | 'delegate' | 'mark_failed' | 'ask_for_help';
-    rationale: string;
-    budgetAdjustment?: {
-        increaseFactor?: number;
-        newTimeoutMs?: number;
-        addModel?: string;
-    };
-}
-interface AutonomousBrainOptions {
-    /** The LLM provider for making decisions */
-    llmProvider: LLMProvider;
-    graph: KnowledgeGraph;
-    fleet?: FleetBus | undefined;
-    /** Maximum retries before a task is marked failed. Default: 3. */
-    maxRetries?: number | undefined;
-    /** Risk threshold above which consensus is required. Default: 'high'. */
-    consensusRiskThreshold?: BrainRisk | undefined;
-    /** Self-improve: track decision history for learning. Default: true. */
-    selfImprove?: boolean | undefined;
-}
-interface LLMProvider {
-    /**
-     * Generate a decision. Receives the full context as a structured prompt.
-     * Returns the chosen option id and rationale.
-     */
-    decide(prompt: DecisionPrompt): Promise<{
-        optionId: string;
-        rationale: string;
-    }>;
-}
-interface DecisionPrompt {
-    decisionType: AutonomousDecisionType;
-    question: string;
-    context: string;
-    options: BrainDecisionOption[];
-    risk: BrainRisk;
-    decisionHistory: DecisionNode[];
-    /** Hints derived from self-improvement data */
-    selfImproveHints?: string[];
-}
-declare class AutonomousBrain implements BrainArbiter {
-    private readonly graph;
-    private readonly fleetBus?;
-    private readonly llmProvider;
-    private readonly maxRetries;
-    private readonly consensusRiskThreshold;
-    private readonly selfImprove;
-    /** Decision history for self-improvement and audit. */
-    private decisionHistory;
-    /** Tracks failure patterns for self-improvement. */
-    private failurePatterns;
-    private readonly RISK_ORDER;
-    private _emit;
-    constructor(opts: AutonomousBrainOptions);
-    /** Implements BrainArbiter — bridges standard brain.ts interface to autonomous engine. */
-    decide(request: BrainDecisionRequest): Promise<BrainDecision>;
-    /**
-     * Primary autonomous decision engine — receives AutonomousDecisionRequest,
-     * queries the LLM, records the decision, and returns a BrainDecision.
-     *
-     * Specialized methods (decideSpawn, decideApproval, etc.) should call this
-     * directly with a pre-built AutonomousDecisionRequest.
-     */
-    decideAuto(request: AutonomousDecisionRequest): Promise<BrainDecision>;
-    /**
-     * Decide whether to spawn a subagent, which role to use, and what budget.
-     */
-    decideSpawn(source: BrainDecisionSource, taskDescription: string, availableFacts: FactNode[], fleetStatus: {
-        running: number;
-        idle: number;
-        total: number;
-        costSoFar: number;
-    }): Promise<BrainDecision>;
-    /**
-     * Decide whether to approve a proposed change.
-     */
-    decideApproval(source: BrainDecisionSource, change: ChangeNode, relevantFacts: FactNode[]): Promise<BrainDecision>;
-    /**
-     * Decide how to handle a failed task.
-     */
-    decideEscalation(source: BrainDecisionSource, taskId: string, error: string, attempts: number): Promise<BrainDecision>;
-    /**
-     * Record the outcome of a decision for self-improvement.
-     * Call this after a spawned agent completes or a change is applied.
-     */
-    recordOutcome(decisionId: string, outcome: 'success' | 'failure', _detail?: string): void;
-    private _getSelfImproveHints;
-    private _toAutonomous;
-    private _inferDecisionType;
-    private _serializeContext;
-    private _loadHistory;
-    private _recordDecision;
-    private _inferRoles;
-    private _changeRisk;
-}
-
-/**
- * TaskDAG — Directed Acyclic Graph of tasks with fork/join semantics.
- *
- * Replaces the Director's flat `awaitTasks()` with a proper dependency graph.
- * Each task has explicit dependencies; the DAG resolves which tasks are
- * runnable at any moment and manages blocking/unblocking as tasks complete.
- *
- * Key features:
- * - Fork: one parent spawns multiple children that run in parallel
- * - Join: a task can wait for multiple children before continuing
- * - Dynamic: tasks can be added dynamically; the graph re-evaluates runnable set
- * - Cycle detection: inserting a dependency that would create a cycle throws
- * - Priority queue: within a "runnable" set, tasks are ordered by priority
- * - Deadlock detection: if no tasks are runnable and no tasks are complete,
- *   the DAG is in deadlock — agents are notified
- *
- * @module task-dag
- */
-/** Represents a node in the DAG. */
-interface DAGNode {
-    id: string;
-    description: string;
-    role?: string;
-    priority: number;
-    status: DAGNodeStatus;
-    deps: string[];
-    dependents: string[];
-    result?: unknown;
-    error?: string;
-    spawnedAt?: string;
-    completedAt?: string;
-    assignedTo?: string;
-    tags: string[];
-}
-type DAGNodeStatus = 'pending' | 'ready' | 'running' | 'done' | 'failed' | 'skipped';
-/** Event emitted by the DAG on state changes. */
-type DAGEdgeEvent = {
-    type: 'node:ready';
-    nodeId: string;
-    deps: string[];
-} | {
-    type: 'node:started';
-    nodeId: string;
-    assignedTo: string;
-} | {
-    type: 'node:completed';
-    nodeId: string;
-    result: unknown;
-    blockers: string[];
-} | {
-    type: 'node:failed';
-    nodeId: string;
-    error: string;
-    blockers: string[];
-} | {
-    type: 'node:skipped';
-    nodeId: string;
-    reason: string;
-} | {
-    type: 'deadlock';
-    blocked: string[];
-} | {
-    type: 'graph:done';
-    allDone: boolean;
-};
-type DAGEdgeHandler = (event: DAGEdgeEvent) => void;
-/** Callback invoked when the DAG produces a set of runnable tasks. */
-type RunnablesHandler = (nodes: DAGNode[]) => void;
-declare class TaskDAG {
-    private readonly nodes;
-    private readonly handlers;
-    private readonly runnablesHandlers;
-    private runnableCache;
-    /**
-     * Add a task node. Dependencies are validated for cycles.
-     * Throws if adding a dep would create a cycle.
-     */
-    addNode(id: string, description: string, deps?: string[], opts?: {
-        role?: string;
-        priority?: number;
-        tags?: string[];
-    }): void;
-    /**
-     * Remove a node and all edges to/from it.
-     * Skips any dependents that would become dangling.
-     */
-    removeNode(id: string): void;
-    /**
-     * Mark a task as running. Returns true if the transition was valid
-     * (task was in 'ready' state), false otherwise.
-     */
-    start(id: string, assignedTo: string): boolean;
-    /**
-     * Mark a task as completed. Unblocks all dependents; they become 'ready'
-     * if all their deps are done.
-     */
-    complete(id: string, result: unknown): void;
-    /**
-     * Mark a task as failed. Unblocks dependents but they remain 'pending'
-     * (they may still be runnable if other deps succeeded).
-     */
-    fail(id: string, error: string): void;
-    /**
-     * Skip a task (e.g., it was deemed unnecessary by an earlier step).
-     * Treats it as done for dependency purposes.
-     */
-    skip(id: string, reason: string): void;
-    getNode(id: string): DAGNode | undefined;
-    getAll(): DAGNode[];
-    getReady(): DAGNode[];
-    getRunning(): DAGNode[];
-    getPending(): DAGNode[];
-    getDone(): DAGNode[];
-    getFailed(): DAGNode[];
-    getCompleted(): DAGNode[];
-    isDone(): boolean;
-    isFailed(): boolean;
-    /** All tasks that are currently blocked (pending but not ready). */
-    getBlocked(): DAGNode[];
-    /** Topological sort — tasks in dependency order. */
-    getTopologicalOrder(): DAGNode[];
-    /** Check for deadlock: no runnable tasks but not done. */
-    hasDeadlock(): boolean;
-    /** Stats snapshot for reporting. */
-    stats(): {
-        total: number;
-        pending: number;
-        ready: number;
-        running: number;
-        done: number;
-        failed: number;
-        skipped: number;
-        progress: number;
-    };
-    onEvent(handler: DAGEdgeHandler): () => void;
-    onRunnable(handler: RunnablesHandler): () => void;
-    private _transition;
-    private _emit;
-    private _emitReady;
-    private invalidateCache;
-    /**
-     * DFS cycle detection. Adding edge (id → dep) creates a cycle if
-     * there already exists a path from dep to id.
-     */
-    private _wouldCycle;
-}
-
-interface TaskBid {
-    id: string;
-    taskId: string;
-    agentId: string;
-    agentName: string;
-    agentRole: string;
-    /** Dispatcher score for this task */
-    score: number;
-    /** Why this agent is a good fit */
-    rationale: string;
-    submittedAt: string;
-}
-interface TaskAuctionOptions {
-    graph: KnowledgeGraph;
-    fleet?: FleetBus | undefined;
-    mailbox?: Mailbox | undefined;
-    selfAgentId?: string | undefined;
-    /** How long a bid window stays open before auto-awarding. Default: 30s */
-    bidWindowMs?: number | undefined;
-    /** Maximum concurrent tasks per agent. Default: 3 */
-    maxTasksPerAgent?: number | undefined;
-    /** Minimum confidence threshold for dispatcher scoring. Default: 0.3 */
-    minConfidence?: number | undefined;
-    /**
-     * Maximum times a task can be republished when no bids are received.
-     * After this, the task is marked as 'failed' with reason 'no_bids'.
-     * Default: 3.
-     */
-    maxBidRetries?: number | undefined;
-}
-declare class TaskAuctioneer {
-    private readonly graph;
-    private readonly fleet?;
-    private readonly mailbox?;
-    private readonly selfAgentId;
-    private readonly bidWindowMs;
-    private readonly maxTasksPerAgent;
-    private readonly minConfidence;
-    private readonly maxBidRetries;
-    /** Pending bids keyed by taskId. */
-    private readonly pendingBids;
-    /** Active bid windows keyed by taskId. */
-    private readonly bidTimers;
-    /** FleetBus subscription disposers, detached in dispose(). */
-    private readonly unsubs;
-    /** How many times a task has been republished with no bids received. */
-    private readonly bidRetryCounts;
-    /** Agent → current task count (from graph + in-flight). */
-    private readonly agentTaskCounts;
-    constructor(opts: TaskAuctionOptions);
-    /**
-     * Detach all FleetBus subscriptions and cancel any open bid-window timers.
-     * Call when the owning coordinator stops/restarts so handlers and timers
-     * don't accumulate across cycles.
-     */
-    dispose(): void;
-    /**
-     * Publish a new task to the auction. Creates a GoalNode and broadcasts
-     * it to all online agents. Returns the goal id.
-     *
-     * If `targetAgent` is specified, the task is assigned directly without auction.
-     */
-    publishTask(input: {
-        title: string;
-        description: string;
-        priority?: GoalPriority;
-        tags?: string[];
-        targetAgent?: string;
-        parentGoal?: string;
-        satisfiesGoals?: string[];
-        /** Goal ids that must reach 'done' before this goal becomes workable. */
-        blockedBy?: string[];
-        deadline?: string;
-        reward?: string;
-    }): Promise<string>;
-    /**
-     * Submit a bid for a task. Called by agents who want to work on it.
-     * Returns true if the bid was accepted, false if the task was already claimed.
-     */
-    bid(taskId: string, agent: {
-        agentId: string;
-        agentName: string;
-        agentRole: string;
-    }, rationale: string): Promise<boolean>;
-    /**
-     * Award a task to a specific agent. Called internally by the bid window
-     * expiry, or can be called directly to force an award.
-     */
-    claim(taskId: string, agentId: string, agentName: string): Promise<boolean>;
-    /**
-     * Mark a task as done. Called by the agent when it finishes.
-     */
-    complete(taskId: string, _result?: string): Promise<void>;
-    /**
-     * Mark a task as failed. Optionally spawn a retry.
-     */
-    fail(taskId: string, error: string): Promise<void>;
-    /**
-     * Find the best available tasks for an agent based on its capabilities.
-     * Returns tasks sorted by match score (best first).
-     */
-    findWork(_agentId: string, agentRole: string, limit?: number): Promise<{
-        task: GoalNode;
-        score: number;
-        bids: number;
-    }[]>;
-    /** Get all pending tasks (available for bidding). */
-    getPendingTasks(): GoalNode[];
-    /** Get tasks assigned to a specific agent. */
-    getTasksForAgent(agentId: string): GoalNode[];
-    /** Get the current bid count for a task. */
-    getBidCount(taskId: string): number;
-    /** Get bids for a task. */
-    getBids(taskId: string): TaskBid[];
-    /** Get task stats for a project-wide dashboard. */
-    getStats(): {
-        total: number;
-        pending: number;
-        in_progress: number;
-        done: number;
-        failed: number;
-        totalBids: number;
-        avgBidsPerTask: number;
-    };
-    private _emit;
-    private _broadcastTask;
-    private _mailboxPublish;
-    private _notifyAgent;
-    private _startBidWindow;
-    private _cancelBidWindow;
-    private _evaluateBids;
-    private _assignDirect;
-    private _onBidEvent;
-    private _onClaimedEvent;
-    private _getAgentTaskCount;
-    private agentTaskCount;
-}
-
-/**
- * ConsensusProtocol — agent voting on proposed changes.
- *
- * Enables autonomous approval of code changes without a human. Agents register
- * as voters with a role weight; changes gather votes; the protocol resolves
- * the outcome based on configured quorum rules.
- *
- * Voting rules (configurable):
- * - Quorum: minimum fraction of eligible voters required (default: 0.5)
- * - Approval threshold: minimum fraction of cast votes that must be approve (default: 0.6)
- * - Veto roles: roles whose 'reject' vote is fatal regardless of count
- * - Auto-approve: changes with severity=critical bypass voting if the proposer is trusted
- *
- * The protocol is stateless — it reads from the KnowledgeGraph and writes results
- * back to it. This makes it naturally consistent with the shared knowledge model.
- *
- * @module consensus-protocol
- */
-
-interface VoterConfig {
-    agentId: string;
-    agentName: string;
-    role: string;
-    /** Weight multiplier for this voter's vote. Default: 1. */
-    weight: number;
-    /** If true, a 'reject' vote from this role is a hard veto. Default: false. */
-    veto?: boolean;
-    /**
-     * @deprecated Not yet implemented. Auto-approve of low-risk changes is planned
-     * but not wired up in the vote resolution logic.
-     */
-    autoApprovesLowRisk?: boolean;
-}
-interface QuorumRule {
-    /** Fraction of eligible voters required (0-1). Default: 0.5. */
-    quorumFraction: number;
-    /** Fraction of cast votes that must be approve (0-1). Default: 0.6. */
-    approvalFraction: number;
-    /** Roles whose reject vote is a hard veto regardless of count. */
-    vetoRoles: string[];
-    /** Minimum total weight of approve votes to pass (0-1 of total eligible weight). */
-    approvalWeightFraction?: number | undefined;
-}
-interface ConsensusResult {
-    changeId: string;
-    outcome: 'approved' | 'rejected' | 'pending' | 'vetoed' | 'quorum_not_met';
-    votes: VoteRecord[];
-    approveCount: number;
-    rejectCount: number;
-    abstainCount: number;
-    totalWeightApprove: number;
-    totalWeightReject: number;
-    eligibleVoters: string[];
-    quorumMet: boolean;
-    approvalMet: boolean;
-    vetoedBy?: string;
-    rationale: string;
-}
-interface ConsensusOptions {
-    rules?: Partial<QuorumRule>;
-    voters: VoterConfig[];
-    graph: KnowledgeGraph;
-    fleet?: FleetBus | undefined;
-}
-/**
- * ConsensusProtocol manages voting on ChangeNodes in the KnowledgeGraph.
- * It is instantiated once per autonomous session and used to initiate votes,
- * cast votes, and resolve outcomes.
- */
-declare class ConsensusProtocol {
-    private readonly graph;
-    private readonly fleet?;
-    private readonly rules;
-    private readonly voters;
-    constructor(opts: ConsensusOptions);
-    /**
-     * Initiate a vote on a proposed change. Updates the change node's status
-     * to 'proposed' and notifies eligible voters via FleetBus.
-     */
-    initiateVote(changeId: string): Promise<void>;
-    /**
-     * Cast a vote. Updates the change node in the graph and re-evaluates
-     * consensus. If the vote triggers a resolution, updates the change status.
-     */
-    castVote(changeId: string, voterId: string, value: VoteValue, rationale?: string): Promise<ConsensusResult>;
-    /**
-     * Resolve the current vote without waiting for all eligible voters.
-     * Useful when a timeout fires or an agent decides to finalize early.
-     */
-    resolveNow(changeId: string): Promise<ConsensusResult>;
-    /**
-     * Register or update a voter's configuration.
-     */
-    registerVoter(config: VoterConfig): void;
-    /**
-     * Get the current vote status for a change.
-     */
-    getStatus(changeId: string): ConsensusResult | null;
-    private _eligibleVoters;
-    private _resolve;
-    private _toChangeStatus;
-    private _notifyVoters;
-}
-
-/**
- * ChangeManager — autonomous code change lifecycle management.
- *
- * Manages the full lifecycle of proposed code changes:
- *   PROPOSE → REVIEW (consensus) → APPLY → VERIFY → (ROLLBACK on failure)
- *
- * The manager does NOT write files directly — it publishes change nodes to the
- * KnowledgeGraph and uses the ConsensusProtocol for approvals. File mutations
- * are performed by agents acting on approved change nodes.
- *
- * Quality gates run automatically before approval:
- * - Tests must pass (or be explicitly waived)
- * - TypeScript must compile
- * - No new critical/high security findings
- * - Lint must pass (or be explicitly ignored)
- *
- * Rollback: on failure detection, the manager can propose a rollback change
- * that reverses the applied change. Rollback changes also go through consensus.
- *
- * @module change-manager
- */
-
-interface ChangeFile {
-    path: string;
-    action: 'create' | 'modify' | 'delete';
-    /** For modify: unified diff string */
-    diff?: string;
-    /** For create/modify: full file content */
-    content?: string;
-}
-interface ChangeProposal {
-    title: string;
-    description: string;
-    files: ChangeFile[];
-    proposedBy: string;
-    satisfiesGoals: string[];
-    tags: string[];
-    /** Quality gate waivers (e.g., ['no-tests', 'lint-errors']) */
-    waivers?: string[];
-    /** Skip consensus vote (for automated/internal refactors only) */
-    skipVote?: boolean;
-}
-interface ApplyResult {
-    changeId: string;
-    success: boolean;
-    appliedAt: string;
-    filesTouched: string[];
-    verificationResult?: QualityGateResult;
-    rollbackChangeId?: string | undefined;
-    error?: string | undefined;
-}
-interface RollbackResult {
-    originalChangeId: string;
-    rollbackChangeId: string;
-    success: boolean;
-    rolledBackAt: string;
-    error?: string;
-}
-/** Quality checks performed before applying a change. */
-interface QualityGateChecks {
-    runTests: boolean;
-    runTypecheck: boolean;
-    runLint: boolean;
-    runSecurityScan: boolean;
-    checkTestCoverage: boolean;
-    minCoveragePercent?: number;
-}
-interface ChangeManagerOptions {
-    graph: KnowledgeGraph;
-    consensus: ConsensusProtocol;
-    fleet?: FleetBus | undefined;
-    checks?: Partial<QualityGateChecks> | undefined;
-}
-/**
- * Default quality gate: tests + typecheck + security scan.
- * Lint and coverage are informational warnings, not blockers.
- */
-declare const DEFAULT_QUALITY_CHECKS: QualityGateChecks;
-/**
- * ChangeManager orchestrates the full change lifecycle.
- *
- * ## Workflow
- * ```
- * propose() → knowledge graph (proposed)
- *            → consensus.vote() (approved/rejected)
- *            → apply() → knowledge graph (applied)
- *            → verify() → on failure: proposeRollback()
- * ```
- */
-declare class ChangeManager {
-    private readonly graph;
-    private readonly consensus;
-    private readonly fleet?;
-    private readonly checks;
-    /** Track applied changes for rollback lookup. */
-    private readonly appliedChanges;
-    constructor(opts: ChangeManagerOptions);
-    /**
-     * Propose a new code change. Creates a ChangeNode in the knowledge graph.
-     * Does NOT automatically initiate voting — call `submitForReview()` for that.
-     */
-    propose(input: ChangeProposal): Promise<ChangeNode>;
-    /**
-     * Submit an approved change for application.
-     * Returns the change node — actual file mutations are performed by agents
-     * acting on this node's data from the knowledge graph.
-     */
-    submitForReview(changeId: string): Promise<void>;
-    /**
-     * Apply an approved change. Updates the change node to 'applied'.
-     * Agents should watch for 'applied' status and perform the actual file mutations.
-     */
-    markApplied(changeId: string, appliedAt: string): Promise<ChangeNode | null>;
-    /**
-     * Mark a change as applied and trigger rollback for any satisfied goal
-     * that turns out to be broken.
-     */
-    markAppliedWithVerification(changeId: string, verify: () => Promise<QualityGateResult>): Promise<ApplyResult>;
-    /**
-     * Propose a rollback for an applied change. Creates a new change that
-     * reverses the original. Goes through full consensus.
-     */
-    proposeRollback(appliedChangeId: string, reason: string): Promise<ChangeNode | null>;
-    /**
-     * Mark a change as rolled back.
-     */
-    markRolledBack(changeId: string, rolledBackAt: string): Promise<ChangeNode | null>;
-    getPendingReviews(): ChangeNode[];
-    getAppliedChanges(): ChangeNode[];
-    getChange(id: string): ChangeNode | undefined;
-    getChangesForGoal(goalId: string): ChangeNode[];
-    /**
-     * Run quality gate checks. This is informational — actual test/lint/typecheck
-     * execution is done by agents spawned for this purpose. This method stores
-     * the result in the change node.
-     */
-    private _runQualityGate;
-    /**
-     * Update quality gate result for a change. Called by verify agents
-     * after running their checks.
-     */
-    updateQualityGate(changeId: string, checkName: string, result: {
-        passed: boolean;
-        detail?: string;
-    }): Promise<void>;
-    private _emit;
-}
-
-/**
- * CoordinatorEvent — union of all event types emitted by the AutonomousCoordinator.
- * Consumed by the TUI to drive coordinator panel state and the reducer.
- */
-type CoordinatorEvent = {
-    type: 'goal:added';
-    goalId: string;
-    title?: string;
-    text?: string;
-    participants?: string[];
-} | {
-    type: 'goal:completed';
-    goalId: string;
-    text?: string;
-    participants?: string[];
-} | {
-    type: 'goal:failed';
-    goalId: string;
-    text?: string;
-} | {
-    type: 'task:ready';
-    goalId: string;
-    taskId: string;
-    title?: string;
-    assignedTo?: string;
-    text?: string;
-} | {
-    type: 'task:completed';
-    goalId: string;
-    taskId: string;
-    text?: string;
-} | {
-    type: 'knowledge:added';
-    knowledgeId: string;
-    title?: string;
-    text?: string;
-} | {
-    type: 'consensus:reached';
-    goalId: string;
-    text?: string;
-    participants?: string[];
-} | {
-    type: 'deadlock:detected';
-    goalId: string;
-    text?: string;
-} | {
-    type: 'coordinator:mode';
-    mode: 'standalone' | 'fleet';
-};
-
-interface AutonomousCoordinatorOptions {
-    sessionDir: string;
-    selfAgentId: string;
-    selfAgentName: string;
-    fleet?: FleetBus | undefined;
-    fleetManager?: FleetManager | undefined;
-    director?: Director | undefined;
-    mailbox?: Mailbox | undefined;
-    events?: EventBus | undefined;
-    llmProvider: LLMProvider;
-    /** Disable self-improvement. Default: false. */
-    disableSelfImprove?: boolean;
-    /** Max concurrent subagents. Default: 5. */
-    maxConcurrentAgents?: number;
-    /**
-     * Called with every CoordinatorEvent so the caller (e.g. execution.ts)
-     * can forward it to the TUI coordinator panel timeline.
-     */
-    onCoordinatorEvent?: (event: CoordinatorEvent) => void;
-}
-interface RunOptions {
-    /** Top-level goal description. Default: "Improve the codebase". */
-    goal?: string;
-    /** If true, the loop runs until all goals are done (no timeout). Default: false. */
-    runUntilComplete?: boolean;
-    /** Max iterations. Default: 100. */
-    maxIterations?: number;
-    /** Stop if cost exceeds this. Default: no limit. */
-    maxCostUsd?: number;
-}
-interface CoordinatorStats {
-    goals: {
-        total: number;
-        done: number;
-        pending: number;
-        failed: number;
-        progress: number;
-    };
-    dag: ReturnType<TaskDAG['stats']>;
-    auction: ReturnType<TaskAuctioneer['getStats']>;
-    changes: {
-        proposed: number;
-        approved: number;
-        applied: number;
-        rejected: number;
-    };
-    decisions: number;
-    costSoFar?: number | undefined;
-}
-/**
- * AutonomousCoordinator — wires all coordination components into one engine.
- *
- * ## Quick start
- *
- * ```typescript
- * const coord = new AutonomousCoordinator({
- *   sessionDir: '/tmp/session',
- *   selfAgentId: 'director-1',
- *   selfAgentName: 'Director',
- *   llmProvider: myLLMProvider,
- *   fleet: myFleetBus,
- *   mailbox: myMailbox,
- * });
- *
- * // Run a self-directing session
- * await coord.run({ goal: 'Audit and fix all security issues in the auth module' });
- * ```
- */
-declare class AutonomousCoordinator {
-    readonly graph: KnowledgeGraph;
-    readonly dag: TaskDAG;
-    readonly auction: TaskAuctioneer;
-    readonly consensus: ConsensusProtocol;
-    readonly changes: ChangeManager;
-    readonly brain: AutonomousBrain;
-    private readonly selfAgentId;
-    private readonly fleet?;
-    private readonly fleetManager?;
-    private readonly director?;
-    private readonly mailbox?;
-    private readonly events?;
-    private readonly onCoordinatorEvent?;
-    private running;
-    private iterationCount;
-    private lastSyncAt;
-    private static readonly SYNC_INTERVAL_MS;
-    /** Tasks already handled by _onSubagentTerminated (to avoid double goal:failed on fleet event). */
-    private readonly _handledBySubagent;
-    /** FleetBus subscription disposers, detached in dispose(). */
-    private readonly unsubs;
-    constructor(opts: AutonomousCoordinatorOptions);
-    /**
-     * Run the autonomous loop until the goal is satisfied or max iterations reached.
-     * This is the main entry point for a fully autonomous session.
-     */
-    run(opts?: RunOptions): Promise<CoordinatorStats>;
-    /** Stop the autonomous loop. */
-    stop(): void;
-    /**
-     * Report that a terminal worker (not a Director subagent) completed a claimed
-     * task. This updates the auction, DAG, publishes a task-result fact, and
-     * extracts follow-up goals — the same path as subagent completion.
-     */
-    reportTaskCompletion(taskId: string, result: string): Promise<void>;
-    /**
-     * Report that a terminal worker failed a claimed task.
-     */
-    reportTaskFailure(taskId: string, error: string): Promise<void>;
-    /**
-     * Reload the KnowledgeGraph from disk and sync the in-memory DAG with any
-     * changes published by other terminal sessions. New goals are added to the
-     * DAG; existing goals whose status changed (e.g. completed by another
-     * terminal) are transitioned accordingly.
-     *
-     * Safe to call at any time — also used internally by the run loop.
-     */
-    syncFromGraph(): Promise<void>;
-    private _syncDagStatuses;
-    private _maybeSyncFromGraph;
-    /**
-     * Tear down the coordinator for good: stop the loop and detach all FleetBus
-     * subscriptions (this coordinator's + the auctioneer's) plus any open bid
-     * timers. Call this when discarding the instance (e.g. `/coordinator stop`
-     * that recreates a fresh coordinator on the next start) so handlers and
-     * timers don't accumulate across cycles. `stop()` only pauses the loop.
-     */
-    dispose(): void;
-    /** Get a stats snapshot. */
-    getStats(): CoordinatorStats;
-    /**
-     * Publish a fact discovered by an agent. Facts are immutable and form
-     * the basis for other agents' decisions.
-     */
-    publishFact(input: {
-        category: FactCategory;
-        subject: string;
-        detail: string;
-        file?: string;
-        line?: number;
-        severity?: 'critical' | 'high' | 'medium' | 'low';
-        tags?: string[];
-    }): Promise<FactNode>;
-    /**
-     * Publish a goal and add it to the DAG.
-     */
-    createGoal(input: {
-        title: string;
-        description: string;
-        priority?: 'critical' | 'high' | 'medium' | 'low';
-        deps?: string[];
-        tags?: string[];
-    }): Promise<GoalNode>;
-    private _waitForDagProgress;
-    private _dagProgressKey;
-    private _rebuildDagFromGraph;
-    private _rebuildDagNode;
-    private _decomposeGoal;
-    private _inferCategory;
-    private _processGoal;
-    private _stringifyTaskResult;
-    private _completeTask;
-    private _publishTaskResultFact;
-    private _createFollowUpGoalsFromResult;
-    private _extractFollowUps;
-    private _failTask;
-    private _recordTaskFailed;
-    private _handlePendingChange;
-    private _onDagEvent;
-    private _onSubagentTerminated;
-    private _fleetStatus;
-    private _buildVoters;
-    private _goalToOptions;
-    private _optionToGoal;
-    private _mailboxBroadcast;
-    /** Emit a CoordinatorEvent to the subscriber (e.g. TUI panel timeline). */
-    private _emit;
-}
-
-export { type AcquireOptions, type AcquireResult, AdaptiveConcurrencyController, type AdaptiveConcurrencyState, AgentDefinition, AgentHeartbeatInput, type AgentMonitorOptions, AgentMonitorService, AgentRegistrationInput, type AgentTimelineEntry, type AgentVirtualSession, type ApplyResult, type ApprovalDecision, AutonomousBrain, type AutonomousBrainOptions, AutonomousCoordinator, type AutonomousCoordinatorOptions, type AutonomousDecisionRequest, type AutonomousDecisionType, BUILD_AGENTS, BrainArbiter, BrainDecision, BrainDecisionOption, BrainDecisionRequest, BrainDecisionSource, type BrainInterventionInput, BrainMonitor, type BrainMonitorOptions, BrainRisk, type ChangeFile, ChangeManager, type ChangeManagerOptions, type ChangeNode, type ChangeProposal, type ChangeStatus, ClientHeartbeatInput, ClientRegistrationInput, ClientStatus, type ConsensusOptions, ConsensusProtocol, type ConsensusResult, type CoordinatorEvent, type CoordinatorStats, type DAGEdgeEvent, type DAGEdgeHandler, type DAGNode, type DAGNodeStatus, DEFAULT_MAX_FLEET_SPAWNS, DEFAULT_QUALITY_CHECKS, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, type DecisionNode, type DecisionPrompt, DefaultMailbox, type DepWatchEntry, type DepWatcherBridgeOptions, type DependencyWatcherConfig, Director, type DownAlertInput, type EscalationDecision, type FactCategory, type FactNode, FleetBus, FleetManager, type FleetStatusToolOptions, FleetSupervisor, type FleetSupervisorActions, FleetSupervisorConfig, type FleetSupervisorOptions, type FleetSupervisorSource, GlobalMailbox, type GoalNode, type GoalPriority, type GoalStatus, type GraphSubscription, HARD_MAX_SPAWN_DEPTH, KNOWLEDGE_AGENTS, KnowledgeGraph, type LLMProvider, type LiveLockResult, MAILBOX_BRIDGE_LOCK_FILENAME, MAILBOX_BRIDGE_TOKEN_FILENAME, MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD, MAILBOX_HEALTH_DEFAULT_FROM, MAILBOX_HEALTH_DEFAULT_INTERVAL_MS, MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS, MATRIX_PHASE_KEYS, MAX_SUBAGENT_STRUCTURED_REPORT_CHARS, META_AGENTS, type MailToolsOptions, Mailbox, MailboxAckBatchInput, MailboxAckInput, type MailboxActionInput, type MailboxActionResult, MailboxAgentStatus, type MailboxBridgeLock, type MailboxHealthEvent, MailboxHealthWatchdog, type MailboxHealthWatchdogOptions, type MailboxHooksOptions, MailboxMessage, type MailboxMessageAction, MailboxQuery, type MailboxResolver, MailboxSendInput, type MailboxToolOptions, type MatrixKeyKind, type ModelMatrixResolution, type ModelMatrixResolutionSource, type ModelReference, type NodeFilter, type NodeType, type OutdatedNotifyMessage, PLANNING_AGENTS, type PackageAuthorEntry, type PackageAuthorLog, type PackageAuthorTrackerOptions, type PackageOutdatedEntry, type PackageOutdatedResult, type PackageOutdatedWatcherOptions, type PrioritizationDecision, PurgeOptions, PurgeResult, type QualityCheck, type QualityGateChecks, type QualityGateResult, type QuorumRule, REVIEW_AGENTS, type RecoveryAlertInput, type ResolvedModelTarget, type ResolvedSubagentModelTarget, type RollbackResult, type RunOptions, type RunnablesHandler, SUBAGENT_STRUCTURED_REPORT_META_KEY, type SpawnDecision, type SupervisedSubagent, type SupervisorLogEntry, type TaskAuctionOptions, TaskAuctioneer, type TaskBid, TaskDAG, VERIFY_AGENTS, type VoteNode, type VoteRecord, type VoteValue, type VoterConfig, type WatchdogConfig, acquireOrJoin, actionToAckInput, attachDepWatcherBridge, buildDownAlert, buildRecoveryAlert, createAgentMonitorService, createMailboxHooks, detectEcosystem, finalize, formatSubagentStructuredReport, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, isValidMatrixKey, mailboxSessionTag, makeDependencyWatcherConfig, makeFleetStatusTool, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeSubagentResultTool, matrixKeyKind, normalizeSubagentStructuredReport, phaseForRole, readLiveLock, readSubagentStructuredReport, recordPackageAction, release, resolveImplementationModelTarget, resolveMailboxIdentity, resolveMaxSpawnDepth, resolveModelMatrix, resolveModelMatrixResolution, resolveModelTargetFromEntry, resolveSubagentModelTarget, roleNeedsIndependentReviewModel, sameModelReference, startPackageOutdatedWatcher, updatePackageOutdatedStatus, validateWatchdogOptions };
+export { createMessage, InMemoryAgentBridge, InMemoryBridgeTransport, } from './agent-bridge.js';
+export { type AgentFactory, type AgentFactoryResult, type AgentRunnerOptions, makeAgentSubagentRunner, withDisabledToolFiltering, } from './agent-subagent-runner.js';
+export { AGENT_CATALOG, AGENTS_BY_PHASE, type AgentBudgetTier, type AgentCapability, type AgentDefinition, type AgentPhase, ALL_AGENT_DEFINITIONS, BUILD_AGENTS, DELIVERY_AGENTS, DISCOVERY_AGENTS, DOMAIN_AGENTS, getAgentDefinition, HEAVY_BUDGET, KNOWLEDGE_AGENTS, LIGHT_BUDGET, MEDIUM_BUDGET, META_AGENTS, PLANNING_AGENTS, REVIEW_AGENTS, TOOLS as AGENT_TOOL_PRESETS, VERIFY_AGENTS, } from './agents/index.js';
+export { type AutoExtendCeiling, type AutoExtendPolicy, attachAutoExtend, } from './auto-extend.js';
+export { type BrainArbiter, type BrainDecision, type BrainDecisionOption, BrainDecisionQueue, type BrainDecisionRequest, type BrainDecisionSource, type BrainFallback, type BrainRisk, DefaultBrainArbiter, type DefaultBrainArbiterOptions, formatHumanPrompt, HumanEscalatingBrainArbiter, ObservableBrainArbiter, } from './brain.js';
+export { type BrainInterventionInput, BrainMonitor, type BrainMonitorOptions, } from './brain-monitor.js';
+export { type BugFinding, type CollabBudgetConfig, type CollabBudgetOverrides, type CollabBudgetWarningPayload, type CollabDebugReport, CollabSession, type CollabSessionOptions, type CriticConcern, type CriticEvaluation, type DirectorAlert, DirectorAlertLevel, type DirectorCancelCollabPayload, type RefactorPhase, type RefactorPlan, type SharedFileEntry, type SharedFileSnapshot, } from './collab-debug.js';
+export { type CreateDelegateToolOptions, createDelegateTool, type DelegateHost, } from './delegate-tool.js';
+export { DEPENDENCY_FILE_PATTERNS, type DependencyWatcherConfig, type DepWatchEntry, makeDependencyWatcherConfig, } from './dep-watcher.js';
+export { attachDepWatcherBridge, type DepWatcherBridgeOptions, } from './dep-watcher-bridge.js';
+export { Director, FleetCostCapError, FleetSpawnBudgetError, FleetTokenCapError, type TaskResultNotification, } from './director.js';
+export { composeDirectorPrompt, composeSubagentPrompt, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, type DirectorPromptParts, rosterSummaryFromConfigs, type SubagentPromptParts, } from './director-prompts.js';
+export { type DirectorSessionFactory, type DirectorSessionFactoryOptions, makeDirectorSessionFactory, } from './director-session.js';
+export { makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeFleetEmitTool, makeFleetTool, makeFleetTool as makeFleetUsageTool, makeFleetTool as makeFleetSessionTool, makeFleetTool as makeFleetHealthTool, makeKanbanQueueTool, makeQualityGateTool, makeRollUpTool, makeSpawnTool, makeTerminateAllTool, makeTerminateTool, makeWorkCompleteTool, } from './director-tools.js';
+export { DEFAULT_DISPATCH_ROLE, type DispatchCandidate, type DispatchClassifier, type DispatchMethod, type DispatchOptions, type DispatchResult, dispatchAgent, makeLLMClassifier, scoreAgents, } from './dispatcher.js';
+export { ACP_AGENTS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, applyRosterBudget, BUG_HUNTER_AGENT, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, type FleetRosterBudget, REFACTOR_PLANNER_AGENT, SECURITY_SCANNER_AGENT, } from './fleet.js';
+export { FleetBus, type FleetEvent, type FleetHandler, type FleetUsage, FleetUsageAggregator, type SubagentUsageSnapshot, } from './fleet-bus.js';
+export { FleetManager, type FleetManagerOptions, } from './fleet-manager.js';
+export { type FleetStatusToolOptions, makeFleetStatusTool } from './fleet-status-tool.js';
+export { FleetSupervisor, type FleetSupervisorActions, type FleetSupervisorConfig, type FleetSupervisorOptions, type FleetSupervisorSource, type SupervisedSubagent, type SupervisorLogEntry, } from './fleet-supervisor.js';
+export { DEFAULT_MAX_FLEET_SPAWNS, HARD_MAX_SPAWN_DEPTH, resolveMaxSpawnDepth, } from './spawn-budget.js';
+export { GlobalMailbox, resolveProjectDir } from './global-mailbox.js';
+export type { ICoordinator } from './icoordinator.js';
+export type { IFleetManager } from './ifleet-manager.js';
+export { LargeAnswerStore } from './large-answer-store.js';
+export { formatSubagentStructuredReport, MAX_SUBAGENT_STRUCTURED_REPORT_CHARS, makeSubagentResultTool, normalizeSubagentStructuredReport, readSubagentStructuredReport, SUBAGENT_STRUCTURED_REPORT_META_KEY, } from './subagent-result-tool.js';
+export { type MailToolsOptions, makeMailInboxTool, makeMailSendTool } from './mail-tools.js';
+export { DefaultMailbox } from './mailbox.js';
+export type { MailboxActionInput, MailboxActionResult, MailboxMessageAction, } from './mailbox-actions.js';
+export { actionToAckInput } from './mailbox-actions.js';
+export { buildDownAlert, buildRecoveryAlert, type DownAlertInput, MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD, MAILBOX_HEALTH_DEFAULT_FROM, MAILBOX_HEALTH_DEFAULT_INTERVAL_MS, MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS, type MailboxHealthEvent, MailboxHealthWatchdog, type MailboxHealthWatchdogOptions, type RecoveryAlertInput, validateWatchdogOptions, type WatchdogConfig, } from './mailbox-health.js';
+export { createMailboxHooks, type MailboxHooksOptions, } from './mailbox-hooks.js';
+export { type MailboxResolver, type MailboxToolOptions, mailboxSessionTag, makeMailboxTool, resolveMailboxIdentity, } from './mailbox-tool.js';
+export type { AgentHeartbeatInput, AgentRegistrationInput, ClientHeartbeatInput, ClientRegistrationInput, ClientSource, ClientStatus, Mailbox, MailboxAckBatchInput, MailboxAckInput, MailboxAgentStatus, MailboxMessage, MailboxMessageType, MailboxQuery, MailboxSendInput, MailboxTaskContext, PurgeOptions, PurgeResult, ReadReceipts, RegisteredAgent, } from './mailbox-types.js';
+export { normalizeRecipient } from './mailbox-types.js';
+export { isValidMatrixKey, MATRIX_PHASE_KEYS, type MatrixKeyKind, type ModelMatrixResolution, type ModelMatrixResolutionSource, type ModelReference, matrixKeyKind, phaseForRole, type ResolvedModelTarget, type ResolvedSubagentModelTarget, resolveImplementationModelTarget, resolveModelMatrix, resolveModelMatrixResolution, resolveModelTargetFromEntry, resolveSubagentModelTarget, roleNeedsIndependentReviewModel, sameModelReference, } from './model-matrix.js';
+export { DefaultMultiAgentCoordinator, type MultiAgentCoordinatorOptions, } from './multi-agent-coordinator.js';
+export { NULL_FLEET_BUS } from './null-fleet-bus.js';
+export { detectEcosystem, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, type PackageAuthorEntry, type PackageAuthorLog, type PackageAuthorTrackerOptions, recordPackageAction, updatePackageOutdatedStatus, } from './package-author-tracker.js';
+export { type OutdatedNotifyMessage, type PackageOutdatedEntry, type PackageOutdatedResult, type PackageOutdatedWatcherOptions, startPackageOutdatedWatcher, } from './package-outdated-watcher.js';
+export { type AcquireOptions, type AcquireResult, acquireOrJoin, finalize, type LiveLockResult, MAILBOX_BRIDGE_LOCK_FILENAME, MAILBOX_BRIDGE_TOKEN_FILENAME, type MailboxBridgeLock, readLiveLock, release, } from './single-instance-mailbox.js';
+export type { BudgetKind, BudgetLimits, BudgetNegotiationMode, BudgetThresholdDecision, BudgetThresholdHandler, BudgetUsage, } from './subagent-budget.js';
+export { BudgetExceededError, BudgetThresholdSignal, 
+/** 60 000 ms — hard safety net for budget negotiation decisions. Both the
+ * coordinator watchdog and SubagentBudget._negotiateExtension use this value
+ * so they agree on the decision window. Re-exported here so consumers of
+ * the coordination module can reference it without a sub-module import. */
+DECISION_TIMEOUT_MS, SubagentBudget, 
+/** 0.85 — fraction of wall-clock `timeoutMs` at which the coordinator watchdog
+ * fires a PROACTIVE pre-empt (before deadline). Canonical source:
+ * `coordination/subagent-budget.ts`. Re-exported here so all budget symbols
+ * are accessible from one import path. */
+TIMEOUT_PREEMPT_FRACTION, } from './subagent-budget.js';
+export { type FleetWorktreePolicy, resolveSubagentWorktreeDecision, subagentNeedsWorktree, WorktreeIntegrationError, type WorktreeIsolationDecision, type WorktreeTaskRunnerOptions, type WorktreeTaskStateUpdate, wrapSubagentRunnerWithWorktrees, } from './worktree-task-runner.js';
+export { AdaptiveConcurrencyController, type AdaptiveConcurrencyState, } from './adaptive-concurrency.js';
+/** Agent Monitor — virtual chat history, timeline streaming, HQ bridge */
+export { type AgentMonitorOptions, AgentMonitorService, type AgentTimelineEntry, type AgentVirtualSession, createAgentMonitorService, } from './agent-monitor.js';
+export type { ApprovalDecision, AutonomousBrainOptions, AutonomousDecisionRequest, AutonomousDecisionType, DecisionPrompt, EscalationDecision, LLMProvider, PrioritizationDecision, SpawnDecision, } from './autonomous-brain.js';
+/** Autonomous brain — LLM-backed decision-making engine */
+export { AutonomousBrain } from './autonomous-brain.js';
+export type { AutonomousCoordinatorOptions, CoordinatorEvent, CoordinatorStats, RunOptions, } from './autonomous-coordinator.js';
+/** Autonomous coordinator — wires all coordination components */
+export { AutonomousCoordinator } from './autonomous-coordinator.js';
+/** Change manager — autonomous code change lifecycle */
+export { type ApplyResult, type ChangeFile, ChangeManager, type ChangeManagerOptions, type ChangeProposal, DEFAULT_QUALITY_CHECKS, type QualityGateChecks, type RollbackResult, } from './change-manager.js';
+export type { ConsensusOptions, ConsensusResult, QuorumRule, VoterConfig, } from './consensus-protocol.js';
+/** Consensus protocol — agent voting on proposed changes */
+export { ConsensusProtocol } from './consensus-protocol.js';
+export type { ChangeNode, ChangeStatus, DecisionNode, FactCategory, FactNode, GoalNode, GoalPriority, GoalStatus, GraphSubscription, NodeFilter, NodeType, QualityCheck, QualityGateResult, VoteNode, VoteRecord, VoteValue, } from './knowledge-graph.js';
+/** Shared knowledge graph — facts, goals, decisions, changes */
+export { KnowledgeGraph } from './knowledge-graph.js';
+export type { TaskAuctionOptions, TaskBid, } from './task-auctioneer.js';
+/** Task auctioneer — project-wide task marketplace */
+export { TaskAuctioneer } from './task-auctioneer.js';
+export type { DAGEdgeEvent, DAGEdgeHandler, DAGNode, DAGNodeStatus, RunnablesHandler, } from './task-dag.js';
+/** Task DAG — dependency graph with fork/join semantics */
+export { TaskDAG } from './task-dag.js';
+//# sourceMappingURL=index.d.ts.map