@wrongstack/core 0.270.0 → 0.272.0

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;
@@ -8987,15 +9057,7 @@ 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 [];
     }
@@ -9120,43 +9182,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_…").
    *  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());
@@ -9175,6 +9296,78 @@ var DefaultSessionStore = class _DefaultSessionStore {
       errorMsg = "summary fallback \u2014 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 +9492,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,6 +9566,25 @@ var DefaultSessionStore = class _DefaultSessionStore {
       };
     }
   }
+  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();
+    }
+  }
   metaFromEvents(id, events) {
     const start = events.find((e) => e.type === "session_start");
     const end = events.findLast((e) => e.type === "session_end");
@@ -10013,6 +10248,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 +10743,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 +10782,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 +10906,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 +10966,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 +11057,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 +11080,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 {
@@ -11330,30 +11684,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 +11766,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 +11777,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 +15222,263 @@ ${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);
+}
 
-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, 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