@wrongstack/core 0.270.0 → 0.272.1

package/dist/coordination/index.js

@@ -5,6 +5,8 @@ import { isAbsolute, resolve } from 'path';
 import * as os from 'os';
 import { hostname } from 'os';
 import { EventEmitter } from 'events';
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
 
 // src/coordination/brain.ts
 var ObservableBrainArbiter = class {
@@ -5877,6 +5879,68 @@ Working rules:
 - When in doubt, flag as medium rather than ignoring potential issues`
   // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
+var SHADOW_AGENT = {
+  id: "shadow-agent",
+  name: "Shadow",
+  role: "shadow-agent",
+  prompt: `You are the Shadow Agent \u2014 a silent background monitor for the WrongStack fleet.
+
+Your job is to observe, detect anomalies, and be ready to intervene \u2014 but only when commanded.
+
+## Core Responsibilities
+
+1. **Fleet Monitoring** (every 30s)
+   - Call \`fleet_status\` + \`fleet_health\` on each heartbeat
+   - Track what each agent is doing (task descriptions)
+   - Detect stuck agents (>5min no events), idle agents, crashed agents
+
+2. **FleetBus Subscription**
+   - Subscribe to \`subagent.*\` events to track lifecycle
+   - Subscribe to \`tool.executed\` to monitor activity
+   - Track agent joins (subagent.started) and leaves (subagent.stopped)
+
+3. **Mailbox Surveillance**
+   - Monitor for \`control\` type messages starting with "hoop"
+   - Detect orphan assigns (assign without result within 5min)
+   - Cross-session awareness via shared project mailbox
+
+4. **Spike Detection**
+   - Track task duration per agent
+   - Flag agents that spawn and die within <5 seconds
+   - Log spike events with reason (completed/error/killed/timeout)
+
+5. **Intervention Commands**
+   Parse these from mailbox control messages:
+   - \`hoop <agentId>\` \u2014 terminate specific agent
+   - \`hoop all\` \u2014 terminate all running agents
+   - \`shadow status\` \u2014 report current fleet snapshot
+   - \`shadow mute\` \u2014 pause heartbeat monitoring
+   - \`shadow resume\` \u2014 resume heartbeat monitoring
+   - \`shadow interval <ms>\` \u2014 change heartbeat interval
+   - \`shadow model <model-id>\` \u2014 change analysis model
+
+## Operating Rules
+
+- **Silent by default**: Use DEBUG level logging unless anomaly detected
+- **Deterministic**: Same state always produces same actions \u2014 no randomness
+- **Report on anomaly**: When anomaly detected, use \`mail_send\` to broadcast warning
+- **Never auto-intervene**: Always report unless explicitly commanded
+- **Minimal footprint**: Small state, efficient snapshots
+
+## Startup Sequence
+
+1. Send broadcast: \`shadow:started { intervalMs, model, startTime }\`
+2. Subscribe to FleetBus for all relevant events
+3. Schedule heartbeat cron job at configured interval
+4. Wait for commands or anomalies
+
+## Shutdown Sequence
+
+1. Cancel all cron jobs (\`cron_cancel\`)
+2. Send broadcast: \`shadow:stopped { reason, finalState }\`
+3. Clean up FleetBus subscriptions`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
+};
 var CRITIC_AGENT = {
   id: "critic",
   name: "Critic",
@@ -5917,6 +5981,7 @@ var FLEET_ROSTER = {
   "refactor-planner": REFACTOR_PLANNER_AGENT,
   "security-scanner": SECURITY_SCANNER_AGENT,
   "critic": CRITIC_AGENT,
+  "shadow-agent": SHADOW_AGENT,
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
   )
@@ -5928,6 +5993,8 @@ var FLEET_ROSTER_BUDGETS = {
   "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
   "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
   "critic": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
+  "shadow-agent": { timeoutMs: 24 * 60 * 60 * 1e3, maxIterations: 1e4, maxToolCalls: 5e3 },
+  // Long-running background monitor
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
   )
@@ -8748,6 +8815,8 @@ function generateSessionId(startedAt, model) {
   const modelPart = model ? `_${sanitizeModel(model)}` : "";
   return `${date}/${time}Z${modelPart}_${suffix}`;
 }
+
+// src/storage/session-store.ts
 var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
@@ -8765,6 +8834,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   _loadCache = /* @__PURE__ */ new Map();
   _indexCache = null;
   static LOAD_CACHE_MAX_ENTRIES = 50;
+  static LIST_SCAN_CONCURRENCY = 32;
   constructor(opts) {
     this.dir = opts.dir;
     this.events = opts.events;
@@ -8781,7 +8851,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this._loadCache.clear();
     }
   }
-  // ── Storage event helpers ───────────────────────────────────────────────────
+  // ── Storage event helpers ───────────────────────────────────────────────────
   emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
     this.events?.emit("storage.read", {
       sessionId,
@@ -8896,7 +8966,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         this.events,
         {
           resumed: true,
-          // Shard directory (sessions/<date>/) — must match create() so the
+          // 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: path5.dirname(file),
@@ -8937,19 +9007,93 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const raw = await fsp6.readFile(file, "utf8");
       const lines = raw.split("\n").filter((l) => l.trim());
       const events = [];
+      let sessionStartEvent;
+      let sessionEndEvent;
+      let sessionModel;
+      let sessionProvider;
+      let sessionPendingToolUses;
+      const messages = [];
+      const openToolUses = /* @__PURE__ */ new Set();
+      let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
       for (const line of lines) {
         try {
           const parsed = JSON.parse(line);
           if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
-            events.push(parsed);
+            const ev = parsed;
+            events.push(ev);
+            if (ev.type === "session_start" && !sessionStartEvent) {
+              sessionStartEvent = ev;
+              sessionModel = ev.model;
+              sessionProvider = ev.provider;
+            }
+            if (ev.type === "session_end") {
+              sessionEndEvent = ev;
+              sessionPendingToolUses = ev.pendingToolUses;
+            }
+            if (ev.type === "user_input") {
+              openToolUses.clear();
+              messages.push({ role: "user", content: ev.content, ts: ev.ts });
+            } else if (ev.type === "llm_response") {
+              messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
+              for (const b of ev.content) {
+                if (b.type === "tool_use") openToolUses.add(b.id);
+              }
+              usage = {
+                input: usage.input + (ev.usage.input ?? 0),
+                output: usage.output + (ev.usage.output ?? 0),
+                cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
+                cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
+              };
+            } else if (ev.type === "tool_result") {
+              if (!openToolUses.has(ev.id)) {
+                this.events?.emit("session.damaged", {
+                  sessionId: id,
+                  detail: `Orphan tool_result "${ev.id}" has no matching tool_use`
+                });
+                continue;
+              }
+              openToolUses.delete(ev.id);
+              const resultBlock = {
+                type: "tool_result",
+                tool_use_id: ev.id,
+                content: typeof ev.content === "string" ? ev.content : JSON.stringify(ev.content),
+                is_error: ev.isError
+              };
+              const last = messages[messages.length - 1];
+              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: [resultBlock], ts: ev.ts });
+              }
+            }
           }
         } catch {
         }
       }
-      const meta = this.metaFromEvents(id, events);
-      const { messages, usage } = this.replay(events, id);
+      if (openToolUses.size > 0) {
+        this.events?.emit("session.damaged", {
+          sessionId: id,
+          detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
+        });
+      }
+      const repaired = repairToolUseAdjacency(messages);
+      if (repaired.report.changed) {
+        this.events?.emit("session.damaged", {
+          sessionId: id,
+          detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
+        });
+      }
+      const meta = {
+        id,
+        startedAt: sessionStartEvent?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        endedAt: sessionEndEvent?.ts,
+        model: sessionModel,
+        provider: sessionProvider,
+        pendingToolUses: sessionPendingToolUses
+      };
       const toolCallEnds = extractToolCallEnds(events);
-      const data = { metadata: meta, events, messages, usage, toolCallEnds };
+      const data = { metadata: meta, events, messages: repaired.messages, usage, toolCallEnds };
       if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
         const oldest = this._loadCache.keys().next().value;
         if (oldest !== void 0) {
@@ -8987,20 +9131,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
         });
         return indexed.slice(0, limit);
       }
-      const ids = await this.collectSessionIds(this.dir);
-      const sessions = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
-      const out = sessions.filter((s) => s !== null);
-      out.sort((a, b) => {
-        if (a.startedAt < b.startedAt) return 1;
-        if (a.startedAt > b.startedAt) return -1;
-        return a.id.localeCompare(b.id);
-      });
-      return out.slice(0, limit);
+      return await this.listFromDirectoryScan(limit);
     } catch {
       return [];
     }
   }
-  // ── Session index (_index.jsonl) ─────────────────────────────────────────
+  // ── Session index (_index.jsonl) ─────────────────────────────────────────
   //
   // One JSON line per closed session, appended atomically on close().
   // When a session is deleted, a tombstone {action:"delete",id:"..."} is
@@ -9120,43 +9256,102 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this._indexCache = null;
     return valid.length;
   }
+  async listFromDirectoryScan(limit) {
+    const refs = await this.collectSessionFiles(this.dir);
+    const candidates = await mapWithConcurrency(
+      refs,
+      _DefaultSessionStore.LIST_SCAN_CONCURRENCY,
+      async (ref) => {
+        const manifest = await this.readSummaryManifest(ref.id);
+        if (manifest) return { summary: manifest, needsBackfill: false };
+        const summary = await this.summaryHeaderFor(ref);
+        return summary ? { summary, needsBackfill: true } : null;
+      }
+    );
+    const out = candidates.filter((s) => s !== null);
+    out.sort((a, b) => compareSessionSummaries(a.summary, b.summary));
+    const selected = out.slice(0, limit);
+    const summaries = await mapWithConcurrency(
+      selected,
+      Math.min(_DefaultSessionStore.LIST_SCAN_CONCURRENCY, Math.max(1, limit)),
+      async (candidate) => {
+        if (!candidate.needsBackfill) return candidate.summary;
+        return await this.summaryFor(candidate.summary.id).catch(() => candidate.summary);
+      }
+    );
+    return summaries.filter((s) => s !== null);
+  }
+  async collectSessionFiles(dir, prefix = "", depth = 0) {
+    let entries;
+    try {
+      entries = await fsp6.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const dirEntries = [];
+    const files = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
+      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+        continue;
+      if (entry.isDirectory()) {
+        dirEntries.push(entry);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        if (entry.name === "_index.jsonl") continue;
+        const base = entry.name.replace(/\.jsonl$/, "");
+        const id = prefix ? `${prefix}/${base}` : base;
+        files.push({ id, filePath: path5.join(dir, entry.name) });
+      }
+    }
+    const childFileArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionFiles(path5.join(dir, entry.name), childPrefix, depth + 1);
+      })
+    );
+    return [...childFileArrays.flat(), ...files];
+  }
   /** Recursively collect session IDs from date-shard subdirectories.
-   *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
+   *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
    *  Skips `.jsonl`/`.summary.json` root files, dot-files, and
    *  sub-directories that belong to fleet/subagent sessions. */
   async collectSessionIds(dir, prefix = "", depth = 0) {
-    const ids = [];
     let entries;
     try {
       entries = await fsp6.readdir(dir, { withFileTypes: true });
     } catch {
-      return ids;
+      return [];
     }
+    const dirEntries = [];
+    const fileIds = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
       if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
         continue;
       if (entry.isDirectory()) {
-        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        ids.push(...await this.collectSessionIds(path5.join(dir, entry.name), childPrefix, depth + 1));
+        dirEntries.push(entry);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
         if (entry.name === "_index.jsonl") continue;
         const base = entry.name.replace(/\.jsonl$/, "");
-        ids.push(prefix ? `${prefix}/${base}` : base);
+        fileIds.push(prefix ? `${prefix}/${base}` : base);
       }
     }
-    return ids;
+    const childIdArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionIds(path5.join(dir, entry.name), childPrefix, depth + 1);
+      })
+    );
+    return [...childIdArrays.flat(), ...fileIds];
   }
   async summaryFor(id) {
     const manifest = this.sessionPath(id, ".summary.json");
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
+    const fromManifest = await this.readSummaryManifest(id, t0);
+    if (fromManifest) return fromManifest;
     try {
-      const raw = await fsp6.readFile(manifest, "utf8");
-      this.emitRead(id, manifest, "summary", "success", Date.now() - t0);
-      return JSON.parse(raw);
-    } catch {
       const full = this.sessionPath(id, ".jsonl");
       const stat7 = await fsp6.stat(full);
       const summary = await this.summarize(id, stat7.mtime.toISOString());
@@ -9172,9 +9367,81 @@ var DefaultSessionStore = class _DefaultSessionStore {
         }));
       });
       outcome = "failure";
-      errorMsg = "summary fallback \u2014 manifest rebuilt";
+      errorMsg = "summary fallback \xE2\u20AC\u201D manifest rebuilt";
       this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
       return summary;
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = toErrorMessage(err);
+      this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
+      return {
+        id,
+        title: "(damaged)",
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
+    }
+  }
+  async readSummaryManifest(id, startTime = Date.now()) {
+    const manifest = this.sessionPath(id, ".summary.json");
+    try {
+      const raw = await fsp6.readFile(manifest, "utf8");
+      this.emitRead(id, manifest, "summary", "success", Date.now() - startTime);
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async summaryHeaderFor(ref) {
+    let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
+    try {
+      const stat7 = await fsp6.stat(ref.filePath);
+      if (!stat7.isFile()) {
+        return {
+          id: ref.id,
+          title: "(damaged)",
+          startedAt: stat7.mtime.toISOString(),
+          model: "unknown",
+          provider: "unknown",
+          tokenTotal: 0
+        };
+      }
+      mtime = stat7.mtime.toISOString();
+    } catch {
+      return null;
+    }
+    try {
+      for await (const event of this.iterSessionEvents(ref.filePath)) {
+        if (event.type === "session_start") {
+          return {
+            id: ref.id,
+            title: "(empty session)",
+            startedAt: event.ts,
+            model: event.model ?? "unknown",
+            provider: event.provider ?? "unknown",
+            tokenTotal: 0
+          };
+        }
+      }
+      return {
+        id: ref.id,
+        title: "(empty session)",
+        startedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
+    } catch {
+      return {
+        id: ref.id,
+        title: "(damaged)",
+        startedAt: mtime,
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
     }
   }
   /**
@@ -9299,39 +9566,62 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   async summarize(id, mtime) {
     try {
-      const data = await this.load(id);
-      const firstUser = data.events.find((e) => e.type === "user_input");
-      const title = firstUser && firstUser.type === "user_input" ? userInputTitle(firstUser.content) : "(empty session)";
+      const file = this.sessionPath(id, ".jsonl");
+      let title = "(empty session)";
+      let startedAt = (/* @__PURE__ */ new Date(0)).toISOString();
+      let endedAt;
+      let model = "unknown";
+      let provider = "unknown";
+      let tokenIn = 0;
+      let tokenOut = 0;
       let iterationCount = 0;
       let toolCallCount = 0;
       let toolErrorCount = 0;
       let fileChangeCount = 0;
       const toolBreakdown = {};
       let outcome;
-      const lastEvent = data.events[data.events.length - 1];
-      for (const e of data.events) {
-        if (e.type === "in_flight_start") iterationCount++;
+      let lastEventType;
+      let hasError = false;
+      let sawStart = false;
+      for await (const e of this.iterSessionEvents(file)) {
+        lastEventType = e.type;
+        if (e.type === "session_start") {
+          if (!sawStart) {
+            sawStart = true;
+            startedAt = e.ts;
+            model = e.model ?? "unknown";
+            provider = e.provider ?? "unknown";
+          }
+        } else if (e.type === "session_end") {
+          endedAt = e.ts;
+        } else if (e.type === "user_input") {
+          if (title === "(empty session)") title = userInputTitle(e.content);
+        } else if (e.type === "llm_response") {
+          tokenIn += e.usage.input ?? 0;
+          tokenOut += e.usage.output ?? 0;
+        } else if (e.type === "in_flight_start") iterationCount++;
         else if (e.type === "tool_call_start") {
           toolCallCount++;
           toolBreakdown[e.name] = (toolBreakdown[e.name] ?? 0) + 1;
         } else if (e.type === "tool_result" && e.isError) toolErrorCount++;
         else if (e.type === "file_snapshot") fileChangeCount += e.files.length;
+        else if (e.type === "error" || e.type === "provider_error") hasError = true;
       }
-      if (lastEvent?.type === "session_end") {
+      if (lastEventType === "session_end") {
         outcome = "completed";
-      } else if (lastEvent?.type === "in_flight_start") {
+      } else if (lastEventType === "in_flight_start") {
         outcome = "aborted";
-      } else if (data.events.some((e) => e.type === "error")) {
+      } else if (hasError) {
         outcome = "error";
       }
       return {
         id,
         title,
-        startedAt: data.metadata.startedAt,
-        endedAt: data.metadata.endedAt,
-        model: data.metadata.model ?? "unknown",
-        provider: data.metadata.provider ?? "unknown",
-        tokenTotal: data.usage.input + data.usage.output,
+        startedAt,
+        endedAt,
+        model,
+        provider,
+        tokenTotal: tokenIn + tokenOut,
         iterationCount: iterationCount > 0 ? iterationCount : void 0,
         toolCallCount: toolCallCount > 0 ? toolCallCount : void 0,
         toolErrorCount: toolErrorCount > 0 ? toolErrorCount : void 0,
@@ -9350,75 +9640,24 @@ var DefaultSessionStore = class _DefaultSessionStore {
       };
     }
   }
-  metaFromEvents(id, events) {
-    const start = events.find((e) => e.type === "session_start");
-    const end = events.findLast((e) => e.type === "session_end");
-    return {
-      id,
-      startedAt: start?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-      endedAt: end?.ts,
-      model: start?.model,
-      provider: start?.provider,
-      pendingToolUses: end?.pendingToolUses
-    };
-  }
-  replay(events, sessionId = "unknown") {
-    const messages = [];
-    let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-    const openToolUses = /* @__PURE__ */ new Set();
-    for (const e of events) {
-      if (e.type === "user_input") {
-        openToolUses.clear();
-        messages.push({ role: "user", content: e.content, ts: e.ts });
-      } else if (e.type === "llm_response") {
-        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);
-        }
-        usage = {
-          input: usage.input + (e.usage.input ?? 0),
-          output: usage.output + (e.usage.output ?? 0),
-          cacheRead: (usage.cacheRead ?? 0) + (e.usage.cacheRead ?? 0),
-          cacheWrite: (usage.cacheWrite ?? 0) + (e.usage.cacheWrite ?? 0)
-        };
-      } else if (e.type === "tool_result") {
-        if (!openToolUses.has(e.id)) {
-          this.events?.emit("session.damaged", {
-            sessionId,
-            detail: `Orphan tool_result "${e.id}" has no matching tool_use`
-          });
-          continue;
-        }
-        openToolUses.delete(e.id);
-        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];
-        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: [resultBlock], ts: e.ts });
+  async *iterSessionEvents(file) {
+    const stream = createReadStream(file, { encoding: "utf8" });
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+      for await (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
+            yield parsed;
+          }
+        } catch {
         }
       }
+    } finally {
+      lines.close();
+      stream.destroy();
     }
-    if (openToolUses.size > 0) {
-      this.events?.emit("session.damaged", {
-        sessionId,
-        detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
-      });
-    }
-    const repaired = repairToolUseAdjacency(messages);
-    if (repaired.report.changed) {
-      this.events?.emit("session.damaged", {
-        sessionId,
-        detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
-      });
-    }
-    return { messages: repaired.messages, usage };
   }
 };
 function extractToolCallEnds(events) {
@@ -9478,7 +9717,7 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * 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 —
+   * 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;
@@ -9491,24 +9730,24 @@ var FileSessionWriter = class _FileSessionWriter {
   lastAppendWarnAt = 0;
   secretScrubber;
   onCloseCb;
-  /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
+  /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
   traceId;
-  // ── Write buffer — batches events to reduce per-event disk I/O ─────────
+  // ── 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.
+  // format — the JSONL is still one JSON object per line.
   writeBuffer = [];
   flushTimer = null;
   static FLUSH_INTERVAL_MS = 500;
   static FLUSH_SIZE = 50;
-  // ── Write serialization ─────────────────────────────────────────────────
+  // ── 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
+  // 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.
@@ -9522,7 +9761,7 @@ var FileSessionWriter = class _FileSessionWriter {
     );
     return write;
   }
-  // ── Enriched summary tracking ──────────────────────────────────────────
+  // ── Enriched summary tracking ──────────────────────────────────────────
   iterationCount = 0;
   toolCallCount = 0;
   toolErrorCount = 0;
@@ -9614,7 +9853,7 @@ var FileSessionWriter = class _FileSessionWriter {
    * (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
+   * Idempotent — cancels any pending timer and writes whatever has
    * accumulated in the buffer. Safe to call even when the buffer
    * is empty (no-op).
    */
@@ -9637,7 +9876,7 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * 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.
+   * 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).
    */
@@ -9820,7 +10059,7 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Truncate the session file to the checkpoint with the given promptIndex,
    * removing all events that follow it. Uses a single-pass byte-offset scan
-   * so post-checkpoint content is never read or parsed — O(1) memory instead
+   * so post-checkpoint content is never read or parsed — O(1) memory instead
    * of O(N) JSON.parse calls over the full file.
    */
   async truncateToCheckpoint(targetPromptIndex) {
@@ -9977,7 +10216,7 @@ var FileSessionWriter = class _FileSessionWriter {
     await fsp6.writeFile(this.filePath, record, "utf8");
   }
   /**
-   * Idea #1 — write an in-flight marker. The agent loop should call
+   * Idea #1 — write an in-flight marker. The agent loop should call
    * this at the start of each long-running operation; a matching
    * `clearInFlightMarker` follows on clean exit. A stale marker
    * (no end) is what `SessionRecovery.detectStale` looks for.
@@ -9994,9 +10233,9 @@ var FileSessionWriter = class _FileSessionWriter {
     this.events?.emit("in_flight.started", { context, ts: (/* @__PURE__ */ new Date()).toISOString() });
   }
   /**
-   * Idea #1 — close the in-flight marker. Idempotent in spirit
+   * Idea #1 — close the in-flight marker. Idempotent in spirit
    * (you can call it after a successful iteration even if you
-   * didn't open one this round) — but the session log records
+   * didn't open one this round) — but the session log records
    * every call so postmortem tooling can see "the agent finished
    * cleanly X times, then died without finishing Y".
    */
@@ -10013,6 +10252,27 @@ function userInputTitle(content) {
   const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
   return (text || "(non-text input)").slice(0, 60);
 }
+function compareSessionSummaries(a, b) {
+  if (a.startedAt < b.startedAt) return 1;
+  if (a.startedAt > b.startedAt) return -1;
+  return a.id.localeCompare(b.id);
+}
+async function mapWithConcurrency(items, concurrency, fn) {
+  if (items.length === 0) return [];
+  const out = new Array(items.length);
+  let next = 0;
+  const workerCount = Math.min(Math.max(1, concurrency), items.length);
+  const workers = Array.from({ length: workerCount }, async () => {
+    for (; ; ) {
+      const idx = next++;
+      if (idx >= items.length) return;
+      const item = items[idx];
+      if (item !== void 0) out[idx] = await fn(item);
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
 
 // src/coordination/director-session.ts
 function makeDirectorSessionFactory(opts) {
@@ -10487,6 +10747,10 @@ var DefaultMailbox = class {
   _messageCache = null;
   _messageCacheMtime = -1;
   _messageCacheSize = -1;
+  /** Primary index: recipient → Set of messages (points into _messageCache). */
+  _byTo = /* @__PURE__ */ new Map();
+  /** Secondary index: sender → Set of messages (points into _messageCache). */
+  _byFrom = /* @__PURE__ */ new Map();
   constructor(sessionDir) {
     this.filePath = path5.join(sessionDir, MAILBOX_FILE);
   }
@@ -10522,12 +10786,30 @@ var DefaultMailbox = class {
   }
   // ── Query ─────────────────────────────────────────────────────────────
   async query(q) {
-    const all = await this._readAllCached();
+    const needFullScan = q.unreadBy !== void 0 || q.since !== void 0;
+    let candidates;
+    if (needFullScan) {
+      candidates = await this._readAllCached();
+    } else {
+      await this._readAllCached();
+      if (q.to !== void 0) {
+        const direct = this._byTo.get(q.to);
+        const broadcast = this._byTo.get("*");
+        const combined = /* @__PURE__ */ new Map();
+        if (direct) for (const m of direct) combined.set(m.id, m);
+        if (broadcast) for (const m of broadcast) combined.set(m.id, m);
+        candidates = Array.from(combined.values());
+      } else if (q.from !== void 0) {
+        candidates = Array.from(this._byFrom.get(q.from) ?? []);
+      } else {
+        candidates = await this._readAllCached();
+      }
+    }
     const limit = q.limit ?? 50;
     const order = q.minPriority !== void 0 ? { low: 0, normal: 1, high: 2 } : null;
     const minPriorityRank = order && q.minPriority !== void 0 ? order[q.minPriority] : 0;
     const filtered = [];
-    for (const msg of all) {
+    for (const msg of candidates) {
       if (q.to !== void 0 && msg.to !== q.to && msg.to !== "*") continue;
       if (q.from !== void 0 && msg.from !== q.from) continue;
       if (q.unreadBy !== void 0 && q.unreadBy in msg.readBy) continue;
@@ -10628,6 +10910,8 @@ var DefaultMailbox = class {
     this._messageCache = null;
     this._messageCacheMtime = -1;
     this._messageCacheSize = -1;
+    this._byTo.clear();
+    this._byFrom.clear();
   }
   async clearAll() {
     await withFileLock(this.filePath, async () => {
@@ -10686,36 +10970,81 @@ var DefaultMailbox = class {
   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;
+      return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
   }
+  /**
+   * Read only newly-appended bytes from the file and append them to the
+   * in-memory cache, avoiding a full re-read when the file only grew.
+   */
+  async _readNewMessagesOnly(fd, oldSize, newSize) {
+    const tailLen = newSize - oldSize;
+    const buf = Buffer.alloc(tailLen);
+    await fd.read(buf, 0, tailLen, oldSize);
+    const tail = buf.toString("utf8");
+    for (const line of tail.split(LINE_SEPARATOR)) {
+      if (!line.trim()) continue;
+      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"];
+        }
+        const msg = parsed;
+        this._messageCache.push(msg);
+        this._indexMsg(msg);
+      } catch {
+      }
+    }
+    return this._messageCache;
+  }
+  /** Parse a JSONL string into MailboxMessage[], including migration. */
+  _parseLines(raw) {
+    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;
+  }
   async _readAllCached() {
     try {
       const st = await fsp6.stat(this.filePath);
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
         return this._messageCache;
       }
+      if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
+        const fd = await fsp6.open(this.filePath, "r");
+        try {
+          const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
+          this._messageCacheMtime = st.mtimeMs;
+          this._messageCacheSize = st.size;
+          return updated;
+        } finally {
+          await fd.close();
+        }
+      }
       const all = await this._readAll();
       this._setMessageCache(all, st.mtimeMs, st.size);
       return all;
@@ -10732,9 +11061,12 @@ var DefaultMailbox = class {
       this._messageCache = null;
       this._messageCacheMtime = -1;
       this._messageCacheSize = -1;
+      this._byTo.clear();
+      this._byFrom.clear();
       return;
     }
     this._messageCache = messages;
+    this._buildIndexes(messages);
     if (mtime !== void 0 && size !== void 0) {
       this._messageCacheMtime = mtime;
       this._messageCacheSize = size;
@@ -10752,9 +11084,35 @@ var DefaultMailbox = class {
       this._messageCache = null;
       this._messageCacheMtime = -1;
       this._messageCacheSize = -1;
+      this._byTo.clear();
+      this._byFrom.clear();
       return;
     }
     this._messageCache.push(msg);
+    this._indexMsg(msg);
+  }
+  /** Rebuild both indexes from a full message list. */
+  _buildIndexes(messages) {
+    this._byTo.clear();
+    this._byFrom.clear();
+    for (const msg of messages) {
+      this._indexMsg(msg);
+    }
+  }
+  /** Add a single message to both indexes. */
+  _indexMsg(msg) {
+    const toSet = this._byTo.get(msg.to);
+    if (toSet) {
+      toSet.add(msg);
+    } else {
+      this._byTo.set(msg.to, /* @__PURE__ */ new Set([msg]));
+    }
+    const fromSet = this._byFrom.get(msg.from);
+    if (fromSet) {
+      fromSet.add(msg);
+    } else {
+      this._byFrom.set(msg.from, /* @__PURE__ */ new Set([msg]));
+    }
   }
 };
 var BrainMonitor = class {
@@ -10948,7 +11306,7 @@ var GlobalMailbox = class {
   /**
    * @param projectDir — `~/.wrongstack/projects/<slug>/`
    * @param events — optional EventBus for real-time TUI/WebUI notifications
-   * @param hqPublisher — optional HQ publisher for cross-project telemetry
+   * @param hqPublisher — optional HQ publisher, or getter, for cross-project telemetry
    */
   constructor(projectDir, events, hqPublisher) {
     this.messagePath = path5.join(projectDir, MAILBOX_FILE2);
@@ -10960,15 +11318,19 @@ var GlobalMailbox = class {
   get hqMailboxId() {
     return `${path5.basename(path5.dirname(this.messagePath))}:mailbox`;
   }
+  get hqPublisher() {
+    return typeof this._hqPublisher === "function" ? this._hqPublisher() : this._hqPublisher;
+  }
   publishHqMailboxEvent(input) {
     try {
-      this._hqPublisher?.publishMailboxEvent(input);
+      this.hqPublisher?.publishMailboxEvent(input);
     } catch {
     }
   }
   publishHqMailboxSnapshot() {
-    if (this._hqPublisher === void 0) return;
-    void this._hqPublisher.publishMailboxSnapshot(this, { mailboxId: this.hqMailboxId }).catch(() => {
+    const publisher = this.hqPublisher;
+    if (publisher === void 0) return;
+    void publisher.publishMailboxSnapshot(this, { mailboxId: this.hqMailboxId }).catch(() => {
     });
   }
   // ── Messages ────────────────────────────────────────────────────────────
@@ -11330,30 +11692,69 @@ var GlobalMailbox = class {
   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;
+      return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
   }
+  /**
+   * Read only newly-appended bytes from the file and append them to the
+   * in-memory cache. This avoids re-reading and re-parsing the entire file
+   * when another process appended messages since our last read.
+   *
+   * Only safe when the file grew in size (messages are append-only). When
+   * the file was rewritten (ack/purge changed existing content), callers
+   * must fall back to {@link _readMessages}.
+   *
+   * @returns The (now up-to-date) message cache.
+   */
+  async _readNewMessagesOnly(fd, oldSize, newSize) {
+    const tailLen = newSize - oldSize;
+    const buf = Buffer.alloc(tailLen);
+    await fd.read(buf, 0, tailLen, oldSize);
+    const tail = buf.toString("utf8");
+    for (const line of tail.split(LINE_SEPARATOR2)) {
+      if (!line.trim()) continue;
+      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"];
+        }
+        this._messageCache.push(parsed);
+      } catch {
+      }
+    }
+    return this._messageCache;
+  }
+  /** Parse a JSONL string into MailboxMessage[], including migration. */
+  _parseLines(raw) {
+    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;
+  }
   /**
    * Read messages, then adopt the result as the in-memory cache. Use this
    * from writers that just took the file lock — the read reflects the
@@ -11373,6 +11774,10 @@ var GlobalMailbox = class {
    * stat matches the cached mtime+size we return the cached array — no
    * file read and no JSON.parse — collapsing the per-iteration query
    * cost on the mailbox-loop hot path.
+   *
+   * When the file only grew (new messages appended by another process),
+   * we read and parse just the tail bytes instead of the entire file.
+   * This avoids re-parsing the full 10K-message history on every check.
    */
   async _readMessagesCached() {
     try {
@@ -11380,6 +11785,17 @@ var GlobalMailbox = class {
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
         return this._messageCache;
       }
+      if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
+        const fd = await fsp6.open(this.messagePath, "r");
+        try {
+          const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
+          this._messageCacheMtime = st.mtimeMs;
+          this._messageCacheSize = st.size;
+          return updated;
+        } finally {
+          await fd.close();
+        }
+      }
       const all = await this._readMessages();
       this._setMessageCache(all, st.mtimeMs, st.size);
       return all;
@@ -14814,7 +15230,443 @@ ${input.detail}`
     this.onCoordinatorEvent?.(event);
   }
 };
+var AgentMonitorService = class {
+  _fleetBus;
+  _events;
+  _transcriptsDir;
+  _maxEntries;
+  _streamEnabled;
+  _onEntry;
+  /** Per-subagent virtual sessions. */
+  _sessions = /* @__PURE__ */ new Map();
+  /** Disposers for FleetBus subscriptions, keyed by subagentId. */
+  _subscriptions = /* @__PURE__ */ new Map();
+  /** Generic fleet-wide subscription disposer. */
+  _fleetDisposer;
+  /** Track whether service is running. */
+  _started = false;
+  constructor(opts) {
+    this._fleetBus = opts.fleetBus;
+    this._events = opts.events;
+    this._transcriptsDir = opts.transcriptsDir;
+    this._maxEntries = opts.maxEntriesPerAgent ?? 500;
+    this._streamEnabled = opts.streamEnabled ?? false;
+    this._onEntry = opts.onEntry;
+  }
+  // ── Public API ────────────────────────────────────────────────────
+  /** Set the FleetBus to listen on. Must be called before `start()`. */
+  setFleetBus(bus) {
+    this._fleetBus = bus;
+  }
+  get streamEnabled() {
+    return this._streamEnabled;
+  }
+  /** Enable/disable streaming agent conversations to the main chat timeline. */
+  setStreamEnabled(enabled) {
+    this._streamEnabled = enabled;
+  }
+  /** Get a snapshot of all known agent sessions. */
+  getAllSessions() {
+    return Array.from(this._sessions.values());
+  }
+  /** Get a specific agent's virtual session, or undefined. */
+  getSession(subagentId) {
+    return this._sessions.get(subagentId);
+  }
+  /** Get transcript entries for a specific agent, newest first. */
+  getTranscript(subagentId, limit = 50) {
+    const session = this._sessions.get(subagentId);
+    if (!session) return [];
+    return session.transcript.slice(-limit).reverse();
+  }
+  /** Set a callback for each new timeline entry (HQ bridge). */
+  setOnEntry(handler) {
+    this._onEntry = handler;
+  }
+  // ── Lifecycle ──────────────────────────────────────────────────────
+  /** Start listening to FleetBus events. */
+  start() {
+    if (this._started) return;
+    if (!this._fleetBus) {
+      this._started = true;
+      return;
+    }
+    this._started = true;
+    this._fleetDisposer = this._fleetBus.onAny((event) => {
+      this._routeEvent(event.subagentId, event.type, event.payload);
+    });
+  }
+  /** Stop listening and clean up all subscriptions. */
+  stop() {
+    if (!this._started) return;
+    this._started = false;
+    if (this._fleetDisposer) {
+      this._fleetDisposer();
+      this._fleetDisposer = void 0;
+    }
+    for (const disposer of this._subscriptions.values()) {
+      disposer();
+    }
+    this._subscriptions.clear();
+  }
+  /** Ensure a subagent is being tracked. Called when a subagent spawns. */
+  trackSubagent(subagentId, agentName, task) {
+    if (this._sessions.has(subagentId)) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const session = {
+      subagentId,
+      agentName,
+      createdAt: now,
+      status: "spawned",
+      task,
+      transcript: []
+    };
+    this._sessions.set(subagentId, session);
+    this._addEntry(subagentId, {
+      id: this._uid(),
+      subagentId,
+      agentName,
+      ts: now,
+      kind: "system",
+      content: task ? `\u{1F3AF} Spawned: ${task}` : "\u{1F916} Agent spawned",
+      iteration: 0
+    });
+    this._events.emit("agent.status_changed", {
+      subagentId,
+      agentName,
+      status: "spawned",
+      ts: now,
+      summary: task,
+      task
+    });
+  }
+  /** Mark a subagent as completed/failed/etc. Called on subagent finish. */
+  completeSubagent(subagentId, status, summary) {
+    const session = this._sessions.get(subagentId);
+    if (!session) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    session.status = status;
+    this._addEntry(subagentId, {
+      id: this._uid(),
+      subagentId,
+      agentName: session.agentName,
+      ts: now,
+      kind: "status",
+      content: summary ?? `Agent ${status}`,
+      iteration: 999
+    });
+    this._events.emit("agent.status_changed", {
+      subagentId,
+      agentName: session.agentName,
+      status,
+      ts: now,
+      summary,
+      task: session.task
+    });
+  }
+  // ── Internal ───────────────────────────────────────────────────────
+  _routeEvent(subagentId, type, payload) {
+    const session = this._sessions.get(subagentId);
+    if (!session) return;
+    switch (type) {
+      case "provider.text_delta": {
+        const text = payload.text;
+        if (!text || text.length === 0) return;
+        const iteration = payload.iteration ?? 0;
+        this._addEntry(subagentId, {
+          id: this._uid(),
+          subagentId,
+          agentName: session.agentName,
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          kind: "text",
+          content: text,
+          iteration
+        });
+        break;
+      }
+      case "provider.thinking_delta": {
+        const text = payload.text;
+        if (!text || text.length === 0) return;
+        const iteration = payload.iteration ?? 0;
+        this._addEntry(subagentId, {
+          id: this._uid(),
+          subagentId,
+          agentName: session.agentName,
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          kind: "text",
+          content: `\u{1F9E0} ${text}`,
+          iteration
+        });
+        break;
+      }
+      case "tool.started": {
+        const name = payload.name;
+        if (!name) return;
+        this._addEntry(subagentId, {
+          id: this._uid(),
+          subagentId,
+          agentName: session.agentName,
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          kind: "tool_use",
+          content: `\u{1F527} ${name}()`,
+          iteration: payload.iteration ?? 0,
+          toolName: name
+        });
+        break;
+      }
+      case "tool.executed": {
+        const name = payload.name;
+        const ok = payload.ok;
+        const durationMs = payload.durationMs;
+        if (!name) return;
+        const statusIcon = ok ? "\u2705" : "\u274C";
+        const duration = durationMs !== void 0 ? ` (${durationMs}ms)` : "";
+        this._addEntry(subagentId, {
+          id: this._uid(),
+          subagentId,
+          agentName: session.agentName,
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          kind: "tool_result",
+          content: `${statusIcon} ${name}${duration}`,
+          iteration: payload.iteration ?? 0,
+          toolName: name,
+          toolOk: ok
+        });
+        break;
+      }
+      case "iteration.completed": {
+        const index = payload.index ?? 0;
+        if (index > 0 && index % 5 === 0) {
+          this._addEntry(subagentId, {
+            id: this._uid(),
+            subagentId,
+            agentName: session.agentName,
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            kind: "status",
+            content: `\u{1F504} Iteration ${index}`,
+            iteration: index
+          });
+        }
+        break;
+      }
+    }
+  }
+  _addEntry(subagentId, entry) {
+    const session = this._sessions.get(subagentId);
+    if (!session) return;
+    session.transcript.push(entry);
+    if (session.transcript.length > this._maxEntries) {
+      session.transcript.splice(0, session.transcript.length - this._maxEntries);
+    }
+    this._appendToFile(subagentId, entry).catch(() => {
+    });
+    this._events.emit("agent.timeline.message", {
+      subagentId: entry.subagentId,
+      agentName: entry.agentName,
+      content: entry.content,
+      kind: entry.kind === "tool_result" ? "tool_use" : entry.kind === "system" ? "status" : entry.kind,
+      iteration: entry.iteration,
+      ts: entry.ts,
+      toolName: entry.toolName,
+      costUsd: entry.costUsd
+    });
+    this._onEntry?.(entry);
+  }
+  async _appendToFile(subagentId, entry) {
+    const dir = path5.join(this._transcriptsDir, subagentId);
+    await fsp6.mkdir(dir, { recursive: true });
+    const filePath = path5.join(dir, "transcript.jsonl");
+    const line = JSON.stringify(entry) + "\n";
+    await fsp6.appendFile(filePath, line, { encoding: "utf8" });
+  }
+  _uid() {
+    return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+  }
+};
+function createAgentMonitorService(opts) {
+  return new AgentMonitorService(opts);
+}
+
+// src/coordination/adaptive-concurrency.ts
+var DEFAULT_CONFIG = Object.freeze({
+  enabled: false,
+  minConcurrent: 1,
+  maxConcurrent: 16,
+  decreaseFactor: 0.5,
+  successThreshold: 10,
+  recoveryIntervalMs: 3e4
+});
+var AdaptiveConcurrencyController = class {
+  config;
+  state;
+  disposers = [];
+  stateChangeHandlers = [];
+  constructor(fleetBus, setMaxConcurrent, config = {}, onStateChange) {
+    this.config = {
+      enabled: config.enabled ?? DEFAULT_CONFIG.enabled,
+      minConcurrent: config.minConcurrent ?? DEFAULT_CONFIG.minConcurrent,
+      maxConcurrent: config.maxConcurrent ?? DEFAULT_CONFIG.maxConcurrent,
+      decreaseFactor: config.decreaseFactor ?? DEFAULT_CONFIG.decreaseFactor,
+      successThreshold: config.successThreshold ?? DEFAULT_CONFIG.successThreshold,
+      recoveryIntervalMs: config.recoveryIntervalMs ?? DEFAULT_CONFIG.recoveryIntervalMs
+    };
+    this.state = {
+      current: this.config.maxConcurrent,
+      min: this.config.minConcurrent,
+      max: this.config.maxConcurrent,
+      consecutiveSuccesses: 0,
+      consecutiveFailures: 0,
+      totalDecreases: 0,
+      totalIncreases: 0,
+      enabled: this.config.enabled
+    };
+    if (onStateChange) {
+      this.stateChangeHandlers.push(onStateChange);
+    }
+    if (this.config.enabled) {
+      setMaxConcurrent(this.state.current);
+    }
+    this.setupEventHandlers(fleetBus, setMaxConcurrent);
+  }
+  setupEventHandlers(fleetBus, setMaxConcurrent) {
+    if (!this.config.enabled) return;
+    const off = fleetBus.onAny((event) => {
+      if (!this.config.enabled) return;
+      if (event.type === "error" || event.type === "provider_error") {
+        const payload = event.payload;
+        if (payload?.status === 429 || payload?.code === "rate_limit_error" || payload?.kind === "rate_limit") {
+          this.handleRateLimit(setMaxConcurrent);
+        }
+      }
+    });
+    this.disposers.push(off);
+  }
+  /**
+   * Handle a rate limit (429) error - decrease concurrency
+   */
+  handleRateLimit(setMaxConcurrent) {
+    if (this.state.current <= this.config.minConcurrent) {
+      this.state.consecutiveFailures++;
+      this.state.consecutiveSuccesses = 0;
+      this.notifyStateChange();
+      return;
+    }
+    const newConcurrent = Math.max(
+      this.config.minConcurrent,
+      Math.floor(this.state.current * this.config.decreaseFactor)
+    );
+    if (newConcurrent < this.state.current) {
+      const previousConcurrent = this.state.current;
+      this.state.current = newConcurrent;
+      this.state.consecutiveFailures++;
+      this.state.consecutiveSuccesses = 0;
+      this.state.totalDecreases++;
+      setMaxConcurrent(this.state.current);
+      this.notifyStateChange();
+      console.log(
+        JSON.stringify({
+          level: "warn",
+          event: "adaptive_concurrency.decreased",
+          reason: "rate_limit",
+          previousConcurrent,
+          newConcurrent: this.state.current,
+          decreaseFactor: this.config.decreaseFactor,
+          totalDecreases: this.state.totalDecreases
+        })
+      );
+    }
+  }
+  /**
+   * Force a decrease (e.g., manual trigger or other error types)
+   */
+  decrease(target) {
+    if (!this.config.enabled) return;
+    const newConcurrent = target ?? Math.max(
+      this.config.minConcurrent,
+      Math.floor(this.state.current * this.config.decreaseFactor)
+    );
+    if (newConcurrent < this.state.current) {
+      const previousConcurrent = this.state.current;
+      this.state.current = newConcurrent;
+      this.state.consecutiveSuccesses = 0;
+      this.state.totalDecreases++;
+      this.notifyStateChange();
+      console.log(
+        JSON.stringify({
+          level: "warn",
+          event: "adaptive_concurrency.decreased",
+          reason: "manual",
+          previousConcurrent,
+          newConcurrent: this.state.current,
+          totalDecreases: this.state.totalDecreases
+        })
+      );
+    }
+  }
+  /**
+   * Get the current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Update configuration at runtime
+   */
+  updateConfig(config) {
+    if (config.enabled !== void 0) {
+      this.config.enabled = config.enabled;
+    }
+    if (config.minConcurrent !== void 0) {
+      this.config.minConcurrent = config.minConcurrent;
+    }
+    if (config.maxConcurrent !== void 0) {
+      this.config.maxConcurrent = config.maxConcurrent;
+    }
+    if (config.decreaseFactor !== void 0) {
+      this.config.decreaseFactor = config.decreaseFactor;
+    }
+    if (config.successThreshold !== void 0) {
+      this.config.successThreshold = config.successThreshold;
+    }
+    if (config.recoveryIntervalMs !== void 0) {
+      this.config.recoveryIntervalMs = config.recoveryIntervalMs;
+    }
+    this.state.current = Math.max(this.config.minConcurrent, Math.min(this.state.current, this.config.maxConcurrent));
+    this.state.enabled = this.config.enabled;
+    this.state.min = this.config.minConcurrent;
+    this.state.max = this.config.maxConcurrent;
+    this.notifyStateChange();
+  }
+  /**
+   * Dispose of the controller and clean up event listeners
+   */
+  dispose() {
+    for (const dispose of this.disposers) {
+      dispose();
+    }
+    this.disposers.length = 0;
+    this.stateChangeHandlers = [];
+  }
+  notifyStateChange() {
+    const state = this.getState();
+    for (const handler of this.stateChangeHandlers) {
+      handler(state);
+    }
+  }
+  /**
+   * Register a state change handler
+   */
+  onStateChange(handler) {
+    this.stateChangeHandlers.push(handler);
+    return () => {
+      const index = this.stateChangeHandlers.indexOf(handler);
+      if (index !== -1) {
+        this.stateChangeHandlers.splice(index, 1);
+      }
+    };
+  }
+};
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_QUALITY_CHECKS, 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, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MEDIUM_BUDGET, META_AGENTS, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, 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, withDisabledToolFiltering };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, AgentMonitorService, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_QUALITY_CHECKS, 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, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MEDIUM_BUDGET, META_AGENTS, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, composeDirectorPrompt, composeSubagentPrompt, createAgentMonitorService, 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, withDisabledToolFiltering };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map