@wrongstack/core 0.277.2 → 0.280.1

package/dist/coordination/index.d.ts

@@ -1,26 +1,27 @@
-import { E as EventBus, B as BrainArbiter, f as BrainDecisionOption, k as BrainRisk, h as BrainDecisionRequest, e as BrainDecision, i as BrainDecisionSource } from '../brain-CCfuEOdp.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-CCfuEOdp.js';
-import { H as FleetManager, s as Director } from '../null-fleet-bus-C9KsYyrI.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, a7 as makeFleetSessionTool, a7 as makeFleetStatusTool, a7 as makeFleetTool, a7 as makeFleetUsageTool, a8 as makeRollUpTool, a9 as makeSpawnTool, aa as makeTerminateAllTool, ab as makeTerminateTool, ac as makeWorkCompleteTool, ad as rosterSummaryFromConfigs } from '../null-fleet-bus-C9KsYyrI.js';
-import { b as AgentDefinition } from '../multi-agent-coordinator-CcrcncvG.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-CcrcncvG.js';
-import { F as FleetBus } from '../agent-subagent-runner-BimKihiC.js';
-export { i as AgentFactory, w as AgentFactoryResult, x as AgentRunnerOptions, y as BudgetExceededError, z as BudgetKind, E as BudgetLimits, G as BudgetNegotiationMode, H as BudgetThresholdDecision, I as BudgetThresholdHandler, J as BudgetThresholdSignal, K as BudgetUsage, N as DECISION_TIMEOUT_MS, O as FleetEvent, Q as FleetHandler, j as FleetUsage, k as FleetUsageAggregator, R as SubagentBudget, Z as SubagentUsageSnapshot, _ as TIMEOUT_PREEMPT_FRACTION, a0 as makeAgentSubagentRunner, a1 as withDisabledToolFiltering } from '../agent-subagent-runner-BimKihiC.js';
-export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-BFJ2ODzI.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-DTl7bRH3.js';
-export { k as ClientSource, l as MailboxMessageType, m as MailboxTaskContext, R as ReadReceipts, n as RegisteredAgent, o as normalizeRecipient } from '../mailbox-types-DTl7bRH3.js';
-import { G as GlobalMailbox } from '../global-mailbox-Dr4cTKqL.js';
-export { aw as resolveProjectDir } from '../global-mailbox-Dr4cTKqL.js';
-import { C as Context, T as Tool } from '../context-DPlA6kid.js';
-import { A as AdaptiveConcurrencyConfig } from '../config-DAOjriz9.js';
+export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-DXC6QDJ4.js';
+import { F as FleetBus } from '../agent-subagent-runner-PoqNKiR4.js';
+export { i as AgentFactory, x as AgentFactoryResult, y as AgentRunnerOptions, z as BudgetExceededError, E as BudgetKind, G as BudgetLimits, H as BudgetNegotiationMode, I as BudgetThresholdDecision, J as BudgetThresholdHandler, K as BudgetThresholdSignal, L as BudgetUsage, O as DECISION_TIMEOUT_MS, Q as FleetEvent, R as FleetHandler, j as FleetUsage, k as FleetUsageAggregator, W as SubagentBudget, a0 as SubagentUsageSnapshot, a1 as TIMEOUT_PREEMPT_FRACTION, a3 as makeAgentSubagentRunner, a4 as withDisabledToolFiltering } from '../agent-subagent-runner-PoqNKiR4.js';
+import { H as FleetManager, s as Director } from '../null-fleet-bus-DkdmZJ_W.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, a7 as makeFleetSessionTool, a7 as makeFleetStatusTool, a7 as makeFleetTool, a7 as makeFleetUsageTool, a8 as makeRollUpTool, a9 as makeSpawnTool, aa as makeTerminateAllTool, ab as makeTerminateTool, ac as makeWorkCompleteTool, ad as rosterSummaryFromConfigs } from '../null-fleet-bus-DkdmZJ_W.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-Bs2fmldo.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-Bs2fmldo.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 { b as AgentDefinition } from '../multi-agent-coordinator-CieyUoEL.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-CieyUoEL.js';
+import { G as GlobalMailbox } from '../global-mailbox-Ct7IorLJ.js';
+export { aA as resolveProjectDir } from '../global-mailbox-Ct7IorLJ.js';
+import { C as Context, T as Tool } from '../tool-BkOgs_KL.js';
+import { A as AdaptiveConcurrencyConfig } from '../config-Cr3312zc.js';
+import { L as Logger } from '../logger-B63L5bTg.js';
+import '../index-kidebiDh.js';
+import '../pipeline-BwAP21_4.js';
+import '../permission-Dx6dIqS2.js';
+import '../observability-D-HZN_mF.js';
+import '../secret-scrubber-3MHDDAtm.js';
+import '../retry-policy-D4feSLk3.js';
 import 'node:events';
-import '../logger-B63L5bTg.js';
 import '../director-state-BfeCUbmk.js';
-import '../index-DJXj-dcr.js';
-import '../pipeline-CEjBjzVA.js';
-import '../observability-D-HZN_mF.js';
-import '../permission-DbsGOA1C.js';
-import '../retry-policy-Git9WF6d.js';
 
 /** Phase 1 · Discovery — map the territory before any work begins. */
 declare const DISCOVERY_AGENTS: AgentDefinition[];
@@ -49,72 +50,6 @@ 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;
-    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>;
-    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;
-    /**
-     * 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;
-}
-
 /**
  * BrainMonitor — the Brain's SELF-ACTIVATION layer.
  *
@@ -189,276 +124,124 @@ declare class BrainMonitor {
 }
 
 /**
- * Single-instance mailbox-bridge lock.
+ * dep-watcher — File-change → Mailbox bridge for dependency monitoring.
  *
- * 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.
+ * 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.
  *
- * 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.
+ * 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.
  *
- * 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.
+ * 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
  *
- * 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).
+ * @module dep-watcher
  */
-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;
+
+/**
+ * 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;
 }
-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;
+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;
 }
 /**
- * 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.
+ * 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.
  *
- * 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.
+ * 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 acquireOrJoin(opts: AcquireOptions): Promise<AcquireResult>;
+declare function makeDependencyWatcherConfig(opts: DependencyWatcherOptions): DependencyWatcherConfig;
+
 /**
- * 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.
+ * dep-watcher-bridge — Bridges the file-watcher plugin's custom events
+ * to the dependency watcher → mailbox pipeline.
  *
- * 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).
+ * 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.
  *
- * 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).
+ * Returns a dispose function that unsubscribes from the event bus.
  *
- * 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.
+ * @module dep-watcher-bridge
  */
-type LiveLockResult = {
-    kind: 'live';
-    lock: MailboxBridgeLock;
-} | {
-    kind: 'probe-failed';
-    lock: MailboxBridgeLock;
-} | {
-    kind: 'absent';
-};
-declare function readLiveLock(projectDir: string): Promise<LiveLockResult>;
 
+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;
+}
 /**
- * MailboxHealthWatchdog — probes the mailbox HTTP bridge and posts a
- * status message when it goes down.
+ * Wire the file-watcher's `file-watcher:changed` events into the
+ * dependency watcher → mailbox pipeline.
  *
- * 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."
+ * Returns a dispose function. Call it to unsubscribe when the
+ * session ends or the watcher is no longer needed.
  *
  * 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('mailbox bridge', event.kind),
+ *   const dispose = attachDepWatcherBridge({
+ *     events: ctx.events,
+ *     mailbox: new DefaultMailbox(sessionDir),
+ *     projectRoot: ctx.projectRoot,
  *   });
- *   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.
+ *   // ... session runs ...
+ *   dispose(); // clean up on exit
  */
-declare function validateWatchdogOptions(cfg: WatchdogConfig): void;
+declare function attachDepWatcherBridge(opts: DepWatcherBridgeOptions): () => void;
 
 /**
  * mailbox-tool — Tool that exposes the inter-agent mailbox to agents.
@@ -564,124 +347,271 @@ 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.
+ * DefaultMailbox — append-only JSONL inter-agent mailbox (per-session).
  *
- * 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.
+ * 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.
  *
- * 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
+ * For cross-session communication, use GlobalMailbox instead.
  *
- * @module dep-watcher
+ * @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;
+}
+
 /**
- * Files that declare project dependencies. When any of these change
- * (create/update), a mailbox message triggers a tech-stack audit.
+ * 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.
  */
-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;
+
+/**
+ * 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;
 }
 /**
- * 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.
+ * 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 makeDependencyWatcherConfig(opts: DependencyWatcherOptions): DependencyWatcherConfig;
+declare function actionToAckInput(action: Exclude<MailboxMessageAction, 'soft-delete' | 'restore'>, input: MailboxActionInput): MailboxAckInput;
 
 /**
- * dep-watcher-bridge — Bridges the file-watcher plugin's custom events
- * to the dependency watcher → mailbox pipeline.
+ * MailboxHealthWatchdog — probes the mailbox HTTP bridge and posts a
+ * status message when it goes down.
  *
- * 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.
+ * 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."
  *
- * Returns a dispose function that unsubscribes from the event bus.
+ * Usage:
  *
- * @module dep-watcher-bridge
+ *   const mailbox = new GlobalMailbox(projectDir);
+ *   const watchdog = new MailboxHealthWatchdog({
+ *     mailbox,
+ *     url: 'http://127.0.0.1:7788',
+ *     probeIntervalMs: 15_000,
+ *     onAlert: (event) => console.warn('mailbox bridge', event.kind),
+ *   });
+ *   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 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;
+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;
 }
-/**
- * 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
+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 attachDepWatcherBridge(opts: DepWatcherBridgeOptions): () => void;
+declare function validateWatchdogOptions(cfg: WatchdogConfig): void;
 
 /**
  * mailbox-hooks — Tool-execution hooks for mailbox integration.
@@ -893,19 +823,330 @@ interface PackageOutdatedWatcherOptions {
     /** Called on errors. */
     onError?: ((err: unknown) => void) | undefined;
 }
-interface OutdatedNotifyMessage {
-    from: string;
-    to: string;
-    subject: string;
-    body: string;
-    priority: 'high' | 'normal' | 'low';
+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;
 }
-/**
- * Start the package outdated watcher.
- *
- * Returns a dispose function that stops polling and cleans up.
- */
-declare function startPackageOutdatedWatcher(opts: PackageOutdatedWatcherOptions): () => void;
+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';
@@ -1035,93 +1276,242 @@ interface NodeFilter {
     /** 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;
+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>;
     /**
-     * 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.
+     * 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.
      */
-    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);
+    decideAuto(request: AutonomousDecisionRequest): Promise<BrainDecision>;
     /**
-     * Add a node. Fires to all matching subscriptions synchronously.
-     * Returns the node with its assigned id.
+     * Decide whether to spawn a subagent, which role to use, and what budget.
      */
-    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[];
+    decideSpawn(source: BrainDecisionSource, taskDescription: string, availableFacts: FactNode[], fleetStatus: {
+        running: number;
+        idle: number;
+        total: number;
+        costSoFar: number;
+    }): Promise<BrainDecision>;
     /**
-     * Subscribe to nodes matching a filter. Returns a channel id that can be
-     * used to poll for new nodes since the last check.
+     * Decide whether to approve a proposed change.
      */
-    subscribe(agentId: string, filter: NodeFilter): string;
+    decideApproval(source: BrainDecisionSource, change: ChangeNode, relevantFacts: FactNode[]): Promise<BrainDecision>;
     /**
-     * Poll for new nodes delivered to a channel since last check.
-     * Clears the delivery buffer after reading.
+     * Decide how to handle a failed task.
      */
-    poll(channel: string): GraphNode[];
-    unsubscribe(channel: string): void;
+    decideEscalation(source: BrainDecisionSource, taskId: string, error: string, attempts: number): Promise<BrainDecision>;
     /**
-     * Create a quality gate result. Call this when a change is being proposed
-     * so the change node carries the gate result.
+     * Record the outcome of a decision for self-improvement.
+     * Call this after a spawned agent completes or a change is applied.
      */
-    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;
-    };
+    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;
 }
 
 /**
@@ -1271,6 +1661,144 @@ declare class TaskDAG {
     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.
  *
@@ -1471,343 +1999,56 @@ declare class ChangeManager {
     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);
+    constructor(opts: ChangeManagerOptions);
     /**
-     * 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.
+     * Propose a new code change. Creates a ChangeNode in the knowledge graph.
+     * Does NOT automatically initiate voting — call `submitForReview()` for that.
      */
-    dispose(): void;
+    propose(input: ChangeProposal): Promise<ChangeNode>;
     /**
-     * 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.
+     * 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.
      */
-    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>;
+    submitForReview(changeId: string): Promise<void>;
     /**
-     * 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.
+     * Apply an approved change. Updates the change node to 'applied'.
+     * Agents should watch for 'applied' status and perform the actual file mutations.
      */
-    bid(taskId: string, agent: {
-        agentId: string;
-        agentName: string;
-        agentRole: string;
-    }, rationale: string): Promise<boolean>;
+    markApplied(changeId: string, appliedAt: string): Promise<ChangeNode | null>;
     /**
-     * Award a task to a specific agent. Called internally by the bid window
-     * expiry, or can be called directly to force an award.
+     * Mark a change as applied and trigger rollback for any satisfied goal
+     * that turns out to be broken.
      */
-    claim(taskId: string, agentId: string, agentName: string): Promise<boolean>;
+    markAppliedWithVerification(changeId: string, verify: () => Promise<QualityGateResult>): Promise<ApplyResult>;
     /**
-     * Mark a task as done. Called by the agent when it finishes.
+     * Propose a rollback for an applied change. Creates a new change that
+     * reverses the original. Goes through full consensus.
      */
-    complete(taskId: string, _result?: string): Promise<void>;
+    proposeRollback(appliedChangeId: string, reason: string): Promise<ChangeNode | null>;
     /**
-     * Mark a task as failed. Optionally spawn a retry.
+     * Mark a change as rolled back.
      */
-    fail(taskId: string, error: string): Promise<void>;
+    markRolledBack(changeId: string, rolledBackAt: string): Promise<ChangeNode | null>;
+    getPendingReviews(): ChangeNode[];
+    getAppliedChanges(): ChangeNode[];
+    getChange(id: string): ChangeNode | undefined;
+    getChangesForGoal(goalId: string): ChangeNode[];
     /**
-     * Find the best available tasks for an agent based on its capabilities.
-     * Returns tasks sorted by match score (best first).
+     * 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.
      */
-    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 _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;
-    private _broadcastTask;
-    private _mailboxPublish;
-    private _notifyAgent;
-    private _startBidWindow;
-    private _cancelBidWindow;
-    private _evaluateBids;
-    private _assignDirect;
-    private _onBidEvent;
-    private _onClaimedEvent;
-    private _getAgentTaskCount;
-    private agentTaskCount;
 }
 
 /**
@@ -2038,156 +2279,4 @@ declare class AutonomousCoordinator {
     private _emit;
 }
 
-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' | '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;
-}
-declare function createAgentMonitorService(opts: AgentMonitorOptions): AgentMonitorService;
-
-/**
- * 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;
-    constructor(fleetBus: FleetBus, setMaxConcurrent: (n: number) => void, config?: Partial<AdaptiveConcurrencyConfig>, onStateChange?: (state: AdaptiveConcurrencyState) => void);
-    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;
-}
-
-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_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, GlobalMailbox, type GoalNode, type GoalPriority, type GoalStatus, type GraphSubscription, 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, META_AGENTS, type MailToolsOptions, Mailbox, MailboxAckBatchInput, MailboxAckInput, MailboxAgentStatus, type MailboxBridgeLock, type MailboxHealthEvent, MailboxHealthWatchdog, type MailboxHealthWatchdogOptions, 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, PurgeOptions, PurgeResult, type QualityCheck, type QualityGateChecks, type QualityGateResult, type QuorumRule, REVIEW_AGENTS, type RecoveryAlertInput, type RollbackResult, type RunOptions, type RunnablesHandler, type SpawnDecision, type TaskAuctionOptions, TaskAuctioneer, type TaskBid, TaskDAG, VERIFY_AGENTS, type VoteNode, type VoteRecord, type VoteValue, type VoterConfig, type WatchdogConfig, acquireOrJoin, attachDepWatcherBridge, buildDownAlert, buildRecoveryAlert, createAgentMonitorService, createMailboxHooks, detectEcosystem, finalize, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeDependencyWatcherConfig, makeMailInboxTool, makeMailSendTool, makeMailboxTool, readLiveLock, recordPackageAction, release, resolveMailboxIdentity, startPackageOutdatedWatcher, updatePackageOutdatedStatus, validateWatchdogOptions };
+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_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, GlobalMailbox, type GoalNode, type GoalPriority, type GoalStatus, type GraphSubscription, 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, 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 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 RollbackResult, type RunOptions, type RunnablesHandler, type SpawnDecision, 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, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeDependencyWatcherConfig, makeMailInboxTool, makeMailSendTool, makeMailboxTool, readLiveLock, recordPackageAction, release, resolveMailboxIdentity, startPackageOutdatedWatcher, updatePackageOutdatedStatus, validateWatchdogOptions };