@wrongstack/core 0.284.1 → 0.286.0

package/dist/coordination/index.js

@@ -1,29 +1,22 @@
-import { randomUUID, createHash, randomBytes } from 'crypto';
-import * as fsp9 from 'fs/promises';
-import * as path9 from 'path';
-import { isAbsolute, resolve } from 'path';
-import * as os from 'os';
-import { hostname } from 'os';
-import { readFileSync, statSync, createReadStream, openSync, writeSync, fsyncSync, closeSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { EventEmitter } from 'events';
-import { listReadyTasks, claimReadyTask, updateTaskAssignment } from '@wrongstack/kanban';
-import { createInterface } from 'readline';
-import { execFileSync, spawn } from 'child_process';
-
 // src/coordination/agent-bridge.ts
+import { randomUUID } from "node:crypto";
+
+// src/utils/atomic-write.ts
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path9.dirname(targetPath);
-  await fsp9.mkdir(dir, { recursive: true });
-  const tmp = path9.join(dir, `.${path9.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const dir = path.dirname(targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = path.join(dir, `.${path.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
-      await fsp9.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+      await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
     } else {
-      await fsp9.writeFile(tmp, content, { flag: "wx" });
+      await fs.writeFile(tmp, content, { flag: "wx" });
     }
     try {
-      const fh = await fsp9.open(tmp, "r+");
+      const fh = await fs.open(tmp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -33,56 +26,56 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat9 = await fsp9.stat(targetPath);
+      const stat9 = await fs.stat(targetPath);
       mode = stat9.mode & 511;
     } catch {
       mode = opts.mode;
     }
     if (mode !== void 0) {
-      await fsp9.chmod(tmp, mode);
+      await fs.chmod(tmp, mode);
     }
     await renameWithRetry(tmp, targetPath);
     if (mode !== void 0 && process.platform === "win32") {
       try {
-        await fsp9.chmod(targetPath, mode);
+        await fs.chmod(targetPath, mode);
       } catch {
       }
     }
   } catch (err) {
     try {
-      await fsp9.unlink(tmp);
+      await fs.unlink(tmp);
     } catch {
     }
     throw err;
   }
 }
 async function ensureDir(dir) {
-  await fsp9.mkdir(dir, { recursive: true });
+  await fs.mkdir(dir, { recursive: true });
 }
 async function withFileLock(targetPath, fn, opts = {}) {
-  const dir = path9.dirname(targetPath);
-  await fsp9.mkdir(dir, { recursive: true });
-  const lockPath = path9.join(dir, `.${path9.basename(targetPath)}.lock`);
+  const dir = path.dirname(targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const lockPath = path.join(dir, `.${path.basename(targetPath)}.lock`);
   const timeoutMs = opts.timeoutMs ?? 5e3;
   const staleMs = opts.staleMs ?? 3e4;
   const started = Date.now();
   let handle;
   for (; ; ) {
     try {
-      handle = await fsp9.open(lockPath, "wx");
+      handle = await fs.open(lockPath, "wx");
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
-        await fsp9.mkdir(dir, { recursive: true });
+        await fs.mkdir(dir, { recursive: true });
         continue;
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat9 = await fsp9.stat(lockPath);
+        const stat9 = await fs.stat(lockPath);
         if (Date.now() - stat9.mtimeMs > staleMs) {
-          await fsp9.unlink(lockPath);
+          await fs.unlink(lockPath);
           continue;
         }
       } catch {
@@ -107,7 +100,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
     } catch {
     }
     try {
-      await fsp9.unlink(lockPath);
+      await fs.unlink(lockPath);
     } catch {
     }
   }
@@ -115,14 +108,14 @@ async function withFileLock(targetPath, fn, opts = {}) {
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
-    await fsp9.rename(from, to);
+    await fs.rename(from, to);
     return;
   }
   const delays = [10, 25, 60, 120, 250];
   let lastErr;
   for (let i = 0; i <= delays.length; i++) {
     try {
-      await fsp9.rename(from, to);
+      await fs.rename(from, to);
       return;
     } catch (err) {
       lastErr = err;
@@ -210,8 +203,9 @@ function sanitizeNodeOptions(value) {
   }
   return kept.join(" ");
 }
+var gitIdentity = null;
 function buildChildEnv(optsOrSessionId) {
-  const opts = {};
+  const opts = typeof optsOrSessionId === "string" ? { sessionId: optsOrSessionId } : optsOrSessionId ?? {};
   const hasOwn = Object.hasOwn(process.env, "WRONGSTACK_CHILD_ENV_PASSTHROUGH");
   const legacyHasOwn = Object.hasOwn(process.env, "WRONGSTACK_BASH_ENV_PASSTHROUGH");
   const passthrough = hasOwn && process.env["WRONGSTACK_CHILD_ENV_PASSTHROUGH"] === "1" || legacyHasOwn && process.env["WRONGSTACK_BASH_ENV_PASSTHROUGH"] === "1";
@@ -249,6 +243,16 @@ function buildChildEnv(optsOrSessionId) {
       out[k] = v;
     }
   }
+  if (gitIdentity) {
+    if (gitIdentity.name) {
+      out["GIT_AUTHOR_NAME"] = gitIdentity.name;
+      out["GIT_COMMITTER_NAME"] = gitIdentity.name;
+    }
+    if (gitIdentity.email) {
+      out["GIT_AUTHOR_EMAIL"] = gitIdentity.email;
+      out["GIT_COMMITTER_EMAIL"] = gitIdentity.email;
+    }
+  }
   if (opts.extra) {
     Object.assign(out, opts.extra);
   }
@@ -264,12 +268,16 @@ function toErrorMessage(err) {
 // src/utils/expect-defined.ts
 function expectDefined(value, label) {
   if (value === null || value === void 0) {
-    const err = new Error("Expected value to be defined");
+    const err = new Error(label ? `Expected ${label} to be defined` : "Expected value to be defined");
     err.name = "ExpectDefinedError";
     throw err;
   }
   return value;
 }
+
+// src/utils/glob-expand.ts
+import * as fsp from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
 var GLOB_CHARS = /* @__PURE__ */ new Set(["*", "?", "["]);
 var IS_WINDOWS = process.platform === "win32";
 var SEP = IS_WINDOWS ? "\\" : "/";
@@ -321,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) {
@@ -335,7 +351,7 @@ async function expandGlob(pattern) {
   async function walk(dir, pat) {
     let entries;
     try {
-      entries = await fsp9.readdir(dir);
+      entries = await fsp.readdir(dir);
     } catch {
       return;
     }
@@ -357,7 +373,7 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat9 = await fsp9.stat(full);
+          const stat9 = await fsp.stat(full);
           if (stat9.isDirectory()) await walk(full, rest);
         } catch {
         }
@@ -375,7 +391,7 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat9 = await fsp9.stat(full);
+          const stat9 = await fsp.stat(full);
           if (stat9.isDirectory()) await walk(full, rest);
         } catch {
         }
@@ -513,13 +529,16 @@ function safeStringify(value, pretty = false) {
     });
   }
 }
+
+// src/utils/session-scoped-path.ts
+import * as path2 from "node:path";
 function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
     throw invalid(sessionId);
   }
-  const resolved = path9.resolve(dir, `${sessionId}${suffix}`);
-  const rel = path9.relative(path9.resolve(dir), resolved);
-  if (rel.startsWith("..") || path9.isAbsolute(rel)) {
+  const resolved = path2.resolve(dir, `${sessionId}${suffix}`);
+  const rel = path2.relative(path2.resolve(dir), resolved);
+  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
     throw invalid(sessionId);
   }
   return resolved;
@@ -532,6 +551,9 @@ function invalid(sessionId) {
     context: { reason: "path_traversal" }
   });
 }
+
+// src/utils/ulid.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
 var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var ENCODING_LEN = ENCODING.length;
 var TIME_LEN = 10;
@@ -547,7 +569,7 @@ function encodeTime(now, len) {
   return str;
 }
 function encodeRandom(len) {
-  const bytes = randomBytes(len);
+  const bytes = randomBytes2(len);
   let str = "";
   for (let i = 0; i < len; i++) {
     str += ENCODING[bytes[i] % ENCODING_LEN];
@@ -562,9 +584,14 @@ function ulid(seedTime = Date.now()) {
 function truncate(s, max) {
   return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
 }
+
+// src/utils/wstack-paths.ts
+import { createHash } from "node:crypto";
+import * as os from "node:os";
+import * as path3 from "node:path";
 function projectSlug(absRoot) {
-  const base = slugify(path9.basename(absRoot));
-  const hash = createHash("sha256").update(path9.resolve(absRoot)).digest("hex").slice(0, 6);
+  const base = slugify(path3.basename(absRoot));
+  const hash = createHash("sha256").update(path3.resolve(absRoot)).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify(name) {
@@ -572,8 +599,8 @@ function slugify(name) {
 }
 function wstackGlobalRoot() {
   const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path9.resolve(fromEnv);
-  return path9.join(os.homedir(), ".wrongstack");
+  if (fromEnv && fromEnv.trim().length > 0) return path3.resolve(fromEnv);
+  return path3.join(os.homedir(), ".wrongstack");
 }
 
 // src/types/errors.ts
@@ -586,13 +613,53 @@ var ERROR_CODES = {
   PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
   PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
   PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
+  // Tool
+  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
+  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
+  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
+  TOOL_TIMEOUT: "TOOL_TIMEOUT",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+  // Config
+  CONFIG_INVALID: "CONFIG_INVALID",
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
+  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
+  // Plugin
+  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
+  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
+  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
   // Agent
   AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
   AGENT_ABORTED: "AGENT_ABORTED",
   AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // Session
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_CORRUPTED: "SESSION_CORRUPTED",
+  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
+  // Container / Registry
+  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
+  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
+  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
+  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
+  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  REGISTRY_INVALID: "REGISTRY_INVALID",
   // File system
   FS_READ_FAILED: "FS_READ_FAILED",
-  FS_DELETE_FAILED: "FS_DELETE_FAILED"};
+  FS_WRITE_FAILED: "FS_WRITE_FAILED",
+  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
+  FS_DELETE_FAILED: "FS_DELETE_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
+  // SDD (Spec-Driven Development)
+  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
+  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
+  SDD_INVALID_STATE: "SDD_INVALID_STATE",
+  SDD_NOT_READY: "SDD_NOT_READY",
+  // General
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  PARSE_FAILED: "PARSE_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
 var WrongStackError = class extends Error {
   code;
   subsystem;
@@ -1271,10 +1338,30 @@ var ToolCapabilities = {
   SHELL_RESTRICTED: "shell.restricted",
   /** Can run a restricted project formatter/linter-style command. */
   SHELL_EXEC: "shell.exec",
+  /** Can read files inside the project (and possibly outside via symlinks if not guarded). */
+  FS_READ: "fs.read",
   /** Can write / modify / delete files inside the project. */
   FS_WRITE: "fs.write",
   /** Can write files outside the current project root (very high risk). */
   FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
+  /** Can perform outbound network requests. */
+  NET_OUTBOUND: "net.outbound",
+  /** Can mutate in-memory session todos only. */
+  SESSION_TODO: "session.todo",
+  /** Can mutate in-memory session mode only. */
+  SESSION_MODE: "session.mode",
+  /** Can inspect registered tool metadata. */
+  TOOL_META: "tool.meta",
+  /** Can invoke arbitrary registered tools through a meta-tool. */
+  TOOL_MUTATE_ANY: "tool.mutate.any",
+  /** Can read persistent memory. */
+  MEMORY_READ: "memory.read",
+  /** Can write persistent memory. */
+  MEMORY_WRITE: "memory.write",
+  /** Can delete persistent memory. */
+  MEMORY_DELETE: "memory.delete",
+  /** Proxies tools from external MCP servers (unknown capability). */
+  MCP_PROXY: "mcp.proxy",
   /** Can spawn or manage subagents / multi-agent tasks. */
   SUBAGENT_SPAWN: "subagent.spawn",
   /** Can inspect fleet/subagent coordination state without mutating it. */
@@ -1285,9 +1372,43 @@ var ToolCapabilities = {
   COORDINATION_RESULT_SUBMIT: "coordination.result.submit",
   /** Can read or write inter-agent mailbox messages. */
   COORDINATION_MAIL: "coordination.mail",
+  /** Can schedule, inspect, or cancel in-session cron jobs. */
+  COORDINATION_CRON: "coordination.cron",
+  /** Can mutate global or session configuration / trust state. */
+  CONFIG_MUTATE: "config.mutate",
   /** Can install packages or run package managers with side effects. */
   PACKAGE_INSTALL: "package.install"
 };
+var DANGEROUS_FOR_SUBAGENTS = [
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
+  ToolCapabilities.TOOL_MUTATE_ANY,
+  ToolCapabilities.MEMORY_WRITE,
+  ToolCapabilities.MEMORY_DELETE,
+  ToolCapabilities.MCP_PROXY,
+  ToolCapabilities.SUBAGENT_SPAWN,
+  ToolCapabilities.CONFIG_MUTATE,
+  ToolCapabilities.PACKAGE_INSTALL
+];
+var WIDE_SUBAGENT_CAPABILITIES = [
+  ToolCapabilities.FS_READ,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.NET_OUTBOUND,
+  ToolCapabilities.SESSION_TODO,
+  ToolCapabilities.TOOL_META,
+  ToolCapabilities.MEMORY_READ,
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.PACKAGE_INSTALL,
+  // Read-only fleet visibility (fleet_status) — peer awareness has no blast
+  // radius and every fleet worker should coordinate around its peers.
+  ToolCapabilities.COORDINATION_FLEET_READ,
+  ToolCapabilities.COORDINATION_RESULT_SUBMIT
+];
 
 // src/coordination/subagent-result-tool.ts
 var SUBAGENT_STRUCTURED_REPORT_META_KEY = "subagentStructuredReport";
@@ -1304,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 = {
@@ -1314,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;
 }
@@ -1327,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}`,
@@ -1336,7 +1463,7 @@ Files examined: ${files}`,
     `
 Suggested next steps:
 ${next}`
-  ].join("\n");
+  ].filter((line) => typeof line === "string").join("\n");
 }
 function makeSubagentResultTool() {
   return {
@@ -1376,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"],
@@ -1405,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;
 }
@@ -1685,6 +1825,12 @@ var TOOLS = {
   /** Web research. */
   research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
 };
+
+// src/coordination/agents/agent-prompts.ts
+import { readFileSync, statSync } from "node:fs";
+import * as os2 from "node:os";
+import * as path4 from "node:path";
+import { fileURLToPath } from "node:url";
 var promptCache = /* @__PURE__ */ new Map();
 var candidateCache = /* @__PURE__ */ new Map();
 function agentPrompt(id) {
@@ -1696,7 +1842,7 @@ function agentPrompt(id) {
   let resolved = "";
   for (const dir of agentPromptDirCandidates(envDir)) {
     try {
-      resolved = readFileSync(path9.join(dir, fileName), "utf8").trimEnd();
+      resolved = readFileSync(path4.join(dir, fileName), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -1705,20 +1851,20 @@ function agentPrompt(id) {
   return resolved;
 }
 function agentPromptDirCandidates(envDir) {
-  const globalRoot = process.env["WRONGSTACK_HOME"] || path9.join(os.homedir(), ".wrongstack");
+  const globalRoot = process.env["WRONGSTACK_HOME"] || path4.join(os2.homedir(), ".wrongstack");
   const candKey = `${envDir}\0${globalRoot}`;
   const cached = candidateCache.get(candKey);
   if (cached !== void 0) return cached;
-  const here = path9.dirname(fileURLToPath(import.meta.url));
+  const here = path4.dirname(fileURLToPath(import.meta.url));
   const explicitDir = envDir || void 0;
   const candidates = [
-    ...explicitDir ? [path9.resolve(explicitDir)] : [],
-    path9.join(globalRoot, "instructions", "agents"),
-    path9.resolve(here, "../../../../instructions/agents"),
-    path9.resolve(here, "../../../instructions/agents"),
-    path9.resolve(here, "../../instructions/agents"),
-    path9.resolve(here, "../instructions/agents"),
-    path9.resolve(here, "instructions/agents")
+    ...explicitDir ? [path4.resolve(explicitDir)] : [],
+    path4.join(globalRoot, "instructions", "agents"),
+    path4.resolve(here, "../../../../instructions/agents"),
+    path4.resolve(here, "../../../instructions/agents"),
+    path4.resolve(here, "../../instructions/agents"),
+    path4.resolve(here, "../instructions/agents"),
+    path4.resolve(here, "instructions/agents")
   ];
   const ordered = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
   candidateCache.set(candKey, ordered);
@@ -3339,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);
@@ -3356,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;
@@ -3430,27 +3621,342 @@ function formatHumanPrompt(request) {
   lines.push("", `Risk: ${request.risk}`);
   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;
@@ -3470,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();
@@ -3494,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;
@@ -3502,7 +4071,7 @@ var BrainMonitor = class {
     this.lastEngagedAt.set(kind, Date.now());
     try {
       const request = {
-        id: `brainmon-${randomUUID()}`,
+        id: `brainmon-${randomUUID2()}`,
         sessionId: this.opts.sessionId?.(),
         source: "system",
         question: input.question,
@@ -3565,6 +4134,11 @@ var BrainMonitor = class {
   }
 };
 
+// src/coordination/collab-debug.ts
+import { EventEmitter } from "node:events";
+import * as fsp2 from "node:fs/promises";
+import { randomUUID as randomUUID3 } from "node:crypto";
+
 // src/coordination/fleet-event-validation.ts
 var ROLE_BY_EVENT = {
   "bug.found": "bug-hunter",
@@ -3721,7 +4295,7 @@ var CollabSession = class extends EventEmitter {
   _timeoutTimer;
   constructor(director, fleetBus, options) {
     super();
-    this.sessionId = randomUUID();
+    this.sessionId = randomUUID3();
     this.options = options;
     this.director = director;
     this.fleetBus = fleetBus;
@@ -3783,8 +4357,8 @@ var CollabSession = class extends EventEmitter {
     for (const filePath of allFiles) {
       try {
         const [content, stat9] = await Promise.all([
-          fsp9.readFile(filePath, "utf8"),
-          fsp9.stat(filePath)
+          fsp2.readFile(filePath, "utf8"),
+          fsp2.stat(filePath)
         ]);
         const ext = filePath.split(".").pop() ?? "";
         const language = ext === "ts" || ext === "tsx" ? "typescript" : ext === "js" || ext === "jsx" ? "javascript" : ext === "md" ? "markdown" : ext === "json" ? "json" : void 0;
@@ -3961,7 +4535,7 @@ var CollabSession = class extends EventEmitter {
       timeoutMs: budget.timeoutMs
     };
     const subagentId = await this.director.spawn(cfg);
-    await this.director.assign({ id: randomUUID(), subagentId, description: taskBrief });
+    await this.director.assign({ id: randomUUID3(), subagentId, description: taskBrief });
     return subagentId;
   }
   buildBugHunterTask() {
@@ -4212,7 +4786,7 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     for (const file of this.snapshot.files) {
       if (file.snapshotMtimeMs === void 0 && file.snapshotSizeBytes === void 0) continue;
       try {
-        const stat9 = await fsp9.stat(file.path);
+        const stat9 = await fsp2.stat(file.path);
         const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat9.mtimeMs > file.snapshotMtimeMs + 1;
         const sizeChanged = file.snapshotSizeBytes !== void 0 && stat9.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
@@ -4289,59 +4863,33 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
   }
 };
 
+// src/coordination/delegate-tool.ts
+import * as fsp3 from "node:fs/promises";
+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])
@@ -4353,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,
@@ -4390,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,
@@ -4432,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]))
@@ -4444,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",
@@ -4503,24 +5024,39 @@ 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. Auto-promotes the host into director mode on first call.",
+    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) {
+    async execute(input, _ctx, execOpts) {
       const sessionId = opts.directorRunId;
+      const abortSignal = execOpts?.signal;
       const i = input ?? {};
       if (typeof i.task !== "string" || !i.task.trim()) {
         return { ok: false, error: "`task` is required." };
       }
+      if (abortSignal?.aborted) {
+        return {
+          ok: false,
+          stopReason: "aborted",
+          error: "Delegation cancelled before spawn \u2014 the run was interrupted."
+        };
+      }
       const target = i.role ?? i.name ?? "subagent";
       try {
         let director = await opts.host.ensureDirector();
@@ -4544,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;
@@ -4583,136 +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: `${randomUUID()}`,
-          description: i.task,
-          subagentId
-        });
         const dir = director;
-        const result = await new Promise((resolve9) => {
-          let settled = false;
-          let timer;
-          const finish = (value) => {
-            if (settled) return;
-            settled = true;
-            if (timer) clearTimeout(timer);
-            offTool();
-            offIter();
-            offProgress();
-            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);
-          arm();
-          dir.awaitTasks([taskId]).then((r) => finish(r[0] ?? { __emptyResult: true })).catch(() => finish({ __timeout: true }));
-        });
-        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,
+        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: "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.",
+          const result = await awaitDelegateAttempt(
+            dir,
             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", {
@@ -4735,13 +5310,106 @@ 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}-${randomUUID().slice(0, 8)}`
+    id: `${role}-${randomUUID4().slice(0, 8)}`
   };
 }
 function hintForKind(kind, retryable, backoffMs, partial) {
@@ -4816,13 +5484,13 @@ async function readSubagentPartial(opts, subagentId) {
   if (!opts.sessionsRoot) return void 0;
   const candidates = [];
   if (opts.directorRunId) {
-    candidates.push(path9.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
+    candidates.push(path5.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
   } else {
     try {
-      const entries = await fsp9.readdir(opts.sessionsRoot, { withFileTypes: true });
+      const entries = await fsp3.readdir(opts.sessionsRoot, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          candidates.push(path9.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
+          candidates.push(path5.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
         }
       }
     } catch {
@@ -4832,7 +5500,7 @@ async function readSubagentPartial(opts, subagentId) {
   for (const file of candidates) {
     let raw;
     try {
-      raw = await fsp9.readFile(file, "utf8");
+      raw = await fsp3.readFile(file, "utf8");
     } catch {
       continue;
     }
@@ -4924,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;
   }
@@ -5013,10 +5681,19 @@ function attachDepWatcherBridge(opts) {
     unsub();
   };
 }
+
+// src/coordination/director.ts
+import { randomUUID as randomUUID7 } from "node:crypto";
+import * as fsp5 from "node:fs/promises";
+import * as path7 from "node:path";
+
+// src/storage/director-state.ts
+import * as fsp4 from "node:fs/promises";
+import { hostname } from "node:os";
 async function acquireDirectorStateLock(lockPath, processId = process.pid) {
   let existing;
   try {
-    existing = await fsp9.readFile(lockPath, "utf8");
+    existing = await fsp4.readFile(lockPath, "utf8");
   } catch {
   }
   if (existing) {
@@ -5040,7 +5717,7 @@ async function acquireDirectorStateLock(lockPath, processId = process.pid) {
 }
 async function releaseDirectorStateLock(lockPath) {
   try {
-    await fsp9.unlink(lockPath);
+    await fsp4.unlink(lockPath);
   } catch {
   }
 }
@@ -5260,6 +5937,11 @@ var FleetContextOverflowError = class extends Error {
     this.observed = observed;
   }
 };
+
+// src/utils/instruction-file.ts
+import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import * as path6 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var textCache = /* @__PURE__ */ new Map();
 var rootCandidates;
 function readBundledInstructionText(relativePath) {
@@ -5268,7 +5950,7 @@ function readBundledInstructionText(relativePath) {
   let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      resolved = readFileSync(path9.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync2(path6.join(root, relativePath), "utf8").trimEnd();
       break;
     } catch {
     }
@@ -5284,18 +5966,18 @@ function renderInstructionTemplate(template, values) {
 }
 function instructionRootCandidates() {
   if (rootCandidates !== void 0) return rootCandidates;
-  const here = path9.dirname(fileURLToPath(import.meta.url));
+  const here = path6.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    path9.resolve(here, "../../instructions"),
-    path9.resolve(here, "../instructions"),
-    path9.resolve(here, "instructions")
+    path6.resolve(here, "../../instructions"),
+    path6.resolve(here, "../instructions"),
+    path6.resolve(here, "instructions")
   ];
   rootCandidates = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
   return rootCandidates;
 }
 function isDirectory2(candidate) {
   try {
-    return statSync(candidate).isDirectory();
+    return statSync2(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -5362,6 +6044,14 @@ function rosterSummaryFromConfigs(roster) {
   return lines.join("\n");
 }
 
+// src/coordination/director-tools.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+import {
+  claimReadyTask,
+  listReadyTasks,
+  updateTaskAssignment
+} from "@wrongstack/kanban";
+
 // src/coordination/dispatcher.ts
 var DEFAULT_DISPATCH_ROLE = "executor";
 var FALLBACK_DEFINITION = {
@@ -5621,7 +6311,7 @@ function instantiateRosterConfig2(role, base) {
     ...base,
     // Roster entries are templates. A director may spawn several
     // workers with the same role, so never reuse the template id.
-    id: `${role}-${randomUUID().slice(0, 8)}`
+    id: `${role}-${randomUUID5().slice(0, 8)}`
   };
 }
 function makeQualityGateTool(director, roster) {
@@ -5720,7 +6410,7 @@ function makeQualityGateTool(director, roster) {
             makeQualityGateSubagentConfig("verifier", roster, i.verifierWorktree ?? "auto")
           );
           const taskId = await director.assign({
-            id: randomUUID(),
+            id: randomUUID5(),
             subagentId,
             description: buildVerifierTask(i, {
               attempt,
@@ -5738,7 +6428,7 @@ function makeQualityGateTool(director, roster) {
             makeQualityGateSubagentConfig("reviewer", roster, i.reviewerWorktree ?? "off")
           );
           const taskId = await director.assign({
-            id: randomUUID(),
+            id: randomUUID5(),
             subagentId,
             description: buildReviewerTask(i, {
               attempt,
@@ -5766,7 +6456,7 @@ function makeQualityGateTool(director, roster) {
           };
         }
         const repairTaskId = await director.assign({
-          id: randomUUID(),
+          id: randomUUID5(),
           subagentId: i.repairSubagentId,
           description: buildRepairTask(i, attempts[attempts.length - 1], attempt),
           timeoutMs: i.timeoutMs
@@ -6034,7 +6724,7 @@ function makeAssignTool(director) {
     async execute(input) {
       const i = input;
       const task = {
-        id: randomUUID(),
+        id: randomUUID5(),
         description: i.description,
         subagentId: i.subagentId,
         maxToolCalls: i.maxToolCalls,
@@ -6115,7 +6805,7 @@ function makeKanbanQueueTool(director, roster) {
       const leaseTtlMs = Math.max(1e3, Math.floor(i.leaseTtlMs ?? 5 * 60 * 1e3));
       const claimedAt = nowIso();
       const leaseSeeding = {
-        leaseId: randomUUID(),
+        leaseId: randomUUID5(),
         claimedAt,
         heartbeatAt: claimedAt,
         leaseExpiresAt: new Date(Date.now() + leaseTtlMs).toISOString()
@@ -6169,7 +6859,7 @@ function makeKanbanQueueTool(director, roster) {
           const config = buildKanbanSubagentConfig(claim.task, i, roster);
           subagentId = await director.spawn(config);
           runTaskId = await director.assign({
-            id: randomUUID(),
+            id: randomUUID5(),
             subagentId,
             description: buildKanbanFleetTaskPrompt(claim.board, claim.task, {
               heartbeatIntervalMs: i.heartbeatIntervalMs ?? 6e4,
@@ -7184,6 +7874,7 @@ function fallbackProfileChain(config, profileName) {
   const chain = config.fallbackProfiles?.[profileName];
   return Array.isArray(chain) ? chain.filter((ref) => parseModelRef(ref).model) : [];
 }
+var DEFAULT_PRIMARY_COOLDOWN_MAX_MS = 10 * 6e4;
 
 // src/coordination/model-matrix.ts
 var MATRIX_PHASE_KEYS = Object.keys(AGENTS_BY_PHASE);
@@ -7357,6 +8048,10 @@ function isValidMatrixKey(key) {
   return matrixKeyKind(key) !== "unknown";
 }
 
+// src/coordination/multi-agent-coordinator.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { EventEmitter as EventEmitter2 } from "node:events";
+
 // src/coordination/coordinator/error-classifier.ts
 function classifySubagentError(err, hints = {}) {
   if (err instanceof AgentError && err.cause) {
@@ -7551,7 +8246,7 @@ function formatRole(role) {
 }
 
 // src/coordination/multi-agent-coordinator.ts
-var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends EventEmitter {
+var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends EventEmitter2 {
   coordinatorId;
   config;
   runner;
@@ -7644,7 +8339,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     return { ...subagent, name: display };
   }
   async spawn(subagent) {
-    const id = subagent.id || randomUUID();
+    const id = subagent.id || randomUUID6();
     const cfg = this.withNickname(subagent, id);
     if (this.subagents.has(id)) {
       throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
@@ -8311,8 +9006,9 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     const subagent = this.subagents.get(result.subagentId);
     if (subagent && subagent.status !== "stopped") {
-      result.status === "failed" || result.status === "timeout";
+      const failed = result.status === "failed" || result.status === "timeout";
       subagent.status = "idle";
+      void failed;
       subagent.currentTask = void 0;
       if (subagent.abortController.signal.aborted) {
         subagent.abortController = new AbortController();
@@ -8701,6 +9397,9 @@ var Director = class _Director {
   subagentBaseline;
   /** See {@link DirectorOptions.taskResultNotifier}. */
   taskResultNotifier;
+  subagentIdleTimeoutMs;
+  retireSubagentOnTaskComplete;
+  subagentIdleTimers = /* @__PURE__ */ new Map();
   /** Absolute path to the fleet's shared scratchpad directory, or null
    *  when none was configured. Exposed as a readonly getter for callers
    *  that need to surface the path to the user (e.g. the CLI logging
@@ -8796,13 +9495,15 @@ var Director = class _Director {
   /** Prevents large `ask_subagent` answers from bloating the leader's context window. */
   largeAnswerStore;
   constructor(opts) {
-    this.id = opts.config.coordinatorId || randomUUID();
+    this.id = opts.config.coordinatorId || randomUUID7();
     this.brain = opts.brain;
     this.manifestPath = opts.manifestPath;
     this.roster = opts.roster;
     this.directorPreamble = opts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
     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 ?? true;
     this.sharedScratchpadPath = opts.sharedScratchpadPath ?? null;
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = opts.fleetManager?.maxSpawnDepth ?? resolveMaxSpawnDepth(opts.maxSpawnDepth);
@@ -8813,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;
@@ -8833,7 +9534,7 @@ var Director = class _Director {
     this.fleetManager = opts.fleetManager;
     this.logger = opts.logger;
     if (this.sharedScratchpadPath) {
-      void fsp9.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
+      void fsp5.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
     }
     this.transport = new InMemoryBridgeTransport();
     this.bridge = new InMemoryAgentBridge(
@@ -8947,6 +9648,10 @@ var Director = class _Director {
       } else {
         this.scheduleManifest();
       }
+      this.armSubagentIdleRetirement(
+        r.subagentId,
+        this.retireSubagentOnTaskComplete ? 0 : this.subagentIdleTimeoutMs
+      );
     };
     this.coordinator.on("task.completed", this.taskCompletedListener);
     const extendCounts = /* @__PURE__ */ new Map();
@@ -9058,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;
           }
@@ -9419,6 +10124,7 @@ var Director = class _Director {
       });
       this.scheduleManifest();
     }
+    this.armSubagentIdleRetirement(result.subagentId, this.subagentIdleTimeoutMs);
     return result.subagentId;
   }
   /**
@@ -9441,7 +10147,7 @@ var Director = class _Director {
       );
     }
     const msg = {
-      id: randomUUID(),
+      id: randomUUID7(),
       type: "task",
       from: this.id,
       to: subagentId,
@@ -9540,7 +10246,7 @@ var Director = class _Director {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp9.mkdir(path9.dirname(this.manifestPath), { recursive: true });
+    await fsp5.mkdir(path7.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -9567,6 +10273,8 @@ var Director = class _Director {
       this.budgetFilter();
       this.budgetFilter = null;
     }
+    for (const timer of this.subagentIdleTimers.values()) clearTimeout(timer);
+    this.subagentIdleTimers.clear();
     await this.coordinator.stopAll();
     for (const b of this.subagentBridges.values()) {
       await b.stop().catch((err) => this.logShutdownError("subagent_bridge_stop", err));
@@ -9583,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
@@ -9606,7 +10315,7 @@ var Director = class _Director {
    * concurrency limit applies — the task may queue before running.
    */
   async assign(task) {
-    const taskWithId = task.id ? task : { ...task, id: randomUUID() };
+    const taskWithId = task.id ? task : { ...task, id: randomUUID7() };
     if (this.workCompleteFlag) {
       const synthetic = {
         subagentId: taskWithId.subagentId ?? "unassigned",
@@ -9670,7 +10379,7 @@ var Director = class _Director {
    * rollups and persisted fleet task history.
    */
   async assignInternal(task) {
-    const taskWithId = task.id ? task : { ...task, id: randomUUID() };
+    const taskWithId = task.id ? task : { ...task, id: randomUUID7() };
     this.internalTaskIds.add(taskWithId.id);
     try {
       await this.coordinator.assign(taskWithId);
@@ -9784,11 +10493,21 @@ 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);
     await this.coordinator.remove(subagentId);
     const bridge = this.subagentBridges.get(subagentId);
     if (bridge) {
@@ -9809,6 +10528,34 @@ var Director = class _Director {
     this.taskOwners.delete(subagentId);
     this.taskDescriptions.delete(subagentId);
   }
+  clearSubagentIdleRetirement(subagentId) {
+    const timer = this.subagentIdleTimers.get(subagentId);
+    if (!timer) return;
+    clearTimeout(timer);
+    this.subagentIdleTimers.delete(subagentId);
+  }
+  /**
+   * Arm one lifecycle timer per worker. The callback re-checks coordinator
+   * state so a task assigned in the same turn always wins over retirement.
+   */
+  armSubagentIdleRetirement(subagentId, delayMs) {
+    this.clearSubagentIdleRetirement(subagentId);
+    if (delayMs === void 0) return;
+    const timer = setTimeout(() => {
+      this.subagentIdleTimers.delete(subagentId);
+      const entry = this.coordinator.getStatus().subagents.find((a) => a.id === subagentId);
+      if (entry?.status !== "idle") return;
+      if (this.coordinator.listPendingTasks().some((task) => task.subagentId === subagentId)) {
+        this.armSubagentIdleRetirement(subagentId, this.subagentIdleTimeoutMs);
+        return;
+      }
+      void this.remove(subagentId).catch(
+        (err) => this.logShutdownError("subagent_idle_retirement", err)
+      );
+    }, delayMs);
+    if (typeof timer.unref === "function") timer.unref();
+    this.subagentIdleTimers.set(subagentId, timer);
+  }
   status() {
     const base = this.coordinator.getStatus();
     return {
@@ -9860,10 +10607,10 @@ var Director = class _Director {
    */
   async readSession(subagentId, tail) {
     if (!this.sessionsRoot) return null;
-    const filePath = path9.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
+    const filePath = path7.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
     let raw;
     try {
-      raw = await fsp9.readFile(filePath, "utf8");
+      raw = await fsp5.readFile(filePath, "utf8");
     } catch {
       return null;
     }
@@ -10028,6 +10775,21 @@ var Director = class _Director {
   }
 };
 
+// src/coordination/director-session.ts
+import * as path12 from "node:path";
+
+// src/storage/session-store.ts
+import { createHash as createHash4 } from "node:crypto";
+import { createReadStream } from "node:fs";
+import * as fsp9 from "node:fs/promises";
+import * as path11 from "node:path";
+import { createInterface } from "node:readline";
+
+// src/storage/file-session-writer.ts
+import { closeSync, fsyncSync, openSync, writeSync } from "node:fs";
+import * as fsp6 from "node:fs/promises";
+import * as path8 from "node:path";
+
 // src/storage/session-helpers.ts
 function userInputTitle(content) {
   const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
@@ -10043,7 +10805,7 @@ var FileSessionWriter = class _FileSessionWriter {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path9.join(opts.dir, `${path9.basename(id)}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path8.join(opts.dir, `${path8.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
     this.checkpointCas = opts.checkpointCas;
@@ -10583,7 +11345,7 @@ var FileSessionWriter = class _FileSessionWriter {
     let removedCount = 0;
     let targetCheckpointSeen = false;
     try {
-      fd = await fsp9.open(this.filePath, "r", 384);
+      fd = await fsp6.open(this.filePath, "r", 384);
       while (true) {
         const buf = Buffer.alloc(CHUNK_SIZE);
         const { bytesRead } = await fd.read(buf, 0, CHUNK_SIZE, fileOffset);
@@ -10638,7 +11400,7 @@ var FileSessionWriter = class _FileSessionWriter {
     await this.writeChain;
     await this.handle.close();
     const tmpPath = `${this.filePath}.rewind.tmp`;
-    const src = await fsp9.open(this.filePath, "r", 384);
+    const src = await fsp6.open(this.filePath, "r", 384);
     try {
       const statResult = await src.stat();
       const totalSize = statResult.size;
@@ -10654,7 +11416,7 @@ var FileSessionWriter = class _FileSessionWriter {
       } else {
         newlineAfterCheckpoint = totalSize;
       }
-      const writeFd = await fsp9.open(tmpPath, "w", 384);
+      const writeFd = await fsp6.open(tmpPath, "w", 384);
       try {
         let readOffset = 0;
         while (readOffset < newlineAfterCheckpoint) {
@@ -10702,11 +11464,11 @@ var FileSessionWriter = class _FileSessionWriter {
         await writeFd.close();
       }
       await src.close();
-      await fsp9.rename(tmpPath, this.filePath);
-      this.handle = await fsp9.open(this.filePath, "a", 384);
+      await fsp6.rename(tmpPath, this.filePath);
+      this.handle = await fsp6.open(this.filePath, "a", 384);
     } catch (err) {
-      await fsp9.unlink(tmpPath).catch(() => void 0);
-      this.handle = await fsp9.open(this.filePath, "a", 384).catch(() => this.handle);
+      await fsp6.unlink(tmpPath).catch(() => void 0);
+      this.handle = await fsp6.open(this.filePath, "a", 384).catch(() => this.handle);
       throw err;
     }
     await this.append({
@@ -10741,7 +11503,7 @@ var FileSessionWriter = class _FileSessionWriter {
       provider: this.meta.provider ?? "unknown"
     })}
 `;
-    await fsp9.writeFile(this.filePath, record, "utf8");
+    await fsp6.writeFile(this.filePath, record, "utf8");
     this.activePromptIndex = null;
     this.pendingFileSnapshots = [];
   }
@@ -10786,6 +11548,12 @@ var FileSessionWriter = class _FileSessionWriter {
   }
 };
 
+// src/storage/session-checkpoint-cas.ts
+import { spawn } from "node:child_process";
+import { createHash as createHash2, randomUUID as randomUUID8 } from "node:crypto";
+import * as fsp7 from "node:fs/promises";
+import * as path9 from "node:path";
+
 // src/storage/storage-concurrency.ts
 async function mapWithConcurrency(items, concurrency, mapper) {
   if (items.length === 0) return [];
@@ -10812,7 +11580,7 @@ var MAX_GIT_OUTPUT = 16 * 1024 * 1024;
 var MAX_BLOB_BYTES = 64 * 1024 * 1024;
 var MAX_CHECKPOINT_BYTES = 512 * 1024 * 1024;
 function sha256(content) {
-  return createHash("sha256").update(content).digest("hex");
+  return createHash2("sha256").update(content).digest("hex");
 }
 function isInside(root, target) {
   const relative4 = path9.relative(root, target);
@@ -10868,9 +11636,9 @@ var SessionCheckpointCas = class {
           return null;
         }
         try {
-          const stat9 = await fsp9.lstat(absolute);
+          const stat9 = await fsp7.lstat(absolute);
           if (stat9.isSymbolicLink()) {
-            const linkTarget = await fsp9.readlink(absolute);
+            const linkTarget = await fsp7.readlink(absolute);
             const resolvedLink = path9.resolve(path9.dirname(absolute), linkTarget);
             if (path9.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
               unresolved.push({
@@ -10900,7 +11668,7 @@ var SessionCheckpointCas = class {
             return null;
           }
           scheduledBytes += stat9.size;
-          const content = await fsp9.readFile(absolute);
+          const content = await fsp7.readFile(absolute);
           const blobHash = sha256(content);
           await this.putBlob(blobHash, content);
           return { path: relative4, state: "file", blobHash, mode: stat9.mode & 511 };
@@ -10938,7 +11706,7 @@ var SessionCheckpointCas = class {
     if (target === this.projectRoot) {
       throw new Error("Refusing to materialize a workspace checkpoint over the parent project root");
     }
-    const targetStat = await fsp9.stat(target);
+    const targetStat = await fsp7.stat(target);
     if (!targetStat.isDirectory()) throw new Error(`Checkpoint target is not a directory: ${target}`);
     const manifest = await this.loadManifest(checkpoint.manifestHash);
     if (manifest.baseHead !== checkpoint.baseHead.toLowerCase() || manifest.coverage !== checkpoint.coverage || manifest.entries.length !== checkpoint.entryCount || manifest.unresolved.length !== checkpoint.unresolvedCount) {
@@ -10965,7 +11733,7 @@ var SessionCheckpointCas = class {
     if (targetStatus.stdout.length > 0) {
       throw new Error("Checkpoint target must be a clean checkout before materialization");
     }
-    const realTarget = await fsp9.realpath(target);
+    const realTarget = await fsp7.realpath(target);
     const writtenFiles = [];
     const deletedFiles = [];
     const errors = [];
@@ -10995,24 +11763,24 @@ var SessionCheckpointCas = class {
     for (const { entry, output, content } of prepared) {
       try {
         if (entry.state === "absent") {
-          await fsp9.unlink(output).catch((err) => {
+          await fsp7.unlink(output).catch((err) => {
             if (err.code !== "ENOENT") throw err;
           });
           deletedFiles.push(entry.path);
           continue;
         }
         if (entry.state === "symlink") {
-          await fsp9.unlink(output).catch((err) => {
+          await fsp7.unlink(output).catch((err) => {
             if (err.code !== "ENOENT") throw err;
           });
-          await fsp9.mkdir(path9.dirname(output), { recursive: true });
-          await fsp9.symlink(entry.linkTarget, output);
+          await fsp7.mkdir(path9.dirname(output), { recursive: true });
+          await fsp7.symlink(entry.linkTarget, output);
           writtenFiles.push(entry.path);
           continue;
         }
         if (!content) throw new Error("CAS blob was not prepared");
         await atomicWrite(output, content, { mode: entry.mode });
-        await fsp9.chmod(output, entry.mode).catch(() => void 0);
+        await fsp7.chmod(output, entry.mode).catch(() => void 0);
         writtenFiles.push(entry.path);
       } catch (err) {
         errors.push(`${entry.path}: ${toErrorMessage(err)}`);
@@ -11030,9 +11798,9 @@ var SessionCheckpointCas = class {
   }
   async putBlob(hash, content) {
     const target = this.objectPath(hash);
-    await fsp9.mkdir(path9.dirname(target), { recursive: true });
+    await fsp7.mkdir(path9.dirname(target), { recursive: true });
     try {
-      const existing = await fsp9.readFile(target);
+      const existing = await fsp7.readFile(target);
       if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
       return;
     } catch (err) {
@@ -11040,30 +11808,30 @@ var SessionCheckpointCas = class {
     }
     const temp = path9.join(
       path9.dirname(target),
-      `.${path9.basename(target)}.${process.pid}.${randomUUID()}.tmp`
+      `.${path9.basename(target)}.${process.pid}.${randomUUID8()}.tmp`
     );
     let handle;
     try {
-      handle = await fsp9.open(temp, "wx", 384);
+      handle = await fsp7.open(temp, "wx", 384);
       await handle.writeFile(content);
       await handle.sync();
       await handle.close();
       handle = void 0;
       try {
-        await fsp9.link(temp, target);
+        await fsp7.link(temp, target);
       } catch (err) {
         if (err.code !== "EEXIST") throw err;
-        const existing = await fsp9.readFile(target);
+        const existing = await fsp7.readFile(target);
         if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
       }
     } finally {
       await handle?.close().catch(() => void 0);
-      await fsp9.unlink(temp).catch(() => void 0);
+      await fsp7.unlink(temp).catch(() => void 0);
     }
   }
   async putManifest(hash, encoded) {
     const target = this.manifestPath(hash);
-    const existing = await fsp9.readFile(target).catch(() => null);
+    const existing = await fsp7.readFile(target).catch(() => null);
     if (existing) {
       if (sha256(existing) !== hash) throw new Error(`Corrupt checkpoint manifest collision: ${hash}`);
       return;
@@ -11071,12 +11839,12 @@ var SessionCheckpointCas = class {
     await atomicWrite(target, encoded, { mode: 384 });
   }
   async readBlob(hash) {
-    const content = await fsp9.readFile(this.objectPath(hash));
+    const content = await fsp7.readFile(this.objectPath(hash));
     if (sha256(content) !== hash) throw new Error(`CAS blob integrity check failed: ${hash}`);
     return content;
   }
   async loadManifest(hash) {
-    const raw = await fsp9.readFile(this.manifestPath(hash));
+    const raw = await fsp7.readFile(this.manifestPath(hash));
     if (sha256(raw) !== hash) throw new Error(`Checkpoint manifest integrity check failed: ${hash}`);
     const parsed = JSON.parse(raw.toString("utf8"));
     if (parsed.version !== 1 || typeof parsed.baseHead !== "string" || parsed.coverage !== "git-head-plus-dirty" || !Array.isArray(parsed.entries) || !Array.isArray(parsed.unresolved)) {
@@ -11106,7 +11874,7 @@ var SessionCheckpointCas = class {
     let probe = output;
     for (; ; ) {
       try {
-        const real = await fsp9.realpath(probe);
+        const real = await fsp7.realpath(probe);
         if (!isInside(realTarget, real)) throw new Error("path resolves through a symlink outside checkpoint target");
         return output;
       } catch (err) {
@@ -11166,12 +11934,17 @@ function defaultRunGit(args, cwd) {
     child.on("close", (code) => resolve9(result(code ?? 1)));
   });
 }
+
+// src/storage/session-resume-validation.ts
+import { createHash as createHash3 } from "node:crypto";
+import * as fsp8 from "node:fs/promises";
+import * as path10 from "node:path";
 var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
 var VALIDATION_CONCURRENCY = 8;
 var NOTICE_PATH_LIMIT = 20;
 function isInside2(root, target) {
-  const relative4 = path9.relative(root, target);
-  return relative4 === "" || !relative4.startsWith("..") && !path9.isAbsolute(relative4);
+  const relative4 = path10.relative(root, target);
+  return relative4 === "" || !relative4.startsWith("..") && !path10.isAbsolute(relative4);
 }
 function errno(err) {
   return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
@@ -11182,7 +11955,7 @@ function latestObservations(events, projectRoot) {
     if (event.type !== "file_observation" || typeof event.path !== "string" || event.path.length === 0 || typeof event.hash !== "string" || !/^[a-f\d]{64}$/i.test(event.hash)) {
       continue;
     }
-    const normalized = path9.resolve(projectRoot, event.path);
+    const normalized = path10.resolve(projectRoot, event.path);
     latest.set(normalized, {
       path: normalized,
       hash: event.hash.toLowerCase(),
@@ -11206,7 +11979,7 @@ async function validateOne(observation, lexicalRoot, realRoot) {
   }
   let realFile;
   try {
-    realFile = await fsp9.realpath(observation.path);
+    realFile = await fsp8.realpath(observation.path);
   } catch (err) {
     if (errno(err) === "ENOENT") return { ...base, status: "deleted" };
     return { ...base, status: "unreadable", detail: toErrorMessage(err) };
@@ -11219,7 +11992,7 @@ async function validateOne(observation, lexicalRoot, realRoot) {
     };
   }
   try {
-    const stat9 = await fsp9.stat(realFile);
+    const stat9 = await fsp8.stat(realFile);
     if (!stat9.isFile()) {
       return { ...base, status: "unreadable", detail: "Path is no longer a regular file." };
     }
@@ -11230,8 +12003,8 @@ async function validateOne(observation, lexicalRoot, realRoot) {
         detail: `File now exceeds the ${MAX_REVALIDATE_BYTES}-byte validation limit.`
       };
     }
-    const content = await fsp9.readFile(realFile, "utf8");
-    const actualHash = createHash("sha256").update(content, "utf8").digest("hex");
+    const content = await fsp8.readFile(realFile, "utf8");
+    const actualHash = createHash3("sha256").update(content, "utf8").digest("hex");
     if (actualHash === observation.hash) return null;
     return { ...base, status: "modified", actualHash };
   } catch (err) {
@@ -11240,8 +12013,8 @@ async function validateOne(observation, lexicalRoot, realRoot) {
   }
 }
 async function validateResumeFileObservations(events, projectRoot) {
-  const lexicalRoot = path9.resolve(projectRoot);
-  const realRoot = await fsp9.realpath(lexicalRoot).catch(() => lexicalRoot);
+  const lexicalRoot = path10.resolve(projectRoot);
+  const realRoot = await fsp8.realpath(lexicalRoot).catch(() => lexicalRoot);
   const observations = latestObservations(events, lexicalRoot);
   const results = await mapWithConcurrency(
     observations,
@@ -11256,9 +12029,9 @@ async function validateResumeFileObservations(events, projectRoot) {
 }
 function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
-  const root = path9.resolve(projectRoot);
+  const root = path10.resolve(projectRoot);
   const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
-    const relative4 = path9.relative(root, entry.path);
+    const relative4 = path10.relative(root, entry.path);
     const display = isInside2(root, entry.path) ? relative4 || "." : entry.path;
     return `- ${JSON.stringify(display)} [${entry.status}]`;
   });
@@ -11363,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
@@ -11380,14 +12154,26 @@ var DefaultSessionStore = class _DefaultSessionStore {
   static LIST_SCAN_CONCURRENCY = 32;
   constructor(opts) {
     this.dir = opts.dir;
-    this.projectRoot = opts.projectRoot ? path9.resolve(opts.projectRoot) : void 0;
+    this.projectRoot = opts.projectRoot ? path11.resolve(opts.projectRoot) : void 0;
     this.checkpointCas = this.projectRoot ? new SessionCheckpointCas({
-      rootDir: path9.join(this.dir, "_cas"),
+      rootDir: path11.join(this.dir, "_cas"),
       projectRoot: this.projectRoot
     }) : void 0;
     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
@@ -11436,17 +12222,17 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   /** Absolute path to the session index file. */
   get indexFile() {
-    return path9.join(this.dir, "_index.jsonl");
+    return path11.join(this.dir, "_index.jsonl");
   }
   /** Join session ID to its absolute path within the store directory. */
   sessionPath(id, ext) {
     return sessionScopedPath(this.dir, id, ext);
   }
   shardManifestPath(shardKey) {
-    return shardKey ? path9.join(this.dir, shardKey, "_manifest.json") : path9.join(this.dir, "_manifest.json");
+    return shardKey ? path11.join(this.dir, shardKey, "_manifest.json") : path11.join(this.dir, "_manifest.json");
   }
   shardKeyForSessionId(id) {
-    const dirName = path9.dirname(id);
+    const dirName = path11.dirname(id);
     return dirName === "." ? "" : dirName;
   }
   invalidateShardManifestBySessionId(id) {
@@ -11458,7 +12244,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * subdirectory so sessions group naturally by day.
    */
   async ensureShardDir(id) {
-    const dirPath = path9.dirname(sessionScopedPath(this.dir, id, ""));
+    const dirPath = path11.dirname(sessionScopedPath(this.dir, id, ""));
     await ensureDir(dirPath);
     return dirPath;
   }
@@ -11489,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;
     }
@@ -11520,7 +12304,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     }
     const parentPrefix = parent.events.slice(0, boundary + 1);
     const workspaceCheckpoint = targetCheckpoint?.workspaceCheckpoint;
-    const checkpointHash = createHash("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
+    const checkpointHash = createHash4("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
     const inherited = parentPrefix.filter(inheritsIntoFork);
     const writer = await this.create({
       id: "",
@@ -11615,7 +12399,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
           // Shard directory (sessions/<date>/) — must match create() so the
           // .summary.json sidecar lands next to the JSONL instead of the
           // sessions root (where summaryFor() would never find it).
-          dir: path9.dirname(file),
+          dir: path11.dirname(file),
           filePath: file,
           secretScrubber: this.secretScrubber,
           checkpointCas: this.checkpointCas,
@@ -11625,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;
     }
@@ -12170,7 +12952,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return entry;
   }
   async collectSessionFilesInShard(shardKey) {
-    const dir = shardKey ? path9.join(this.dir, shardKey) : this.dir;
+    const dir = shardKey ? path11.join(this.dir, shardKey) : this.dir;
     const entries = await this.collectSessionFiles(dir, shardKey);
     return shardKey ? entries.filter((entry) => entry.id.startsWith(`${shardKey}/`)) : entries.filter((entry) => !entry.id.includes("/"));
   }
@@ -12193,13 +12975,13 @@ var DefaultSessionStore = class _DefaultSessionStore {
         if (entry.name === "_index.jsonl") continue;
         const base = entry.name.replace(/\.jsonl$/, "");
         const id = prefix ? `${prefix}/${base}` : base;
-        files.push({ id, filePath: path9.join(dir, entry.name) });
+        files.push({ id, filePath: path11.join(dir, entry.name) });
       }
     }
     const childFileArrays = await Promise.all(
       dirEntries.map((entry) => {
         const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionFiles(path9.join(dir, entry.name), childPrefix, depth + 1);
+        return this.collectSessionFiles(path11.join(dir, entry.name), childPrefix, depth + 1);
       })
     );
     return [...childFileArrays.flat(), ...files];
@@ -12232,7 +13014,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const childIdArrays = await Promise.all(
       dirEntries.map((entry) => {
         const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionIds(path9.join(dir, entry.name), childPrefix, depth + 1);
+        return this.collectSessionIds(path11.join(dir, entry.name), childPrefix, depth + 1);
       })
     );
     return [...childIdArrays.flat(), ...fileIds];
@@ -12251,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";
@@ -12349,9 +13128,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async deleteSession(id) {
     const jsonlPath = this.sessionPath(id, ".jsonl");
     const summaryPath = this.sessionPath(id, ".summary.json");
-    const shardDir = path9.dirname(jsonlPath);
-    const base = path9.basename(id);
-    const sessDir = path9.join(shardDir, base);
+    const shardDir = path11.dirname(jsonlPath);
+    const base = path11.basename(id);
+    const sessDir = path11.join(shardDir, base);
     const deletions = [
       fsp9.unlink(jsonlPath),
       fsp9.unlink(summaryPath),
@@ -12392,7 +13171,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    */
   async readActiveSessionId() {
     try {
-      const raw = await fsp9.readFile(path9.join(this.dir, "active.json"), "utf8");
+      const raw = await fsp9.readFile(path11.join(this.dir, "active.json"), "utf8");
       const active = JSON.parse(raw);
       return active.sessionId ?? null;
     } catch {
@@ -12455,7 +13234,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const activeSessionId = await this.readActiveSessionId();
     const isPrunableJsonl = (name) => name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
     const pruneFile = async (dir, name, prefix) => {
-      const jsonlPath = path9.join(dir, name);
+      const jsonlPath = path11.join(dir, name);
       try {
         const stat9 = await fsp9.stat(jsonlPath);
         if (stat9.mtimeMs >= cutoff) return;
@@ -12475,7 +13254,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         continue;
       }
       if (!entry.isDirectory()) continue;
-      const dateDir = path9.join(this.dir, entry.name);
+      const dateDir = path11.join(this.dir, entry.name);
       const files = await fsp9.readdir(dateDir, { withFileTypes: true }).catch(() => []);
       for (const file of files) {
         if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
@@ -12487,7 +13266,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const dateDir = path9.join(this.dir, entry.name);
+      const dateDir = path11.join(this.dir, entry.name);
       try {
         const remaining = await fsp9.readdir(dateDir);
         if (remaining.length === 0) {
@@ -12618,9 +13397,9 @@ function makeDirectorSessionFactory(opts) {
   let dir;
   if (opts.store) {
     store = opts.store;
-    dir = opts.sessionsRoot ? path9.join(opts.sessionsRoot, runId) : "(caller-managed)";
+    dir = opts.sessionsRoot ? path12.join(opts.sessionsRoot, runId) : "(caller-managed)";
   } else if (opts.sessionsRoot) {
-    dir = path9.join(opts.sessionsRoot, runId);
+    dir = path12.join(opts.sessionsRoot, runId);
     store = new DefaultSessionStore({ dir });
   } else {
     throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
@@ -12642,6 +13421,11 @@ function makeDirectorSessionFactory(opts) {
     }
   };
 }
+
+// src/coordination/fleet-manager.ts
+import { randomUUID as randomUUID9 } from "node:crypto";
+import * as fsp10 from "node:fs/promises";
+import * as path13 from "node:path";
 var FleetManager = class {
   /** The fleet-wide event bus. */
   fleet;
@@ -12687,7 +13471,7 @@ var FleetManager = class {
   maxContext;
   constructor(opts = {}) {
     this.manifestPath = opts.manifestPath;
-    this.directorRunId = opts.directorRunId ?? randomUUID();
+    this.directorRunId = opts.directorRunId ?? randomUUID9();
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = resolveMaxSpawnDepth(opts.maxSpawnDepth);
     this.spawnDepth = opts.spawnDepth ?? 0;
@@ -12902,7 +13686,7 @@ var FleetManager = class {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp9.mkdir(path9.dirname(this.manifestPath), { recursive: true });
+    await fsp10.mkdir(path13.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -13039,6 +13823,153 @@ var FleetManager = class {
   }
 };
 
+// src/coordination/global-mailbox.ts
+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();
@@ -13047,15 +13978,8 @@ 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 path9.join(globalRoot, "projects", projectSlug(projectRoot));
+  return path14.join(globalRoot, "projects", projectSlug(projectRoot));
 }
 var GlobalMailbox = class {
   /** Path to the JSONL message file. */
@@ -13068,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
@@ -13113,20 +14043,47 @@ 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) {
-    this.messagePath = path9.join(projectDir, MAILBOX_FILE);
-    this.registryPath = path9.join(projectDir, "_mailbox.registry.json");
-    this.clientRegistryPath = path9.join(projectDir, CLIENT_REGISTRY_FILE);
+  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 `${path9.basename(path9.dirname(this.messagePath))}:mailbox`;
+    return `${path14.basename(path14.dirname(this.messagePath))}:mailbox`;
   }
   get hqPublisher() {
     return typeof this._hqPublisher === "function" ? this._hqPublisher() : this._hqPublisher;
@@ -13147,12 +14104,12 @@ var GlobalMailbox = class {
   async send(input) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const msg = {
-      id: randomUUID(),
+      id: randomUUID10(),
       from: input.from,
       // "all" is an accepted spelling of the broadcast address — canonical
       // form on disk is '*' so every query/checker matches it.
       to: normalizeRecipient(input.to),
-      type: input.type,
+      type: normalizeMailboxMessageType(input.type),
       subject: input.subject,
       body: input.body,
       priority: input.priority ?? "normal",
@@ -13160,12 +14117,13 @@ 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 fsp9.mkdir(path9.dirname(this.messagePath), { recursive: true });
+    await fsp11.mkdir(path14.dirname(this.messagePath), { recursive: true });
     await withFileLock(this.messagePath, async () => {
-      await fsp9.appendFile(this.messagePath, line, "utf8");
+      await fsp11.appendFile(this.messagePath, line, "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
       this._pushToCache(msg, mtimeMs, size);
     });
@@ -13175,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;
       }
@@ -13236,7 +14222,7 @@ var GlobalMailbox = class {
       }
       if (changed) {
         const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-        await fsp9.writeFile(this.messagePath, serialized, "utf8");
+        await fsp11.writeFile(this.messagePath, serialized, "utf8");
       }
       const { mtimeMs, size } = await this._statMessageFile();
       this._setMessageCache(all, mtimeMs, size);
@@ -13247,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;
@@ -13254,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;
@@ -13267,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) {
@@ -13276,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 fsp9.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;
   }
@@ -13296,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 fsp9.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;
   }
@@ -13446,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,
@@ -13499,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();
@@ -13528,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,
@@ -13540,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;
@@ -13547,10 +14635,12 @@ 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 () => {
-      await fsp9.writeFile(this.messagePath, "", "utf8");
+      await fsp11.writeFile(this.messagePath, "", "utf8");
       const { mtimeMs, size } = await this._statMessageFile();
       this._setMessageCache([], mtimeMs, size);
     });
@@ -13583,7 +14673,7 @@ var GlobalMailbox = class {
       remaining = kept.length;
       if (kept.length < all.length) {
         const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-        await fsp9.writeFile(this.messagePath, content, "utf8");
+        await fsp11.writeFile(this.messagePath, content, "utf8");
       }
       const { mtimeMs, size } = await this._statMessageFile();
       this._setMessageCache(kept, mtimeMs, size);
@@ -13595,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.
@@ -13604,7 +14788,7 @@ var GlobalMailbox = class {
    */
   async _readMessages() {
     try {
-      const raw = await fsp9.readFile(this.messagePath, "utf8");
+      const raw = await fsp11.readFile(this.messagePath, "utf8");
       return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
@@ -13627,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;
   }
@@ -13697,7 +14896,7 @@ var GlobalMailbox = class {
    */
   async _statMessageFile() {
     try {
-      const st = await fsp9.stat(this.messagePath);
+      const st = await fsp11.stat(this.messagePath);
       return { mtimeMs: st.mtimeMs, size: st.size };
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -13743,16 +14942,15 @@ var GlobalMailbox = class {
    */
   async _readMessagesCachedWork() {
     try {
-      const st = await fsp9.stat(this.messagePath);
+      const st = await fsp11.stat(this.messagePath);
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
         return this._messageCache;
       }
       if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
-        const fd = await fsp9.open(this.messagePath, "r");
+        const fd = await fsp11.open(this.messagePath, "r");
         try {
           const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
           this._messageCacheMtime = st.mtimeMs;
-          this._messageCacheSize = st.size;
           return updated;
         } finally {
           await fd.close();
@@ -13789,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
@@ -13820,18 +15053,35 @@ 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;
   }
   async _ensureRegistry() {
-    await fsp9.mkdir(path9.dirname(this.registryPath), { recursive: true });
+    await fsp11.mkdir(path14.dirname(this.registryPath), { recursive: true });
   }
   async _readRegistry(opts) {
     if (!opts?.fresh && this._registryCache && Date.now() - this._registryCacheAt < REGISTRY_CACHE_TTL_MS) {
       return new Map(this._registryCache);
     }
     try {
-      const raw = await fsp9.readFile(this.registryPath, "utf8");
+      const raw = await fsp11.readFile(this.registryPath, "utf8");
       const data = JSON.parse(raw);
       const map = /* @__PURE__ */ new Map();
       for (const [id, agent] of Object.entries(data)) {
@@ -13851,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) {
@@ -13873,20 +15114,20 @@ var GlobalMailbox = class {
     for (const [id, agent] of registry) {
       obj[id] = agent;
     }
-    const tmp = `${this.registryPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp9.writeFile(tmp, JSON.stringify(obj), "utf8");
-    await fsp9.rename(tmp, this.registryPath);
+    const tmp = `${this.registryPath}.${randomUUID10().slice(0, 8)}.tmp`;
+    await fsp11.writeFile(tmp, JSON.stringify(obj), "utf8");
+    await fsp11.rename(tmp, this.registryPath);
   }
   // ── Client registry internals ───────────────────────────────────────────
   async _ensureClientRegistry() {
-    await fsp9.mkdir(path9.dirname(this.clientRegistryPath), { recursive: true });
+    await fsp11.mkdir(path14.dirname(this.clientRegistryPath), { recursive: true });
   }
   async _readClientRegistry(opts) {
     if (!opts?.fresh && this._clientRegistryCache && Date.now() - this._clientRegistryCacheAt < REGISTRY_CACHE_TTL_MS) {
       return new Map(this._clientRegistryCache);
     }
     try {
-      const raw = await fsp9.readFile(this.clientRegistryPath, "utf8");
+      const raw = await fsp11.readFile(this.clientRegistryPath, "utf8");
       const data = JSON.parse(raw);
       const map = /* @__PURE__ */ new Map();
       for (const [id, client] of Object.entries(data)) {
@@ -13907,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);
       }
     }
   }
@@ -13918,16 +15160,19 @@ var GlobalMailbox = class {
     for (const [id, client] of registry) {
       obj[id] = client;
     }
-    const tmp = `${this.clientRegistryPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp9.writeFile(tmp, JSON.stringify(obj), "utf8");
-    await fsp9.rename(tmp, this.clientRegistryPath);
+    const tmp = `${this.clientRegistryPath}.${randomUUID10().slice(0, 8)}.tmp`;
+    await fsp11.writeFile(tmp, JSON.stringify(obj), "utf8");
+    await fsp11.rename(tmp, this.clientRegistryPath);
   }
 };
+
+// src/coordination/mailbox-tool.ts
+import { createHash as createHash5 } from "node:crypto";
 function defaultResolveProjectDir(ctx) {
   return resolveProjectDir(ctx.projectRoot, wstackGlobalRoot());
 }
 function mailboxSessionTag(sessionId) {
-  return createHash("sha256").update(sessionId).digest("hex").slice(0, 8);
+  return createHash5("sha256").update(sessionId).digest("hex").slice(0, 8);
 }
 function resolveMailboxIdentity(ctx, fallbackBase = "leader") {
   const fieldId = ctx.agentId && ctx.agentId !== "unknown" ? ctx.agentId : void 0;
@@ -13964,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"] },
@@ -14273,6 +15518,9 @@ function makeFleetStatusTool(opts = {}) {
     }
   };
 }
+
+// src/coordination/fleet-supervisor.ts
+import { randomUUID as randomUUID11 } from "node:crypto";
 var COLLAB_ID_PREFIXES = ["bug-hunter-", "refactor-planner-", "critic-"];
 var DEFAULTS = {
   intervalMs: 2e4,
@@ -14514,7 +15762,7 @@ var FleetSupervisor = class {
    */
   async decide(question, context, options, risk) {
     const request = {
-      id: `fleetsup-${randomUUID()}`,
+      id: `fleetsup-${randomUUID11()}`,
       sessionId: this.opts.sessionId?.(),
       source: "system",
       question,
@@ -15002,6 +16250,11 @@ function makeMailInboxTool(opts = {}) {
     }
   };
 }
+
+// src/coordination/mailbox.ts
+import { randomUUID as randomUUID12 } from "node:crypto";
+import * as fsp12 from "node:fs/promises";
+import * as path15 from "node:path";
 var MAILBOX_FILE2 = "_mailbox.jsonl";
 var LINE_SEPARATOR2 = "\n";
 var MESSAGE_CACHE_MAX_ENTRIES2 = 1e4;
@@ -15010,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) {
-    this.filePath = path9.join(sessionDir, MAILBOX_FILE2);
+  logger;
+  constructor(sessionDir, opts) {
+    this.filePath = path15.join(sessionDir, MAILBOX_FILE2);
+    this.logger = opts?.logger;
   }
   get mailboxPath() {
     return this.filePath;
@@ -15030,12 +16287,12 @@ var DefaultMailbox = class {
   async send(input) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const msg = {
-      id: randomUUID(),
+      id: randomUUID12(),
       from: input.from,
       // "all" is an accepted spelling of the broadcast address — canonical
       // form on disk is '*' so every query/checker matches it.
       to: normalizeRecipient(input.to),
-      type: input.type,
+      type: normalizeMailboxMessageType(input.type),
       subject: input.subject,
       body: input.body,
       priority: input.priority ?? "normal",
@@ -15046,9 +16303,9 @@ var DefaultMailbox = class {
       taskContext: input.taskContext
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR2;
-    await fsp9.mkdir(path9.dirname(this.filePath), { recursive: true });
+    await fsp12.mkdir(path15.dirname(this.filePath), { recursive: true });
     await withFileLock(this.filePath, async () => {
-      await fsp9.appendFile(this.filePath, line, "utf8");
+      await fsp12.appendFile(this.filePath, line, "utf8");
       this._pushToCache(msg);
       const { mtime, size } = await this._statUnderLockOrAbsent();
       this._messageCacheMtime = mtime;
@@ -15058,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("*");
@@ -15071,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;
@@ -15085,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) {
@@ -15148,7 +16419,7 @@ var DefaultMailbox = class {
       }
       if (changed) {
         const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
-        await fsp9.writeFile(this.filePath, serialized, "utf8");
+        await fsp12.writeFile(this.filePath, serialized, "utf8");
       }
       const { mtime, size } = await this._statUnderLockOrAbsent();
       this._setMessageCache(all, mtime, size);
@@ -15162,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,
@@ -15204,12 +16475,13 @@ var DefaultMailbox = class {
     this._messageCache = null;
     this._messageCacheMtime = -1;
     this._messageCacheSize = -1;
+    this._messageCacheTruncated = false;
     this._byTo.clear();
     this._byFrom.clear();
   }
   async clearAll() {
     await withFileLock(this.filePath, async () => {
-      await fsp9.writeFile(this.filePath, "", "utf8");
+      await fsp12.writeFile(this.filePath, "", "utf8");
       const { mtime, size } = await this._statUnderLockOrAbsent();
       this._setMessageCache([], mtime, size);
     });
@@ -15242,7 +16514,7 @@ var DefaultMailbox = class {
       remaining = kept.length;
       if (kept.length < all.length) {
         const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
-        await fsp9.writeFile(this.filePath, content, "utf8");
+        await fsp12.writeFile(this.filePath, content, "utf8");
       }
       const { mtime, size } = await this._statUnderLockOrAbsent();
       this._setMessageCache(kept, mtime, size);
@@ -15255,17 +16527,36 @@ 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 {
-      const raw = await fsp9.readFile(this.filePath, "utf8");
+      const raw = await fsp12.readFile(this.filePath, "utf8");
       return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
@@ -15275,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;
   }
@@ -15340,7 +16633,7 @@ var DefaultMailbox = class {
    */
   async _statUnderLockOrAbsent() {
     try {
-      const st = await fsp9.stat(this.filePath);
+      const st = await fsp12.stat(this.filePath);
       return { mtime: st.mtimeMs, size: st.size };
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -15349,18 +16642,19 @@ var DefaultMailbox = class {
       throw err;
     }
   }
-  async _readAllCached() {
+  async _readAllCached(requireComplete = true) {
     try {
-      const st = await fsp9.stat(this.filePath);
+      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) {
-        const fd = await fsp9.open(this.filePath, "r");
+        const fd = await fsp12.open(this.filePath, "r");
         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();
@@ -15378,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);
@@ -15427,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
@@ -15695,14 +16988,18 @@ function createMailboxHooks(opts) {
 
 // src/coordination/null-fleet-bus.ts
 var NULL_FLEET_BUS = new FleetBus();
+
+// src/coordination/package-author-tracker.ts
+import * as fs2 from "node:fs/promises";
+import * as path16 from "node:path";
 var DEFAULT_MAX_ENTRIES = 1e4;
 var LOG_FILENAME = "package-authors.json";
 function logPath(storageDir) {
-  return path9.join(storageDir, LOG_FILENAME);
+  return path16.join(storageDir, LOG_FILENAME);
 }
 async function loadLog(storageDir, projectRoot) {
   try {
-    const raw = await fsp9.readFile(logPath(storageDir), "utf-8");
+    const raw = await fs2.readFile(logPath(storageDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.entries || !Array.isArray(parsed.entries)) {
       return { projectRoot, entries: [] };
@@ -15716,13 +17013,13 @@ async function loadLog(storageDir, projectRoot) {
   }
 }
 async function saveLog(storageDir, log) {
-  await fsp9.mkdir(storageDir, { recursive: true });
+  await fs2.mkdir(storageDir, { recursive: true });
   const tmp = `${logPath(storageDir)}.tmp.${Date.now()}`;
-  await fsp9.writeFile(tmp, JSON.stringify(log, null, 2) + "\n", "utf-8");
-  await fsp9.rename(tmp, logPath(storageDir));
+  await fs2.writeFile(tmp, JSON.stringify(log, null, 2) + "\n", "utf-8");
+  await fs2.rename(tmp, logPath(storageDir));
 }
 function detectEcosystem(manifestPath) {
-  const name = path9.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";
@@ -15967,11 +17264,18 @@ mvn versions:use-latest-versions`;
       return `# Update ${entry.name} to ${entry.latestVersion} using your package manager`;
   }
 }
+
+// src/coordination/single-instance-mailbox.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
+import * as fsp13 from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+import * as os3 from "node:os";
+import * as path17 from "node:path";
 var MAILBOX_BRIDGE_LOCK_FILENAME = ".mailbox-bridge.lock";
 var MAILBOX_BRIDGE_TOKEN_FILENAME = ".mailbox.token";
 async function acquireOrJoin(opts) {
-  const lockPath = path9.join(opts.projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path9.join(opts.projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path17.join(opts.projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path17.join(opts.projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   const inspected = await readLockForInspection(lockPath);
   if (inspected.kind === "live") {
     const existing = inspected.lock;
@@ -15981,10 +17285,10 @@ async function acquireOrJoin(opts) {
     return { kind: "joined", lock: existing, tokenPath };
   }
   if (inspected.kind === "stale") {
-    await fsp9.unlink(lockPath).catch(() => void 0);
+    await fsp13.unlink(lockPath).catch(() => void 0);
   }
   const generation = inspected.kind === "stale" ? inspected.lock.generation + 1 : 1;
-  const token = randomBytes(32).toString("hex");
+  const token = randomBytes3(32).toString("hex");
   const tentative = {
     pid: process.pid,
     host: opts.host,
@@ -15999,34 +17303,34 @@ async function acquireOrJoin(opts) {
   return { kind: "acquired", lock: tentative, tokenPath };
 }
 async function finalize(projectDir, tentative, boundPort) {
-  const lockPath = path9.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path9.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path17.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path17.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   const finalized = {
     ...tentative,
     port: boundPort,
     url: `http://${tentative.host}:${boundPort}`
   };
   await atomicWriteJson(lockPath, finalized);
-  await fsp9.writeFile(tokenPath, finalized.token, { mode: 384 });
+  await fsp13.writeFile(tokenPath, finalized.token, { mode: 384 });
   return finalized;
 }
 async function release(projectDir, generation) {
-  const lockPath = path9.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
-  const tokenPath = path9.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
+  const lockPath = path17.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const tokenPath = path17.join(projectDir, MAILBOX_BRIDGE_TOKEN_FILENAME);
   try {
-    const raw = await fsp9.readFile(lockPath, "utf-8");
+    const raw = await fsp13.readFile(lockPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.generation !== generation) return;
     if (parsed.pid !== process.pid) return;
-    await fsp9.unlink(lockPath).catch(() => void 0);
-    await fsp9.unlink(tokenPath).catch(() => void 0);
+    await fsp13.unlink(lockPath).catch(() => void 0);
+    await fsp13.unlink(tokenPath).catch(() => void 0);
   } catch {
   }
 }
 async function readLockForInspection(lockPath) {
   let raw;
   try {
-    raw = await fsp9.readFile(lockPath, "utf-8");
+    raw = await fsp13.readFile(lockPath, "utf-8");
   } catch {
     return { kind: "absent" };
   }
@@ -16034,7 +17338,7 @@ async function readLockForInspection(lockPath) {
   try {
     parsed = JSON.parse(raw);
   } catch {
-    await fsp9.unlink(lockPath).catch(() => void 0);
+    await fsp13.unlink(lockPath).catch(() => void 0);
     return { kind: "absent" };
   }
   if (!isProcessAlive(parsed.pid)) {
@@ -16046,7 +17350,7 @@ async function readLockForInspection(lockPath) {
   return { kind: "live", lock: parsed };
 }
 async function readLiveLock(projectDir) {
-  const lockPath = path9.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
+  const lockPath = path17.join(projectDir, MAILBOX_BRIDGE_LOCK_FILENAME);
   const result = await readLockForInspection(lockPath);
   if (result.kind === "live") {
     return { kind: "live", lock: result.lock };
@@ -16057,28 +17361,29 @@ async function readLiveLock(projectDir) {
   return { kind: "absent" };
 }
 async function atomicWriteJson(targetPath, value) {
-  const dir = path9.dirname(targetPath);
-  await fsp9.mkdir(dir, { recursive: true });
-  const tmp = `${targetPath}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
+  const dir = path17.dirname(targetPath);
+  await fsp13.mkdir(dir, { recursive: true });
+  const tmp = `${targetPath}.tmp.${process.pid}.${randomBytes3(4).toString("hex")}`;
   const body = JSON.stringify(value, null, 2) + "\n";
-  await fsp9.writeFile(tmp, body, { mode: 384 });
+  await fsp13.writeFile(tmp, body, { mode: 384 });
   try {
-    await fsp9.rename(tmp, targetPath);
+    await fsp13.rename(tmp, targetPath);
   } catch (err) {
-    await fsp9.unlink(tmp).catch(() => void 0);
+    await fsp13.unlink(tmp).catch(() => void 0);
     throw err;
   }
 }
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   if (pid === process.pid) return true;
-  if (os.platform() === "win32") {
+  if (os3.platform() === "win32") {
     try {
       const out = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/NH", "/FO", "CSV"], {
         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;
     }
@@ -16279,7 +17584,11 @@ var AdaptiveConcurrencyController = class {
     };
   }
 };
-var AgentMonitorService = class {
+
+// src/coordination/agent-monitor.ts
+import * as fs3 from "node:fs/promises";
+import * as path18 from "node:path";
+var AgentMonitorService = class _AgentMonitorService {
   _fleetBus;
   _events;
   _sessionId;
@@ -16289,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. */
@@ -16351,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;
@@ -16417,6 +17738,14 @@ var AgentMonitorService = class {
       task: session.task
     });
   }
+  /** 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();
+    this._subscriptions.delete(subagentId);
+  }
   // ── Internal ───────────────────────────────────────────────────────
   _routeEvent(subagentId, type, payload) {
     const session = this._sessions.get(subagentId);
@@ -16425,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": {
@@ -16506,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,
@@ -16529,11 +17891,11 @@ var AgentMonitorService = class {
     this._onEntry?.(entry);
   }
   async _appendToFile(subagentId, entry) {
-    const dir = path9.join(this._transcriptsDir, subagentId);
-    await fsp9.mkdir(dir, { recursive: true });
-    const filePath = path9.join(dir, "transcript.jsonl");
+    const dir = path18.join(this._transcriptsDir, subagentId);
+    await fs3.mkdir(dir, { recursive: true });
+    const filePath = path18.join(dir, "transcript.jsonl");
     const line = JSON.stringify(entry) + "\n";
-    await fsp9.appendFile(filePath, line, { encoding: "utf8" });
+    await fs3.appendFile(filePath, line, { encoding: "utf8" });
   }
   _uid() {
     return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
@@ -16541,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;
@@ -16568,6 +17933,9 @@ ${output}${suffix}`;
 function createAgentMonitorService(opts) {
   return new AgentMonitorService(opts);
 }
+
+// src/coordination/autonomous-brain.ts
+import { randomUUID as randomUUID13 } from "node:crypto";
 var AutonomousBrain = class {
   graph;
   // Fleet bus for emitting decisions — null-safe, no-op if not provided
@@ -16576,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"];
@@ -16675,7 +18041,7 @@ var AutonomousBrain = class {
       consequence: i === 0 ? `Spawn the most appropriate agent for: ${taskDescription.slice(0, 80)}` : `Spawn an alternative agent for the same task`
     }));
     return this.decideAuto({
-      id: randomUUID(),
+      id: randomUUID13(),
       source,
       decisionType: "spawn",
       question: `Should we spawn a subagent for this task?`,
@@ -16718,7 +18084,7 @@ var AutonomousBrain = class {
       }
     ];
     return this.decideAuto({
-      id: randomUUID(),
+      id: randomUUID13(),
       source,
       decisionType: "approve_change",
       question: `Should we approve the change "${change.title}"?`,
@@ -16777,7 +18143,7 @@ var AutonomousBrain = class {
       consequence: "Break the task into smaller sub-tasks"
     });
     return this.decideAuto({
-      id: randomUUID(),
+      id: randomUUID13(),
       source,
       decisionType: "escalate_task",
       question: `Task failed: ${error.slice(0, 100)}. How should we proceed?`,
@@ -16889,7 +18255,6 @@ ${ctx.error}`);
       madeAt: (/* @__PURE__ */ new Date()).toISOString(),
       context: input.context
     });
-    this.decisionHistory.push(node);
     return node;
   }
   _inferRoles(task) {
@@ -16910,7 +18275,16 @@ ${ctx.error}`);
     return "low";
   }
 };
-var KnowledgeGraph = class {
+
+// src/coordination/autonomous-coordinator.ts
+import { randomUUID as randomUUID16 } from "node:crypto";
+
+// src/coordination/knowledge-graph.ts
+import { randomUUID as randomUUID14 } from "node:crypto";
+import * as fsp14 from "node:fs/promises";
+import * as path19 from "node:path";
+var DEFAULT_MAX_NODES = 2e3;
+var KnowledgeGraph = class _KnowledgeGraph {
   nodes = /* @__PURE__ */ new Map();
   index = /* @__PURE__ */ new Map();
   // tag/field → node ids
@@ -16918,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),
@@ -16936,9 +18311,10 @@ var KnowledgeGraph = class {
   getIndex() {
     return this.index;
   }
-  constructor(sessionDir) {
-    this.filePath = path9.join(sessionDir, "_knowledge_graph");
-    this.graphFilePath = path9.join(this.filePath, "graph.jsonl");
+  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 ──────────────────────────────────────────────────────────────
   /**
@@ -16946,10 +18322,11 @@ var KnowledgeGraph = class {
    * Returns the node with its assigned id.
    */
   async add(node) {
-    const full = { id: randomUUID(), ...node };
+    const full = { id: randomUUID14(), ...node };
     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;
@@ -16962,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);
@@ -17029,8 +18444,8 @@ var KnowledgeGraph = class {
    * used to poll for new nodes since the last check.
    */
   subscribe(agentId, filter) {
-    const channel = randomUUID();
-    const sub = { id: randomUUID(), agentId, filter, channel };
+    const channel = randomUUID14();
+    const sub = { id: randomUUID14(), agentId, filter, channel };
     this.subs.set(channel, sub);
     this.pendingDeliveries.set(channel, []);
     return channel;
@@ -17120,7 +18535,8 @@ var KnowledgeGraph = class {
       const nodeTags = node.tags ?? node.tags ?? [];
       if (!f.tags.some((t) => nodeTags.includes(t))) return false;
     }
-    if (f.since && node.id > f.since) ;
+    if (f.since && node.id > f.since) {
+    }
     return true;
   }
   _deliver(node) {
@@ -17132,23 +18548,23 @@ var KnowledgeGraph = class {
     }
   }
   async _persist(node) {
-    await fsp9.mkdir(this.filePath, { recursive: true });
+    await fsp14.mkdir(this.filePath, { recursive: true });
     const line = JSON.stringify(node) + "\n";
     await withFileLock(this.graphFilePath, async () => {
-      await fsp9.appendFile(this.graphFilePath, line, "utf8");
+      await fsp14.appendFile(this.graphFilePath, line, "utf8");
     });
   }
   async _append(node) {
-    await fsp9.mkdir(this.filePath, { recursive: true });
+    await fsp14.mkdir(this.filePath, { recursive: true });
     const line = JSON.stringify({ op: "update", node }) + "\n";
     await withFileLock(this.graphFilePath, async () => {
-      await fsp9.appendFile(this.graphFilePath, line, "utf8");
+      await fsp14.appendFile(this.graphFilePath, line, "utf8");
     });
   }
   /** Rebuild in-memory state from the log file. Call on startup. */
   async load() {
     try {
-      const content = await fsp9.readFile(this.graphFilePath, "utf8");
+      const content = await fsp14.readFile(this.graphFilePath, "utf8");
       const lines = content.split("\n").filter(Boolean);
       for (const line of lines) {
         try {
@@ -17470,6 +18886,9 @@ var TaskDAG = class {
     return false;
   }
 };
+
+// src/coordination/task-auctioneer.ts
+import { randomUUID as randomUUID15 } from "node:crypto";
 var TaskAuctioneer = class {
   graph;
   fleet;
@@ -17589,7 +19008,7 @@ var TaskAuctioneer = class {
     const score = dispatchResult.confidence * (dispatchResult.role === agent.agentRole ? 1.2 : 1);
     if (score < this.minConfidence) return false;
     const bid = {
-      id: randomUUID(),
+      id: randomUUID15(),
       taskId,
       agentId: agent.agentId,
       agentName: agent.agentName,
@@ -18394,6 +19813,7 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
   mailbox;
   events;
   onCoordinatorEvent;
+  logger;
   running = false;
   iterationCount = 0;
   lastSyncAt = 0;
@@ -18410,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({
@@ -18515,7 +19936,7 @@ var AutonomousCoordinator = class _AutonomousCoordinator {
           break;
         }
         const decision = await this.brain.decideAuto({
-          id: randomUUID(),
+          id: randomUUID16(),
           source: "system",
           decisionType: "prioritize_goals",
           question: `What should we work on next? Open goals: ${dispatchable.map((g) => g.title).join(", ")}`,
@@ -18568,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
@@ -19010,7 +20438,168 @@ ${input.detail}`
     this.onCoordinatorEvent?.(event);
   }
 };
-
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, AgentMonitorService, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_FLEET_SPAWNS, DEFAULT_QUALITY_CHECKS, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetSupervisor, FleetTokenCapError, FleetUsageAggregator, GlobalMailbox, HARD_MAX_SPAWN_DEPTH, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MAILBOX_BRIDGE_LOCK_FILENAME, MAILBOX_BRIDGE_TOKEN_FILENAME, MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD, MAILBOX_HEALTH_DEFAULT_FROM, MAILBOX_HEALTH_DEFAULT_INTERVAL_MS, MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS, MATRIX_PHASE_KEYS, MAX_SUBAGENT_STRUCTURED_REPORT_CHARS, MEDIUM_BUDGET, META_AGENTS, MailboxHealthWatchdog, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SUBAGENT_STRUCTURED_REPORT_META_KEY, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, WorktreeIntegrationError, acquireOrJoin, actionToAckInput, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, buildDownAlert, buildRecoveryAlert, composeDirectorPrompt, composeSubagentPrompt, createAgentMonitorService, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, finalize, formatHumanPrompt, formatSubagentStructuredReport, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, isValidMatrixKey, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetTool as makeFleetHealthTool, makeFleetTool as makeFleetSessionTool, makeFleetStatusTool, makeFleetTool, makeFleetTool as makeFleetUsageTool, makeKanbanQueueTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeQualityGateTool, makeRollUpTool, makeSpawnTool, makeSubagentResultTool, makeTerminateAllTool, makeTerminateTool, makeWorkCompleteTool, matrixKeyKind, normalizeRecipient, normalizeSubagentStructuredReport, phaseForRole, readLiveLock, readSubagentStructuredReport, recordPackageAction, release, resolveImplementationModelTarget, resolveMailboxIdentity, resolveMaxSpawnDepth, resolveModelMatrix, resolveModelMatrixResolution, resolveModelTargetFromEntry, resolveProjectDir, resolveSubagentModelTarget, resolveSubagentWorktreeDecision, roleNeedsIndependentReviewModel, rosterSummaryFromConfigs, sameModelReference, scoreAgents, startPackageOutdatedWatcher, subagentNeedsWorktree, updatePackageOutdatedStatus, validateWatchdogOptions, withDisabledToolFiltering, wrapSubagentRunnerWithWorktrees };
+export {
+  ACP_AGENTS,
+  AGENTS_BY_PHASE,
+  AGENT_CATALOG,
+  TOOLS as AGENT_TOOL_PRESETS,
+  ALL_AGENT_DEFINITIONS,
+  ALL_FLEET_AGENTS,
+  AUDIT_LOG_AGENT,
+  AdaptiveConcurrencyController,
+  AgentMonitorService,
+  AutonomousBrain,
+  AutonomousCoordinator,
+  BUG_HUNTER_AGENT,
+  BUILD_AGENTS,
+  BrainDecisionLedger,
+  BrainDecisionQueue,
+  BrainMonitor,
+  BudgetExceededError,
+  BudgetThresholdSignal,
+  ChangeManager,
+  CollabSession,
+  ConsensusProtocol,
+  DECISION_TIMEOUT_MS,
+  DEFAULT_DIRECTOR_PREAMBLE,
+  DEFAULT_DISPATCH_ROLE,
+  DEFAULT_MAX_FLEET_SPAWNS,
+  DEFAULT_QUALITY_CHECKS,
+  DEFAULT_SUBAGENT_BASELINE,
+  DELIVERY_AGENTS,
+  DEPENDENCY_FILE_PATTERNS,
+  DISCOVERY_AGENTS,
+  DOMAIN_AGENTS,
+  DefaultBrainArbiter,
+  DefaultMailbox,
+  DefaultMultiAgentCoordinator,
+  Director,
+  DirectorAlertLevel,
+  EscalationRoutingBrainArbiter,
+  FLEET_ROSTER,
+  FLEET_ROSTER_BUDGETS,
+  FLEET_ROSTER_WITHACP,
+  FleetBus,
+  FleetCostCapError,
+  FleetManager,
+  FleetSpawnBudgetError,
+  FleetSupervisor,
+  FleetTokenCapError,
+  FleetUsageAggregator,
+  GlobalMailbox,
+  HARD_MAX_SPAWN_DEPTH,
+  HEAVY_BUDGET,
+  HumanEscalatingBrainArbiter,
+  InMemoryAgentBridge,
+  InMemoryBridgeTransport,
+  KNOWLEDGE_AGENTS,
+  KnowledgeGraph,
+  LIGHT_BUDGET,
+  LargeAnswerStore,
+  MAILBOX_BRIDGE_LOCK_FILENAME,
+  MAILBOX_BRIDGE_TOKEN_FILENAME,
+  MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD,
+  MAILBOX_HEALTH_DEFAULT_FROM,
+  MAILBOX_HEALTH_DEFAULT_INTERVAL_MS,
+  MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS,
+  MATRIX_PHASE_KEYS,
+  MAX_SUBAGENT_STRUCTURED_REPORT_CHARS,
+  MEDIUM_BUDGET,
+  META_AGENTS,
+  MailboxHealthWatchdog,
+  NULL_FLEET_BUS,
+  ObservableBrainArbiter,
+  PLANNING_AGENTS,
+  REFACTOR_PLANNER_AGENT,
+  REVIEW_AGENTS,
+  SECURITY_SCANNER_AGENT,
+  SUBAGENT_STRUCTURED_REPORT_META_KEY,
+  SubagentBudget,
+  TIMEOUT_PREEMPT_FRACTION,
+  TaskAuctioneer,
+  TaskDAG,
+  VERIFY_AGENTS,
+  WorktreeIntegrationError,
+  acquireOrJoin,
+  actionToAckInput,
+  applyRosterBudget,
+  attachAutoExtend,
+  attachDepWatcherBridge,
+  brainDecisionKey,
+  buildDownAlert,
+  buildRecoveryAlert,
+  composeDirectorPrompt,
+  composeSubagentPrompt,
+  createAgentMonitorService,
+  createDelegateTool,
+  createLedgerGuardBrainArbiter,
+  createMailboxHooks,
+  createMessage,
+  detectEcosystem,
+  dispatchAgent,
+  finalize,
+  formatHumanPrompt,
+  formatSubagentStructuredReport,
+  getAgentDefinition,
+  getFullPackageLog,
+  getManifestPackages,
+  getPackageAuthor,
+  getPackagesByAgent,
+  isValidMatrixKey,
+  mailboxSessionTag,
+  makeAgentSubagentRunner,
+  makeAskResultTool,
+  makeAskTool,
+  makeAssignTool,
+  makeAwaitTasksTool,
+  makeCollabDebugTool,
+  makeDependencyWatcherConfig,
+  makeDirectorSessionFactory,
+  makeFleetEmitTool,
+  makeFleetTool as makeFleetHealthTool,
+  makeFleetTool as makeFleetSessionTool,
+  makeFleetStatusTool,
+  makeFleetTool,
+  makeFleetTool as makeFleetUsageTool,
+  makeKanbanQueueTool,
+  makeLLMClassifier,
+  makeMailInboxTool,
+  makeMailSendTool,
+  makeMailboxTool,
+  makeQualityGateTool,
+  makeRollUpTool,
+  makeSpawnTool,
+  makeSubagentResultTool,
+  makeTerminateAllTool,
+  makeTerminateTool,
+  makeWorkCompleteTool,
+  matrixKeyKind,
+  normalizeRecipient,
+  normalizeSubagentStructuredReport,
+  phaseForRole,
+  readLiveLock,
+  readSubagentStructuredReport,
+  recordPackageAction,
+  release,
+  resolveImplementationModelTarget,
+  resolveMailboxIdentity,
+  resolveMaxSpawnDepth,
+  resolveModelMatrix,
+  resolveModelMatrixResolution,
+  resolveModelTargetFromEntry,
+  resolveProjectDir,
+  resolveSubagentModelTarget,
+  resolveSubagentWorktreeDecision,
+  roleNeedsIndependentReviewModel,
+  rosterSummaryFromConfigs,
+  sameModelReference,
+  scoreAgents,
+  startPackageOutdatedWatcher,
+  subagentNeedsWorktree,
+  terminalPolicyDecision,
+  updatePackageOutdatedStatus,
+  validateWatchdogOptions,
+  withDisabledToolFiltering,
+  wrapSubagentRunnerWithWorktrees
+};
 //# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map