@wrongstack/core 0.155.0 → 0.250.0

package/dist/coordination/index.js

@@ -1,7 +1,8 @@
-import { randomUUID, randomBytes } from 'crypto';
+import { randomUUID, createHash, randomBytes } from 'crypto';
 import * as fsp6 from 'fs/promises';
 import * as path4 from 'path';
 import { isAbsolute, resolve } from 'path';
+import * as os from 'os';
 import { hostname } from 'os';
 import { EventEmitter } from 'events';
 
@@ -54,12 +55,12 @@ var BrainDecisionQueue = class {
       options: request.options,
       rationale: "Decision escalated to human authority."
     };
-    const pending = new Promise((resolve2) => {
-      const entry = { request, resolve: resolve2 };
+    const pending = new Promise((resolve3) => {
+      const entry = { request, resolve: resolve3 };
       if (this.opts.timeoutMs && this.opts.timeoutMs > 0) {
         entry.timer = setTimeout(() => {
           this.pending.delete(request.id);
-          resolve2({ type: "deny", reason: "Brain human decision timed out." });
+          resolve3({ type: "deny", reason: "Brain human decision timed out." });
         }, this.opts.timeoutMs);
       }
       this.pending.set(request.id, entry);
@@ -191,6 +192,49 @@ async function atomicWrite(targetPath, content, opts = {}) {
 async function ensureDir(dir) {
   await fsp6.mkdir(dir, { recursive: true });
 }
+async function withFileLock(targetPath, fn, opts = {}) {
+  const dir = path4.dirname(targetPath);
+  await fsp6.mkdir(dir, { recursive: true });
+  const lockPath = path4.join(dir, `.${path4.basename(targetPath)}.lock`);
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const staleMs = opts.staleMs ?? 3e4;
+  const started = Date.now();
+  let handle;
+  for (; ; ) {
+    try {
+      handle = await fsp6.open(lockPath, "wx");
+      await handle.writeFile(`${process.pid}:${Date.now()}`);
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      try {
+        const stat5 = await fsp6.stat(lockPath);
+        if (Date.now() - stat5.mtimeMs > staleMs) {
+          await fsp6.unlink(lockPath);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() - started >= timeoutMs) {
+        throw new Error(`Timed out waiting for file lock: ${targetPath}`);
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, 25));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    try {
+      await handle?.close();
+    } catch {
+    }
+    try {
+      await fsp6.unlink(lockPath);
+    } catch {
+    }
+  }
+}
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
@@ -209,7 +253,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve2) => setTimeout(resolve2, delays[i]));
+      await new Promise((resolve3) => setTimeout(resolve3, delays[i]));
     }
   }
   throw lastErr;
@@ -395,6 +439,62 @@ function safeParse(input, maxBytes = 5e6) {
   }
 }
 
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED"};
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var AgentError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "agent",
+      severity: opts.code === ERROR_CODES.AGENT_ABORTED ? "warning" : "error",
+      recoverable: opts.recoverable ?? opts.code === ERROR_CODES.AGENT_ITERATION_LIMIT,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "AgentError";
+  }
+};
+
 // src/coordination/in-memory-transport.ts
 var InMemoryBridgeTransport = class {
   subs = /* @__PURE__ */ new Map();
@@ -483,28 +583,40 @@ var InMemoryAgentBridge = class {
     return () => this.subscriptions.delete(handler);
   }
   async request(msg, timeoutMs) {
-    if (this.stopped) throw new Error("Bridge is stopped");
+    if (this.stopped) throw new AgentError({
+      message: "Bridge is stopped",
+      code: ERROR_CODES.AGENT_ABORTED
+    });
     const timeout = timeoutMs ?? this.timeoutMs;
     const correlationId = msg.id;
     if (this.inflightGuards.has(correlationId)) {
-      throw new Error(
-        `Bridge request id "${correlationId}" collides with an in-flight request \u2014 caller is reusing message ids`
-      );
+      throw new AgentError({
+        message: `Bridge request id "${correlationId}" collides with an in-flight request \u2014 caller is reusing message ids`,
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        context: { correlationId }
+      });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
-        reject(new Error(`Request ${correlationId} timed out after ${timeout}ms`));
+        reject(new AgentError({
+          message: `Request ${correlationId} timed out after ${timeout}ms`,
+          code: ERROR_CODES.AGENT_RUN_FAILED,
+          context: { correlationId, timeoutMs: timeout }
+        }));
       }, timeout);
       if (!this.inflightGuards.has(correlationId)) {
         clearTimeout(timer);
-        reject(new Error("Bridge stopped"));
+        reject(new AgentError({
+          message: "Bridge stopped",
+          code: ERROR_CODES.AGENT_ABORTED
+        }));
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve2,
+        resolve: resolve3,
         reject,
         timer
       });
@@ -521,7 +633,10 @@ var InMemoryAgentBridge = class {
     this.stopped = true;
     for (const [, p] of this.pendingRequests) {
       clearTimeout(p.timer);
-      p.reject(new Error("Bridge stopped"));
+      p.reject(new AgentError({
+        message: "Bridge stopped",
+        code: ERROR_CODES.AGENT_ABORTED
+      }));
     }
     this.pendingRequests.clear();
     this.inflightGuards.clear();
@@ -546,7 +661,9 @@ function createMessage(type, from, payload, to) {
 // src/utils/expect-defined.ts
 function expectDefined(value, label) {
   if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
+    const err = new Error("Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
   }
   return value;
 }
@@ -1306,7 +1423,23 @@ Bridge contract:
     subagents' context. Those are not yours to read.
   - Your final task output is what the Director sees. Be concise,
     structured, and self-contained \u2014 assume the Director will paste your
-    output into its own context.`;
+    output into its own context.
+
+Inter-agent mailbox (if you have the \`mail_send\`/\`mail_inbox\`/\`mailbox\` tools):
+  - You are part of a project-wide fleet that may span other terminals and
+    WebUIs. Your mailbox identity is \`<your-name>@<session-tag>\` (unique
+    per session); mail addressed to you, to your bare name, or broadcast
+    to \`*\` is injected into your conversation automatically before each
+    step \u2014 read it once, it is marked read.
+  - Broadcast milestones: when you complete a significant piece of work,
+    \`mail_send to="*"\` a one-line summary so parallel agents don't collide
+    with or duplicate it.
+  - Hand off matching work: if another online agent's role fits a follow-up
+    better (e.g. a reviewer while you just wrote code), \`mail_send\` it to
+    their exact id instead of doing everything yourself. Discover ids with
+    \`mailbox action=online\`.
+  - Answer your mail: reply to the sender's exact \`from\` id. When done with
+    an assigned task, post a \`result\` back to whoever assigned it.`;
 function composeDirectorPrompt(parts = {}) {
   const sections = [];
   const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
@@ -1380,11 +1513,11 @@ var HEAVY_BUDGET = {
 };
 var TOOLS = {
   /** Pure read/inspect — safe for analysis and review agents. */
-  read: ["read", "grep", "glob", "search", "tree"],
+  read: ["read", "grep", "glob", "search", "tree", "mailbox"],
   /** Read + structured inspection (logs, diffs, json, dependency audit). */
-  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit"],
+  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit", "mailbox"],
   /** Read + edit (no shell). For agents that write code/docs but don't run it. */
-  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch"],
+  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch", "mailbox"],
   /** Full build loop: edit + run (lint/format/typecheck/test/bash). */
   build: [
     "read",
@@ -1401,16 +1534,17 @@ var TOOLS = {
     "lint",
     "format",
     "typecheck",
-    "test"
+    "test",
+    "mailbox"
   ],
   /** Version control. */
   vcs: ["read", "grep", "glob", "git", "diff"],
   /** Dependency management + CVE audit. */
-  deps: ["read", "grep", "glob", "install", "outdated", "audit", "json"],
+  deps: ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"],
   /** Documentation authoring. */
-  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document"],
+  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document", "mailbox"],
   /** Web research. */
-  research: ["read", "grep", "glob", "search", "fetch"]
+  research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
 };
 
 // src/coordination/agents/phase1-discovery.ts
@@ -3823,7 +3957,7 @@ Working rules:
       id: "tech-stack",
       name: "Tech Stack Validator",
       role: "tech-stack",
-      tools: ["search", "fetch", "read", "grep", "glob", "outdated", "audit", "json"],
+      tools: ["search", "fetch", "read", "grep", "glob", "outdated", "audit", "json", "mailbox"],
       prompt: `You are the Tech Stack Validator \u2014 a single-shot validation agent that fires
 before any package, library, or framework choice is committed.
 
@@ -3831,6 +3965,16 @@ Your ONLY job: verify that a technology choice is current, real, and not obsolet
 You are the "this isn't code, this is 10-year-old technology" agent. Intervene
 hard when the LLM hallucinates a version number or suggests dead tech.
 
+## Before you begin
+
+Check the inter-agent mailbox for pending tasks. Other agents or the file-watcher
+may have left assign messages with dependency files to audit:
+- mailbox action=check
+
+If you find an assign message, use the specified file path and packages.
+When done, post results back:
+- mailbox action=send to=<sender> type=result subject="Tech stack audit results" body="..."
+
 ## Critical rules
 
 1. **Verify existence.** Search npm registry (fetch https://registry.npmjs.org/<pkg>/latest)
@@ -3889,11 +4033,11 @@ When APPROVED:
 **Install**: pnpm add <name>@^<major>.<minor>.0`
     },
     budget: {
-      timeoutMs: 6e4,
-      maxIterations: 5,
-      maxToolCalls: 20,
-      maxTokens: 4e4,
-      maxCostUsd: 0.1
+      timeoutMs: 12e4,
+      maxIterations: 10,
+      maxToolCalls: 40,
+      maxTokens: 6e4,
+      maxCostUsd: 0.25
     },
     capability: {
       phase: "meta",
@@ -5025,12 +5169,12 @@ var SubagentBudget = class _SubagentBudget {
           if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
             return Promise.resolve("stop");
           }
-          return new Promise((resolve2) => {
+          return new Promise((resolve3) => {
             let resolved = false;
             const respond = (d) => {
               if (resolved) return;
               resolved = true;
-              resolve2(d);
+              resolve3(d);
             };
             const fallback = setTimeout(
               () => respond("stop"),
@@ -5151,42 +5295,9 @@ var SubagentBudget = class _SubagentBudget {
   }
 };
 
-// src/types/errors.ts
-var ERROR_CODES = {
-  // Provider
-  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
-  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
-  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
-  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
-  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
-  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR"};
-var WrongStackError = class extends Error {
-  code;
-  subsystem;
-  severity;
-  recoverable;
-  context;
-  constructor(opts) {
-    super(opts.message, { cause: opts.cause });
-    this.name = "WrongStackError";
-    this.code = opts.code;
-    this.subsystem = opts.subsystem;
-    this.severity = opts.severity ?? "error";
-    this.recoverable = opts.recoverable ?? false;
-    this.context = opts.context;
-  }
-  /**
-   * Render a one-line user-facing description.
-   * Subclasses should override for domain-specific formatting.
-   */
-  describe() {
-    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
-    return `${this.code}: ${this.message}${ctx}`;
-  }
-};
-function formatContext(ctx) {
-  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
-  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+// src/utils/string.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
 }
 
 // src/types/provider.ts
@@ -5247,9 +5358,6 @@ function describeStatus(status, type) {
   if (type) return `${type} (${status})`;
   return `HTTP ${status}`;
 }
-function truncate(s, n) {
-  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
-}
 function providerStatusToCode(status, type) {
   if (status === 0) return ERROR_CODES.PROVIDER_NETWORK_ERROR;
   if (type === "rate_limit_error" || status === 429) return ERROR_CODES.PROVIDER_RATE_LIMITED;
@@ -5263,6 +5371,9 @@ function providerStatusToCode(status, type) {
 
 // src/coordination/coordinator/error-classifier.ts
 function classifySubagentError(err, hints = {}) {
+  if (err instanceof AgentError && err.cause) {
+    return classifySubagentError(err.cause, hints);
+  }
   const cause = err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : void 0;
   if (err instanceof ProviderError) {
     const baseMessage2 = err.describe();
@@ -5295,7 +5406,7 @@ function classifySubagentError(err, hints = {}) {
   if (/agent exhausted iteration limit$/i.test(baseMessage)) {
     return { kind: "budget_iterations", message: baseMessage, retryable: false, cause };
   }
-  if (/empty response$/i.test(baseMessage)) {
+  if (/empty response/i.test(baseMessage)) {
     return { kind: "empty_response", message: baseMessage, retryable: false, cause };
   }
   if (/^tool failed: /i.test(baseMessage)) {
@@ -5980,7 +6091,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve3, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -5989,7 +6100,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve2(result);
+              resolve3(result);
             }
           };
           this.on("task.completed", handler);
@@ -7362,11 +7473,11 @@ var Director = class _Director {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve2;
+        let resolve3;
         const promise = new Promise((res) => {
-          resolve2 = res;
+          resolve3 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve2 });
+        this.taskWaiters.set(id, { promise, resolve: resolve3 });
         return promise;
       })
     );
@@ -7762,7 +7873,7 @@ function createDelegateTool(opts) {
           subagentId
         });
         const dir = director;
-        const result = await new Promise((resolve2) => {
+        const result = await new Promise((resolve3) => {
           let settled = false;
           let timer;
           const finish = (value) => {
@@ -7772,7 +7883,7 @@ function createDelegateTool(opts) {
             offTool();
             offIter();
             offProgress();
-            resolve2(value);
+            resolve3(value);
           };
           const arm = () => {
             if (timer) clearTimeout(timer);
@@ -8182,21 +8293,40 @@ function makeAgentSubagentRunner(opts) {
       if (budgetError) throw budgetError;
     }
     if (result.status === "failed") {
-      throw result.error instanceof Error ? result.error : new Error(String(result.error ?? "agent failed"));
+      throw result.error instanceof AgentError ? result.error : new AgentError({
+        message: result.error instanceof Error ? result.error.message : String(result.error ?? "agent failed"),
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        cause: result.error
+      });
     }
     if (result.status === "aborted") {
-      throw new Error("agent aborted");
+      throw new AgentError({
+        message: "agent aborted",
+        code: ERROR_CODES.AGENT_ABORTED
+      });
     }
     if (result.status === "max_iterations") {
-      throw new Error("agent exhausted iteration limit");
+      throw new AgentError({
+        message: "agent exhausted iteration limit",
+        code: ERROR_CODES.AGENT_ITERATION_LIMIT,
+        recoverable: true
+      });
     }
     const usage = ctx.budget.usage();
     const finalText = (result.finalText ?? "").trim();
     if (finalText.length === 0 && usage.toolCalls === 0) {
-      throw new Error("empty response");
+      throw new AgentError({
+        message: "empty response \u2014 agent produced no text and no tool calls",
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        context: { iterations: result.iterations }
+      });
     }
     if (finalText.length === 0 && lastToolFailed !== null) {
-      throw new Error(`tool failed: ${lastToolFailed}`);
+      throw new AgentError({
+        message: `unrecovered tool failure: ${lastToolFailed} \u2014 agent ended turn without acknowledging the error`,
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        context: { tool: lastToolFailed, iterations: result.iterations }
+      });
     }
     return {
       result: result.finalText,
@@ -8361,7 +8491,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
         onClose: (s) => this.appendToIndex(s)
       });
     } catch (err) {
-      await handle.close().catch((e) => console.warn(`[session-store] handle.close() failed: ${e}`));
+      await handle.close().catch((e) => console.warn(JSON.stringify({
+        level: "warn",
+        event: "session_store.handle_close_failed",
+        message: e instanceof Error ? e.message : String(e),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })));
       throw err;
     }
   }
@@ -8388,11 +8523,25 @@ var DefaultSessionStore = class _DefaultSessionStore {
           provider: data.metadata.provider
         },
         this.events,
-        { resumed: true, dir: this.dir, filePath: file, secretScrubber: this.secretScrubber, onClose: (s) => this.appendToIndex(s) }
+        {
+          resumed: true,
+          // Shard directory (sessions/<date>/) — must match create() so the
+          // .summary.json sidecar lands next to the JSONL instead of the
+          // sessions root (where summaryFor() would never find it).
+          dir: path4.dirname(file),
+          filePath: file,
+          secretScrubber: this.secretScrubber,
+          onClose: (s) => this.appendToIndex(s)
+        }
       );
       return { writer, data };
     } catch (err) {
-      await handle.close().catch((e) => console.warn(`[session-store] handle.close() failed: ${e}`));
+      await handle.close().catch((e) => console.warn(JSON.stringify({
+        level: "warn",
+        event: "session_store.handle_close_failed",
+        message: e instanceof Error ? e.message : String(e),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })));
       throw err;
     }
   }
@@ -8412,7 +8561,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     }
     const meta = this.metaFromEvents(id, events);
     const { messages, usage } = this.replay(events, id);
-    return { metadata: meta, events, messages, usage };
+    const toolCallEnds = extractToolCallEnds(events);
+    return { metadata: meta, events, messages, usage, toolCallEnds };
   }
   async list(limit = 20) {
     try {
@@ -8568,10 +8718,13 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const stat5 = await fsp6.stat(full);
       const summary = await this.summarize(id, stat5.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
-        console.warn(
-          `[session-store] Failed to write manifest for "${id}":`,
-          err instanceof Error ? err.message : String(err)
-        );
+        console.warn(JSON.stringify({
+          level: "warn",
+          event: "session_store.manifest_write_failed",
+          sessionId: id,
+          message: err instanceof Error ? err.message : String(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
       });
       return summary;
     }
@@ -8579,17 +8732,48 @@ var DefaultSessionStore = class _DefaultSessionStore {
   /**
    * Delete a session and all associated files: JSONL, summary, plan/todos
    * sidecars, and the session directory (fleet.json, shared/, subagents/).
+   *
+   * Individual file deletions are best-effort (logged as structured warnings),
+   * but a tombstone is always written so readIndex() filters this session out.
+   * If the session directory itself can't be removed, the error is surfaced
+   * to the caller so prune() can report it.
    */
   async deleteSession(id) {
-    await fsp6.unlink(this.sessionPath(id, ".jsonl")).catch((err) => console.warn(`[session-store] delete .jsonl failed: ${err}`));
-    await fsp6.unlink(this.sessionPath(id, ".summary.json")).catch((err) => console.warn(`[session-store] delete .summary.json failed: ${err}`));
+    const jsonlPath = this.sessionPath(id, ".jsonl");
+    const summaryPath = this.sessionPath(id, ".summary.json");
     const shardDir = path4.dirname(path4.join(this.dir, id));
     const base = path4.basename(id);
-    for (const ext of [".plan.json", ".todos.json"]) {
-      await fsp6.unlink(path4.join(shardDir, `${base}${ext}`)).catch((err) => console.warn(`[session-store] delete ${ext} failed: ${err}`));
-    }
     const sessDir = path4.join(shardDir, base);
-    await fsp6.rm(sessDir, { recursive: true, force: true }).catch((err) => console.warn(`[session-store] delete session dir failed: ${err}`));
+    const deletions = [
+      fsp6.unlink(jsonlPath),
+      fsp6.unlink(summaryPath),
+      fsp6.unlink(path4.join(shardDir, `${base}.plan.json`)),
+      fsp6.unlink(path4.join(shardDir, `${base}.todos.json`))
+    ];
+    const results = await Promise.allSettled(deletions);
+    for (const r of results) {
+      if (r.status === "rejected") {
+        const msg = r.reason instanceof Error ? r.reason.message : String(r.reason);
+        if (r.reason?.code !== "ENOENT") {
+          console.warn(JSON.stringify({
+            level: "warn",
+            event: "session_store.delete_failed",
+            sessionId: id,
+            message: msg,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+        }
+      }
+    }
+    await fsp6.rm(sessDir, { recursive: true, force: true }).catch((err) => {
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "session_store.rmdir_failed",
+        sessionId: id,
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    });
     await this.writeTombstone(id);
   }
   async delete(id) {
@@ -8605,24 +8789,33 @@ var DefaultSessionStore = class _DefaultSessionStore {
       activeSessionId = active.sessionId ?? null;
     } catch {
     }
+    const isPrunableJsonl = (name) => name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
+    const pruneFile = async (dir, name, prefix) => {
+      const jsonlPath = path4.join(dir, name);
+      try {
+        const stat5 = await fsp6.stat(jsonlPath);
+        if (stat5.mtimeMs >= cutoff) return;
+      } catch {
+        return;
+      }
+      const base = name.replace(/\.jsonl$/, "");
+      const id = prefix ? `${prefix}/${base}` : base;
+      if (activeSessionId && id === activeSessionId) return;
+      await this.deleteSession(id);
+      deleted++;
+    };
     const entries = await fsp6.readdir(this.dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
+      if (entry.isFile()) {
+        if (isPrunableJsonl(entry.name)) await pruneFile(this.dir, entry.name, "");
+        continue;
+      }
       if (!entry.isDirectory()) continue;
       const dateDir = path4.join(this.dir, entry.name);
       const files = await fsp6.readdir(dateDir, { withFileTypes: true }).catch(() => []);
       for (const file of files) {
-        if (!file.isFile() || !file.name.endsWith(".jsonl")) continue;
-        const jsonlPath = path4.join(dateDir, file.name);
-        try {
-          const stat5 = await fsp6.stat(jsonlPath);
-          if (stat5.mtimeMs >= cutoff) continue;
-        } catch {
-          continue;
-        }
-        const id = `${entry.name}/${file.name.replace(/\.jsonl$/, "")}`;
-        if (activeSessionId && id === activeSessionId) continue;
-        await this.deleteSession(id);
-        deleted++;
+        if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
+        await pruneFile(dateDir, file.name, entry.name);
       }
     }
     if (deleted > 0) {
@@ -8711,7 +8904,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   metaFromEvents(id, events) {
     const start = events.find((e) => e.type === "session_start");
-    const end = events.find((e) => e.type === "session_end");
+    const end = events.findLast((e) => e.type === "session_end");
     return {
       id,
       startedAt: start?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
@@ -8728,9 +8921,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
     for (const e of events) {
       if (e.type === "user_input") {
         openToolUses.clear();
-        messages.push({ role: "user", content: e.content });
+        messages.push({ role: "user", content: e.content, ts: e.ts });
       } else if (e.type === "llm_response") {
-        messages.push({ role: "assistant", content: e.content });
+        messages.push({ role: "assistant", content: e.content, ts: e.ts });
         for (const b of e.content) {
           if (b.type === "tool_use") openToolUses.add(b.id);
         }
@@ -8749,25 +8942,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
           continue;
         }
         openToolUses.delete(e.id);
-        const content = [
-          {
-            type: "tool_result",
-            tool_use_id: e.id,
-            content: typeof e.content === "string" ? e.content : JSON.stringify(e.content),
-            is_error: e.isError
-          }
-        ];
+        const resultBlock = {
+          type: "tool_result",
+          tool_use_id: e.id,
+          content: typeof e.content === "string" ? e.content : JSON.stringify(e.content),
+          is_error: e.isError
+        };
         const last = messages[messages.length - 1];
-        if (last && last.role === "user") {
-          if (Array.isArray(last.content)) {
-            last.content.push(...content);
-          } else if (typeof last.content === "string") {
-            last.content = [{ type: "text", text: last.content }, ...content];
-          } else {
-            messages.push({ role: "user", content });
-          }
+        const lastIsToolResultUser = last?.role === "user" && Array.isArray(last.content) && last.content.every((b) => b.type === "tool_result");
+        if (lastIsToolResultUser && Array.isArray(last.content)) {
+          last.content.push(resultBlock);
         } else {
-          messages.push({ role: "user", content });
+          messages.push({ role: "user", content: [resultBlock], ts: e.ts });
         }
       }
     }
@@ -8787,7 +8973,24 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return { messages: repaired.messages, usage };
   }
 };
-var FileSessionWriter = class {
+function extractToolCallEnds(events) {
+  const result = [];
+  for (const e of events) {
+    if (e.type === "tool_call_end") {
+      result.push({
+        name: e.name,
+        id: e.id,
+        durationMs: e.durationMs,
+        ok: e.ok ?? false,
+        outputBytes: e.outputBytes,
+        outputTokens: e.outputTokens,
+        outputLines: e.outputLines
+      });
+    }
+  }
+  return result;
+}
+var FileSessionWriter = class _FileSessionWriter {
   constructor(id, handle, startedAt, meta, events, opts = {}) {
     this.id = id;
     this.handle = handle;
@@ -8814,7 +9017,7 @@ var FileSessionWriter = class {
   meta;
   events;
   closed = false;
-  closing = false;
+  closePromise = null;
   manifestFile;
   summary;
   tokenIn = 0;
@@ -8823,12 +9026,51 @@ var FileSessionWriter = class {
   get transcriptPath() {
     return this.filePath || void 0;
   }
-  initDone = false;
+  /**
+   * Lazy session_start/session_resumed init, shared by all appenders.
+   * A single promise (not a boolean) so a second append racing the first
+   * can't push its event into the buffer BEFORE the first append's event —
+   * every appender awaits the same init and resumes in FIFO call order.
+   */
+  initPromise = null;
+  ensureInit() {
+    if (!this.initPromise) this.initPromise = this.writeSessionStartLazy();
+    return this.initPromise;
+  }
   resumed;
   appendFailCount = 0;
   lastAppendWarnAt = 0;
   secretScrubber;
   onCloseCb;
+  // ── Write buffer — batches events to reduce per-event disk I/O ─────────
+  //
+  // Every append() pushes the scrubbed event into an in-memory buffer instead
+  // of calling handle.appendFile() synchronously. The buffer flushes to disk
+  // when it reaches FLUSH_SIZE events OR after FLUSH_INTERVAL_MS of inactivity.
+  // This cuts the number of disk writes by ~95% without changing the on-disk
+  // format — the JSONL is still one JSON object per line.
+  writeBuffer = [];
+  flushTimer = null;
+  static FLUSH_INTERVAL_MS = 500;
+  static FLUSH_SIZE = 50;
+  // ── Write serialization ─────────────────────────────────────────────────
+  //
+  // All disk writes are funneled through a FIFO promise chain. Without it,
+  // a timer-driven flush racing an explicit flush()/close() issues two
+  // concurrent appendFile() calls on the shared O_APPEND handle — the kernel
+  // may complete them out of order (chronology breaks) or, for large
+  // batches, interleave partial writes (torn JSONL lines). The chain keeps
+  // exactly one write in flight; failures don't break the chain.
+  writeChain = Promise.resolve();
+  /** Enqueue a write on the FIFO chain. Resolves/rejects with that write. */
+  enqueueWrite(data) {
+    const write = this.writeChain.then(() => this.handle.appendFile(data, "utf8"));
+    this.writeChain = write.then(
+      () => void 0,
+      () => void 0
+    );
+    return write;
+  }
   // ── Enriched summary tracking ──────────────────────────────────────────
   iterationCount = 0;
   toolCallCount = 0;
@@ -8878,31 +9120,91 @@ var FileSessionWriter = class {
     })}
 `;
     try {
-      if (this.filePath) {
-        await fsp6.writeFile(this.filePath, record, { flag: "a", mode: 384 });
-      }
+      await this.enqueueWrite(record);
     } catch {
     }
   }
   async append(event) {
     if (this.closed) return;
-    if (!this.initDone) {
-      this.initDone = true;
-      await this.writeSessionStartLazy();
-    }
+    await this.ensureInit();
     const scrubbed = this.scrubEvent(event);
     this.observeForSummary(scrubbed);
+    this.writeBuffer.push(scrubbed);
+    if (this.writeBuffer.length >= _FileSessionWriter.FLUSH_SIZE) {
+      if (this.flushTimer) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+      }
+      await this.flushBuffer();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  async appendBatch(events) {
+    if (this.closed || events.length === 0) return;
+    await this.ensureInit();
+    for (const event of events) {
+      const scrubbed = this.scrubEvent(event);
+      this.observeForSummary(scrubbed);
+      this.writeBuffer.push(scrubbed);
+    }
+    if (this.writeBuffer.length >= _FileSessionWriter.FLUSH_SIZE) {
+      if (this.flushTimer) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+      }
+      await this.flushBuffer();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  /**
+   * Flush buffered events to disk immediately. Critical events
+   * (user_input, llm_response) call this so they survive SIGKILL/crash
+   * instead of sitting in the in-memory buffer for up to 500ms.
+   *
+   * Idempotent — cancels any pending timer and writes whatever has
+   * accumulated in the buffer. Safe to call even when the buffer
+   * is empty (no-op).
+   */
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flushBuffer();
+  }
+  /** Schedule a deferred flush. No-op if a timer is already pending. */
+  scheduleFlush() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flushBuffer().catch(() => {
+      });
+    }, _FileSessionWriter.FLUSH_INTERVAL_MS);
+  }
+  /**
+   * Flush all buffered events to disk as a single appendFile call.
+   * Errors use the same throttled-warning pattern the old per-event
+   * append path used — one warning every 5s with a suppressed count.
+   * On failure the buffer is cleared (events are best-effort, same as
+   * the old per-event path where a failed write was silently dropped).
+   */
+  async flushBuffer() {
+    if (this.writeBuffer.length === 0) return;
+    const eventCount = this.writeBuffer.length;
+    const batch = this.writeBuffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    this.writeBuffer = [];
     try {
-      await this.handle.appendFile(`${JSON.stringify(scrubbed)}
-`, "utf8");
+      await this.enqueueWrite(batch);
     } catch (err) {
-      this.appendFailCount++;
+      this.appendFailCount += eventCount;
       const now = Date.now();
       if (now - this.lastAppendWarnAt > 5e3) {
         const suppressed = this.appendFailCount - 1;
         const tail = suppressed > 0 ? ` (+${suppressed} suppressed)` : "";
         console.warn(
-          "[session] append failed:",
+          "[session] flush failed:",
           err instanceof Error ? err.message : String(err),
           tail
         );
@@ -8912,6 +9214,11 @@ var FileSessionWriter = class {
     }
   }
   observeForSummary(event) {
+    if (event.type === "llm_response") {
+      for (const block of event.content) {
+        if (block.type === "tool_use") this.openToolUses.add(block.id);
+      }
+    }
     if (event.type === "tool_use") {
       this.openToolUses.add(event.id);
     } else if (event.type === "tool_call_start") {
@@ -8945,9 +9252,18 @@ var FileSessionWriter = class {
     }
   }
   async close() {
-    if (this.closing) return;
-    this.closing = true;
+    if (this.closePromise) return this.closePromise;
+    this.closePromise = this.doClose();
+    return this.closePromise;
+  }
+  async doClose() {
     this.closed = true;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flushBuffer();
+    await this.writeChain;
     this.summary = {
       ...this.summary,
       endedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9003,6 +9319,12 @@ var FileSessionWriter = class {
   }
   async truncateToCheckpoint(targetPromptIndex) {
     if (!this.filePath) return 0;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flushBuffer();
+    await this.writeChain;
     const raw = await fsp6.readFile(this.filePath, "utf8");
     const lines = raw.split("\n");
     const kept = [];
@@ -9065,6 +9387,12 @@ var FileSessionWriter = class {
   }
   async clearSession() {
     if (!this.filePath) return;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.writeBuffer = [];
+    await this.writeChain;
     const record = `${JSON.stringify({
       type: "session_start",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9563,6 +9891,1518 @@ var FleetManager = class {
   }
 };
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BudgetExceededError, BudgetThresholdSignal, CollabSession, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, LIGHT_BUDGET, LargeAnswerStore, MEDIUM_BUDGET, META_AGENTS, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, VERIFY_AGENTS, applyRosterBudget, attachAutoExtend, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMessage, dispatchAgent, formatHumanPrompt, getAgentDefinition, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeRollUpTool, makeSpawnTool, makeTerminateTool, makeWorkCompleteTool, rosterSummaryFromConfigs, scoreAgents };
+// src/coordination/mailbox-types.ts
+function normalizeRecipient(to) {
+  return to.trim().toLowerCase() === "all" ? "*" : to.trim();
+}
+
+// src/coordination/mailbox.ts
+var MAILBOX_FILE = "_mailbox.jsonl";
+var LINE_SEPARATOR = "\n";
+var DefaultMailbox = class {
+  filePath;
+  constructor(sessionDir) {
+    this.filePath = path4.join(sessionDir, MAILBOX_FILE);
+  }
+  get mailboxPath() {
+    return this.filePath;
+  }
+  // ── Send ──────────────────────────────────────────────────────────────
+  async send(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const msg = {
+      id: randomUUID(),
+      from: input.from,
+      // "all" is an accepted spelling of the broadcast address — canonical
+      // form on disk is '*' so every query/checker matches it.
+      to: normalizeRecipient(input.to),
+      type: input.type,
+      subject: input.subject,
+      body: input.body,
+      priority: input.priority ?? "normal",
+      readBy: {},
+      completed: false,
+      timestamp: now,
+      replyTo: input.replyTo,
+      taskContext: input.taskContext
+    };
+    const line = JSON.stringify(msg) + LINE_SEPARATOR;
+    await fsp6.mkdir(path4.dirname(this.filePath), { recursive: true });
+    await withFileLock(this.filePath, async () => {
+      await fsp6.appendFile(this.filePath, line, "utf8");
+    });
+    return msg;
+  }
+  // ── Query ─────────────────────────────────────────────────────────────
+  async query(q) {
+    const all = await this._readAll();
+    const limit = q.limit ?? 50;
+    let filtered = all;
+    if (q.to !== void 0) {
+      filtered = filtered.filter((m) => m.to === q.to || m.to === "*");
+    }
+    if (q.from !== void 0) {
+      filtered = filtered.filter((m) => m.from === q.from);
+    }
+    if (q.unreadBy !== void 0) {
+      filtered = filtered.filter((m) => !(q.unreadBy in m.readBy));
+    }
+    if (q.incompleteOnly) {
+      filtered = filtered.filter((m) => !m.completed);
+    }
+    if (q.type !== void 0) {
+      filtered = filtered.filter((m) => m.type === q.type);
+    }
+    if (q.minPriority !== void 0) {
+      const order = { low: 0, normal: 1, high: 2 };
+      const min = order[q.minPriority];
+      filtered = filtered.filter((m) => (order[m.priority] ?? 1) >= min);
+    }
+    if (q.since !== void 0) {
+      const since = q.since;
+      filtered = filtered.filter((m) => m.timestamp > since);
+    }
+    filtered.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return filtered.slice(0, limit);
+  }
+  // ── Ack ───────────────────────────────────────────────────────────────
+  async ack(input) {
+    let result = null;
+    await withFileLock(this.filePath, async () => {
+      const all = await this._readAll();
+      const idx = all.findIndex((m) => m.id === input.messageId);
+      if (idx === -1) return;
+      const msg = all[idx];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      if (input.read !== false) {
+        msg.readBy[input.readerId] = now;
+      }
+      if (input.completed) {
+        msg.completed = true;
+        msg.completedBy = input.readerId;
+        msg.completedAt = now;
+      }
+      if (input.outcome !== void 0) {
+        msg.outcome = input.outcome;
+      }
+      const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
+      await fsp6.writeFile(this.filePath, serialized, "utf8");
+      result = msg;
+    });
+    return result;
+  }
+  // ── Agent statuses ────────────────────────────────────────────────────
+  async getAgentStatuses() {
+    const all = await this._readAll();
+    const latest = /* @__PURE__ */ new Map();
+    for (const m of all) {
+      if (m.type !== "status") continue;
+      const existing = latest.get(m.from);
+      if (existing && m.timestamp <= existing.lastActivityAt) continue;
+      latest.set(m.from, {
+        agentId: m.from,
+        name: m.taskContext?.agentName ?? m.from,
+        role: m.taskContext?.agentRole,
+        sessionId: m.senderSessionId ?? "?",
+        status: m.taskContext?.status ?? "idle",
+        currentTool: void 0,
+        currentTask: m.subject,
+        iterations: 0,
+        toolCalls: 0,
+        lastActivityAt: m.timestamp,
+        lastSeenAt: m.timestamp,
+        online: true,
+        pid: 0,
+        source: void 0
+      });
+    }
+    return Array.from(latest.values()).sort(
+      (a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt)
+    );
+  }
+  // ── Stubs for cross-session features (not applicable per-session) ─────
+  async getOnlineAgents() {
+    return this.getAgentStatuses();
+  }
+  async registerAgent(_input) {
+  }
+  async heartbeat(_input) {
+  }
+  async unreadCount(forAgentId) {
+    const all = await this._readAll();
+    return all.filter(
+      (m) => (m.to === forAgentId || m.to === "*") && !(forAgentId in m.readBy) && !m.completed
+    ).length;
+  }
+  async close() {
+  }
+  async clearAll() {
+    await withFileLock(this.filePath, async () => {
+      await fsp6.writeFile(this.filePath, "", "utf8");
+    });
+  }
+  // ── Internal ──────────────────────────────────────────────────────────
+  async _readAll() {
+    try {
+      const raw = await fsp6.readFile(this.filePath, "utf8");
+      const lines = raw.split(LINE_SEPARATOR).filter((l) => l.trim().length > 0);
+      const messages = [];
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line);
+          if (!parsed["readBy"]) {
+            const readBy = {};
+            if (parsed["read"] && parsed["readAt"]) {
+              readBy[parsed["to"] ?? "unknown"] = parsed["readAt"];
+            }
+            parsed["readBy"] = readBy;
+            delete parsed["read"];
+            delete parsed["readAt"];
+          }
+          messages.push(parsed);
+        } catch {
+        }
+      }
+      return messages;
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+};
+var BrainMonitor = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.toolFailureStreak = opts.toolFailureStreak ?? 3;
+    this.errorStormCount = opts.errorStormCount ?? 4;
+    this.errorStormWindowMs = opts.errorStormWindowMs ?? 6e4;
+    this.cooldownMs = opts.cooldownMs ?? 12e4;
+  }
+  opts;
+  failStreaks = /* @__PURE__ */ new Map();
+  errorTimestamps = [];
+  lastEngagedAt = /* @__PURE__ */ new Map();
+  unsubscribers = [];
+  engaging = false;
+  toolFailureStreak;
+  errorStormCount;
+  errorStormWindowMs;
+  cooldownMs;
+  start() {
+    this.unsubscribers.push(
+      this.opts.events.on("tool.executed", (e) => {
+        if (e.ok) {
+          this.failStreaks.delete(e.name);
+          return;
+        }
+        const streak = (this.failStreaks.get(e.name) ?? 0) + 1;
+        this.failStreaks.set(e.name, streak);
+        if (streak >= this.toolFailureStreak) {
+          this.failStreaks.delete(e.name);
+          void this.engage("tool_failure_streak", {
+            question: `The tool "${e.name}" has failed ${streak} times in a row. Should the agent be steered to a different approach?`,
+            context: [
+              `Tool: ${e.name}`,
+              `Consecutive failures: ${streak}`,
+              e.output ? `Last output (truncated): ${String(e.output).slice(0, 400)}` : ""
+            ].filter(Boolean).join("\n")
+          });
+        }
+      })
+    );
+    this.unsubscribers.push(
+      this.opts.events.on("error", (e) => {
+        const now = Date.now();
+        this.errorTimestamps.push(now);
+        this.errorTimestamps = this.errorTimestamps.filter(
+          (t) => now - t <= this.errorStormWindowMs
+        );
+        if (this.errorTimestamps.length >= this.errorStormCount) {
+          const count = this.errorTimestamps.length;
+          this.errorTimestamps = [];
+          const message = e.err instanceof Error ? e.err.message : String(e.err);
+          void this.engage("error_storm", {
+            question: `${count} errors occurred within ${Math.round(this.errorStormWindowMs / 1e3)}s (phase: ${e.phase}). Should the agent be steered before more work is wasted?`,
+            context: `Latest error: ${message.slice(0, 400)}`
+          });
+        }
+      })
+    );
+  }
+  stop() {
+    for (const off of this.unsubscribers) off();
+    this.unsubscribers.length = 0;
+    this.failStreaks.clear();
+    this.errorTimestamps = [];
+  }
+  async engage(kind, input) {
+    const last = this.lastEngagedAt.get(kind) ?? 0;
+    if (this.engaging || Date.now() - last < this.cooldownMs) return;
+    this.engaging = true;
+    this.lastEngagedAt.set(kind, Date.now());
+    try {
+      const request = {
+        id: `brainmon-${randomUUID()}`,
+        source: "system",
+        question: input.question,
+        context: input.context,
+        options: [
+          {
+            id: "steer",
+            label: "Steer the agent with corrective guidance",
+            consequence: "A steer message is injected before its next step.",
+            risk: "low"
+          },
+          {
+            id: "continue",
+            label: "Let the agent continue unaided",
+            risk: "low"
+          }
+        ],
+        risk: "medium",
+        // Without an LLM layer the policy brain resolves this fallback to
+        // "continue" — the monitor observes but never interferes.
+        fallback: "continue"
+      };
+      const decision = await this.opts.brain.decide(request);
+      const intervened = await this.maybeIntervene(kind, request, decision);
+      this.opts.events.emit("brain.intervention", {
+        kind,
+        request,
+        decision,
+        intervened,
+        at: Date.now()
+      });
+    } catch {
+    } finally {
+      this.engaging = false;
+    }
+  }
+  async maybeIntervene(kind, request, decision) {
+    if (decision.type !== "answer") return false;
+    const choseSteer = decision.optionId === "steer";
+    const freeTextGuidance = !decision.optionId && !/^continue\b/i.test(decision.text.trim()) && decision.text.trim().length > 0;
+    if (!choseSteer && !freeTextGuidance) return false;
+    const guidance = decision.rationale?.trim() || decision.text.trim();
+    try {
+      await this.opts.intervene({
+        subject: `Brain intervention: ${kind.replace(/_/g, " ")}`,
+        body: [
+          `The Brain engaged after detecting: ${request.question}`,
+          "",
+          `Guidance: ${guidance}`,
+          "",
+          "Adjust your approach accordingly \u2014 do not simply retry the same action."
+        ].join("\n")
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function projectSlug(absRoot) {
+  const base = slugify(path4.basename(absRoot));
+  const hash = createHash("sha256").update(path4.resolve(absRoot)).digest("hex").slice(0, 6);
+  return `${base}-${hash}`;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
+}
+function wstackGlobalRoot() {
+  const fromEnv = process.env["WRONGSTACK_HOME"];
+  if (fromEnv && fromEnv.trim().length > 0) return path4.resolve(fromEnv);
+  return path4.join(os.homedir(), ".wrongstack");
+}
+
+// src/coordination/global-mailbox.ts
+var MAILBOX_FILE2 = "_mailbox.jsonl";
+var AGENT_STALE_MS = 6e4;
+var HEARTBEAT_THROTTLE_MS = 5e3;
+var REGISTRY_CACHE_TTL_MS = 2e3;
+var LINE_SEPARATOR2 = "\n";
+function resolveProjectDir(projectRoot, globalRoot) {
+  return path4.join(globalRoot, "projects", projectSlug(projectRoot));
+}
+var GlobalMailbox = class {
+  /** Path to the JSONL message file. */
+  messagePath;
+  /** Path to the JSON agent registry file. */
+  registryPath;
+  /** Optional event bus for emitting agent registration/heartbeat events. */
+  _events;
+  /**
+   * Local cache of the agent registry to avoid re-reading on every call.
+   * Time-bounded: the registry file is shared ACROSS PROCESSES (that's the
+   * whole point of GlobalMailbox), so a cache served forever would never see
+   * agents registered by other sessions. Writers always bypass it.
+   */
+  _registryCache = null;
+  /** When the registry cache was last refreshed from disk (epoch ms). */
+  _registryCacheAt = 0;
+  /** Last time each local agent sent a heartbeat (throttle). */
+  _lastHeartbeat = /* @__PURE__ */ new Map();
+  /**
+   * @param projectDir — `~/.wrongstack/projects/<slug>/`
+   * @param events — optional EventBus for real-time TUI/WebUI notifications
+   */
+  constructor(projectDir, events) {
+    this.messagePath = path4.join(projectDir, MAILBOX_FILE2);
+    this.registryPath = path4.join(projectDir, "_mailbox.registry.json");
+    this._events = events;
+  }
+  // ── Messages ────────────────────────────────────────────────────────────
+  async send(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const msg = {
+      id: randomUUID(),
+      from: input.from,
+      // "all" is an accepted spelling of the broadcast address — canonical
+      // form on disk is '*' so every query/checker matches it.
+      to: normalizeRecipient(input.to),
+      type: input.type,
+      subject: input.subject,
+      body: input.body,
+      priority: input.priority ?? "normal",
+      readBy: {},
+      completed: false,
+      timestamp: now,
+      replyTo: input.replyTo,
+      taskContext: input.taskContext
+    };
+    const line = JSON.stringify(msg) + LINE_SEPARATOR2;
+    await fsp6.mkdir(path4.dirname(this.messagePath), { recursive: true });
+    await withFileLock(this.messagePath, async () => {
+      await fsp6.appendFile(this.messagePath, line, "utf8");
+    });
+    return msg;
+  }
+  async query(q) {
+    const all = await this._readMessages();
+    const limit = q.limit ?? 50;
+    let filtered = all;
+    if (q.to !== void 0) {
+      filtered = filtered.filter((m) => m.to === q.to || m.to === "*");
+    }
+    if (q.from !== void 0) {
+      filtered = filtered.filter((m) => m.from === q.from);
+    }
+    if (q.unreadBy !== void 0) {
+      filtered = filtered.filter((m) => !(q.unreadBy in m.readBy));
+    }
+    if (q.incompleteOnly) {
+      filtered = filtered.filter((m) => !m.completed);
+    }
+    if (q.type !== void 0) {
+      filtered = filtered.filter((m) => m.type === q.type);
+    }
+    if (q.minPriority !== void 0) {
+      const order = { low: 0, normal: 1, high: 2 };
+      const min = order[q.minPriority];
+      filtered = filtered.filter((m) => (order[m.priority] ?? 1) >= min);
+    }
+    if (q.since !== void 0) {
+      const since = q.since;
+      filtered = filtered.filter((m) => m.timestamp > since);
+    }
+    filtered.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return filtered.slice(0, limit);
+  }
+  async ack(input) {
+    let result = null;
+    await withFileLock(this.messagePath, async () => {
+      const all = await this._readMessages();
+      const idx = all.findIndex((m) => m.id === input.messageId);
+      if (idx === -1) return;
+      const msg = all[idx];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      if (input.read !== false) {
+        msg.readBy[input.readerId] = now;
+      }
+      if (input.completed) {
+        msg.completed = true;
+        msg.completedBy = input.readerId;
+        msg.completedAt = now;
+      }
+      if (input.outcome !== void 0) {
+        msg.outcome = input.outcome;
+      }
+      const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
+      await fsp6.writeFile(this.messagePath, serialized, "utf8");
+      result = msg;
+    });
+    return result;
+  }
+  async unreadCount(forAgentId) {
+    const all = await this._readMessages();
+    return all.filter(
+      (m) => (m.to === forAgentId || m.to === "*") && !(forAgentId in m.readBy) && !m.completed
+    ).length;
+  }
+  // ── Agent registry ──────────────────────────────────────────────────────
+  async registerAgent(input) {
+    await this._ensureRegistry();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const agent = {
+      agentId: input.agentId,
+      sessionId: input.sessionId,
+      name: input.name,
+      role: input.role,
+      status: "idle",
+      currentTool: void 0,
+      currentTask: void 0,
+      iterations: 0,
+      toolCalls: 0,
+      registeredAt: now,
+      lastSeenAt: now,
+      pid: input.pid,
+      source: input.source
+    };
+    await withFileLock(this.registryPath, async () => {
+      const registry = await this._readRegistry({ fresh: true });
+      this._pruneStaleInPlace(registry);
+      registry.set(input.agentId, agent);
+      this._registryCache = registry;
+      this._registryCacheAt = Date.now();
+      await this._writeRegistry(registry);
+    });
+    this._events?.emitCustom("mailbox.agent_registered", {
+      agentId: input.agentId,
+      sessionId: input.sessionId,
+      name: input.name,
+      role: input.role,
+      source: input.source
+    });
+  }
+  async heartbeat(input) {
+    const last = this._lastHeartbeat.get(input.agentId) ?? 0;
+    const now = Date.now();
+    if (now - last < HEARTBEAT_THROTTLE_MS) return;
+    this._lastHeartbeat.set(input.agentId, now);
+    await this._ensureRegistry();
+    await withFileLock(this.registryPath, async () => {
+      const registry = await this._readRegistry({ fresh: true });
+      this._pruneStaleInPlace(registry);
+      const agent = registry.get(input.agentId);
+      if (agent) {
+        const iso = (/* @__PURE__ */ new Date()).toISOString();
+        agent.lastSeenAt = iso;
+        if (input.status !== void 0) agent.status = input.status;
+        if (input.currentTool !== void 0) agent.currentTool = input.currentTool;
+        if (input.currentTask !== void 0) agent.currentTask = input.currentTask;
+        if (input.iterations !== void 0) agent.iterations = input.iterations;
+        if (input.toolCalls !== void 0) agent.toolCalls = input.toolCalls;
+      }
+      this._registryCache = registry;
+      this._registryCacheAt = Date.now();
+      await this._writeRegistry(registry);
+    });
+    this._events?.emitCustom("mailbox.agent_heartbeat", {
+      agentId: input.agentId,
+      status: input.status,
+      currentTool: input.currentTool,
+      currentTask: input.currentTask
+    });
+  }
+  async getAgentStatuses() {
+    await this._ensureRegistry();
+    const registry = await this._readRegistry();
+    this._pruneStaleInPlace(registry);
+    const now = Date.now();
+    return Array.from(registry.values()).map((a) => ({
+      agentId: a.agentId,
+      name: a.name,
+      role: a.role,
+      sessionId: a.sessionId,
+      status: a.status,
+      currentTool: a.currentTool,
+      currentTask: a.currentTask,
+      iterations: a.iterations,
+      toolCalls: a.toolCalls,
+      lastActivityAt: a.lastSeenAt,
+      lastSeenAt: a.lastSeenAt,
+      online: now - new Date(a.lastSeenAt).getTime() < AGENT_STALE_MS,
+      pid: a.pid,
+      source: a.source
+    })).sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
+  }
+  async getOnlineAgents() {
+    const all = await this.getAgentStatuses();
+    return all.filter((a) => a.online);
+  }
+  // ── Lifecycle ───────────────────────────────────────────────────────────
+  async close() {
+    this._registryCache = null;
+  }
+  async clearAll() {
+    await withFileLock(this.messagePath, async () => {
+      await fsp6.writeFile(this.messagePath, "", "utf8");
+    });
+  }
+  // ── Internal ────────────────────────────────────────────────────────────
+  async _readMessages() {
+    try {
+      const raw = await fsp6.readFile(this.messagePath, "utf8");
+      const lines = raw.split(LINE_SEPARATOR2).filter((l) => l.trim().length > 0);
+      const messages = [];
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line);
+          if (!parsed["readBy"]) {
+            const readBy = {};
+            if (parsed["read"] && parsed["readAt"]) {
+              readBy[parsed["to"]] = parsed["readAt"];
+            }
+            parsed["readBy"] = readBy;
+            delete parsed["read"];
+            delete parsed["readAt"];
+          }
+          messages.push(parsed);
+        } catch {
+        }
+      }
+      return messages;
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  async _ensureRegistry() {
+    await fsp6.mkdir(path4.dirname(this.registryPath), { recursive: true });
+  }
+  async _readRegistry(opts) {
+    if (!opts?.fresh && this._registryCache && Date.now() - this._registryCacheAt < REGISTRY_CACHE_TTL_MS) {
+      return new Map(this._registryCache);
+    }
+    try {
+      const raw = await fsp6.readFile(this.registryPath, "utf8");
+      const data = JSON.parse(raw);
+      const map = /* @__PURE__ */ new Map();
+      for (const [id, agent] of Object.entries(data)) {
+        map.set(id, agent);
+      }
+      this._registryCache = map;
+      this._registryCacheAt = Date.now();
+      return new Map(map);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        const empty = /* @__PURE__ */ new Map();
+        this._registryCache = empty;
+        this._registryCacheAt = Date.now();
+        return empty;
+      }
+      throw err;
+    }
+  }
+  _pruneStaleInPlace(registry) {
+    const cutoff = Date.now() - AGENT_STALE_MS;
+    for (const agent of registry.values()) {
+      if (new Date(agent.lastSeenAt).getTime() < cutoff) {
+        agent.status = "idle";
+      }
+    }
+  }
+  async _writeRegistry(registry) {
+    const obj = {};
+    for (const [id, agent] of registry) {
+      obj[id] = agent;
+    }
+    const tmp = `${this.registryPath}.${randomUUID().slice(0, 8)}.tmp`;
+    await fsp6.writeFile(tmp, JSON.stringify(obj, null, 2), "utf8");
+    await fsp6.rename(tmp, this.registryPath);
+  }
+};
+function defaultResolveProjectDir(ctx) {
+  return resolveProjectDir(ctx.projectRoot, wstackGlobalRoot());
+}
+function mailboxSessionTag(sessionId) {
+  return createHash("sha256").update(sessionId).digest("hex").slice(0, 8);
+}
+function resolveMailboxIdentity(ctx, fallbackBase = "leader") {
+  const fieldId = ctx.agentId && ctx.agentId !== "unknown" ? ctx.agentId : void 0;
+  const baseId = ctx.meta["agentId"] ?? fieldId ?? fallbackBase;
+  const sessionId = ctx.meta["sessionId"] ?? ctx.session?.id ?? "default";
+  const callerId = ctx.meta["globalAgentId"] ?? `${baseId}@${mailboxSessionTag(sessionId)}`;
+  const fieldName = ctx.agentName && ctx.agentName !== "Unknown Agent" ? ctx.agentName : void 0;
+  const name = ctx.meta["agentName"] ?? fieldName ?? baseId;
+  const role = ctx.meta["agentRole"];
+  return { baseId, callerId, name, role, sessionId };
+}
+function makeMailboxTool(opts = {}) {
+  const resolveMailbox = opts.resolveMailbox ?? ((ctx) => {
+    const dir = opts.projectDir ?? defaultResolveProjectDir(ctx);
+    return new GlobalMailbox(dir, opts.events);
+  });
+  const agentId = opts.agentId ?? "leader";
+  const sessionId = opts.sessionId ?? "default";
+  const shortHint = "Sub-commands: check (unread), send (to/broadcast), ack (read/complete), query (filter), status (all agents), online (active only), unread (count).";
+  return {
+    name: "mailbox",
+    description: "Inter-agent mailbox with cross-session support. Send messages, check for incoming messages, acknowledge with read receipts, query by criteria, see online agents.",
+    usageHint: shortHint,
+    category: "coordination",
+    permission: "auto",
+    mutating: true,
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["check", "send", "ack", "query", "status", "online", "unread"],
+          description: "Which mailbox operation to perform."
+        },
+        to: { type: "string", description: "Recipient agent id, or '*' / 'all' for broadcast." },
+        type: { type: "string", enum: ["note", "ask", "assign", "steer", "btw", "broadcast", "status", "result"], description: "Message type." },
+        subject: { type: "string", description: "Short subject line." },
+        body: { type: "string", description: "Full message content." },
+        priority: { type: "string", enum: ["low", "normal", "high"] },
+        replyTo: { type: "string", description: "Reply to a specific message id." },
+        messageId: { type: "string", description: "Message id to acknowledge. Required for 'ack'." },
+        read: { type: "boolean", description: "Mark as read (adds read receipt)." },
+        completed: { type: "boolean", description: "Mark as completed." },
+        outcome: { type: "string", description: "Outcome summary when marking complete." },
+        unreadBy: { type: "string", description: "Filter messages unread by this agent. Used by 'check'." },
+        incompleteOnly: { type: "boolean", description: "Only incomplete messages." },
+        from: { type: "string", description: "Filter by sender." },
+        minPriority: { type: "string", enum: ["low", "normal", "high"] },
+        since: { type: "string", description: "ISO8601 timestamp \u2014 only messages after this." },
+        limit: { type: "number", description: "Max messages to return." }
+      },
+      required: ["action"]
+    },
+    async execute(input, ctx) {
+      const mb = resolveMailbox(ctx);
+      const i = input ?? {};
+      const action = i.action;
+      const identity = resolveMailboxIdentity(ctx, agentId);
+      const baseCallerId = identity.baseId;
+      const callerId = identity.callerId;
+      const callerSessionId = ctx.meta["sessionId"] ?? (ctx.session?.id ?? sessionId);
+      try {
+        await mb.registerAgent({
+          agentId: callerId,
+          sessionId: callerSessionId,
+          name: identity.name,
+          role: identity.role,
+          pid: process.pid,
+          source: ctx.meta["source"] ?? "cli"
+        });
+      } catch {
+      }
+      try {
+        await mb.heartbeat({ agentId: callerId });
+      } catch {
+      }
+      switch (action) {
+        case "check":
+          return executeCheck(mb, callerId, [baseCallerId], i);
+        case "send":
+          return executeSend(mb, callerId, callerSessionId, i);
+        case "ack":
+          return executeAck(mb, callerId, i);
+        case "query":
+          return executeQuery(mb, i);
+        case "status":
+          return executeStatus(mb);
+        case "online":
+          return executeOnline(mb);
+        case "unread":
+          return executeUnread(mb, callerId, [baseCallerId]);
+        default:
+          return { ok: false, error: `Unknown action: "${action}". Use check, send, ack, query, status, online, or unread.` };
+      }
+    }
+  };
+}
+async function executeCheck(mb, agentId, aliases, i) {
+  const limit = i.limit ?? 20;
+  const targets = [agentId, ...aliases.filter((al) => al && al !== agentId)];
+  const batches = await Promise.all(
+    targets.map(
+      (to) => mb.query({ to, unreadBy: agentId, limit, minPriority: "low" }).catch(() => [])
+    )
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const messages = batches.flat().filter((m) => {
+    if (seen.has(m.id)) return false;
+    seen.add(m.id);
+    return true;
+  });
+  const acked = await Promise.all(
+    messages.map(async (m) => {
+      const updated = await mb.ack({ messageId: m.id, readerId: agentId, read: true }).catch(() => null);
+      return updated ?? m;
+    })
+  );
+  return {
+    ok: true,
+    count: acked.length,
+    messages: acked.map((m) => formatMessage(m, agentId)),
+    summary: acked.length === 0 ? "No unread messages." : `${acked.length} unread message(s).`
+  };
+}
+async function executeSend(mb, agentId, _sessionId, i) {
+  const to = i.to;
+  const tp = i.type;
+  const subject = i.subject;
+  const body = i.body;
+  if (!to) return { ok: false, error: '"to" is required.' };
+  if (!tp) return { ok: false, error: '"type" is required.' };
+  if (!subject) return { ok: false, error: '"subject" is required.' };
+  if (body === void 0 || body === null) return { ok: false, error: '"body" is required.' };
+  const msg = await mb.send({
+    from: agentId,
+    to,
+    type: tp,
+    subject,
+    body,
+    priority: i.priority ?? "normal",
+    replyTo: i.replyTo
+  });
+  return {
+    ok: true,
+    messageId: msg.id,
+    to: msg.to,
+    type: msg.type,
+    timestamp: msg.timestamp,
+    summary: `Message sent to ${msg.to === "*" ? "all agents" : msg.to}. Id: ${msg.id}`
+  };
+}
+async function executeAck(mb, agentId, i) {
+  const messageId = i.messageId;
+  if (!messageId) return { ok: false, error: '"messageId" is required.' };
+  const updated = await mb.ack({
+    messageId,
+    readerId: agentId,
+    read: i.read,
+    completed: i.completed,
+    outcome: i.outcome
+  });
+  if (!updated) return { ok: false, error: `Message "${messageId}" not found.` };
+  return {
+    ok: true,
+    messageId: updated.id,
+    readBy: Object.keys(updated.readBy),
+    readByCount: Object.keys(updated.readBy).length,
+    completed: updated.completed,
+    completedBy: updated.completedBy,
+    outcome: updated.outcome,
+    summary: `Message ${messageId} acknowledged. Read by ${Object.keys(updated.readBy).length} agent(s), Completed: ${updated.completed}.`
+  };
+}
+async function executeQuery(mb, i) {
+  const limit = i.limit ?? 50;
+  const messages = await mb.query({
+    to: i.to,
+    from: i.from,
+    unreadBy: i.unreadBy,
+    incompleteOnly: i.incompleteOnly,
+    type: i.type,
+    minPriority: i.minPriority,
+    since: i.since,
+    limit
+  });
+  return { ok: true, count: messages.length, messages, summary: `${messages.length} message(s).` };
+}
+async function executeStatus(mb) {
+  const agents = await mb.getAgentStatuses();
+  return {
+    ok: true,
+    count: agents.length,
+    agents: agents.map((a) => ({
+      agentId: a.agentId,
+      name: a.name,
+      role: a.role,
+      sessionId: a.sessionId,
+      status: a.status,
+      currentTool: a.currentTool,
+      currentTask: a.currentTask,
+      iterations: a.iterations,
+      toolCalls: a.toolCalls,
+      lastSeenAt: a.lastSeenAt,
+      online: a.online,
+      pid: a.pid,
+      source: a.source
+    })),
+    summary: `${agents.filter((a) => a.online).length} online, ${agents.length} total.`
+  };
+}
+async function executeOnline(mb) {
+  const agents = await mb.getOnlineAgents();
+  return {
+    ok: true,
+    count: agents.length,
+    agents: agents.map((a) => ({
+      agentId: a.agentId,
+      name: a.name,
+      role: a.role,
+      sessionId: a.sessionId,
+      status: a.status,
+      currentTool: a.currentTool,
+      currentTask: a.currentTask,
+      lastSeenAt: a.lastSeenAt,
+      source: a.source
+    })),
+    summary: `${agents.length} online agent(s).`
+  };
+}
+async function executeUnread(mb, agentId, aliases = []) {
+  const targets = [agentId, ...aliases.filter((al) => al && al !== agentId)];
+  const batches = await Promise.all(
+    targets.map((to) => mb.query({ to, unreadBy: agentId, limit: 200 }).catch(() => []))
+  );
+  const ids = new Set(batches.flat().map((m) => m.id));
+  return { ok: true, count: ids.size, summary: `${ids.size} unread message(s) for you.` };
+}
+function formatMessage(m, readerId) {
+  const maxBody = 2e3;
+  const truncated = m.body.length > maxBody ? `${m.body.slice(0, maxBody)}\u2026 [truncated]` : m.body;
+  return {
+    id: m.id,
+    from: m.from,
+    to: m.to,
+    type: m.type,
+    subject: m.subject,
+    body: truncated,
+    priority: m.priority,
+    readByMe: readerId in m.readBy,
+    readByCount: Object.keys(m.readBy).length,
+    readBy: m.readBy,
+    completed: m.completed,
+    completedBy: m.completedBy,
+    outcome: m.outcome,
+    timestamp: m.timestamp,
+    replyTo: m.replyTo,
+    senderSessionId: m.senderSessionId
+  };
+}
+
+// src/coordination/mail-tools.ts
+function makeResolver(opts) {
+  return opts.resolveMailbox ?? ((ctx) => new GlobalMailbox(opts.projectDir ?? defaultResolveProjectDir(ctx), opts.events));
+}
+async function register(mb, ctx) {
+  const identity = resolveMailboxIdentity(ctx);
+  try {
+    await mb.registerAgent({
+      agentId: identity.callerId,
+      sessionId: identity.sessionId,
+      name: identity.name,
+      role: identity.role,
+      pid: process.pid,
+      source: ctx.meta["source"] ?? "cli"
+    });
+    await mb.heartbeat({ agentId: identity.callerId });
+  } catch {
+  }
+  return identity;
+}
+function makeMailSendTool(opts = {}) {
+  const resolveMailbox = makeResolver(opts);
+  return {
+    name: "mail_send",
+    description: 'Send a mail to other agents working on this project (other terminals, TUIs, WebUIs). Use it to hand off work ("can you review src/auth.ts?"), ask questions, or announce what you just did. to="*" broadcasts to everyone; to="leader" reaches every leader process; an exact id like "leader@a1b2c3d4" reaches one agent. Recipients see your mail automatically before their next step.',
+    usageHint: 'mail_send to="*" subject="auth refactor done" body="touched src/auth/*, please review"',
+    category: "coordination",
+    permission: "auto",
+    mutating: true,
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: {
+          type: "string",
+          description: 'Recipient: exact agent id ("leader@a1b2c3d4"), base alias ("leader"), or "*" / "all" for everyone.'
+        },
+        subject: { type: "string", description: "Short subject line." },
+        body: { type: "string", description: "The message." },
+        type: {
+          type: "string",
+          enum: ["note", "ask", "assign", "steer", "btw", "broadcast", "status", "result"],
+          description: 'Message intent. Default: "broadcast" when to="*", otherwise "note".'
+        },
+        priority: { type: "string", enum: ["low", "normal", "high"] },
+        replyTo: { type: "string", description: "Message id this replies to." }
+      },
+      required: ["to", "subject", "body"]
+    },
+    async execute(input, ctx) {
+      const i = input ?? {};
+      const rawTo = i.to;
+      const subject = i.subject;
+      const body = i.body;
+      if (!rawTo || !subject || body === void 0 || body === null) {
+        return { ok: false, error: '"to", "subject" and "body" are required.' };
+      }
+      const to = normalizeRecipient(rawTo);
+      const mb = resolveMailbox(ctx);
+      const identity = await register(mb, ctx);
+      const type = i.type ?? (to === "*" ? "broadcast" : "note");
+      const msg = await mb.send({
+        from: identity.callerId,
+        to,
+        type,
+        subject,
+        body,
+        priority: i.priority ?? "normal",
+        replyTo: i.replyTo
+      });
+      return {
+        ok: true,
+        messageId: msg.id,
+        from: identity.callerId,
+        to: msg.to,
+        summary: `Mail sent to ${msg.to === "*" ? "all agents" : msg.to} as ${identity.callerId}.`
+      };
+    }
+  };
+}
+function makeMailInboxTool(opts = {}) {
+  const resolveMailbox = makeResolver(opts);
+  return {
+    name: "mail_inbox",
+    description: 'Read your unread mail from other agents on this project and mark it read. Covers mail addressed to you directly, to your base name (e.g. "leader"), and broadcasts ("*"). Urgent steer/btw mail is already injected automatically \u2014 use this to catch up on notes, questions, handoffs and results, or after a long stretch of tool work.',
+    usageHint: "mail_inbox  (optionally: limit=10, markRead=false to peek)",
+    category: "coordination",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Max messages to return (default 20)." },
+        markRead: {
+          type: "boolean",
+          description: "Add a read receipt for each returned message (default true)."
+        }
+      }
+    },
+    async execute(input, ctx) {
+      const i = input ?? {};
+      const limit = i.limit ?? 20;
+      const markRead = i.markRead ?? true;
+      const mb = resolveMailbox(ctx);
+      const identity = await register(mb, ctx);
+      const targets = [identity.callerId];
+      if (identity.baseId !== identity.callerId) targets.push(identity.baseId);
+      const batches = await Promise.all(
+        targets.map(
+          (to) => mb.query({ to, unreadBy: identity.callerId, limit }).catch(() => [])
+        )
+      );
+      const seen = /* @__PURE__ */ new Set();
+      const messages = batches.flat().filter((m) => {
+        if (seen.has(m.id) || m.from === identity.callerId) return false;
+        seen.add(m.id);
+        return true;
+      }).slice(0, limit);
+      if (markRead) {
+        await Promise.all(
+          messages.map(
+            (m) => mb.ack({ messageId: m.id, readerId: identity.callerId, read: true }).catch(() => null)
+          )
+        );
+      }
+      return {
+        ok: true,
+        you: identity.callerId,
+        count: messages.length,
+        messages: messages.map((m) => ({
+          id: m.id,
+          from: m.from,
+          to: m.to,
+          type: m.type,
+          subject: m.subject,
+          body: m.body.length > 2e3 ? `${m.body.slice(0, 2e3)}\u2026 [truncated]` : m.body,
+          timestamp: m.timestamp,
+          replyTo: m.replyTo
+        })),
+        summary: messages.length === 0 ? "Inbox empty." : `${messages.length} unread message(s)${markRead ? " (marked read)" : ""}. Reply with mail_send using the sender id.`
+      };
+    }
+  };
+}
+
+// src/coordination/dep-watcher.ts
+var DEPENDENCY_FILE_PATTERNS = [
+  "package.json",
+  "tsconfig.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "package-lock.json",
+  "go.mod",
+  "go.sum",
+  "Cargo.toml",
+  "Cargo.lock",
+  "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "requirements.txt",
+  "Pipfile",
+  "Pipfile.lock",
+  "Gemfile",
+  "Gemfile.lock",
+  "composer.json",
+  "composer.lock",
+  "mix.exs",
+  "mix.lock",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "settings.gradle",
+  "settings.gradle.kts",
+  "*.csproj",
+  "packages.config",
+  "pubspec.yaml",
+  "pubspec.lock",
+  "CMakeLists.txt",
+  "conanfile.txt",
+  "conanfile.py",
+  "vcpkg.json"
+];
+function makeDependencyWatcherConfig(opts) {
+  const {
+    projectRoot,
+    mailbox,
+    targetAgent = "*",
+    watcherAgentId = "dep-watcher",
+    debounceMs = 3e3,
+    patterns = DEPENDENCY_FILE_PATTERNS
+  } = opts;
+  const watchPaths = [];
+  for (const p of patterns) {
+    if (p.includes("*")) {
+      continue;
+    }
+    watchPaths.push(`${projectRoot}/${p}`);
+  }
+  watchPaths.push(projectRoot);
+  const unique = [...new Set(watchPaths)];
+  const globPatterns = patterns.filter((p) => p.includes("*"));
+  const plainPatterns = patterns.filter((p) => !p.includes("*"));
+  function matchesPattern(filePath) {
+    const basename5 = filePath.split("/").pop()?.split("\\").pop() ?? "";
+    if (plainPatterns.includes(basename5)) return true;
+    for (const gp of globPatterns) {
+      const regex = new RegExp(
+        "^" + gp.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
+      );
+      if (regex.test(basename5)) return true;
+    }
+    return false;
+  }
+  const pending = /* @__PURE__ */ new Map();
+  return {
+    watchPaths: unique,
+    debounceMs,
+    async onChange(entry) {
+      if (entry.event === "delete") return;
+      if (!matchesPattern(entry.path)) return;
+      const key = entry.path;
+      const existing = pending.get(key);
+      if (existing) clearTimeout(existing);
+      pending.set(
+        key,
+        setTimeout(async () => {
+          pending.delete(key);
+          try {
+            const fileName = entry.path.split("/").pop()?.split("\\").pop() ?? entry.path;
+            await mailbox.send({
+              from: watcherAgentId,
+              to: targetAgent,
+              type: "assign",
+              subject: `Dependency file changed: ${fileName}`,
+              body: [
+                `File: ${entry.path}`,
+                `Event: ${entry.event}`,
+                `Timestamp: ${entry.timestamp}`,
+                "",
+                `Action: Run a tech-stack audit on the changed dependency file.`,
+                `Validate any new packages, check versions, flag deprecated or prehistoric packages.`,
+                `Report findings back via mailbox (type: result).`
+              ].join("\n"),
+              priority: "high",
+              taskContext: {
+                agentRole: "tech-stack",
+                status: "pending"
+              }
+            });
+          } catch {
+          }
+        }, debounceMs)
+      );
+    }
+  };
+}
+
+// src/coordination/dep-watcher-bridge.ts
+function attachDepWatcherBridge(opts) {
+  const {
+    events,
+    mailbox,
+    projectRoot,
+    targetAgent = "tech-stack",
+    watcherAgentId = "dep-watcher",
+    debounceMs = 3e3
+  } = opts;
+  const cfg = makeDependencyWatcherConfig({
+    projectRoot,
+    mailbox,
+    targetAgent,
+    watcherAgentId,
+    debounceMs
+  });
+  const unsub = events.onPattern("file-watcher:changed", (_eventName, rawPayload) => {
+    const payload = rawPayload;
+    if (!payload?.path) return;
+    void cfg.onChange({
+      path: payload.path,
+      event: payload.event ?? "change",
+      timestamp: payload.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    }).catch(() => {
+    });
+  });
+  return () => {
+    unsub();
+  };
+}
+
+// src/coordination/mailbox-hooks.ts
+function createMailboxHooks(opts) {
+  const { mailbox, agentId, notifyNewMail = true, heartbeat = true } = opts;
+  let lastUnreadCount = -1;
+  return {
+    /**
+     * Call before each tool execution. Checks mailbox and emits events.
+     * @param events — EventBus-like object with emit method.
+     */
+    async beforeTool(events) {
+      try {
+        const count = await mailbox.unreadCount(agentId);
+        if (notifyNewMail && count !== lastUnreadCount) {
+          lastUnreadCount = count;
+          events.emit("mailbox.unread_count", { agentId, count });
+        }
+      } catch {
+      }
+    },
+    /**
+     * Call after each tool execution. Updates heartbeat and optionally
+     * current tool status.
+     */
+    async afterTool(toolName) {
+      if (!heartbeat) return;
+      try {
+        await mailbox.heartbeat({
+          agentId,
+          status: "running",
+          currentTool: toolName
+        });
+      } catch {
+      }
+    },
+    /** Reset the cached unread count (e.g., after the agent checks manually). */
+    reset() {
+      lastUnreadCount = -1;
+    }
+  };
+}
+var DEFAULT_MAX_ENTRIES = 1e4;
+var LOG_FILENAME = "package-authors.json";
+function logPath(storageDir) {
+  return path4.join(storageDir, LOG_FILENAME);
+}
+async function loadLog(storageDir, projectRoot) {
+  try {
+    const raw = await fsp6.readFile(logPath(storageDir), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.entries || !Array.isArray(parsed.entries)) {
+      return { projectRoot, entries: [] };
+    }
+    return parsed;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { projectRoot, entries: [] };
+    }
+    throw err;
+  }
+}
+async function saveLog(storageDir, log) {
+  await fsp6.mkdir(storageDir, { recursive: true });
+  const tmp = `${logPath(storageDir)}.tmp.${Date.now()}`;
+  await fsp6.writeFile(tmp, JSON.stringify(log, null, 2) + "\n", "utf-8");
+  await fsp6.rename(tmp, logPath(storageDir));
+}
+function detectEcosystem(manifestPath) {
+  const name = path4.basename(manifestPath).toLowerCase();
+  if (name === "package.json") return "npm";
+  if (name === "go.mod") return "go";
+  if (name === "cargo.toml") return "cargo";
+  if (name === "pyproject.toml" || name === "requirements.txt" || name === "pipfile" || name === "pipfile.lock") return "pip";
+  if (name === "gemfile" || name === "gemfile.lock") return "gem";
+  if (name === "composer.json" || name === "composer.lock") return "composer";
+  if (name.endsWith(".csproj") || name === "packages.config") return "nuget";
+  if (name === "mix.exs" || name === "mix.lock") return "elixir";
+  if (name === "pom.xml" || name.startsWith("build.gradle")) return "maven";
+  if (name === "pubspec.yaml" || name === "pubspec.lock") return "dart";
+  if (name === "vcpkg.json") return "vcpkg";
+  if (name === "conanfile.txt" || name === "conanfile.py") return "conan";
+  if (name === "cmakeLists.txt") return "cmake";
+  return "unknown";
+}
+async function recordPackageAction(opts, entry) {
+  const { storageDir, projectRoot, maxEntries = DEFAULT_MAX_ENTRIES } = opts;
+  const log = await loadLog(storageDir, projectRoot);
+  log.entries.push({
+    ...entry,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (log.entries.length > maxEntries) {
+    const keep = Math.floor(maxEntries * 0.8);
+    log.entries = log.entries.slice(-keep);
+    log.lastCompactedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  await saveLog(storageDir, log);
+}
+async function getPackageAuthor(opts, manifestPath, packageName) {
+  const log = await loadLog(opts.storageDir, opts.projectRoot);
+  const normalizedManifest = manifestPath.replace(/\\/g, "/");
+  for (let i = log.entries.length - 1; i >= 0; i--) {
+    const e = log.entries[i];
+    if (e && e.manifestPath.replace(/\\/g, "/") === normalizedManifest && e.packageName === packageName) {
+      return e;
+    }
+  }
+  return void 0;
+}
+async function getManifestPackages(opts, manifestPath) {
+  const log = await loadLog(opts.storageDir, opts.projectRoot);
+  const normalizedManifest = manifestPath.replace(/\\/g, "/");
+  return log.entries.filter(
+    (e) => e.manifestPath.replace(/\\/g, "/") === normalizedManifest
+  );
+}
+async function getPackagesByAgent(opts, agentId) {
+  const log = await loadLog(opts.storageDir, opts.projectRoot);
+  const map = /* @__PURE__ */ new Map();
+  for (const e of log.entries) {
+    if (e.agentId === agentId) {
+      const key = `${e.manifestPath}|${e.packageName}`;
+      map.set(key, e);
+    }
+  }
+  return map;
+}
+async function updatePackageOutdatedStatus(opts, manifestPath, packageName, outdated, latestVersion) {
+  const { storageDir, projectRoot } = opts;
+  const log = await loadLog(storageDir, projectRoot);
+  log.entries.push({
+    manifestPath,
+    packageName,
+    versionSpec: "",
+    ecosystem: detectEcosystem(manifestPath),
+    agentId: "outdated-checker",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    outdated,
+    latestVersion
+  });
+  await saveLog(storageDir, log);
+}
+async function getFullPackageLog(opts) {
+  return loadLog(opts.storageDir, opts.projectRoot);
+}
+
+// src/coordination/package-outdated-watcher.ts
+function parseOutdatedPackages(body) {
+  const results = [];
+  const tableRows = body.matchAll(
+    /^\|\s*([^-][^|]*?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|/gm
+  );
+  for (const rowMatch of tableRows) {
+    const cols = rowMatch[0].split("|").map((c) => c.trim()).filter(Boolean);
+    if (cols.length >= 5 && cols[0] && cols[0] !== "Package") {
+      results.push({
+        name: cols[0] ?? "",
+        currentVersion: cols[1] ?? "",
+        latestVersion: cols[2] ?? "",
+        wantedVersion: cols[3] ?? "",
+        manifestPath: cols[4] ?? "",
+        ecosystem: detectEcosystem2(cols[4] ?? "")
+      });
+    }
+  }
+  if (results.length === 0) {
+    const kvMatches = body.matchAll(
+      /(?:package|name)[\s:=]+([\w@/-]+).*?(?:current|version)[\s:=]+([\d.]+).*?latest[\s:=]+([\d.]+)/gi
+    );
+    for (const m of kvMatches) {
+      results.push({
+        name: m[1] ?? "",
+        currentVersion: m[2] ?? "",
+        latestVersion: m[3] ?? "",
+        wantedVersion: m[2] ?? "",
+        manifestPath: "",
+        ecosystem: "unknown"
+      });
+    }
+  }
+  return results;
+}
+function detectEcosystem2(manifestPath) {
+  const name = manifestPath.split("/").pop()?.split("\\").pop() ?? manifestPath;
+  if (name === "package.json") return "npm";
+  if (name === "go.mod") return "go";
+  if (name === "cargo.toml") return "cargo";
+  if (name === "pyproject.toml" || name === "requirements.txt") return "pip";
+  if (name === "gemfile" || name === "gemfile.lock") return "gem";
+  if (name === "composer.json" || name === "composer.lock") return "composer";
+  if (name.endsWith(".csproj") || name === "packages.config") return "nuget";
+  if (name === "mix.exs" || name === "mix.lock") return "elixir";
+  if (name === "pom.xml" || name.startsWith("build.gradle")) return "maven";
+  if (name === "pubspec.yaml" || name === "pubspec.lock") return "dart";
+  return "unknown";
+}
+function startPackageOutdatedWatcher(opts) {
+  const {
+    mailbox,
+    packageTrackerOpts,
+    pollIntervalMs = 60 * 60 * 1e3,
+    watcherAgentId = "pkg-outdated-watcher",
+    onNotify,
+    onLog,
+    onError
+  } = opts;
+  const log = (msg) => onLog?.(msg);
+  const handleError = (err) => onError?.(err);
+  const state = {
+    running: true,
+    timer: null,
+    processedIds: /* @__PURE__ */ new Set()
+  };
+  async function pollOnce() {
+    if (!state.running) return;
+    try {
+      const messages = await mailbox.query({
+        to: watcherAgentId,
+        type: "result",
+        unreadBy: watcherAgentId,
+        limit: 10
+      });
+      for (const msg of messages) {
+        if (state.processedIds.has(msg.id)) continue;
+        state.processedIds.add(msg.id);
+        await mailbox.ack({
+          messageId: msg.id,
+          readerId: watcherAgentId,
+          read: true
+        });
+        await processResultMessage(msg);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  }
+  async function processResultMessage(msg) {
+    const entries = parseOutdatedPackages(msg.body ?? "");
+    if (entries.length === 0) {
+      log(`[pkg-outdated-watcher] No outdated packages found in message ${msg.id}`);
+      return;
+    }
+    log(`[pkg-outdated-watcher] Processing ${entries.length} outdated package(s) from ${msg.from}`);
+    for (const entry of entries) {
+      try {
+        const author = await getPackageAuthor(
+          packageTrackerOpts,
+          entry.manifestPath,
+          entry.name
+        );
+        const notifyTarget = author?.agentId ?? "*";
+        const notifyBody = buildNotifyBody(entry, author?.agentName);
+        const notifyMsg = {
+          from: watcherAgentId,
+          to: notifyTarget,
+          subject: `Outdated package: ${entry.name}@${entry.currentVersion} \u2192 ${entry.latestVersion}`,
+          body: notifyBody,
+          priority: "high"
+        };
+        await onNotify(notifyMsg);
+        log(
+          `[pkg-outdated-watcher] Notified ${notifyTarget} about outdated ${entry.name} (${entry.currentVersion} \u2192 ${entry.latestVersion}) in ${entry.manifestPath}`
+        );
+      } catch (err) {
+        handleError(err);
+        log(`[pkg-outdated-watcher] Failed to notify for ${entry.name}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  state.timer = setInterval(() => {
+    void pollOnce();
+  }, pollIntervalMs);
+  void pollOnce();
+  return () => {
+    state.running = false;
+    if (state.timer) {
+      clearInterval(state.timer);
+      state.timer = null;
+    }
+  };
+}
+function buildNotifyBody(entry, authorName) {
+  const lines = [
+    `The package **${entry.name}** is outdated.`,
+    "",
+    `| Field | Value |`,
+    `|-------|-------|`,
+    `| Package | ${entry.name} |`,
+    `| Installed | ${entry.currentVersion} |`,
+    `| Latest | ${entry.latestVersion} |`,
+    `| Wanted | ${entry.wantedVersion} |`,
+    `| Manifest | ${entry.manifestPath} |`,
+    `| Ecosystem | ${entry.ecosystem} |`,
+    ""
+  ];
+  if (authorName) {
+    lines.push(
+      `You added this package${authorName !== "unknown" ? ` (as ${authorName})` : ""}. Consider updating it with the install tool.`
+    );
+  } else {
+    lines.push(
+      `This package appears to have been added by an agent no longer on record. Consider reviewing and updating it.`
+    );
+  }
+  lines.push(
+    "",
+    `Update with:`,
+    `\`\`\``,
+    `${getUpdateCommand(entry)}`,
+    `\`\`\``
+  );
+  return lines.join("\n");
+}
+function getUpdateCommand(entry) {
+  switch (entry.ecosystem) {
+    case "npm":
+      return `pnpm add ${entry.name}@latest  # or: pnpm update ${entry.name}`;
+    case "cargo":
+      return `cargo update ${entry.name}`;
+    case "go":
+      return `go get ${entry.name}@latest`;
+    case "pip":
+      return `pip install --upgrade ${entry.name}`;
+    case "gem":
+      return `gem install ${entry.name}`;
+    case "composer":
+      return `composer require ${entry.name}:^${entry.latestVersion} --update-with-dependencies`;
+    case "nuget":
+      return `dotnet add package ${entry.name}`;
+    case "maven":
+      return `# Update the <version> in pom.xml or run:
+mvn versions:use-latest-versions`;
+    case "dart":
+      return `dart pub upgrade ${entry.name}`;
+    default:
+      return `# Update ${entry.name} to ${entry.latestVersion} using your package manager`;
+  }
+}
+
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, CollabSession, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GlobalMailbox, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, LIGHT_BUDGET, LargeAnswerStore, MEDIUM_BUDGET, META_AGENTS, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, VERIFY_AGENTS, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, formatHumanPrompt, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, makeWorkCompleteTool, normalizeRecipient, recordPackageAction, resolveMailboxIdentity, resolveProjectDir, rosterSummaryFromConfigs, scoreAgents, startPackageOutdatedWatcher, updatePackageOutdatedStatus };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map