@wrongstack/core 0.260.0 → 0.265.1

package/dist/coordination/index.d.ts

@@ -1,21 +1,23 @@
-export { B as BrainArbiter, b as BrainDecision, c as BrainDecisionOption, d as BrainDecisionQueue, e as BrainDecisionRequest, f as BrainDecisionSource, g as BrainFallback, h as BrainRisk, D as DefaultBrainArbiter, i as DefaultBrainArbiterOptions, H as HumanEscalatingBrainArbiter, O as ObservableBrainArbiter, j as formatHumanPrompt } from '../brain-C2yDd7Lw.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, s as Director, 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, H as FleetManager, I as FleetManagerOptions, J as FleetRosterBudget, K as FleetSpawnBudgetError, L as ICoordinator, M as IFleetManager, N as LargeAnswerStore, O as NULL_FLEET_BUS, R as REFACTOR_PLANNER_AGENT, P as RefactorPhase, Q as RefactorPlan, S as SECURITY_SCANNER_AGENT, T as SharedFileEntry, U as SharedFileSnapshot, V as SubagentPromptParts, W as applyRosterBudget, X as attachAutoExtend, Y as composeDirectorPrompt, Z as composeSubagentPrompt, _ as createDelegateTool, $ as getAgentDefinition, a0 as makeAskResultTool, a1 as makeAskTool, a2 as makeAssignTool, a3 as makeAwaitTasksTool, a4 as makeCollabDebugTool, a5 as makeDirectorSessionFactory, a6 as makeFleetEmitTool, a7 as makeFleetHealthTool, a8 as makeFleetSessionTool, a9 as makeFleetStatusTool, aa as makeFleetUsageTool, ab as makeRollUpTool, ac as makeSpawnTool, ad as makeTerminateTool, ae as makeWorkCompleteTool, af as rosterSummaryFromConfigs } from '../null-fleet-bus-DT92xqgJ.js';
-import { A as AgentDefinition } from '../multi-agent-coordinator-CEmrSCMJ.js';
-export { T as AGENT_TOOL_PRESETS, b as AgentBudgetTier, c as AgentCapability, d as AgentPhase, e as DEFAULT_DISPATCH_ROLE, a as DefaultMultiAgentCoordinator, f as DispatchCandidate, D as DispatchClassifier, g as DispatchMethod, h as DispatchOptions, i as DispatchResult, H as HEAVY_BUDGET, L as LIGHT_BUDGET, M as MEDIUM_BUDGET, j as MultiAgentCoordinatorOptions, k as dispatchAgent, m as makeLLMClassifier, s as scoreAgents } from '../multi-agent-coordinator-CEmrSCMJ.js';
-export { h as AgentFactory, i as AgentFactoryResult, j as AgentRunnerOptions, k as BudgetExceededError, l as BudgetKind, m as BudgetLimits, n as BudgetNegotiationMode, o as BudgetThresholdDecision, p as BudgetThresholdHandler, q as BudgetThresholdSignal, r as BudgetUsage, F as FleetBus, s as FleetEvent, t as FleetHandler, u as FleetUsage, v as FleetUsageAggregator, w as SubagentBudget, x as SubagentUsageSnapshot, y as makeAgentSubagentRunner, z as withDisabledToolFiltering } from '../agent-subagent-runner-BNIGZx18.js';
-export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-BbskZ7HH.js';
-export { B as BrainInterventionInput, a as BrainMonitor, b as BrainMonitorOptions, D as DEPENDENCY_FILE_PATTERNS, c as DefaultMailbox, d as DepWatchEntry, e as DepWatcherBridgeOptions, f as DependencyWatcherConfig, G as GlobalMailbox, M as MailToolsOptions, g as MailboxResolver, h as MailboxToolOptions, O as OutdatedNotifyMessage, P as PackageAuthorEntry, i as PackageAuthorLog, j as PackageAuthorTrackerOptions, k as PackageOutdatedEntry, l as PackageOutdatedResult, m as PackageOutdatedWatcherOptions, n as attachDepWatcherBridge, o as detectEcosystem, p as getFullPackageLog, q as getManifestPackages, r as getPackageAuthor, s as getPackagesByAgent, t as mailboxSessionTag, u as makeDependencyWatcherConfig, v as makeMailInboxTool, w as makeMailSendTool, x as makeMailboxTool, y as recordPackageAction, z as resolveMailboxIdentity, A as resolveProjectDir, C as startPackageOutdatedWatcher, E as updatePackageOutdatedStatus } from '../package-outdated-watcher-C70ag2G9.js';
-import { b as Mailbox } from '../pipeline-zflkI2dp.js';
-export { h as AgentHeartbeatInput, A as AgentRegistrationInput, f as MailboxAckInput, g as MailboxAgentStatus, d as MailboxMessage, l as MailboxMessageType, e as MailboxQuery, c as MailboxSendInput, m as MailboxTaskContext, n as ReadReceipts, o as RegisteredAgent, p as normalizeRecipient } from '../pipeline-zflkI2dp.js';
-import '../context-JFOVvu6z.js';
+import { E as EventBus, B as BrainArbiter, f as BrainDecisionOption, k as BrainRisk, h as BrainDecisionRequest, e as BrainDecision, i as BrainDecisionSource } from '../brain-BXd_61kQ.js';
+export { g as BrainDecisionQueue, j as BrainFallback, D as DefaultBrainArbiter, l as DefaultBrainArbiterOptions, H as HumanEscalatingBrainArbiter, O as ObservableBrainArbiter, w as formatHumanPrompt } from '../brain-BXd_61kQ.js';
+import { H as FleetManager, s as Director } from '../null-fleet-bus-CG9QY2aP.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 ICoordinator, M as IFleetManager, N as LargeAnswerStore, O as NULL_FLEET_BUS, R as REFACTOR_PLANNER_AGENT, P as RefactorPhase, Q as RefactorPlan, S as SECURITY_SCANNER_AGENT, T as SharedFileEntry, U as SharedFileSnapshot, V as SubagentPromptParts, W as applyRosterBudget, X as attachAutoExtend, Y as composeDirectorPrompt, Z as composeSubagentPrompt, _ as createDelegateTool, $ as getAgentDefinition, a0 as makeAskResultTool, a1 as makeAskTool, a2 as makeAssignTool, a3 as makeAwaitTasksTool, a4 as makeCollabDebugTool, a5 as makeDirectorSessionFactory, a6 as makeFleetEmitTool, a7 as makeFleetHealthTool, a8 as makeFleetSessionTool, a9 as makeFleetStatusTool, aa as makeFleetUsageTool, ab as makeRollUpTool, ac as makeSpawnTool, ad as makeTerminateTool, ae as makeWorkCompleteTool, af as rosterSummaryFromConfigs } from '../null-fleet-bus-CG9QY2aP.js';
+import { b as AgentDefinition } from '../multi-agent-coordinator-DyCkCZnU.js';
+export { T as AGENT_TOOL_PRESETS, c as AgentBudgetTier, d as AgentCapability, A as AgentPhase, e as DEFAULT_DISPATCH_ROLE, a as DefaultMultiAgentCoordinator, f as DispatchCandidate, D as DispatchClassifier, g as DispatchMethod, h as DispatchOptions, i as DispatchResult, H as HEAVY_BUDGET, L as LIGHT_BUDGET, M as MEDIUM_BUDGET, j as MultiAgentCoordinatorOptions, k as dispatchAgent, m as makeLLMClassifier, s as scoreAgents } from '../multi-agent-coordinator-DyCkCZnU.js';
+import { F as FleetBus } from '../agent-subagent-runner-DM2pP-B6.js';
+export { h as AgentFactory, v as AgentFactoryResult, w as AgentRunnerOptions, x as BudgetExceededError, y as BudgetKind, z as BudgetLimits, E as BudgetNegotiationMode, G as BudgetThresholdDecision, H as BudgetThresholdHandler, I as BudgetThresholdSignal, J as BudgetUsage, L as DECISION_TIMEOUT_MS, N as FleetEvent, O as FleetHandler, i as FleetUsage, j as FleetUsageAggregator, Q as SubagentBudget, Y as SubagentUsageSnapshot, Z as TIMEOUT_PREEMPT_FRACTION, $ as makeAgentSubagentRunner, a0 as withDisabledToolFiltering } from '../agent-subagent-runner-DM2pP-B6.js';
+export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-DrkBxszZ.js';
+import { c as Mailbox, k as MailboxSendInput, d as MailboxMessage, j as MailboxQuery, g as MailboxAckInput, s as MailboxAckBatchInput, h as MailboxAgentStatus, e as AgentRegistrationInput, A as AgentHeartbeatInput, t as PurgeOptions, u as PurgeResult, v as ClientRegistrationInput, w as ClientHeartbeatInput, x as ClientStatus } from '../pipeline-DPDxH_7m.js';
+export { i as MailboxMessageType, l as MailboxTaskContext, o as ReadReceipts, p as RegisteredAgent, r as normalizeRecipient } from '../pipeline-DPDxH_7m.js';
+import { C as Context, T as Tool } from '../context-MRk5PhNv.js';
 import 'node:events';
 import '../director-state-BfeCUbmk.js';
-import '../config-FG6As4H5.js';
-import '../index-BPcg4N3M.js';
+import '../config-BMCj_XDs.js';
+import '../index-CEDeNodM.js';
 import '../logger-B63L5bTg.js';
 import '../observability-D-HZN_mF.js';
-import '../permission-BJ7eO9Vl.js';
-import '../retry-policy-Cavrzmtk.js';
+import '../permission-B9SB45lp.js';
+import '../retry-policy-CN0khdlj.js';
 
 /** Phase 1 · Discovery — map the territory before any work begins. */
 declare const DISCOVERY_AGENTS: AgentDefinition[];
@@ -44,6 +46,471 @@ declare const DELIVERY_AGENTS: AgentDefinition[];
 /** Phase 9 · Meta — agents that improve the agent system itself. */
 declare const META_AGENTS: AgentDefinition[];
 
+/**
+ * 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;
+    constructor(sessionDir: string);
+    get mailboxPath(): string;
+    send(input: MailboxSendInput): Promise<MailboxMessage>;
+    query(q: MailboxQuery): Promise<MailboxMessage[]>;
+    ack(input: MailboxAckInput): Promise<MailboxMessage | null>;
+    ackMany(input: MailboxAckBatchInput): Promise<MailboxMessage[]>;
+    getAgentStatuses(): Promise<MailboxAgentStatus[]>;
+    getOnlineAgents(): Promise<MailboxAgentStatus[]>;
+    registerAgent(_input: AgentRegistrationInput): 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;
+}
+
+/**
+ * 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;
+    /**
+     * 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;
+}
+
+/**
+ * GlobalMailbox — project-level inter-agent mailbox with cross-session support.
+ *
+ * Stores messages at `~/.wrongstack/projects/<slug>/_mailbox.jsonl` so all
+ * sessions (terminals, WebUIs) working on the same project share one inbox.
+ *
+ * Features:
+ * - Agent registration + heartbeat (agents go stale after 60s without heartbeat)
+ * - Per-recipient read receipts (readBy[agentId] = ISO8601)
+ * - Atomic file-locking for concurrent multi-process writes
+ * - Unread count for new-mail notifications
+ * - Online agent list
+ *
+ * @module GlobalMailbox
+ */
+
+/**
+ * Derive the project-level mailbox directory path.
+ *
+ * Delegates to the CANONICAL `projectSlug()` from wstack-paths so every
+ * surface (CLI, TUI, WebUI, mailbox tool, loop checker) lands in the exact
+ * same `~/.wrongstack/projects/<slug>/` directory. A previous inline copy
+ * skipped the leading/trailing-hyphen strip, which silently split agents
+ * working on projects with non-alphanumeric name edges into TWO mailboxes.
+ *
+ * @param projectRoot  — absolute path to the project root
+ * @param globalRoot   — `~/.wrongstack` (or custom global root)
+ */
+declare function resolveProjectDir(projectRoot: string, globalRoot: string): string;
+declare class GlobalMailbox implements Mailbox {
+    /** Path to the JSONL message file. */
+    readonly messagePath: string;
+    /** Path to the JSON agent registry file. */
+    readonly registryPath: string;
+    /** Path to the JSON client registry file. */
+    readonly clientRegistryPath: string;
+    /** Optional event bus for emitting agent registration/heartbeat events. */
+    private readonly _events?;
+    /**
+     * Local cache of the agent registry to avoid re-reading on every call.
+     * Time-bounded: the registry file is shared ACROSS PROCESSES (that's the
+     * whole point of GlobalMailbox), so a cache served forever would never see
+     * agents registered by other sessions. Writers always bypass it.
+     */
+    private _registryCache;
+    /** When the registry cache was last refreshed from disk (epoch ms). */
+    private _registryCacheAt;
+    /**
+     * Local cache of the client registry to avoid re-reading on every call.
+     * Same reasoning as agent registry cache.
+     */
+    private _clientRegistryCache;
+    /** When the client registry cache was last refreshed from disk (epoch ms). */
+    private _clientRegistryCacheAt;
+    /** Last time each local agent sent a heartbeat (throttle). */
+    private _lastHeartbeat;
+    /** Last time each local client sent a heartbeat (throttle). */
+    private _lastClientHeartbeat;
+    /**
+     * In-memory mirror of the JSONL message file. The mailbox is shared
+     * ACROSS PROCESSES, so reads cannot trust the cache blindly — we pair it
+     * with an mtime check. The file lock serializes every write, so a
+     * changed mtimeMs is a definitive signal that another process (or this
+     * one) wrote; an unchanged mtimeMs guarantees no write happened and the
+     * cache is current. This collapses the per-iteration `query()` cost from
+     * O(file_size) disk + parse to O(messages) in memory.
+     */
+    private _messageCache;
+    /** mtimeMs of the file when `_messageCache` was populated. */
+    private _messageCacheMtime;
+    /** Size of the file when `_messageCache` was populated (extra guard). */
+    private _messageCacheSize;
+    /**
+     * @param projectDir — `~/.wrongstack/projects/<slug>/`
+     * @param events — optional EventBus for real-time TUI/WebUI notifications
+     */
+    constructor(projectDir: string, events?: EventBus);
+    send(input: MailboxSendInput): Promise<MailboxMessage>;
+    query(q: MailboxQuery): Promise<MailboxMessage[]>;
+    ack(input: MailboxAckInput): Promise<MailboxMessage | null>;
+    ackMany(input: MailboxAckBatchInput): Promise<MailboxMessage[]>;
+    unreadCount(forAgentId: string): Promise<number>;
+    registerAgent(input: AgentRegistrationInput): Promise<void>;
+    heartbeat(input: AgentHeartbeatInput): Promise<void>;
+    getAgentStatuses(): Promise<MailboxAgentStatus[]>;
+    getOnlineAgents(): Promise<MailboxAgentStatus[]>;
+    registerClient(input: ClientRegistrationInput): Promise<void>;
+    clientHeartbeat(input: ClientHeartbeatInput): Promise<void>;
+    getClientStatuses(): Promise<ClientStatus[]>;
+    close(): Promise<void>;
+    clearAll(): Promise<void>;
+    purgeStale(opts?: PurgeOptions): Promise<PurgeResult>;
+    /**
+     * Read all messages from the JSONL file. Always reads + parses the file.
+     * Callers that can tolerate a stale-by-mtime view should use
+     * {@link _readMessagesCached}; writers that need the post-lock truth
+     * should call this directly (it's what {@link _readMessagesFresh} aliases).
+     */
+    private _readMessages;
+    /**
+     * Read messages, then adopt the result as the in-memory cache. Use this
+     * from writers that just took the file lock — the read reflects the
+     * authoritative post-lock state and should be served to subsequent
+     * queries without re-reading.
+     */
+    private _readMessagesFresh;
+    /**
+     * Read messages, consulting the mtime-bounded in-memory cache first.
+     * The mailbox file is shared across processes; every `send`/`ack`/
+     * `clearAll`/`purgeStale` takes the file lock, so writes are serialized
+     * and a changed mtimeMs is a definitive freshness signal. When the
+     * stat matches the cached mtime+size we return the cached array — no
+     * file read and no JSON.parse — collapsing the per-iteration query
+     * cost on the mailbox-loop hot path.
+     */
+    private _readMessagesCached;
+    /**
+     * Replace the in-memory cache. Caller is responsible for guaranteeing
+     * that `messages` reflects the current on-disk state (e.g. they just
+     * read or wrote it under the file lock).
+     */
+    private _setMessageCache;
+    /**
+     * Append a single just-sent message to the in-memory cache without
+     * re-reading the file. The caller must hold the file lock (or have
+     * just released it after a successful append) so the cache stays
+     * consistent with on-disk state.
+     */
+    private _pushToCache;
+    private _ensureRegistry;
+    private _readRegistry;
+    private _pruneStaleInPlace;
+    private _writeRegistry;
+    private _ensureClientRegistry;
+    private _readClientRegistry;
+    private _pruneStaleClientsInPlace;
+    private _writeClientRegistry;
+}
+
+/**
+ * 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/10-48-34Z_model_e66c");
+ * 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;
+
+/**
+ * mail-tools — thin, high-affordance wrappers over the project mailbox.
+ *
+ * The multi-action `mailbox` tool is the power surface; these two 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;
+
+/**
+ * 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-hooks — Tool-execution hooks for mailbox integration.
  *
@@ -99,4 +566,1259 @@ declare function createMailboxHooks(opts: MailboxHooksOptions): {
     reset(): void;
 };
 
-export { AgentDefinition, BUILD_AGENTS, DELIVERY_AGENTS, DISCOVERY_AGENTS, DOMAIN_AGENTS, KNOWLEDGE_AGENTS, META_AGENTS, Mailbox, type MailboxHooksOptions, PLANNING_AGENTS, REVIEW_AGENTS, VERIFY_AGENTS, createMailboxHooks };
+/**
+ * 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;
+
+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;
+    /** 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;
+    };
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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): 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): 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): 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;
+}
+
+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;
+}
+
+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;
+}
+
+/**
+ * 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;
+    /** 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;
+    /**
+     * 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 _decomposeGoal;
+    private _inferCategory;
+    private _processGoal;
+    private _handlePendingChange;
+    private _onDagEvent;
+    private _onSubagentTerminated;
+    private _fleetStatus;
+    private _buildVoters;
+    private _goalToOptions;
+    private _optionToGoal;
+    private _dagPriorityToGoal;
+    private _mailboxBroadcast;
+    /** Emit a CoordinatorEvent to the subscriber (e.g. TUI panel timeline). */
+    private _emit;
+}
+
+export { AgentDefinition, AgentHeartbeatInput, AgentRegistrationInput, 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, type ConsensusOptions, ConsensusProtocol, type ConsensusResult, type CoordinatorEvent, type CoordinatorStats, type DAGEdgeEvent, type DAGEdgeHandler, type DAGNode, type DAGNodeStatus, 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 EscalationDecision, type FactCategory, type FactNode, FleetBus, FleetManager, GlobalMailbox, type GoalNode, type GoalPriority, type GoalStatus, type GraphSubscription, KNOWLEDGE_AGENTS, KnowledgeGraph, type LLMProvider, META_AGENTS, type MailToolsOptions, Mailbox, MailboxAckInput, MailboxAgentStatus, type MailboxHooksOptions, MailboxMessage, MailboxQuery, type MailboxResolver, MailboxSendInput, type MailboxToolOptions, type NodeFilter, type NodeType, type OutdatedNotifyMessage, PLANNING_AGENTS, type PackageAuthorEntry, type PackageAuthorLog, type PackageAuthorTrackerOptions, type PackageOutdatedEntry, type PackageOutdatedResult, type PackageOutdatedWatcherOptions, type PrioritizationDecision, type QualityCheck, type QualityGateChecks, type QualityGateResult, type QuorumRule, REVIEW_AGENTS, type RollbackResult, type RunOptions, type RunnablesHandler, type SpawnDecision, type TaskAuctionOptions, TaskAuctioneer, type TaskBid, TaskDAG, VERIFY_AGENTS, type VoteNode, type VoteRecord, type VoteValue, type VoterConfig, attachDepWatcherBridge, createMailboxHooks, detectEcosystem, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeDependencyWatcherConfig, makeMailInboxTool, makeMailSendTool, makeMailboxTool, recordPackageAction, resolveMailboxIdentity, resolveProjectDir, startPackageOutdatedWatcher, updatePackageOutdatedStatus };