@wrongstack/core 0.285.0 → 0.286.0

package/dist/coordination/index.js

@@ -329,9 +329,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) {
@@ -1417,9 +1425,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 +1437,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 +1452,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 +1463,7 @@ Files examined: ${files}`,
     `
 Suggested next steps:
 ${next}`
-  ].join("\n");
+  ].filter((line) => typeof line === "string").join("\n");
 }
 function makeSubagentResultTool() {
   return {
@@ -1489,6 +1503,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 +1542,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;
 }
@@ -3458,7 +3485,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 +3507,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 +3622,341 @@ 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 dirname3 } 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(dirname3(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;
   start() {
     this.unsubscribers.push(
       this.opts.events.on("tool.executed", (e) => {
+        this.lastProgressAt = Date.now();
+        this.trackFileChurn(e.name, e.ok, e.input);
         if (e.ok) {
           this.failStreaks.delete(e.name);
           return;
@@ -3592,6 +3976,38 @@ var BrainMonitor = class {
         }
       })
     );
+    if (this.stallMs > 0) {
+      this.unsubscribers.push(
+        this.opts.events.on("agent.run.started", () => {
+          this.activeRuns += 1;
+          this.lastProgressAt = Date.now();
+        }),
+        this.opts.events.on("agent.run.completed", () => {
+          this.activeRuns = Math.max(0, this.activeRuns - 1);
+        }),
+        this.opts.events.on("agent.run.error", () => {
+          this.activeRuns = Math.max(0, this.activeRuns - 1);
+        }),
+        this.opts.events.on("iteration.started", () => {
+          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 now = Date.now();
@@ -3616,6 +4032,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,58 +4869,27 @@ 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])
@@ -4485,7 +4901,7 @@ var FLEET_ROSTER_BUDGETS = {
   "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 },
+  critic: { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
   "shadow-agent": {
     idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
     maxIterations: 2e3,
@@ -4522,41 +4938,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 +4950,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,7 +4965,7 @@ 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",
@@ -4635,16 +5024,23 @@ function createDelegateTool(opts) {
         type: "number",
         minimum: 0,
         description: "Maximum estimated USD cost the subagent may incur. Unset = use the role/coordinator default."
+      },
+      maxHandoffs: {
+        type: "number",
+        minimum: 0,
+        maximum: 8,
+        description: "Maximum fresh-worker continuations after partial completion or budget exhaustion. Default 1; set 0 to disable. Each successor receives the prior structured/partial report and is told to continue only the remaining work."
       }
     },
     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 discrete piece of work to a dedicated subagent and wait for its result. The subagent has its own context, its own LLM call, and a generous, auto-extending budget. If it reports explicit partial completion or still exhausts a recoverable budget, delegate can continue the remaining work with a fresh subagent (bounded by `maxHandoffs`, default 1). Workers may ask the leader to spawn a parallel helper through the mailbox, but cannot recursively spawn agents themselves. Use specialized roster roles when possible; otherwise pass `name` + `task`. Call multiple delegates in parallel through the provider's parallel-tool-call surface for independent work.",
+    usageHint: "Set `task` to a complete instruction. Either pick `role` from the roster or pass `name` for a free-form coding agent. Defaults are intentionally generous; override `timeoutMs`, `maxIterations`, `maxToolCalls`, or `maxHandoffs` only when the task warrants it. Returns the final TaskResult plus a `handoffs` history when fresh workers continued partial work. Requires Director mode in normal CLI sessions.",
     permission: "auto",
     mutating: false,
+    managesOwnTimeout: true,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema,
     async execute(input, _ctx, execOpts) {
@@ -4684,7 +5080,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 +5119,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);
-          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
-          });
-          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
-          };
-        }
-        if ("__emptyResult" 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: "empty_result",
-            summary: `[${target}] completed without a task result`,
-            durationMs: 0,
-            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: "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
+            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
           };
         }
-        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 +5310,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 +5592,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;
   }
@@ -9011,7 +9503,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 +9514,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;
@@ -9271,7 +9763,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;
           }
@@ -9799,6 +10291,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 +10493,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 +10544,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;
@@ -11634,6 +12136,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 +12162,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 +12275,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 +12409,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 +13033,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";
@@ -13320,6 +13828,148 @@ 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));
+}
+
 // src/coordination/mailbox-types.ts
 function normalizeRecipient(to) {
   return to.trim().toLowerCase() === "all" ? "*" : to.trim();
@@ -13328,13 +13978,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 +13992,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
@@ -13394,17 +14043,44 @@ var GlobalMailbox = class {
    * that follows the read. Pattern mirrors `DefaultMemoryStore.runSerialized`.
    */
   _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`, `_readNewMessagesOnly`), 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 +14109,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 +14117,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 +14133,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;
       }
@@ -13528,6 +14233,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,10 +14247,22 @@ 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;
@@ -13548,6 +14272,7 @@ var GlobalMailbox = class {
     await withFileLock(this.messagePath, async () => {
       const all = await this._readMessagesFresh();
       const now = (/* @__PURE__ */ new Date()).toISOString();
+      let changed = false;
       for (const m of all) {
         if (m.id !== mailId) continue;
         if (m.deletedAt !== void 0) {
@@ -13557,19 +14282,30 @@ var GlobalMailbox = class {
         m.deletedAt = now;
         m.deletedBy = by;
         updated = m;
+        changed = true;
+      }
+      if (changed) {
+        const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
+        await fsp11.writeFile(this.messagePath, serialized, "utf8");
       }
-      const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-      await fsp11.writeFile(this.messagePath, serialized, "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
       this._setMessageCache(all, mtimeMs, size);
     });
     if (updated !== null) {
+      const msg = updated;
       this.publishHqMailboxEvent({
         mailboxId: this.hqMailboxId,
         action: "message.updated",
-        message: updated
+        message: msg
       });
       this.publishHqMailboxSnapshot();
+      this.eventEmitter?.emit({
+        type: "message.deleted",
+        messageId: msg.id,
+        from: msg.from,
+        to: msg.to,
+        timestamp: msg.deletedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      });
     }
     return updated;
   }
@@ -13577,24 +14313,40 @@ var GlobalMailbox = class {
     let updated = null;
     await withFileLock(this.messagePath, async () => {
       const all = await this._readMessagesFresh();
+      let changed = false;
       for (const m of all) {
         if (m.id !== mailId) continue;
+        if (m.deletedAt === void 0 && m.deletedBy === void 0) {
+          updated = m;
+          continue;
+        }
         delete m.deletedAt;
         delete m.deletedBy;
         updated = m;
+        changed = true;
+      }
+      if (changed) {
+        const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
+        await fsp11.writeFile(this.messagePath, serialized, "utf8");
       }
-      const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-      await fsp11.writeFile(this.messagePath, serialized, "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
       this._setMessageCache(all, mtimeMs, size);
     });
     if (updated !== null) {
+      const msg = updated;
       this.publishHqMailboxEvent({
         mailboxId: this.hqMailboxId,
         action: "message.updated",
-        message: updated
+        message: msg
       });
       this.publishHqMailboxSnapshot();
+      this.eventEmitter?.emit({
+        type: "message.restored",
+        messageId: msg.id,
+        from: msg.from,
+        to: msg.to,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
     }
     return updated;
   }
@@ -13727,8 +14479,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 +14543,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();
@@ -13809,7 +14586,11 @@ var GlobalMailbox = class {
   async getClientStatuses() {
     await this._ensureClientRegistry();
     const registry = await this._readClientRegistry();
+    const before = registry.size;
     this._pruneStaleClientsInPlace(registry);
+    if (registry.size < before) {
+      await this._writeClientRegistry(registry);
+    }
     const now = Date.now();
     return Array.from(registry.values()).map((c) => ({
       clientId: c.clientId,
@@ -13821,6 +14602,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 +14635,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 +14685,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.
@@ -13908,44 +14811,59 @@ var GlobalMailbox = class {
     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 (!tail.endsWith(LINE_SEPARATOR)) {
+      const lastSeparatorIdx = tail.lastIndexOf(LINE_SEPARATOR);
+      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_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"];
+      const message = this._parseLine(line);
+      if (message === null) continue;
+      this._messageCache.push(message);
+      const idx = this._messageCache.length - 1;
+      if (this._recipientIndex !== null) {
+        let set = this._recipientIndex.get(message.to);
+        if (set === void 0) {
+          set = /* @__PURE__ */ new Set();
+          this._recipientIndex.set(message.to, set);
         }
-        this._messageCache.push(parsed);
-      } catch {
+        set.add(idx);
+      }
+      if (this._senderIndex !== null) {
+        let set = this._senderIndex.get(message.from);
+        if (set === void 0) {
+          set = /* @__PURE__ */ new Set();
+          this._senderIndex.set(message.from, set);
+        }
+        set.add(idx);
       }
     }
-    return this._messageCache;
+  }
+  _parseLine(line) {
+    try {
+      return parseMailboxMessageLine(line);
+    } catch {
+      return null;
+    }
   }
   /** Parse a JSONL string into MailboxMessage[], including migration. */
   _parseLines(raw) {
     const lines = raw.split(LINE_SEPARATOR).filter((l) => l.trim().length > 0);
     const messages = [];
     for (const line of lines) {
-      try {
-        const parsed = JSON.parse(line);
-        if (!parsed["readBy"]) {
-          const readBy = {};
-          if (parsed["read"] && parsed["readAt"]) {
-            readBy[parsed["to"]] = parsed["readAt"];
-          }
-          parsed["readBy"] = readBy;
-          delete parsed["read"];
-          delete parsed["readAt"];
-        }
-        messages.push(parsed);
-      } catch {
-      }
+      const message = this._parseLine(line);
+      if (message !== null) messages.push(message);
     }
     return messages;
   }
@@ -14033,7 +14951,6 @@ var GlobalMailbox = class {
         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();
@@ -14070,11 +14987,46 @@ 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();
+  }
+  /**
+   * 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 +15053,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,21 +15101,12 @@ 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;
+      const lastSeen = Date.parse(agent.lastSeenAt);
+      if (!Number.isFinite(lastSeen) || lastSeen < cutoff) {
+        registry.delete(id);
       }
-      if (lastSeen < staleCutoff) {
-        agent.status = "idle";
-      }
-    }
-    for (const id of toDelete) {
-      registry.delete(id);
     }
   }
   async _writeRegistry(registry) {
@@ -14188,9 +15148,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 +15209,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"] },
@@ -15302,14 +16263,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 +16292,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 +16315,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 +16330,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 +16346,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 +16433,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 +16475,7 @@ var DefaultMailbox = class {
     this._messageCache = null;
     this._messageCacheMtime = -1;
     this._messageCacheSize = -1;
+    this._messageCacheTruncated = false;
     this._byTo.clear();
     this._byFrom.clear();
   }
@@ -15547,13 +16527,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 +16566,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 +16642,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 +16654,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 +16672,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 +16711,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
@@ -16018,7 +17019,7 @@ async function saveLog(storageDir, log) {
   await fs2.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 +17382,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;
     }
@@ -16586,7 +17588,7 @@ var AdaptiveConcurrencyController = class {
 // src/coordination/agent-monitor.ts
 import * as fs3 from "node:fs/promises";
 import * as path18 from "node:path";
-var AgentMonitorService = class {
+var AgentMonitorService = class _AgentMonitorService {
   _fleetBus;
   _events;
   _sessionId;
@@ -16596,6 +17598,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 +17669,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 +17740,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 +17754,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 +17817,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 open7 = this._openStreams.get(subagentId);
+    if (open7 && open7.entry.kind === kind && open7.entry.iteration === iteration && open7.entry.content.length + text.length <= _AgentMonitorService._MAX_SEGMENT_CHARS) {
+      open7.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 open7 = this._openStreams.get(subagentId);
+    if (!open7) return;
+    this._openStreams.delete(subagentId);
+    this._appendToFile(subagentId, open7.entry).catch(() => {
+    });
+    this._emitEntry(open7.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,
@@ -16855,8 +17903,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 +17944,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 +18255,6 @@ ${ctx.error}`);
       madeAt: (/* @__PURE__ */ new Date()).toISOString(),
       context: input.context
     });
-    this.decisionHistory.push(node);
     return node;
   }
   _inferRoles(task) {
@@ -17235,7 +18283,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 +18292,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 +18311,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 +18326,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 +18339,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 +19813,7 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
   mailbox;
   events;
   onCoordinatorEvent;
+  logger;
   running = false;
   iterationCount = 0;
   lastSyncAt = 0;
@@ -18739,6 +19830,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 +19989,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 +20452,7 @@ export {
   AutonomousCoordinator,
   BUG_HUNTER_AGENT,
   BUILD_AGENTS,
+  BrainDecisionLedger,
   BrainDecisionQueue,
   BrainMonitor,
   BudgetExceededError,
@@ -19375,6 +20475,7 @@ export {
   DefaultMultiAgentCoordinator,
   Director,
   DirectorAlertLevel,
+  EscalationRoutingBrainArbiter,
   FLEET_ROSTER,
   FLEET_ROSTER_BUDGETS,
   FLEET_ROSTER_WITHACP,
@@ -19424,12 +20525,14 @@ export {
   applyRosterBudget,
   attachAutoExtend,
   attachDepWatcherBridge,
+  brainDecisionKey,
   buildDownAlert,
   buildRecoveryAlert,
   composeDirectorPrompt,
   composeSubagentPrompt,
   createAgentMonitorService,
   createDelegateTool,
+  createLedgerGuardBrainArbiter,
   createMailboxHooks,
   createMessage,
   detectEcosystem,
@@ -19493,6 +20596,7 @@ export {
   scoreAgents,
   startPackageOutdatedWatcher,
   subagentNeedsWorktree,
+  terminalPolicyDecision,
   updatePackageOutdatedStatus,
   validateWatchdogOptions,
   withDisabledToolFiltering,