@wrongstack/core 0.285.0 → 0.287.0

package/dist/coordination/index.js

@@ -4,6 +4,7 @@ import { randomUUID } from "node:crypto";
 // src/utils/atomic-write.ts
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs/promises";
+import { watch as watchDir } from "node:fs";
 import * as path from "node:path";
 async function atomicWrite(targetPath, content, opts = {}) {
   const dir = path.dirname(targetPath);
@@ -71,7 +72,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
         await fs.mkdir(dir, { recursive: true });
         continue;
       }
-      if (code !== "EEXIST") throw err;
+      if (code !== "EEXIST" && code !== "EPERM") throw err;
       try {
         const stat9 = await fs.stat(lockPath);
         if (Date.now() - stat9.mtimeMs > staleMs) {
@@ -81,7 +82,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       } catch {
         continue;
       }
-      if (Date.now() - started >= timeoutMs) {
+      const elapsed = Date.now() - started;
+      if (elapsed >= timeoutMs) {
         throw new FsError({
           message: `Timed out waiting for file lock: ${targetPath}`,
           code: "FS_ATOMIC_WRITE_FAILED",
@@ -89,7 +91,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
           context: { timeoutMs }
         });
       }
-      await new Promise((resolve9) => setTimeout(resolve9, 25));
+      await waitForLockRelease(lockPath, timeoutMs - elapsed);
     }
   }
   try {
@@ -105,6 +107,50 @@ async function withFileLock(targetPath, fn, opts = {}) {
     }
   }
 }
+async function waitForLockRelease(lockPath, remainingMs) {
+  const parentDir = path.dirname(lockPath);
+  const lockName = path.basename(lockPath);
+  const intervalMs = Math.min(remainingMs, 100);
+  return new Promise((resolve9) => {
+    let settled = false;
+    let watcher = null;
+    const timer = setTimeout(() => {
+      settled = true;
+      watcher?.close();
+      resolve9();
+    }, intervalMs);
+    try {
+      watcher = watchDir(parentDir, (eventType, filename) => {
+        if (settled) return;
+        if (filename === lockName && (eventType === "rename" || eventType === "change")) {
+          settled = true;
+          clearTimeout(timer);
+          watcher?.close();
+          resolve9();
+        }
+      });
+    } catch {
+      clearTimeout(timer);
+      if (!settled) {
+        settled = true;
+        setTimeout(resolve9, Math.min(remainingMs, 25));
+      }
+      return;
+    }
+    fs.access(lockPath).then(
+      () => {
+      },
+      () => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          watcher?.close();
+          resolve9();
+        }
+      }
+    );
+  });
+}
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
@@ -329,9 +375,17 @@ function globToRegex(pat) {
   return new RegExp(re + "$");
 }
 function baseDir(pat) {
-  let i = pat.length - 1;
-  while (i >= 0 && !GLOB_CHARS.has(expectDefined(pat[i])) && pat[i] !== SEP && pat[i] !== "/") i--;
-  const cut = i >= 0 ? pat.lastIndexOf(SEP, i) : pat.lastIndexOf("/", i);
+  let firstGlob = pat.length;
+  for (let i = 0; i < pat.length; i++) {
+    if (GLOB_CHARS.has(expectDefined(pat[i]))) {
+      firstGlob = i;
+      break;
+    }
+  }
+  const cut = Math.max(
+    pat.lastIndexOf(SEP, firstGlob - 1),
+    pat.lastIndexOf("/", firstGlob - 1)
+  );
   return cut < 0 ? "." : pat.slice(0, cut);
 }
 async function expandGlob(pattern) {
@@ -579,11 +633,31 @@ function truncate(s, max) {
 
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
+import * as fs2 from "node:fs";
 import * as os from "node:os";
 import * as path3 from "node:path";
+function canonicalProjectRoot(absRoot) {
+  const checkoutRoot = path3.resolve(absRoot);
+  const dotGit = path3.join(checkoutRoot, ".git");
+  try {
+    if (!fs2.statSync(dotGit).isFile()) return checkoutRoot;
+    const gitDirLine = fs2.readFileSync(dotGit, "utf8").trim();
+    const match = /^gitdir:\s*(.+)$/i.exec(gitDirLine);
+    if (!match?.[1]) return checkoutRoot;
+    const gitDir = path3.resolve(checkoutRoot, match[1].trim());
+    const commonDirFile = path3.join(gitDir, "commondir");
+    if (!fs2.statSync(commonDirFile).isFile()) return checkoutRoot;
+    const commonDir = path3.resolve(gitDir, fs2.readFileSync(commonDirFile, "utf8").trim());
+    if (path3.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
+    return path3.dirname(commonDir);
+  } catch {
+    return checkoutRoot;
+  }
+}
 function projectSlug(absRoot) {
-  const base = slugify(path3.basename(absRoot));
-  const hash = createHash("sha256").update(path3.resolve(absRoot)).digest("hex").slice(0, 6);
+  const identityRoot = canonicalProjectRoot(absRoot);
+  const base = slugify(path3.basename(identityRoot));
+  const hash = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify(name) {
@@ -1417,9 +1491,11 @@ function normalizeSubagentStructuredReport(value) {
   const filesExamined = stringArray(value["files_examined"]);
   const nextSteps = stringArray(value["suggested_next_steps"]);
   const confidence = value["confidence"];
+  const completion = value["completion"];
+  const remainingWork = optionalString(value["remaining_work"]);
   if (!summary || summary.length > MAX_SUMMARY_CHARS || !findings || findings.length > MAX_FINDINGS || !filesExamined || filesExamined.length > MAX_FILES || !nextSteps || nextSteps.length > MAX_NEXT_STEPS || [...findings, ...filesExamined, ...nextSteps].some(
     (item) => item.trim().length > MAX_ITEM_CHARS
-  ) || typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+  ) || typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1 || completion !== void 0 && completion !== "complete" && completion !== "partial" || completion === "partial" && !remainingWork || remainingWork !== void 0 && remainingWork.length > MAX_SUMMARY_CHARS) {
     return void 0;
   }
   const report = {
@@ -1427,7 +1503,9 @@ function normalizeSubagentStructuredReport(value) {
     findings: findings.map((item) => item.trim()).filter(Boolean),
     files_examined: filesExamined.map((item) => item.trim()).filter(Boolean),
     confidence,
-    suggested_next_steps: nextSteps.map((item) => item.trim()).filter(Boolean)
+    suggested_next_steps: nextSteps.map((item) => item.trim()).filter(Boolean),
+    ...completion === "complete" || completion === "partial" ? { completion } : {},
+    ...remainingWork ? { remaining_work: remainingWork } : {}
   };
   return JSON.stringify(report).length <= MAX_SUBAGENT_STRUCTURED_REPORT_CHARS ? report : void 0;
 }
@@ -1440,6 +1518,8 @@ function formatSubagentStructuredReport(report) {
   const next = report.suggested_next_steps.length ? report.suggested_next_steps.map((item) => `- ${item}`).join("\n") : "- (none)";
   return [
     report.summary,
+    report.completion ? `Completion: ${report.completion}` : void 0,
+    report.remaining_work ? `Remaining work: ${report.remaining_work}` : void 0,
     `
 Findings:
 ${findings}`,
@@ -1449,7 +1529,7 @@ Files examined: ${files}`,
     `
 Suggested next steps:
 ${next}`
-  ].join("\n");
+  ].filter((line) => typeof line === "string").join("\n");
 }
 function makeSubagentResultTool() {
   return {
@@ -1489,6 +1569,16 @@ function makeSubagentResultTool() {
           maxItems: MAX_NEXT_STEPS,
           items: { type: "string" },
           description: "Concrete follow-ups; use an empty array when none remain."
+        },
+        completion: {
+          type: "string",
+          enum: ["complete", "partial"],
+          description: "Use `partial` only when the task is intentionally stopping at a clean checkpoint and another worker should continue."
+        },
+        remaining_work: {
+          type: "string",
+          maxLength: MAX_SUMMARY_CHARS,
+          description: "Concrete work left for a successor. Required by runtime validation when completion is `partial`."
         }
       },
       required: ["summary", "findings", "files_examined", "confidence", "suggested_next_steps"],
@@ -1518,6 +1608,9 @@ function isRecord(value) {
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+function optionalString(value) {
+  return value === void 0 ? void 0 : nonEmptyString(value);
+}
 function stringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
 }
@@ -1800,7 +1893,7 @@ var TOOLS = {
 };
 
 // src/coordination/agents/agent-prompts.ts
-import { readFileSync, statSync } from "node:fs";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import * as os2 from "node:os";
 import * as path4 from "node:path";
 import { fileURLToPath } from "node:url";
@@ -1815,7 +1908,7 @@ function agentPrompt(id) {
   let resolved = "";
   for (const dir of agentPromptDirCandidates(envDir)) {
     try {
-      resolved = readFileSync(path4.join(dir, fileName), "utf8").trimEnd();
+      resolved = readFileSync2(path4.join(dir, fileName), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -1845,7 +1938,7 @@ function agentPromptDirCandidates(envDir) {
 }
 function isDirectory(candidate) {
   try {
-    return statSync(candidate).isDirectory();
+    return statSync2(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -3458,7 +3551,12 @@ var BrainDecisionQueue = class {
       if (this.opts.timeoutMs && this.opts.timeoutMs > 0) {
         entry.timer = setTimeout(() => {
           this.pending.delete(request.id);
-          resolve9({ type: "deny", reason: "Brain human decision timed out." });
+          resolve9(
+            this.opts.onTimeout?.(request) ?? {
+              type: "deny",
+              reason: "Brain human decision timed out."
+            }
+          );
         }, this.opts.timeoutMs);
       }
       this.pending.set(request.id, entry);
@@ -3475,6 +3573,46 @@ var BrainDecisionQueue = class {
     }
   }
 };
+function terminalPolicyDecision(request) {
+  const recommended = request.options?.find((option) => option.recommended);
+  if (recommended && (request.risk === "low" || request.risk === "medium")) {
+    return {
+      type: "answer",
+      optionId: recommended.id,
+      text: recommended.label,
+      rationale: `Headless terminal policy: caller-recommended option accepted at ${request.risk} risk (no human available by configuration).`
+    };
+  }
+  if (request.fallback === "continue") {
+    return {
+      type: "answer",
+      text: "Continue with the caller default.",
+      rationale: "Headless terminal policy: request declares continue as its safe fallback."
+    };
+  }
+  return {
+    type: "deny",
+    reason: `Headless terminal policy: no safe automatic option for "${request.question}" (risk: ${request.risk}). The proposed action was not taken.`
+  };
+}
+var EscalationRoutingBrainArbiter = class {
+  constructor(inner, queue, getMode) {
+    this.inner = inner;
+    this.queue = queue;
+    this.getMode = getMode;
+  }
+  inner;
+  queue;
+  getMode;
+  async decide(request) {
+    const decision = await this.inner.decide(request);
+    if (decision.type !== "ask_human") return decision;
+    if (this.getMode() === "interactive" && this.queue) {
+      return this.queue.requestHumanDecision(request);
+    }
+    return terminalPolicyDecision(request);
+  }
+};
 var HumanEscalatingBrainArbiter = class {
   constructor(inner, queue) {
     this.inner = inner;
@@ -3550,29 +3688,348 @@ function formatHumanPrompt(request) {
   return lines.join("\n");
 }
 
+// src/coordination/brain-ledger.ts
+import { appendFile, mkdir as mkdir2, readFile } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
+var QUESTION_MAX = 200;
+var DETAIL_MAX = 240;
+var truncate2 = (s, max) => s === void 0 ? void 0 : s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+function brainDecisionKey(source, question) {
+  const normalized = question.toLowerCase().replace(/[^\s]*\d[^\s]*/g, "#").replace(/\s+/g, " ").trim().slice(0, 100);
+  return `${source ?? "?"}:${normalized}`;
+}
+function fmtAge(ms) {
+  const s = Math.max(0, Math.round(ms / 1e3));
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.round(s / 60)}m ago`;
+  return `${Math.round(s / 3600)}h ago`;
+}
+function createLedgerGuardBrainArbiter(opts) {
+  const denyAfter = opts.denyAfter ?? 3;
+  return {
+    async decide(request) {
+      if (denyAfter > 0) {
+        const streak = opts.failureStreakFor(request);
+        if (streak >= denyAfter) {
+          return {
+            type: "deny",
+            reason: `Ledger guard: the last ${streak} approved decisions of this kind all ended in observed failures \u2014 denying deterministically until a success is recorded. (${request.question.slice(0, 120)})`
+          };
+        }
+      }
+      return opts.inner.decide(request);
+    }
+  };
+}
+var BrainDecisionLedger = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.maxMemoryEntries = opts.maxMemoryEntries ?? 500;
+    this.retryWindowMs = opts.interventionRetryWindowMs ?? 10 * 6e4;
+    this.now = opts.now ?? Date.now;
+  }
+  opts;
+  entries = [];
+  outcomeByRequest = /* @__PURE__ */ new Map();
+  /** subagentId → decision request ids awaiting that subagent's task result. */
+  pendingBudgetOutcomes = /* @__PURE__ */ new Map();
+  lastInterventionByKind = /* @__PURE__ */ new Map();
+  unsubscribers = [];
+  /** Serialized fire-and-forget writes — awaited by `stop()` (drain). */
+  writeChain = Promise.resolve();
+  dirReady = false;
+  maxMemoryEntries;
+  retryWindowMs;
+  now;
+  /**
+   * Subscribe to the EventBus and seed the in-memory ring from the JSONL
+   * tail. The returned promise resolves once the seed load finished
+   * (best-effort — a missing/corrupt file is an empty history, not an error).
+   */
+  async start() {
+    const { events } = this.opts;
+    this.unsubscribers.push(
+      events.on("brain.decision_answered", (e) => {
+        this.record({
+          at: e.at,
+          sessionId: e.sessionId,
+          requestId: e.request.id,
+          kind: "answered",
+          source: e.request.source,
+          risk: e.request.risk,
+          question: truncate2(e.request.question, QUESTION_MAX),
+          optionId: e.decision.type === "answer" ? e.decision.optionId : void 0,
+          detail: e.decision.type === "answer" ? truncate2(e.decision.rationale ?? e.decision.text, DETAIL_MAX) : void 0
+        });
+      }),
+      events.on("brain.decision_denied", (e) => {
+        this.record({
+          at: e.at,
+          sessionId: e.sessionId,
+          requestId: e.request.id,
+          kind: "denied",
+          source: e.request.source,
+          risk: e.request.risk,
+          question: truncate2(e.request.question, QUESTION_MAX),
+          detail: e.decision.type === "deny" ? truncate2(e.decision.reason, DETAIL_MAX) : void 0
+        });
+      }),
+      events.on("brain.decision_ask_human", (e) => {
+        this.record({
+          at: e.at,
+          sessionId: e.sessionId,
+          requestId: e.request.id,
+          kind: "ask_human",
+          source: e.request.source,
+          risk: e.request.risk,
+          question: truncate2(e.request.question, QUESTION_MAX)
+        });
+      }),
+      events.on("brain.intervention", (e) => {
+        this.record({
+          at: e.at,
+          sessionId: e.sessionId,
+          requestId: e.request.id,
+          kind: "intervention",
+          source: e.request.source,
+          risk: e.request.risk,
+          question: truncate2(`[${e.kind}] ${e.request.question}`, QUESTION_MAX),
+          detail: e.intervened ? "steered" : "observed only"
+        });
+        if (!e.intervened) return;
+        const prev = this.lastInterventionByKind.get(e.kind);
+        if (prev && e.at - prev.at <= this.retryWindowMs) {
+          this.recordOutcome(
+            prev.requestId,
+            "failure",
+            `same signal (${e.kind}) re-triggered ${fmtAge(e.at - prev.at).replace(" ago", " later")}`,
+            e.sessionId
+          );
+        }
+        this.lastInterventionByKind.set(e.kind, { requestId: e.request.id, at: e.at });
+      }),
+      // ── Outcome correlation: budget extensions ────────────────────────
+      events.on("subagent.budget_extended", (e) => {
+        const requestId = `director-budget-${e.subagentId}-${e.kind}`;
+        if (!this.entries.some((entry) => entry.requestId === requestId)) return;
+        let set = this.pendingBudgetOutcomes.get(e.subagentId);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this.pendingBudgetOutcomes.set(e.subagentId, set);
+        }
+        set.add(requestId);
+      }),
+      events.on("subagent.task_completed", (e) => {
+        const pending = this.pendingBudgetOutcomes.get(e.subagentId);
+        if (!pending) return;
+        this.pendingBudgetOutcomes.delete(e.subagentId);
+        const outcome = e.status === "success" ? "success" : "failure";
+        for (const requestId of pending) {
+          this.recordOutcome(
+            requestId,
+            outcome,
+            `budget-extended subagent's task ${e.status}`,
+            e.sessionId
+          );
+        }
+      })
+    );
+    await this.load();
+  }
+  /** Unsubscribe and drain pending writes. Safe to call twice. */
+  async stop() {
+    for (const off of this.unsubscribers) off();
+    this.unsubscribers.length = 0;
+    await this.writeChain.catch(() => {
+    });
+  }
+  /**
+   * Attach a real-world outcome to an earlier decision. Appended to the
+   * JSONL, folded into future digests, and re-emitted as `brain.outcome`.
+   */
+  recordOutcome(requestId, outcome, detail, sessionId) {
+    this.outcomeByRequest.set(requestId, outcome);
+    this.record({
+      at: this.now(),
+      sessionId,
+      requestId,
+      kind: "outcome",
+      outcome,
+      detail: truncate2(detail, DETAIL_MAX)
+    });
+    this.opts.events.emit("brain.outcome", {
+      sessionId,
+      requestId,
+      outcome,
+      detail,
+      at: this.now()
+    });
+  }
+  /** Last `n` ledger rows, oldest first. */
+  tail(n) {
+    return this.entries.slice(-n);
+  }
+  /**
+   * Consecutive most-recent FAILURE outcomes among answered decisions of
+   * this request's group. Decisions whose outcome is still unknown are
+   * skipped (they neither extend nor break the streak); the first known
+   * SUCCESS ends it. Powers the deterministic ledger guard: "the last K
+   * times we approved this, it went wrong — stop approving".
+   */
+  failureStreakFor(request) {
+    const key = brainDecisionKey(request.source, request.question);
+    let streak = 0;
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const e = this.entries[i];
+      if (e?.kind !== "answered" || e.requestId === request.id || e.question === void 0 || brainDecisionKey(e.source, e.question) !== key) {
+        continue;
+      }
+      const outcome = this.outcomeByRequest.get(e.requestId);
+      if (outcome === void 0) continue;
+      if (outcome === "success") break;
+      streak += 1;
+    }
+    return streak;
+  }
+  /**
+   * Short decision-history block for the LLM/council prompt: how similar
+   * past decisions went and — when known — how they turned OUT. Returns
+   * undefined when there is no relevant history (no prompt noise).
+   */
+  digestFor(request) {
+    const key = brainDecisionKey(request.source, request.question);
+    const related = this.entries.filter(
+      (e) => (e.kind === "answered" || e.kind === "denied") && e.requestId !== request.id && e.question !== void 0 && brainDecisionKey(e.source, e.question) === key
+    );
+    if (related.length === 0) return void 0;
+    const recent = related.slice(-5).reverse();
+    const now = this.now();
+    const lines = recent.map((e) => {
+      const what = e.kind === "denied" ? "denied" : e.optionId ? `chose [${e.optionId}]` : "answered";
+      const outcome = this.outcomeByRequest.get(e.requestId);
+      const suffix = outcome === "failure" ? " \u2192 later FAILED" : outcome === "success" ? " \u2192 later succeeded" : "";
+      return `- ${fmtAge(now - e.at)}: ${what}${suffix}`;
+    });
+    const approved = related.filter((e) => e.kind === "answered");
+    const failedAfter = approved.filter(
+      (e) => this.outcomeByRequest.get(e.requestId) === "failure"
+    ).length;
+    const summary = `Summary: ${related.length} similar decision(s); ${approved.length} answered${failedAfter > 0 ? ` (${failedAfter} later failed)` : ""}, ${related.length - approved.length} denied.`;
+    return [...lines, summary].join("\n");
+  }
+  // ── Private ───────────────────────────────────────────────────────────
+  record(entry) {
+    this.entries.push(entry);
+    if (this.entries.length > this.maxMemoryEntries) {
+      const evictedRequestIds = /* @__PURE__ */ new Set();
+      const evictCount = this.entries.length - this.maxMemoryEntries;
+      const evicted = this.entries.splice(0, evictCount);
+      for (const e of evicted) {
+        if (e.requestId) evictedRequestIds.add(e.requestId);
+      }
+      if (evictedRequestIds.size > 0) {
+        const remainingRequestIds = /* @__PURE__ */ new Set();
+        for (const e of this.entries) {
+          if (e.requestId) remainingRequestIds.add(e.requestId);
+        }
+        for (const id of evictedRequestIds) {
+          if (!remainingRequestIds.has(id)) this.outcomeByRequest.delete(id);
+        }
+      }
+    }
+    this.append(entry);
+  }
+  append(entry) {
+    this.writeChain = this.writeChain.then(async () => {
+      if (!this.dirReady) {
+        await mkdir2(dirname4(this.opts.filePath), { recursive: true });
+        this.dirReady = true;
+      }
+      await appendFile(this.opts.filePath, `${JSON.stringify(entry)}
+`, "utf8");
+    }).catch(() => {
+    });
+  }
+  /** Seed the in-memory ring from the JSONL tail (cross-session learning). */
+  async load() {
+    let raw;
+    try {
+      raw = await readFile(this.opts.filePath, "utf8");
+    } catch {
+      return;
+    }
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    const seed = [];
+    for (const line of lines.slice(-this.maxMemoryEntries)) {
+      try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed?.requestId === "string" && typeof parsed.at === "number") {
+          seed.push(parsed);
+        }
+      } catch {
+      }
+    }
+    this.entries.unshift(...seed);
+    if (this.entries.length > this.maxMemoryEntries) {
+      this.entries.splice(0, this.entries.length - this.maxMemoryEntries);
+    }
+    for (const e of this.entries) {
+      if (e.kind === "outcome" && e.outcome) this.outcomeByRequest.set(e.requestId, e.outcome);
+    }
+  }
+};
+
 // src/coordination/brain-monitor.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
+var FILE_EDIT_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "patch", "multi_edit", "multiedit", "str_replace"]);
+function editedPath(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const r = input;
+  const candidate = r["file_path"] ?? r["path"] ?? r["filePath"] ?? r["file"];
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
+}
 var BrainMonitor = class {
   constructor(opts) {
     this.opts = opts;
     this.toolFailureStreak = opts.toolFailureStreak ?? 3;
     this.errorStormCount = opts.errorStormCount ?? 4;
     this.errorStormWindowMs = opts.errorStormWindowMs ?? 6e4;
+    this.stallMs = opts.stallMs ?? 3e5;
+    this.stallCheckIntervalMs = opts.stallCheckIntervalMs ?? 3e4;
+    this.fileChurnThreshold = opts.fileChurnThreshold ?? 5;
+    this.fileChurnWindowMs = opts.fileChurnWindowMs ?? 6e5;
     this.cooldownMs = opts.cooldownMs ?? 12e4;
   }
   opts;
   failStreaks = /* @__PURE__ */ new Map();
   errorTimestamps = [];
+  editTimestamps = /* @__PURE__ */ new Map();
   lastEngagedAt = /* @__PURE__ */ new Map();
   unsubscribers = [];
   engaging = false;
+  activeRuns = 0;
+  lastProgressAt = 0;
+  stallTimer;
   toolFailureStreak;
   errorStormCount;
   errorStormWindowMs;
+  stallMs;
+  stallCheckIntervalMs;
+  fileChurnThreshold;
+  fileChurnWindowMs;
   cooldownMs;
+  /** Resolve the leader's own session id for event filtering. */
+  resolveLeaderSessionId() {
+    const id = this.opts.leaderSessionId;
+    return typeof id === "function" ? id() : id;
+  }
   start() {
     this.unsubscribers.push(
       this.opts.events.on("tool.executed", (e) => {
+        const leaderSid = this.resolveLeaderSessionId();
+        if (leaderSid && e.sessionId && e.sessionId !== leaderSid) return;
+        this.lastProgressAt = Date.now();
+        this.trackFileChurn(e.name, e.ok, e.input);
         if (e.ok) {
           this.failStreaks.delete(e.name);
           return;
@@ -3592,8 +4049,50 @@ var BrainMonitor = class {
         }
       })
     );
+    if (this.stallMs > 0) {
+      this.unsubscribers.push(
+        this.opts.events.on("agent.run.started", (e) => {
+          const lsid = this.resolveLeaderSessionId();
+          if (lsid && e.sessionId && e.sessionId !== lsid) return;
+          this.activeRuns += 1;
+          this.lastProgressAt = Date.now();
+        }),
+        this.opts.events.on("agent.run.completed", (e) => {
+          const lsid = this.resolveLeaderSessionId();
+          if (lsid && e.sessionId && e.sessionId !== lsid) return;
+          this.activeRuns = Math.max(0, this.activeRuns - 1);
+        }),
+        this.opts.events.on("agent.run.error", (e) => {
+          const lsid = this.resolveLeaderSessionId();
+          if (lsid && e.sessionId && e.sessionId !== lsid) return;
+          this.activeRuns = Math.max(0, this.activeRuns - 1);
+        }),
+        this.opts.events.on("iteration.started", (e) => {
+          const lsid = this.resolveLeaderSessionId();
+          if (lsid && e.sessionId && e.sessionId !== lsid) return;
+          this.lastProgressAt = Date.now();
+        })
+      );
+      this.stallTimer = setInterval(() => {
+        if (this.activeRuns === 0 || this.lastProgressAt === 0) return;
+        const idleMs = Date.now() - this.lastProgressAt;
+        if (idleMs < this.stallMs) return;
+        this.lastProgressAt = Date.now();
+        void this.engage("agent_stall", {
+          question: `An active run has made no observable progress (no tool call or iteration) for ${Math.round(idleMs / 6e4)} minute(s). Should the agent be steered before more time is wasted?`,
+          context: [
+            `Active runs: ${this.activeRuns}`,
+            `Idle for: ${Math.round(idleMs / 1e3)}s`,
+            `Stall threshold: ${Math.round(this.stallMs / 1e3)}s`
+          ].join("\n")
+        });
+      }, this.stallCheckIntervalMs);
+      this.stallTimer.unref?.();
+    }
     this.unsubscribers.push(
       this.opts.events.on("error", (e) => {
+        const lsid = this.resolveLeaderSessionId();
+        if (lsid && e.sessionId && e.sessionId !== lsid) return;
         const now = Date.now();
         this.errorTimestamps.push(now);
         this.errorTimestamps = this.errorTimestamps.filter(
@@ -3616,6 +4115,37 @@ var BrainMonitor = class {
     this.unsubscribers.length = 0;
     this.failStreaks.clear();
     this.errorTimestamps = [];
+    this.editTimestamps.clear();
+    if (this.stallTimer) {
+      clearInterval(this.stallTimer);
+      this.stallTimer = void 0;
+    }
+    this.activeRuns = 0;
+    this.lastProgressAt = 0;
+  }
+  /** Sliding-window count of successful edits per file → churn signal. */
+  trackFileChurn(toolName, ok, input) {
+    if (!ok || !FILE_EDIT_TOOLS.has(toolName.toLowerCase())) return;
+    const path20 = editedPath(input);
+    if (!path20) return;
+    const now = Date.now();
+    const stamps = (this.editTimestamps.get(path20) ?? []).filter(
+      (t) => now - t <= this.fileChurnWindowMs
+    );
+    stamps.push(now);
+    if (stamps.length >= this.fileChurnThreshold) {
+      this.editTimestamps.delete(path20);
+      void this.engage("file_churn", {
+        question: `The file "${path20}" has been edited ${stamps.length} times within ${Math.round(this.fileChurnWindowMs / 6e4)} minutes \u2014 the agent may be oscillating (edit/revert loop) instead of converging. Should it be steered?`,
+        context: [
+          `File: ${path20}`,
+          `Edits in window: ${stamps.length}`,
+          `Window: ${Math.round(this.fileChurnWindowMs / 1e3)}s`
+        ].join("\n")
+      });
+      return;
+    }
+    this.editTimestamps.set(path20, stamps);
   }
   async engage(kind, input) {
     const last = this.lastEngagedAt.get(kind) ?? 0;
@@ -4422,76 +4952,45 @@ import * as path5 from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/coordination/fleet.ts
-var AUDIT_LOG_AGENT = {
-  id: "audit-log",
-  name: "Audit Log",
-  role: "audit-log",
-  prompt: agentPrompt("audit-log")
-  // No hardcoded budgets — the orchestrator (delegate tool or
-  // spawn_subagent) decides per-task how much room a subagent gets.
-  // A monorepo audit needs hours; a single-file lint check needs
-  // seconds. Pinning a number here forces the orchestrator to fight
-  // the role's default instead of just asking for what it needs.
-};
-var BUG_HUNTER_AGENT = {
-  id: "bug-hunter",
-  name: "Bug Hunter",
-  role: "bug-hunter",
-  prompt: agentPrompt("bug-hunter")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var REFACTOR_PLANNER_AGENT = {
-  id: "refactor-planner",
-  name: "Refactor Planner",
-  role: "refactor-planner",
-  prompt: agentPrompt("refactor-planner")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var SECURITY_SCANNER_AGENT = {
-  id: "security-scanner",
-  name: "Security Scanner",
-  role: "security-scanner",
-  prompt: agentPrompt("security-scanner")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var SHADOW_AGENT = {
-  id: "shadow-agent",
-  name: "Shadow",
-  role: "shadow-agent",
-  prompt: agentPrompt("shadow-agent")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var CRITIC_AGENT = {
-  id: "critic",
-  name: "Critic",
-  role: "critic",
-  prompt: agentPrompt("critic")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
+function defineAgent(id, name, promptRole = id, provider) {
+  return {
+    id,
+    name,
+    role: id,
+    prompt: agentPrompt(promptRole),
+    ...provider === void 0 ? {} : { provider }
+  };
+}
+var AUDIT_LOG_AGENT = defineAgent("audit-log", "Audit Log");
+var BUG_HUNTER_AGENT = defineAgent("bug-hunter", "Bug Hunter");
+var REFACTOR_PLANNER_AGENT = defineAgent("refactor-planner", "Refactor Planner");
+var SECURITY_SCANNER_AGENT = defineAgent("security-scanner", "Security Scanner");
+var SHADOW_AGENT = defineAgent("shadow-agent", "Shadow");
+var CRITIC_AGENT = defineAgent("critic", "Critic");
 var FLEET_ROSTER = {
   "audit-log": AUDIT_LOG_AGENT,
   "bug-hunter": BUG_HUNTER_AGENT,
   "refactor-planner": REFACTOR_PLANNER_AGENT,
   "security-scanner": SECURITY_SCANNER_AGENT,
-  "critic": CRITIC_AGENT,
+  critic: CRITIC_AGENT,
   "shadow-agent": SHADOW_AGENT,
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
   )
 };
-var DEFAULT_IDLE_TIMEOUT_MS = 15 * 60 * 1e3;
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
 var FLEET_ROSTER_BUDGETS = {
-  "audit-log": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 5e3, maxToolCalls: 15e3 },
-  "bug-hunter": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
-  "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 },
+  "audit-log": { timeoutMs: 3 * 60 * 60 * 1e3, maxIterations: 2500, maxToolCalls: 7500 },
+  "bug-hunter": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 1e4 },
+  "refactor-planner": { timeoutMs: 4 * 60 * 60 * 1e3, maxIterations: 3e3, maxToolCalls: 9e3 },
+  "security-scanner": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 1e4 },
+  critic: { timeoutMs: 3 * 60 * 60 * 1e3, maxIterations: 2e3, maxToolCalls: 6e3 },
   "shadow-agent": {
     idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
-    maxIterations: 2e3,
-    maxToolCalls: 5e3,
-    maxTokens: 6e4,
-    maxCostUsd: 1
+    maxIterations: 1e3,
+    maxToolCalls: 2500,
+    maxTokens: 3e4,
+    maxCostUsd: 0.5
   },
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
@@ -4499,8 +4998,8 @@ var FLEET_ROSTER_BUDGETS = {
 };
 var GENERIC_SUBAGENT_BUDGET = {
   idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
-  maxIterations: 5e3,
-  maxToolCalls: 15e3
+  maxIterations: 2500,
+  maxToolCalls: 7500
 };
 function applyRosterBudget(cfg) {
   const roleBudget = cfg.role ? FLEET_ROSTER_BUDGETS[cfg.role] : void 0;
@@ -4522,41 +5021,11 @@ function applyRosterBudget(cfg) {
   };
 }
 var ALL_FLEET_AGENTS = Object.values(FLEET_ROSTER);
-var CLINE_AGENT = {
-  id: "cline",
-  name: "Cline",
-  role: "cline",
-  prompt: agentPrompt("acp-cline"),
-  provider: "acp"
-};
-var GEMINI_CLI_AGENT = {
-  id: "gemini-cli",
-  name: "Gemini CLI",
-  role: "gemini-cli",
-  prompt: agentPrompt("acp-gemini-cli"),
-  provider: "acp"
-};
-var COPILOT_AGENT = {
-  id: "copilot",
-  name: "GitHub Copilot",
-  role: "copilot",
-  prompt: agentPrompt("acp-copilot"),
-  provider: "acp"
-};
-var OPENHANDS_AGENT = {
-  id: "openhands",
-  name: "OpenHands",
-  role: "openhands",
-  prompt: agentPrompt("acp-openhands"),
-  provider: "acp"
-};
-var GOOSE_AGENT = {
-  id: "goose",
-  name: "Goose",
-  role: "goose",
-  prompt: agentPrompt("acp-goose"),
-  provider: "acp"
-};
+var CLINE_AGENT = defineAgent("cline", "Cline", "acp-cline", "acp");
+var GEMINI_CLI_AGENT = defineAgent("gemini-cli", "Gemini CLI", "acp-gemini-cli", "acp");
+var COPILOT_AGENT = defineAgent("copilot", "GitHub Copilot", "acp-copilot", "acp");
+var OPENHANDS_AGENT = defineAgent("openhands", "OpenHands", "acp-openhands", "acp");
+var GOOSE_AGENT = defineAgent("goose", "Goose", "acp-goose", "acp");
 var ACP_AGENTS = [
   CLINE_AGENT,
   GEMINI_CLI_AGENT,
@@ -4564,11 +5033,14 @@ var ACP_AGENTS = [
   OPENHANDS_AGENT,
   GOOSE_AGENT
 ];
-FLEET_ROSTER_BUDGETS["cline"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["gemini-cli"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["copilot"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["openhands"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["goose"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
+var ACP_AGENT_BUDGET = {
+  timeoutMs: 10 * 60 * 60 * 1e3,
+  maxIterations: 8e3,
+  maxToolCalls: 2e4
+};
+for (const agent of ACP_AGENTS) {
+  FLEET_ROSTER_BUDGETS[agent.role] = { ...ACP_AGENT_BUDGET };
+}
 var FLEET_ROSTER_WITHACP = {
   ...FLEET_ROSTER,
   ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
@@ -4576,75 +5048,81 @@ var FLEET_ROSTER_WITHACP = {
 
 // src/coordination/delegate-tool.ts
 function createDelegateTool(opts) {
-  const defaultTimeoutMs = opts.defaultTimeoutMs ?? 30 * 60 * 1e3;
+  const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
   const rosterIds = opts.roster ? Object.keys(opts.roster) : [];
   const inputSchema = {
     type: "object",
     properties: {
       task: {
         type: "string",
-        description: "What the subagent should do \u2014 natural language, complete sentence(s). The subagent has its own tool slice, its own LLM call, and returns when its task is done."
+        description: "What the subagent should do \u2014 natural language, complete sentence(s)."
       },
       role: {
         type: "string",
-        description: rosterIds.length > 0 ? `Roster role (preferred). One of: ${rosterIds.join(", ")}. Picks a pre-tuned config (prompt, budgets, tools) for that role.` : "No roster is configured \u2014 pass `name` instead.",
-        enum: rosterIds.length > 0 ? rosterIds : void 0
+        description: rosterIds.length > 0 ? "Roster role id. Common: bug-hunter, security-scanner, refactor-planner, critic, audit-log, executor, shadow-agent, architect." : "No roster configured \u2014 pass `name` instead."
       },
       name: {
         type: "string",
-        description: "Display name for free-form subagents (not using a roster role). The subagent gets a large default budget (3h, 5000 iter, 15000 tool calls). Required when `role` is omitted."
+        description: "Display name for free-form subagents (no roster role). Required when `role` is omitted."
       },
       provider: {
         type: "string",
-        description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the host provider when omitted.'
+        description: 'Provider id (e.g. "anthropic", "openai"). Defaults to host provider.'
       },
       model: {
         type: "string",
-        description: "Model id within the provider. Defaults to the host model when omitted."
+        description: "Model id within the provider. Defaults to host model."
       },
       systemPromptOverride: {
         type: "string",
-        description: "Optional extra prompt text appended to the role baseline."
+        description: "Extra prompt text appended to the role baseline."
       },
       timeoutMs: {
         type: "number",
         minimum: 1,
-        description: `Wall-clock budget for this delegate in milliseconds. No hard cap \u2014 set as high as the task realistically needs (a monorepo audit can take hours, a single-file lint takes seconds). Default ${Math.round(defaultTimeoutMs / 1e3 / 60)} minutes.`
+        description: `Wall-clock budget in ms (default ${Math.round(defaultTimeoutMs / 1e3 / 60)} min). No hard cap \u2014 set as high as the task needs.`
       },
       maxIterations: {
         type: "number",
         minimum: 1,
-        description: "Maximum LLM iterations the subagent may take. Unset = use the role/coordinator default. Raise this for tasks with many tool-think-tool cycles (deep code analysis, multi-file refactors)."
+        description: "Maximum LLM iterations. Unset = role default. Raise for deep multi-step tasks."
       },
       maxToolCalls: {
         type: "number",
         minimum: 1,
-        description: "Maximum number of tool invocations the subagent may make. Unset = use the role/coordinator default. Raise this for tasks that touch many files (large grep + read + report)."
+        description: "Maximum tool invocations. Unset = role default. Raise for file-heavy tasks."
       },
       idleTimeoutMs: {
         type: "number",
         minimum: 1,
-        description: "Idle timeout in ms: reap the subagent after this long with no activity. Resets on every iteration/tool call. Unset = use the role/coordinator default."
+        description: "Idle timeout in ms. Resets on activity. Unset = role default."
       },
       maxTokens: {
         type: "number",
         minimum: 1,
-        description: "Maximum total tokens (input + output) the subagent may use. Unset = use the role/coordinator default."
+        description: "Max total tokens (input+output). Unset = role default."
       },
       maxCostUsd: {
         type: "number",
         minimum: 0,
-        description: "Maximum estimated USD cost the subagent may incur. Unset = use the role/coordinator default."
+        description: "Max estimated USD cost. Unset = role default."
+      },
+      maxHandoffs: {
+        type: "number",
+        minimum: 0,
+        maximum: 8,
+        description: "Max fresh-worker continuations after budget exhaustion. Default 1. Each gets the prior partial report."
       }
     },
     required: ["task"]
   };
   return {
     name: "delegate",
-    description: "Hand a discrete piece of work to a dedicated subagent and wait for its result. The subagent has its own context, its own LLM call, and its own budget \u2014 use this when a task is self-contained, would otherwise blow up your context, or benefits from a specialized role (bug-hunter, security-scanner, refactor-planner, audit-log). For free-form coding tasks (not tied to a pre-defined role), pass `name` + `task` \u2014 the subagent runs as a general-purpose coding agent with a large default budget. YOU decide how big the budget is: pass `timeoutMs`, `maxIterations`, and `maxToolCalls` sized to the actual work. There is no hidden cap forcing a 3-minute / 80-iteration limit \u2014 if a monorepo audit needs 2 hours and 500 tool calls, ask for that. Call multiple delegates in parallel through the provider's parallel-tool-call surface to fan work out across roles.",
-    usageHint: "Set `task` to a complete instruction. Either pick `role` from the roster (audit-log, bug-hunter, refactor-planner, security-scanner) or pass `name` to run a free-form coding agent. For non-trivial work, also pass `timeoutMs`, `maxIterations`, and `maxToolCalls`. Returns the subagent's `TaskResult` \u2014 including the textual `result`, iteration count, tool count, and duration. Requires Director mode to be active in normal CLI sessions.",
+    description: "Hand a piece of work to a subagent and wait for its result. Has own context, LLM call, auto-extending budget. Can continue remaining work with a fresh subagent on partial completion (maxHandoffs, default 1). Workers cannot recursively spawn. Use roster roles when possible; otherwise pass `name` + `task`.",
+    usageHint: "Set `task` to a complete instruction. Pick `role` from roster or pass `name` for free-form. Override `timeoutMs`/`maxIterations`/`maxToolCalls` only when needed.",
     permission: "auto",
     mutating: false,
+    managesOwnTimeout: true,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema,
     async execute(input, _ctx, execOpts) {
@@ -4668,10 +5146,9 @@ function createDelegateTool(opts) {
           director = await opts.host.promoteToDirector();
         }
         if (!director) {
-          const reason = opts.host.getPromotionBlockReason?.();
           return {
             ok: false,
-            error: reason ?? "Director could not be activated \u2014 multi-agent host already running in legacy non-director mode. Restart with `--director` for fleet support."
+            error: "Director could not be activated \u2014 fleet orchestration is unavailable."
           };
         }
         const timeoutMs = i.timeoutMs ?? defaultTimeoutMs;
@@ -4684,7 +5161,7 @@ function createDelegateTool(opts) {
               error: `Unknown role "${i.role}". Available: ${rosterIds.join(", ") || "(no roster configured)"}.`
             };
           }
-          cfg = instantiateRosterConfig(i.role, base);
+          cfg = instantiateRosterConfig(i.role, base, i.timeoutMs, defaultTimeoutMs);
           if (i.systemPromptOverride) cfg.systemPromptOverride = i.systemPromptOverride;
           if (i.provider) cfg.provider = i.provider;
           if (i.model) cfg.model = i.model;
@@ -4723,172 +5200,175 @@ function createDelegateTool(opts) {
           cfg.timeoutMs = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
         }
         opts.events?.emit("delegate.started", { sessionId, target, task: i.task });
-        const subagentId = await director.spawn(cfg);
-        const taskId = await director.assign({
-          id: `${randomUUID4()}`,
-          description: i.task,
-          subagentId
-        });
         const dir = director;
-        const result = await new Promise((resolve9) => {
-          let settled = false;
-          let timer;
-          let offAbort = () => {
-          };
-          const finish = (value) => {
-            if (settled) return;
-            settled = true;
-            if (timer) clearTimeout(timer);
-            offTool();
-            offIter();
-            offProgress();
-            offAbort();
-            resolve9(value);
-          };
-          const arm = () => {
-            if (timer) clearTimeout(timer);
-            timer = setTimeout(() => finish({ __timeout: true }), timeoutMs);
-          };
-          const bump = (e) => {
-            if (e.subagentId === subagentId) arm();
-          };
-          const offTool = dir.fleet.filter("tool.executed", bump);
-          const offIter = dir.fleet.filter("iteration.started", bump);
-          const offProgress = dir.fleet.filter("tool.progress", bump);
-          if (abortSignal) {
-            const onAbortSignal = () => finish({ __aborted: true });
-            abortSignal.addEventListener("abort", onAbortSignal, { once: true });
-            offAbort = () => abortSignal.removeEventListener("abort", onAbortSignal);
-            if (abortSignal.aborted) onAbortSignal();
-          }
-          arm();
-          dir.awaitTasks([taskId]).then((r) => finish(r[0] ?? { __emptyResult: true })).catch(() => finish({ __timeout: true }));
-        });
-        if ("__aborted" in result) {
-          try {
-            await dir.terminate(subagentId);
-          } catch {
-          }
-          const partial2 = await readSubagentPartial(opts, subagentId);
-          opts.events?.emit("delegate.completed", {
-            sessionId,
-            target,
-            task: i.task,
-            ok: false,
-            status: "aborted",
-            summary: `[${target}] aborted \u2014 the run was interrupted`,
-            durationMs: 0,
-            iterations: partial2?.events ?? 0,
-            toolCalls: partial2?.toolUsesObserved ?? 0,
+        const maxHandoffs = Math.min(8, Math.max(0, Math.floor(i.maxHandoffs ?? 1)));
+        const handoffs = [];
+        let delegatedTask = i.task;
+        let handoffCount = 0;
+        for (; ; ) {
+          const attemptConfig = handoffCount === 0 ? cfg : freshHandoffConfig(cfg, i.role, handoffCount);
+          const subagentId = await dir.spawn(attemptConfig);
+          const taskId = await dir.assign({
+            id: randomUUID4(),
+            description: delegatedTask,
             subagentId
           });
-          return {
-            ok: false,
-            stopReason: "aborted",
-            error: "Delegated task aborted \u2014 the run was interrupted.",
+          const result = await awaitDelegateAttempt(
+            dir,
             subagentId,
             taskId,
-            partial: partial2
-          };
-        }
-        if ("__timeout" in result) {
-          const partial2 = await readSubagentPartial(opts, subagentId);
+            timeoutMs,
+            abortSignal
+          );
+          if ("__aborted" in result) {
+            try {
+              await dir.terminate(subagentId);
+            } catch {
+            }
+            const partial2 = await readSubagentPartial(opts, subagentId);
+            opts.events?.emit("delegate.completed", {
+              sessionId,
+              target,
+              task: i.task,
+              ok: false,
+              status: "aborted",
+              summary: `[${target}] aborted \u2014 the run was interrupted`,
+              durationMs: 0,
+              iterations: partial2?.events ?? 0,
+              toolCalls: partial2?.toolUsesObserved ?? 0,
+              subagentId
+            });
+            return {
+              ok: false,
+              stopReason: "aborted",
+              error: "Delegated task aborted \u2014 the run was interrupted.",
+              subagentId,
+              taskId,
+              partial: partial2,
+              ...handoffs.length > 0 ? { handoffs } : {}
+            };
+          }
+          if ("__timeout" in result) {
+            try {
+              await dir.terminate(subagentId);
+            } catch {
+            }
+            const partial2 = await readSubagentPartial(opts, subagentId);
+            opts.events?.emit("delegate.completed", {
+              sessionId,
+              target,
+              task: i.task,
+              ok: false,
+              status: "host_timeout",
+              summary: `[${target}] timed out \u2014 no progress within ${Math.round(timeoutMs / 1e3)}s`,
+              durationMs: timeoutMs,
+              iterations: partial2?.events ?? 0,
+              toolCalls: partial2?.toolUsesObserved ?? 0,
+              subagentId
+            });
+            return {
+              ok: false,
+              stopReason: "host_timeout",
+              error: `Subagent timed out: it did not finish or report progress within ${timeoutMs}ms.`,
+              hint: "Raise timeoutMs for unusually long single operations, or split the remaining work.",
+              subagentId,
+              taskId,
+              partial: partial2,
+              ...handoffs.length > 0 ? { handoffs } : {}
+            };
+          }
+          if ("__emptyResult" in result) {
+            const partial2 = await readSubagentPartial(opts, subagentId);
+            opts.events?.emit("delegate.completed", {
+              sessionId,
+              target,
+              task: i.task,
+              ok: false,
+              status: "empty_result",
+              summary: `[${target}] completed without a task result`,
+              durationMs: 0,
+              iterations: partial2?.events ?? 0,
+              toolCalls: partial2?.toolUsesObserved ?? 0,
+              subagentId
+            });
+            return {
+              ok: false,
+              stopReason: "error",
+              error: "Director returned no task result for the delegated task.",
+              hint: "Check fleet state, then retry or reassign the task.",
+              subagentId,
+              taskId,
+              partial: partial2,
+              ...handoffs.length > 0 ? { handoffs } : {}
+            };
+          }
+          const partial = result.status === "success" ? void 0 : result.partial ? {
+            lastAssistantText: result.partial.text,
+            toolUsesObserved: result.toolCalls,
+            events: result.iterations
+          } : await readSubagentPartial(opts, subagentId);
+          const continuation = continuationFor(result, partial, attemptConfig);
+          if (continuation && handoffCount < maxHandoffs) {
+            handoffs.push({
+              fromSubagentId: result.subagentId,
+              fromTaskId: result.taskId,
+              status: result.status,
+              errorKind: result.error?.kind,
+              summary: continuation.summary,
+              remainingWork: continuation.remainingWork
+            });
+            handoffCount += 1;
+            delegatedTask = buildHandoffTask(i.task, continuation, handoffCount, maxHandoffs);
+            continue;
+          }
+          const incomplete = result.report?.completion === "partial";
+          const baseStopReason = incomplete ? "handoff_limit" : result.status === "success" ? "end_turn" : result.status === "timeout" ? "subagent_timeout" : result.status === "stopped" ? "aborted" : "budget_exhausted";
+          const errorKind = result.error?.kind;
+          const retryable = result.error?.retryable;
+          const backoffMs = result.error?.backoffMs;
+          const summary = incomplete ? `[${target}] partial checkpoint \u2014 handoff limit reached after ${handoffCount} continuation(s)` : buildDelegateSummary(i.role, result);
+          let costUsd;
+          try {
+            costUsd = dir.snapshot().perSubagent[result.subagentId]?.cost;
+          } catch {
+            costUsd = void 0;
+          }
           opts.events?.emit("delegate.completed", {
             sessionId,
             target,
             task: i.task,
-            ok: false,
-            status: "host_timeout",
-            summary: `[${target}] timed out \u2014 no result within ${Math.round(timeoutMs / 1e3)}s`,
-            durationMs: timeoutMs,
-            iterations: partial2?.events ?? 0,
-            toolCalls: partial2?.toolUsesObserved ?? 0,
-            subagentId
+            ok: result.status === "success" && !incomplete,
+            status: incomplete ? "partial" : result.status,
+            summary,
+            durationMs: result.durationMs,
+            iterations: result.iterations,
+            toolCalls: result.toolCalls,
+            costUsd,
+            subagentId: result.subagentId
           });
           return {
-            ok: false,
-            stopReason: "host_timeout",
-            error: `Subagent did not finish within ${timeoutMs}ms.`,
-            hint: "Reduce scope of the next delegate, raise timeoutMs, or use spawn_subagent + await_tasks for long-running work.",
-            subagentId,
-            taskId,
-            partial: partial2
+            ok: result.status === "success" && !incomplete,
+            status: incomplete ? "partial" : result.status,
+            stopReason: baseStopReason,
+            errorKind,
+            retryable,
+            backoffMs,
+            subagentId: result.subagentId,
+            taskId: result.taskId,
+            result: result.result,
+            report: result.report,
+            error: result.error,
+            iterations: result.iterations,
+            toolCalls: result.toolCalls,
+            durationMs: result.durationMs,
+            ...partial ? { partial } : {},
+            ...handoffs.length > 0 ? { handoffs } : {},
+            ...incomplete ? {
+              hint: "A clean partial checkpoint remains. Reinvoke delegate with a larger maxHandoffs or assign report.remaining_work explicitly."
+            } : hintForKind(errorKind, retryable, backoffMs, partial) ? { hint: hintForKind(errorKind, retryable, backoffMs, partial) } : {},
+            summary
           };
         }
-        if ("__emptyResult" in result) {
-          const partial2 = await readSubagentPartial(opts, subagentId);
-          opts.events?.emit("delegate.completed", {
-            sessionId,
-            target,
-            task: i.task,
-            ok: false,
-            status: "empty_result",
-            summary: `[${target}] completed without a task result`,
-            durationMs: 0,
-            iterations: partial2?.events ?? 0,
-            toolCalls: partial2?.toolUsesObserved ?? 0,
-            subagentId
-          });
-          return {
-            ok: false,
-            stopReason: "error",
-            error: "Director returned no task result for the delegated task.",
-            hint: "Check fleet state with /fleet status, then retry or reassign the task.",
-            subagentId,
-            taskId,
-            partial: partial2
-          };
-        }
-        const baseStopReason = result.status === "success" ? "end_turn" : result.status === "timeout" ? "subagent_timeout" : result.status === "stopped" ? "aborted" : "budget_exhausted";
-        const partial = result.status === "success" ? void 0 : result.partial ? {
-          lastAssistantText: result.partial.text,
-          toolUsesObserved: result.toolCalls,
-          events: result.iterations
-        } : await readSubagentPartial(opts, subagentId);
-        const errorKind = result.error?.kind;
-        const retryable = result.error?.retryable;
-        const backoffMs = result.error?.backoffMs;
-        const summary = buildDelegateSummary(i.role, result);
-        let costUsd;
-        try {
-          costUsd = dir.snapshot().perSubagent[result.subagentId]?.cost;
-        } catch {
-          costUsd = void 0;
-        }
-        opts.events?.emit("delegate.completed", {
-          sessionId,
-          target,
-          task: i.task,
-          ok: result.status === "success",
-          status: result.status,
-          summary,
-          durationMs: result.durationMs,
-          iterations: result.iterations,
-          toolCalls: result.toolCalls,
-          costUsd,
-          subagentId: result.subagentId
-        });
-        return {
-          ok: result.status === "success",
-          status: result.status,
-          stopReason: baseStopReason,
-          errorKind,
-          retryable,
-          backoffMs,
-          subagentId: result.subagentId,
-          taskId: result.taskId,
-          result: result.result,
-          report: result.report,
-          error: result.error,
-          iterations: result.iterations,
-          toolCalls: result.toolCalls,
-          durationMs: result.durationMs,
-          ...partial ? { partial } : {},
-          ...hintForKind(errorKind, retryable, backoffMs, partial) ? { hint: hintForKind(errorKind, retryable, backoffMs, partial) } : {},
-          // Summary is included so callers (TUI, CLI renderer) can surface
-          // it as a chat history line — the LLM also sees it for continuity.
-          summary
-        };
       } catch (err) {
         const message = toErrorMessage(err);
         opts.events?.emit("delegate.completed", {
@@ -4911,10 +5391,103 @@ function createDelegateTool(opts) {
     }
   };
 }
-function instantiateRosterConfig(role, base) {
+async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abortSignal) {
+  return new Promise((resolve9) => {
+    let settled = false;
+    let timer;
+    let offAbort = () => {
+    };
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      offTool();
+      offIter();
+      offProgress();
+      offAbort();
+      resolve9(value);
+    };
+    const arm = () => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => finish({ __timeout: true }), timeoutMs);
+    };
+    const bump = (event) => {
+      if (event.subagentId === subagentId) arm();
+    };
+    const offTool = director.fleet.filter("tool.executed", bump);
+    const offIter = director.fleet.filter("iteration.started", bump);
+    const offProgress = director.fleet.filter("tool.progress", bump);
+    if (abortSignal) {
+      const onAbort = () => finish({ __aborted: true });
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+      offAbort = () => abortSignal.removeEventListener("abort", onAbort);
+      if (abortSignal.aborted) onAbort();
+    }
+    arm();
+    director.awaitTasks([taskId]).then((results) => finish(results[0] ?? { __emptyResult: true })).catch(() => finish({ __timeout: true }));
+  });
+}
+function freshHandoffConfig(cfg, role, handoffCount) {
+  return {
+    ...cfg,
+    id: role ? `${role}-${randomUUID4().slice(0, 8)}` : `${cfg.name.toLowerCase().replace(/[^a-z0-9]+/g, "-") || "subagent"}-handoff-${handoffCount}-${randomUUID4().slice(0, 6)}`
+  };
+}
+function continuationFor(result, partial, config) {
+  if (result.report?.completion === "partial" && result.report.remaining_work) {
+    return {
+      summary: result.report.summary,
+      remainingWork: result.report.remaining_work,
+      partialText: typeof result.result === "string" ? result.result : partial?.lastAssistantText
+    };
+  }
+  const budgetKinds = /* @__PURE__ */ new Set([
+    "budget_iterations",
+    "budget_tool_calls",
+    "budget_tokens",
+    "budget_cost",
+    "budget_timeout"
+  ]);
+  const partialText = result.partial?.text ?? partial?.lastAssistantText;
+  const mayHaveIsolatedWrites = config.worktree !== false && config.worktree !== "off" && (!config.tools || config.tools.some(
+    (tool) => ["write", "edit", "replace", "patch", "bash", "exec", "install", "format"].includes(tool)
+  ));
+  if (!mayHaveIsolatedWrites && result.status !== "success" && result.error?.kind && budgetKinds.has(result.error.kind) && partialText) {
+    return {
+      summary: `Prior worker stopped at ${result.error.kind} after ${result.iterations} iterations and ${result.toolCalls} tool calls.`,
+      remainingWork: "Inspect the existing workspace and finish only the work that remains from the original task.",
+      partialText
+    };
+  }
+  return void 0;
+}
+function buildHandoffTask(originalTask, continuation, handoffCount, maxHandoffs) {
+  const partial = continuation.partialText?.trim().slice(-6e3);
+  return [
+    `Continue an oversized delegated task as fresh worker ${handoffCount} of ${maxHandoffs}.`,
+    "Do not blindly repeat completed actions. Inspect the current workspace, git diff, tests, and any files named below before changing anything.",
+    'If the remaining work is still too large, stop at a clean checkpoint and call submit_result with completion="partial" plus concrete remaining_work.',
+    "If parallel help would materially improve the outcome and mail_send is available, send the leader an `ask` that names the exact helper task; do not spawn agents yourself.",
+    `Original task:
+${originalTask}`,
+    `Prior checkpoint summary:
+${continuation.summary}`,
+    `Remaining work:
+${continuation.remainingWork}`,
+    partial ? `Prior worker's last useful output:
+${partial}` : ""
+  ].filter(Boolean).join("\n\n");
+}
+function instantiateRosterConfig(role, base, requestedTimeoutMs, defaultTimeoutMs) {
   const withBudget = applyRosterBudget({ ...base, role });
+  const rosterTimeoutMs = FLEET_ROSTER_BUDGETS[role]?.timeoutMs;
   return {
     ...withBudget,
+    // Without an explicit host wait, apply the role's tuned multi-hour
+    // wall-clock budget. With an explicit wait, leave this unset so the buffer
+    // logic above derives a slightly shorter child budget without clamping the
+    // role defaults used by ordinary calls.
+    timeoutMs: requestedTimeoutMs === void 0 ? rosterTimeoutMs ?? defaultTimeoutMs : void 0,
     // Give each spawn a fresh id so parallel or repeated delegates
     // can use the same role safely.
     id: `${role}-${randomUUID4().slice(0, 8)}`
@@ -5100,13 +5673,13 @@ function makeDependencyWatcherConfig(opts) {
   const globPatterns = patterns.filter((p) => p.includes("*"));
   const plainPatterns = patterns.filter((p) => !p.includes("*"));
   function matchesPattern(filePath) {
-    const basename8 = filePath.split("/").pop()?.split("\\").pop() ?? "";
-    if (plainPatterns.includes(basename8)) return true;
+    const basename7 = filePath.split("/").pop()?.split("\\").pop() ?? "";
+    if (plainPatterns.includes(basename7)) return true;
     for (const gp of globPatterns) {
       const regex = new RegExp(
         "^" + gp.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
       );
-      if (regex.test(basename8)) return true;
+      if (regex.test(basename7)) return true;
     }
     return false;
   }
@@ -5446,8 +6019,86 @@ var FleetContextOverflowError = class extends Error {
   }
 };
 
+// src/coordination/director/director-collab.ts
+var DirectorCollabController = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  /** Active collab sessions tracked by sessionId (see spawn).
+   *  The tuple holds the session and its Director-registered listener unsubs.
+   *  Calling the unsubs on cancel/premature-cleanup prevents listener accumulation
+   *  on CollabSession (EventEmitter) across many spawn() calls. */
+  activeSessions = /* @__PURE__ */ new Map();
+  async spawn(options) {
+    const session = new CollabSession(this.deps.director, this.deps.fleet, {
+      ...options,
+      onBudgetWarning: (alert) => {
+        return options.onBudgetWarning?.(alert) ?? "ignore";
+      }
+    });
+    const doneHandler = () => this.activeSessions.delete(session.sessionId);
+    const errorHandler = () => this.activeSessions.delete(session.sessionId);
+    session.on("session.done", doneHandler);
+    session.on("session.error", errorHandler);
+    const unsubs = [
+      () => session.off("session.done", doneHandler),
+      () => session.off("session.error", errorHandler)
+    ];
+    this.activeSessions.set(session.sessionId, { session, unsubs });
+    return session.start();
+  }
+  cancel(sessionId, reason = "Director cancelled") {
+    const entry = this.activeSessions.get(sessionId);
+    if (!entry || entry.session.isCancelled()) return;
+    for (const unsub of entry.unsubs) unsub();
+    entry.session.cancel(reason);
+    for (const [_role, subagentId] of entry.session.getSubagentIds()) {
+      this.deps.coordinator.stop(subagentId).catch((err) => {
+        this.deps.logger?.debug(
+          `stop subagent ${subagentId} failed (may have already completed)`,
+          {
+            subagentId,
+            err: err instanceof Error ? err.message : String(err)
+          }
+        );
+      });
+    }
+  }
+  onAlert(handler) {
+    return this.deps.fleet.filter("collab.warning", (e) => {
+      handler(e.payload);
+    });
+  }
+  activeSessionIds() {
+    return Array.from(this.activeSessions.keys());
+  }
+};
+
+// src/coordination/director/director-btw-notes.ts
+var DirectorBtwNotes = class {
+  notes = [];
+  /** Stash a note (trimmed; empty ignored). Returns the pending count. Cap 20. */
+  add(note) {
+    const trimmed = note.trim();
+    if (!trimmed) return this.notes.length;
+    this.notes = [...this.notes, trimmed].slice(-20);
+    return this.notes.length;
+  }
+  /** Read and clear all pending notes, in FIFO order (empty array when none). */
+  drain() {
+    const notes = this.notes;
+    this.notes = [];
+    return notes;
+  }
+  /** Peek at pending notes without consuming them. */
+  peek() {
+    return [...this.notes];
+  }
+};
+
 // src/utils/instruction-file.ts
-import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
 import * as path6 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
@@ -5458,7 +6109,7 @@ function readBundledInstructionText(relativePath) {
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      resolved = readFileSync2(path6.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync3(path6.join(root, relativePath), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -5485,7 +6136,7 @@ function instructionRootCandidates() {
 }
 function isDirectory2(candidate) {
   try {
-    return statSync2(candidate).isDirectory();
+    return statSync3(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -8993,13 +9644,12 @@ var Director = class _Director {
    * coordinator from keeping workers alive for tasks that will never arrive.
    */
   workCompleteFlag = false;
-  /** Pending /btw notes stashed by the leader agent (see setLeaderBtwNote). */
-  _leaderBtwNotes = [];
-  /** Active collab sessions tracked by sessionId (see spawnCollab).
-   *  The tuple holds the session and its Director-registered listener unsubs.
-   *  Calling the unsubs on cancel/premature-cleanup prevents listener accumulation
-   *  on CollabSession (EventEmitter) across many spawnCollab() calls. */
-  _activeCollabSessions = /* @__PURE__ */ new Map();
+  /** Pending /btw notes stashed by the leader agent (see setLeaderBtwNote).
+   *  Owned by DirectorBtwNotes (R4); the public btw methods delegate to it. */
+  btwNotes = new DirectorBtwNotes();
+  /** Owns active collab-debug sessions (spawn/cancel/alert/list). Extracted
+   *  from Director in R4; the public collab methods below delegate to it. */
+  collab;
   /** Prevents large `ask_subagent` answers from bloating the leader's context window. */
   largeAnswerStore;
   constructor(opts) {
@@ -9011,7 +9661,7 @@ var Director = class _Director {
     this.subagentBaseline = opts.subagentBaseline ?? DEFAULT_SUBAGENT_BASELINE;
     this.taskResultNotifier = opts.taskResultNotifier;
     this.subagentIdleTimeoutMs = typeof opts.subagentIdleTimeoutMs === "number" && Number.isFinite(opts.subagentIdleTimeoutMs) && opts.subagentIdleTimeoutMs >= 0 ? opts.subagentIdleTimeoutMs : void 0;
-    this.retireSubagentOnTaskComplete = opts.retireSubagentOnTaskComplete ?? false;
+    this.retireSubagentOnTaskComplete = opts.retireSubagentOnTaskComplete ?? true;
     this.sharedScratchpadPath = opts.sharedScratchpadPath ?? null;
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = opts.fleetManager?.maxSpawnDepth ?? resolveMaxSpawnDepth(opts.maxSpawnDepth);
@@ -9022,7 +9672,7 @@ var Director = class _Director {
     this.dispatchClassifier = opts.dispatchClassifier;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
     this.maxFleetTokens = opts.directorBudget?.maxTokens ?? Number.POSITIVE_INFINITY;
-    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
+    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 12;
     this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
     this.maxContext = opts.maxContext ?? 128e3;
     this.modelMatrix = opts.modelMatrix;
@@ -9076,92 +9726,103 @@ var Director = class _Director {
     );
     this.coordinator.setFleetBus(this.fleet);
     this.fleetManager?.setCoordinator(this.coordinator);
-    this.taskCompletedListener = (payload) => {
-      const r = payload.result;
-      const internalTask = this.internalTaskIds.delete(r.taskId);
-      if (!internalTask) {
-        this.completed.set(r.taskId, r);
-        if (this.completed.size > _Director.MAX_COMPLETED) {
-          const toDelete = this.completed.size - _Director.MAX_COMPLETED;
-          const keys = [...this.completed.keys()].slice(0, toDelete);
-          for (const k of keys) this.completed.delete(k);
-        }
-      }
-      const waiter = this.taskWaiters.get(r.taskId);
-      if (waiter) {
-        waiter.resolve(r);
-        this.taskWaiters.delete(r.taskId);
-      }
-      let anyConsumed = false;
-      for (const aw of [...this.anyWaiters]) {
-        if (!aw.ids.has(r.taskId)) continue;
-        if (aw.timer) clearTimeout(aw.timer);
-        this.anyWaiters.delete(aw);
-        aw.resolve(r);
-        anyConsumed = true;
-      }
-      const consumedInBand = !!waiter || anyConsumed;
-      if (internalTask) return;
-      const title = this.taskDescriptions.get(r.taskId) ?? payload.task.description ?? r.taskId;
-      if (!consumedInBand && this.taskResultNotifier) {
-        const resultText = typeof r.result === "string" ? r.result : r.result !== void 0 ? safeStringify(r.result) : void 0;
-        try {
-          void Promise.resolve(
-            this.taskResultNotifier({
-              taskId: r.taskId,
-              title,
-              status: r.status,
-              subagentId: r.subagentId,
-              subagentName: this.manifestEntries.get(r.subagentId)?.name,
-              resultText,
-              errorText: r.error ? `${r.error.kind}: ${r.error.message}` : void 0,
-              partialText: r.partial?.text,
-              report: r.report,
-              iterations: r.iterations,
-              toolCalls: r.toolCalls,
-              durationMs: r.durationMs
-            })
-          ).catch(() => {
-          });
-        } catch {
-        }
+    this.taskCompletedListener = (payload) => this.handleTaskCompleted(payload);
+    this.coordinator.on("task.completed", this.taskCompletedListener);
+    this.wireBudgetPolicy();
+    this.largeAnswerStore = new LargeAnswerStore(2e3);
+    this.collab = new DirectorCollabController({
+      director: this,
+      fleet: this.fleet,
+      coordinator: this.coordinator,
+      logger: this.logger
+    });
+  }
+  handleTaskCompleted(payload) {
+    const r = payload.result;
+    const internalTask = this.internalTaskIds.delete(r.taskId);
+    if (!internalTask) {
+      this.completed.set(r.taskId, r);
+      if (this.completed.size > _Director.MAX_COMPLETED) {
+        const toDelete = this.completed.size - _Director.MAX_COMPLETED;
+        const keys = [...this.completed.keys()].slice(0, toDelete);
+        for (const k of keys) this.completed.delete(k);
+      }
+    }
+    const waiter = this.taskWaiters.get(r.taskId);
+    if (waiter) {
+      waiter.resolve(r);
+      this.taskWaiters.delete(r.taskId);
+    }
+    let anyConsumed = false;
+    for (const aw of [...this.anyWaiters]) {
+      if (!aw.ids.has(r.taskId)) continue;
+      if (aw.timer) clearTimeout(aw.timer);
+      this.anyWaiters.delete(aw);
+      aw.resolve(r);
+      anyConsumed = true;
+    }
+    const consumedInBand = !!waiter || anyConsumed;
+    if (internalTask) return;
+    const title = this.taskDescriptions.get(r.taskId) ?? payload.task.description ?? r.taskId;
+    if (!consumedInBand && this.taskResultNotifier) {
+      const resultText = typeof r.result === "string" ? r.result : r.result !== void 0 ? safeStringify(r.result) : void 0;
+      try {
+        void Promise.resolve(
+          this.taskResultNotifier({
+            taskId: r.taskId,
+            title,
+            status: r.status,
+            subagentId: r.subagentId,
+            subagentName: this.manifestEntries.get(r.subagentId)?.name,
+            resultText,
+            errorText: r.error ? `${r.error.kind}: ${r.error.message}` : void 0,
+            partialText: r.partial?.text,
+            report: r.report,
+            iterations: r.iterations,
+            toolCalls: r.toolCalls,
+            durationMs: r.durationMs
+          })
+        ).catch(() => {
+        });
+      } catch {
       }
-      const failed = r.status !== "success";
-      const errorString = r.error ? `${r.error.kind}: ${r.error.message}` : void 0;
-      this.stateCheckpoint?.recordTaskStatus(r.taskId, {
-        status: failed ? r.status : "completed",
-        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        iterations: r.iterations,
-        toolCalls: r.toolCalls,
-        durationMs: r.durationMs,
-        error: errorString
-      });
-      this.stateCheckpoint?.setUsage(this.usage.snapshot());
-      void this.appendSessionEvent(
-        failed ? {
-          type: "task_failed",
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          taskId: r.taskId,
-          title,
-          error: errorString ?? r.status
-        } : {
-          type: "task_completed",
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          taskId: r.taskId,
-          title
-        }
-      );
-      if (this.fleetManager) {
-        void this.fleetManager.flushManifest();
-      } else {
-        this.scheduleManifest();
+    }
+    const failed = r.status !== "success";
+    const errorString = r.error ? `${r.error.kind}: ${r.error.message}` : void 0;
+    this.stateCheckpoint?.recordTaskStatus(r.taskId, {
+      status: failed ? r.status : "completed",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      iterations: r.iterations,
+      toolCalls: r.toolCalls,
+      durationMs: r.durationMs,
+      error: errorString
+    });
+    this.stateCheckpoint?.setUsage(this.usage.snapshot());
+    void this.appendSessionEvent(
+      failed ? {
+        type: "task_failed",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        taskId: r.taskId,
+        title,
+        error: errorString ?? r.status
+      } : {
+        type: "task_completed",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        taskId: r.taskId,
+        title
       }
-      this.armSubagentIdleRetirement(
-        r.subagentId,
-        this.retireSubagentOnTaskComplete ? 0 : this.subagentIdleTimeoutMs
-      );
-    };
-    this.coordinator.on("task.completed", this.taskCompletedListener);
+    );
+    if (this.fleetManager) {
+      void this.fleetManager.flushManifest();
+    } else {
+      this.scheduleManifest();
+    }
+    this.armSubagentIdleRetirement(
+      r.subagentId,
+      this.retireSubagentOnTaskComplete ? 0 : this.subagentIdleTimeoutMs
+    );
+  }
+  wireBudgetPolicy() {
     const extendCounts = /* @__PURE__ */ new Map();
     const progressBySubagent = /* @__PURE__ */ new Map();
     const lastTimeoutProgress = /* @__PURE__ */ new Map();
@@ -9271,7 +9932,7 @@ var Director = class _Director {
             payload.deny();
             return;
           }
-          if (decision.optionId === "stop" || /\bstop\b/i.test(decision.text)) {
+          if (decision.optionId === "stop") {
             payload.deny();
             return;
           }
@@ -9281,7 +9942,6 @@ var Director = class _Director {
       }
       grantExtension();
     });
-    this.largeAnswerStore = new LargeAnswerStore(2e3);
   }
   /**
    * Record a granted budget extension and broadcast it on the FleetBus so
@@ -9339,10 +9999,7 @@ var Director = class _Director {
    * programmatically without going through the slash-command path.
    */
   setLeaderBtwNote(note) {
-    const trimmed = note.trim();
-    if (!trimmed) return this._leaderBtwNotes.length;
-    this._leaderBtwNotes = [...this._leaderBtwNotes, trimmed].slice(-20);
-    return this._leaderBtwNotes.length;
+    return this.btwNotes.add(note);
   }
   /**
    * Read and clear all pending /btw notes the leader has stashed.
@@ -9353,16 +10010,14 @@ var Director = class _Director {
    * to cancel the collab session or let it continue.
    */
   getLeaderBtwNotes() {
-    const notes = this._leaderBtwNotes;
-    this._leaderBtwNotes = [];
-    return notes;
+    return this.btwNotes.drain();
   }
   /**
    * Peek at pending /btw notes without consuming them.
    * Useful for UI to show "N pending notes" without clearing them.
    */
   peekLeaderBtwNotes() {
-    return [...this._leaderBtwNotes];
+    return this.btwNotes.peek();
   }
   /**
    * Drain (read + clear) all /btw notes in one call.
@@ -9382,18 +10037,7 @@ var Director = class _Director {
    * The CollabDebugReport will reflect 'cancelled' disposition when awaited.
    */
   cancelCollabSession(sessionId, reason = "Director cancelled") {
-    const entry = this._activeCollabSessions.get(sessionId);
-    if (!entry || entry.session.isCancelled()) return;
-    for (const unsub of entry.unsubs) unsub();
-    entry.session.cancel(reason);
-    for (const [_role, subagentId] of entry.session.getSubagentIds()) {
-      this.coordinator.stop(subagentId).catch((err) => {
-        this.logger?.debug(`stop subagent ${subagentId} failed (may have already completed)`, {
-          subagentId,
-          err: err instanceof Error ? err.message : String(err)
-        });
-      });
-    }
+    this.collab.cancel(sessionId, reason);
   }
   /**
    * Subscribe a callback to be notified whenever a collab session raises
@@ -9402,9 +10046,7 @@ var Director = class _Director {
    * Returns an unsubscribe function.
    */
   onCollabAlert(handler) {
-    return this.fleet.filter("collab.warning", (e) => {
-      handler(e.payload);
-    });
+    return this.collab.onAlert(handler);
   }
   /**
    * Returns all active (not yet settled) collab session ids.
@@ -9412,7 +10054,7 @@ var Director = class _Director {
    * the host to know what can be cancelled.
    */
   activeCollabSessions() {
-    return Array.from(this._activeCollabSessions.keys());
+    return this.collab.activeSessionIds();
   }
   /** Best-effort session-writer append. Swallows failures — the director
    *  must not break a fleet run because the session JSONL handle closed. */
@@ -9478,6 +10120,77 @@ var Director = class _Director {
       );
     }
     const config = { ...callerConfig };
+    this.resolveSpawnModel(config);
+    this.enforceSpawnCaps(config);
+    let result;
+    this.assignSpawnNickname(config);
+    this.applySpawnLineage(config);
+    result = await this.coordinator.spawn(config);
+    if (this.fleetManager) {
+      this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
+    } else {
+      this.spawnCount += 1;
+      this.subagentMeta.set(result.subagentId, {
+        provider: config.provider,
+        model: config.model
+      });
+      if (priceLookup && config.provider && config.model) {
+        this.priceLookups.set(`${config.provider}/${config.model}`, priceLookup);
+      }
+    }
+    const subagentBridge = new InMemoryAgentBridge(
+      { agentId: result.subagentId, coordinatorId: this.id },
+      this.transport
+    );
+    this.coordinator.setSubagentBridge(result.subagentId, subagentBridge);
+    this.subagentBridges.set(result.subagentId, subagentBridge);
+    this.fleet.emit({
+      subagentId: result.subagentId,
+      ts: Date.now(),
+      type: "subagent.spawned",
+      payload: {
+        subagentId: result.subagentId,
+        taskId: "",
+        // taskId will be set when assign() is called
+        name: config.name,
+        role: config.role,
+        provider: config.provider,
+        model: config.model
+      }
+    });
+    if (!this.fleetManager) {
+      this.manifestEntries.set(result.subagentId, {
+        subagentId: result.subagentId,
+        name: config.name,
+        role: config.role,
+        provider: config.provider,
+        model: config.model,
+        taskIds: []
+      });
+      const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.stateCheckpoint?.recordSpawn(
+        {
+          id: result.subagentId,
+          name: config.name,
+          role: config.role,
+          provider: config.provider,
+          model: config.model,
+          spawnedAt
+        },
+        this.spawnCount
+      );
+      void this.appendSessionEvent({
+        type: "agent_spawned",
+        ts: spawnedAt,
+        agentId: result.subagentId,
+        role: config.role ?? config.name
+      });
+      this.scheduleManifest();
+    }
+    this.armSubagentIdleRetirement(result.subagentId, this.subagentIdleTimeoutMs);
+    return result.subagentId;
+  }
+  resolveSpawnModel(config) {
     if (!config.model && this.modelMatrix) {
       const matrix = typeof this.modelMatrix === "function" ? this.modelMatrix() : this.modelMatrix;
       const resolution = resolveModelMatrixResolution(matrix, config.role);
@@ -9488,6 +10201,8 @@ var Director = class _Director {
         if (entry.modelRuntime) config.modelRuntime = entry.modelRuntime;
       }
     }
+  }
+  enforceSpawnCaps(config) {
     if (this.fleetManager) {
       const rejection = this.fleetManager.canSpawn(config);
       if (rejection) {
@@ -9530,7 +10245,8 @@ var Director = class _Director {
         }
       }
     }
-    let result;
+  }
+  assignSpawnNickname(config) {
     const needsNickname = config.name === config.role || !config.name || config.name === "subagent" || config.name === "adhoc";
     if (needsNickname) {
       const role = config.role ?? "subagent";
@@ -9542,6 +10258,8 @@ var Director = class _Director {
         this._usedNicknames.add(key);
       }
     }
+  }
+  applySpawnLineage(config) {
     const budget = this.fleetManager ? this.fleetManager.budgetSnapshot() : (() => {
       const total = this.usage.snapshot().total;
       const usedTokens = (total?.input ?? 0) + (total?.output ?? 0);
@@ -9570,70 +10288,6 @@ var Director = class _Director {
         ...Number.isFinite(budget.remainingCostUsd) ? { remainingCostUsd: budget.remainingCostUsd } : {}
       }
     };
-    result = await this.coordinator.spawn(config);
-    if (this.fleetManager) {
-      this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
-    } else {
-      this.spawnCount += 1;
-      this.subagentMeta.set(result.subagentId, {
-        provider: config.provider,
-        model: config.model
-      });
-      if (priceLookup && config.provider && config.model) {
-        this.priceLookups.set(`${config.provider}/${config.model}`, priceLookup);
-      }
-    }
-    const subagentBridge = new InMemoryAgentBridge(
-      { agentId: result.subagentId, coordinatorId: this.id },
-      this.transport
-    );
-    this.coordinator.setSubagentBridge(result.subagentId, subagentBridge);
-    this.subagentBridges.set(result.subagentId, subagentBridge);
-    this.fleet.emit({
-      subagentId: result.subagentId,
-      ts: Date.now(),
-      type: "subagent.spawned",
-      payload: {
-        subagentId: result.subagentId,
-        taskId: "",
-        // taskId will be set when assign() is called
-        name: config.name,
-        role: config.role,
-        provider: config.provider,
-        model: config.model
-      }
-    });
-    if (!this.fleetManager) {
-      this.manifestEntries.set(result.subagentId, {
-        subagentId: result.subagentId,
-        name: config.name,
-        role: config.role,
-        provider: config.provider,
-        model: config.model,
-        taskIds: []
-      });
-      const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
-      this.stateCheckpoint?.recordSpawn(
-        {
-          id: result.subagentId,
-          name: config.name,
-          role: config.role,
-          provider: config.provider,
-          model: config.model,
-          spawnedAt
-        },
-        this.spawnCount
-      );
-      void this.appendSessionEvent({
-        type: "agent_spawned",
-        ts: spawnedAt,
-        agentId: result.subagentId,
-        role: config.role ?? config.name
-      });
-      this.scheduleManifest();
-    }
-    this.armSubagentIdleRetirement(result.subagentId, this.subagentIdleTimeoutMs);
-    return result.subagentId;
   }
   /**
    * Synchronously ask a subagent something via the bridge. Sends a
@@ -9758,6 +10412,23 @@ var Director = class _Director {
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
+  /**
+   * Cancel the pending manifest debounce timer and drain any in-flight
+   * manifest write so that, once this resolves, no Director-owned manifest
+   * write is armed or running.
+   *
+   * Unlike `shutdown()`, this does NOT tear down the coordinator, bridges,
+   * or waiters — it is the lightweight quiesce that `MultiAgentHost.stopAll()`
+   * needs. `stopAll()` flushes the FleetManager's manifest but never touched
+   * the Director's own writer, leaving its armed debounce timer to fire ~2s
+   * later. Under CPU starvation that late, un-awaited `atomicWrite` (temp
+   * sibling + rename) races a caller that deletes the manifest directory,
+   * producing an `ENOTEMPTY` on the parent `rmdir` (Windows especially).
+   */
+  async quiesceManifest() {
+    this.clearManifestTimer();
+    await this.manifestWriteChain.catch(() => void 0);
+  }
   /**
    * Tear down the director: stop every subagent, close every bridge
    * endpoint, and (when configured) write the final manifest. Idempotent
@@ -9769,8 +10440,17 @@ var Director = class _Director {
       this.coordinator.off("task.completed", this.taskCompletedListener);
       this.taskCompletedListener = null;
     }
-    for (const aw of this.anyWaiters) {
+    for (const aw of [...this.anyWaiters]) {
       if (aw.timer) clearTimeout(aw.timer);
+      const firstId = [...aw.ids][0];
+      aw.resolve({
+        taskId: firstId ?? "unknown",
+        subagentId: "director",
+        status: "stopped",
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      });
     }
     this.anyWaiters.clear();
     if (this.toolExecFilter) {
@@ -9784,6 +10464,17 @@ var Director = class _Director {
     for (const timer of this.subagentIdleTimers.values()) clearTimeout(timer);
     this.subagentIdleTimers.clear();
     await this.coordinator.stopAll();
+    for (const [id, waiter] of this.taskWaiters) {
+      waiter.resolve({
+        taskId: id,
+        subagentId: "director",
+        status: "stopped",
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      });
+    }
+    this.taskWaiters.clear();
     for (const b of this.subagentBridges.values()) {
       await b.stop().catch((err) => this.logShutdownError("subagent_bridge_stop", err));
     }
@@ -9791,6 +10482,7 @@ var Director = class _Director {
     await this.bridge.stop().catch((err) => this.logShutdownError("director_bridge_stop", err));
     if (this.fleetManager) {
       await this.fleetManager.flushManifest().catch((err) => this.logShutdownError("fleet_manifest_flush", err));
+      await this.manifestWriteChain.catch(() => void 0);
     } else if (this.manifestPath) {
       await this.writeManifest().catch((err) => this.logShutdownError("manifest_write", err));
     }
@@ -9799,6 +10491,7 @@ var Director = class _Director {
       await this.stateCheckpoint.flush().catch((err) => this.logShutdownError("state_checkpoint_flush", err));
       await this.stateCheckpoint.releaseLock().catch((err) => this.logShutdownError("state_checkpoint_lock_release", err));
     }
+    this.largeAnswerStore.clear();
   }
   /**
    * Funnel for shutdown-phase errors. We can't throw — `shutdown()` is
@@ -10000,9 +10693,18 @@ var Director = class _Director {
   }
   async terminate(subagentId) {
     await this.coordinator.stop(subagentId);
+    void this.remove(subagentId).catch(
+      (err) => this.logShutdownError("terminate_remove", err)
+    );
   }
   async terminateAll() {
+    const ids = this.status().subagents.map((s) => s.id);
     await this.coordinator.stopAll();
+    for (const id of ids) {
+      void this.remove(id).catch(
+        (err) => this.logShutdownError("terminate_all_remove", err)
+      );
+    }
   }
   async remove(subagentId) {
     this.clearSubagentIdleRetirement(subagentId);
@@ -10042,7 +10744,7 @@ var Director = class _Director {
     const timer = setTimeout(() => {
       this.subagentIdleTimers.delete(subagentId);
       const entry = this.coordinator.getStatus().subagents.find((a) => a.id === subagentId);
-      if (!entry || entry.status !== "idle") return;
+      if (entry?.status !== "idle") return;
       if (this.coordinator.listPendingTasks().some((task) => task.subagentId === subagentId)) {
         this.armSubagentIdleRetirement(subagentId, this.subagentIdleTimeoutMs);
         return;
@@ -10246,22 +10948,7 @@ var Director = class _Director {
    * three agents complete or the session times out.
    */
   async spawnCollab(options) {
-    const session = new CollabSession(this, this.fleet, {
-      ...options,
-      onBudgetWarning: (alert) => {
-        return options.onBudgetWarning?.(alert) ?? "ignore";
-      }
-    });
-    const doneHandler = () => this._activeCollabSessions.delete(session.sessionId);
-    const errorHandler = () => this._activeCollabSessions.delete(session.sessionId);
-    session.on("session.done", doneHandler);
-    session.on("session.error", errorHandler);
-    const unsubs = [
-      () => session.off("session.done", doneHandler),
-      () => session.off("session.error", errorHandler)
-    ];
-    this._activeCollabSessions.set(session.sessionId, { session, unsubs });
-    return session.start();
+    return this.collab.spawn(options);
   }
   /**
    * Resume from a prior checkpoint snapshot (loaded via
@@ -11634,6 +12321,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   projectRoot;
   checkpointCas;
   isSessionInUse;
+  logger;
   /**
    * In-memory cache for load() results, keyed by session ID. The cache is
    * invalidated when the file's mtimeMs or size changes (indicating the
@@ -11659,6 +12347,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
     this.isSessionInUse = opts.isSessionInUse;
+    this.logger = opts.logger;
+  }
+  /**
+   * Emit a structured warning. Uses the configured Logger when available;
+   * falls back to console.warn(JSON) so warnings are never silently dropped.
+   */
+  logWarn(msg, ctx) {
+    if (this.logger) {
+      this.logger.warn(msg, ctx);
+    } else {
+      console.warn(JSON.stringify({ ...ctx, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    }
   }
   /**
    * Clear the load() cache. Useful for testing or when the caller knows
@@ -11760,12 +12460,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite(id, file, "create", "success", Date.now() - t0);
       return writer;
     } catch (err) {
-      await handle.close().catch((e) => console.warn(JSON.stringify({
-        level: "warn",
-        event: "session_store.handle_close_failed",
-        message: e instanceof Error ? e.message : String(e),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })));
+      await handle.close().catch((e) => this.logWarn(
+        "Session handle close failed",
+        { event: "session_store.handle_close_failed", message: e instanceof Error ? e.message : String(e) }
+      ));
       this.emitError(id, file, "create", toErrorMessage(err), true);
       throw err;
     }
@@ -11896,12 +12594,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite(id, file, "resume", "success", Date.now() - t0);
       return { writer, data: resumedData };
     } catch (err) {
-      await handle.close().catch((e) => console.warn(JSON.stringify({
-        level: "warn",
-        event: "session_store.handle_close_failed",
-        message: e instanceof Error ? e.message : String(e),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })));
+      await handle.close().catch((e) => this.logWarn(
+        "Session handle close failed",
+        { event: "session_store.handle_close_failed", message: e instanceof Error ? e.message : String(e) }
+      ));
       this.emitError(id, file, "resume", toErrorMessage(err), true);
       throw err;
     }
@@ -12522,13 +13218,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
-        console.warn(JSON.stringify({
-          level: "warn",
-          event: "session_store.manifest_write_failed",
-          sessionId: id,
-          message: msg,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }));
+        this.logWarn(
+          "Session manifest write failed",
+          { event: "session_store.manifest_write_failed", sessionId: id, message: msg }
+        );
       });
       outcome = "failure";
       errorMsg = "summary fallback \xE2\u20AC\u201D manifest rebuilt";
@@ -12938,6 +13631,16 @@ var FleetManager = class {
   manifestTimer = null;
   manifestWriteChain = Promise.resolve();
   disposed = false;
+  /**
+   * Teardown freeze. Set by `closeManifest()` after the final manifest is
+   * flushed; makes any subsequent `scheduleManifest`/`writeManifest`/
+   * `flushManifest` a no-op so a late fire-and-forget write (e.g. the
+   * task-completion flush the Director issues via `void flushManifest()`)
+   * cannot land an `atomicWrite` in the manifest directory while a caller is
+   * deleting it. Cleared by `recordSpawn` so a stop-then-spawn-again host
+   * resumes writing.
+   */
+  closing = false;
   manifestDebounceMs;
   /** Fleet-wide cost cap. Infinity = no cap. Distinct from SubagentBudget limits,
    *  which track per-subagent spend — this field caps the entire fleet total. */
@@ -13119,6 +13822,7 @@ var FleetManager = class {
    * @param priceLookup Optional per-subagent pricing data
    */
   recordSpawn(subagentId, config, priceLookup) {
+    this.closing = false;
     this.spawnCount += 1;
     this.subagentMeta.set(subagentId, {
       provider: config.provider,
@@ -13156,6 +13860,7 @@ var FleetManager = class {
   }
   async writeManifest() {
     if (!this.manifestPath) return null;
+    if (this.closing) return this.manifestPath;
     this.clearManifestTimer();
     const write = this.manifestWriteChain.catch(() => void 0).then(() => this.writeManifestNow());
     this.manifestWriteChain = write.catch(() => void 0);
@@ -13204,7 +13909,7 @@ var FleetManager = class {
    * When `manifestDebounceMs` is 0, writes are synchronous (no debounce).
    */
   scheduleManifest() {
-    if (this.disposed) return;
+    if (this.disposed || this.closing) return;
     if (!this.manifestPath) return;
     if (this.manifestDebounceMs === 0) {
       void this.writeManifest().catch((err) => {
@@ -13235,6 +13940,22 @@ var FleetManager = class {
       process.emitWarning(`FleetManager manifest write failed: ${detail}`, "FleetManagerWarning");
     });
   }
+  /**
+   * Teardown flush for callers that will delete the manifest directory next
+   * (host `stopAll`/`dispose`). Writes the final manifest, then freezes the
+   * writer so no later fire-and-forget write can start, and drains anything
+   * still in flight. After this resolves it is safe to `rm -rf` the manifest
+   * directory: no `atomicWrite` (temp sibling + rename) can race the removal.
+   *
+   * The freeze is lifted by the next `recordSpawn`, so a stop-then-spawn-again
+   * host keeps persisting manifests.
+   */
+  async closeManifest() {
+    if (!this.manifestPath) return;
+    await this.flushManifest();
+    this.closing = true;
+    await this.manifestWriteChain.catch(() => void 0);
+  }
   clearManifestTimer() {
     if (!this.manifestTimer) return;
     clearTimeout(this.manifestTimer);
@@ -13320,6 +14041,184 @@ import { randomUUID as randomUUID10 } from "node:crypto";
 import * as fsp11 from "node:fs/promises";
 import * as path14 from "node:path";
 
+// src/coordination/mailbox-constants.ts
+var AGENT_STALE_MS = 6e4;
+var CLIENT_STALE_MS = 6e4;
+var HEARTBEAT_THROTTLE_MS = 5e3;
+var REGISTRY_CACHE_TTL_MS = 2e3;
+var LINE_SEPARATOR = "\n";
+var MESSAGE_CACHE_MAX_ENTRIES = 1e4;
+var AUTO_COMPACT_INTERVAL_MS = 3e5;
+var AUTO_COMPACT_READ_MAX_AGE_MS = 6e5;
+var AUTO_COMPACT_DEFAULT_TTL_MS = 864e5;
+
+// src/coordination/mailbox-message-codec.ts
+var MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  "note",
+  "ask",
+  "assign",
+  "steer",
+  "btw",
+  "broadcast",
+  "status",
+  "result",
+  "review",
+  "control"
+]);
+var PRIORITIES = /* @__PURE__ */ new Set(["low", "normal", "high"]);
+var TASK_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "in_progress",
+  "completed",
+  "failed",
+  "idle",
+  "running",
+  "streaming",
+  "waiting_user",
+  "error",
+  "offline",
+  "busy"
+]);
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requiredString(record, key) {
+  const value = record[key];
+  if (typeof value !== "string") {
+    throw new TypeError(`mailbox message field "${key}" must be a string`);
+  }
+  return value;
+}
+function optionalString2(record, key) {
+  const value = record[key];
+  if (value === void 0) return {};
+  if (typeof value !== "string") {
+    throw new TypeError(`mailbox message field "${key}" must be a string when present`);
+  }
+  return { [key]: value };
+}
+function parseMessageType(value) {
+  if (value === "info") return "note";
+  if (value === "task") return "assign";
+  if (typeof value === "string" && MESSAGE_TYPES.has(value)) {
+    return value;
+  }
+  throw new TypeError('mailbox message field "type" is invalid');
+}
+function normalizeMailboxMessageType(value) {
+  return parseMessageType(value);
+}
+function parsePriority(value) {
+  if (typeof value === "string" && PRIORITIES.has(value)) {
+    return value;
+  }
+  if (typeof value === "string") return "normal";
+  throw new TypeError('mailbox message field "priority" must be a string');
+}
+function parseReadReceipts(record, to) {
+  const value = record["readBy"];
+  if (value === void 0) {
+    const legacyReadAt = record["readAt"];
+    return record["read"] === true && typeof legacyReadAt === "string" ? { [to || "unknown"]: legacyReadAt } : {};
+  }
+  if (!isRecord3(value)) {
+    throw new TypeError('mailbox message field "readBy" must be an object');
+  }
+  const receipts = {};
+  for (const [agentId, timestamp] of Object.entries(value)) {
+    if (typeof timestamp !== "string") {
+      throw new TypeError("mailbox message read receipt timestamps must be strings");
+    }
+    receipts[agentId] = timestamp;
+  }
+  return receipts;
+}
+function parseTaskContext(value) {
+  if (value === void 0) return void 0;
+  if (!isRecord3(value)) {
+    throw new TypeError('mailbox message field "taskContext" must be an object');
+  }
+  const status = value["status"];
+  if (status !== void 0 && (typeof status !== "string" || !TASK_STATUSES.has(status))) {
+    throw new TypeError("mailbox message taskContext status is invalid");
+  }
+  return {
+    ...optionalString2(value, "agentRole"),
+    ...optionalString2(value, "agentName"),
+    ...optionalString2(value, "taskId"),
+    ...status === void 0 ? {} : { status }
+  };
+}
+function parseMailboxMessage(value) {
+  if (!isRecord3(value)) throw new TypeError("mailbox message must be an object");
+  const to = value["to"] === void 0 ? "" : requiredString(value, "to");
+  const completed = value["completed"];
+  if (typeof completed !== "boolean") {
+    throw new TypeError('mailbox message field "completed" must be a boolean');
+  }
+  const taskContext = parseTaskContext(value["taskContext"]);
+  return {
+    id: requiredString(value, "id"),
+    from: requiredString(value, "from"),
+    to,
+    type: parseMessageType(value["type"]),
+    subject: requiredString(value, "subject"),
+    body: requiredString(value, "body"),
+    priority: parsePriority(value["priority"]),
+    readBy: parseReadReceipts(value, to),
+    completed,
+    timestamp: requiredString(value, "timestamp"),
+    ...optionalString2(value, "completedBy"),
+    ...optionalString2(value, "outcome"),
+    ...optionalString2(value, "completedAt"),
+    ...optionalString2(value, "deletedAt"),
+    ...optionalString2(value, "deletedBy"),
+    ...optionalString2(value, "replyTo"),
+    ...optionalString2(value, "senderSessionId"),
+    ...optionalString2(value, "expiresAt"),
+    ...taskContext === void 0 ? {} : { taskContext }
+  };
+}
+function parseMailboxMessageLine(line) {
+  return parseMailboxMessage(JSON.parse(line));
+}
+function isAckRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && value["__ack"] === true;
+}
+function parseMailboxLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (isAckRecord(parsed)) return parsed;
+    return parseMailboxMessage(parsed);
+  } catch {
+    return null;
+  }
+}
+function applyAckToMessage(msg, ack) {
+  if (ack.read && !(ack.readerId in msg.readBy)) {
+    msg.readBy[ack.readerId] = ack.timestamp;
+  }
+  if (ack.completed && !msg.completed) {
+    msg.completed = true;
+    msg.completedBy = ack.completedBy ?? ack.readerId;
+    msg.completedAt = ack.timestamp;
+  }
+  if (ack.outcome !== void 0 && msg.outcome !== ack.outcome) {
+    msg.outcome = ack.outcome;
+  }
+  if (ack.deleted === true) {
+    msg.deletedAt = ack.timestamp;
+    msg.deletedBy = ack.deletedBy ?? ack.readerId;
+  }
+  if (ack.deleted === false) {
+    delete msg.deletedAt;
+    delete msg.deletedBy;
+  }
+}
+function serializeAckRecord(ack) {
+  return JSON.stringify(ack) + "\n";
+}
+
 // src/coordination/mailbox-types.ts
 function normalizeRecipient(to) {
   return to.trim().toLowerCase() === "all" ? "*" : to.trim();
@@ -13328,13 +14227,6 @@ function normalizeRecipient(to) {
 // src/coordination/global-mailbox.ts
 var MAILBOX_FILE = "_mailbox.jsonl";
 var CLIENT_REGISTRY_FILE = "_mailbox.clients.json";
-var AGENT_STALE_MS = 6e4;
-var AGENT_PURGE_MS = 864e5;
-var CLIENT_STALE_MS = 6e4;
-var HEARTBEAT_THROTTLE_MS = 5e3;
-var REGISTRY_CACHE_TTL_MS = 2e3;
-var LINE_SEPARATOR = "\n";
-var MESSAGE_CACHE_MAX_ENTRIES = 1e4;
 function resolveProjectDir(projectRoot, globalRoot) {
   return path14.join(globalRoot, "projects", projectSlug(projectRoot));
 }
@@ -13349,6 +14241,12 @@ var GlobalMailbox = class {
   _events;
   /** Optional HQ publisher for cross-project command-center telemetry. */
   _hqPublisher;
+  /**
+   * Optional SSE event emitter for real-time push to HTTP bridge clients.
+   * When present, `send`/`ack`/`softDelete`/`restore` emit events that
+   * connected SSE subscribers receive instantly.
+   */
+  eventEmitter;
   /**
    * Local cache of the agent registry to avoid re-reading on every call.
    * Time-bounded: the registry file is shared ACROSS PROCESSES (that's the
@@ -13391,20 +14289,47 @@ var GlobalMailbox = class {
    * appended message). The chain runs each read to completion before
    * the next starts, in issue order — readers are read-only and never
    * conflict with each other on content, only on the cache mutation
-   * that follows the read. Pattern mirrors `DefaultMemoryStore.runSerialized`.
+   * that follows the read. Pattern mirrors a serialized mutation chain.
    */
   _readChain = Promise.resolve([]);
+  /**
+   * Recipient → Set of indices into `_messageCache`. Maintained alongside
+   * the cache so `query({ to })` and `unreadCount(agentId)` can skip the
+   * O(N) full scan and iterate only the messages addressed to the target
+   * recipient (plus broadcasts `*`).
+   *
+   * The index is rebuilt whenever the cache array is replaced
+   * (`_setMessageCache`), extended when new messages are pushed
+   * (`_pushToCache`), and cleared on `close()`.
+   * It is `null` when the cache itself is null (> MESSAGE_CACHE_MAX_ENTRIES
+   * or never populated).
+   *
+   * Safety: array indices are valid only as long as the cache array
+   * reference hasn't changed. Since we rebuild the index in the same
+   * synchronous step that replaces the cache, a reader that calls
+   * `_readMessagesCached()` either gets the old array + old index, or
+   * the new array + new index — never a mismatch.
+   */
+  _recipientIndex = null;
+  /**
+   * Sender → Set of indices into `_messageCache`. Same lifecycle and
+   * safety properties as `_recipientIndex`, but keyed on `msg.from`
+   * so `query({ from })` can skip the full scan.
+   */
+  _senderIndex = null;
   /**
    * @param projectDir — `~/.wrongstack/projects/<slug>/`
    * @param events — optional EventBus for real-time TUI/WebUI notifications
    * @param hqPublisher — optional HQ publisher, or getter, for cross-project telemetry
+   * @param eventEmitter — optional SSE event emitter for HTTP bridge push
    */
-  constructor(projectDir, events, hqPublisher) {
+  constructor(projectDir, events, hqPublisher, eventEmitter) {
     this.messagePath = path14.join(projectDir, MAILBOX_FILE);
     this.registryPath = path14.join(projectDir, "_mailbox.registry.json");
     this.clientRegistryPath = path14.join(projectDir, CLIENT_REGISTRY_FILE);
     this._events = events;
     this._hqPublisher = hqPublisher;
+    this.eventEmitter = eventEmitter;
   }
   get hqMailboxId() {
     return `${path14.basename(path14.dirname(this.messagePath))}:mailbox`;
@@ -13433,7 +14358,7 @@ var GlobalMailbox = class {
       // "all" is an accepted spelling of the broadcast address — canonical
       // form on disk is '*' so every query/checker matches it.
       to: normalizeRecipient(input.to),
-      type: input.type,
+      type: normalizeMailboxMessageType(input.type),
       subject: input.subject,
       body: input.body,
       priority: input.priority ?? "normal",
@@ -13441,7 +14366,8 @@ var GlobalMailbox = class {
       completed: false,
       timestamp: now,
       replyTo: input.replyTo,
-      taskContext: input.taskContext
+      taskContext: input.taskContext,
+      expiresAt: input.ttlMs !== void 0 ? new Date(Date.now() + input.ttlMs).toISOString() : void 0
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR;
     await fsp11.mkdir(path14.dirname(this.messagePath), { recursive: true });
@@ -13456,21 +14382,49 @@ var GlobalMailbox = class {
       message: msg
     });
     this.publishHqMailboxSnapshot();
+    this._events?.emitCustom("mailbox.message_sent", {
+      messageId: msg.id,
+      from: msg.from,
+      to: msg.to,
+      type: msg.type,
+      subject: msg.subject
+    });
+    this.eventEmitter?.emit({
+      type: "message.sent",
+      messageId: msg.id,
+      from: msg.from,
+      to: msg.to,
+      timestamp: now
+    });
     return msg;
   }
   async query(q) {
+    const queryType = q.type === void 0 ? void 0 : normalizeMailboxMessageType(q.type);
     const all = await this._readMessagesCached();
     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 out = [];
-    for (let i = 0; i < all.length; i++) {
-      const m = all[i];
+    let candidates;
+    if (q.to !== void 0 && this._recipientIndex !== null && q.from === void 0 && q.type === void 0 && q.minPriority === void 0) {
+      const indices = /* @__PURE__ */ new Set();
+      const direct = this._recipientIndex.get(q.to);
+      if (direct !== void 0) for (const i of direct) indices.add(i);
+      const broadcasts = this._recipientIndex.get("*");
+      if (broadcasts !== void 0) for (const i of broadcasts) indices.add(i);
+      candidates = [...indices].sort((a, b) => a - b).map((i) => all[i]);
+    } else if (q.from !== void 0 && q.to === void 0 && this._senderIndex !== null && q.type === void 0 && q.minPriority === void 0) {
+      const indices = this._senderIndex.get(q.from);
+      candidates = indices !== void 0 ? [...indices].sort((a, b) => a - b).map((i) => all[i]) : [];
+    } else {
+      candidates = all;
+    }
+    for (const m of candidates) {
       if (q.to !== void 0 && m.to !== q.to && m.to !== "*") continue;
       if (q.from !== void 0 && m.from !== q.from) continue;
       if (q.unreadBy !== void 0 && q.unreadBy in m.readBy) continue;
       if (q.incompleteOnly && m.completed) continue;
-      if (q.type !== void 0 && m.type !== q.type) continue;
+      if (queryType !== void 0 && m.type !== queryType) continue;
       if (order !== null && (order[m.priority] ?? 1) < minPriorityRank) {
         continue;
       }
@@ -13485,42 +14439,100 @@ var GlobalMailbox = class {
     const updated = await this.ackMany({ acks: [input] });
     return updated.length > 0 ? updated[0] : null;
   }
+  /** Diagnostic counters exposed for test/tool introspection. */
+  diag = {
+    ackManyCacheDesync: 0,
+    ackManyPreLockMtime: 0,
+    ackManyPostLockMtime: 0,
+    ackManyPreLockSize: 0,
+    ackManyPostLockSize: 0,
+    ackManyMessageCount: 0,
+    ackManyAckCount: 0,
+    cacheHitCount: 0,
+    cacheMissCount: 0,
+    cacheDesyncNoOp: 0,
+    applyAckTargetMissing: 0,
+    setMessageCacheCount: 0,
+    pushToCacheCount: 0
+  };
   async ackMany(input) {
     if (input.acks.length === 0) return [];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const ackRecords = [];
     const updated = [];
+    const targetIds = /* @__PURE__ */ new Set();
     const byId = /* @__PURE__ */ new Map();
     for (const a of input.acks) {
       byId.set(a.messageId, a);
+      targetIds.add(a.messageId);
     }
-    await withFileLock(this.messagePath, async () => {
-      const all = await this._readMessagesFresh();
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      let changed = false;
-      for (const msg of all) {
-        const a = byId.get(msg.id);
-        if (!a) continue;
-        updated.push(msg);
-        if (a.read !== false && !(a.readerId in msg.readBy)) {
-          msg.readBy[a.readerId] = now;
-          changed = true;
-        }
-        if (a.completed && !msg.completed) {
-          msg.completed = true;
-          msg.completedBy = a.readerId;
-          msg.completedAt = now;
-          changed = true;
-        }
-        if (a.outcome !== void 0 && msg.outcome !== a.outcome) {
-          msg.outcome = a.outcome;
-          changed = true;
-        }
+    const preLockMtime = this._messageCacheMtime;
+    const preLockSize = this._messageCacheSize;
+    this.diag.ackManyPreLockMtime = preLockMtime;
+    this.diag.ackManyPreLockSize = preLockSize;
+    const all = await this._readMessagesCached();
+    for (const msg of all) {
+      const a = byId.get(msg.id);
+      if (!a) continue;
+      const needsRead = a.read !== false && !(a.readerId in msg.readBy);
+      const needsComplete = a.completed && !msg.completed;
+      const needsOutcome = a.outcome !== void 0 && msg.outcome !== a.outcome;
+      if (!needsRead && !needsComplete && !needsOutcome) {
+        updated.push({ ...msg, readBy: { ...msg.readBy } });
+        continue;
       }
-      if (changed) {
-        const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-        await fsp11.writeFile(this.messagePath, serialized, "utf8");
+      const copy = { ...msg, readBy: { ...msg.readBy } };
+      if (needsRead) copy.readBy[a.readerId] = now;
+      if (needsComplete) {
+        copy.completed = true;
+        copy.completedBy = a.readerId;
+        copy.completedAt = now;
+      }
+      if (needsOutcome) copy.outcome = a.outcome;
+      updated.push(copy);
+      ackRecords.push({
+        __ack: true,
+        messageId: msg.id,
+        readerId: a.readerId,
+        timestamp: now,
+        read: a.read !== false,
+        completed: a.completed,
+        completedBy: a.completed ? a.readerId : void 0,
+        outcome: a.outcome
+      });
+    }
+    if (ackRecords.length === 0) {
+      if (updated.length > 0) {
+        for (const message of updated) {
+          this.publishHqMailboxEvent({
+            mailboxId: this.hqMailboxId,
+            action: message.completed ? "message.completed" : "message.read",
+            message
+          });
+        }
       }
+      return updated;
+    }
+    const serialized = ackRecords.map((a) => serializeAckRecord(a)).join("");
+    await withFileLock(this.messagePath, async () => {
+      await fsp11.appendFile(this.messagePath, serialized, "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
-      this._setMessageCache(all, mtimeMs, size);
+      for (const ack of ackRecords) {
+        this._applyAckToCache(ack);
+      }
+      this._messageCacheMtime = mtimeMs;
+      this._messageCacheSize = size;
+      this.diag.ackManyPostLockMtime = mtimeMs;
+      this.diag.ackManyPostLockSize = size;
+      this.diag.ackManyMessageCount = this._messageCache?.length ?? -1;
+      this.diag.ackManyAckCount = ackRecords.length;
+      const expectedMinSize = preLockSize + serialized.length;
+      if (preLockSize > 0 && size > expectedMinSize) {
+        const extraBytes = size - expectedMinSize;
+        console.error(
+          `[MAILBOX-DIAG] ackMany: post-lock size ${size} exceeds expected ${expectedMinSize} by ${extraBytes}B (mtime ${preLockMtime}->${mtimeMs}). Cache may be missing cross-process messages. diag.ackManyCacheDesync=${++this.diag.ackManyCacheDesync}`
+        );
+      }
     });
     for (const message of updated) {
       this.publishHqMailboxEvent({
@@ -13528,6 +14540,13 @@ var GlobalMailbox = class {
         action: message.completed ? "message.completed" : "message.read",
         message
       });
+      this.eventEmitter?.emit({
+        type: "message.acked",
+        messageId: message.id,
+        from: message.from,
+        to: message.to,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
     }
     if (updated.length > 0) this.publishHqMailboxSnapshot();
     return updated;
@@ -13535,68 +14554,108 @@ var GlobalMailbox = class {
   async unreadCount(forAgentId) {
     const all = await this._readMessagesCached();
     let count = 0;
-    for (let i = 0; i < all.length; i++) {
-      const m = all[i];
-      if ((m.to === forAgentId || m.to === "*") && !(forAgentId in m.readBy) && !m.completed) {
-        count++;
+    if (this._recipientIndex !== null) {
+      const indices = /* @__PURE__ */ new Set();
+      const direct = this._recipientIndex.get(forAgentId);
+      if (direct !== void 0) for (const i of direct) indices.add(i);
+      const broadcasts = this._recipientIndex.get("*");
+      if (broadcasts !== void 0) for (const i of broadcasts) indices.add(i);
+      for (const i of indices) {
+        const m = all[i];
+        if (!(forAgentId in m.readBy) && !m.completed) count++;
+      }
+    } else {
+      for (let i = 0; i < all.length; i++) {
+        const m = all[i];
+        if ((m.to === forAgentId || m.to === "*") && !(forAgentId in m.readBy) && !m.completed) {
+          count++;
+        }
       }
     }
     return count;
   }
   async softDelete(mailId, by) {
-    let updated = null;
+    const all = await this._readMessagesCached();
+    const target = all.find((m) => m.id === mailId);
+    if (target === void 0) return null;
+    if (target.deletedAt !== void 0) {
+      return { ...target, readBy: { ...target.readBy } };
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const ack = {
+      __ack: true,
+      messageId: mailId,
+      readerId: by,
+      timestamp: now,
+      read: true,
+      deleted: true,
+      deletedBy: by
+    };
     await withFileLock(this.messagePath, async () => {
-      const all = await this._readMessagesFresh();
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      for (const m of all) {
-        if (m.id !== mailId) continue;
-        if (m.deletedAt !== void 0) {
-          updated = m;
-          continue;
-        }
-        m.deletedAt = now;
-        m.deletedBy = by;
-        updated = m;
-      }
-      const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-      await fsp11.writeFile(this.messagePath, serialized, "utf8");
+      await fsp11.appendFile(this.messagePath, serializeAckRecord(ack), "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
-      this._setMessageCache(all, mtimeMs, size);
+      this._applyAckToCache(ack);
+      this._messageCacheMtime = mtimeMs;
+      this._messageCacheSize = size;
     });
-    if (updated !== null) {
-      this.publishHqMailboxEvent({
-        mailboxId: this.hqMailboxId,
-        action: "message.updated",
-        message: updated
-      });
-      this.publishHqMailboxSnapshot();
-    }
-    return updated;
+    const msg = { ...target, readBy: { ...target.readBy } };
+    msg.deletedAt = now;
+    msg.deletedBy = by;
+    this.publishHqMailboxEvent({
+      mailboxId: this.hqMailboxId,
+      action: "message.updated",
+      message: msg
+    });
+    this.publishHqMailboxSnapshot();
+    this.eventEmitter?.emit({
+      type: "message.deleted",
+      messageId: msg.id,
+      from: msg.from,
+      to: msg.to,
+      timestamp: msg.deletedAt ?? now
+    });
+    return msg;
   }
   async restore(mailId) {
-    let updated = null;
+    const all = await this._readMessagesCached();
+    const target = all.find((m) => m.id === mailId);
+    if (target === void 0) return null;
+    if (target.deletedAt === void 0 && target.deletedBy === void 0) {
+      return { ...target, readBy: { ...target.readBy } };
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const ack = {
+      __ack: true,
+      messageId: mailId,
+      readerId: "",
+      timestamp: now,
+      read: true,
+      deleted: false
+    };
     await withFileLock(this.messagePath, async () => {
-      const all = await this._readMessagesFresh();
-      for (const m of all) {
-        if (m.id !== mailId) continue;
-        delete m.deletedAt;
-        delete m.deletedBy;
-        updated = m;
-      }
-      const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-      await fsp11.writeFile(this.messagePath, serialized, "utf8");
+      await fsp11.appendFile(this.messagePath, serializeAckRecord(ack), "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
-      this._setMessageCache(all, mtimeMs, size);
+      this._applyAckToCache(ack);
+      this._messageCacheMtime = mtimeMs;
+      this._messageCacheSize = size;
+    });
+    const msg = { ...target, readBy: { ...target.readBy } };
+    delete msg.deletedAt;
+    delete msg.deletedBy;
+    this.publishHqMailboxEvent({
+      mailboxId: this.hqMailboxId,
+      action: "message.updated",
+      message: msg
     });
-    if (updated !== null) {
-      this.publishHqMailboxEvent({
-        mailboxId: this.hqMailboxId,
-        action: "message.updated",
-        message: updated
-      });
-      this.publishHqMailboxSnapshot();
-    }
-    return updated;
+    this.publishHqMailboxSnapshot();
+    this.eventEmitter?.emit({
+      type: "message.restored",
+      messageId: msg.id,
+      from: msg.from,
+      to: msg.to,
+      timestamp: now
+    });
+    return msg;
   }
   // ── Agent registry ──────────────────────────────────────────────────────
   async registerAgent(input) {
@@ -13727,8 +14786,19 @@ var GlobalMailbox = class {
   }
   async getAgentStatuses() {
     await this._ensureRegistry();
-    const registry = await this._readRegistry();
+    let registry = await this._readRegistry();
+    const before = registry.size;
     this._pruneStaleInPlace(registry);
+    if (registry.size < before) {
+      await withFileLock(this.registryPath, async () => {
+        const fresh = await this._readRegistry({ fresh: true });
+        this._pruneStaleInPlace(fresh);
+        this._registryCache = fresh;
+        this._registryCacheAt = Date.now();
+        await this._writeRegistry(fresh);
+        registry = fresh;
+      });
+    }
     const now = Date.now();
     return Array.from(registry.values()).map((a) => ({
       agentId: a.agentId,
@@ -13780,6 +14850,20 @@ var GlobalMailbox = class {
     });
     this.publishHqMailboxSnapshot();
   }
+  async deregisterClient(clientId) {
+    await this._ensureClientRegistry();
+    await withFileLock(this.clientRegistryPath, async () => {
+      const registry = await this._readClientRegistry({ fresh: true });
+      this._pruneStaleClientsInPlace(registry);
+      registry.delete(clientId);
+      this._clientRegistryCache = registry;
+      this._clientRegistryCacheAt = Date.now();
+      await this._writeClientRegistry(registry);
+    });
+    this._lastClientHeartbeat.delete(clientId);
+    this._events?.emitCustom("mailbox.client_deregistered", { clientId });
+    this.publishHqMailboxSnapshot();
+  }
   async clientHeartbeat(input) {
     const last = this._lastClientHeartbeat.get(input.clientId) ?? 0;
     const now = Date.now();
@@ -13808,8 +14892,19 @@ var GlobalMailbox = class {
   }
   async getClientStatuses() {
     await this._ensureClientRegistry();
-    const registry = await this._readClientRegistry();
+    let registry = await this._readClientRegistry();
+    const before = registry.size;
     this._pruneStaleClientsInPlace(registry);
+    if (registry.size < before) {
+      await withFileLock(this.clientRegistryPath, async () => {
+        registry = await this._readClientRegistry({ fresh: true });
+        const postLockBefore = registry.size;
+        this._pruneStaleClientsInPlace(registry);
+        if (registry.size < postLockBefore) {
+          await this._writeClientRegistry(registry);
+        }
+      });
+    }
     const now = Date.now();
     return Array.from(registry.values()).map((c) => ({
       clientId: c.clientId,
@@ -13821,6 +14916,32 @@ var GlobalMailbox = class {
       pid: c.pid
     })).sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
   }
+  /**
+   * Explicitly purge stale clients from the registry and write back to disk.
+   * Removes client entries whose lastSeenAt is older than CLIENT_STALE_MS.
+   * Returns the number of entries purged.
+   *
+   * Idempotent — safe to call regularly. The same pruning runs implicitly
+   * inside registerClient, clientHeartbeat, and getClientStatuses, but if
+   * no client registers or heartbeats for a long time, this public method
+   * ensures the file gets cleaned up on demand.
+   */
+  async purgeClients() {
+    await this._ensureClientRegistry();
+    let purged = 0;
+    await withFileLock(this.clientRegistryPath, async () => {
+      const registry = await this._readClientRegistry({ fresh: true });
+      const before = registry.size;
+      this._pruneStaleClientsInPlace(registry);
+      purged = before - registry.size;
+      if (purged > 0) {
+        this._clientRegistryCache = registry;
+        this._clientRegistryCacheAt = Date.now();
+        await this._writeClientRegistry(registry);
+      }
+    });
+    return purged;
+  }
   // ── Lifecycle ───────────────────────────────────────────────────────────
   async close() {
     this._registryCache = null;
@@ -13828,6 +14949,8 @@ var GlobalMailbox = class {
     this._messageCache = null;
     this._messageCacheMtime = -1;
     this._messageCacheSize = -1;
+    this._recipientIndex = null;
+    this._senderIndex = null;
   }
   async clearAll() {
     await withFileLock(this.messagePath, async () => {
@@ -13876,6 +14999,100 @@ var GlobalMailbox = class {
       remaining
     };
   }
+  // ── Auto-compaction ─────────────────────────────────────────────────────
+  _autoCompactTimer = null;
+  async autoCompact(opts) {
+    const readMaxAgeMs = opts?.readMaxAgeMs ?? AUTO_COMPACT_READ_MAX_AGE_MS;
+    const defaultTtlMs = opts?.defaultTtlMs ?? AUTO_COMPACT_DEFAULT_TTL_MS;
+    const completedMaxAgeMs = opts?.completedMaxAgeMs ?? 864e5;
+    const incompleteMaxAgeMs = opts?.incompleteMaxAgeMs ?? 6048e5;
+    let expiredPurged = 0;
+    let readByAllPurged = 0;
+    let completedPurged = 0;
+    let incompletePurged = 0;
+    let remaining = 0;
+    let onlineAgentIds = null;
+    try {
+      const statuses = await this.getAgentStatuses();
+      const online = statuses.filter((s) => s.online);
+      onlineAgentIds = online.length > 0 ? new Set(online.map((s) => s.agentId)) : null;
+    } catch {
+      onlineAgentIds = null;
+    }
+    await withFileLock(this.messagePath, async () => {
+      const all = await this._readMessagesFresh();
+      const now = Date.now();
+      const cutoffReadAge = now - readMaxAgeMs;
+      const cutoffCompleted = now - completedMaxAgeMs;
+      const cutoffIncomplete = now - incompleteMaxAgeMs;
+      const cutoffDefaultTtl = now - defaultTtlMs;
+      const kept = [];
+      for (const msg of all) {
+        const msgTime = new Date(msg.timestamp).getTime();
+        if (msg.expiresAt !== void 0) {
+          if (new Date(msg.expiresAt).getTime() < now) {
+            expiredPurged++;
+            continue;
+          }
+        } else if (msgTime < cutoffDefaultTtl) {
+          expiredPurged++;
+          continue;
+        }
+        if (onlineAgentIds !== null && !msg.completed) {
+          const readByAll = onlineAgentIds.size > 0 && [...onlineAgentIds].every((id) => id in msg.readBy);
+          if (readByAll) {
+            const readTimes = Object.values(msg.readBy).map((t) => new Date(t).getTime());
+            const latestRead = Math.max(...readTimes);
+            if (latestRead < cutoffReadAge) {
+              readByAllPurged++;
+              continue;
+            }
+          }
+        }
+        const completedTime = msg.completedAt ? new Date(msg.completedAt).getTime() : 0;
+        if (msg.completed && completedTime < cutoffCompleted) {
+          completedPurged++;
+          continue;
+        }
+        if (!msg.completed && msgTime < cutoffIncomplete) {
+          incompletePurged++;
+          continue;
+        }
+        kept.push(msg);
+      }
+      remaining = kept.length;
+      if (kept.length < all.length) {
+        const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
+        await fsp11.writeFile(this.messagePath, content, "utf8");
+      }
+      const { mtimeMs, size } = await this._statMessageFile();
+      this._setMessageCache(kept, mtimeMs, size);
+    });
+    const totalRemoved = expiredPurged + readByAllPurged + completedPurged + incompletePurged;
+    return {
+      expiredRemoved: expiredPurged,
+      readByAllRemoved: readByAllPurged,
+      stalePurged: completedPurged + incompletePurged,
+      totalRemoved,
+      remaining
+    };
+  }
+  startAutoCompactTimer(opts) {
+    if (this._autoCompactTimer !== null) {
+      clearInterval(this._autoCompactTimer);
+    }
+    const intervalMs = opts?.intervalMs ?? AUTO_COMPACT_INTERVAL_MS;
+    const timer = setInterval(() => {
+      this.autoCompact(opts).catch(() => {
+      });
+    }, intervalMs);
+    timer.unref?.();
+    this._autoCompactTimer = timer;
+    return () => {
+      clearInterval(timer);
+      this._autoCompactTimer = null;
+    };
+  }
   // ── Internal ────────────────────────────────────────────────────────────
   /**
    * Read all messages from the JSONL file. Always reads + parses the file.
@@ -13892,61 +15109,23 @@ var GlobalMailbox = class {
       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_SEPARATOR)) {
-      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. */
+  /** Parse a JSONL string into MailboxMessage[], applying ack records. */
   _parseLines(raw) {
     const lines = raw.split(LINE_SEPARATOR).filter((l) => l.trim().length > 0);
     const messages = [];
+    const acks = [];
     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"];
-        }
+      const parsed = parseMailboxLine(line);
+      if (isAckRecord(parsed)) {
+        acks.push(parsed);
+      } else if (parsed !== null) {
         messages.push(parsed);
-      } catch {
       }
     }
+    for (const ack of acks) {
+      const target = messages.find((m) => m.id === ack.messageId);
+      if (target) applyAckToMessage(target, ack);
+    }
     return messages;
   }
   /**
@@ -14028,17 +15207,6 @@ 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 fsp11.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;
@@ -14070,11 +15238,61 @@ var GlobalMailbox = class {
       this._messageCache = null;
       this._messageCacheMtime = -1;
       this._messageCacheSize = -1;
+      this._recipientIndex = null;
+      this._senderIndex = null;
       return;
     }
     this._messageCache = messages;
     this._messageCacheMtime = mtime;
     this._messageCacheSize = size;
+    this._rebuildRecipientIndex();
+  }
+  /**
+   * Fold a single ack record into the in-memory cache, mutating the target
+   * message in place. Called from `ackMany` after appending the record to
+   * disk so the cache reflects the ack without a full re-read + re-parse.
+   *
+   * An ack only touches `readBy`/`completed*`/`outcome` — none of which
+   * affect the recipient/sender indexes — so no index rebuild is needed.
+   * No-op when the cache is empty or the target message isn't cached.
+   */
+  _applyAckToCache(ack) {
+    const cache = this._messageCache;
+    if (cache === null) return;
+    const target = cache.find((m) => m.id === ack.messageId);
+    if (target !== void 0) applyAckToMessage(target, ack);
+  }
+  /**
+   * Build the recipient AND sender indexes from the current `_messageCache`.
+   * Called only from `_setMessageCache` so both indexes are always in sync
+   * with a freshly-replaced cache array.
+   */
+  _rebuildRecipientIndex() {
+    const cache = this._messageCache;
+    if (cache === null) {
+      this._recipientIndex = null;
+      this._senderIndex = null;
+      return;
+    }
+    const recIdx = /* @__PURE__ */ new Map();
+    const sndIdx = /* @__PURE__ */ new Map();
+    for (let i = 0; i < cache.length; i++) {
+      const msg = cache[i];
+      let rSet = recIdx.get(msg.to);
+      if (rSet === void 0) {
+        rSet = /* @__PURE__ */ new Set();
+        recIdx.set(msg.to, rSet);
+      }
+      rSet.add(i);
+      let sSet = sndIdx.get(msg.from);
+      if (sSet === void 0) {
+        sSet = /* @__PURE__ */ new Set();
+        sndIdx.set(msg.from, sSet);
+      }
+      sSet.add(i);
+    }
+    this._recipientIndex = recIdx;
+    this._senderIndex = sndIdx;
   }
   /**
    * Append a single just-sent message to the in-memory cache without
@@ -14101,6 +15319,23 @@ var GlobalMailbox = class {
       return;
     }
     this._messageCache.push(msg);
+    const newIdx = this._messageCache.length - 1;
+    if (this._recipientIndex !== null) {
+      let set = this._recipientIndex.get(msg.to);
+      if (set === void 0) {
+        set = /* @__PURE__ */ new Set();
+        this._recipientIndex.set(msg.to, set);
+      }
+      set.add(newIdx);
+    }
+    if (this._senderIndex !== null) {
+      let set = this._senderIndex.get(msg.from);
+      if (set === void 0) {
+        set = /* @__PURE__ */ new Set();
+        this._senderIndex.set(msg.from, set);
+      }
+      set.add(newIdx);
+    }
     this._messageCacheMtime = mtime;
     this._messageCacheSize = size;
   }
@@ -14132,22 +15367,13 @@ var GlobalMailbox = class {
     }
   }
   _pruneStaleInPlace(registry) {
-    const staleCutoff = Date.now() - AGENT_STALE_MS;
-    const purgeCutoff = Date.now() - AGENT_PURGE_MS;
-    const toDelete = [];
+    const cutoff = Date.now() - AGENT_STALE_MS;
     for (const [id, agent] of registry) {
-      const lastSeen = new Date(agent.lastSeenAt).getTime();
-      if (lastSeen < purgeCutoff) {
-        toDelete.push(id);
-        continue;
-      }
-      if (lastSeen < staleCutoff) {
-        agent.status = "idle";
+      const lastSeen = Date.parse(agent.lastSeenAt);
+      if (!Number.isFinite(lastSeen) || lastSeen < cutoff) {
+        registry.delete(id);
       }
     }
-    for (const id of toDelete) {
-      registry.delete(id);
-    }
   }
   async _writeRegistry(registry) {
     const obj = {};
@@ -14188,9 +15414,10 @@ var GlobalMailbox = class {
   }
   _pruneStaleClientsInPlace(registry) {
     const cutoff = Date.now() - CLIENT_STALE_MS;
-    for (const client of registry.values()) {
-      if (new Date(client.lastSeenAt).getTime() < cutoff) {
-        client.lastSeenAt = new Date(cutoff).toISOString();
+    for (const [id, client] of registry) {
+      const lastSeen = Date.parse(client.lastSeenAt);
+      if (!Number.isFinite(lastSeen) || lastSeen < cutoff) {
+        registry.delete(id);
       }
     }
   }
@@ -14248,7 +15475,7 @@ function makeMailboxTool(opts = {}) {
           description: "Which mailbox operation to perform."
         },
         to: { type: "string", description: "Recipient agent id, or '*' / 'all' for broadcast." },
-        type: { type: "string", enum: ["note", "ask", "assign", "steer", "btw", "broadcast", "status", "result", "review"], description: "Message type." },
+        type: { type: "string", enum: ["note", "ask", "assign", "steer", "btw", "broadcast", "status", "result", "review", "control"], description: "Message type." },
         subject: { type: "string", description: "Short subject line." },
         body: { type: "string", description: "Full message content." },
         priority: { type: "string", enum: ["low", "normal", "high"] },
@@ -14490,7 +15717,7 @@ function makeFleetStatusTool(opts = {}) {
   const resolveMailbox = opts.resolveMailbox ?? ((ctx) => new GlobalMailbox(opts.projectDir ?? defaultResolveProjectDir(ctx), opts.events));
   return {
     name: "fleet_status",
-    description: "Live snapshot of every agent working on this project (this process AND other terminals/TUIs/WebUIs): who is online, what task each is on, which tool is running, and progress counters. Check it before starting work that might overlap with a peer, when deciding whether to wait for someone or proceed, or when a task mentions another agent. Read-only. To talk to a peer, use mail_send with the returned id.",
+    description: "Live snapshot of every agent working on this canonical project (all clients, processes, sessions, branches, and linked Git worktrees): who is online, what task each is on, which tool is running, and progress counters. Check it before starting work that might overlap with a peer, when deciding whether to wait for someone or proceed, or when a task mentions another agent. Read-only. To talk to a peer, use mail_send with the returned id.",
     usageHint: "fleet_status  (optionally: onlineOnly=false to include recently-offline agents)",
     category: "Coordination",
     permission: "auto",
@@ -15154,7 +16381,7 @@ function makeMailSendTool(opts = {}) {
   const resolveMailbox = makeResolver(opts);
   return {
     name: "mail_send",
-    description: 'Send a mail to other agents working on this project (other terminals, TUIs, WebUIs). Use it to hand off work, ask questions, announce what you just did, or request a review (type="review" \u2014 passive ask, no immediate reply required). to="*" broadcasts to everyone; to="leader" reaches every leader process; an exact id like "leader@a1b2c3d4" reaches one agent. Recipients see your mail automatically before their next step. Pick the type that matches the intent: note (default), ask (blocking question), assign (task), steer (mid-task direction), result (completion notice), review (passive ask), btw/status/broadcast/control (informational).',
+    description: 'Send mail to any agent on this canonical project, across clients, processes, sessions, branches, and linked Git worktrees (CLI, TUI, WebUI, ACP/MCP/HTTP). Use it to hand off work, ask questions, announce what you just did, or request a review (type="review" \u2014 passive ask, no immediate reply required). to="*" broadcasts to everyone; to="leader" reaches every leader process; an exact id like "leader@a1b2c3d4" reaches one agent. Recipients see your mail automatically before their next step. Pick the type that matches the intent: note (default), ask (blocking question), assign (task), steer (mid-task direction), result (completion notice), review (passive ask), btw/status/broadcast/control (informational).',
     usageHint: 'mail_send to="<id>" type="review" body="please skim <file>"',
     category: "Coordination",
     permission: "auto",
@@ -15214,7 +16441,7 @@ function makeMailInboxTool(opts = {}) {
   const resolveMailbox = makeResolver(opts);
   return {
     name: "mail_inbox",
-    description: 'Read your unread mail from other agents on this project and mark it read. Covers mail addressed to you directly, to your base name (e.g. "leader"), and broadcasts ("*"). Urgent steer/btw mail is already injected automatically \u2014 use this to catch up on notes, questions, handoffs, results, and review requests (type="review" \u2014 passive asks where no reply is required). Best called after a long stretch of tool work. Set completed=true to finish every returned message in the same call.',
+    description: 'Read your unread project-wide mail from agents in any client, session, branch, or linked Git worktree and mark it read. Covers mail addressed to you directly, to your base name (e.g. "leader"), and broadcasts ("*"). Urgent steer/btw mail is already injected automatically \u2014 use this to catch up on notes, questions, handoffs, results, and review requests (type="review" \u2014 passive asks where no reply is required). Best called after a long stretch of tool work. Set completed=true to finish every returned message in the same call.',
     usageHint: 'mail_inbox  (optionally: limit=10, markRead=false to peek, completed=true outcome="handled")',
     category: "Coordination",
     permission: "auto",
@@ -15302,14 +16529,18 @@ var DefaultMailbox = class {
   _messageCache = null;
   _messageCacheMtime = -1;
   _messageCacheSize = -1;
+  /** True when the cache is only the newest MESSAGE_CACHE_MAX_ENTRIES records. */
+  _messageCacheTruncated = false;
   /** 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();
   /** Counts malformed JSONL lines skipped during parsing for observability. */
   _corruptionCount = 0;
-  constructor(sessionDir) {
+  logger;
+  constructor(sessionDir, opts) {
     this.filePath = path15.join(sessionDir, MAILBOX_FILE2);
+    this.logger = opts?.logger;
   }
   get mailboxPath() {
     return this.filePath;
@@ -15327,7 +16558,7 @@ var DefaultMailbox = class {
       // "all" is an accepted spelling of the broadcast address — canonical
       // form on disk is '*' so every query/checker matches it.
       to: normalizeRecipient(input.to),
-      type: input.type,
+      type: normalizeMailboxMessageType(input.type),
       subject: input.subject,
       body: input.body,
       priority: input.priority ?? "normal",
@@ -15350,12 +16581,14 @@ var DefaultMailbox = class {
   }
   // ── Query ─────────────────────────────────────────────────────────────
   async query(q) {
+    const queryType = q.type === void 0 ? void 0 : normalizeMailboxMessageType(q.type);
     const needFullScan = q.unreadBy !== void 0 || q.since !== void 0;
+    const cached = await this._readAllCached(false);
     let candidates;
+    let candidatesComplete = !this._messageCacheTruncated || cached !== this._messageCache;
     if (needFullScan) {
-      candidates = await this._readAllCached();
+      candidates = cached;
     } else {
-      await this._readAllCached();
       if (q.to !== void 0) {
         const direct = this._byTo.get(q.to);
         const broadcast = this._byTo.get("*");
@@ -15363,10 +16596,12 @@ var DefaultMailbox = class {
         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());
+        candidatesComplete = !this._messageCacheTruncated;
       } else if (q.from !== void 0) {
         candidates = Array.from(this._byFrom.get(q.from) ?? []);
+        candidatesComplete = !this._messageCacheTruncated;
       } else {
-        candidates = await this._readAllCached();
+        candidates = cached;
       }
     }
     const limit = q.limit ?? 50;
@@ -15377,27 +16612,37 @@ var DefaultMailbox = class {
       if (q.from !== void 0 && msg.from !== q.from) return false;
       if (q.unreadBy !== void 0 && q.unreadBy in msg.readBy) return false;
       if (q.incompleteOnly && msg.completed) return false;
-      if (q.type !== void 0 && msg.type !== q.type) return false;
+      if (queryType !== void 0 && msg.type !== queryType) return false;
       if (order !== null && (order[msg.priority] ?? 1) < minPriorityRank)
         return false;
       if (q.since !== void 0 && msg.timestamp <= q.since) return false;
       return true;
     };
-    if (order === null) {
+    const selectNewest = (source) => {
       const out = [];
-      for (let i = candidates.length - 1; i >= 0 && out.length < limit; i--) {
-        const msg = candidates[i];
+      for (let i = source.length - 1; i >= 0 && out.length < limit; i--) {
+        const msg = source[i];
         if (passes(msg)) out.push(msg);
       }
       return out;
-    }
-    const filtered = [];
-    for (let i = candidates.length - 1; i >= 0; i--) {
-      const msg = candidates[i];
-      if (passes(msg)) filtered.push(msg);
-    }
-    filtered.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-    return filtered.slice(0, limit);
+    };
+    if (order === null) {
+      const out = selectNewest(candidates);
+      if (out.length >= limit || candidatesComplete) return out;
+      return selectNewest(await this._readAll());
+    }
+    const selectByPriority = (source) => {
+      const filtered2 = [];
+      for (let i = source.length - 1; i >= 0; i--) {
+        const msg = source[i];
+        if (passes(msg)) filtered2.push(msg);
+      }
+      filtered2.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+      return filtered2.slice(0, limit);
+    };
+    const filtered = selectByPriority(candidates);
+    if (filtered.length >= limit || candidatesComplete) return filtered;
+    return selectByPriority(await this._readAll());
   }
   // ── Ack ───────────────────────────────────────────────────────────────
   async ack(input) {
@@ -15454,7 +16699,7 @@ var DefaultMailbox = class {
     for (const m of all) {
       if (m.type !== "status") continue;
       const existing = latest.get(m.from);
-      if (existing && m.timestamp <= existing.lastActivityAt) continue;
+      if (existing && m.timestamp < existing.lastActivityAt) continue;
       latest.set(m.from, {
         agentId: m.from,
         name: m.taskContext?.agentName ?? m.from,
@@ -15496,6 +16741,7 @@ var DefaultMailbox = class {
     this._messageCache = null;
     this._messageCacheMtime = -1;
     this._messageCacheSize = -1;
+    this._messageCacheTruncated = false;
     this._byTo.clear();
     this._byFrom.clear();
   }
@@ -15547,13 +16793,32 @@ var DefaultMailbox = class {
     };
   }
   // ── Client registry stubs (not applicable per-session) ─────────────────
+  async autoCompact(_opts) {
+    const purged = await this.purgeStale(_opts);
+    return {
+      readByAllRemoved: 0,
+      expiredRemoved: 0,
+      stalePurged: purged.totalPurged,
+      totalRemoved: purged.totalPurged,
+      remaining: purged.remaining
+    };
+  }
+  startAutoCompactTimer(_opts) {
+    return () => {
+    };
+  }
   async registerClient(_input) {
   }
   async clientHeartbeat(_input) {
   }
+  async deregisterClient(_clientId) {
+  }
   async getClientStatuses() {
     return [];
   }
+  async purgeClients() {
+    return 0;
+  }
   // ── Internal ──────────────────────────────────────────────────────────
   async _readAll() {
     try {
@@ -15567,60 +16832,62 @@ var DefaultMailbox = class {
   /**
    * 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.
+   *
+   * Guards against a half-written tail: when the tail doesn't end with
+   * LINE_SEPARATOR, another process may be mid-append. Parsing a partial
+   * JSON line would throw (caught below), but worse: the NEXT incremental
+   * read would skip that same line because the size tracker already advanced.
    */
   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 (!tail.endsWith(LINE_SEPARATOR2)) {
+      const lastSeparatorIdx = tail.lastIndexOf(LINE_SEPARATOR2);
+      if (lastSeparatorIdx === -1) {
+        return this._messageCache;
+      }
+      const completeTail = tail.slice(0, lastSeparatorIdx + 1);
+      this._appendIncrementalLines(completeTail);
+      this._messageCacheSize = oldSize + lastSeparatorIdx + 1;
+      return this._messageCache;
+    }
+    this._appendIncrementalLines(tail);
+    this._messageCacheSize = newSize;
+    return this._messageCache;
+  }
+  _appendIncrementalLines(raw) {
+    for (const line of raw.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"] ?? "unknown"] = parsed["readAt"];
-          }
-          parsed["readBy"] = readBy;
-          delete parsed["read"];
-          delete parsed["readAt"];
-        }
-        const msg = parsed;
-        this._messageCache.push(msg);
-        this._indexMsg(msg);
-      } catch (err) {
-        this._corruptionCount++;
-        console.debug(
-          `[mailbox] skipped malformed line during incremental read: ${err.message}`
+      const msg = this._parseLine(line, "incremental read");
+      if (msg === null) continue;
+      this._pushToCache(msg);
+    }
+  }
+  _parseLine(line, source) {
+    try {
+      return parseMailboxMessageLine(line);
+    } catch (err) {
+      this._corruptionCount++;
+      if (this.logger) {
+        this.logger.debug(
+          "Skipped malformed mailbox line",
+          { source, error: err.message, corruptionCount: this._corruptionCount }
         );
+      } else {
+        console.debug(`[mailbox] skipped malformed line during ${source}: ${err.message}`);
       }
+      return null;
     }
-    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"] ?? "unknown"] = parsed["readAt"];
-          }
-          parsed["readBy"] = readBy;
-          delete parsed["read"];
-          delete parsed["readAt"];
-        }
-        messages.push(parsed);
-      } catch (err) {
-        this._corruptionCount++;
-        console.debug(
-          `[mailbox] skipped malformed line during full parse: ${err.message}`
-        );
-      }
+      const message = this._parseLine(line, "full parse");
+      if (message !== null) messages.push(message);
     }
     return messages;
   }
@@ -15641,10 +16908,11 @@ var DefaultMailbox = class {
       throw err;
     }
   }
-  async _readAllCached() {
+  async _readAllCached(requireComplete = true) {
     try {
       const st = await fsp12.stat(this.filePath);
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
+        if (requireComplete && this._messageCacheTruncated) return this._readAll();
         return this._messageCache;
       }
       if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
@@ -15652,7 +16920,7 @@ var DefaultMailbox = class {
         try {
           const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
           this._messageCacheMtime = st.mtimeMs;
-          this._messageCacheSize = st.size;
+          if (requireComplete && this._messageCacheTruncated) return this._readAll();
           return updated;
         } finally {
           await fd.close();
@@ -15670,28 +16938,18 @@ var DefaultMailbox = class {
     }
   }
   _setMessageCache(messages, mtime, size) {
-    if (messages.length > MESSAGE_CACHE_MAX_ENTRIES2) {
-      this._messageCache = null;
-      this._messageCacheMtime = -1;
-      this._messageCacheSize = -1;
-      this._byTo.clear();
-      this._byFrom.clear();
-      return;
-    }
-    this._messageCache = messages;
-    this._buildIndexes(messages);
+    this._messageCacheTruncated = messages.length > MESSAGE_CACHE_MAX_ENTRIES2;
+    this._messageCache = this._messageCacheTruncated ? messages.slice(-MESSAGE_CACHE_MAX_ENTRIES2) : messages;
+    this._buildIndexes(this._messageCache);
     this._messageCacheMtime = mtime;
     this._messageCacheSize = size;
   }
   _pushToCache(msg) {
     if (this._messageCache === null) return;
     if (this._messageCache.length >= MESSAGE_CACHE_MAX_ENTRIES2) {
-      this._messageCache = null;
-      this._messageCacheMtime = -1;
-      this._messageCacheSize = -1;
-      this._byTo.clear();
-      this._byFrom.clear();
-      return;
+      const evicted = this._messageCache.shift();
+      if (evicted !== void 0) this._unindexMsg(evicted);
+      this._messageCacheTruncated = true;
     }
     this._messageCache.push(msg);
     this._indexMsg(msg);
@@ -15719,6 +16977,15 @@ var DefaultMailbox = class {
       this._byFrom.set(msg.from, /* @__PURE__ */ new Set([msg]));
     }
   }
+  /** Remove an evicted message from both indexes without rebuilding them. */
+  _unindexMsg(msg) {
+    const toSet = this._byTo.get(msg.to);
+    toSet?.delete(msg);
+    if (toSet?.size === 0) this._byTo.delete(msg.to);
+    const fromSet = this._byFrom.get(msg.from);
+    fromSet?.delete(msg);
+    if (fromSet?.size === 0) this._byFrom.delete(msg.from);
+  }
 };
 
 // src/coordination/mailbox-actions.ts
@@ -15989,7 +17256,7 @@ function createMailboxHooks(opts) {
 var NULL_FLEET_BUS = new FleetBus();
 
 // src/coordination/package-author-tracker.ts
-import * as fs2 from "node:fs/promises";
+import * as fs3 from "node:fs/promises";
 import * as path16 from "node:path";
 var DEFAULT_MAX_ENTRIES = 1e4;
 var LOG_FILENAME = "package-authors.json";
@@ -15998,7 +17265,7 @@ function logPath(storageDir) {
 }
 async function loadLog(storageDir, projectRoot) {
   try {
-    const raw = await fs2.readFile(logPath(storageDir), "utf-8");
+    const raw = await fs3.readFile(logPath(storageDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.entries || !Array.isArray(parsed.entries)) {
       return { projectRoot, entries: [] };
@@ -16012,13 +17279,13 @@ async function loadLog(storageDir, projectRoot) {
   }
 }
 async function saveLog(storageDir, log) {
-  await fs2.mkdir(storageDir, { recursive: true });
+  await fs3.mkdir(storageDir, { recursive: true });
   const tmp = `${logPath(storageDir)}.tmp.${Date.now()}`;
-  await fs2.writeFile(tmp, JSON.stringify(log, null, 2) + "\n", "utf-8");
-  await fs2.rename(tmp, logPath(storageDir));
+  await fs3.writeFile(tmp, JSON.stringify(log, null, 2) + "\n", "utf-8");
+  await fs3.rename(tmp, logPath(storageDir));
 }
 function detectEcosystem(manifestPath) {
-  const name = path16.basename(manifestPath).toLowerCase();
+  const name = path16.win32.basename(manifestPath).toLowerCase();
   if (name === "package.json") return "npm";
   if (name === "go.mod") return "go";
   if (name === "cargo.toml") return "cargo";
@@ -16381,7 +17648,8 @@ function isProcessAlive(pid) {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
-      return /\b"?,?\d+,?"?/.test(out) || out.includes(String(pid));
+      const match = /(?:^|\n)"[^"]*","(\d+)"/.exec(out);
+      return match !== null && match[1] === String(pid);
     } catch {
       return false;
     }
@@ -16584,9 +17852,9 @@ var AdaptiveConcurrencyController = class {
 };
 
 // src/coordination/agent-monitor.ts
-import * as fs3 from "node:fs/promises";
+import * as fs4 from "node:fs/promises";
 import * as path18 from "node:path";
-var AgentMonitorService = class {
+var AgentMonitorService = class _AgentMonitorService {
   _fleetBus;
   _events;
   _sessionId;
@@ -16596,6 +17864,15 @@ var AgentMonitorService = class {
   _onEntry;
   /** Per-subagent virtual sessions. */
   _sessions = /* @__PURE__ */ new Map();
+  /**
+   * Per-subagent OPEN streaming segment. Provider text/thinking deltas
+   * arrive word-by-word; writing one transcript entry per delta fragments
+   * every surface (ring, JSONL, HQ) into unreadable single-word lines.
+   * Instead, consecutive same-kind/same-iteration deltas append into ONE
+   * entry that is already in the ring (live views see it grow in place);
+   * the JSONL line is written once, when the segment closes.
+   */
+  _openStreams = /* @__PURE__ */ new Map();
   /** Disposers for FleetBus subscriptions, keyed by subagentId. */
   _subscriptions = /* @__PURE__ */ new Map();
   /** Generic fleet-wide subscription disposer. */
@@ -16658,6 +17935,9 @@ var AgentMonitorService = class {
   stop() {
     if (!this._started) return;
     this._started = false;
+    for (const subagentId of [...this._openStreams.keys()]) {
+      this._closeStream(subagentId);
+    }
     if (this._fleetDisposer) {
       this._fleetDisposer();
       this._fleetDisposer = void 0;
@@ -16726,6 +18006,7 @@ var AgentMonitorService = class {
   }
   /** Drop a retired subagent from every live in-memory monitor surface. */
   removeSubagent(subagentId) {
+    this._closeStream(subagentId);
     this._sessions.delete(subagentId);
     const dispose = this._subscriptions.get(subagentId);
     if (dispose) dispose();
@@ -16739,31 +18020,13 @@ var AgentMonitorService = class {
       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
-        });
+        this._appendStreamDelta(subagentId, session, "text", text, payload.iteration ?? 0);
         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: "thinking",
-          content: text,
-          iteration
-        });
+        this._appendStreamDelta(subagentId, session, "thinking", text, payload.iteration ?? 0);
         break;
       }
       case "tool.started": {
@@ -16820,15 +18083,66 @@ var AgentMonitorService = class {
       }
     }
   }
+  /** Max characters accumulated into one streaming segment before rolling over. */
+  static _MAX_SEGMENT_CHARS = 2e4;
+  /**
+   * Fold a provider text/thinking delta into the subagent's open streaming
+   * segment, or open a new one. A segment breaks on kind change, iteration
+   * change, size cap, or any non-delta entry (see `_addEntry`). The entry
+   * is pushed to the ring when the segment OPENS (live views poll the ring
+   * and watch it grow in place); the JSONL line AND the timeline/HQ
+   * announcement happen once, on close, with the COMPLETE segment — so
+   * downstream consumers get one whole message instead of a word-per-event
+   * firehose (or, worse, only the first word).
+   */
+  _appendStreamDelta(subagentId, session, kind, text, iteration) {
+    const open6 = this._openStreams.get(subagentId);
+    if (open6 && open6.entry.kind === kind && open6.entry.iteration === iteration && open6.entry.content.length + text.length <= _AgentMonitorService._MAX_SEGMENT_CHARS) {
+      open6.entry.content += text;
+      return;
+    }
+    this._closeStream(subagentId);
+    const entry = {
+      id: this._uid(),
+      subagentId,
+      agentName: session.agentName,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      kind,
+      content: text,
+      iteration
+    };
+    this._openStreams.set(subagentId, { entry });
+    session.transcript.push(entry);
+    if (session.transcript.length > this._maxEntries) {
+      session.transcript.splice(0, session.transcript.length - this._maxEntries);
+    }
+  }
+  /**
+   * Close the subagent's open streaming segment: persist it to JSONL and
+   * announce the completed entry on the local bus + HQ callback.
+   */
+  _closeStream(subagentId) {
+    const open6 = this._openStreams.get(subagentId);
+    if (!open6) return;
+    this._openStreams.delete(subagentId);
+    this._appendToFile(subagentId, open6.entry).catch(() => {
+    });
+    this._emitEntry(open6.entry);
+  }
   _addEntry(subagentId, entry) {
     const session = this._sessions.get(subagentId);
     if (!session) return;
+    this._closeStream(subagentId);
     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._emitEntry(entry);
+  }
+  /** Announce a transcript entry on the local bus + HQ callback. */
+  _emitEntry(entry) {
     this._events.emit("agent.timeline.message", {
       sessionId: this._sessionId,
       subagentId: entry.subagentId,
@@ -16844,10 +18158,10 @@ var AgentMonitorService = class {
   }
   async _appendToFile(subagentId, entry) {
     const dir = path18.join(this._transcriptsDir, subagentId);
-    await fs3.mkdir(dir, { recursive: true });
+    await fs4.mkdir(dir, { recursive: true });
     const filePath = path18.join(dir, "transcript.jsonl");
     const line = JSON.stringify(entry) + "\n";
-    await fs3.appendFile(filePath, line, { encoding: "utf8" });
+    await fs4.appendFile(filePath, line, { encoding: "utf8" });
   }
   _uid() {
     return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
@@ -16855,8 +18169,11 @@ var AgentMonitorService = class {
   _formatToolUse(name, input) {
     if (input === void 0) return `${name}()`;
     const body = this._stringifyForTimeline(input);
-    return body ? `${name}
-${body}` : `${name}()`;
+    if (!body) return `${name}()`;
+    const inline = body.replace(/\s+/g, " ").trim();
+    const head = inline.length <= 160 ? `${name}(${inline})` : `${name}(${inline.slice(0, 159)}\u2026)`;
+    return `${head}
+${body}`;
   }
   _formatToolResult(summary, output, outputBytes) {
     if (!output) return summary;
@@ -16893,8 +18210,6 @@ var AutonomousBrain = class {
   maxRetries;
   consensusRiskThreshold;
   selfImprove;
-  /** Decision history for self-improvement and audit. */
-  decisionHistory = [];
   /** Tracks failure patterns for self-improvement. */
   failurePatterns = /* @__PURE__ */ new Map();
   RISK_ORDER = ["low", "medium", "high", "critical"];
@@ -17206,7 +18521,6 @@ ${ctx.error}`);
       madeAt: (/* @__PURE__ */ new Date()).toISOString(),
       context: input.context
     });
-    this.decisionHistory.push(node);
     return node;
   }
   _inferRoles(task) {
@@ -17235,7 +18549,8 @@ import { randomUUID as randomUUID16 } from "node:crypto";
 import { randomUUID as randomUUID14 } from "node:crypto";
 import * as fsp14 from "node:fs/promises";
 import * as path19 from "node:path";
-var KnowledgeGraph = class {
+var DEFAULT_MAX_NODES = 2e3;
+var KnowledgeGraph = class _KnowledgeGraph {
   nodes = /* @__PURE__ */ new Map();
   index = /* @__PURE__ */ new Map();
   // tag/field → node ids
@@ -17243,6 +18558,7 @@ var KnowledgeGraph = class {
   pendingDeliveries = /* @__PURE__ */ new Map();
   filePath;
   graphFilePath;
+  maxNodes;
   /**
    * Stable per-node insertion sequence. `nodes` (a Map) preserves insertion
    * order even across `update()` (Map.set on an existing key keeps its slot),
@@ -17261,9 +18577,10 @@ var KnowledgeGraph = class {
   getIndex() {
     return this.index;
   }
-  constructor(sessionDir) {
+  constructor(sessionDir, maxNodes = DEFAULT_MAX_NODES) {
     this.filePath = path19.join(sessionDir, "_knowledge_graph");
     this.graphFilePath = path19.join(this.filePath, "graph.jsonl");
+    this.maxNodes = maxNodes;
   }
   // ── Write ──────────────────────────────────────────────────────────────
   /**
@@ -17275,6 +18592,7 @@ var KnowledgeGraph = class {
     this.nodes.set(full.id, full);
     this._trackSeq(full.id);
     this._addToIndex(full, this._indexKeys(full));
+    this._prune();
     await this._persist(full);
     this._deliver(full);
     return full;
@@ -17287,10 +18605,48 @@ var KnowledgeGraph = class {
     const updated = { ...existing, ...patch };
     this.nodes.set(id, updated);
     this._addToIndex(updated, this._indexKeys(updated));
+    this._prune();
     this._deliver(updated);
     await this._append(updated);
     return updated;
   }
+  /**
+   * True when the node is in a terminal / settled state — no future mutations
+   * are expected. Such nodes are the first to be evicted when the in-memory
+   * cap is reached. The JSONL file on disk retains the full history.
+   */
+  static _isTerminal(node) {
+    if (node.type === "goal") return node.status === "done" || node.status === "failed";
+    if (node.type === "change") return node.status === "rejected" || node.status === "rolled_back";
+    if (node.type === "vote") return true;
+    return false;
+  }
+  /**
+   * Evict oldest terminal-state nodes when the in-memory cap is exceeded.
+   * The JSONL file is the authoritative record; eviction only affects memory.
+   */
+  _prune() {
+    if (this.nodes.size <= this.maxNodes) return;
+    const toEvict = this.nodes.size - this.maxNodes;
+    const terminal = [];
+    for (const [id, node] of this.nodes) {
+      if (_KnowledgeGraph._isTerminal(node)) terminal.push({ id, seq: this.seq.get(id) ?? 0 });
+    }
+    terminal.sort((a, b) => a.seq - b.seq);
+    const evicted = new Set(terminal.slice(0, toEvict).map((e) => e.id));
+    if (evicted.size === 0) return;
+    for (const id of evicted) {
+      const node = this.nodes.get(id);
+      if (!node) continue;
+      this._removeFromIndex(node, this._indexKeys(node));
+      this.nodes.delete(id);
+      this.seq.delete(id);
+      for (const pending of this.pendingDeliveries.values()) {
+        const idx = pending.findIndex((n) => n.id === id);
+        if (idx >= 0) pending.splice(idx, 1);
+      }
+    }
+  }
   // ── Read ───────────────────────────────────────────────────────────────
   get(id) {
     return this.nodes.get(id);
@@ -18723,6 +20079,7 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
   mailbox;
   events;
   onCoordinatorEvent;
+  logger;
   running = false;
   iterationCount = 0;
   lastSyncAt = 0;
@@ -18739,6 +20096,7 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
     this.mailbox = opts.mailbox ?? void 0;
     this.events = opts.events ?? void 0;
     this.onCoordinatorEvent = opts.onCoordinatorEvent;
+    this.logger = opts.logger;
     this.graph = new KnowledgeGraph(opts.sessionDir);
     this.dag = new TaskDAG();
     this.auction = new TaskAuctioneer({
@@ -18897,15 +20255,22 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
   stop() {
     if (!this.running) return;
     this.running = false;
-    console.error(
-      JSON.stringify({
-        level: "error",
-        event: "autonomous_coordinator.stop_signal",
-        message: "stop signal received \u2014 shutting down",
-        iteration: this.iterationCount,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })
-    );
+    if (this.logger) {
+      this.logger.error(
+        "Stop signal received \u2014 shutting down",
+        { event: "autonomous_coordinator.stop_signal", iteration: this.iterationCount }
+      );
+    } else {
+      console.error(
+        JSON.stringify({
+          level: "error",
+          event: "autonomous_coordinator.stop_signal",
+          message: "stop signal received \u2014 shutting down",
+          iteration: this.iterationCount,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
   }
   /**
    * Report that a terminal worker (not a Director subagent) completed a claimed
@@ -19353,6 +20718,7 @@ export {
   AutonomousCoordinator,
   BUG_HUNTER_AGENT,
   BUILD_AGENTS,
+  BrainDecisionLedger,
   BrainDecisionQueue,
   BrainMonitor,
   BudgetExceededError,
@@ -19375,6 +20741,7 @@ export {
   DefaultMultiAgentCoordinator,
   Director,
   DirectorAlertLevel,
+  EscalationRoutingBrainArbiter,
   FLEET_ROSTER,
   FLEET_ROSTER_BUDGETS,
   FLEET_ROSTER_WITHACP,
@@ -19424,12 +20791,14 @@ export {
   applyRosterBudget,
   attachAutoExtend,
   attachDepWatcherBridge,
+  brainDecisionKey,
   buildDownAlert,
   buildRecoveryAlert,
   composeDirectorPrompt,
   composeSubagentPrompt,
   createAgentMonitorService,
   createDelegateTool,
+  createLedgerGuardBrainArbiter,
   createMailboxHooks,
   createMessage,
   detectEcosystem,
@@ -19493,6 +20862,7 @@ export {
   scoreAgents,
   startPackageOutdatedWatcher,
   subagentNeedsWorktree,
+  terminalPolicyDecision,
   updatePackageOutdatedStatus,
   validateWatchdogOptions,
   withDisabledToolFiltering,