@wrongstack/core 0.260.0 → 0.265.1

package/dist/coordination/index.js

@@ -1,6 +1,6 @@
 import { randomUUID, createHash, randomBytes } from 'crypto';
 import * as fsp6 from 'fs/promises';
-import * as path4 from 'path';
+import * as path5 from 'path';
 import { isAbsolute, resolve } from 'path';
 import * as os from 'os';
 import { hostname } from 'os';
@@ -152,9 +152,9 @@ function formatHumanPrompt(request) {
   return lines.join("\n");
 }
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path4.dirname(targetPath);
+  const dir = path5.dirname(targetPath);
   await fsp6.mkdir(dir, { recursive: true });
-  const tmp = path4.join(dir, `.${path4.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const tmp = path5.join(dir, `.${path5.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
       await fsp6.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
@@ -172,8 +172,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat5 = await fsp6.stat(targetPath);
-      mode = stat5.mode & 511;
+      const stat6 = await fsp6.stat(targetPath);
+      mode = stat6.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -193,9 +193,9 @@ async function ensureDir(dir) {
   await fsp6.mkdir(dir, { recursive: true });
 }
 async function withFileLock(targetPath, fn, opts = {}) {
-  const dir = path4.dirname(targetPath);
+  const dir = path5.dirname(targetPath);
   await fsp6.mkdir(dir, { recursive: true });
-  const lockPath = path4.join(dir, `.${path4.basename(targetPath)}.lock`);
+  const lockPath = path5.join(dir, `.${path5.basename(targetPath)}.lock`);
   const timeoutMs = opts.timeoutMs ?? 5e3;
   const staleMs = opts.staleMs ?? 3e4;
   const started = Date.now();
@@ -206,10 +206,15 @@ async function withFileLock(targetPath, fn, opts = {}) {
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
-      if (err.code !== "EEXIST") throw err;
+      const code = err.code;
+      if (code === "ENOENT") {
+        await fsp6.mkdir(dir, { recursive: true });
+        continue;
+      }
+      if (code !== "EEXIST") throw err;
       try {
-        const stat5 = await fsp6.stat(lockPath);
-        if (Date.now() - stat5.mtimeMs > staleMs) {
+        const stat6 = await fsp6.stat(lockPath);
+        if (Date.now() - stat6.mtimeMs > staleMs) {
           await fsp6.unlink(lockPath);
           continue;
         }
@@ -259,6 +264,11 @@ async function renameWithRetry(from, to) {
   throw lastErr;
 }
 
+// src/utils/error.ts
+function toErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
 // src/storage/director-state.ts
 async function acquireDirectorStateLock(lockPath, processId = process.pid) {
   let existing;
@@ -412,7 +422,7 @@ var DirectorStateCheckpoint = class {
     } catch (err) {
       console.warn(
         "[director-state] checkpoint write failed:",
-        err instanceof Error ? err.message : String(err)
+        toErrorMessage(err)
       );
     } finally {
       this.writing = false;
@@ -434,11 +444,246 @@ function safeParse(input, maxBytes = 5e6) {
   } catch (err) {
     return {
       ok: false,
-      error: err instanceof Error ? err.message : String(err)
+      error: toErrorMessage(err)
     };
   }
 }
 
+// src/utils/string.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
+  if (value === null || value === void 0) {
+    const err = new Error("Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
+  }
+  return value;
+}
+function projectSlug(absRoot) {
+  const base = slugify(path5.basename(absRoot));
+  const hash = createHash("sha256").update(path5.resolve(absRoot)).digest("hex").slice(0, 6);
+  return `${base}-${hash}`;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
+}
+function wstackGlobalRoot() {
+  const fromEnv = process.env["WRONGSTACK_HOME"];
+  if (fromEnv && fromEnv.trim().length > 0) return path5.resolve(fromEnv);
+  return path5.join(os.homedir(), ".wrongstack");
+}
+
+// src/utils/message-invariants.ts
+function repairToolUseAdjacency(messages) {
+  const removedToolUses = [];
+  const removedToolResults = [];
+  let removedMessages = 0;
+  let changed = false;
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const original = expectDefined(messages[i]);
+    let msg = original;
+    if (hasToolUse(msg)) {
+      const nextIds = toolResultIds(messages[i + 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_use" && !nextIds.has(block.id)) {
+            removedToolUses.push(block.id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (hasToolResult(msg)) {
+      const allowed = toolUseIds(out[out.length - 1]);
+      const filtered = mapContent(msg, (blocks) => {
+        const next = [];
+        for (const block of blocks) {
+          if (block.type === "tool_result" && !allowed.has(block.tool_use_id)) {
+            removedToolResults.push(block.tool_use_id);
+            changed = true;
+            continue;
+          }
+          next.push(block);
+        }
+        return next;
+      });
+      msg = filtered ?? msg;
+    }
+    if (isEmptyMessage(msg)) {
+      removedMessages++;
+      changed = true;
+      continue;
+    }
+    out.push(msg);
+  }
+  return {
+    messages: changed ? out : messages,
+    report: { changed, removedToolUses, removedToolResults, removedMessages }
+  };
+}
+function hasToolUse(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_use");
+}
+function hasToolResult(msg) {
+  return contentBlocks(msg).some((b) => b.type === "tool_result");
+}
+function toolUseIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!msg || msg.role !== "assistant") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_use") ids.add(block.id);
+  }
+  return ids;
+}
+function toolResultIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!msg || msg.role !== "user") return ids;
+  for (const block of contentBlocks(msg)) {
+    if (block.type === "tool_result") ids.add(block.tool_use_id);
+  }
+  return ids;
+}
+function contentBlocks(msg) {
+  return msg && Array.isArray(msg.content) ? msg.content : [];
+}
+function mapContent(msg, fn) {
+  if (!Array.isArray(msg.content)) return msg;
+  const next = fn(msg.content);
+  if (next.length === msg.content.length && next.every((b, idx) => b === msg.content[idx])) {
+    return msg;
+  }
+  return { ...msg, content: next };
+}
+function isEmptyMessage(msg) {
+  if (typeof msg.content === "string") return msg.content.trim().length === 0;
+  return msg.content.length === 0;
+}
+var GLOB_CHARS = /* @__PURE__ */ new Set(["*", "?", "["]);
+var IS_WINDOWS = process.platform === "win32";
+var SEP = IS_WINDOWS ? "\\" : "/";
+function isGlob(p) {
+  for (const c of p) {
+    if (GLOB_CHARS.has(c)) return true;
+  }
+  return false;
+}
+function globToRegex(pat) {
+  let i = 0;
+  let re = "^";
+  while (i < pat.length) {
+    const c = expectDefined(pat[i]);
+    if (c === "*") {
+      if (pat[i + 1] === "*") {
+        re += ".*";
+        i += 2;
+        if (pat[i] === "/") i++;
+      } else {
+        re += "[^/\\\\]*";
+        i++;
+      }
+    } else if (c === "?") {
+      re += "[^/\\\\]";
+      i++;
+    } else if (c === "[") {
+      let cls = "[";
+      i++;
+      if (pat[i] === "!" || pat[i] === "^") {
+        cls += "^";
+        i++;
+      }
+      while (i < pat.length && pat[i] !== "]") {
+        const ch = pat[i] ?? "";
+        if (ch === "\\") cls += "\\\\";
+        else if (ch === "]" || ch === "^") cls += `\\${ch}`;
+        else cls += ch;
+        i++;
+      }
+      cls += "]";
+      re += cls;
+      i++;
+    } else {
+      re += c.replace(/[.+^${}()|\\]/g, "\\$&");
+      i++;
+    }
+  }
+  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);
+  return cut < 0 ? "." : pat.slice(0, cut);
+}
+async function expandGlob(pattern) {
+  if (!isGlob(pattern)) return [pattern];
+  const results = /* @__PURE__ */ new Set();
+  const abs = isAbsolute(pattern);
+  const base = abs ? baseDir(pattern) : baseDir(pattern);
+  const relPat = base === "." ? pattern : pattern.slice(base.length + 1);
+  async function walk(dir, pat) {
+    let entries;
+    try {
+      entries = await fsp6.readdir(dir);
+    } catch {
+      return;
+    }
+    const firstGlob = pat.search(/[*?[[]/);
+    if (firstGlob < 0) {
+      const re = globToRegex(pat);
+      for (const e of entries) {
+        if (re.test(e)) {
+          const full = `${dir}${SEP}${e}`;
+          results.add(abs ? resolve(full) : full);
+        }
+      }
+      return;
+    }
+    const before = pat.slice(0, firstGlob);
+    const rest = pat.slice(firstGlob);
+    if (before.endsWith("**")) {
+      await walk(dir, rest);
+      for (const e of entries) {
+        const full = `${dir}${SEP}${e}`;
+        try {
+          const stat6 = await fsp6.stat(full);
+          if (stat6.isDirectory()) await walk(full, rest);
+        } catch {
+        }
+      }
+    } else if (before === "") {
+      const re = globToRegex(rest);
+      for (const e of entries) {
+        if (re.test(e)) {
+          const full = `${dir}${SEP}${e}`;
+          results.add(abs ? resolve(full) : full);
+        }
+      }
+    } else {
+      const seg = before.replace(/[*?[\]]/g, "").replace(/\/$/, "");
+      if (entries.includes(seg)) {
+        const full = `${dir}${SEP}${seg}`;
+        try {
+          const stat6 = await fsp6.stat(full);
+          if (stat6.isDirectory()) await walk(full, rest);
+        } catch {
+        }
+      }
+    }
+  }
+  await walk(base === "." ? "." : base, relPat);
+  return [...results];
+}
+
 // src/types/errors.ts
 var ERROR_CODES = {
   // Provider
@@ -657,133 +902,6 @@ function createMessage(type, from, payload, to) {
     priority: "normal"
   };
 }
-
-// src/utils/expect-defined.ts
-function expectDefined(value, label) {
-  if (value === null || value === void 0) {
-    const err = new Error("Expected value to be defined");
-    err.name = "ExpectDefinedError";
-    throw err;
-  }
-  return value;
-}
-var GLOB_CHARS = /* @__PURE__ */ new Set(["*", "?", "["]);
-var IS_WINDOWS = process.platform === "win32";
-var SEP = IS_WINDOWS ? "\\" : "/";
-function isGlob(p) {
-  for (const c of p) {
-    if (GLOB_CHARS.has(c)) return true;
-  }
-  return false;
-}
-function globToRegex(pat) {
-  let i = 0;
-  let re = "^";
-  while (i < pat.length) {
-    const c = expectDefined(pat[i]);
-    if (c === "*") {
-      if (pat[i + 1] === "*") {
-        re += ".*";
-        i += 2;
-        if (pat[i] === "/") i++;
-      } else {
-        re += "[^/\\\\]*";
-        i++;
-      }
-    } else if (c === "?") {
-      re += "[^/\\\\]";
-      i++;
-    } else if (c === "[") {
-      let cls = "[";
-      i++;
-      if (pat[i] === "!" || pat[i] === "^") {
-        cls += "^";
-        i++;
-      }
-      while (i < pat.length && pat[i] !== "]") {
-        const ch = pat[i] ?? "";
-        if (ch === "\\") cls += "\\\\";
-        else if (ch === "]" || ch === "^") cls += `\\${ch}`;
-        else cls += ch;
-        i++;
-      }
-      cls += "]";
-      re += cls;
-      i++;
-    } else {
-      re += c.replace(/[.+^${}()|\\]/g, "\\$&");
-      i++;
-    }
-  }
-  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);
-  return cut < 0 ? "." : pat.slice(0, cut);
-}
-async function expandGlob(pattern) {
-  if (!isGlob(pattern)) return [pattern];
-  const results = /* @__PURE__ */ new Set();
-  const abs = isAbsolute(pattern);
-  const base = abs ? baseDir(pattern) : baseDir(pattern);
-  const relPat = base === "." ? pattern : pattern.slice(base.length + 1);
-  async function walk(dir, pat) {
-    let entries;
-    try {
-      entries = await fsp6.readdir(dir);
-    } catch {
-      return;
-    }
-    const firstGlob = pat.search(/[*?[[]/);
-    if (firstGlob < 0) {
-      const re = globToRegex(pat);
-      for (const e of entries) {
-        if (re.test(e)) {
-          const full = `${dir}${SEP}${e}`;
-          results.add(abs ? resolve(full) : full);
-        }
-      }
-      return;
-    }
-    const before = pat.slice(0, firstGlob);
-    const rest = pat.slice(firstGlob);
-    if (before.endsWith("**")) {
-      await walk(dir, rest);
-      for (const e of entries) {
-        const full = `${dir}${SEP}${e}`;
-        try {
-          const stat5 = await fsp6.stat(full);
-          if (stat5.isDirectory()) await walk(full, rest);
-        } catch {
-        }
-      }
-    } else if (before === "") {
-      const re = globToRegex(rest);
-      for (const e of entries) {
-        if (re.test(e)) {
-          const full = `${dir}${SEP}${e}`;
-          results.add(abs ? resolve(full) : full);
-        }
-      }
-    } else {
-      const seg = before.replace(/[*?[\]]/g, "").replace(/\/$/, "");
-      if (entries.includes(seg)) {
-        const full = `${dir}${SEP}${seg}`;
-        try {
-          const stat5 = await fsp6.stat(full);
-          if (stat5.isDirectory()) await walk(full, rest);
-        } catch {
-        }
-      }
-    }
-  }
-  await walk(base === "." ? "." : base, relPat);
-  return [...results];
-}
-
-// src/coordination/collab-debug.ts
 var DEFAULT_MAX_TARGET_FILES = 30;
 var DirectorAlertLevel = /* @__PURE__ */ ((DirectorAlertLevel2) => {
   DirectorAlertLevel2["WARNING"] = "warning";
@@ -878,7 +996,7 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const [content, stat5] = await Promise.all([
+        const [content, stat6] = await Promise.all([
           fsp6.readFile(filePath, "utf8"),
           fsp6.stat(filePath)
         ]);
@@ -888,8 +1006,8 @@ var CollabSession = class extends EventEmitter {
           path: filePath,
           content,
           language,
-          snapshotMtimeMs: stat5.mtimeMs,
-          snapshotSizeBytes: stat5.size
+          snapshotMtimeMs: stat6.mtimeMs,
+          snapshotSizeBytes: stat6.size
         });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
@@ -1302,9 +1420,9 @@ 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 stat5 = await fsp6.stat(file.path);
-        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat5.mtimeMs > file.snapshotMtimeMs + 1;
-        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat5.size !== file.snapshotSizeBytes;
+        const stat6 = await fsp6.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat6.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat6.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
           warnings.push(`${file.path} changed after the collab snapshot was captured.`);
         }
@@ -4329,7 +4447,7 @@ function makeSpawnTool(director, roster) {
         if (err instanceof FleetCostCapError) {
           return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
         }
-        return { error: err instanceof Error ? err.message : String(err) };
+        return { error: toErrorMessage(err) };
       }
     }
   };
@@ -4411,7 +4529,7 @@ function makeAskTool(director) {
           _hint: "Response was large and stored. Use ask_result with the key to retrieve it."
         };
       } catch (err) {
-        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+        return { ok: false, error: toErrorMessage(err) };
       }
     }
   };
@@ -4637,7 +4755,7 @@ function makeCollabDebugTool(director) {
           evaluations: report.evaluations
         };
       } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = toErrorMessage(err);
         return { error: "collab_debug failed: " + msg };
       }
     }
@@ -4971,6 +5089,7 @@ function resolveModelMatrix(matrix, role) {
 
 // src/coordination/subagent-budget.ts
 var TIMEOUT_PREEMPT_FRACTION = 0.85;
+var DECISION_TIMEOUT_MS = 6e4;
 var BudgetExceededError = class extends Error {
   kind;
   limit;
@@ -5000,6 +5119,31 @@ var BudgetThresholdSignal = class extends Error {
 };
 var SubagentBudget = class _SubagentBudget {
   limits;
+  /** Patch one or more budget limits in-place after construction.
+   * Used by the coordinator watchdog when granting an extension.
+   * All fields are optional — only provided fields are updated.
+   * This is the single write path for limit mutations so that future
+   * validation or side-effects live in one place (M1). */
+  patchLimits(ext) {
+    if (ext.maxIterations !== void 0) {
+      this.limits.maxIterations = ext.maxIterations;
+    }
+    if (ext.maxToolCalls !== void 0) {
+      this.limits.maxToolCalls = ext.maxToolCalls;
+    }
+    if (ext.maxTokens !== void 0) {
+      this.limits.maxTokens = ext.maxTokens;
+    }
+    if (ext.maxCostUsd !== void 0) {
+      this.limits.maxCostUsd = ext.maxCostUsd;
+    }
+    if (ext.timeoutMs !== void 0) {
+      this.limits.timeoutMs = ext.timeoutMs;
+    }
+    if (ext.idleTimeoutMs !== void 0) {
+      this.limits.idleTimeoutMs = ext.idleTimeoutMs;
+    }
+  }
   iterations = 0;
   toolCalls = 0;
   tokenInput = 0;
@@ -5020,12 +5164,44 @@ var SubagentBudget = class _SubagentBudget {
    * or hung listener (Director not built / event filter detached mid-run)
    * leaves the budget over-limit and never enforces anything.
    */
-  static DECISION_TIMEOUT_MS = 6e4;
+  static DECISION_TIMEOUT_MS = DECISION_TIMEOUT_MS;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
    * Used to emit `budget.threshold_reached` events in `'auto'` mode.
    */
   _events;
+  /**
+   * Guard against dual-path races between the coordinator watchdog
+   * (`executeWithTimeout`) and the budget's own `checkTimeout()`.
+   * Both paths detect `elapsed >= timeoutMs` and can emit
+   * `budget.threshold_reached` for kind `'timeout'` simultaneously.
+   * Set to the current `timeoutMs` ceiling by the coordinator BEFORE
+   * calling `onThreshold`, and cleared after the negotiation resolves.
+   * `checkTimeout()` skips its wall-clock check while this is set so
+   * the coordinator's watchdog is the sole source of wall-clock timeout
+   * events — `checkTimeout()` focuses exclusively on `idle_timeout`.
+   */
+  _watchdogActive;
+  /** Returns the timeout ceiling currently being negotiated by the watchdog,
+   * or `undefined` when no wall-clock negotiation is in flight.
+   * Used by `executeWithTimeout` to detect a stale lock (M3). */
+  get watchdogActive() {
+    return this._watchdogActive;
+  }
+  /** Called by the coordinator watchdog BEFORE calling `onThreshold` so that
+   * `checkTimeout()` skips its wall-clock check for this ceiling. Prevents
+   * the budget's own `checkTimeout()` from emitting a second
+   * `budget.threshold_reached` event while the watchdog is already
+   * negotiating the same wall-clock deadline (C1). */
+  setWatchdogNegotiation(timeoutMs) {
+    this._watchdogActive = timeoutMs;
+  }
+  /** Clears the watchdog guard after negotiation resolves. Called in the
+   * `finally` block of both the pre-empt and deadline branches so it fires
+   * on every exit path: grant, deny, throw, or error. */
+  clearWatchdogNegotiation() {
+    this._watchdogActive = void 0;
+  }
   /**
    * Negotiation mode — controls whether a threshold hit tries to emit
    * `budget.threshold_reached` and wait for a coordinator decision, or
@@ -5126,7 +5302,8 @@ var SubagentBudget = class _SubagentBudget {
       if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
         exceeded.push({ kind: "idle_timeout", used: idle, limit: this.limits.idleTimeoutMs });
       }
-      if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs) {
+      const wallOwnedByWatchdog = this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
+      if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs && !wallOwnedByWatchdog) {
         exceeded.push({ kind: "timeout", used: elapsedMs, limit: this.limits.timeoutMs });
       }
     }
@@ -5140,19 +5317,99 @@ var SubagentBudget = class _SubagentBudget {
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     const bus = this._events;
-    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+    if (!bus) {
       const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
+    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
+    if (bus.hasListenerFor("budget.threshold_reached")) {
+      for (const entry of exceeded) {
+        if (this._pendingNegotiations.has(entry.kind)) continue;
+        this._pendingNegotiations.set(entry.kind, this._negotiateExtension(entry));
+      }
+      const decision = this._pendingNegotiations.get(first.kind);
+      if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
+      throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
+    }
+    let hardStop = null;
     for (const entry of exceeded) {
       if (this._pendingNegotiations.has(entry.kind)) continue;
-      const decision2 = this._negotiateExtension(entry.kind, exceeded);
-      this._pendingNegotiations.set(entry.kind, decision2);
+      const marker = Promise.resolve("stop");
+      this._pendingNegotiations.set(entry.kind, marker);
+      void marker.finally(() => this._pendingNegotiations.delete(entry.kind));
+      const sync = this._invokeHandlerSync(entry);
+      if (!sync) hardStop ??= new BudgetExceededError(entry.kind, entry.limit, entry.used);
     }
-    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
-    const decision = this._pendingNegotiations.get(first.kind);
-    if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
-    throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
+    if (hardStop) throw hardStop;
+    return exceeded;
+  }
+  /**
+   * Invoke `onThreshold` once for `entry` on the NO-LISTENER path and report
+   * whether it decided synchronously. Returns `true` when the handler returned
+   * a synchronous decision (already honored — an `extend` patched the limits),
+   * or `false` when it returned a Promise (async; the caller hard-stops, since
+   * there is no listener to resolve the negotiation). The handler is given the
+   * full info shape (`requestDecision` plus direct `extend`/`deny`) so both
+   * recording handlers and policy handlers work without a wired listener.
+   */
+  _invokeHandlerSync(entry) {
+    const handler = this._onThreshold;
+    if (!handler) return false;
+    let extendArg;
+    const result = handler({
+      kind: entry.kind,
+      used: entry.used,
+      limit: entry.limit,
+      requestDecision: () => this._busRequestDecision(entry),
+      // Direct hooks for synchronous policy/recording handlers.
+      extend: (extra) => {
+        extendArg = extra;
+      },
+      deny: () => {
+      }
+    });
+    if (result && typeof result.then === "function") return false;
+    if (result === "throw") return false;
+    if (result && typeof result === "object" && "extend" in result) {
+      extendArg = result.extend;
+    }
+    if (extendArg) this.patchLimits(extendArg);
+    return true;
+  }
+  /**
+   * Emit `budget.threshold_reached` and resolve to the listener's verdict.
+   * Resolves to `'stop'` immediately when there is no listener (or no bus) so
+   * no negotiation can hang and no fallback timer leaks. Mirrors the
+   * coordinator watchdog's own request path so both agree on the no-listener
+   * default.
+   */
+  _busRequestDecision(entry) {
+    const bus = this._events;
+    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+      return Promise.resolve("stop");
+    }
+    return new Promise((resolve3) => {
+      let resolved = false;
+      const respond = (d) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(fallback);
+        resolve3(d);
+      };
+      const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
+      bus.emit("budget.threshold_reached", {
+        kind: entry.kind,
+        used: entry.used,
+        limit: entry.limit,
+        timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+        // deny() wins over a same-dispatch extend(): a listener that both grants
+        // and denies (or two listeners disagreeing) is resolved as a stop. The
+        // grant is deferred a microtask so a synchronous deny in the same emit
+        // pre-empts it; async grants still resolve normally.
+        extend: (extra) => queueMicrotask(() => respond({ extend: extra })),
+        deny: () => respond("stop")
+      });
+    });
   }
   /**
    * Per-kind in-flight negotiation Promises. Each budget kind can have its
@@ -5172,77 +5429,33 @@ var SubagentBudget = class _SubagentBudget {
    * `{ extend: {} }` — keep going without patching; next overrun fires
    * a fresh signal.
    */
-  async _negotiateExtension(kind, exceeded) {
+  async _negotiateExtension(entry) {
     if (!this._onThreshold) {
       return "stop";
     }
     try {
-      const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       const result = this._onThreshold({
-        kind: first.kind,
-        used: first.used,
-        limit: first.limit,
-        requestDecision: () => {
-          const bus = this._events;
-          if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
-            return Promise.resolve("stop");
-          }
-          return new Promise((resolve3) => {
-            let resolved = false;
-            const respond = (d) => {
-              if (resolved) return;
-              resolved = true;
-              resolve3(d);
-            };
-            const fallback = setTimeout(
-              () => respond("stop"),
-              _SubagentBudget.DECISION_TIMEOUT_MS
-            );
-            for (const { kind: kind2, used, limit } of exceeded) {
-              bus.emit("budget.threshold_reached", {
-                kind: kind2,
-                used,
-                limit,
-                timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
-                extend: (extra) => {
-                  clearTimeout(fallback);
-                  respond({ extend: extra });
-                },
-                deny: () => {
-                  clearTimeout(fallback);
-                  respond("stop");
-                }
-              });
-            }
-          });
+        kind: entry.kind,
+        used: entry.used,
+        limit: entry.limit,
+        // One event for THIS kind only — each exceeded kind has its own
+        // negotiation (and its own resolve), so there is no cross-kind
+        // first-wins drop and no O(N^2) re-emission.
+        requestDecision: () => this._busRequestDecision(entry),
+        extend: (extra) => {
+          this.patchLimits(extra);
+        },
+        deny: () => {
         }
       });
       if (result === "throw") return "stop";
       if (result === "continue") return { extend: {} };
       const decision = await result;
       if (decision === "stop") return "stop";
-      const ext = decision.extend;
-      if (ext.maxIterations !== void 0) {
-        this.limits.maxIterations = ext.maxIterations;
-      }
-      if (ext.maxToolCalls !== void 0) {
-        this.limits.maxToolCalls = ext.maxToolCalls;
-      }
-      if (ext.maxTokens !== void 0) {
-        this.limits.maxTokens = ext.maxTokens;
-      }
-      if (ext.maxCostUsd !== void 0) {
-        this.limits.maxCostUsd = ext.maxCostUsd;
-      }
-      if (ext.timeoutMs !== void 0) {
-        this.limits.timeoutMs = ext.timeoutMs;
-      }
-      if (ext.idleTimeoutMs !== void 0) {
-        this.limits.idleTimeoutMs = ext.idleTimeoutMs;
-      }
+      this.patchLimits(decision.extend);
       return decision;
     } finally {
-      this._pendingNegotiations.delete(kind);
+      this._pendingNegotiations.delete(entry.kind);
     }
   }
   recordIteration() {
@@ -5285,7 +5498,8 @@ var SubagentBudget = class _SubagentBudget {
     const { timeoutMs, idleTimeoutMs } = this.limits;
     if (timeoutMs === void 0 && idleTimeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
-    const wallTripped = timeoutMs !== void 0 && elapsed > timeoutMs;
+    const wallSkipped = this._onThreshold !== void 0 && this._watchdogActive !== void 0 && timeoutMs !== void 0 && this._watchdogActive === timeoutMs;
+    const wallTripped = wallSkipped ? false : timeoutMs !== void 0 && elapsed > timeoutMs;
     const idleTripped = idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs;
     if (!wallTripped && !idleTripped) return;
     void this.checkLimits(elapsed);
@@ -5313,11 +5527,6 @@ var SubagentBudget = class _SubagentBudget {
   }
 };
 
-// src/utils/string.ts
-function truncate(s, max) {
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
-}
-
 // src/types/provider.ts
 var ProviderError = class extends WrongStackError {
   status;
@@ -5397,7 +5606,7 @@ function classifySubagentError(err, hints = {}) {
     const baseMessage2 = err.describe();
     return providerErrorToSubagentError(err, baseMessage2, cause);
   }
-  const baseMessage = err instanceof Error ? err.message : String(err);
+  const baseMessage = toErrorMessage(err);
   if (err instanceof BudgetExceededError) {
     const map = {
       iterations: "budget_iterations",
@@ -5912,6 +6121,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   terminating = /* @__PURE__ */ new Set();
   constructor(config, options = {}) {
     super();
+    this.setMaxListeners(0);
     this.coordinatorId = config.coordinatorId;
     this.config = config;
     this.runner = options.runner;
@@ -6306,7 +6516,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     let result;
     budget.start();
     try {
-      const outcome = await this.executeWithTimeout(this.runner, task, runCtx, budget);
+      const outcome = await this.executeWithTimeout(
+        this.runner,
+        task,
+        runCtx,
+        budget,
+        subagent.config.preemptFraction
+      );
       result = {
         subagentId,
         taskId: task.id,
@@ -6333,7 +6549,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     this.recordCompletion(result);
   }
-  async executeWithTimeout(runner, task, ctx, budget) {
+  async executeWithTimeout(runner, task, ctx, budget, preemptFraction = TIMEOUT_PREEMPT_FRACTION) {
     const initialTimeoutMs = budget.limits.timeoutMs;
     const idleLimitMs = budget.limits.idleTimeoutMs;
     if (initialTimeoutMs === void 0 && idleLimitMs === void 0) {
@@ -6341,8 +6557,21 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     const start = Date.now();
     let timer = null;
-    let preemptedForLimit = null;
+    let PreemptState;
+    ((PreemptState2) => {
+      PreemptState2["ACTIVE"] = "active";
+      PreemptState2["LOCKED"] = "locked";
+    })(PreemptState || (PreemptState = {}));
+    let preemptedCeiling = null;
+    let preemptState = "active" /* ACTIVE */;
+    let lastGrantActivityTs = -1;
     const timeoutPromise = new Promise((_, reject) => {
+      const terminate = (kind, limit, used) => {
+        this.subagents.get(ctx.subagentId)?.abortController.abort();
+        reject(
+          budget._events?.hasListenerFor("budget.threshold_reached") ? new Error(`subagent stopped: budget ${kind} (limit=${limit}, used=${used})`) : new BudgetExceededError(kind, limit, used)
+        );
+      };
       const armFor = (ms) => {
         if (timer) clearTimeout(timer);
         timer = setTimeout(onTick, Math.max(0, ms));
@@ -6351,7 +6580,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         const wallLimit = budget.limits.timeoutMs ?? initialTimeoutMs;
         const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : wallLimit - (Date.now() - start);
         const idleRemaining = idleLimitMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
-        const preemptRemaining = initialTimeoutMs === void 0 || preemptedForLimit === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * TIMEOUT_PREEMPT_FRACTION - (Date.now() - start);
+        const preemptRemaining = initialTimeoutMs === void 0 || preemptedCeiling === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * preemptFraction - (Date.now() - start);
         armFor(Math.max(25, Math.min(wallRemaining, idleRemaining, preemptRemaining)));
       };
       const negotiateTimeout = async (used, limit) => {
@@ -6361,16 +6590,42 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
           kind: "timeout",
           used,
           limit,
-          requestDecision: () => new Promise((resolveDecision) => {
-            budget._events?.emit("budget.threshold_reached", {
-              kind: "timeout",
-              used,
-              limit,
-              timeoutMs: 6e4,
-              extend: (extra) => resolveDecision({ extend: extra }),
-              deny: () => resolveDecision("stop")
+          requestDecision: () => {
+            if (!budget._events?.hasListenerFor("budget.threshold_reached")) {
+              return Promise.resolve("stop");
+            }
+            return new Promise((resolveDecision) => {
+              let settled = false;
+              const resolve3 = (d) => {
+                if (settled) return;
+                settled = true;
+                resolveDecision(d);
+              };
+              const fallback = setTimeout(() => resolve3("stop"), DECISION_TIMEOUT_MS);
+              budget._events?.emit("budget.threshold_reached", {
+                kind: "timeout",
+                used,
+                limit,
+                // Informational: the budget's own decision deadline. Listeners may use
+                // this to display a countdown. The coordinator does NOT enforce it —
+                // it is the budget's own `setTimeout(fallback)` that races against
+                // the listener's `extend()`/`deny()` call to guarantee progress.
+                timeoutMs: DECISION_TIMEOUT_MS,
+                // deny() wins over a same-dispatch extend(): defer the grant a
+                // microtask so a synchronous deny in the same emit pre-empts it
+                // (a listener that both grants and denies, or two listeners
+                // disagreeing, resolves as a stop). Async grants still resolve.
+                extend: (extra) => {
+                  clearTimeout(fallback);
+                  queueMicrotask(() => resolve3({ extend: extra }));
+                },
+                deny: () => {
+                  clearTimeout(fallback);
+                  resolve3("stop");
+                }
+              });
             });
-          })
+          }
         });
         return typeof result === "string" ? result : await result;
       };
@@ -6381,21 +6636,45 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         const wallExceeded = wallLimit !== void 0 && elapsed >= wallLimit;
         const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
         if (idleExceeded && !wallExceeded) {
+          budget._events?.emit("budget.threshold_reached", {
+            kind: "idle_timeout",
+            used: budget.idleMs(),
+            limit: idleLimit ?? 0,
+            timeoutMs: DECISION_TIMEOUT_MS,
+            extend: () => {
+            },
+            deny: () => {
+            }
+          });
           this.subagents.get(ctx.subagentId)?.abortController.abort();
-          reject(new BudgetExceededError("timeout", idleLimit ?? 0, budget.idleMs()));
+          reject(new BudgetExceededError("idle_timeout", idleLimit ?? 0, budget.idleMs()));
           return;
         }
-        if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptedForLimit !== wallLimit && elapsed >= wallLimit * TIMEOUT_PREEMPT_FRACTION) {
+        if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed >= wallLimit * preemptFraction) {
+          const activityTs = Date.now() - budget.idleMs();
+          if (activityTs <= lastGrantActivityTs) {
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
+            scheduleNext();
+            return;
+          }
+          budget.setWatchdogNegotiation(wallLimit);
           try {
             const decision = await negotiateTimeout(elapsed, wallLimit);
             if (typeof decision !== "string" && decision.extend.timeoutMs !== void 0) {
-              budget.limits.timeoutMs = decision.extend.timeoutMs;
-              preemptedForLimit = null;
+              budget.patchLimits({ timeoutMs: decision.extend.timeoutMs });
+              lastGrantActivityTs = Date.now() - budget.idleMs();
+              preemptState = "active" /* ACTIVE */;
+              preemptedCeiling = null;
             } else {
-              preemptedForLimit = wallLimit;
+              preemptState = "locked" /* LOCKED */;
+              preemptedCeiling = wallLimit;
             }
           } catch {
-            preemptedForLimit = wallLimit;
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
+          } finally {
+            budget.clearWatchdogNegotiation();
           }
           scheduleNext();
           return;
@@ -6410,26 +6689,41 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
           reject(new BudgetExceededError("timeout", limit, elapsed));
           return;
         }
+        budget.setWatchdogNegotiation(limit);
         try {
           const decision = await negotiateTimeout(elapsed, limit);
-          if (decision === "continue" || decision === "throw" || decision === "stop") {
-            preemptedForLimit = null;
+          if (decision === "throw") {
+            terminate("timeout", limit, elapsed);
+            return;
+          }
+          if (decision === "continue") {
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
             armFor(Math.max(1e3, limit));
             return;
           }
+          if (decision === "stop") {
+            terminate("timeout", limit, elapsed);
+            return;
+          }
           if (decision.extend.timeoutMs !== void 0) {
-            budget.limits.timeoutMs = decision.extend.timeoutMs;
-            preemptedForLimit = null;
+            budget.patchLimits({ timeoutMs: decision.extend.timeoutMs });
+            lastGrantActivityTs = Date.now() - budget.idleMs();
+            preemptState = "active" /* ACTIVE */;
+            preemptedCeiling = null;
             scheduleNext();
             return;
           }
-          this.subagents.get(ctx.subagentId)?.abortController.abort();
-          reject(new BudgetExceededError("timeout", limit, elapsed));
+          terminate("timeout", limit, elapsed);
+          return;
         } catch (err) {
           this.subagents.get(ctx.subagentId)?.abortController.abort();
           reject(
             err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
           );
+          return;
+        } finally {
+          budget.clearWatchdogNegotiation();
         }
       };
       scheduleNext();
@@ -7383,7 +7677,7 @@ var Director = class _Director {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp6.mkdir(path4.dirname(this.manifestPath), { recursive: true });
+    await fsp6.mkdir(path5.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -7433,7 +7727,7 @@ var Director = class _Director {
    * listener for structured collection, and never affects exit code.
    */
   logShutdownError(phase, err) {
-    const detail = err instanceof Error ? err.message : String(err);
+    const detail = toErrorMessage(err);
     process.emitWarning(
       `Director shutdown phase "${phase}" failed: ${detail}`,
       "DirectorShutdownWarning"
@@ -7597,7 +7891,7 @@ var Director = class _Director {
    */
   async readSession(subagentId, tail) {
     if (!this.sessionsRoot) return null;
-    const filePath = path4.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
+    const filePath = path5.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
     let raw;
     try {
       raw = await fsp6.readFile(filePath, "utf8");
@@ -8026,7 +8320,7 @@ function createDelegateTool(opts) {
           summary
         };
       } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+        const message = toErrorMessage(err);
         opts.events?.emit("delegate.completed", {
           target,
           task: i.task,
@@ -8127,13 +8421,13 @@ async function readSubagentPartial(opts, subagentId) {
   if (!opts.sessionsRoot) return void 0;
   const candidates = [];
   if (opts.directorRunId) {
-    candidates.push(path4.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
+    candidates.push(path5.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
   } else {
     try {
       const entries = await fsp6.readdir(opts.sessionsRoot, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          candidates.push(path4.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
+          candidates.push(path5.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
         }
       }
     } catch {
@@ -8389,119 +8683,48 @@ function makeAgentSubagentRunner(opts) {
 function defaultFormatTaskInput(task) {
   return task.description ?? "";
 }
-
-// src/utils/message-invariants.ts
-function repairToolUseAdjacency(messages) {
-  const removedToolUses = [];
-  const removedToolResults = [];
-  let removedMessages = 0;
-  let changed = false;
-  const out = [];
-  for (let i = 0; i < messages.length; i++) {
-    const original = expectDefined(messages[i]);
-    let msg = original;
-    if (hasToolUse(msg)) {
-      const nextIds = toolResultIds(messages[i + 1]);
-      const filtered = mapContent(msg, (blocks) => {
-        const next = [];
-        for (const block of blocks) {
-          if (block.type === "tool_use" && !nextIds.has(block.id)) {
-            removedToolUses.push(block.id);
-            changed = true;
-            continue;
-          }
-          next.push(block);
-        }
-        return next;
-      });
-      msg = filtered ?? msg;
-    }
-    if (hasToolResult(msg)) {
-      const allowed = toolUseIds(out[out.length - 1]);
-      const filtered = mapContent(msg, (blocks) => {
-        const next = [];
-        for (const block of blocks) {
-          if (block.type === "tool_result" && !allowed.has(block.tool_use_id)) {
-            removedToolResults.push(block.tool_use_id);
-            changed = true;
-            continue;
-          }
-          next.push(block);
-        }
-        return next;
-      });
-      msg = filtered ?? msg;
-    }
-    if (isEmptyMessage(msg)) {
-      removedMessages++;
-      changed = true;
-      continue;
-    }
-    out.push(msg);
-  }
-  return {
-    messages: changed ? out : messages,
-    report: { changed, removedToolUses, removedToolResults, removedMessages }
-  };
-}
-function hasToolUse(msg) {
-  return contentBlocks(msg).some((b) => b.type === "tool_use");
+function sanitizeModel(model) {
+  return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
 }
-function hasToolResult(msg) {
-  return contentBlocks(msg).some((b) => b.type === "tool_result");
-}
-function toolUseIds(msg) {
-  const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "assistant") return ids;
-  for (const block of contentBlocks(msg)) {
-    if (block.type === "tool_use") ids.add(block.id);
-  }
-  return ids;
-}
-function toolResultIds(msg) {
-  const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "user") return ids;
-  for (const block of contentBlocks(msg)) {
-    if (block.type === "tool_result") ids.add(block.tool_use_id);
-  }
-  return ids;
-}
-function contentBlocks(msg) {
-  return msg && Array.isArray(msg.content) ? msg.content : [];
-}
-function mapContent(msg, fn) {
-  if (!Array.isArray(msg.content)) return msg;
-  const next = fn(msg.content);
-  if (next.length === msg.content.length && next.every((b, idx) => b === msg.content[idx])) {
-    return msg;
-  }
-  return { ...msg, content: next };
-}
-function isEmptyMessage(msg) {
-  if (typeof msg.content === "string") return msg.content.trim().length === 0;
-  return msg.content.length === 0;
-}
-
-// src/storage/session-store.ts
-function sanitizeModel(model) {
-  return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
-}
-function generateSessionId(startedAt, model) {
-  const date = startedAt.slice(0, 10);
-  const time = startedAt.slice(11, 19).replace(/:/g, "-");
-  const suffix = randomBytes(2).toString("hex");
-  const modelPart = model ? `_${sanitizeModel(model)}` : "";
-  return `${date}/${time}Z${modelPart}_${suffix}`;
+function generateSessionId(startedAt, model) {
+  const date = startedAt.slice(0, 10);
+  const time = startedAt.slice(11, 19).replace(/:/g, "-");
+  const suffix = randomBytes(2).toString("hex");
+  const modelPart = model ? `_${sanitizeModel(model)}` : "";
+  return `${date}/${time}Z${modelPart}_${suffix}`;
 }
 var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
   secretScrubber;
+  /**
+   * In-memory cache for load() results, keyed by session ID. The cache is
+   * invalidated when the file's mtimeMs or size changes (indicating the
+   * file was written to). This eliminates redundant full-file reads and
+   * JSON parses when the same session is loaded multiple times within the
+   * store's lifetime (e.g., webui session detail views, list() fallbacks).
+   *
+   * Max size is capped to prevent unbounded memory growth in long-running
+   * processes. When the limit is reached, the oldest entry is evicted.
+   */
+  _loadCache = /* @__PURE__ */ new Map();
+  static LOAD_CACHE_MAX_ENTRIES = 50;
   constructor(opts) {
     this.dir = opts.dir;
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
   }
+  /**
+   * Clear the load() cache. Useful for testing or when the caller knows
+   * the file has changed externally (e.g., another process wrote to it).
+   */
+  clearLoadCache(sessionId) {
+    if (sessionId !== void 0) {
+      this._loadCache.delete(sessionId);
+    } else {
+      this._loadCache.clear();
+    }
+  }
   // ── Storage event helpers ───────────────────────────────────────────────────
   emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
     this.events?.emit("storage.read", {
@@ -8538,11 +8761,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   /** Absolute path to the session index file. */
   get indexFile() {
-    return path4.join(this.dir, "_index.jsonl");
+    return path5.join(this.dir, "_index.jsonl");
   }
   /** Join session ID to its absolute path within the store directory. */
   sessionPath(id, ext) {
-    return path4.join(this.dir, `${id}${ext}`);
+    return path5.join(this.dir, `${id}${ext}`);
   }
   /**
    * Ensure the directory implied by the session ID exists. When the ID
@@ -8550,7 +8773,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * subdirectory so sessions group naturally by day.
    */
   async ensureShardDir(id) {
-    const dirPath = path4.dirname(path4.join(this.dir, id));
+    const dirPath = path5.dirname(path5.join(this.dir, id));
     await ensureDir(dirPath);
     return dirPath;
   }
@@ -8558,15 +8781,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const id = meta.id && meta.id.length > 0 ? meta.id : generateSessionId(startedAt, meta.model ?? meta.provider);
     const shardDir = await this.ensureShardDir(id);
-    const file = path4.join(shardDir, `${path4.basename(id)}.jsonl`);
+    const file = path5.join(shardDir, `${path5.basename(id)}.jsonl`);
     const t0 = Date.now();
     let handle;
     try {
       handle = await fsp6.open(file, "a", 384);
     } catch (err) {
-      this.emitError(id, file, "create", err instanceof Error ? err.message : String(err), false);
+      this.emitError(id, file, "create", toErrorMessage(err), false);
       throw new Error(
-        `Failed to open session file: ${err instanceof Error ? err.message : String(err)}`,
+        `Failed to open session file: ${toErrorMessage(err)}`,
         { cause: err }
       );
     }
@@ -8586,7 +8809,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         message: e instanceof Error ? e.message : String(e),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       })));
-      this.emitError(id, file, "create", err instanceof Error ? err.message : String(err), true);
+      this.emitError(id, file, "create", toErrorMessage(err), true);
       throw err;
     }
   }
@@ -8598,9 +8821,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
     try {
       handle = await fsp6.open(file, "a", 384);
     } catch (err) {
-      this.emitError(id, file, "resume", err instanceof Error ? err.message : String(err), false);
+      this.emitError(id, file, "resume", toErrorMessage(err), false);
       throw new Error(
-        `Failed to open session "${id}" for append: ${err instanceof Error ? err.message : String(err)}`,
+        `Failed to open session "${id}" for append: ${toErrorMessage(err)}`,
         { cause: err }
       );
     }
@@ -8620,7 +8843,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: path4.dirname(file),
+          dir: path5.dirname(file),
           filePath: file,
           secretScrubber: this.secretScrubber,
           onClose: (s) => this.appendToIndex(s)
@@ -8635,7 +8858,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         message: e instanceof Error ? e.message : String(e),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       })));
-      this.emitError(id, file, "resume", err instanceof Error ? err.message : String(err), true);
+      this.emitError(id, file, "resume", toErrorMessage(err), true);
       throw err;
     }
   }
@@ -8644,7 +8867,20 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
+    let cacheHit = false;
     try {
+      let stat6;
+      try {
+        const s = await fsp6.stat(file);
+        stat6 = { mtimeMs: s.mtimeMs, size: s.size };
+      } catch (err) {
+        throw err;
+      }
+      const cached = this._loadCache.get(id);
+      if (cached && cached.mtimeMs === stat6.mtimeMs && cached.size === stat6.size) {
+        cacheHit = true;
+        return cached.data;
+      }
       const raw = await fsp6.readFile(file, "utf8");
       const lines = raw.split("\n").filter((l) => l.trim());
       const events = [];
@@ -8660,13 +8896,30 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const meta = this.metaFromEvents(id, events);
       const { messages, usage } = this.replay(events, id);
       const toolCallEnds = extractToolCallEnds(events);
-      return { metadata: meta, events, messages, usage, toolCallEnds };
+      const data = { metadata: meta, events, messages, usage, toolCallEnds };
+      if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
+        const oldest = this._loadCache.keys().next().value;
+        if (oldest !== void 0) {
+          this._loadCache.delete(oldest);
+        }
+      }
+      this._loadCache.set(id, { mtimeMs: stat6.mtimeMs, size: stat6.size, data });
+      return data;
     } catch (err) {
       outcome = "failure";
-      errorMsg = err instanceof Error ? err.message : String(err);
+      errorMsg = toErrorMessage(err);
       throw err;
     } finally {
       this.emitRead(id, file, "load", outcome, Date.now() - t0, errorMsg);
+      if (cacheHit) {
+        this.events?.emit("storage.cache_hit", {
+          sessionId: id,
+          store: "session",
+          filePath: file,
+          operation: "load",
+          durationMs: Date.now() - t0
+        });
+      }
     }
   }
   async list(limit = 20) {
@@ -8746,7 +8999,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await fsp6.rename(tmp, this.indexFile);
     } catch (err) {
       outcome = "failure";
-      errorMsg = err instanceof Error ? err.message : String(err);
+      errorMsg = toErrorMessage(err);
     } finally {
       this.emitWrite("~compact~", this.indexFile, "compact", outcome, Date.now() - t0, void 0, errorMsg);
     }
@@ -8814,7 +9067,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         continue;
       if (entry.isDirectory()) {
         const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        ids.push(...await this.collectSessionIds(path4.join(dir, entry.name), childPrefix, depth + 1));
+        ids.push(...await this.collectSessionIds(path5.join(dir, entry.name), childPrefix, depth + 1));
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
         if (entry.name === "_index.jsonl") continue;
         const base = entry.name.replace(/\.jsonl$/, "");
@@ -8834,10 +9087,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat5 = await fsp6.stat(full);
-      const summary = await this.summarize(id, stat5.mtime.toISOString());
+      const stat6 = await fsp6.stat(full);
+      const summary = await this.summarize(id, stat6.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
         console.warn(JSON.stringify({
           level: "warn",
@@ -8865,14 +9118,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async deleteSession(id) {
     const jsonlPath = this.sessionPath(id, ".jsonl");
     const summaryPath = this.sessionPath(id, ".summary.json");
-    const shardDir = path4.dirname(path4.join(this.dir, id));
-    const base = path4.basename(id);
-    const sessDir = path4.join(shardDir, base);
+    const shardDir = path5.dirname(path5.join(this.dir, id));
+    const base = path5.basename(id);
+    const sessDir = path5.join(shardDir, base);
     const deletions = [
       fsp6.unlink(jsonlPath),
       fsp6.unlink(summaryPath),
-      fsp6.unlink(path4.join(shardDir, `${base}.plan.json`)),
-      fsp6.unlink(path4.join(shardDir, `${base}.todos.json`))
+      fsp6.unlink(path5.join(shardDir, `${base}.plan.json`)),
+      fsp6.unlink(path5.join(shardDir, `${base}.todos.json`))
     ];
     const results = await Promise.allSettled(deletions);
     for (const r of results) {
@@ -8894,7 +9147,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         level: "warn",
         event: "session_store.rmdir_failed",
         sessionId: id,
-        message: err instanceof Error ? err.message : String(err),
+        message: toErrorMessage(err),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
     });
@@ -8908,17 +9161,17 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let deleted = 0;
     let activeSessionId = null;
     try {
-      const raw = await fsp6.readFile(path4.join(this.dir, "active.json"), "utf8");
+      const raw = await fsp6.readFile(path5.join(this.dir, "active.json"), "utf8");
       const active = JSON.parse(raw);
       activeSessionId = active.sessionId ?? null;
     } catch {
     }
     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 = path4.join(dir, name);
+      const jsonlPath = path5.join(dir, name);
       try {
-        const stat5 = await fsp6.stat(jsonlPath);
-        if (stat5.mtimeMs >= cutoff) return;
+        const stat6 = await fsp6.stat(jsonlPath);
+        if (stat6.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -8935,7 +9188,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         continue;
       }
       if (!entry.isDirectory()) continue;
-      const dateDir = path4.join(this.dir, entry.name);
+      const dateDir = path5.join(this.dir, entry.name);
       const files = await fsp6.readdir(dateDir, { withFileTypes: true }).catch(() => []);
       for (const file of files) {
         if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
@@ -8947,7 +9200,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const dateDir = path4.join(this.dir, entry.name);
+      const dateDir = path5.join(this.dir, entry.name);
       try {
         const remaining = await fsp6.readdir(dateDir);
         if (remaining.length === 0) {
@@ -9122,7 +9375,7 @@ var FileSessionWriter = class _FileSessionWriter {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path4.join(opts.dir, `${path4.basename(id)}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path5.join(opts.dir, `${path5.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
     this.onCloseCb = opts.onClose;
@@ -9329,7 +9582,7 @@ var FileSessionWriter = class _FileSessionWriter {
       await this.enqueueWrite(batch);
     } catch (err) {
       outcome = "failure";
-      errorMsg = err instanceof Error ? err.message : String(err);
+      errorMsg = toErrorMessage(err);
       this.appendFailCount += eventCount;
       const now = Date.now();
       if (now - this.lastAppendWarnAt > 5e3) {
@@ -9337,7 +9590,7 @@ var FileSessionWriter = class _FileSessionWriter {
         const tail = suppressed > 0 ? ` (+${suppressed} suppressed)` : "";
         console.warn(
           "[session] flush failed:",
-          err instanceof Error ? err.message : String(err),
+          toErrorMessage(err),
           tail
         );
         this.lastAppendWarnAt = now;
@@ -9427,7 +9680,7 @@ var FileSessionWriter = class _FileSessionWriter {
         await atomicWrite(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
       } catch (err) {
         outcome = "failure";
-        errorMsg = err instanceof Error ? err.message : String(err);
+        errorMsg = toErrorMessage(err);
       } finally {
         this.events?.emit("storage.write", {
           sessionId: this.id,
@@ -9448,7 +9701,7 @@ var FileSessionWriter = class _FileSessionWriter {
       await this.onCloseCb?.(this.summary);
     } catch (err) {
       idxOutcome = "failure";
-      idxError = err instanceof Error ? err.message : String(err);
+      idxError = toErrorMessage(err);
     } finally {
       this.events?.emit("storage.write", {
         sessionId: this.summary.id,
@@ -9625,9 +9878,9 @@ function makeDirectorSessionFactory(opts) {
   let dir;
   if (opts.store) {
     store = opts.store;
-    dir = opts.sessionsRoot ? path4.join(opts.sessionsRoot, runId) : "(caller-managed)";
+    dir = opts.sessionsRoot ? path5.join(opts.sessionsRoot, runId) : "(caller-managed)";
   } else if (opts.sessionsRoot) {
-    dir = path4.join(opts.sessionsRoot, runId);
+    dir = path5.join(opts.sessionsRoot, runId);
     store = new DefaultSessionStore({ dir });
   } else {
     throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
@@ -9673,6 +9926,7 @@ function attachAutoExtend(events, policy = {}) {
   const extendCounts = /* @__PURE__ */ new Map();
   let progress = 0;
   let lastTimeoutProgress = -1;
+  let lastSeenKey = null;
   const unsubs = [
     events.on("tool.executed", () => {
       progress++;
@@ -9682,6 +9936,9 @@ function attachAutoExtend(events, policy = {}) {
     }),
     events.on("budget.threshold_reached", (e) => {
       const { kind, limit, extend, deny } = e;
+      const key = `${kind}:${limit}`;
+      if (key === lastSeenKey) return;
+      lastSeenKey = key;
       if (kind === "timeout" || kind === "idle_timeout") {
         if (progress > lastTimeoutProgress) {
           lastTimeoutProgress = progress;
@@ -9935,7 +10192,7 @@ var FleetManager = class {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp6.mkdir(path4.dirname(this.manifestPath), { recursive: true });
+    await fsp6.mkdir(path5.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -9956,7 +10213,7 @@ var FleetManager = class {
     if (!this.manifestPath) return;
     if (this.manifestDebounceMs === 0) {
       void this.writeManifest().catch((err) => {
-        const detail = err instanceof Error ? err.message : String(err);
+        const detail = toErrorMessage(err);
         process.emitWarning(
           `FleetManager manifest write failed: ${detail}`,
           "FleetManagerWarning"
@@ -9969,7 +10226,7 @@ var FleetManager = class {
     this.manifestTimer = setTimeout(() => {
       this.manifestTimer = null;
       void this.writeManifest().catch((err) => {
-        const detail = err instanceof Error ? err.message : String(err);
+        const detail = toErrorMessage(err);
         process.emitWarning(
           `FleetManager manifest write failed: ${detail}`,
           "FleetManagerWarning"
@@ -9988,7 +10245,7 @@ var FleetManager = class {
       this.manifestTimer = null;
     }
     await this.writeManifest().catch((err) => {
-      const detail = err instanceof Error ? err.message : String(err);
+      const detail = toErrorMessage(err);
       process.emitWarning(
         `FleetManager manifest write failed: ${detail}`,
         "FleetManagerWarning"
@@ -10083,7 +10340,7 @@ var LINE_SEPARATOR = "\n";
 var DefaultMailbox = class {
   filePath;
   constructor(sessionDir) {
-    this.filePath = path4.join(sessionDir, MAILBOX_FILE);
+    this.filePath = path5.join(sessionDir, MAILBOX_FILE);
   }
   get mailboxPath() {
     return this.filePath;
@@ -10108,7 +10365,7 @@ var DefaultMailbox = class {
       taskContext: input.taskContext
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR;
-    await fsp6.mkdir(path4.dirname(this.filePath), { recursive: true });
+    await fsp6.mkdir(path5.dirname(this.filePath), { recursive: true });
     await withFileLock(this.filePath, async () => {
       await fsp6.appendFile(this.filePath, line, "utf8");
     });
@@ -10148,29 +10405,43 @@ var DefaultMailbox = class {
   }
   // ── Ack ───────────────────────────────────────────────────────────────
   async ack(input) {
-    let result = null;
+    const updated = await this.ackMany({ acks: [input] });
+    return updated.length > 0 ? updated[0] : null;
+  }
+  async ackMany(input) {
+    if (input.acks.length === 0) return [];
+    const updated = [];
+    const byId = /* @__PURE__ */ new Map();
+    for (const a of input.acks) byId.set(a.messageId, a);
     await withFileLock(this.filePath, async () => {
       const all = await this._readAll();
-      const idx = all.findIndex((m) => m.id === input.messageId);
-      if (idx === -1) return;
-      const msg = all[idx];
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      if (input.read !== false) {
-        msg.readBy[input.readerId] = now;
-      }
-      if (input.completed) {
-        msg.completed = true;
-        msg.completedBy = input.readerId;
-        msg.completedAt = now;
+      let changed = false;
+      for (const msg of all) {
+        const a = byId.get(msg.id);
+        if (!a) continue;
+        updated.push(msg);
+        if (a.read !== false && !(a.readerId in msg.readBy)) {
+          msg.readBy[a.readerId] = now;
+          changed = true;
+        }
+        if (a.completed && !msg.completed) {
+          msg.completed = true;
+          msg.completedBy = a.readerId;
+          msg.completedAt = now;
+          changed = true;
+        }
+        if (a.outcome !== void 0 && msg.outcome !== a.outcome) {
+          msg.outcome = a.outcome;
+          changed = true;
+        }
       }
-      if (input.outcome !== void 0) {
-        msg.outcome = input.outcome;
+      if (changed) {
+        const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
+        await fsp6.writeFile(this.filePath, serialized, "utf8");
       }
-      const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-      await fsp6.writeFile(this.filePath, serialized, "utf8");
-      result = msg;
     });
-    return result;
+    return updated;
   }
   // ── Agent statuses ────────────────────────────────────────────────────
   async getAgentStatuses() {
@@ -10222,6 +10493,43 @@ var DefaultMailbox = class {
       await fsp6.writeFile(this.filePath, "", "utf8");
     });
   }
+  async purgeStale(opts) {
+    const COMPLETED_MAX_AGE_MS = opts?.completedMaxAgeMs ?? 864e5;
+    const INCOMPLETE_MAX_AGE_MS = opts?.incompleteMaxAgeMs ?? 6048e5;
+    let completedPurged = 0;
+    let incompletePurged = 0;
+    await withFileLock(this.filePath, async () => {
+      const all2 = await this._readAll();
+      const now = Date.now();
+      const cutoffCompleted = now - COMPLETED_MAX_AGE_MS;
+      const cutoffIncomplete = now - INCOMPLETE_MAX_AGE_MS;
+      const kept = [];
+      for (const msg of all2) {
+        const msgTime = new Date(msg.timestamp).getTime();
+        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);
+      }
+      if (kept.length < all2.length) {
+        const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
+        await fsp6.writeFile(this.filePath, content, "utf8");
+      }
+    });
+    const all = await this._readAll();
+    return {
+      completedPurged,
+      incompletePurged,
+      totalPurged: completedPurged + incompletePurged,
+      remaining: all.length
+    };
+  }
   // ── Client registry stubs (not applicable per-session) ─────────────────
   async registerClient(_input) {
   }
@@ -10340,7 +10648,8 @@ var BrainMonitor = class {
             id: "steer",
             label: "Steer the agent with corrective guidance",
             consequence: "A steer message is injected before its next step.",
-            risk: "low"
+            risk: "low",
+            recommended: true
           },
           {
             id: "continue",
@@ -10349,9 +10658,9 @@ var BrainMonitor = class {
           }
         ],
         risk: "medium",
-        // Without an LLM layer the policy brain resolves this fallback to
-        // "continue" — the monitor observes but never interferes.
-        fallback: "continue"
+        // 'ask_human' routes to the LLM-backed autonomous layer via
+        // createTieredBrainArbiter before any human escalation.
+        fallback: "ask_human"
       };
       const decision = await this.opts.brain.decide(request);
       const intervened = await this.maybeIntervene(kind, request, decision);
@@ -10390,21 +10699,6 @@ var BrainMonitor = class {
     }
   }
 };
-function projectSlug(absRoot) {
-  const base = slugify(path4.basename(absRoot));
-  const hash = createHash("sha256").update(path4.resolve(absRoot)).digest("hex").slice(0, 6);
-  return `${base}-${hash}`;
-}
-function slugify(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
-}
-function wstackGlobalRoot() {
-  const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path4.resolve(fromEnv);
-  return path4.join(os.homedir(), ".wrongstack");
-}
-
-// src/coordination/global-mailbox.ts
 var MAILBOX_FILE2 = "_mailbox.jsonl";
 var CLIENT_REGISTRY_FILE = "_mailbox.clients.json";
 var AGENT_STALE_MS = 6e4;
@@ -10412,8 +10706,9 @@ var CLIENT_STALE_MS = 6e4;
 var HEARTBEAT_THROTTLE_MS = 5e3;
 var REGISTRY_CACHE_TTL_MS = 2e3;
 var LINE_SEPARATOR2 = "\n";
+var MESSAGE_CACHE_MAX_ENTRIES = 1e4;
 function resolveProjectDir(projectRoot, globalRoot) {
-  return path4.join(globalRoot, "projects", projectSlug(projectRoot));
+  return path5.join(globalRoot, "projects", projectSlug(projectRoot));
 }
 var GlobalMailbox = class {
   /** Path to the JSONL message file. */
@@ -10444,14 +10739,28 @@ var GlobalMailbox = class {
   _lastHeartbeat = /* @__PURE__ */ new Map();
   /** Last time each local client sent a heartbeat (throttle). */
   _lastClientHeartbeat = /* @__PURE__ */ new Map();
+  /**
+   * In-memory mirror of the JSONL message file. The mailbox is shared
+   * ACROSS PROCESSES, so reads cannot trust the cache blindly — we pair it
+   * with an mtime check. The file lock serializes every write, so a
+   * changed mtimeMs is a definitive signal that another process (or this
+   * one) wrote; an unchanged mtimeMs guarantees no write happened and the
+   * cache is current. This collapses the per-iteration `query()` cost from
+   * O(file_size) disk + parse to O(messages) in memory.
+   */
+  _messageCache = null;
+  /** mtimeMs of the file when `_messageCache` was populated. */
+  _messageCacheMtime = -1;
+  /** Size of the file when `_messageCache` was populated (extra guard). */
+  _messageCacheSize = -1;
   /**
    * @param projectDir — `~/.wrongstack/projects/<slug>/`
    * @param events — optional EventBus for real-time TUI/WebUI notifications
    */
   constructor(projectDir, events) {
-    this.messagePath = path4.join(projectDir, MAILBOX_FILE2);
-    this.registryPath = path4.join(projectDir, "_mailbox.registry.json");
-    this.clientRegistryPath = path4.join(projectDir, CLIENT_REGISTRY_FILE);
+    this.messagePath = path5.join(projectDir, MAILBOX_FILE2);
+    this.registryPath = path5.join(projectDir, "_mailbox.registry.json");
+    this.clientRegistryPath = path5.join(projectDir, CLIENT_REGISTRY_FILE);
     this._events = events;
   }
   // ── Messages ────────────────────────────────────────────────────────────
@@ -10474,73 +10783,89 @@ var GlobalMailbox = class {
       taskContext: input.taskContext
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR2;
-    await fsp6.mkdir(path4.dirname(this.messagePath), { recursive: true });
+    await fsp6.mkdir(path5.dirname(this.messagePath), { recursive: true });
     await withFileLock(this.messagePath, async () => {
       await fsp6.appendFile(this.messagePath, line, "utf8");
+      this._pushToCache(msg);
     });
     return msg;
   }
   async query(q) {
-    const all = await this._readMessages();
+    const all = await this._readMessagesCached();
     const limit = q.limit ?? 50;
-    let filtered = all;
-    if (q.to !== void 0) {
-      filtered = filtered.filter((m) => m.to === q.to || m.to === "*");
-    }
-    if (q.from !== void 0) {
-      filtered = filtered.filter((m) => m.from === q.from);
-    }
-    if (q.unreadBy !== void 0) {
-      filtered = filtered.filter((m) => !(q.unreadBy in m.readBy));
-    }
-    if (q.incompleteOnly) {
-      filtered = filtered.filter((m) => !m.completed);
-    }
-    if (q.type !== void 0) {
-      filtered = filtered.filter((m) => m.type === q.type);
-    }
-    if (q.minPriority !== void 0) {
-      const order = { low: 0, normal: 1, high: 2 };
-      const min = order[q.minPriority];
-      filtered = filtered.filter((m) => (order[m.priority] ?? 1) >= min);
-    }
-    if (q.since !== void 0) {
-      const since = q.since;
-      filtered = filtered.filter((m) => m.timestamp > since);
+    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];
+      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 (order !== null && (order[m.priority] ?? 1) < minPriorityRank) {
+        continue;
+      }
+      if (q.since !== void 0 && m.timestamp <= q.since) continue;
+      out.push(m);
     }
-    filtered.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-    return filtered.slice(0, limit);
+    out.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return out.slice(0, limit).map((m) => ({ ...m, readBy: { ...m.readBy } }));
   }
   async ack(input) {
-    let result = null;
+    const updated = await this.ackMany({ acks: [input] });
+    return updated.length > 0 ? updated[0] : null;
+  }
+  async ackMany(input) {
+    if (input.acks.length === 0) return [];
+    const updated = [];
+    const byId = /* @__PURE__ */ new Map();
+    for (const a of input.acks) {
+      byId.set(a.messageId, a);
+    }
+    let cacheSnapshot = null;
     await withFileLock(this.messagePath, async () => {
-      const all = await this._readMessages();
-      const idx = all.findIndex((m) => m.id === input.messageId);
-      if (idx === -1) return;
-      const msg = all[idx];
+      const all = await this._readMessagesFresh();
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      if (input.read !== false) {
-        msg.readBy[input.readerId] = now;
-      }
-      if (input.completed) {
-        msg.completed = true;
-        msg.completedBy = input.readerId;
-        msg.completedAt = now;
+      let changed = false;
+      for (const msg of all) {
+        const a = byId.get(msg.id);
+        if (!a) continue;
+        updated.push(msg);
+        if (a.read !== false && !(a.readerId in msg.readBy)) {
+          msg.readBy[a.readerId] = now;
+          changed = true;
+        }
+        if (a.completed && !msg.completed) {
+          msg.completed = true;
+          msg.completedBy = a.readerId;
+          msg.completedAt = now;
+          changed = true;
+        }
+        if (a.outcome !== void 0 && msg.outcome !== a.outcome) {
+          msg.outcome = a.outcome;
+          changed = true;
+        }
       }
-      if (input.outcome !== void 0) {
-        msg.outcome = input.outcome;
+      if (changed) {
+        const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
+        await fsp6.writeFile(this.messagePath, serialized, "utf8");
       }
-      const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
-      await fsp6.writeFile(this.messagePath, serialized, "utf8");
-      result = msg;
+      cacheSnapshot = all;
     });
-    return result;
+    if (cacheSnapshot) this._setMessageCache(cacheSnapshot);
+    return updated;
   }
   async unreadCount(forAgentId) {
-    const all = await this._readMessages();
-    return all.filter(
-      (m) => (m.to === forAgentId || m.to === "*") && !(forAgentId in m.readBy) && !m.completed
-    ).length;
+    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++;
+      }
+    }
+    return count;
   }
   // ── Agent registry ──────────────────────────────────────────────────────
   async registerAgent(input) {
@@ -10701,13 +11026,62 @@ var GlobalMailbox = class {
   async close() {
     this._registryCache = null;
     this._clientRegistryCache = null;
+    this._messageCache = null;
+    this._messageCacheMtime = -1;
+    this._messageCacheSize = -1;
   }
   async clearAll() {
     await withFileLock(this.messagePath, async () => {
       await fsp6.writeFile(this.messagePath, "", "utf8");
     });
+    this._setMessageCache([]);
+  }
+  async purgeStale(opts) {
+    const COMPLETED_MAX_AGE_MS = opts?.completedMaxAgeMs ?? 864e5;
+    const INCOMPLETE_MAX_AGE_MS = opts?.incompleteMaxAgeMs ?? 6048e5;
+    let completedPurged = 0;
+    let incompletePurged = 0;
+    let remaining = 0;
+    await withFileLock(this.messagePath, async () => {
+      const all = await this._readMessagesFresh();
+      const now = Date.now();
+      const cutoffCompleted = now - COMPLETED_MAX_AGE_MS;
+      const cutoffIncomplete = now - INCOMPLETE_MAX_AGE_MS;
+      const kept = [];
+      for (const msg of all) {
+        const msgTime = new Date(msg.timestamp).getTime();
+        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_SEPARATOR2) + LINE_SEPARATOR2;
+        await fsp6.writeFile(this.messagePath, content, "utf8");
+      }
+      this._setMessageCache(kept);
+    });
+    return {
+      completedPurged,
+      incompletePurged,
+      totalPurged: completedPurged + incompletePurged,
+      remaining
+    };
   }
   // ── Internal ────────────────────────────────────────────────────────────
+  /**
+   * Read all messages from the JSONL file. Always reads + parses the file.
+   * Callers that can tolerate a stale-by-mtime view should use
+   * {@link _readMessagesCached}; writers that need the post-lock truth
+   * should call this directly (it's what {@link _readMessagesFresh} aliases).
+   */
   async _readMessages() {
     try {
       const raw = await fsp6.readFile(this.messagePath, "utf8");
@@ -10735,8 +11109,85 @@ var GlobalMailbox = class {
       throw err;
     }
   }
+  /**
+   * Read messages, then adopt the result as the in-memory cache. Use this
+   * from writers that just took the file lock — the read reflects the
+   * authoritative post-lock state and should be served to subsequent
+   * queries without re-reading.
+   */
+  async _readMessagesFresh() {
+    const all = await this._readMessages();
+    this._setMessageCache(all);
+    return all;
+  }
+  /**
+   * Read messages, consulting the mtime-bounded in-memory cache first.
+   * The mailbox file is shared across processes; every `send`/`ack`/
+   * `clearAll`/`purgeStale` takes the file lock, so writes are serialized
+   * and a changed mtimeMs is a definitive freshness signal. When the
+   * stat matches the cached mtime+size we return the cached array — no
+   * file read and no JSON.parse — collapsing the per-iteration query
+   * cost on the mailbox-loop hot path.
+   */
+  async _readMessagesCached() {
+    try {
+      const st = await fsp6.stat(this.messagePath);
+      if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
+        return this._messageCache;
+      }
+      const all = await this._readMessages();
+      this._setMessageCache(all, st.mtimeMs, st.size);
+      return all;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        this._setMessageCache([], -1, -1);
+        return [];
+      }
+      throw err;
+    }
+  }
+  /**
+   * Replace the in-memory cache. Caller is responsible for guaranteeing
+   * that `messages` reflects the current on-disk state (e.g. they just
+   * read or wrote it under the file lock).
+   */
+  _setMessageCache(messages, mtime, size) {
+    if (messages.length > MESSAGE_CACHE_MAX_ENTRIES) {
+      this._messageCache = null;
+      this._messageCacheMtime = -1;
+      this._messageCacheSize = -1;
+      return;
+    }
+    this._messageCache = messages;
+    if (mtime !== void 0 && size !== void 0) {
+      this._messageCacheMtime = mtime;
+      this._messageCacheSize = size;
+    } else {
+      void fsp6.stat(this.messagePath).then((st) => {
+        this._messageCacheMtime = st.mtimeMs;
+        this._messageCacheSize = st.size;
+      }).catch(() => {
+      });
+    }
+  }
+  /**
+   * Append a single just-sent message to the in-memory cache without
+   * re-reading the file. The caller must hold the file lock (or have
+   * just released it after a successful append) so the cache stays
+   * consistent with on-disk state.
+   */
+  _pushToCache(msg) {
+    if (this._messageCache === null) return;
+    if (this._messageCache.length >= MESSAGE_CACHE_MAX_ENTRIES) {
+      this._messageCache = null;
+      this._messageCacheMtime = -1;
+      this._messageCacheSize = -1;
+      return;
+    }
+    this._messageCache.push(msg);
+  }
   async _ensureRegistry() {
-    await fsp6.mkdir(path4.dirname(this.registryPath), { recursive: true });
+    await fsp6.mkdir(path5.dirname(this.registryPath), { recursive: true });
   }
   async _readRegistry(opts) {
     if (!opts?.fresh && this._registryCache && Date.now() - this._registryCacheAt < REGISTRY_CACHE_TTL_MS) {
@@ -10781,7 +11232,7 @@ var GlobalMailbox = class {
   }
   // ── Client registry internals ───────────────────────────────────────────
   async _ensureClientRegistry() {
-    await fsp6.mkdir(path4.dirname(this.clientRegistryPath), { recursive: true });
+    await fsp6.mkdir(path5.dirname(this.clientRegistryPath), { recursive: true });
   }
   async _readClientRegistry(opts) {
     if (!opts?.fresh && this._clientRegistryCache && Date.now() - this._clientRegistryCacheAt < REGISTRY_CACHE_TTL_MS) {
@@ -11306,6 +11757,10 @@ function makeDependencyWatcherConfig(opts) {
   return {
     watchPaths: unique,
     debounceMs,
+    dispose() {
+      for (const t of pending.values()) clearTimeout(t);
+      pending.clear();
+    },
     async onChange(entry) {
       if (entry.event === "delete") return;
       if (!matchesPattern(entry.path)) return;
@@ -11421,7 +11876,7 @@ function createMailboxHooks(opts) {
 var DEFAULT_MAX_ENTRIES = 1e4;
 var LOG_FILENAME = "package-authors.json";
 function logPath(storageDir) {
-  return path4.join(storageDir, LOG_FILENAME);
+  return path5.join(storageDir, LOG_FILENAME);
 }
 async function loadLog(storageDir, projectRoot) {
   try {
@@ -11445,7 +11900,7 @@ async function saveLog(storageDir, log) {
   await fsp6.rename(tmp, logPath(storageDir));
 }
 function detectEcosystem(manifestPath) {
-  const name = path4.basename(manifestPath).toLowerCase();
+  const name = path5.basename(manifestPath).toLowerCase();
   if (name === "package.json") return "npm";
   if (name === "go.mod") return "go";
   if (name === "cargo.toml") return "cargo";
@@ -11642,7 +12097,7 @@ function startPackageOutdatedWatcher(opts) {
         );
       } catch (err) {
         handleError(err);
-        log(`[pkg-outdated-watcher] Failed to notify for ${entry.name}: ${err instanceof Error ? err.message : String(err)}`);
+        log(`[pkg-outdated-watcher] Failed to notify for ${entry.name}: ${toErrorMessage(err)}`);
       }
     }
   }
@@ -11715,7 +12170,2210 @@ mvn versions:use-latest-versions`;
       return `# Update ${entry.name} to ${entry.latestVersion} using your package manager`;
   }
 }
+var KnowledgeGraph = class {
+  nodes = /* @__PURE__ */ new Map();
+  index = /* @__PURE__ */ new Map();
+  // tag/field → node ids
+  subs = /* @__PURE__ */ new Map();
+  pendingDeliveries = /* @__PURE__ */ new Map();
+  filePath;
+  graphFilePath;
+  /** Exposed for unit-testing only: read current index contents. */
+  getIndex() {
+    return this.index;
+  }
+  constructor(sessionDir) {
+    this.filePath = path5.join(sessionDir, "_knowledge_graph");
+    this.graphFilePath = path5.join(this.filePath, "graph.jsonl");
+  }
+  // ── Write ──────────────────────────────────────────────────────────────
+  /**
+   * Add a node. Fires to all matching subscriptions synchronously.
+   * Returns the node with its assigned id.
+   */
+  async add(node) {
+    const full = { id: randomUUID(), ...node };
+    this.nodes.set(full.id, full);
+    this._addToIndex(full, this._indexKeys(full));
+    await this._persist(full);
+    this._deliver(full);
+    return full;
+  }
+  /** Update an existing node by id. Returns updated node or null if not found. */
+  async update(id, patch) {
+    const existing = this.nodes.get(id);
+    if (!existing) return null;
+    this._removeFromIndex(existing, this._indexKeys(existing));
+    const updated = { ...existing, ...patch };
+    this.nodes.set(id, updated);
+    this._addToIndex(updated, this._indexKeys(updated));
+    this._deliver(updated);
+    await this._append(updated);
+    return updated;
+  }
+  // ── Read ───────────────────────────────────────────────────────────────
+  get(id) {
+    return this.nodes.get(id);
+  }
+  getAll(filter) {
+    return Array.from(this.nodes.values()).filter((n) => this._matches(n, filter ?? {}));
+  }
+  getGoals(filter) {
+    return this.getAll({ type: "goal", ...filter });
+  }
+  getFacts(filter) {
+    return this.getAll({ type: "fact", ...filter });
+  }
+  getChanges(filter) {
+    return this.getAll({ type: "change", ...filter });
+  }
+  getOpenGoals() {
+    return this.getGoals({ status: "pending" }).concat(
+      this.getGoals({ status: "in_progress" })
+    );
+  }
+  getTopLevelGoals() {
+    return this.getGoals({}).filter((g) => !g.parentGoal);
+  }
+  getBlockedGoals() {
+    return this.getGoals({ status: "blocked" });
+  }
+  getPendingChanges() {
+    return this.getChanges({ status: "proposed" });
+  }
+  getDecisions(since) {
+    return this.getAll({ type: "decision", since });
+  }
+  // ── Search ─────────────────────────────────────────────────────────────
+  searchFacts(query) {
+    const q = query.toLowerCase();
+    return this.getFacts().filter(
+      (f) => f.subject.toLowerCase().includes(q) || f.detail.toLowerCase().includes(q) || f.file?.toLowerCase().includes(q) || f.tags.some((t) => t.toLowerCase().includes(q))
+    );
+  }
+  getRelatedFacts(factId) {
+    const fact = this.nodes.get(factId);
+    if (!fact) return [];
+    return fact.related.map((id) => this.nodes.get(id)).filter((n) => n?.type === "fact");
+  }
+  // ── Subscriptions ──────────────────────────────────────────────────────
+  /**
+   * Subscribe to nodes matching a filter. Returns a channel id that can be
+   * used to poll for new nodes since the last check.
+   */
+  subscribe(agentId, filter) {
+    const channel = randomUUID();
+    const sub = { id: randomUUID(), agentId, filter, channel };
+    this.subs.set(channel, sub);
+    this.pendingDeliveries.set(channel, []);
+    return channel;
+  }
+  /**
+   * Poll for new nodes delivered to a channel since last check.
+   * Clears the delivery buffer after reading.
+   */
+  poll(channel) {
+    const pending = this.pendingDeliveries.get(channel);
+    if (!pending) return [];
+    const delivered = [...pending];
+    pending.length = 0;
+    return delivered;
+  }
+  unsubscribe(channel) {
+    this.subs.delete(channel);
+    this.pendingDeliveries.delete(channel);
+  }
+  // ── Quality gate helpers ───────────────────────────────────────────────
+  /**
+   * Create a quality gate result. Call this when a change is being proposed
+   * so the change node carries the gate result.
+   */
+  static makeQualityGate(checks) {
+    return { passed: checks.every((c) => c.passed), checks };
+  }
+  // ── Private ────────────────────────────────────────────────────────────
+  /** Pure: compute the set of index keys a node would belong to. */
+  _indexKeys(node) {
+    const keys = /* @__PURE__ */ new Set();
+    const add = (key) => keys.add(key);
+    add(`type:${node.type}`);
+    if (node.type === "fact") {
+      const f = node;
+      add(`cat:${f.category}`);
+      if (f.severity) add(`sev:${f.severity}`);
+      add(`by:${f.discoveredBy}`);
+      for (const tag of f.tags) add(`tag:${tag}`);
+      add(`key:${f.key}`);
+      add(`subject:${f.subject}`);
+      if (f.detail) add(`detail:${f.detail}`);
+    }
+    if (node.type === "goal") {
+      const g = node;
+      add(`status:${g.status}`);
+      add(`prio:${g.priority}`);
+      if (g.assignee) add(`assign:${g.assignee}`);
+      for (const tag of g.tags) add(`tag:${tag}`);
+    }
+    if (node.type === "change") {
+      const c = node;
+      add(`change:${c.status}`);
+      add(`by:${c.proposedBy}`);
+      for (const g of c.satisfiesGoals) add(`goal:${g}`);
+    }
+    return keys;
+  }
+  /** Mutate the index: add a node's id to every set for the given keys. */
+  _addToIndex(node, keys) {
+    for (const key of keys) {
+      let set = this.index.get(key);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        this.index.set(key, set);
+      }
+      set.add(node.id);
+    }
+  }
+  /** Remove a node's id from all index sets for the given keys. */
+  _removeFromIndex(node, keys) {
+    for (const key of keys) {
+      this.index.get(key)?.delete(node.id);
+    }
+  }
+  _matches(node, f) {
+    if (f.type && node.type !== f.type) return false;
+    if (f.category && node.category !== f.category) return false;
+    if (f.status) {
+      if (node.type === "goal" && node.status !== f.status) return false;
+      if (node.type === "change" && node.status !== f.status) return false;
+    }
+    if (f.assignee && node.assignee !== f.assignee) return false;
+    if (f.discoveredBy && node.discoveredBy !== f.discoveredBy) return false;
+    if (f.proposedBy && node.proposedBy !== f.proposedBy) return false;
+    if (f.tags?.length) {
+      const nodeTags = node.tags ?? node.tags ?? [];
+      if (!f.tags.some((t) => nodeTags.includes(t))) return false;
+    }
+    if (f.since && node.id > f.since) ;
+    return true;
+  }
+  _deliver(node) {
+    for (const sub of this.subs.values()) {
+      if (this._matches(node, sub.filter)) {
+        const pending = this.pendingDeliveries.get(sub.channel);
+        if (pending) pending.push(node);
+      }
+    }
+  }
+  async _persist(node) {
+    await fsp6.mkdir(this.filePath, { recursive: true });
+    const line = JSON.stringify(node) + "\n";
+    await withFileLock(this.graphFilePath, async () => {
+      await fsp6.appendFile(this.graphFilePath, line, "utf8");
+    });
+  }
+  async _append(node) {
+    await fsp6.mkdir(this.filePath, { recursive: true });
+    const line = JSON.stringify({ op: "update", node }) + "\n";
+    await withFileLock(this.graphFilePath, async () => {
+      await fsp6.appendFile(this.graphFilePath, line, "utf8");
+    });
+  }
+  /** Rebuild in-memory state from the log file. Call on startup. */
+  async load() {
+    try {
+      const content = await fsp6.readFile(this.graphFilePath, "utf8");
+      const lines = content.split("\n").filter(Boolean);
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.op === "update") {
+            const oldNode = this.nodes.get(parsed.node.id);
+            if (oldNode) {
+              this._removeFromIndex(oldNode, this._indexKeys(oldNode));
+            }
+            this.nodes.set(parsed.node.id, parsed.node);
+            this._addToIndex(parsed.node, this._indexKeys(parsed.node));
+          } else {
+            this.nodes.set(parsed.id, parsed);
+            this._addToIndex(parsed, this._indexKeys(parsed));
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /** Snapshot for serialization. */
+  snapshot() {
+    return {
+      nodes: Array.from(this.nodes.values()),
+      subs: this.subs.size
+    };
+  }
+};
+
+// src/coordination/task-dag.ts
+var TaskDAG = class {
+  nodes = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Set();
+  runnablesHandlers = /* @__PURE__ */ new Set();
+  runnableCache = null;
+  // ── Node management ───────────────────────────────────────────────────
+  /**
+   * Add a task node. Dependencies are validated for cycles.
+   * Throws if adding a dep would create a cycle.
+   */
+  addNode(id, description, deps = [], opts = {}) {
+    if (this.nodes.has(id)) return;
+    for (const depId of deps) {
+      if (!this.nodes.has(depId)) {
+        throw new Error(`TaskDAG.addNode: unknown dependency "${depId}" for task "${id}". Add the dep first.`);
+      }
+    }
+    if (this._wouldCycle(id, deps)) {
+      throw new Error(`TaskDAG.addNode: adding deps [${deps.join(", ")}] to "${id}" would create a cycle.`);
+    }
+    const node = {
+      id,
+      description,
+      deps: [...deps],
+      status: deps.length === 0 ? "ready" : "pending",
+      role: opts.role,
+      priority: opts.priority ?? 5,
+      dependents: [],
+      tags: opts.tags ?? []
+    };
+    this.nodes.set(id, node);
+    for (const depId of deps) {
+      this.nodes.get(depId).dependents.push(id);
+    }
+    this.invalidateCache();
+    this._emitReady();
+  }
+  /**
+   * Remove a node and all edges to/from it.
+   * Skips any dependents that would become dangling.
+   */
+  removeNode(id) {
+    const node = this.nodes.get(id);
+    if (!node) return;
+    for (const depId of node.deps) {
+      const dep = this.nodes.get(depId);
+      if (dep) {
+        dep.dependents = dep.dependents.filter((d) => d !== id);
+      }
+    }
+    for (const depId of node.dependents) {
+      const dep = this.nodes.get(depId);
+      if (dep && dep.deps.every((d) => !this.nodes.has(d) || this.nodes.get(d).status === "done")) {
+        this._transition(depId, "pending", "ready");
+      }
+    }
+    this.nodes.delete(id);
+    this.invalidateCache();
+  }
+  // ── State transitions ──────────────────────────────────────────────────
+  /**
+   * Mark a task as running. Returns true if the transition was valid
+   * (task was in 'ready' state), false otherwise.
+   */
+  start(id, assignedTo) {
+    const node = this.nodes.get(id);
+    if (!node) return false;
+    if (node.status !== "ready") return false;
+    node.status = "running";
+    node.assignedTo = assignedTo;
+    node.spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.invalidateCache();
+    this._emit({ type: "node:started", nodeId: id, assignedTo });
+    return true;
+  }
+  /**
+   * Mark a task as completed. Unblocks all dependents; they become 'ready'
+   * if all their deps are done.
+   */
+  complete(id, result) {
+    const node = this.nodes.get(id);
+    if (!node) return;
+    node.status = "done";
+    node.result = result;
+    node.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.invalidateCache();
+    const blocked = [];
+    for (const depId of node.dependents) {
+      const dep = this.nodes.get(depId);
+      if (!dep) continue;
+      const allDone = dep.deps.filter((d) => this.nodes.has(d)).every((d) => this.nodes.get(d).status === "done");
+      if (allDone) {
+        this._transition(depId, "pending", "ready");
+      } else {
+        blocked.push(depId);
+      }
+    }
+    this._emit({ type: "node:completed", nodeId: id, result, blockers: blocked });
+    if (blocked.length === 0) this._emitReady();
+  }
+  /**
+   * Mark a task as failed. Unblocks dependents but they remain 'pending'
+   * (they may still be runnable if other deps succeeded).
+   */
+  fail(id, error) {
+    const node = this.nodes.get(id);
+    if (!node) return;
+    node.status = "failed";
+    node.error = error;
+    node.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.invalidateCache();
+    const blocked = [];
+    for (const depId of node.dependents) {
+      const dep = this.nodes.get(depId);
+      if (!dep) continue;
+      const allDone = dep.deps.filter((d) => this.nodes.has(d)).every((d) => {
+        const s = this.nodes.get(d).status;
+        return s === "done" || s === "skipped";
+      });
+      if (allDone) {
+        this._transition(depId, "pending", "ready");
+      } else {
+        blocked.push(depId);
+      }
+    }
+    this._emit({ type: "node:failed", nodeId: id, error, blockers: blocked });
+    if (blocked.length === 0) this._emitReady();
+  }
+  /**
+   * Skip a task (e.g., it was deemed unnecessary by an earlier step).
+   * Treats it as done for dependency purposes.
+   */
+  skip(id, reason) {
+    const node = this.nodes.get(id);
+    if (!node) return;
+    node.status = "skipped";
+    node.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.invalidateCache();
+    for (const depId of node.dependents) {
+      const dep = this.nodes.get(depId);
+      if (!dep) continue;
+      const allDone = dep.deps.filter((d) => this.nodes.has(d)).every((d) => {
+        const s = this.nodes.get(d).status;
+        return s === "done" || s === "skipped";
+      });
+      if (allDone) this._transition(depId, "pending", "ready");
+    }
+    this._emit({ type: "node:skipped", nodeId: id, reason });
+  }
+  // ── Queries ────────────────────────────────────────────────────────────
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  getAll() {
+    return Array.from(this.nodes.values());
+  }
+  getReady() {
+    if (this.runnableCache) return this.runnableCache;
+    const runnable = Array.from(this.nodes.values()).filter((n) => n.status === "ready").sort((a, b) => a.priority - b.priority);
+    this.runnableCache = runnable;
+    return runnable;
+  }
+  getRunning() {
+    return Array.from(this.nodes.values()).filter((n) => n.status === "running");
+  }
+  getPending() {
+    return Array.from(this.nodes.values()).filter((n) => n.status === "pending");
+  }
+  getDone() {
+    return Array.from(this.nodes.values()).filter((n) => n.status === "done");
+  }
+  getFailed() {
+    return Array.from(this.nodes.values()).filter((n) => n.status === "failed");
+  }
+  getCompleted() {
+    return Array.from(this.nodes.values()).filter((n) => n.status === "done" || n.status === "skipped");
+  }
+  isDone() {
+    return Array.from(this.nodes.values()).every(
+      (n) => n.status === "done" || n.status === "failed" || n.status === "skipped"
+    );
+  }
+  isFailed() {
+    return Array.from(this.nodes.values()).some((n) => n.status === "failed");
+  }
+  /** All tasks that are currently blocked (pending but not ready). */
+  getBlocked() {
+    return Array.from(this.nodes.values()).filter((n) => n.status === "pending");
+  }
+  /** Topological sort — tasks in dependency order. */
+  getTopologicalOrder() {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const visit = (id) => {
+      if (visited.has(id)) return;
+      visited.add(id);
+      const node = this.nodes.get(id);
+      if (!node) return;
+      for (const depId of node.deps) visit(depId);
+      result.push(node);
+    };
+    for (const id of this.nodes.keys()) visit(id);
+    return result;
+  }
+  /** Check for deadlock: no runnable tasks but not done. */
+  hasDeadlock() {
+    if (this.isDone()) return false;
+    return this.getReady().length === 0 && this.getRunning().length === 0;
+  }
+  /** Stats snapshot for reporting. */
+  stats() {
+    const all = Array.from(this.nodes.values());
+    const done = all.filter((n) => n.status === "done" || n.status === "skipped").length;
+    return {
+      total: all.length,
+      pending: all.filter((n) => n.status === "pending").length,
+      ready: all.filter((n) => n.status === "ready").length,
+      running: all.filter((n) => n.status === "running").length,
+      done: all.filter((n) => n.status === "done").length,
+      failed: all.filter((n) => n.status === "failed").length,
+      skipped: all.filter((n) => n.status === "skipped").length,
+      progress: all.length ? done / all.length : 0
+    };
+  }
+  // ── Events ────────────────────────────────────────────────────────────
+  onEvent(handler) {
+    this.handlers.add(handler);
+    return () => void this.handlers.delete(handler);
+  }
+  onRunnable(handler) {
+    this.runnablesHandlers.add(handler);
+    return () => void this.runnablesHandlers.delete(handler);
+  }
+  // ── Private ───────────────────────────────────────────────────────────
+  _transition(id, from, to) {
+    const node = this.nodes.get(id);
+    if (!node || node.status !== from) return;
+    node.status = to;
+    this.invalidateCache();
+    if (to === "ready") {
+      this._emit({ type: "node:ready", nodeId: id, deps: node.deps });
+    }
+  }
+  _emit(event) {
+    for (const h of this.handlers) {
+      try {
+        h(event);
+      } catch {
+      }
+    }
+  }
+  _emitReady() {
+    const runnable = this.getReady();
+    if (this.hasDeadlock()) {
+      this._emit({ type: "deadlock", blocked: this.getBlocked().map((n) => n.id) });
+    } else {
+      this._emit({ type: "graph:done", allDone: this.isDone() });
+    }
+    if (runnable.length > 0) {
+      for (const h of this.runnablesHandlers) {
+        try {
+          h(runnable);
+        } catch {
+        }
+      }
+    }
+  }
+  invalidateCache() {
+    this.runnableCache = null;
+  }
+  /**
+   * DFS cycle detection. Adding edge (id → dep) creates a cycle if
+   * there already exists a path from dep to id.
+   */
+  _wouldCycle(id, newDeps) {
+    const visited = /* @__PURE__ */ new Set();
+    const stack = [...newDeps];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current === id) return true;
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const node = this.nodes.get(current);
+      if (node) stack.push(...node.deps);
+    }
+    return false;
+  }
+};
+
+// src/coordination/consensus-protocol.ts
+var ConsensusProtocol = class {
+  graph;
+  fleet;
+  rules;
+  voters;
+  // agentId → config
+  constructor(opts) {
+    this.graph = opts.graph;
+    this.fleet = opts.fleet ?? void 0;
+    this.voters = new Map(opts.voters.map((v) => [v.agentId, v]));
+    this.rules = {
+      quorumFraction: opts.rules?.quorumFraction ?? 0.5,
+      approvalFraction: opts.rules?.approvalFraction ?? 0.6,
+      vetoRoles: opts.rules?.vetoRoles ?? [],
+      approvalWeightFraction: opts.rules?.approvalWeightFraction
+    };
+  }
+  // ── Vote lifecycle ────────────────────────────────────────────────────
+  /**
+   * Initiate a vote on a proposed change. Updates the change node's status
+   * to 'proposed' and notifies eligible voters via FleetBus.
+   */
+  initiateVote(changeId) {
+    const change = this.graph.get(changeId);
+    if (!change || change.type !== "change") {
+      throw new Error(`ConsensusProtocol: no change found with id "${changeId}"`);
+    }
+    this.graph.update(changeId, { status: "proposed", votes: [] });
+    const eligible = this._eligibleVoters(change);
+    this._notifyVoters(change, eligible, "vote_initiated");
+  }
+  /**
+   * Cast a vote. Updates the change node in the graph and re-evaluates
+   * consensus. If the vote triggers a resolution, updates the change status.
+   */
+  castVote(changeId, voterId, value, rationale) {
+    const change = this.graph.get(changeId);
+    if (!change || change.type !== "change") {
+      throw new Error(`ConsensusProtocol: no change found for "${changeId}"`);
+    }
+    const voter = this.voters.get(voterId);
+    if (!voter) {
+      throw new Error(`ConsensusProtocol: unknown voter "${voterId}"`);
+    }
+    const eligible = this._eligibleVoters(change);
+    if (!eligible.includes(voterId)) {
+      throw new Error(`ConsensusProtocol: voter "${voterId}" is not eligible for this vote`);
+    }
+    const vote = {
+      agentId: voterId,
+      agentName: voter.agentName,
+      value,
+      rationale,
+      votedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const existingIdx = change.votes.findIndex((v) => v.agentId === voterId);
+    const newVotes = existingIdx >= 0 ? change.votes.with(existingIdx, vote) : [...change.votes, vote];
+    const result = this._resolve(changeId, newVotes, eligible);
+    this.graph.update(changeId, {
+      votes: newVotes,
+      ...result.outcome !== "pending" ? { status: this._toChangeStatus(result.outcome) } : {}
+    });
+    this._notifyVoters(change, eligible, "vote_cast", { voterId, value, result });
+    return result;
+  }
+  /**
+   * Resolve the current vote without waiting for all eligible voters.
+   * Useful when a timeout fires or an agent decides to finalize early.
+   */
+  resolveNow(changeId) {
+    const change = this.graph.get(changeId);
+    if (!change) throw new Error(`ConsensusProtocol: unknown change "${changeId}"`);
+    const eligible = this._eligibleVoters(change);
+    const result = this._resolve(changeId, change.votes, eligible);
+    if (result.outcome !== "pending") {
+      this.graph.update(changeId, { status: this._toChangeStatus(result.outcome) });
+      this._notifyVoters(change, eligible, "vote_resolved", { result });
+    }
+    return result;
+  }
+  /**
+   * Register or update a voter's configuration.
+   */
+  registerVoter(config) {
+    this.voters.set(config.agentId, config);
+  }
+  /**
+   * Get the current vote status for a change.
+   */
+  getStatus(changeId) {
+    const change = this.graph.get(changeId);
+    if (!change || change.type !== "change") return null;
+    const eligible = this._eligibleVoters(change);
+    return this._resolve(changeId, change.votes, eligible);
+  }
+  // ── Private ───────────────────────────────────────────────────────────
+  _eligibleVoters(change) {
+    return Array.from(this.voters.keys()).filter(
+      (agentId) => agentId !== change.proposedBy
+    );
+  }
+  _resolve(changeId, votes, eligible) {
+    const totalEligible = eligible.length;
+    const approve = votes.filter((v) => v.value === "approve");
+    const reject = votes.filter((v) => v.value === "reject");
+    const abstain = votes.filter((v) => v.value === "abstain");
+    const totalWeightApprove = approve.reduce(
+      (sum, v) => sum + (this.voters.get(v.agentId)?.weight ?? 1),
+      0
+    );
+    const totalWeightReject = reject.reduce(
+      (sum, v) => sum + (this.voters.get(v.agentId)?.weight ?? 1),
+      0
+    );
+    const totalWeight = Array.from(this.voters.values()).reduce(
+      (sum, v) => sum + v.weight,
+      0
+    );
+    const castCount = votes.length;
+    const quorumRequired = Math.ceil(totalEligible * this.rules.quorumFraction);
+    const quorumMet = castCount >= quorumRequired;
+    for (const v of reject) {
+      const config = this.voters.get(v.agentId);
+      if (config?.veto && this.rules.vetoRoles.includes(config.role)) {
+        return {
+          changeId,
+          outcome: "vetoed",
+          votes,
+          approveCount: approve.length,
+          rejectCount: reject.length,
+          abstainCount: abstain.length,
+          totalWeightApprove,
+          totalWeightReject,
+          eligibleVoters: eligible,
+          quorumMet,
+          approvalMet: false,
+          vetoedBy: config.agentId,
+          rationale: `Hard veto from role "${config.role}" (${config.agentName}).`
+        };
+      }
+    }
+    if (!quorumMet) {
+      return {
+        changeId,
+        outcome: "quorum_not_met",
+        votes,
+        approveCount: approve.length,
+        rejectCount: reject.length,
+        abstainCount: abstain.length,
+        totalWeightApprove,
+        totalWeightReject,
+        eligibleVoters: eligible,
+        quorumMet: false,
+        approvalMet: false,
+        rationale: `Quorum not met: ${castCount}/${quorumRequired} required.`
+      };
+    }
+    const approvalRequired = Math.ceil(castCount * this.rules.approvalFraction);
+    const approvalMet = approve.length >= approvalRequired;
+    if (this.rules.approvalWeightFraction !== void 0 && approvalMet) {
+      const weightRequired = totalWeight * this.rules.approvalWeightFraction;
+      if (totalWeightApprove < weightRequired) {
+        return {
+          changeId,
+          outcome: "rejected",
+          votes,
+          approveCount: approve.length,
+          rejectCount: reject.length,
+          abstainCount: abstain.length,
+          totalWeightApprove,
+          totalWeightReject,
+          eligibleVoters: eligible,
+          quorumMet: true,
+          approvalMet: false,
+          rationale: `Weight threshold not met: ${totalWeightApprove.toFixed(2)}/${weightRequired.toFixed(2)} required.`
+        };
+      }
+    }
+    if (approvalMet) {
+      return {
+        changeId,
+        outcome: "approved",
+        votes,
+        approveCount: approve.length,
+        rejectCount: reject.length,
+        abstainCount: abstain.length,
+        totalWeightApprove,
+        totalWeightReject,
+        eligibleVoters: eligible,
+        quorumMet: true,
+        approvalMet: true,
+        rationale: `Approved: ${approve.length}/${castCount} votes (threshold: ${approvalRequired}).`
+      };
+    }
+    return {
+      changeId,
+      outcome: "rejected",
+      votes,
+      approveCount: approve.length,
+      rejectCount: reject.length,
+      abstainCount: abstain.length,
+      totalWeightApprove,
+      totalWeightReject,
+      eligibleVoters: eligible,
+      quorumMet: true,
+      approvalMet: false,
+      rationale: `Rejected: ${approve.length}/${castCount} approve votes (threshold: ${approvalRequired}).`
+    };
+  }
+  _toChangeStatus(outcome) {
+    switch (outcome) {
+      case "approved":
+        return "approved";
+      case "rejected":
+        return "rejected";
+      case "vetoed":
+        return "rejected";
+      case "quorum_not_met":
+        return "proposed";
+      default:
+        return "proposed";
+    }
+  }
+  _notifyVoters(change, eligible, event, extra) {
+    if (!this.fleet) return;
+    this.fleet.emit({
+      subagentId: "consensus",
+      ts: Date.now(),
+      type: `consensus:${event}`,
+      payload: { changeId: change.id, changeTitle: change.title, eligible, ...extra }
+    });
+  }
+};
+
+// src/coordination/change-manager.ts
+var DEFAULT_QUALITY_CHECKS = {
+  runTests: true,
+  runTypecheck: true,
+  runLint: false,
+  // warning only
+  runSecurityScan: true,
+  checkTestCoverage: false,
+  minCoveragePercent: 70
+};
+var ChangeManager = class {
+  graph;
+  consensus;
+  fleet;
+  checks;
+  /** Track applied changes for rollback lookup. */
+  appliedChanges = /* @__PURE__ */ new Map();
+  // changeId → rollbackId
+  constructor(opts) {
+    this.graph = opts.graph;
+    this.consensus = opts.consensus;
+    this.fleet = opts.fleet ?? void 0;
+    this.checks = { ...DEFAULT_QUALITY_CHECKS, ...opts.checks };
+  }
+  // ── Lifecycle ────────────────────────────────────────────────────────
+  /**
+   * Propose a new code change. Creates a ChangeNode in the knowledge graph.
+   * Does NOT automatically initiate voting — call `submitForReview()` for that.
+   */
+  async propose(input) {
+    const node = await this.graph.add({
+      type: "change",
+      title: input.title,
+      description: input.description,
+      files: input.files.map((f) => ({
+        path: f.path,
+        action: f.action
+      })),
+      status: "proposed",
+      proposedBy: input.proposedBy,
+      proposedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      approvedBy: [],
+      rejectedBy: [],
+      votes: [],
+      qualityGate: { passed: false, checks: [] },
+      // filled after quality gate
+      satisfiesGoals: input.satisfiesGoals
+    });
+    void this._runQualityGate(node.id, input.files).then((gate) => {
+      void this.graph.update(node.id, { qualityGate: gate });
+    });
+    this._emit("change:proposed", { changeId: node.id, title: node.title });
+    return node;
+  }
+  /**
+   * Submit an approved change for application.
+   * Returns the change node — actual file mutations are performed by agents
+   * acting on this node's data from the knowledge graph.
+   */
+  async submitForReview(changeId) {
+    const change = this.graph.get(changeId);
+    if (!change || change.type !== "change") {
+      throw new Error(`ChangeManager: no change found "${changeId}"`);
+    }
+    if (change.status !== "proposed") {
+      throw new Error(`ChangeManager: change "${changeId}" is not in 'proposed' state`);
+    }
+    this.consensus.initiateVote(changeId);
+    this._emit("change:submitted_for_review", { changeId, title: change.title });
+  }
+  /**
+   * Apply an approved change. Updates the change node to 'applied'.
+   * Agents should watch for 'applied' status and perform the actual file mutations.
+   */
+  async markApplied(changeId, appliedAt) {
+    const change = this.graph.get(changeId);
+    if (!change) return null;
+    const updated = await this.graph.update(changeId, {
+      status: "applied",
+      appliedAt
+    });
+    if (updated) {
+      this.appliedChanges.set(changeId, "");
+      this._emit("change:applied", { changeId, title: updated.title, files: updated.files });
+    }
+    return updated;
+  }
+  /**
+   * Mark a change as applied and trigger rollback for any satisfied goal
+   * that turns out to be broken.
+   */
+  async markAppliedWithVerification(changeId, verify) {
+    const change = this.graph.get(changeId);
+    if (!change) throw new Error(`ChangeManager: unknown change "${changeId}"`);
+    const appliedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.markApplied(changeId, appliedAt);
+    const verificationResult = await verify();
+    if (!verificationResult.passed) {
+      const rollbackResult = await this.proposeRollback(changeId, "Quality gate failed after apply");
+      return {
+        changeId,
+        success: false,
+        appliedAt,
+        filesTouched: change.files.map((f) => f.path),
+        verificationResult,
+        rollbackChangeId: rollbackResult?.id,
+        error: `Quality gate failed: ${verificationResult.checks.filter((c) => !c.passed).map((c) => c.name).join(", ")}`
+      };
+    }
+    return {
+      changeId,
+      success: true,
+      appliedAt,
+      filesTouched: change.files.map((f) => f.path),
+      verificationResult
+    };
+  }
+  /**
+   * Propose a rollback for an applied change. Creates a new change that
+   * reverses the original. Goes through full consensus.
+   */
+  async proposeRollback(appliedChangeId, reason) {
+    const original = this.graph.get(appliedChangeId);
+    if (!original || original.type !== "change") return null;
+    const rollbackFiles = original.files.map((f) => ({
+      path: f.path,
+      action: f.action === "create" ? "delete" : f.action === "delete" ? "create" : "modify"
+    }));
+    const rollback = await this.propose({
+      title: `Rollback: ${original.title}`,
+      description: `Rollback of "${original.title}" applied at ${original.appliedAt}. Reason: ${reason}`,
+      files: rollbackFiles,
+      proposedBy: "change-manager",
+      satisfiesGoals: [],
+      tags: ["rollback", `original:${appliedChangeId}`]
+    });
+    this.appliedChanges.set(appliedChangeId, rollback.id);
+    await this.graph.update(appliedChangeId, {
+      rolledBackAt: (/* @__PURE__ */ new Date()).toISOString(),
+      rollbackReason: reason
+    });
+    this._emit("change:rollback_proposed", {
+      originalChangeId: appliedChangeId,
+      rollbackChangeId: rollback.id,
+      reason
+    });
+    return rollback;
+  }
+  /**
+   * Mark a change as rolled back.
+   */
+  async markRolledBack(changeId, rolledBackAt) {
+    const updated = await this.graph.update(changeId, {
+      status: "rolled_back",
+      rolledBackAt
+    });
+    if (updated) {
+      this._emit("change:rolled_back", { changeId, title: updated.title });
+    }
+    return updated;
+  }
+  // ── Queries ───────────────────────────────────────────────────────────
+  getPendingReviews() {
+    return this.graph.getChanges({ status: "proposed" });
+  }
+  getAppliedChanges() {
+    return this.graph.getChanges({ status: "applied" });
+  }
+  getChange(id) {
+    return this.graph.get(id);
+  }
+  getChangesForGoal(goalId) {
+    return this.graph.getChanges({}).filter(
+      (c) => c.satisfiesGoals.includes(goalId)
+    );
+  }
+  // ── Quality gate ──────────────────────────────────────────────────────
+  /**
+   * Run quality gate checks. This is informational — actual test/lint/typecheck
+   * execution is done by agents spawned for this purpose. This method stores
+   * the result in the change node.
+   */
+  async _runQualityGate(_changeId, _files) {
+    const checks = [];
+    if (this.checks.runTests) {
+      checks.push({ name: "tests", passed: false, detail: "Tests must be run by a verify agent" });
+    }
+    if (this.checks.runTypecheck) {
+      checks.push({ name: "typecheck", passed: false, detail: "TypeScript must compile" });
+    }
+    if (this.checks.runSecurityScan) {
+      checks.push({ name: "security", passed: false, detail: "Security scan must pass" });
+    }
+    if (this.checks.runLint) {
+      checks.push({ name: "lint", passed: false, detail: "Lint check" });
+    }
+    const result = {
+      passed: checks.length === 0,
+      checks
+    };
+    await this.graph.update(_changeId, { qualityGate: result });
+    return result;
+  }
+  /**
+   * Update quality gate result for a change. Called by verify agents
+   * after running their checks.
+   */
+  async updateQualityGate(changeId, checkName, result) {
+    const change = this.graph.get(changeId);
+    if (!change) return;
+    const checks = change.qualityGate.checks.map(
+      (c) => c.name === checkName ? { ...c, ...result } : c
+    );
+    const allPassed = checks.every((c) => c.passed);
+    await this.graph.update(changeId, {
+      qualityGate: { passed: allPassed, checks }
+    });
+    this._emit("quality_gate:updated", { changeId, checkName, passed: result.passed });
+  }
+  // ── Helpers ──────────────────────────────────────────────────────────
+  _emit(type, payload) {
+    if (!this.fleet) return;
+    this.fleet.emit({ subagentId: "change-manager", ts: Date.now(), type, payload });
+  }
+};
+var AutonomousBrain = class {
+  graph;
+  // Fleet bus for emitting decisions — null-safe, no-op if not provided
+  fleetBus;
+  llmProvider;
+  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"];
+  // ── Fleet bus integration ─────────────────────────────────────────────
+  _emit(type, payload) {
+    if (!this.fleetBus) return;
+    this.fleetBus.emit({ subagentId: "brain", ts: Date.now(), type, payload });
+  }
+  constructor(opts) {
+    this.graph = opts.graph;
+    this.fleetBus = opts.fleet ?? void 0;
+    this.llmProvider = opts.llmProvider;
+    this.maxRetries = opts.maxRetries ?? 3;
+    this.consensusRiskThreshold = opts.consensusRiskThreshold ?? "high";
+    this.selfImprove = opts.selfImprove ?? true;
+  }
+  // ── BrainArbiter interface ────────────────────────────────────────────
+  /** Implements BrainArbiter — bridges standard brain.ts interface to autonomous engine. */
+  async decide(request) {
+    return this.decideAuto(this._toAutonomous(request));
+  }
+  // ── Main entry point ──────────────────────────────────────────────────
+  /**
+   * Primary autonomous decision engine — receives AutonomousDecisionRequest,
+   * queries the LLM, records the decision, and returns a BrainDecision.
+   *
+   * Specialized methods (decideSpawn, decideApproval, etc.) should call this
+   * directly with a pre-built AutonomousDecisionRequest.
+   */
+  async decideAuto(request) {
+    const { id, decisionType, question, context, options, risk, requiresConsensus } = request;
+    const history = this.selfImprove ? this._loadHistory(decisionType, risk) : [];
+    const hints = this.selfImprove ? this._getSelfImproveHints(decisionType) : [];
+    const prompt = {
+      decisionType,
+      question,
+      context: this._serializeContext(context),
+      options,
+      risk,
+      decisionHistory: history,
+      selfImproveHints: hints
+    };
+    let result;
+    try {
+      result = await this.llmProvider.decide(prompt);
+    } catch (err) {
+      const recommended = options.find((o) => o.recommended);
+      if (recommended && risk === "low") {
+        return { type: "answer", optionId: recommended.id, text: recommended.label };
+      }
+      return { type: "deny", reason: `Brain LLM failed: ${String(err)}` };
+    }
+    this._recordDecision({
+      id,
+      decisionType,
+      question,
+      options,
+      chosen: result.optionId,
+      rationale: result.rationale,
+      madeBy: "autonomous-brain",
+      context: JSON.stringify(context)
+    }).catch(() => {
+    });
+    if (requiresConsensus) {
+      this._emit("brain.decision", { id, decisionType, optionId: result.optionId, rationale: result.rationale, consensusRequired: true });
+      return {
+        type: "answer",
+        optionId: result.optionId,
+        text: options.find((o) => o.id === result.optionId)?.label ?? result.optionId,
+        rationale: `${result.rationale}
+
+\u26A0\uFE0F This decision requires consensus approval before execution.`
+      };
+    }
+    this._emit("brain.decision", { id, decisionType, optionId: result.optionId, rationale: result.rationale, consensusRequired: false });
+    return {
+      type: "answer",
+      optionId: result.optionId,
+      text: options.find((o) => o.id === result.optionId)?.label ?? result.optionId,
+      rationale: result.rationale
+    };
+  }
+  // ── Specialized decision methods ────────────────────────────────────
+  /**
+   * Decide whether to spawn a subagent, which role to use, and what budget.
+   */
+  async decideSpawn(source, taskDescription, availableFacts, fleetStatus) {
+    const roleHints = this._inferRoles(taskDescription);
+    const risk = roleHints.length > 1 ? "medium" : "low";
+    const options = roleHints.map((role, i) => ({
+      id: `spawn:${role}`,
+      label: `Spawn ${role} agent`,
+      risk: i === 0 ? "low" : "medium",
+      recommended: i === 0,
+      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(),
+      source,
+      decisionType: "spawn",
+      question: `Should we spawn a subagent for this task?`,
+      context: {
+        facts: availableFacts,
+        fleetStatus,
+        taskDescription
+      },
+      options,
+      risk,
+      requiresConsensus: false
+    });
+  }
+  /**
+   * Decide whether to approve a proposed change.
+   */
+  async decideApproval(source, change, relevantFacts) {
+    const risk = this._changeRisk(change);
+    const options = [
+      {
+        id: "approve",
+        label: "Approve change",
+        recommended: change.qualityGate.passed && relevantFacts.filter((f) => f.severity === "critical").length === 0,
+        risk,
+        consequence: `Apply changes to: ${change.files.map((f) => f.path).join(", ")}`
+      },
+      {
+        id: "reject",
+        label: "Reject change",
+        recommended: false,
+        risk: "medium",
+        consequence: "Return change to proposer with feedback"
+      },
+      {
+        id: "request_changes",
+        label: "Request specific changes",
+        recommended: false,
+        risk: "low",
+        consequence: "Send back for revision with conditions"
+      }
+    ];
+    return this.decideAuto({
+      id: randomUUID(),
+      source,
+      decisionType: "approve_change",
+      question: `Should we approve the change "${change.title}"?`,
+      context: {
+        facts: relevantFacts,
+        change
+      },
+      options,
+      risk,
+      requiresConsensus: risk === "critical" || risk === "high"
+    });
+  }
+  /**
+   * Decide how to handle a failed task.
+   */
+  async decideEscalation(source, taskId, error, attempts) {
+    const retryCount = this.failurePatterns.get(taskId)?.failures ?? attempts;
+    const options = [];
+    if (retryCount < this.maxRetries) {
+      options.push({
+        id: "retry",
+        label: `Retry task (attempt ${retryCount + 1}/${this.maxRetries})`,
+        recommended: retryCount < 2,
+        risk: "medium",
+        consequence: `Restart the task with same or adjusted budget`
+      });
+      options.push({
+        id: "retry_with_adjustment",
+        label: `Retry with more budget`,
+        recommended: retryCount >= 1,
+        risk: "medium",
+        consequence: `Increase timeout or iterations before retrying`
+      });
+    }
+    options.push({
+      id: "delegate",
+      label: "Delegate to different role",
+      recommended: retryCount >= 1,
+      risk: "medium",
+      consequence: "Try a different agent role for the same task"
+    });
+    if (retryCount >= this.maxRetries) {
+      options.push({
+        id: "mark_failed",
+        label: "Mark task as failed",
+        recommended: true,
+        risk: "high",
+        consequence: "Stop retrying, propagate failure upward"
+      });
+    }
+    options.push({
+      id: "decompose",
+      label: "Decompose and retry in parts",
+      recommended: false,
+      risk: "low",
+      consequence: "Break the task into smaller sub-tasks"
+    });
+    return this.decideAuto({
+      id: randomUUID(),
+      source,
+      decisionType: "escalate_task",
+      question: `Task failed: ${error.slice(0, 100)}. How should we proceed?`,
+      context: { error, attempts: retryCount },
+      options,
+      risk: retryCount >= this.maxRetries ? "critical" : "medium",
+      requiresConsensus: false
+    });
+  }
+  // ── Self-improvement ─────────────────────────────────────────────────
+  /**
+   * Record the outcome of a decision for self-improvement.
+   * Call this after a spawned agent completes or a change is applied.
+   */
+  recordOutcome(decisionId, outcome, _detail) {
+    const node = this.graph.get(decisionId);
+    if (!node) return;
+    const key = `decision:${node.decisionType}`;
+    if (outcome === "failure") {
+      const existing = this.failurePatterns.get(key) ?? { failures: 0, lastFailure: "" };
+      existing.failures += 1;
+      existing.lastFailure = (/* @__PURE__ */ new Date()).toISOString();
+      this.failurePatterns.set(key, existing);
+    } else {
+      this.failurePatterns.delete(key);
+    }
+    void this.graph.update(decisionId, { decisionType: node.decisionType });
+  }
+  _getSelfImproveHints(decisionType) {
+    const pattern = this.failurePatterns.get(`decision:${decisionType}`);
+    if (!pattern || pattern.failures < 2) return [];
+    return [
+      `\u26A0\uFE0F ${decisionType} decisions have failed ${pattern.failures} times recently.`,
+      "Consider alternative approaches before defaulting to this pattern."
+    ];
+  }
+  // ── Private ───────────────────────────────────────────────────────────
+  _toAutonomous(req) {
+    const decisionType = this._inferDecisionType(req);
+    return {
+      id: req.id,
+      source: req.source,
+      decisionType,
+      question: req.question,
+      context: {
+        taskDescription: req.context ?? ""
+      },
+      options: req.options ?? [],
+      risk: req.risk,
+      requiresConsensus: this.RISK_ORDER.indexOf(req.risk) >= this.RISK_ORDER.indexOf(this.consensusRiskThreshold)
+    };
+  }
+  _inferDecisionType(req) {
+    if (req.question.toLowerCase().includes("spawn")) return "spawn";
+    if (req.question.toLowerCase().includes("approve") || req.question.toLowerCase().includes("change")) return "approve_change";
+    if (req.question.toLowerCase().includes("retry") || req.question.toLowerCase().includes("fail")) return "retry_task";
+    if (req.question.toLowerCase().includes("priorit")) return "prioritize_goals";
+    if (req.question.toLowerCase().includes("decompos")) return "decompose_goal";
+    return "assign_task";
+  }
+  _serializeContext(ctx) {
+    const parts = [];
+    if (ctx.facts?.length) {
+      parts.push(`## Relevant Facts
+${ctx.facts.map((f) => `- [${f.severity ?? "info"}] ${f.subject}: ${f.detail}`).join("\n")}`);
+    }
+    if (ctx.goals?.length) {
+      parts.push(`## Active Goals
+${ctx.goals.map((g) => `- [${g.status}] ${g.priority}: ${g.title}`).join("\n")}`);
+    }
+    if (ctx.change) {
+      const c = ctx.change;
+      parts.push(`## Change Under Review
+- Title: ${c.title}
+- Status: ${c.status}
+- Files: ${c.files.map((f) => `${f.action} ${f.path}`).join(", ")}
+- Quality gate: ${c.qualityGate.passed ? "PASSED" : "FAILED"}
+  Checks: ${c.qualityGate.checks.map((ch) => `${ch.name}:${ch.passed ? "\u2705" : "\u274C"}`).join(", ")}`);
+    }
+    if (ctx.fleetStatus) {
+      parts.push(`## Fleet Status
+- Running: ${ctx.fleetStatus.running}, Idle: ${ctx.fleetStatus.idle}, Total: ${ctx.fleetStatus.total}
+- Cost so far: $${ctx.fleetStatus.costSoFar.toFixed(4)}`);
+    }
+    if (ctx.taskDescription) {
+      parts.push(`## Task
+${ctx.taskDescription}`);
+    }
+    if (ctx.error) {
+      parts.push(`## Error
+${ctx.error}`);
+    }
+    return parts.join("\n\n");
+  }
+  _loadHistory(type, _risk) {
+    const all = this.graph.getDecisions().filter((d) => d.decisionType === type);
+    return all.slice(-10);
+  }
+  async _recordDecision(input) {
+    const node = await this.graph.add({
+      type: "decision",
+      decisionType: input.decisionType,
+      question: input.question,
+      options: input.options,
+      chosen: input.chosen,
+      rationale: input.rationale,
+      madeBy: input.madeBy,
+      madeAt: (/* @__PURE__ */ new Date()).toISOString(),
+      context: input.context
+    });
+    this.decisionHistory.push(node);
+    return node;
+  }
+  _inferRoles(task) {
+    const t = task.toLowerCase();
+    if (t.includes("bug") || t.includes("error") || t.includes("crash")) return ["bug-hunter", "fixer"];
+    if (t.includes("security") || t.includes("secret") || t.includes("injection")) return ["security-scanner"];
+    if (t.includes("refactor") || t.includes("architecture") || t.includes("debt")) return ["refactor-planner", "critic"];
+    if (t.includes("audit") || t.includes("log") || t.includes("analyze")) return ["audit-log"];
+    if (t.includes("test") || t.includes("coverage")) return ["tester", "bug-hunter"];
+    return ["bug-hunter", "refactor-planner"];
+  }
+  _changeRisk(change) {
+    const criticalFiles = change.files.filter(
+      (f) => f.path.includes("auth") || f.path.includes("config") || f.path.includes("schema")
+    );
+    if (criticalFiles.length > 0) return "high";
+    if (change.files.length > 10) return "medium";
+    return "low";
+  }
+};
+var TaskAuctioneer = class {
+  graph;
+  fleet;
+  mailbox;
+  selfAgentId;
+  bidWindowMs;
+  maxTasksPerAgent;
+  minConfidence;
+  // minimum dispatcher confidence to accept a bid
+  maxBidRetries;
+  // max republished attempts before marking task failed
+  /** Pending bids keyed by taskId. */
+  pendingBids = /* @__PURE__ */ new Map();
+  /** Active bid windows keyed by taskId. */
+  bidTimers = /* @__PURE__ */ new Map();
+  /** FleetBus subscription disposers, detached in dispose(). */
+  unsubs = [];
+  /** How many times a task has been republished with no bids received. */
+  bidRetryCounts = /* @__PURE__ */ new Map();
+  /** Agent → current task count (from graph + in-flight). */
+  agentTaskCounts = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.graph = opts.graph;
+    this.fleet = opts.fleet;
+    this.mailbox = opts.mailbox;
+    this.selfAgentId = opts.selfAgentId ?? "auctioneer";
+    this.bidWindowMs = opts.bidWindowMs ?? 3e4;
+    this.maxTasksPerAgent = opts.maxTasksPerAgent ?? 3;
+    this.minConfidence = opts.minConfidence ?? 0.3;
+    this.maxBidRetries = opts.maxBidRetries ?? 3;
+    const offBid = this.fleet?.filter("task:bid", (e) => this._onBidEvent(e));
+    const offClaimed = this.fleet?.filter("task:claimed", (e) => this._onClaimedEvent(e));
+    if (offBid) this.unsubs.push(offBid);
+    if (offClaimed) this.unsubs.push(offClaimed);
+  }
+  /**
+   * Detach all FleetBus subscriptions and cancel any open bid-window timers.
+   * Call when the owning coordinator stops/restarts so handlers and timers
+   * don't accumulate across cycles.
+   */
+  dispose() {
+    for (const off of this.unsubs.splice(0)) {
+      try {
+        off();
+      } catch {
+      }
+    }
+    for (const t of this.bidTimers.values()) clearTimeout(t);
+    this.bidTimers.clear();
+  }
+  // ── Publish a task ────────────────────────────────────────────────────
+  /**
+   * Publish a new task to the auction. Creates a GoalNode and broadcasts
+   * it to all online agents. Returns the goal id.
+   *
+   * If `targetAgent` is specified, the task is assigned directly without auction.
+   */
+  async publishTask(input) {
+    const blockedBy = input.blockedBy ?? [];
+    const hasOpenBlockers = blockedBy.length > 0 && blockedBy.some((id) => this.graph.get(id)?.status !== "done");
+    const goal = await this.graph.add({
+      type: "goal",
+      title: input.title,
+      description: input.description,
+      status: input.targetAgent ? "in_progress" : hasOpenBlockers ? "blocked" : "pending",
+      priority: input.priority ?? "medium",
+      assignee: input.targetAgent,
+      blockedBy,
+      dependsOn: input.satisfiesGoals ?? [],
+      createdBy: this.selfAgentId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tags: input.tags ?? [],
+      children: [],
+      parentGoal: input.parentGoal
+    });
+    if (input.parentGoal) {
+      const parent = this.graph.get(input.parentGoal);
+      if (parent) {
+        await this.graph.update(input.parentGoal, {
+          children: [...parent.children, goal.id]
+        });
+      }
+    }
+    for (const blockerId of blockedBy) {
+      const blocker = this.graph.get(blockerId);
+      if (blocker && !blocker.children.includes(goal.id)) {
+        await this.graph.update(blockerId, { children: [...blocker.children, goal.id] });
+      }
+    }
+    if (input.targetAgent) {
+      await this._assignDirect(goal.id, input.targetAgent);
+    } else {
+      await this._broadcastTask(goal);
+      this._startBidWindow(goal.id);
+    }
+    this._emit("task:published", {
+      taskId: goal.id,
+      title: goal.title,
+      priority: goal.priority,
+      tags: goal.tags
+    });
+    return goal.id;
+  }
+  // ── Bid on a task ─────────────────────────────────────────────────────
+  /**
+   * Submit a bid for a task. Called by agents who want to work on it.
+   * Returns true if the bid was accepted, false if the task was already claimed.
+   */
+  async bid(taskId, agent, rationale) {
+    const goal = this.graph.get(taskId);
+    if (!goal || goal.type !== "goal") return false;
+    if (goal.status !== "pending") return false;
+    const currentCount = this._getAgentTaskCount(agent.agentId);
+    if (currentCount >= this.maxTasksPerAgent) return false;
+    const dispatchResult = await dispatchAgent(goal.description);
+    const score = dispatchResult.confidence * (dispatchResult.role === agent.agentRole ? 1.2 : 1);
+    if (score < this.minConfidence) return false;
+    const bid = {
+      id: randomUUID(),
+      taskId,
+      agentId: agent.agentId,
+      agentName: agent.agentName,
+      agentRole: agent.agentRole,
+      score,
+      rationale,
+      submittedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let bids = this.pendingBids.get(taskId);
+    if (!bids) {
+      bids = [];
+      this.pendingBids.set(taskId, bids);
+    }
+    const existingIdx = bids.findIndex((b) => b.agentId === agent.agentId);
+    if (existingIdx >= 0) {
+      bids[existingIdx] = bid;
+    } else {
+      bids.push(bid);
+    }
+    this._emit("task:bid", {
+      taskId,
+      bid: { ...bid, score: Math.round(score * 100) / 100 },
+      agentName: agent.agentName
+    });
+    await this._mailboxPublish({
+      type: "note",
+      subject: `[bid] ${agent.agentName} \u2192 ${goal.title}`,
+      body: `${agent.agentName} (${agent.agentRole}) bidded on task "${goal.title}" (${goal.id})
+Rationale: ${rationale}
+Score: ${score.toFixed(2)}`
+    });
+    return true;
+  }
+  // ── Claim (award) a task ───────────────────────────────────────────────
+  /**
+   * Award a task to a specific agent. Called internally by the bid window
+   * expiry, or can be called directly to force an award.
+   */
+  async claim(taskId, agentId, agentName) {
+    const goal = this.graph.get(taskId);
+    if (!goal || goal.type !== "goal") return false;
+    if (goal.status !== "pending") return false;
+    this._cancelBidWindow(taskId);
+    await this.graph.update(taskId, {
+      status: "in_progress",
+      assignee: agentId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.pendingBids.delete(taskId);
+    this.agentTaskCount(agentId, 1);
+    await this._notifyAgent(agentId, {
+      type: "assign",
+      subject: `[assigned] ${goal.title}`,
+      body: `You have been assigned: "${goal.title}"
+
+${goal.description}
+
+Task ID: ${taskId}
+Priority: ${goal.priority}`,
+      taskContext: {
+        agentRole: goal.tags[0],
+        taskId,
+        status: "in_progress"
+      }
+    });
+    this._emit("task:claimed", { taskId, agentId, agentName });
+    return true;
+  }
+  // ── Complete a task ────────────────────────────────────────────────────
+  /**
+   * Mark a task as done. Called by the agent when it finishes.
+   */
+  async complete(taskId, _result) {
+    const goal = this.graph.get(taskId);
+    if (!goal) return;
+    const agentId = goal.assignee ?? "unknown";
+    this.agentTaskCount(agentId, -1);
+    await this.graph.update(taskId, {
+      status: "done",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.bidRetryCounts.delete(taskId);
+    this.pendingBids.delete(taskId);
+    this._cancelBidWindow(taskId);
+    for (const childId of goal.children) {
+      const child = this.graph.get(childId);
+      if (child && child.status === "blocked") {
+        const allUnblocked = child.blockedBy.every((blockedId) => {
+          const blocked = this.graph.get(blockedId);
+          return blocked?.status === "done";
+        });
+        if (allUnblocked) {
+          await this.graph.update(childId, { status: "pending", updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+          const unblockedGoal = this.graph.get(childId);
+          await this._broadcastTask(unblockedGoal);
+          this._startBidWindow(childId);
+        }
+      }
+    }
+    this._emit("task:completed", { taskId, agentId, result: _result });
+    await this._mailboxPublish({
+      type: "result",
+      subject: `[done] ${goal.title}`,
+      body: `Task completed by ${agentId}: "${goal.title}"
+
+${_result ?? "No result provided."}`
+    });
+  }
+  /**
+   * Mark a task as failed. Optionally spawn a retry.
+   */
+  async fail(taskId, error) {
+    const goal = this.graph.get(taskId);
+    if (!goal) return;
+    const agentId = goal.assignee ?? "unknown";
+    this.agentTaskCount(agentId, -1);
+    await this.graph.update(taskId, {
+      status: "failed",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      result: error
+    });
+    this.bidRetryCounts.delete(taskId);
+    this.pendingBids.delete(taskId);
+    this._cancelBidWindow(taskId);
+    this._emit("task:failed", { taskId, agentId, error });
+    await this._mailboxPublish({
+      type: "note",
+      subject: `[failed] ${goal.title}`,
+      body: `Task failed: "${goal.title}"
+Error: ${error}
+Assignee: ${agentId}`
+    });
+  }
+  // ── Work finding ──────────────────────────────────────────────────────
+  /**
+   * Find the best available tasks for an agent based on its capabilities.
+   * Returns tasks sorted by match score (best first).
+   */
+  async findWork(_agentId, agentRole, limit = 5) {
+    const pending = this.graph.getGoals({ status: "pending" });
+    const scored = [];
+    for (const goal of pending) {
+      if (goal.blockedBy.length > 0) continue;
+      const dispatchResult = await dispatchAgent(goal.description);
+      const roleBonus = agentRole && goal.tags.includes(agentRole) ? 1.3 : 1;
+      const priorityBonus = goal.priority === "critical" ? 1.5 : goal.priority === "high" ? 1.2 : 1;
+      const score = dispatchResult.confidence * roleBonus * priorityBonus;
+      const bids = this.pendingBids.get(goal.id)?.length ?? 0;
+      scored.push({ task: goal, score, bids });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit);
+  }
+  // ── Queries ──────────────────────────────────────────────────────────
+  /** Get all pending tasks (available for bidding). */
+  getPendingTasks() {
+    return this.graph.getGoals({ status: "pending" }).filter((g) => g.blockedBy.length === 0);
+  }
+  /** Get tasks assigned to a specific agent. */
+  getTasksForAgent(agentId) {
+    return this.graph.getGoals({}).filter((g) => g.assignee === agentId);
+  }
+  /** Get the current bid count for a task. */
+  getBidCount(taskId) {
+    return this.pendingBids.get(taskId)?.length ?? 0;
+  }
+  /** Get bids for a task. */
+  getBids(taskId) {
+    return this.pendingBids.get(taskId) ?? [];
+  }
+  /** Get task stats for a project-wide dashboard. */
+  getStats() {
+    const all = this.graph.getGoals({});
+    const pending = all.filter((g) => g.status === "pending" && g.blockedBy.length === 0);
+    const inProgress = all.filter((g) => g.status === "in_progress");
+    const done = all.filter((g) => g.status === "done");
+    const failed = all.filter((g) => g.status === "failed");
+    let totalBids = 0;
+    for (const bids of this.pendingBids.values()) totalBids += bids.length;
+    return {
+      total: all.length,
+      pending: pending.length,
+      in_progress: inProgress.length,
+      done: done.length,
+      failed: failed.length,
+      totalBids,
+      avgBidsPerTask: pending.length > 0 ? totalBids / pending.length : 0
+    };
+  }
+  // ── Private ───────────────────────────────────────────────────────────
+  _emit(type, payload) {
+    if (!this.fleet) return;
+    this.fleet.emit({ subagentId: this.selfAgentId, ts: Date.now(), type, payload });
+  }
+  _broadcastTask(goal) {
+    this._emit("task:available", {
+      taskId: goal.id,
+      title: goal.title,
+      description: goal.description,
+      priority: goal.priority,
+      tags: goal.tags
+    });
+    this._mailboxPublish({
+      type: "broadcast",
+      subject: `[task] ${goal.title} (${goal.priority})`,
+      body: `New task available: "${goal.title}"
+Priority: ${goal.priority}
+Description: ${goal.description.slice(0, 200)}${goal.description.length > 200 ? "..." : ""}
+
+Task ID: ${goal.id}
+Tags: ${goal.tags.join(", ") || "none"}
+
+Bid by calling taskAuctioneer.bid("${goal.id}", ...)`
+    }).catch(() => {
+    });
+  }
+  async _mailboxPublish(msg) {
+    if (!this.mailbox) return;
+    try {
+      await this.mailbox.send({
+        from: this.selfAgentId,
+        to: "*",
+        type: msg.type,
+        subject: msg.subject,
+        body: msg.body,
+        priority: "normal"
+      });
+    } catch {
+    }
+  }
+  async _notifyAgent(agentId, msg) {
+    if (!this.mailbox) return;
+    try {
+      await this.mailbox.send({
+        from: this.selfAgentId,
+        to: agentId,
+        type: msg.type,
+        subject: msg.subject,
+        body: msg.body,
+        priority: "high",
+        taskContext: msg.taskContext
+      });
+    } catch {
+    }
+  }
+  _startBidWindow(taskId) {
+    this._cancelBidWindow(taskId);
+    const timer = setTimeout(() => {
+      this.bidTimers.delete(taskId);
+      void this._evaluateBids(taskId).catch(() => {
+      });
+    }, this.bidWindowMs);
+    this.bidTimers.set(taskId, timer);
+  }
+  _cancelBidWindow(taskId) {
+    const timer = this.bidTimers.get(taskId);
+    if (timer) {
+      clearTimeout(timer);
+      this.bidTimers.delete(taskId);
+    }
+  }
+  async _evaluateBids(taskId) {
+    const bids = this.pendingBids.get(taskId);
+    if (!bids || bids.length === 0) {
+      const retryCount = (this.bidRetryCounts.get(taskId) ?? 0) + 1;
+      this.bidRetryCounts.set(taskId, retryCount);
+      if (retryCount >= this.maxBidRetries) {
+        await this.fail(taskId, `No bids received after ${this.maxBidRetries} attempts`);
+        this.bidRetryCounts.delete(taskId);
+        return;
+      }
+      const goal = this.graph.get(taskId);
+      if (goal) {
+        await this._broadcastTask(goal);
+        this._startBidWindow(taskId);
+      }
+      return;
+    }
+    bids.sort((a, b) => b.score - a.score);
+    const winner = bids.find((b) => this._getAgentTaskCount(b.agentId) < this.maxTasksPerAgent);
+    if (!winner) {
+      const goal = this.graph.get(taskId);
+      if (goal) {
+        await this._broadcastTask(goal);
+        this._startBidWindow(taskId);
+      }
+      return;
+    }
+    await this.claim(taskId, winner.agentId, winner.agentName);
+  }
+  async _assignDirect(taskId, agentId) {
+    const goal = this.graph.get(taskId);
+    if (!goal) return;
+    await this.graph.update(taskId, {
+      status: "in_progress",
+      assignee: agentId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.agentTaskCount(agentId, 1);
+    await this._notifyAgent(agentId, {
+      type: "assign",
+      subject: `[assigned] ${goal.title}`,
+      body: `You have been directly assigned: "${goal.title}"
+
+${goal.description}`,
+      taskContext: { taskId, status: "in_progress" }
+    });
+  }
+  _onBidEvent(_e) {
+  }
+  _onClaimedEvent(e) {
+    const { taskId } = e.payload;
+    this.pendingBids.delete(taskId);
+    this._cancelBidWindow(taskId);
+  }
+  _getAgentTaskCount(agentId) {
+    return this.agentTaskCounts.get(agentId) ?? 0;
+  }
+  agentTaskCount(agentId, delta) {
+    const current = this._getAgentTaskCount(agentId);
+    const next = Math.max(0, current + delta);
+    this.agentTaskCounts.set(agentId, next);
+  }
+};
+var AutonomousCoordinator = class {
+  graph;
+  dag;
+  auction;
+  consensus;
+  changes;
+  brain;
+  selfAgentId;
+  fleet;
+  fleetManager;
+  director;
+  mailbox;
+  events;
+  onCoordinatorEvent;
+  running = false;
+  iterationCount = 0;
+  /** Tasks already handled by _onSubagentTerminated (to avoid double goal:failed on fleet event). */
+  _handledBySubagent = /* @__PURE__ */ new Set();
+  /** FleetBus subscription disposers, detached in dispose(). */
+  unsubs = [];
+  constructor(opts) {
+    this.selfAgentId = opts.selfAgentId;
+    this.fleet = opts.fleet ?? void 0;
+    this.fleetManager = opts.fleetManager ?? void 0;
+    this.director = opts.director ?? void 0;
+    this.mailbox = opts.mailbox ?? void 0;
+    this.events = opts.events ?? void 0;
+    this.onCoordinatorEvent = opts.onCoordinatorEvent;
+    this.graph = new KnowledgeGraph(opts.sessionDir);
+    this.dag = new TaskDAG();
+    this.auction = new TaskAuctioneer({
+      graph: this.graph,
+      fleet: this.fleet ?? void 0,
+      mailbox: this.mailbox ?? void 0,
+      selfAgentId: this.selfAgentId
+    });
+    this.consensus = new ConsensusProtocol({
+      graph: this.graph,
+      fleet: this.fleet ?? void 0,
+      voters: this._buildVoters(),
+      rules: {
+        quorumFraction: 0.5,
+        approvalFraction: 0.6,
+        vetoRoles: ["critic"],
+        // Critic has veto power
+        approvalWeightFraction: 0.5
+      }
+    });
+    this.changes = new ChangeManager({
+      graph: this.graph,
+      consensus: this.consensus,
+      fleet: this.fleet ?? void 0,
+      checks: DEFAULT_QUALITY_CHECKS
+    });
+    this.brain = new AutonomousBrain({
+      llmProvider: opts.llmProvider,
+      graph: this.graph,
+      fleet: this.fleet ?? void 0,
+      selfImprove: !opts.disableSelfImprove
+    });
+    this.dag.onEvent((event) => {
+      this._onDagEvent(event);
+    });
+    const offCompleted = this.fleet?.filter("subagent.completed", (e) => {
+      this._onSubagentTerminated(e);
+    });
+    if (offCompleted) this.unsubs.push(offCompleted);
+    const offFailed = this.fleet?.filter("task:failed", (e) => {
+      const payload = e.payload;
+      const taskId = payload?.taskId;
+      if (!taskId || this._handledBySubagent.has(taskId)) return;
+      this._handledBySubagent.add(taskId);
+      this._emit({ type: "goal:failed", goalId: taskId, text: payload?.error ?? "Task failed" });
+    });
+    if (offFailed) this.unsubs.push(offFailed);
+    this._emit({ type: "coordinator:mode", mode: this.fleet ? "fleet" : "standalone" });
+  }
+  // ── Public API ───────────────────────────────────────────────────────
+  /**
+   * Run the autonomous loop until the goal is satisfied or max iterations reached.
+   * This is the main entry point for a fully autonomous session.
+   */
+  async run(opts = {}) {
+    if (this.running) throw new Error("AutonomousCoordinator: already running");
+    this.running = true;
+    this.iterationCount = 0;
+    const maxIterations = opts.maxIterations ?? 100;
+    const goal = opts.goal ?? "Improve the codebase";
+    const maxCost = opts.maxCostUsd;
+    try {
+      await this.graph.load();
+      const goalConfigs = await this._decomposeGoal(goal);
+      for (const g of goalConfigs) {
+        const goalId = await this.auction.publishTask(g);
+        this.dag.addNode(goalId, g.description, []);
+        this._emit({ type: "goal:added", goalId, title: g.title, text: g.description });
+      }
+      while (this.running) {
+        this.iterationCount++;
+        if (this.iterationCount >= maxIterations) break;
+        if (maxCost !== void 0) {
+          const cost = this.fleetManager?.snapshot()?.total?.cost ?? 0;
+          if (cost >= maxCost) break;
+        }
+        if (opts.runUntilComplete && this.dag.isDone()) break;
+        const decision = await this.brain.decideAuto({
+          id: randomUUID(),
+          source: "system",
+          decisionType: "prioritize_goals",
+          question: `What should we work on next? Open goals: ${this.auction.getPendingTasks().map((g) => g.title).join(", ") || "none"}`,
+          context: {
+            goals: this.auction.getPendingTasks(),
+            fleetStatus: this._fleetStatus()
+          },
+          options: this._goalToOptions(this.auction.getPendingTasks()),
+          risk: "medium",
+          requiresConsensus: false
+        });
+        if (decision.type === "deny") {
+          const blocked = this.dag.getBlocked();
+          if (blocked.length > 0 && this.dag.hasDeadlock()) {
+            (this.events?.emit)("autonomous:deadlock", { blocked });
+            this._emit({ type: "deadlock:detected", goalId: blocked[0]?.id ?? "", text: `Deadlock detected: ${blocked.map((n) => n.id).join(", ")}` });
+            this.running = false;
+          }
+          break;
+        }
+        if (decision.type === "ask_human") {
+          (this.events?.emit)("autonomous:ask_human", { prompt: decision.prompt });
+          break;
+        }
+        if (decision.optionId) {
+          const goalNode = this._optionToGoal(decision.optionId);
+          if (goalNode) {
+            await this._processGoal(goalNode.id);
+          }
+        }
+        const pendingChanges = this.changes.getPendingReviews();
+        for (const change of pendingChanges) {
+          try {
+            await this._handlePendingChange(change);
+          } catch (err) {
+            this._emit({
+              type: "goal:failed",
+              goalId: change.id,
+              text: `Consensus handling failed: ${err instanceof Error ? err.message : String(err)}`
+            });
+          }
+        }
+      }
+    } finally {
+      this.running = false;
+    }
+    return this.getStats();
+  }
+  /** Stop the autonomous loop. */
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    console.error(`[AutonomousCoordinator] stop signal received \u2014 shutting down (iteration ${this.iterationCount})`);
+  }
+  /**
+   * Tear down the coordinator for good: stop the loop and detach all FleetBus
+   * subscriptions (this coordinator's + the auctioneer's) plus any open bid
+   * timers. Call this when discarding the instance (e.g. `/coordinator stop`
+   * that recreates a fresh coordinator on the next start) so handlers and
+   * timers don't accumulate across cycles. `stop()` only pauses the loop.
+   */
+  dispose() {
+    this.stop();
+    for (const off of this.unsubs.splice(0)) {
+      try {
+        off();
+      } catch {
+      }
+    }
+    this.auction.dispose();
+  }
+  /** Get a stats snapshot. */
+  getStats() {
+    const dagStats = this.dag.stats();
+    const auctionStats = this.auction.getStats();
+    const allGoals = this.graph.getGoals({});
+    const allChanges = this.graph.getChanges({});
+    const allDecisions = this.graph.getDecisions();
+    return {
+      goals: {
+        total: allGoals.length,
+        done: allGoals.filter((g) => g.status === "done").length,
+        pending: allGoals.filter((g) => g.status === "pending").length,
+        failed: allGoals.filter((g) => g.status === "failed").length,
+        progress: allGoals.length > 0 ? allGoals.filter((g) => g.status === "done").length / allGoals.length : 0
+      },
+      dag: dagStats,
+      auction: auctionStats,
+      changes: {
+        proposed: allChanges.filter((c) => c.status === "proposed").length,
+        approved: allChanges.filter((c) => c.status === "approved").length,
+        applied: allChanges.filter((c) => c.status === "applied").length,
+        rejected: allChanges.filter((c) => c.status === "rejected").length
+      },
+      decisions: allDecisions.length,
+      costSoFar: this.fleetManager?.snapshot()?.total?.cost
+    };
+  }
+  // ── Fact publishing ──────────────────────────────────────────────────
+  /**
+   * Publish a fact discovered by an agent. Facts are immutable and form
+   * the basis for other agents' decisions.
+   */
+  async publishFact(input) {
+    const fact = await this.graph.add({
+      type: "fact",
+      category: input.category,
+      subject: input.subject,
+      detail: input.detail,
+      file: input.file,
+      line: input.line,
+      severity: input.severity,
+      discoveredBy: this.selfAgentId,
+      discoveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tags: input.tags ?? [],
+      key: `${input.category}:${input.subject}:${input.file ?? ""}:${input.line ?? ""}`,
+      related: []
+    });
+    await this._mailboxBroadcast({
+      type: "note",
+      subject: `[${input.severity ?? "info"}] ${input.category}: ${input.subject}`,
+      body: `**${input.category}**${input.file ? ` in ${input.file}${input.line ? `:${input.line}` : ""}` : ""}
+${input.detail}`
+    });
+    this._emit({ type: "knowledge:added", knowledgeId: fact.id, title: input.subject, text: input.detail });
+    return fact;
+  }
+  // ── Goal creation helpers ────────────────────────────────────────────
+  /**
+   * Publish a goal and add it to the DAG.
+   */
+  async createGoal(input) {
+    const resolvedPriority = input.priority ?? "medium";
+    const goalId = await this.auction.publishTask({
+      title: input.title,
+      description: input.description,
+      priority: resolvedPriority,
+      ...input.tags ? { tags: input.tags } : {},
+      // Mirror the dependency edges into the auction so blocked goals aren't
+      // biddable until their deps complete (the DAG tracks the same edges).
+      ...input.deps && input.deps.length > 0 ? { blockedBy: input.deps } : {}
+    });
+    const goal = this.graph.get(goalId);
+    for (const depId of input.deps ?? []) {
+      this.dag.addNode(depId, this.graph.get(depId)?.type === "goal" ? this.graph.get(depId).title : depId);
+    }
+    this.dag.addNode(goalId, input.description, input.deps ?? []);
+    return goal;
+  }
+  // ── Private ───────────────────────────────────────────────────────────
+  async _decomposeGoal(goalText) {
+    const category = this._inferCategory(goalText);
+    const subGoals = [];
+    if (category === "security") {
+      subGoals.push({ title: "Audit for secrets", description: "Scan codebase for hardcoded secrets and API keys", priority: "critical", tags: ["security"] });
+      subGoals.push({ title: "Check injection vectors", description: "Find eval, innerHTML, SQL concat, shell injection patterns", priority: "critical", tags: ["security", "injection"] });
+      subGoals.push({ title: "Dependency audit", description: "Run npm/pnpm audit for known CVEs", priority: "high", tags: ["security", "deps"] });
+    } else if (category === "bug") {
+      subGoals.push({ title: "Find bugs", description: `Scan for bugs related to: ${goalText}`, priority: "high", tags: ["bug"] });
+      subGoals.push({ title: "Fix bugs", description: "Fix discovered bugs with tests", priority: "high", tags: ["fix"] });
+    } else if (category === "refactor") {
+      subGoals.push({ title: "Plan refactor", description: `Analyze code structure for: ${goalText}`, priority: "medium", tags: ["refactor", "planning"] });
+      subGoals.push({ title: "Implement refactor", description: "Apply the refactoring plan", priority: "medium", tags: ["refactor", "implementation"] });
+    } else {
+      subGoals.push({ title: goalText, description: goalText, priority: "medium", tags: [category] });
+    }
+    return subGoals;
+  }
+  _inferCategory(goal) {
+    const g = goal.toLowerCase();
+    if (g.includes("security") || g.includes("secret") || g.includes("injection")) return "security";
+    if (g.includes("bug") || g.includes("fix") || g.includes("error")) return "bug";
+    if (g.includes("refactor") || g.includes("debt") || g.includes("architecture")) return "architecture";
+    if (g.includes("test") || g.includes("coverage")) return "test";
+    if (g.includes("perf") || g.includes("speed") || g.includes("optimize")) return "perf";
+    if (g.includes("deps") || g.includes("package") || g.includes("update")) return "deps";
+    return "quality";
+  }
+  async _processGoal(goalId) {
+    const ready = this.dag.getReady();
+    if (ready.length === 0) return;
+    const dagNode = ready.find((n) => n.id === goalId) ?? ready[0];
+    this.dag.start(dagNode.id, "auctioneer");
+    const goalNode = this.graph.get(goalId);
+    if (!goalNode) return;
+    const title = goalNode.title || dagNode.description;
+    const taskId = await this.auction.publishTask({
+      title,
+      description: goalNode.description,
+      priority: this._dagPriorityToGoal(dagNode.priority),
+      tags: dagNode.tags
+    });
+    this._emit({ type: "task:ready", goalId, taskId, title });
+    if (this.director) {
+      const config = {
+        name: `worker-${goalId.slice(0, 8)}`,
+        role: "general",
+        maxIterations: 100,
+        timeoutMs: 6e5
+        // 10 minutes per goal
+      };
+      const subagentId = await this.director.spawn(config);
+      await this.auction.claim(taskId, subagentId, config.name);
+      await this.director.assign({
+        id: goalId,
+        subagentId,
+        description: goalNode.description
+      });
+    }
+  }
+  async _handlePendingChange(change) {
+    const result = this.consensus.getStatus(change.id);
+    if (result?.outcome !== "pending") return;
+    if (change.qualityGate.passed) {
+      const voteResult = await this.consensus.castVote(
+        change.id,
+        this.selfAgentId,
+        "approve",
+        `Quality gate passed: ${change.qualityGate.checks.map((c) => c.name).join(", ")}`
+      );
+      if (voteResult.outcome === "approved") {
+        await this.changes.markApplied(change.id, (/* @__PURE__ */ new Date()).toISOString());
+        this._emit({ type: "consensus:reached", goalId: change.id, text: "Change approved and applied" });
+      }
+    } else {
+      const voteResult = await this.consensus.castVote(
+        change.id,
+        this.selfAgentId,
+        "reject",
+        `Quality gate failed: ${change.qualityGate.checks.map((c) => `${c.name}=${c.passed}`).join(", ")}`
+      );
+      if (voteResult.outcome === "rejected" || voteResult.outcome === "vetoed") {
+        this._emit({ type: "consensus:reached", goalId: change.id, text: "Change rejected by quality gate" });
+      }
+    }
+  }
+  _onDagEvent(event) {
+    if (event.type === "node:ready") {
+      const node = this.dag.getNode(event.nodeId);
+      if (node) {
+        (this.events?.emit)("autonomous:task_ready", { taskId: event.nodeId, description: node.description });
+      }
+    }
+    if (event.type === "graph:done") {
+      (this.events?.emit)("autonomous:all_done", this.getStats());
+    }
+  }
+  _onSubagentTerminated(e) {
+    const payload = e.payload;
+    const subagentId = payload?.subagentId ?? e.subagentId;
+    const stopReason = payload?.stopReason ?? (payload?.status === "ok" ? "end_turn" : payload?.status ?? "unknown");
+    const tasks = this.auction.getTasksForAgent(subagentId);
+    for (const task of tasks) {
+      this._handledBySubagent.add(task.id);
+      if (stopReason === "end_turn") {
+        void this.auction.complete(task.id, "Subagent completed successfully");
+        this._emit({ type: "task:completed", goalId: task.id, taskId: task.id, text: "Subagent completed successfully" });
+      } else {
+        void this.auction.fail(task.id, `Subagent terminated: ${stopReason}`);
+        this._emit({ type: "goal:failed", goalId: task.id, text: `Subagent terminated: ${stopReason}` });
+      }
+    }
+  }
+  _fleetStatus() {
+    return {
+      running: this.fleetManager?.getFleetStats().running ?? 0,
+      idle: this.fleetManager?.getFleetStats().idle ?? 0,
+      total: this.fleetManager?.getFleetStats().total ?? 0,
+      costSoFar: this.fleetManager?.snapshot()?.total?.cost ?? 0
+    };
+  }
+  _buildVoters() {
+    return [
+      // The coordinator itself casts the quality-gate auto-vote in
+      // _handlePendingChange — it MUST be a registered, eligible voter or
+      // castVote throws "unknown voter" and tears down the run() loop.
+      { agentId: this.selfAgentId, agentName: "Coordinator", role: "coordinator", weight: 1 },
+      { agentId: "critic", agentName: "Critic", role: "critic", weight: 2, veto: true },
+      { agentId: "bug-hunter", agentName: "Bug Hunter", role: "bug-hunter", weight: 1.5 },
+      { agentId: "security-scanner", agentName: "Security Scanner", role: "security-scanner", weight: 1.5 },
+      { agentId: "audit-log", agentName: "Audit Log", role: "audit-log", weight: 1 },
+      { agentId: "refactor-planner", agentName: "Refactor Planner", role: "refactor-planner", weight: 1 }
+    ];
+  }
+  _goalToOptions(goals) {
+    return goals.slice(0, 5).map((g, i) => ({
+      id: g.id,
+      label: `[${g.priority}] ${g.title}`,
+      recommended: i === 0
+    }));
+  }
+  _optionToGoal(optionId) {
+    return this.graph.get(optionId);
+  }
+  _dagPriorityToGoal(p) {
+    if (p <= 1) return "critical";
+    if (p <= 2) return "high";
+    if (p <= 4) return "medium";
+    return "low";
+  }
+  async _mailboxBroadcast(msg) {
+    if (!this.mailbox) return;
+    try {
+      await this.mailbox.send({
+        from: this.selfAgentId,
+        to: "*",
+        type: msg.type,
+        subject: msg.subject,
+        body: msg.body,
+        priority: "normal"
+      });
+    } catch {
+    }
+  }
+  /** Emit a CoordinatorEvent to the subscriber (e.g. TUI panel timeline). */
+  _emit(event) {
+    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, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, CollabSession, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GlobalMailbox, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, LIGHT_BUDGET, LargeAnswerStore, MEDIUM_BUDGET, META_AGENTS, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, VERIFY_AGENTS, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, formatHumanPrompt, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, makeWorkCompleteTool, normalizeRecipient, recordPackageAction, resolveMailboxIdentity, resolveProjectDir, rosterSummaryFromConfigs, scoreAgents, startPackageOutdatedWatcher, updatePackageOutdatedStatus, withDisabledToolFiltering };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_QUALITY_CHECKS, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GlobalMailbox, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MEDIUM_BUDGET, META_AGENTS, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, formatHumanPrompt, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, makeWorkCompleteTool, normalizeRecipient, recordPackageAction, resolveMailboxIdentity, resolveProjectDir, rosterSummaryFromConfigs, scoreAgents, startPackageOutdatedWatcher, updatePackageOutdatedStatus, withDisabledToolFiltering };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map