@wrongstack/core 0.32.0 → 0.51.3

package/dist/defaults/index.js

@@ -101,11 +101,25 @@ var init_atomic_write = __esm({
   }
 });
 
+// src/utils/term.ts
+var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
+function isStdoutTTY() {
+  return hasStdout() && Boolean(process.stdout.isTTY);
+}
+function writeTo(s, stream) {
+  if (!stream || typeof stream.write !== "function") return false;
+  stream.write(s);
+  return true;
+}
+function writeErr(s, stream = process.stderr) {
+  return writeTo(s, stream);
+}
+
 // src/utils/color.ts
 var isColorTty = () => {
   if (process.env.NO_COLOR) return false;
   if (process.env.FORCE_COLOR) return true;
-  return Boolean(process.stdout?.isTTY);
+  return isStdoutTTY();
 };
 var COLOR = isColorTty();
 var wrap = (open3, close) => (s) => COLOR ? `\x1B[${open3}m${s}\x1B[${close}m` : s;
@@ -202,10 +216,10 @@ var DefaultLogger = class _DefaultLogger {
     if (r <= LEVEL_RANK.warn || this.level === "debug" || this.level === "trace") {
       const head = `${color.dim(ts)} ${COLORS[level](level.toUpperCase().padEnd(5))} ${msg}`;
       if (ctx !== void 0) {
-        process.stderr.write(`${head} ${formatCtx(ctx)}
+        writeErr(`${head} ${formatCtx(ctx)}
 `);
       } else {
-        process.stderr.write(`${head}
+        writeErr(`${head}
 `);
       }
     }
@@ -1106,9 +1120,9 @@ var DefaultMemoryStore = class {
   async readAll() {
     const parts = [];
     for (const scope of ["project-agents", "project-memory", "user-memory"]) {
-      const writeErr = this.writeErrors.get(scope);
-      if (writeErr) {
-        parts.push(`> \u26A0\uFE0F Memory write error (${labelOf(scope)}): ${writeErr.message}`);
+      const writeErr2 = this.writeErrors.get(scope);
+      if (writeErr2) {
+        parts.push(`> \u26A0\uFE0F Memory write error (${labelOf(scope)}): ${writeErr2.message}`);
       }
       const body = await this.read(scope);
       if (body.trim()) parts.push(`## ${labelOf(scope)}
@@ -10772,8 +10786,14 @@ var ParallelEternalEngine = class {
           await this.runOneIteration();
         } catch (err) {
           this.consecutiveFailures++;
-          this.opts.onError?.(err instanceof Error ? err : new Error(String(err)), this.consecutiveFailures);
-          await this.appendFailure("engine error", err instanceof Error ? err.message : String(err));
+          this.opts.onError?.(
+            err instanceof Error ? err : new Error(String(err)),
+            this.consecutiveFailures
+          );
+          await this.appendFailure(
+            "engine error",
+            err instanceof Error ? err.message : String(err)
+          );
         }
         if (this.stopRequested) break;
         await sleep2(2e3);
@@ -10789,14 +10809,19 @@ var ParallelEternalEngine = class {
    * Called by the REPL in its main loop (REPL drives, engine is stateless per tick).
    */
   async runOneIteration() {
+    const emit = (stage) => {
+      this.opts.onStage?.(stage);
+    };
     this.iterations++;
     const goal = await loadGoal(this.goalPath);
     if (!goal) {
       this.stopRequested = true;
+      emit({ phase: "stopped" });
       return false;
     }
     if (goal.goalState !== "active") {
       this.stopRequested = true;
+      emit({ phase: "stopped" });
       return false;
     }
     if (!this.coordinator) {
@@ -10809,10 +10834,13 @@ var ParallelEternalEngine = class {
       const runner = makeAgentSubagentRunner({ factory: this.agentFactory });
       this.coordinator.setRunner?.(runner);
     }
+    emit({ phase: "decompose" });
     const tasks = await this.decomposeGoal(goal);
     if (!tasks || tasks.length === 0) {
+      emit({ phase: "sleep", ms: 2e3 });
       return false;
     }
+    emit({ phase: "fanout", slots: Math.min(this.slots, tasks.length) });
     const fanOut = await this.fanOut(goal, tasks);
     this.iterationsSinceCompact++;
     const successCount = fanOut.results.filter((r) => r.status === "success").length;
@@ -10829,12 +10857,20 @@ var ParallelEternalEngine = class {
       status,
       note
     });
+    emit({
+      phase: "aggregate",
+      successCount,
+      total: fanOut.results.length,
+      goalComplete: fanOut.goalComplete
+    });
     if (fanOut.goalComplete) {
       this.stopRequested = true;
       this.state = "stopped";
+      emit({ phase: "stopped" });
       return true;
     }
     await this.maybeCompact();
+    emit({ phase: "sleep", ms: 2e3 });
     return fanOut.allSuccessful;
   }
   // -------------------------------------------------------------------------
@@ -10848,7 +10884,9 @@ var ParallelEternalEngine = class {
         (t) => dispatchAgent(t, { classifier: this.dispatchClassifier }).catch(() => null)
       )
     ) : [];
-    const recentJournal = goal.journal.slice(-5).map((e) => `  #${e.iteration} [${e.status}] ${e.task}${e.note ? ` \u2014 ${e.note.slice(0, 80)}` : ""}`).join("\n");
+    const recentJournal = goal.journal.slice(-5).map(
+      (e) => `  #${e.iteration} [${e.status}] ${e.task}${e.note ? ` \u2014 ${e.note.slice(0, 80)}` : ""}`
+    ).join("\n");
     const directivePreamble = [
       "\u2550\u2550\u2550 ETERNAL AUTONOMY \u2014 parallel task slot \u2550\u2550\u2550",
       "",
@@ -10891,35 +10929,44 @@ ${personaLine}Task: ${task}
         role: route?.role ?? "generic",
         method: route?.method ?? "none"
       });
-      spawnPromises.push((async () => {
-        try {
-          await coordinator.spawn(
-            route ? {
-              id: subagentId,
-              name: route.definition.config.name,
-              role: route.role,
-              tools: route.definition.config.tools,
-              systemPromptOverride: route.definition.config.prompt,
-              timeoutMs: this.timeoutMs
-            } : {
-              id: subagentId,
-              name: `slot-${subagentId.slice(-6)}`,
-              // Let the coordinator apply its default budget (roster or generic).
-              // Hardcoding low limits here defeats the x10 budget improvement.
-              timeoutMs: this.timeoutMs
-            }
-          );
-          subagentIds.push(subagentId);
-          taskIds.push(taskId);
-          await coordinator.assign(spec);
-        } catch {
-        }
-      })());
+      spawnPromises.push(
+        (async () => {
+          try {
+            await coordinator.spawn(
+              route ? {
+                id: subagentId,
+                name: route.definition.config.name,
+                role: route.role,
+                tools: route.definition.config.tools,
+                systemPromptOverride: route.definition.config.prompt,
+                timeoutMs: this.timeoutMs
+              } : {
+                id: subagentId,
+                name: `slot-${subagentId.slice(-6)}`,
+                // Let the coordinator apply its default budget (roster or generic).
+                // Hardcoding low limits here defeats the x10 budget improvement.
+                timeoutMs: this.timeoutMs
+              }
+            );
+            subagentIds.push(subagentId);
+            taskIds.push(taskId);
+            await coordinator.assign(spec);
+          } catch {
+          }
+        })()
+      );
     }
     await Promise.all(spawnPromises);
     if (taskIds.length === 0) {
-      return { results: [], allSuccessful: false, goalComplete: false, partialOutput: "", routes: routeInfo };
+      return {
+        results: [],
+        allSuccessful: false,
+        goalComplete: false,
+        partialOutput: "",
+        routes: routeInfo
+      };
     }
+    this.opts.onStage?.({ phase: "await", taskIds: [...taskIds] });
     let results = [];
     try {
       const ctrl = new AbortController();
@@ -11200,84 +11247,8 @@ function buildGoalPreamble(goal) {
     "BEGIN.]"
   ].join("\n");
 }
-
-// src/coordination/director.ts
 init_atomic_write();
 
-// src/coordination/large-answer-store.ts
-var LargeAnswerStore = class {
-  /**
-   * Responses above this size (in characters) are stored out-of-context.
-   * Below this, the full answer is returned inline (no overhead).
-   * Default: 2000 chars ≈ 400-600 tokens.
-   */
-  sizeThreshold;
-  store = /* @__PURE__ */ new Map();
-  constructor(sizeThreshold = 2e3) {
-    this.sizeThreshold = sizeThreshold;
-  }
-  /**
-   * Store a value, returning a summary + key for inline use.
-   * If the value is below sizeThreshold, returns it as-is (no store entry).
-   */
-  storeAnswer(value) {
-    if (value === void 0 || value === null) {
-      return { summary: String(value), inline: true };
-    }
-    const serialized = typeof value === "string" ? value : JSON.stringify(value);
-    const size = serialized.length;
-    if (size <= this.sizeThreshold) {
-      return { summary: serialized.slice(0, 500), inline: true };
-    }
-    const key = `a-${hashStr(serialized)}`;
-    this.store.set(key, {
-      key,
-      value,
-      size,
-      storedAt: Date.now()
-    });
-    return {
-      key,
-      summary: `[stored: ${size} chars \u2014 use roll_up or ask_result tool to retrieve, key=${key}]`,
-      inline: false
-    };
-  }
-  /**
-   * Retrieve a previously stored answer by its key.
-   * Returns undefined if the key is unknown or the store was cleared.
-   */
-  retrieveAnswer(key) {
-    return this.store.get(key)?.value;
-  }
-  /**
-   * Check if a key exists in the store.
-   */
-  hasAnswer(key) {
-    return this.store.has(key);
-  }
-  /** Number of stored entries. */
-  get size() {
-    return this.store.size;
-  }
-  /** Total characters stored. */
-  get totalChars() {
-    let total = 0;
-    for (const e of this.store.values()) total += e.size;
-    return total;
-  }
-  /** Clear all stored entries. Call at the end of a director run. */
-  clear() {
-    this.store.clear();
-  }
-};
-function hashStr(s) {
-  let h = 5381;
-  for (let i = 0; i < s.length; i++) {
-    h = h * 33 ^ s.charCodeAt(i);
-  }
-  return (h >>> 0).toString(36);
-}
-
 // src/coordination/in-memory-transport.ts
 var InMemoryBridgeTransport = class {
   subs = /* @__PURE__ */ new Map();
@@ -11425,1051 +11396,344 @@ function createMessage(type, from, payload, to) {
     priority: "normal"
   };
 }
-
-// src/coordination/director-prompts.ts
-var DEFAULT_DIRECTOR_PREAMBLE = `You are the Director of a multi-agent fleet. You orchestrate worker
-subagents by spawning them, assigning tasks, awaiting completions, and
-rolling up their outputs into your next decision.
-
-Core fleet tools available to you:
-  - spawn_subagent       \u2014 create a worker with a chosen provider / model / role
-  - assign_task          \u2014 hand a piece of work to a specific subagent
-  - await_tasks          \u2014 block until named task ids complete (parallel-safe)
-  - ask_subagent         \u2014 synchronously query a running subagent via the bridge
-  - roll_up              \u2014 aggregate finished tasks into a markdown/json summary
-  - terminate_subagent   \u2014 abort a stuck worker (use sparingly)
-  - fleet_status         \u2014 snapshot of all subagents and pending tasks
-  - fleet_usage          \u2014 token + cost breakdown per subagent and total
-
-Working rules:
-  1. Decompose first. Before spawning, decide which sub-tasks are
-     independent and can run in parallel. Sequential work doesn't need a
-     subagent \u2014 do it yourself.
-  2. Match worker to job. Cheap/fast model for triage, capable model for
-     synthesis. Different providers per sibling is allowed and encouraged.
-  3. Always pair an assign with an await. Don't fire-and-forget; you owe
-     the user a single coherent answer at the end.
-  4. Roll up before deciding. After await_tasks resolves, call roll_up so
-     the results are folded back into your context in a compact form.
-  5. Budget is real. Check fleet_usage periodically. If a subagent is
-     thrashing, terminate it rather than letting cost climb silently.
-  6. Never claim a subagent's work as your own without verifying it. If a
-     result looks wrong, ask_subagent for clarification before passing it
-     to the user.
-  7. Wind down when satisfied. When the results are good enough, call
-     work_complete \u2014 no new subagents will spawn and queued tasks complete
-     as aborted. Running subagents finish naturally. Call terminate_subagent
-     only for ones you need to stop immediately.`;
-var DEFAULT_SUBAGENT_BASELINE = `You are a subagent operating under a Director. You were spawned to handle
-a specific slice of a larger plan \u2014 do that slice well and report back.
-
-Bridge contract:
-  - You have a parent (the Director). You may call \`request\` on the
-    parent bridge to ask a clarifying question. Use this sparingly; the
-    parent is also working.
-  - You MAY NOT request the parent's system prompt, tool list, or other
-    subagents' context. Those are not yours to read.
-  - Your final task output is what the Director sees. Be concise,
-    structured, and self-contained \u2014 assume the Director will paste your
-    output into its own context.`;
-function composeDirectorPrompt(parts = {}) {
-  const sections = [];
-  const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
-  if (preamble && preamble.trim().length > 0) sections.push(preamble.trim());
-  if (parts.rosterSummary && parts.rosterSummary.trim().length > 0) {
-    sections.push(`Available roles you can spawn:
-${parts.rosterSummary.trim()}`);
-  }
-  if (parts.basePrompt && parts.basePrompt.trim().length > 0) {
-    sections.push(parts.basePrompt.trim());
+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 sections.join("\n\n");
+  return false;
 }
-function composeSubagentPrompt(parts = {}) {
-  const sections = [];
-  const baseline = parts.baseline ?? DEFAULT_SUBAGENT_BASELINE;
-  if (baseline && baseline.trim().length > 0) sections.push(baseline.trim());
-  if (parts.role && parts.role.trim().length > 0) {
-    sections.push(`Role:
-${parts.role.trim()}`);
-  }
-  if (parts.task && parts.task.trim().length > 0) {
-    sections.push(`Task:
-${parts.task.trim()}`);
-  }
-  if (parts.sharedScratchpad && parts.sharedScratchpad.trim().length > 0) {
-    sections.push(
-      `Shared notes:
-A scratchpad shared with the rest of the fleet is mounted at \`${parts.sharedScratchpad.trim()}\`.
-- Write your final findings as markdown files there (e.g. \`findings.md\`, \`security.md\`).
-- Before starting, list the directory and read any sibling files relevant to your task \u2014 they may already contain context you can build on.
-- Use stable filenames (one file per concern); overwrite instead of appending so the Director sees the latest state.`
-    );
-  }
-  if (parts.override && parts.override.trim().length > 0) {
-    sections.push(parts.override.trim());
+function globToRegex(pat) {
+  let i = 0, re = "^";
+  while (i < pat.length) {
+    const c = 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 sections.join("\n\n");
+  return new RegExp(re + "$");
 }
-function rosterSummaryFromConfigs(roster) {
-  const lines = [];
-  for (const [roleId, cfg] of Object.entries(roster)) {
-    const tag = cfg.provider && cfg.model ? ` (${cfg.provider}/${cfg.model})` : "";
-    const headline = cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").trim().slice(0, 80) : "";
-    const tail = headline ? ` \u2014 ${headline}` : "";
-    lines.push(`- ${roleId}: ${cfg.name}${tag}${tail}`);
-  }
-  return lines.join("\n");
+function baseDir(pat) {
+  let i = pat.length - 1;
+  while (i >= 0 && !GLOB_CHARS.has(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);
 }
-
-// src/coordination/fleet-bus.ts
-var FleetBus = class {
-  byId = /* @__PURE__ */ new Map();
-  byType = /* @__PURE__ */ new Map();
-  any = /* @__PURE__ */ new Set();
-  /**
-   * Hook a subagent's EventBus into the fleet. Uses `onAny()` (an alias for
-   * `onPattern('*')`) to forward all events with subagent attribution, so
-   * new kernel event types are automatically forwarded without any manual
-   * registration. `subagent.*` events are excluded because they originate
-   * from MultiAgentHost on the parent bus, not the subagent's own bus.
-   *
-   * Returns a disposer that detaches every subscription; call on
-   * subagent teardown so the listeners don't outlive the run.
-   */
-  attach(subagentId, bus, taskId) {
-    const off = bus.onAny((type, payload) => {
-      if (type.startsWith("subagent.")) return;
-      this.emit({ subagentId, taskId, ts: Date.now(), type, payload });
-    });
-    return () => {
-      off();
-    };
-  }
-  /** Subscribe to every event from one subagent. */
-  subscribe(subagentId, handler) {
-    let set = this.byId.get(subagentId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.byId.set(subagentId, set);
+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 walk4(dir, pat) {
+    let entries;
+    try {
+      entries = await fsp.readdir(dir);
+    } catch {
+      return;
     }
-    set.add(handler);
-    return () => {
-      set.delete(handler);
-    };
-  }
-  /** Subscribe to one event type across all subagents. */
-  filter(type, handler) {
-    let set = this.byType.get(type);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.byType.set(type, set);
+    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;
     }
-    set.add(handler);
-    return () => {
-      set.delete(handler);
-    };
-  }
-  /** Subscribe to literally everything. The fleet roll-up uses this. */
-  onAny(handler) {
-    this.any.add(handler);
-    return () => {
-      this.any.delete(handler);
-    };
-  }
-  emit(event) {
-    const byId = this.byId.get(event.subagentId);
-    if (byId)
-      for (const h of byId) {
+    const before = pat.slice(0, firstGlob);
+    const rest = pat.slice(firstGlob);
+    if (before.endsWith("**")) {
+      await walk4(dir, rest);
+      for (const e of entries) {
+        const full = `${dir}${SEP}${e}`;
         try {
-          h(event);
+          const stat5 = await fsp.stat(full);
+          if (stat5.isDirectory()) await walk4(full, rest);
         } catch {
         }
       }
-    const byType = this.byType.get(event.type);
-    if (byType)
-      for (const h of byType) {
+    } 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 {
-          h(event);
+          const stat5 = await fsp.stat(full);
+          if (stat5.isDirectory()) await walk4(full, rest);
         } catch {
         }
       }
-    for (const h of this.any) {
-      try {
-        h(event);
-      } catch {
-      }
     }
   }
-};
-var FleetUsageAggregator = class {
-  constructor(bus, priceLookup, metaLookup) {
-    this.priceLookup = priceLookup;
-    this.metaLookup = metaLookup;
-    this.unsub.push(bus.filter("provider.response", (e) => this.onProviderResponse(e)));
-    this.unsub.push(bus.filter("tool.executed", (e) => this.onToolExecuted(e)));
-    this.unsub.push(bus.filter("iteration.started", (e) => this.onIterationStarted(e)));
+  await walk4(base === "." ? "." : base, relPat);
+  return [...results];
+}
+
+// src/coordination/collab-debug.ts
+var DEFAULT_MAX_TARGET_FILES = 30;
+var CollabSession = class extends EventEmitter {
+  sessionId;
+  options;
+  snapshot;
+  director;
+  fleetBus;
+  subagentIds = /* @__PURE__ */ new Map();
+  // role → subagentId
+  bugs = /* @__PURE__ */ new Map();
+  plans = /* @__PURE__ */ new Map();
+  evaluations = /* @__PURE__ */ new Map();
+  disposers = new Array();
+  settled = false;
+  timeoutMs;
+  cancelled = false;
+  alerts = [];
+  /** Tracks tool call counts per subagent for progress-based timeout decisions. */
+  progressBySubagent = /* @__PURE__ */ new Map();
+  /** Last tool call count when a timeout warning was handled. */
+  lastTimeoutProgress = /* @__PURE__ */ new Map();
+  /** Session-level timeout timer handle (cleared on cancel or natural completion). */
+  _timeoutTimer;
+  constructor(director, fleetBus, options) {
+    super();
+    this.sessionId = randomUUID();
+    this.options = options;
+    this.director = director;
+    this.fleetBus = fleetBus;
+    this.timeoutMs = options.timeoutMs ?? 10 * 60 * 1e3;
+    if (options.prebuiltSnapshot) {
+      this.snapshot = options.prebuiltSnapshot;
+    } else {
+      this.snapshot = {
+        id: this.sessionId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        files: []
+      };
+    }
   }
-  priceLookup;
-  metaLookup;
-  perSubagent = /* @__PURE__ */ new Map();
-  total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
-  unsub = new Array();
-  /**
-   * Remove a terminated subagent's data from the aggregator and subtract its
-   * contribution from the running totals. Call this when a subagent is removed
-   * from the fleet so the aggregator doesn't accumulate unbounded data for
-   * entities that will never emit events again.
-   */
-  removeSubagent(subagentId) {
-    const snap = this.perSubagent.get(subagentId);
-    if (!snap) return;
-    this.perSubagent.delete(subagentId);
-    this.total.input -= snap.input;
-    this.total.output -= snap.output;
-    this.total.cacheRead -= snap.cacheRead;
-    this.total.cacheWrite -= snap.cacheWrite;
-    this.total.cost -= snap.cost;
+  get id() {
+    return this.sessionId;
   }
-  /** Disposes all fleet-bus subscriptions. Call when the aggregator is no longer needed. */
-  dispose() {
-    for (const off of this.unsub) off();
-    this.unsub.length = 0;
+  getSessionAlerts() {
+    return [...this.alerts];
   }
-  /** Live snapshot — safe to call from a tool's execute() body. */
-  snapshot() {
-    return {
-      total: { ...this.total },
-      perSubagent: Object.fromEntries(
-        Array.from(this.perSubagent.entries()).map(([k, v]) => [k, { ...v }])
-      )
-    };
+  isCancelled() {
+    return this.cancelled;
   }
-  ensure(subagentId) {
-    let snap = this.perSubagent.get(subagentId);
-    if (!snap) {
-      const meta = this.metaLookup?.(subagentId);
-      snap = {
-        subagentId,
-        provider: meta?.provider,
-        model: meta?.model,
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        cost: 0,
-        toolCalls: 0,
-        iterations: 0,
-        startedAt: Date.now(),
-        lastEventAt: Date.now()
-      };
-      this.perSubagent.set(subagentId, snap);
-    }
-    return snap;
+  /**
+   * Snapshot of role → subagentId map. The Director calls coordinator.stop()
+   * for each agent when cancelling the session, using this map to enumerate
+   * all three collab agents.
+   */
+  getSubagentIds() {
+    return new Map(this.subagentIds);
   }
-  onProviderResponse(e) {
-    const snap = this.ensure(e.subagentId);
-    const p = e.payload;
-    const usage = p?.usage;
-    if (!usage) return;
-    snap.input += usage.input ?? 0;
-    snap.output += usage.output ?? 0;
-    snap.cacheRead += usage.cacheRead ?? 0;
-    snap.cacheWrite += usage.cacheWrite ?? 0;
-    this.total.input += usage.input ?? 0;
-    this.total.output += usage.output ?? 0;
-    this.total.cacheRead += usage.cacheRead ?? 0;
-    this.total.cacheWrite += usage.cacheWrite ?? 0;
-    const price = this.priceLookup?.(e.subagentId, snap.provider, snap.model);
-    if (price) {
-      const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
-      snap.cost += delta;
-      this.total.cost += delta;
+  /**
+   * Returns the effective file limit for this session.
+   * Priority: explicit `maxTargetFiles` > dynamic from `contextWindow` > `DEFAULT_MAX_TARGET_FILES`.
+   */
+  effectiveFileLimit() {
+    if (this.options.maxTargetFiles !== void 0) {
+      return this.options.maxTargetFiles;
     }
-    snap.lastEventAt = e.ts;
+    if (this.options.contextWindow !== void 0) {
+      return Math.max(5, Math.floor(this.options.contextWindow * 0.4 / 2e3));
+    }
+    return DEFAULT_MAX_TARGET_FILES;
   }
-  onToolExecuted(e) {
-    const snap = this.ensure(e.subagentId);
-    snap.toolCalls += 1;
-    snap.lastEventAt = e.ts;
+  async buildSnapshot() {
+    if (this.snapshot.files.length > 0) return this.snapshot;
+    const allFiles = [];
+    for (const pattern of this.options.targetPaths) {
+      const expanded = await expandGlob(pattern);
+      allFiles.push(...expanded);
+    }
+    const limit = this.effectiveFileLimit();
+    if (allFiles.length > limit) {
+      const hint = this.options.contextWindow ? `contextWindow=${this.options.contextWindow} \u2192 calculated limit=${limit}` : `default limit=${DEFAULT_MAX_TARGET_FILES}`;
+      throw new Error(
+        `[collab_debug] Target has ${allFiles.length} files, which exceeds the limit (${hint}). Narrow the target or pass maxTargetFiles / contextWindow to override. For large codebases, run package-by-package or module-by-module sessions instead of targeting the entire repo.`
+      );
+    }
+    for (const filePath of allFiles) {
+      try {
+        const content = await fsp.readFile(filePath, "utf8");
+        const ext = filePath.split(".").pop() ?? "";
+        const language = ext === "ts" || ext === "tsx" ? "typescript" : ext === "js" || ext === "jsx" ? "javascript" : ext === "md" ? "markdown" : ext === "json" ? "json" : void 0;
+        this.snapshot.files.push({ path: filePath, content, language });
+      } catch {
+        this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
+      }
+    }
+    return this.snapshot;
   }
-  onIterationStarted(e) {
-    const snap = this.ensure(e.subagentId);
-    snap.iterations += 1;
-    snap.lastEventAt = e.ts;
+  /**
+   * Cancel the session. Emits director.cancel_collab on the FleetBus so all
+   * collab agents finish early. The session-level timeout timer is also cleared.
+   * Safe to call multiple times (idempotent after first call).
+   */
+  cancel(reason = "Director cancelled collab session") {
+    if (this.settled) return;
+    this.cancelled = true;
+    if (this._timeoutTimer) {
+      clearTimeout(this._timeoutTimer);
+      this._timeoutTimer = void 0;
+    }
+    this.fleetBus.emit({
+      subagentId: this.director.id,
+      ts: Date.now(),
+      type: "director.cancel_collab",
+      payload: { sessionId: this.sessionId, reason, cancelledAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+    this.fleetBus.emit({
+      subagentId: this.director.id,
+      ts: Date.now(),
+      type: "collab.cancelled",
+      payload: { sessionId: this.sessionId, reason }
+    });
   }
-};
-function makeSpawnTool(director, roster) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      role: { type: "string", description: "Roster role id. When set, the spawn uses the matching config from the roster and ignores other fields." },
-      description: { type: "string", description: "Free-form task description. When `role` is not set, the director uses the smart dispatcher to route this to the best-matching catalog agent. Use this when you don't know the exact role name." },
-      name: { type: "string", description: "Display name for the subagent. Used as a fallback when description-based dispatch does not resolve a role." },
-      provider: { type: "string", description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the leader provider when omitted.' },
-      model: { type: "string", description: "Model id within the provider. Defaults to the leader model when omitted." },
-      systemPromptOverride: { type: "string", description: "Extra prompt text appended after the role-base prompt." },
-      maxIterations: { type: "number", minimum: 1 },
-      maxToolCalls: { type: "number", minimum: 1 },
-      maxCostUsd: { type: "number", minimum: 0 },
-      timeoutMs: { type: "number", minimum: 1, description: "Hard wall-clock cap in milliseconds. Defaults to none (idle timeout is the default reaper)." },
-      idleTimeoutMs: { type: "number", minimum: 1, description: "Idle timeout in ms: reap the subagent after this long with no activity. Resets on every iteration/tool call. Default is role/coordinator-specific." },
-      maxTokens: { type: "number", minimum: 1, description: "Maximum total tokens (input + output) the subagent may use." }
-    },
-    required: []
-  };
-  return {
-    name: "spawn_subagent",
-    description: "Create a new subagent under this director. Returns the subagent id.",
-    usageHint: "Pass `role` (matches the roster), `description` (smart dispatch to best agent), or `name` + `provider`/`model`. Returns `{ subagentId }`.",
-    permission: "auto",
-    mutating: false,
-    inputSchema,
-    async execute(input) {
-      const i = input ?? {};
-      const role = typeof i.role === "string" ? i.role : void 0;
-      const description = typeof i.description === "string" ? i.description : void 0;
-      let cfg;
-      if (role && roster) {
-        const base = roster[role];
-        if (!base) return { error: `unknown role "${role}". roster has: ${Object.keys(roster).join(", ")}` };
-        cfg = instantiateRosterConfig(role, base);
-      } else if (description && !role) {
-        const dispatchResult = await dispatchAgent(description, {
-          classifier: director.dispatchClassifier,
-          catalog: roster
-        });
-        const dispatchRole = dispatchResult.role;
-        if (roster?.[dispatchRole]) {
-          cfg = instantiateRosterConfig(dispatchRole, roster[dispatchRole]);
-        } else {
-          const def = dispatchResult.definition;
-          cfg = {
-            name: def.config.name ?? dispatchRole,
-            role: dispatchRole,
-            provider: def.config.provider,
-            model: def.config.model
-          };
-        }
+  async start() {
+    if (this.settled) throw new Error("session already settled");
+    this.settled = true;
+    await this.buildSnapshot();
+    this.wireFleetBus();
+    const [bugHunterId, refactorPlannerId, criticId] = await Promise.all([
+      this.spawnAgent("bug-hunter", this.buildBugHunterTask()),
+      this.spawnAgent("refactor-planner", this.buildRefactorPlannerTask()),
+      this.spawnAgent("critic", this.buildCriticTask())
+    ]);
+    this.subagentIds.set("bug-hunter", bugHunterId);
+    this.subagentIds.set("refactor-planner", refactorPlannerId);
+    this.subagentIds.set("critic", criticId);
+    const timeout = new Promise((_, reject) => {
+      this._timeoutTimer = setTimeout(() => {
+        this.cancel("Session-level timeout reached");
+        reject(new Error(`CollabSession timed out after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+    });
+    let results = null;
+    try {
+      results = await Promise.race([
+        Promise.all([
+          this.director.awaitTasks([bugHunterId]),
+          this.director.awaitTasks([refactorPlannerId]),
+          this.director.awaitTasks([criticId])
+        ]),
+        timeout
+      ]);
+    } catch (err) {
+      if (this._timeoutTimer) {
+        clearTimeout(this._timeoutTimer);
+        this._timeoutTimer = void 0;
       }
-      cfg ??= { name: i.name ?? "subagent" };
-      if (typeof i.name === "string") cfg.name = i.name;
-      if (typeof i.provider === "string") cfg.provider = i.provider;
-      if (typeof i.model === "string") cfg.model = i.model;
-      if (typeof i.systemPromptOverride === "string") cfg.systemPromptOverride = i.systemPromptOverride;
-      if (typeof i.maxIterations === "number") cfg.maxIterations = i.maxIterations;
-      if (typeof i.maxToolCalls === "number") cfg.maxToolCalls = i.maxToolCalls;
-      if (typeof i.maxCostUsd === "number") cfg.maxCostUsd = i.maxCostUsd;
-      if (typeof i.timeoutMs === "number") cfg.timeoutMs = i.timeoutMs;
-      if (typeof i.idleTimeoutMs === "number") cfg.idleTimeoutMs = i.idleTimeoutMs;
-      if (typeof i.maxTokens === "number") cfg.maxTokens = i.maxTokens;
-      try {
-        const subagentId = await director.spawn(cfg);
-        return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name, role: cfg.role };
-      } catch (err) {
-        if (err instanceof FleetSpawnBudgetError) {
-          return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
-        }
-        if (err instanceof FleetCostCapError) {
-          return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
+      this.cleanup();
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.emit("session.error", error);
+      throw error;
+    }
+    for (const result of results.flat()) {
+      await this.parseAndEmit(result);
+    }
+    const report = this.assembleReport();
+    this.cleanup();
+    this.emit("session.done", report);
+    return report;
+  }
+  async parseAndEmit(result) {
+    if (result.status !== "success" || result.result == null) return;
+    const text = typeof result.result === "string" ? result.result : JSON.stringify(result.result);
+    for (const obj of this.extractJsonObjects(text)) {
+      const type = "finding" in obj ? "bug.found" : "plan" in obj ? "refactor.plan" : "evaluation" in obj ? "critic.evaluation" : null;
+      if (!type) continue;
+      this.fleetBus.emit({
+        subagentId: result.subagentId,
+        taskId: result.taskId,
+        ts: Date.now(),
+        type,
+        payload: obj
+      });
+    }
+  }
+  extractJsonObjects(text) {
+    const objects = [];
+    let depth = 0;
+    let start = -1;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (inString) {
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === '"') inString = false;
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+      } else if (ch === "{") {
+        if (depth === 0) start = i;
+        depth++;
+      } else if (ch === "}" && depth > 0) {
+        depth--;
+        if (depth === 0 && start >= 0) {
+          const candidate = text.slice(start, i + 1);
+          try {
+            const parsed = JSON.parse(candidate);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+              objects.push(parsed);
+            }
+          } catch {
+          }
+          start = -1;
         }
-        return { error: err instanceof Error ? err.message : String(err) };
       }
     }
-  };
-}
-function instantiateRosterConfig(role, base) {
-  return {
-    ...base,
-    // Roster entries are templates. A director may spawn several
-    // workers with the same role, so never reuse the template id.
-    id: `${role}-${randomUUID().slice(0, 8)}`
-  };
-}
-function makeAssignTool(director) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      subagentId: { type: "string", minLength: 1, description: "Target subagent id. Required." },
-      description: { type: "string", minLength: 1, description: "The task in natural language \u2014 what you want this subagent to do." },
-      maxToolCalls: { type: "number", minimum: 1, description: "Optional per-task tool-call budget override." },
-      timeoutMs: { type: "number", minimum: 1, description: "Optional per-task timeout in ms." }
-    },
-    required: ["subagentId", "description"]
-  };
-  return {
-    name: "assign_task",
-    description: "Hand a task to a previously spawned subagent. Returns the task id.",
-    permission: "auto",
-    mutating: false,
-    inputSchema,
-    async execute(input) {
-      const i = input;
-      const task = { id: randomUUID(), description: i.description, subagentId: i.subagentId, maxToolCalls: i.maxToolCalls, timeoutMs: i.timeoutMs };
-      const taskId = await director.assign(task);
-      return { taskId, subagentId: i.subagentId };
-    }
-  };
-}
-function makeAwaitTasksTool(director) {
-  return {
-    name: "await_tasks",
-    description: "Block until every named task completes. Returns the array of TaskResult.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: { type: "object", properties: { taskIds: { type: "array", items: { type: "string" }, description: "One or more task ids returned by `assign_task`." } }, required: ["taskIds"] },
-    async execute(input) {
-      const i = input;
-      const results = await director.awaitTasks(i.taskIds);
-      return { results };
-    }
-  };
-}
-function makeAskTool(director) {
-  return {
-    name: "ask_subagent",
-    description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: {
-      type: "object",
-      properties: {
-        subagentId: { type: "string", minLength: 1, description: "Subagent to ask. Must be a previously spawned id." },
-        question: { type: "string", minLength: 1, description: "The question or instruction." },
-        timeoutMs: { type: "number", minimum: 1, description: "Optional timeout in ms (default 30s)." }
-      },
-      required: ["subagentId", "question"]
-    },
-    async execute(input) {
-      const i = input;
-      try {
-        const answer = await director.ask(i.subagentId, { question: i.question }, i.timeoutMs);
-        const stored = director.largeAnswerStore.storeAnswer(answer);
-        if (stored.inline) {
-          return { ok: true, answer: stored.summary };
-        }
-        return {
-          ok: true,
-          answer: stored.summary,
-          _answerKey: stored.key,
-          _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) };
-      }
-    }
-  };
-}
-function makeAskResultTool(director) {
-  return {
-    name: "ask_result",
-    description: "Retrieve a large `ask_subagent` response that was stored out-of-context (>2K chars). Returns the full stored value.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: {
-      type: "object",
-      properties: {
-        key: {
-          type: "string",
-          minLength: 1,
-          description: "The `_answerKey` returned by `ask_subagent` for a large response."
-        }
-      },
-      required: ["key"]
-    },
-    async execute(input) {
-      const i = input;
-      const value = director.largeAnswerStore.retrieveAnswer(i.key);
-      if (value === void 0) {
-        return { ok: false, error: `No stored answer found for key "${i.key}" \u2014 it may have been cleared or the key is invalid.` };
-      }
-      return { ok: true, value };
-    }
-  };
-}
-function makeRollUpTool(director) {
-  return {
-    name: "roll_up",
-    description: "Aggregate completed task results into a single formatted summary.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: {
-      type: "object",
-      properties: {
-        taskIds: { type: "array", items: { type: "string" }, description: "Completed task ids to aggregate." },
-        style: { type: "string", enum: ["markdown", "json"], description: "Output flavor \u2014 markdown (default) or json." }
-      },
-      required: ["taskIds"]
-    },
-    async execute(input) {
-      const i = input;
-      const summary = director.rollUp(i.taskIds, i.style ?? "markdown");
-      return { summary, count: i.taskIds.length };
-    }
-  };
-}
-function makeTerminateTool(director) {
-  return {
-    name: "terminate_subagent",
-    description: 'Forcibly abort a subagent. The subagent finishes its current iteration then exits with status "stopped".',
-    permission: "auto",
-    mutating: true,
-    inputSchema: { type: "object", properties: { subagentId: { type: "string", description: "Subagent to abort." } }, required: ["subagentId"] },
-    async execute(input) {
-      const i = input;
-      await director.terminate(i.subagentId);
-      return { ok: true };
-    }
-  };
-}
-function makeTerminateAllTool(director) {
-  return {
-    name: "terminate_all",
-    description: 'Forcibly stop every subagent in the fleet and drain the pending task queue. In-flight tasks are terminated mid-execution; pending tasks receive "aborted_by_parent" completion immediately. Use this when the fleet is wedged, looping, or you need a clean slate. Compare: work_complete stops spawning but lets running agents finish naturally.',
-    permission: "auto",
-    mutating: true,
-    inputSchema: { type: "object", properties: {}, required: [] },
-    async execute() {
-      await director.terminateAll();
-      return { ok: true, message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.` };
-    }
-  };
-}
-function makeFleetStatusTool(director) {
-  return {
-    name: "fleet_status",
-    description: "Snapshot of the fleet \u2014 every subagent's current status, coordinator counts (total/running/idle/stopped), pending task descriptions, and usage rollup.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: { type: "object", properties: {}, required: [] },
-    async execute() {
-      const base = director.status();
-      const fm = director.fleetManager;
-      const stats = fm?.getFleetStats();
-      const fleetStatus = fm?.getFleetStatus();
-      return {
-        subagents: base.subagents,
-        coordinatorStats: stats ? { total: stats.total, running: stats.running, idle: stats.idle, stopped: stats.stopped } : void 0,
-        pending: fleetStatus?.pending ?? [],
-        usage: fm?.snapshot()
-      };
-    }
-  };
-}
-function makeFleetUsageTool(director) {
-  return {
-    name: "fleet_usage",
-    description: "Token + cost breakdown across the fleet, per-subagent and totals.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: { type: "object", properties: {}, required: [] },
-    async execute() {
-      return director.snapshot();
-    }
-  };
-}
-function makeFleetSessionTool(director) {
-  return {
-    name: "fleet_session",
-    description: "Read a subagent's JSONL transcript and extract its last assistant text, stop reason, and tool-use count. Use this to see what a running or timed-out subagent actually produced.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: {
-      type: "object",
-      properties: {
-        subagentId: { type: "string", description: "Subagent id to read the transcript of." },
-        tail: { type: "number", description: "Number of trailing JSONL lines to return. Omit for the full transcript." }
-      },
-      required: ["subagentId"]
-    },
-    async execute(input) {
-      const i = input;
-      const result = await director.readSession(i.subagentId, i.tail);
-      if (!result) {
-        return {
-          error: `fleet_session: transcript unavailable for "${i.subagentId}". Is sessionsRoot configured?`
-        };
-      }
-      return result;
-    }
-  };
-}
-function makeFleetHealthTool(director) {
-  return {
-    name: "fleet_health",
-    description: "Per-subagent health report: budget pressure (pct of limits consumed), last activity timestamp, and current status. Use to decide whether to assign more work to a subagent or spawn a fresh one.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: { type: "object", properties: {}, required: [] },
-    async execute() {
-      const status = director.status();
-      const snapshot = director.snapshot();
-      const subagents = status.subagents ?? [];
-      const perSubagent = snapshot.perSubagent ?? {};
-      return {
-        subagents: subagents.map((s) => {
-          const usage = perSubagent[s.id];
-          return {
-            id: s.id,
-            status: s.status,
-            lastEventAt: usage?.lastEventAt,
-            budgetPressure: {
-              iterations: usage?.iterations,
-              toolCalls: usage?.toolCalls,
-              costUsd: usage?.cost
-            }
-          };
-        })
-      };
-    }
-  };
-}
-function makeCollabDebugTool(director) {
-  return {
-    name: "collab_debug",
-    description: "Start a collaborative debugging session: BugHunter, RefactorPlanner, and Critic run in parallel on the same target files. BugHunter finds bugs and emits bug.found events. RefactorPlanner listens for bug.found and emits refactor.plan events. Critic evaluates both and emits critic.evaluation events. Returns a structured report with overall verdict (approve / needs_revision / reject).",
-    permission: "auto",
-    mutating: false,
-    inputSchema: {
-      type: "object",
-      properties: {
-        targetPaths: {
-          type: "array",
-          items: { type: "string" },
-          description: "File paths / glob patterns to scan for bugs."
-        },
-        timeoutMs: {
-          type: "number",
-          minimum: 1,
-          description: "Timeout in ms. Default: 600000 (10 minutes)."
-        },
-        maxTargetFiles: {
-          type: "number",
-          minimum: 1,
-          description: "Maximum number of files to include in the snapshot. If not set, the limit is computed dynamically from contextWindow or falls back to the default (30)."
-        },
-        contextWindow: {
-          type: "number",
-          minimum: 1,
-          description: "Context window size (tokens) of the model. When provided and maxTargetFiles is not set, the file limit is computed dynamically as floor((contextWindow * 0.4) / 2000)."
-        }
-      },
-      required: ["targetPaths"]
-    },
-    async execute(input) {
-      const i = input;
-      if (!i.targetPaths?.length) {
-        return { error: "collab_debug: targetPaths is required and must be non-empty." };
-      }
-      const options = {
-        targetPaths: i.targetPaths,
-        timeoutMs: i.timeoutMs,
-        maxTargetFiles: i.maxTargetFiles,
-        contextWindow: i.contextWindow
-      };
-      try {
-        const report = await director.spawnCollab(options);
-        return {
-          sessionId: report.sessionId,
-          overallVerdict: report.overallVerdict,
-          bugCount: report.bugs.length,
-          planCount: report.refactorPlans.length,
-          evaluationCount: report.evaluations.length,
-          summary: report.summary,
-          bugs: report.bugs,
-          refactorPlans: report.refactorPlans,
-          evaluations: report.evaluations
-        };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return { error: "collab_debug failed: " + msg };
-      }
-    }
-  };
-}
-function makeFleetEmitTool(director) {
-  return {
-    name: "fleet_emit",
-    description: "Emit a structured event on the FleetBus. Any subagent can emit any event type; the Director routes it to all listeners. Use it to stream findings, progress updates, or final results to other agents in real time.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: {
-      type: "object",
-      properties: {
-        type: {
-          type: "string",
-          description: "Event type string (e.g. bug.found, refactor.plan, critic.evaluation, progress, result)."
-        },
-        payload: {
-          type: "object",
-          description: "Event payload. Structure depends on event type. Use null if no payload."
-        }
-      },
-      required: ["type"]
-    },
-    async execute(input) {
-      const i = input;
-      director.fleet.emit({
-        subagentId: director.id,
-        ts: Date.now(),
-        type: i.type,
-        payload: i.payload ?? {}
-      });
-      return { ok: true, event: i.type };
-    }
-  };
-}
-function makeWorkCompleteTool(director) {
-  return {
-    name: "work_complete",
-    description: "Signal that the director is satisfied with the results and the fleet should wind down. After calling this, spawn_subagent will refuse with a budget error and assign_task will instantly complete any queued tasks as aborted. Running subagents finish naturally. Call terminate_subagent separately to stop specific subagents immediately.",
-    permission: "auto",
-    mutating: false,
-    inputSchema: { type: "object", properties: {}, required: [] },
-    async execute() {
-      director.workComplete();
-      return { ok: true, message: "Fleet wind-down signaled. No new spawns or task dispatches." };
-    }
-  };
-}
-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, re = "^";
-  while (i < pat.length) {
-    const c = 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(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 walk4(dir, pat) {
-    let entries;
-    try {
-      entries = await fsp.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 walk4(dir, rest);
-      for (const e of entries) {
-        const full = `${dir}${SEP}${e}`;
-        try {
-          const stat5 = await fsp.stat(full);
-          if (stat5.isDirectory()) await walk4(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 fsp.stat(full);
-          if (stat5.isDirectory()) await walk4(full, rest);
-        } catch {
-        }
-      }
-    }
-  }
-  await walk4(base === "." ? "." : base, relPat);
-  return [...results];
-}
-
-// src/coordination/collab-debug.ts
-var DEFAULT_MAX_TARGET_FILES = 30;
-var CollabSession = class extends EventEmitter {
-  sessionId;
-  options;
-  snapshot;
-  director;
-  fleetBus;
-  subagentIds = /* @__PURE__ */ new Map();
-  // role → subagentId
-  bugs = /* @__PURE__ */ new Map();
-  plans = /* @__PURE__ */ new Map();
-  evaluations = /* @__PURE__ */ new Map();
-  disposers = new Array();
-  settled = false;
-  timeoutMs;
-  cancelled = false;
-  alerts = [];
-  /** Tracks tool call counts per subagent for progress-based timeout decisions. */
-  progressBySubagent = /* @__PURE__ */ new Map();
-  /** Last tool call count when a timeout warning was handled. */
-  lastTimeoutProgress = /* @__PURE__ */ new Map();
-  /** Session-level timeout timer handle (cleared on cancel or natural completion). */
-  _timeoutTimer;
-  constructor(director, fleetBus, options) {
-    super();
-    this.sessionId = randomUUID();
-    this.options = options;
-    this.director = director;
-    this.fleetBus = fleetBus;
-    this.timeoutMs = options.timeoutMs ?? 10 * 60 * 1e3;
-    if (options.prebuiltSnapshot) {
-      this.snapshot = options.prebuiltSnapshot;
-    } else {
-      this.snapshot = {
-        id: this.sessionId,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        files: []
-      };
-    }
-  }
-  get id() {
-    return this.sessionId;
-  }
-  getSessionAlerts() {
-    return [...this.alerts];
-  }
-  isCancelled() {
-    return this.cancelled;
-  }
-  /**
-   * Snapshot of role → subagentId map. The Director calls coordinator.stop()
-   * for each agent when cancelling the session, using this map to enumerate
-   * all three collab agents.
-   */
-  getSubagentIds() {
-    return new Map(this.subagentIds);
-  }
-  /**
-   * Returns the effective file limit for this session.
-   * Priority: explicit `maxTargetFiles` > dynamic from `contextWindow` > `DEFAULT_MAX_TARGET_FILES`.
-   */
-  effectiveFileLimit() {
-    if (this.options.maxTargetFiles !== void 0) {
-      return this.options.maxTargetFiles;
-    }
-    if (this.options.contextWindow !== void 0) {
-      return Math.max(5, Math.floor(this.options.contextWindow * 0.4 / 2e3));
-    }
-    return DEFAULT_MAX_TARGET_FILES;
-  }
-  async buildSnapshot() {
-    if (this.snapshot.files.length > 0) return this.snapshot;
-    const allFiles = [];
-    for (const pattern of this.options.targetPaths) {
-      const expanded = await expandGlob(pattern);
-      allFiles.push(...expanded);
-    }
-    const limit = this.effectiveFileLimit();
-    if (allFiles.length > limit) {
-      const hint = this.options.contextWindow ? `contextWindow=${this.options.contextWindow} \u2192 calculated limit=${limit}` : `default limit=${DEFAULT_MAX_TARGET_FILES}`;
-      throw new Error(
-        `[collab_debug] Target has ${allFiles.length} files, which exceeds the limit (${hint}). Narrow the target or pass maxTargetFiles / contextWindow to override. For large codebases, run package-by-package or module-by-module sessions instead of targeting the entire repo.`
-      );
-    }
-    for (const filePath of allFiles) {
-      try {
-        const content = await fsp.readFile(filePath, "utf8");
-        const ext = filePath.split(".").pop() ?? "";
-        const language = ext === "ts" || ext === "tsx" ? "typescript" : ext === "js" || ext === "jsx" ? "javascript" : ext === "md" ? "markdown" : ext === "json" ? "json" : void 0;
-        this.snapshot.files.push({ path: filePath, content, language });
-      } catch {
-        this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
-      }
-    }
-    return this.snapshot;
-  }
-  /**
-   * Cancel the session. Emits director.cancel_collab on the FleetBus so all
-   * collab agents finish early. The session-level timeout timer is also cleared.
-   * Safe to call multiple times (idempotent after first call).
-   */
-  cancel(reason = "Director cancelled collab session") {
-    if (this.settled) return;
-    this.cancelled = true;
-    if (this._timeoutTimer) {
-      clearTimeout(this._timeoutTimer);
-      this._timeoutTimer = void 0;
-    }
-    this.fleetBus.emit({
-      subagentId: this.director.id,
-      ts: Date.now(),
-      type: "director.cancel_collab",
-      payload: { sessionId: this.sessionId, reason, cancelledAt: (/* @__PURE__ */ new Date()).toISOString() }
-    });
-    this.fleetBus.emit({
-      subagentId: this.director.id,
-      ts: Date.now(),
-      type: "collab.cancelled",
-      payload: { sessionId: this.sessionId, reason }
-    });
-  }
-  async start() {
-    if (this.settled) throw new Error("session already settled");
-    this.settled = true;
-    await this.buildSnapshot();
-    this.wireFleetBus();
-    const [bugHunterId, refactorPlannerId, criticId] = await Promise.all([
-      this.spawnAgent("bug-hunter", this.buildBugHunterTask()),
-      this.spawnAgent("refactor-planner", this.buildRefactorPlannerTask()),
-      this.spawnAgent("critic", this.buildCriticTask())
-    ]);
-    this.subagentIds.set("bug-hunter", bugHunterId);
-    this.subagentIds.set("refactor-planner", refactorPlannerId);
-    this.subagentIds.set("critic", criticId);
-    const timeout = new Promise((_, reject) => {
-      this._timeoutTimer = setTimeout(() => {
-        this.cancel("Session-level timeout reached");
-        reject(new Error(`CollabSession timed out after ${this.timeoutMs}ms`));
-      }, this.timeoutMs);
-    });
-    let results = null;
-    try {
-      results = await Promise.race([
-        Promise.all([
-          this.director.awaitTasks([bugHunterId]),
-          this.director.awaitTasks([refactorPlannerId]),
-          this.director.awaitTasks([criticId])
-        ]),
-        timeout
-      ]);
-    } catch (err) {
-      if (this._timeoutTimer) {
-        clearTimeout(this._timeoutTimer);
-        this._timeoutTimer = void 0;
-      }
-      this.cleanup();
-      const error = err instanceof Error ? err : new Error(String(err));
-      this.emit("session.error", error);
-      throw error;
-    }
-    for (const result of results.flat()) {
-      await this.parseAndEmit(result);
-    }
-    const report = this.assembleReport();
-    this.cleanup();
-    this.emit("session.done", report);
-    return report;
-  }
-  async parseAndEmit(result) {
-    if (result.status !== "success" || result.result == null) return;
-    const text = typeof result.result === "string" ? result.result : JSON.stringify(result.result);
-    for (const obj of this.extractJsonObjects(text)) {
-      const type = "finding" in obj ? "bug.found" : "plan" in obj ? "refactor.plan" : "evaluation" in obj ? "critic.evaluation" : null;
-      if (!type) continue;
-      this.fleetBus.emit({
-        subagentId: result.subagentId,
-        taskId: result.taskId,
-        ts: Date.now(),
-        type,
-        payload: obj
-      });
-    }
-  }
-  extractJsonObjects(text) {
-    const objects = [];
-    let depth = 0;
-    let start = -1;
-    let inString = false;
-    let escaped = false;
-    for (let i = 0; i < text.length; i++) {
-      const ch = text[i];
-      if (inString) {
-        if (escaped) escaped = false;
-        else if (ch === "\\") escaped = true;
-        else if (ch === '"') inString = false;
-        continue;
-      }
-      if (ch === '"') {
-        inString = true;
-      } else if (ch === "{") {
-        if (depth === 0) start = i;
-        depth++;
-      } else if (ch === "}" && depth > 0) {
-        depth--;
-        if (depth === 0 && start >= 0) {
-          const candidate = text.slice(start, i + 1);
-          try {
-            const parsed = JSON.parse(candidate);
-            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-              objects.push(parsed);
-            }
-          } catch {
-          }
-          start = -1;
-        }
-      }
-    }
-    return objects;
-  }
-  budgetForRole(role) {
-    if (this.options.budgetOverrides?.[role]) {
-      return this.options.budgetOverrides[role];
+    return objects;
+  }
+  budgetForRole(role) {
+    if (this.options.budgetOverrides?.[role]) {
+      return this.options.budgetOverrides[role];
     }
     const defaults = {
       "bug-hunter": { maxIterations: 2e3, maxToolCalls: 5e3, timeoutMs: 10 * 60 * 1e3 },
@@ -12530,252 +11794,1054 @@ ${scratchpad}/refactor-plan-${this.sessionId}.md
 
 Emit each plan immediately. Do not wait until planning is complete.`;
   }
-  buildCriticTask() {
-    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
-    const bugHunterReportPath = `${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
-    const refactorPlanPath = `${scratchpad}/refactor-plan-${this.sessionId}.md`;
-    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
-${f.content}`).join("\n\n");
-    return `You are Critic. Evaluate bug findings and refactor plans.
-
-Target files:
-${fileContents}
+  buildCriticTask() {
+    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const bugHunterReportPath = `${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
+    const refactorPlanPath = `${scratchpad}/refactor-plan-${this.sessionId}.md`;
+    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
+${f.content}`).join("\n\n");
+    return `You are Critic. Evaluate bug findings and refactor plans.
+
+Target files:
+${fileContents}
+
+Read the BugHunter report at: ${bugHunterReportPath}
+Read the RefactorPlanner report at: ${refactorPlanPath}
+
+For each bug and refactor plan, emit your evaluation using fleet_emit:
+{ "type": "critic.evaluation", "payload": { "evaluation": { "id": "<uuid>", "subjectType": "<bug_finding|refactor_plan>", "subjectId": "<id>", "score": <0-10>, "verdict": "<approve|needs_revision|reject>", "strengths": ["<strength>"], "weaknesses": ["<weakness>"], "concerns": [{ "description": "<concern>", "severity": "<blocking|advisory>" }] } } }
+
+After all evaluations, write your markdown report to:
+${scratchpad}/critic-report-${this.sessionId}.md
+
+Emit each evaluation immediately. Do not wait until you have read all reports.`;
+  }
+  wireFleetBus() {
+    const dTool = this.fleetBus.filter("tool.executed", (e) => {
+      this.progressBySubagent.set(e.subagentId, (this.progressBySubagent.get(e.subagentId) ?? 0) + 1);
+    });
+    this.disposers.push(dTool);
+    const dBudget = this.fleetBus.filter("budget.threshold_reached", (e) => {
+      const payload = e.payload;
+      const role = this.roleFromSubagentId(e.subagentId);
+      if (!role) return;
+      const btwNotes = this.director.getLeaderBtwNotes();
+      const alert = {
+        sessionId: this.sessionId,
+        subagentId: e.subagentId,
+        role,
+        level: "warning" /* WARNING */,
+        message: `${role} hit ${payload.kind} soft limit (${payload.used}/${payload.limit})`,
+        budgetKind: payload.kind,
+        elapsedMs: payload.timeoutMs,
+        limit: payload.limit,
+        btwNotes
+      };
+      this.alerts.push(alert);
+      this.fleetBus.emit({
+        subagentId: e.subagentId,
+        ts: Date.now(),
+        type: "collab.warning",
+        payload: alert
+      });
+      const decision = this.options.onBudgetWarning?.(alert) ?? "ignore";
+      if (decision === "cancel") {
+        this.cancel(`Director cancelled: ${role} ${payload.kind} threshold`);
+        return;
+      }
+      if (payload.kind === "timeout" || payload.kind === "idle_timeout") {
+        const progress = this.progressBySubagent.get(e.subagentId) ?? 0;
+        const lastProgress = this.lastTimeoutProgress.get(e.subagentId) ?? -1;
+        if (progress <= lastProgress) {
+          payload.deny();
+          return;
+        }
+        this.lastTimeoutProgress.set(e.subagentId, progress);
+        const newLimit = Math.min(Math.ceil((payload.timeoutMs ?? payload.limit) * 2), 24 * 60 * 6e4);
+        setImmediate(() => {
+          payload.extend({ timeoutMs: newLimit });
+        });
+        return;
+      }
+      if (decision === "extend") {
+        setImmediate(() => {
+          const base = Math.max(payload.limit, payload.used);
+          const extra = {};
+          switch (payload.kind) {
+            case "iterations":
+              extra.maxIterations = Math.min(Math.ceil(base * 1.5), 5e4);
+              break;
+            case "tool_calls":
+              extra.maxToolCalls = Math.min(Math.ceil(base * 1.5), 1e5);
+              break;
+            case "tokens":
+              extra.maxTokens = Math.min(Math.ceil(base * 1.5), 5e6);
+              break;
+            case "cost":
+              extra.maxCostUsd = Math.min(base * 1.5, 100);
+              break;
+          }
+          payload.extend(extra);
+        });
+        return;
+      }
+      if (payload.kind !== "timeout") {
+        setImmediate(() => {
+          const base = Math.max(payload.limit, payload.used);
+          const extra = {};
+          switch (payload.kind) {
+            case "iterations":
+              extra.maxIterations = Math.min(Math.ceil(base * 1.25), 5e4);
+              break;
+            case "tool_calls":
+              extra.maxToolCalls = Math.min(Math.ceil(base * 1.25), 1e5);
+              break;
+            case "tokens":
+              extra.maxTokens = Math.min(Math.ceil(base * 1.25), 5e6);
+              break;
+            case "cost":
+              extra.maxCostUsd = Math.min(base * 1.25, 100);
+              break;
+          }
+          payload.extend(extra);
+        });
+      }
+    });
+    this.disposers.push(dBudget);
+    const dCancel = this.fleetBus.filter("director.cancel_collab", (e) => {
+      const payload = e.payload;
+      if (payload.sessionId !== this.sessionId) return;
+      this.cancelled = true;
+      if (this._timeoutTimer) {
+        clearTimeout(this._timeoutTimer);
+        this._timeoutTimer = void 0;
+      }
+      this.fleetBus.emit({
+        subagentId: this.director.id,
+        ts: Date.now(),
+        type: "collab.cancelled",
+        payload: { sessionId: this.sessionId, reason: payload.reason }
+      });
+    });
+    this.disposers.push(dCancel);
+    const d1 = this.fleetBus.filter("bug.found", (e) => {
+      const payload = e.payload;
+      if (payload?.finding) {
+        this.bugs.set(payload.finding.id, payload.finding);
+        this.emit("bug.found", payload);
+      }
+    });
+    this.disposers.push(d1);
+    const d2 = this.fleetBus.filter("refactor.plan", (e) => {
+      const payload = e.payload;
+      if (payload?.plan) {
+        this.plans.set(payload.plan.id, payload.plan);
+        this.emit("refactor.plan", payload);
+      }
+    });
+    this.disposers.push(d2);
+    const d3 = this.fleetBus.filter("critic.evaluation", (e) => {
+      const payload = e.payload;
+      if (payload?.evaluation) {
+        this.evaluations.set(payload.evaluation.id, payload.evaluation);
+        this.emit("critic.evaluation", payload);
+      }
+    });
+    this.disposers.push(d3);
+  }
+  roleFromSubagentId(subagentId) {
+    for (const [role, id] of this.subagentIds) {
+      if (id === subagentId) return role;
+    }
+    const match = subagentId.match(/^(bug-hunter|refactor-planner|critic)/);
+    return match?.[1] ?? null;
+  }
+  assembleReport() {
+    const bugList = Array.from(this.bugs.values());
+    const planList = Array.from(this.plans.values());
+    const evalList = Array.from(this.evaluations.values());
+    let disposition = "completed";
+    if (this.cancelled) disposition = "cancelled";
+    const verdictOrder = {
+      approve: 0,
+      needs_revision: 1,
+      reject: 2
+    };
+    const overallVerdict = evalList.reduce(
+      (worst, eval_) => {
+        const w = verdictOrder[worst];
+        const c = verdictOrder[eval_.verdict];
+        return c > w ? eval_.verdict : worst;
+      },
+      "approve"
+    );
+    const summary = this.buildMarkdownSummary(bugList, planList, evalList, overallVerdict, disposition);
+    return {
+      sessionId: this.sessionId,
+      startedAt: this.snapshot.createdAt,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      targetPaths: this.options.targetPaths,
+      disposition,
+      bugs: bugList,
+      refactorPlans: planList,
+      evaluations: evalList,
+      alerts: [...this.alerts],
+      overallVerdict,
+      summary
+    };
+  }
+  buildMarkdownSummary(bugs, plans, evals, overallVerdict, disposition) {
+    const lines = [
+      `## Collaborative Debugging Report \u2014 ${this.sessionId}`,
+      "",
+      `**Target:** ${this.options.targetPaths.join(", ")}`,
+      `**Disposition:** ${disposition.toUpperCase()}`,
+      `**Overall Verdict:** **${overallVerdict.toUpperCase()}**`,
+      ""
+    ];
+    if (this.alerts.length > 0) {
+      lines.push("### Alerts", "");
+      for (const alert of this.alerts) {
+        lines.push(`- **[${alert.level.toUpperCase()}]** ${alert.role}: ${alert.message}`);
+      }
+      lines.push("");
+    }
+    if (bugs.length > 0) {
+      lines.push("### Bugs Found", "");
+      for (const b of bugs) {
+        lines.push(`- **[${b.severity.toUpperCase()}]** \`${b.location.file}:${b.location.line}\` \u2014 ${b.description}`);
+      }
+      lines.push("");
+    }
+    if (plans.length > 0) {
+      lines.push("### Refactor Plans", "");
+      for (const p of plans) {
+        lines.push(`- **Phase plan** (risk: ${p.riskScore}, ~${p.estimatedChangeCount} changes)`);
+        for (const phase of p.phases) {
+          lines.push(`  - Phase ${phase.number}: ${phase.title} [${phase.risk}]`);
+        }
+      }
+      lines.push("");
+    }
+    if (evals.length > 0) {
+      lines.push("### Critic Evaluations", "");
+      for (const e of evals) {
+        lines.push(`- [${e.subjectType}] score=${e.score}/10 \u2014 **${e.verdict.toUpperCase()}**`);
+        for (const c of e.concerns) {
+          if (c.severity === "blocking") lines.push(`  - ${c.description}`);
+        }
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  cleanup() {
+    for (const dispose of this.disposers) dispose();
+    this.disposers.length = 0;
+  }
+};
 
-Read the BugHunter report at: ${bugHunterReportPath}
-Read the RefactorPlanner report at: ${refactorPlanPath}
+// src/coordination/director-prompts.ts
+var DEFAULT_DIRECTOR_PREAMBLE = `You are the Director of a multi-agent fleet. You orchestrate worker
+subagents by spawning them, assigning tasks, awaiting completions, and
+rolling up their outputs into your next decision.
 
-For each bug and refactor plan, emit your evaluation using fleet_emit:
-{ "type": "critic.evaluation", "payload": { "evaluation": { "id": "<uuid>", "subjectType": "<bug_finding|refactor_plan>", "subjectId": "<id>", "score": <0-10>, "verdict": "<approve|needs_revision|reject>", "strengths": ["<strength>"], "weaknesses": ["<weakness>"], "concerns": [{ "description": "<concern>", "severity": "<blocking|advisory>" }] } } }
+Core fleet tools available to you:
+  - spawn_subagent       \u2014 create a worker with a chosen provider / model / role
+  - assign_task          \u2014 hand a piece of work to a specific subagent
+  - await_tasks          \u2014 block until named task ids complete (parallel-safe)
+  - ask_subagent         \u2014 synchronously query a running subagent via the bridge
+  - roll_up              \u2014 aggregate finished tasks into a markdown/json summary
+  - terminate_subagent   \u2014 abort a stuck worker (use sparingly)
+  - fleet_status         \u2014 snapshot of all subagents and pending tasks
+  - fleet_usage          \u2014 token + cost breakdown per subagent and total
 
-After all evaluations, write your markdown report to:
-${scratchpad}/critic-report-${this.sessionId}.md
+Working rules:
+  1. Decompose first. Before spawning, decide which sub-tasks are
+     independent and can run in parallel. Sequential work doesn't need a
+     subagent \u2014 do it yourself.
+  2. Match worker to job. Cheap/fast model for triage, capable model for
+     synthesis. Different providers per sibling is allowed and encouraged.
+  3. Always pair an assign with an await. Don't fire-and-forget; you owe
+     the user a single coherent answer at the end.
+  4. Roll up before deciding. After await_tasks resolves, call roll_up so
+     the results are folded back into your context in a compact form.
+  5. Budget is real. Check fleet_usage periodically. If a subagent is
+     thrashing, terminate it rather than letting cost climb silently.
+  6. Never claim a subagent's work as your own without verifying it. If a
+     result looks wrong, ask_subagent for clarification before passing it
+     to the user.
+  7. Wind down when satisfied. When the results are good enough, call
+     work_complete \u2014 no new subagents will spawn and queued tasks complete
+     as aborted. Running subagents finish naturally. Call terminate_subagent
+     only for ones you need to stop immediately.`;
+var DEFAULT_SUBAGENT_BASELINE = `You are a subagent operating under a Director. You were spawned to handle
+a specific slice of a larger plan \u2014 do that slice well and report back.
 
-Emit each evaluation immediately. Do not wait until you have read all reports.`;
+Bridge contract:
+  - You have a parent (the Director). You may call \`request\` on the
+    parent bridge to ask a clarifying question. Use this sparingly; the
+    parent is also working.
+  - You MAY NOT request the parent's system prompt, tool list, or other
+    subagents' context. Those are not yours to read.
+  - Your final task output is what the Director sees. Be concise,
+    structured, and self-contained \u2014 assume the Director will paste your
+    output into its own context.`;
+function composeDirectorPrompt(parts = {}) {
+  const sections = [];
+  const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
+  if (preamble && preamble.trim().length > 0) sections.push(preamble.trim());
+  if (parts.rosterSummary && parts.rosterSummary.trim().length > 0) {
+    sections.push(`Available roles you can spawn:
+${parts.rosterSummary.trim()}`);
   }
-  wireFleetBus() {
-    const dTool = this.fleetBus.filter("tool.executed", (e) => {
-      this.progressBySubagent.set(e.subagentId, (this.progressBySubagent.get(e.subagentId) ?? 0) + 1);
-    });
-    this.disposers.push(dTool);
-    const dBudget = this.fleetBus.filter("budget.threshold_reached", (e) => {
-      const payload = e.payload;
-      const role = this.roleFromSubagentId(e.subagentId);
-      if (!role) return;
-      const btwNotes = this.director.getLeaderBtwNotes();
-      const alert = {
-        sessionId: this.sessionId,
-        subagentId: e.subagentId,
-        role,
-        level: "warning" /* WARNING */,
-        message: `${role} hit ${payload.kind} soft limit (${payload.used}/${payload.limit})`,
-        budgetKind: payload.kind,
-        elapsedMs: payload.timeoutMs,
-        limit: payload.limit,
-        btwNotes
-      };
-      this.alerts.push(alert);
-      this.fleetBus.emit({
-        subagentId: e.subagentId,
-        ts: Date.now(),
-        type: "collab.warning",
-        payload: alert
-      });
-      const decision = this.options.onBudgetWarning?.(alert) ?? "ignore";
-      if (decision === "cancel") {
-        this.cancel(`Director cancelled: ${role} ${payload.kind} threshold`);
-        return;
+  if (parts.basePrompt && parts.basePrompt.trim().length > 0) {
+    sections.push(parts.basePrompt.trim());
+  }
+  return sections.join("\n\n");
+}
+function composeSubagentPrompt(parts = {}) {
+  const sections = [];
+  const baseline = parts.baseline ?? DEFAULT_SUBAGENT_BASELINE;
+  if (baseline && baseline.trim().length > 0) sections.push(baseline.trim());
+  if (parts.role && parts.role.trim().length > 0) {
+    sections.push(`Role:
+${parts.role.trim()}`);
+  }
+  if (parts.task && parts.task.trim().length > 0) {
+    sections.push(`Task:
+${parts.task.trim()}`);
+  }
+  if (parts.sharedScratchpad && parts.sharedScratchpad.trim().length > 0) {
+    sections.push(
+      `Shared notes:
+A scratchpad shared with the rest of the fleet is mounted at \`${parts.sharedScratchpad.trim()}\`.
+- Write your final findings as markdown files there (e.g. \`findings.md\`, \`security.md\`).
+- Before starting, list the directory and read any sibling files relevant to your task \u2014 they may already contain context you can build on.
+- Use stable filenames (one file per concern); overwrite instead of appending so the Director sees the latest state.`
+    );
+  }
+  if (parts.override && parts.override.trim().length > 0) {
+    sections.push(parts.override.trim());
+  }
+  return sections.join("\n\n");
+}
+function rosterSummaryFromConfigs(roster) {
+  const lines = [];
+  for (const [roleId, cfg] of Object.entries(roster)) {
+    const tag = cfg.provider && cfg.model ? ` (${cfg.provider}/${cfg.model})` : "";
+    const headline = cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").trim().slice(0, 80) : "";
+    const tail = headline ? ` \u2014 ${headline}` : "";
+    lines.push(`- ${roleId}: ${cfg.name}${tag}${tail}`);
+  }
+  return lines.join("\n");
+}
+function makeSpawnTool(director, roster) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      role: { type: "string", description: "Roster role id. When set, the spawn uses the matching config from the roster and ignores other fields." },
+      description: { type: "string", description: "Free-form task description. When `role` is not set, the director uses the smart dispatcher to route this to the best-matching catalog agent. Use this when you don't know the exact role name." },
+      name: { type: "string", description: "Display name for the subagent. Used as a fallback when description-based dispatch does not resolve a role." },
+      provider: { type: "string", description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the leader provider when omitted.' },
+      model: { type: "string", description: "Model id within the provider. Defaults to the leader model when omitted." },
+      systemPromptOverride: { type: "string", description: "Extra prompt text appended after the role-base prompt." },
+      maxIterations: { type: "number", minimum: 1 },
+      maxToolCalls: { type: "number", minimum: 1 },
+      maxCostUsd: { type: "number", minimum: 0 },
+      timeoutMs: { type: "number", minimum: 1, description: "Hard wall-clock cap in milliseconds. Defaults to none (idle timeout is the default reaper)." },
+      idleTimeoutMs: { type: "number", minimum: 1, description: "Idle timeout in ms: reap the subagent after this long with no activity. Resets on every iteration/tool call. Default is role/coordinator-specific." },
+      maxTokens: { type: "number", minimum: 1, description: "Maximum total tokens (input + output) the subagent may use." }
+    },
+    required: []
+  };
+  return {
+    name: "spawn_subagent",
+    description: "Create a new subagent under this director. Returns the subagent id.",
+    usageHint: "Pass `role` (matches the roster), `description` (smart dispatch to best agent), or `name` + `provider`/`model`. Returns `{ subagentId }`.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input ?? {};
+      const role = typeof i.role === "string" ? i.role : void 0;
+      const description = typeof i.description === "string" ? i.description : void 0;
+      let cfg;
+      if (role && roster) {
+        const base = roster[role];
+        if (!base) return { error: `unknown role "${role}". roster has: ${Object.keys(roster).join(", ")}` };
+        cfg = instantiateRosterConfig(role, base);
+      } else if (description && !role) {
+        const dispatchResult = await dispatchAgent(description, {
+          classifier: director.dispatchClassifier,
+          catalog: roster
+        });
+        const dispatchRole = dispatchResult.role;
+        if (roster?.[dispatchRole]) {
+          cfg = instantiateRosterConfig(dispatchRole, roster[dispatchRole]);
+        } else {
+          const def = dispatchResult.definition;
+          cfg = {
+            name: def.config.name ?? dispatchRole,
+            role: dispatchRole,
+            provider: def.config.provider,
+            model: def.config.model
+          };
+        }
+      }
+      cfg ??= { name: i.name ?? "subagent" };
+      if (typeof i.name === "string") cfg.name = i.name;
+      if (typeof i.provider === "string") cfg.provider = i.provider;
+      if (typeof i.model === "string") cfg.model = i.model;
+      if (typeof i.systemPromptOverride === "string") cfg.systemPromptOverride = i.systemPromptOverride;
+      if (typeof i.maxIterations === "number") cfg.maxIterations = i.maxIterations;
+      if (typeof i.maxToolCalls === "number") cfg.maxToolCalls = i.maxToolCalls;
+      if (typeof i.maxCostUsd === "number") cfg.maxCostUsd = i.maxCostUsd;
+      if (typeof i.timeoutMs === "number") cfg.timeoutMs = i.timeoutMs;
+      if (typeof i.idleTimeoutMs === "number") cfg.idleTimeoutMs = i.idleTimeoutMs;
+      if (typeof i.maxTokens === "number") cfg.maxTokens = i.maxTokens;
+      try {
+        const subagentId = await director.spawn(cfg);
+        return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name, role: cfg.role };
+      } catch (err) {
+        if (err instanceof FleetSpawnBudgetError) {
+          return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
+        }
+        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) };
+      }
+    }
+  };
+}
+function instantiateRosterConfig(role, base) {
+  return {
+    ...base,
+    // Roster entries are templates. A director may spawn several
+    // workers with the same role, so never reuse the template id.
+    id: `${role}-${randomUUID().slice(0, 8)}`
+  };
+}
+function makeAssignTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      subagentId: { type: "string", minLength: 1, description: "Target subagent id. Required." },
+      description: { type: "string", minLength: 1, description: "The task in natural language \u2014 what you want this subagent to do." },
+      maxToolCalls: { type: "number", minimum: 1, description: "Optional per-task tool-call budget override." },
+      timeoutMs: { type: "number", minimum: 1, description: "Optional per-task timeout in ms." }
+    },
+    required: ["subagentId", "description"]
+  };
+  return {
+    name: "assign_task",
+    description: "Hand a task to a previously spawned subagent. Returns the task id.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      const task = { id: randomUUID(), description: i.description, subagentId: i.subagentId, maxToolCalls: i.maxToolCalls, timeoutMs: i.timeoutMs };
+      const taskId = await director.assign(task);
+      return { taskId, subagentId: i.subagentId };
+    }
+  };
+}
+function makeAwaitTasksTool(director) {
+  return {
+    name: "await_tasks",
+    description: "Block until every named task completes. Returns the array of TaskResult.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: { taskIds: { type: "array", items: { type: "string" }, description: "One or more task ids returned by `assign_task`." } }, required: ["taskIds"] },
+    async execute(input) {
+      const i = input;
+      const results = await director.awaitTasks(i.taskIds);
+      return { results };
+    }
+  };
+}
+function makeAskTool(director) {
+  return {
+    name: "ask_subagent",
+    description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        subagentId: { type: "string", minLength: 1, description: "Subagent to ask. Must be a previously spawned id." },
+        question: { type: "string", minLength: 1, description: "The question or instruction." },
+        timeoutMs: { type: "number", minimum: 1, description: "Optional timeout in ms (default 30s)." }
+      },
+      required: ["subagentId", "question"]
+    },
+    async execute(input) {
+      const i = input;
+      try {
+        const answer = await director.ask(i.subagentId, { question: i.question }, i.timeoutMs);
+        const stored = director.largeAnswerStore.storeAnswer(answer);
+        if (stored.inline) {
+          return { ok: true, answer: stored.summary };
+        }
+        return {
+          ok: true,
+          answer: stored.summary,
+          _answerKey: stored.key,
+          _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) };
       }
-      if (payload.kind === "timeout" || payload.kind === "idle_timeout") {
-        const progress = this.progressBySubagent.get(e.subagentId) ?? 0;
-        const lastProgress = this.lastTimeoutProgress.get(e.subagentId) ?? -1;
-        if (progress <= lastProgress) {
-          payload.deny();
-          return;
+    }
+  };
+}
+function makeAskResultTool(director) {
+  return {
+    name: "ask_result",
+    description: "Retrieve a large `ask_subagent` response that was stored out-of-context (>2K chars). Returns the full stored value.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          minLength: 1,
+          description: "The `_answerKey` returned by `ask_subagent` for a large response."
         }
-        this.lastTimeoutProgress.set(e.subagentId, progress);
-        const newLimit = Math.min(Math.ceil((payload.timeoutMs ?? payload.limit) * 2), 24 * 60 * 6e4);
-        setImmediate(() => {
-          payload.extend({ timeoutMs: newLimit });
-        });
-        return;
+      },
+      required: ["key"]
+    },
+    async execute(input) {
+      const i = input;
+      const value = director.largeAnswerStore.retrieveAnswer(i.key);
+      if (value === void 0) {
+        return { ok: false, error: `No stored answer found for key "${i.key}" \u2014 it may have been cleared or the key is invalid.` };
       }
-      if (decision === "extend") {
-        setImmediate(() => {
-          const base = Math.max(payload.limit, payload.used);
-          const extra = {};
-          switch (payload.kind) {
-            case "iterations":
-              extra.maxIterations = Math.min(Math.ceil(base * 1.5), 5e4);
-              break;
-            case "tool_calls":
-              extra.maxToolCalls = Math.min(Math.ceil(base * 1.5), 1e5);
-              break;
-            case "tokens":
-              extra.maxTokens = Math.min(Math.ceil(base * 1.5), 5e6);
-              break;
-            case "cost":
-              extra.maxCostUsd = Math.min(base * 1.5, 100);
-              break;
-          }
-          payload.extend(extra);
-        });
-        return;
+      return { ok: true, value };
+    }
+  };
+}
+function makeRollUpTool(director) {
+  return {
+    name: "roll_up",
+    description: "Aggregate completed task results into a single formatted summary.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskIds: { type: "array", items: { type: "string" }, description: "Completed task ids to aggregate." },
+        style: { type: "string", enum: ["markdown", "json"], description: "Output flavor \u2014 markdown (default) or json." }
+      },
+      required: ["taskIds"]
+    },
+    async execute(input) {
+      const i = input;
+      const summary = director.rollUp(i.taskIds, i.style ?? "markdown");
+      return { summary, count: i.taskIds.length };
+    }
+  };
+}
+function makeTerminateTool(director) {
+  return {
+    name: "terminate_subagent",
+    description: 'Forcibly abort a subagent. The subagent finishes its current iteration then exits with status "stopped".',
+    permission: "auto",
+    mutating: true,
+    inputSchema: { type: "object", properties: { subagentId: { type: "string", description: "Subagent to abort." } }, required: ["subagentId"] },
+    async execute(input) {
+      const i = input;
+      await director.terminate(i.subagentId);
+      return { ok: true };
+    }
+  };
+}
+function makeTerminateAllTool(director) {
+  return {
+    name: "terminate_all",
+    description: 'Forcibly stop every subagent in the fleet and drain the pending task queue. In-flight tasks are terminated mid-execution; pending tasks receive "aborted_by_parent" completion immediately. Use this when the fleet is wedged, looping, or you need a clean slate. Compare: work_complete stops spawning but lets running agents finish naturally.',
+    permission: "auto",
+    mutating: true,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      await director.terminateAll();
+      return { ok: true, message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.` };
+    }
+  };
+}
+function makeFleetStatusTool(director) {
+  return {
+    name: "fleet_status",
+    description: "Snapshot of the fleet \u2014 every subagent's current status, coordinator counts (total/running/idle/stopped), pending task descriptions, and usage rollup.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      const base = director.status();
+      const fm = director.fleetManager;
+      const stats = fm?.getFleetStats();
+      const fleetStatus = fm?.getFleetStatus();
+      return {
+        subagents: base.subagents,
+        coordinatorStats: stats ? { total: stats.total, running: stats.running, idle: stats.idle, stopped: stats.stopped } : void 0,
+        pending: fleetStatus?.pending ?? [],
+        usage: fm?.snapshot()
+      };
+    }
+  };
+}
+function makeFleetUsageTool(director) {
+  return {
+    name: "fleet_usage",
+    description: "Token + cost breakdown across the fleet, per-subagent and totals.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      return director.snapshot();
+    }
+  };
+}
+function makeFleetSessionTool(director) {
+  return {
+    name: "fleet_session",
+    description: "Read a subagent's JSONL transcript and extract its last assistant text, stop reason, and tool-use count. Use this to see what a running or timed-out subagent actually produced.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        subagentId: { type: "string", description: "Subagent id to read the transcript of." },
+        tail: { type: "number", description: "Number of trailing JSONL lines to return. Omit for the full transcript." }
+      },
+      required: ["subagentId"]
+    },
+    async execute(input) {
+      const i = input;
+      const result = await director.readSession(i.subagentId, i.tail);
+      if (!result) {
+        return {
+          error: `fleet_session: transcript unavailable for "${i.subagentId}". Is sessionsRoot configured?`
+        };
       }
-      if (payload.kind !== "timeout") {
-        setImmediate(() => {
-          const base = Math.max(payload.limit, payload.used);
-          const extra = {};
-          switch (payload.kind) {
-            case "iterations":
-              extra.maxIterations = Math.min(Math.ceil(base * 1.25), 5e4);
-              break;
-            case "tool_calls":
-              extra.maxToolCalls = Math.min(Math.ceil(base * 1.25), 1e5);
-              break;
-            case "tokens":
-              extra.maxTokens = Math.min(Math.ceil(base * 1.25), 5e6);
-              break;
-            case "cost":
-              extra.maxCostUsd = Math.min(base * 1.25, 100);
-              break;
-          }
-          payload.extend(extra);
-        });
+      return result;
+    }
+  };
+}
+function makeFleetHealthTool(director) {
+  return {
+    name: "fleet_health",
+    description: "Per-subagent health report: budget pressure (pct of limits consumed), last activity timestamp, and current status. Use to decide whether to assign more work to a subagent or spawn a fresh one.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      const status = director.status();
+      const snapshot = director.snapshot();
+      const subagents = status.subagents ?? [];
+      const perSubagent = snapshot.perSubagent ?? {};
+      return {
+        subagents: subagents.map((s) => {
+          const usage = perSubagent[s.id];
+          return {
+            id: s.id,
+            status: s.status,
+            lastEventAt: usage?.lastEventAt,
+            budgetPressure: {
+              iterations: usage?.iterations,
+              toolCalls: usage?.toolCalls,
+              costUsd: usage?.cost
+            }
+          };
+        })
+      };
+    }
+  };
+}
+function makeCollabDebugTool(director) {
+  return {
+    name: "collab_debug",
+    description: "Start a collaborative debugging session: BugHunter, RefactorPlanner, and Critic run in parallel on the same target files. BugHunter finds bugs and emits bug.found events. RefactorPlanner listens for bug.found and emits refactor.plan events. Critic evaluates both and emits critic.evaluation events. Returns a structured report with overall verdict (approve / needs_revision / reject).",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        targetPaths: {
+          type: "array",
+          items: { type: "string" },
+          description: "File paths / glob patterns to scan for bugs."
+        },
+        timeoutMs: {
+          type: "number",
+          minimum: 1,
+          description: "Timeout in ms. Default: 600000 (10 minutes)."
+        },
+        maxTargetFiles: {
+          type: "number",
+          minimum: 1,
+          description: "Maximum number of files to include in the snapshot. If not set, the limit is computed dynamically from contextWindow or falls back to the default (30)."
+        },
+        contextWindow: {
+          type: "number",
+          minimum: 1,
+          description: "Context window size (tokens) of the model. When provided and maxTargetFiles is not set, the file limit is computed dynamically as floor((contextWindow * 0.4) / 2000)."
+        }
+      },
+      required: ["targetPaths"]
+    },
+    async execute(input) {
+      const i = input;
+      if (!i.targetPaths?.length) {
+        return { error: "collab_debug: targetPaths is required and must be non-empty." };
       }
-    });
-    this.disposers.push(dBudget);
-    const dCancel = this.fleetBus.filter("director.cancel_collab", (e) => {
-      const payload = e.payload;
-      if (payload.sessionId !== this.sessionId) return;
-      this.cancelled = true;
-      if (this._timeoutTimer) {
-        clearTimeout(this._timeoutTimer);
-        this._timeoutTimer = void 0;
+      const options = {
+        targetPaths: i.targetPaths,
+        timeoutMs: i.timeoutMs,
+        maxTargetFiles: i.maxTargetFiles,
+        contextWindow: i.contextWindow
+      };
+      try {
+        const report = await director.spawnCollab(options);
+        return {
+          sessionId: report.sessionId,
+          overallVerdict: report.overallVerdict,
+          bugCount: report.bugs.length,
+          planCount: report.refactorPlans.length,
+          evaluationCount: report.evaluations.length,
+          summary: report.summary,
+          bugs: report.bugs,
+          refactorPlans: report.refactorPlans,
+          evaluations: report.evaluations
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { error: "collab_debug failed: " + msg };
       }
-      this.fleetBus.emit({
-        subagentId: this.director.id,
+    }
+  };
+}
+function makeFleetEmitTool(director) {
+  return {
+    name: "fleet_emit",
+    description: "Emit a structured event on the FleetBus. Any subagent can emit any event type; the Director routes it to all listeners. Use it to stream findings, progress updates, or final results to other agents in real time.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          description: "Event type string (e.g. bug.found, refactor.plan, critic.evaluation, progress, result)."
+        },
+        payload: {
+          type: "object",
+          description: "Event payload. Structure depends on event type. Use null if no payload."
+        }
+      },
+      required: ["type"]
+    },
+    async execute(input) {
+      const i = input;
+      director.fleet.emit({
+        subagentId: director.id,
         ts: Date.now(),
-        type: "collab.cancelled",
-        payload: { sessionId: this.sessionId, reason: payload.reason }
+        type: i.type,
+        payload: i.payload ?? {}
       });
+      return { ok: true, event: i.type };
+    }
+  };
+}
+function makeWorkCompleteTool(director) {
+  return {
+    name: "work_complete",
+    description: "Signal that the director is satisfied with the results and the fleet should wind down. After calling this, spawn_subagent will refuse with a budget error and assign_task will instantly complete any queued tasks as aborted. Running subagents finish naturally. Call terminate_subagent separately to stop specific subagents immediately.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      director.workComplete();
+      return { ok: true, message: "Fleet wind-down signaled. No new spawns or task dispatches." };
+    }
+  };
+}
+
+// src/coordination/fleet-bus.ts
+var FleetBus = class {
+  byId = /* @__PURE__ */ new Map();
+  byType = /* @__PURE__ */ new Map();
+  any = /* @__PURE__ */ new Set();
+  /**
+   * Hook a subagent's EventBus into the fleet. Uses `onAny()` (an alias for
+   * `onPattern('*')`) to forward all events with subagent attribution, so
+   * new kernel event types are automatically forwarded without any manual
+   * registration. `subagent.*` events are excluded because they originate
+   * from MultiAgentHost on the parent bus, not the subagent's own bus.
+   *
+   * Returns a disposer that detaches every subscription; call on
+   * subagent teardown so the listeners don't outlive the run.
+   */
+  attach(subagentId, bus, taskId) {
+    const off = bus.onAny((type, payload) => {
+      if (type.startsWith("subagent.")) return;
+      this.emit({ subagentId, taskId, ts: Date.now(), type, payload });
     });
-    this.disposers.push(dCancel);
-    const d1 = this.fleetBus.filter("bug.found", (e) => {
-      const payload = e.payload;
-      if (payload?.finding) {
-        this.bugs.set(payload.finding.id, payload.finding);
-        this.emit("bug.found", payload);
+    return () => {
+      off();
+    };
+  }
+  /** Subscribe to every event from one subagent. */
+  subscribe(subagentId, handler) {
+    let set = this.byId.get(subagentId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byId.set(subagentId, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  /** Subscribe to one event type across all subagents. */
+  filter(type, handler) {
+    let set = this.byType.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byType.set(type, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  /** Subscribe to literally everything. The fleet roll-up uses this. */
+  onAny(handler) {
+    this.any.add(handler);
+    return () => {
+      this.any.delete(handler);
+    };
+  }
+  emit(event) {
+    const byId = this.byId.get(event.subagentId);
+    if (byId)
+      for (const h of byId) {
+        try {
+          h(event);
+        } catch {
+        }
       }
-    });
-    this.disposers.push(d1);
-    const d2 = this.fleetBus.filter("refactor.plan", (e) => {
-      const payload = e.payload;
-      if (payload?.plan) {
-        this.plans.set(payload.plan.id, payload.plan);
-        this.emit("refactor.plan", payload);
+    const byType = this.byType.get(event.type);
+    if (byType)
+      for (const h of byType) {
+        try {
+          h(event);
+        } catch {
+        }
       }
-    });
-    this.disposers.push(d2);
-    const d3 = this.fleetBus.filter("critic.evaluation", (e) => {
-      const payload = e.payload;
-      if (payload?.evaluation) {
-        this.evaluations.set(payload.evaluation.id, payload.evaluation);
-        this.emit("critic.evaluation", payload);
+    for (const h of this.any) {
+      try {
+        h(event);
+      } catch {
       }
-    });
-    this.disposers.push(d3);
-  }
-  roleFromSubagentId(subagentId) {
-    for (const [role, id] of this.subagentIds) {
-      if (id === subagentId) return role;
     }
-    const match = subagentId.match(/^(bug-hunter|refactor-planner|critic)/);
-    return match?.[1] ?? null;
   }
-  assembleReport() {
-    const bugList = Array.from(this.bugs.values());
-    const planList = Array.from(this.plans.values());
-    const evalList = Array.from(this.evaluations.values());
-    let disposition = "completed";
-    if (this.cancelled) disposition = "cancelled";
-    const verdictOrder = {
-      approve: 0,
-      needs_revision: 1,
-      reject: 2
-    };
-    const overallVerdict = evalList.reduce(
-      (worst, eval_) => {
-        const w = verdictOrder[worst];
-        const c = verdictOrder[eval_.verdict];
-        return c > w ? eval_.verdict : worst;
-      },
-      "approve"
-    );
-    const summary = this.buildMarkdownSummary(bugList, planList, evalList, overallVerdict, disposition);
+};
+var FleetUsageAggregator = class {
+  constructor(bus, priceLookup, metaLookup) {
+    this.priceLookup = priceLookup;
+    this.metaLookup = metaLookup;
+    this.unsub.push(bus.filter("provider.response", (e) => this.onProviderResponse(e)));
+    this.unsub.push(bus.filter("tool.executed", (e) => this.onToolExecuted(e)));
+    this.unsub.push(bus.filter("iteration.started", (e) => this.onIterationStarted(e)));
+  }
+  priceLookup;
+  metaLookup;
+  perSubagent = /* @__PURE__ */ new Map();
+  total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  unsub = new Array();
+  /**
+   * Remove a terminated subagent's data from the aggregator and subtract its
+   * contribution from the running totals. Call this when a subagent is removed
+   * from the fleet so the aggregator doesn't accumulate unbounded data for
+   * entities that will never emit events again.
+   */
+  removeSubagent(subagentId) {
+    const snap = this.perSubagent.get(subagentId);
+    if (!snap) return;
+    this.perSubagent.delete(subagentId);
+    this.total.input -= snap.input;
+    this.total.output -= snap.output;
+    this.total.cacheRead -= snap.cacheRead;
+    this.total.cacheWrite -= snap.cacheWrite;
+    this.total.cost -= snap.cost;
+  }
+  /** Disposes all fleet-bus subscriptions. Call when the aggregator is no longer needed. */
+  dispose() {
+    for (const off of this.unsub) off();
+    this.unsub.length = 0;
+  }
+  /** Live snapshot — safe to call from a tool's execute() body. */
+  snapshot() {
     return {
-      sessionId: this.sessionId,
-      startedAt: this.snapshot.createdAt,
-      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      targetPaths: this.options.targetPaths,
-      disposition,
-      bugs: bugList,
-      refactorPlans: planList,
-      evaluations: evalList,
-      alerts: [...this.alerts],
-      overallVerdict,
-      summary
+      total: { ...this.total },
+      perSubagent: Object.fromEntries(
+        Array.from(this.perSubagent.entries()).map(([k, v]) => [k, { ...v }])
+      )
     };
   }
-  buildMarkdownSummary(bugs, plans, evals, overallVerdict, disposition) {
-    const lines = [
-      `## Collaborative Debugging Report \u2014 ${this.sessionId}`,
-      "",
-      `**Target:** ${this.options.targetPaths.join(", ")}`,
-      `**Disposition:** ${disposition.toUpperCase()}`,
-      `**Overall Verdict:** **${overallVerdict.toUpperCase()}**`,
-      ""
-    ];
-    if (this.alerts.length > 0) {
-      lines.push("### Alerts", "");
-      for (const alert of this.alerts) {
-        lines.push(`- **[${alert.level.toUpperCase()}]** ${alert.role}: ${alert.message}`);
-      }
-      lines.push("");
+  ensure(subagentId) {
+    let snap = this.perSubagent.get(subagentId);
+    if (!snap) {
+      const meta = this.metaLookup?.(subagentId);
+      snap = {
+        subagentId,
+        provider: meta?.provider,
+        model: meta?.model,
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: 0,
+        toolCalls: 0,
+        iterations: 0,
+        startedAt: Date.now(),
+        lastEventAt: Date.now()
+      };
+      this.perSubagent.set(subagentId, snap);
     }
-    if (bugs.length > 0) {
-      lines.push("### Bugs Found", "");
-      for (const b of bugs) {
-        lines.push(`- **[${b.severity.toUpperCase()}]** \`${b.location.file}:${b.location.line}\` \u2014 ${b.description}`);
-      }
-      lines.push("");
+    return snap;
+  }
+  onProviderResponse(e) {
+    const snap = this.ensure(e.subagentId);
+    const p = e.payload;
+    const usage = p?.usage;
+    if (!usage) return;
+    snap.input += usage.input ?? 0;
+    snap.output += usage.output ?? 0;
+    snap.cacheRead += usage.cacheRead ?? 0;
+    snap.cacheWrite += usage.cacheWrite ?? 0;
+    this.total.input += usage.input ?? 0;
+    this.total.output += usage.output ?? 0;
+    this.total.cacheRead += usage.cacheRead ?? 0;
+    this.total.cacheWrite += usage.cacheWrite ?? 0;
+    const price = this.priceLookup?.(e.subagentId, snap.provider, snap.model);
+    if (price) {
+      const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
+      snap.cost += delta;
+      this.total.cost += delta;
     }
-    if (plans.length > 0) {
-      lines.push("### Refactor Plans", "");
-      for (const p of plans) {
-        lines.push(`- **Phase plan** (risk: ${p.riskScore}, ~${p.estimatedChangeCount} changes)`);
-        for (const phase of p.phases) {
-          lines.push(`  - Phase ${phase.number}: ${phase.title} [${phase.risk}]`);
-        }
-      }
-      lines.push("");
+    snap.lastEventAt = e.ts;
+  }
+  onToolExecuted(e) {
+    const snap = this.ensure(e.subagentId);
+    snap.toolCalls += 1;
+    snap.lastEventAt = e.ts;
+  }
+  onIterationStarted(e) {
+    const snap = this.ensure(e.subagentId);
+    snap.iterations += 1;
+    snap.lastEventAt = e.ts;
+  }
+};
+
+// src/coordination/large-answer-store.ts
+var LargeAnswerStore = class {
+  /**
+   * Responses above this size (in characters) are stored out-of-context.
+   * Below this, the full answer is returned inline (no overhead).
+   * Default: 2000 chars ≈ 400-600 tokens.
+   */
+  sizeThreshold;
+  store = /* @__PURE__ */ new Map();
+  constructor(sizeThreshold = 2e3) {
+    this.sizeThreshold = sizeThreshold;
+  }
+  /**
+   * Store a value, returning a summary + key for inline use.
+   * If the value is below sizeThreshold, returns it as-is (no store entry).
+   */
+  storeAnswer(value) {
+    if (value === void 0 || value === null) {
+      return { summary: String(value), inline: true };
     }
-    if (evals.length > 0) {
-      lines.push("### Critic Evaluations", "");
-      for (const e of evals) {
-        lines.push(`- [${e.subjectType}] score=${e.score}/10 \u2014 **${e.verdict.toUpperCase()}**`);
-        for (const c of e.concerns) {
-          if (c.severity === "blocking") lines.push(`  - ${c.description}`);
-        }
-      }
-      lines.push("");
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    const size = serialized.length;
+    if (size <= this.sizeThreshold) {
+      return { summary: serialized.slice(0, 500), inline: true };
     }
-    return lines.join("\n");
+    const key = `a-${hashStr(serialized)}`;
+    this.store.set(key, {
+      key,
+      value,
+      size,
+      storedAt: Date.now()
+    });
+    return {
+      key,
+      summary: `[stored: ${size} chars \u2014 use roll_up or ask_result tool to retrieve, key=${key}]`,
+      inline: false
+    };
   }
-  cleanup() {
-    for (const dispose of this.disposers) dispose();
-    this.disposers.length = 0;
+  /**
+   * Retrieve a previously stored answer by its key.
+   * Returns undefined if the key is unknown or the store was cleared.
+   */
+  retrieveAnswer(key) {
+    return this.store.get(key)?.value;
+  }
+  /**
+   * Check if a key exists in the store.
+   */
+  hasAnswer(key) {
+    return this.store.has(key);
+  }
+  /** Number of stored entries. */
+  get size() {
+    return this.store.size;
+  }
+  /** Total characters stored. */
+  get totalChars() {
+    let total = 0;
+    for (const e of this.store.values()) total += e.size;
+    return total;
+  }
+  /** Clear all stored entries. Call at the end of a director run. */
+  clear() {
+    this.store.clear();
   }
 };
+function hashStr(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) {
+    h = h * 33 ^ s.charCodeAt(i);
+  }
+  return (h >>> 0).toString(36);
+}
+var ROLE_TO_PHASE = (() => {
+  const map = {};
+  for (const [phase, defs] of Object.entries(AGENTS_BY_PHASE)) {
+    for (const def of defs) {
+      const role = def.config.role;
+      if (role) map[role] = phase;
+    }
+  }
+  return map;
+})();
+function phaseForRole(role) {
+  return role ? ROLE_TO_PHASE[role] : void 0;
+}
+function resolveModelMatrix(matrix, role) {
+  if (!matrix) return void 0;
+  if (role && matrix[role]) return matrix[role];
+  const phase = phaseForRole(role);
+  if (phase && matrix[phase]) return matrix[phase];
+  if (matrix["*"]) return matrix["*"];
+  return void 0;
+}
 
 // src/coordination/director.ts
 var FleetSpawnBudgetError = class extends Error {
@@ -12854,6 +12920,12 @@ var Director = class _Director {
   getLeaderContextPressure() {
     return this.leaderContextPressure;
   }
+  resolveMaxContext() {
+    const resolved = typeof this.maxContext === "function" ? this.maxContext() : this.maxContext;
+    return resolved && resolved > 0 ? resolved : 128e3;
+  }
+  /** Optional Brain arbiter for director-level policy decisions. */
+  brain;
   /**
    * Optional fleet-level policy container. When provided the Director
    * delegates spawn budgeting, manifest entries, and checkpointing to it
@@ -12945,8 +13017,11 @@ var Director = class _Director {
   leaderContextPressure = 0;
   /** Maximum context load fraction before spawn is refused. */
   maxLeaderContextLoad;
-  /** Provider's max context window in tokens. */
+  /** Provider's max context window in tokens, or a live resolver for runtime model switches. */
   maxContext;
+  /** Per-task model matrix (static record or live getter); resolved
+   *  per-spawn when no explicit model is set. */
+  modelMatrix;
   /**
    * When set by `workComplete()`, the director stops dispatching new tasks
    * and terminates all running subagents. Used when the director's LLM decides
@@ -12962,6 +13037,7 @@ var Director = class _Director {
   largeAnswerStore;
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID();
+    this.brain = opts.brain;
     this.manifestPath = opts.manifestPath;
     this.roster = opts.roster;
     this.directorPreamble = opts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
@@ -12977,20 +13053,23 @@ var Director = class _Director {
     this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
     this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
     this.maxContext = opts.maxContext ?? 128e3;
+    this.modelMatrix = opts.modelMatrix;
     this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? this.id;
-    this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
-      directorRunId: this.id,
-      maxSpawns: opts.maxSpawns,
-      spawnDepth: this.spawnDepth,
-      maxSpawnDepth: this.maxSpawnDepth,
-      directorBudget: opts.directorBudget
-    }, opts.checkpointDebounceMs ?? 250) : null;
+    this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(
+      opts.stateCheckpointPath,
+      {
+        directorRunId: this.id,
+        maxSpawns: opts.maxSpawns,
+        spawnDepth: this.spawnDepth,
+        maxSpawnDepth: this.maxSpawnDepth,
+        directorBudget: opts.directorBudget
+      },
+      opts.checkpointDebounceMs ?? 250
+    ) : null;
     this.fleetManager = opts.fleetManager;
     if (this.sharedScratchpadPath) {
-      void fsp.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(
-        (err) => this.logShutdownError("shared_scratchpad_mkdir", err)
-      );
+      void fsp.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
     }
     this.transport = new InMemoryBridgeTransport();
     this.bridge = new InMemoryAgentBridge(
@@ -13103,33 +13182,81 @@ var Director = class _Director {
           return;
         }
       }
-      extendCounts.set(guardKey, prior + 1);
-      setImmediate(() => {
-        const extra = {};
-        const base = Math.max(payload.limit, payload.used);
-        const grow = (ceiling) => Math.min(Math.ceil(base * 1.5), ceiling);
-        let newLimit = base;
-        switch (payload.kind) {
-          case "iterations":
-            newLimit = grow(5e4);
-            extra.maxIterations = newLimit;
-            break;
-          case "tool_calls":
-            newLimit = grow(1e5);
-            extra.maxToolCalls = newLimit;
-            break;
-          case "tokens":
-            newLimit = grow(5e6);
-            extra.maxTokens = newLimit;
-            break;
-          case "cost":
-            newLimit = Math.min(base * 1.5, 100);
-            extra.maxCostUsd = newLimit;
-            break;
-        }
-        this.recordExtension(e.subagentId, e.taskId, payload.kind, newLimit);
-        payload.extend(extra);
-      });
+      const grantExtension = () => {
+        setImmediate(() => {
+          const extra = {};
+          const base = Math.max(payload.limit, payload.used);
+          const grow = (ceiling) => Math.min(Math.ceil(base * 1.5), ceiling);
+          let newLimit = base;
+          switch (payload.kind) {
+            case "iterations":
+              newLimit = grow(5e4);
+              extra.maxIterations = newLimit;
+              break;
+            case "tool_calls":
+              newLimit = grow(1e5);
+              extra.maxToolCalls = newLimit;
+              break;
+            case "tokens":
+              newLimit = grow(5e6);
+              extra.maxTokens = newLimit;
+              break;
+            case "cost":
+              newLimit = Math.min(base * 1.5, 100);
+              extra.maxCostUsd = newLimit;
+              break;
+          }
+          extendCounts.set(guardKey, prior + 1);
+          this.recordExtension(e.subagentId, e.taskId, payload.kind, newLimit);
+          payload.extend(extra);
+        });
+      };
+      if (this.brain) {
+        void this.brain.decide({
+          id: `director-budget-${e.subagentId}-${payload.kind}`,
+          source: "director",
+          question: `Should the director extend the ${payload.kind} budget for subagent ${e.subagentId}?`,
+          context: [
+            e.taskId ? `Task id: ${e.taskId}` : void 0,
+            `Used: ${payload.used}`,
+            `Limit: ${payload.limit}`,
+            `Prior extensions for this kind: ${prior}`
+          ].filter(Boolean).join("\n"),
+          risk: payload.kind === "cost" ? "high" : "medium",
+          fallback: "continue",
+          options: [
+            {
+              id: "extend",
+              label: "Grant the director default budget extension",
+              consequence: "The subagent continues with a larger per-kind budget.",
+              risk: payload.kind === "cost" ? "high" : "medium",
+              recommended: true
+            },
+            {
+              id: "stop",
+              label: "Stop this subagent at the current budget limit",
+              consequence: "The current task will fail or stop due to budget pressure.",
+              risk: "low"
+            }
+          ]
+        }).then((decision) => {
+          if (decision.type === "deny") {
+            payload.deny();
+            return;
+          }
+          if (decision.type === "ask_human") {
+            payload.deny();
+            return;
+          }
+          if (decision.optionId === "stop" || /\bstop\b/i.test(decision.text)) {
+            payload.deny();
+            return;
+          }
+          grantExtension();
+        }).catch(() => payload.deny());
+        return;
+      }
+      grantExtension();
     });
     this.largeAnswerStore = new LargeAnswerStore(2e3);
   }
@@ -13168,7 +13295,12 @@ var Director = class _Director {
    */
   workComplete() {
     this.workCompleteFlag = true;
-    this.fleet.emit({ subagentId: this.id, ts: Date.now(), type: "director.work_complete", payload: {} });
+    this.fleet.emit({
+      subagentId: this.id,
+      ts: Date.now(),
+      type: "director.work_complete",
+      payload: {}
+    });
   }
   /** Returns true if `workComplete()` has been called on this director. */
   isWorkComplete() {
@@ -13300,13 +13432,25 @@ var Director = class _Director {
         "workComplete() has been called \u2014 director closed further spawning"
       );
     }
+    if (!config.model && this.modelMatrix) {
+      const matrix = typeof this.modelMatrix === "function" ? this.modelMatrix() : this.modelMatrix;
+      const entry = resolveModelMatrix(matrix, config.role);
+      if (entry) {
+        config.model = entry.model;
+        if (entry.provider) config.provider = entry.provider;
+      }
+    }
     if (this.fleetManager) {
       const rejection = this.fleetManager.canSpawn(config);
       if (rejection) {
-        if (rejection.kind === "max_spawn_depth") throw new FleetSpawnBudgetError("max_spawn_depth", rejection.limit, rejection.observed);
-        if (rejection.kind === "max_spawns") throw new FleetSpawnBudgetError("max_spawns", rejection.limit, rejection.observed);
-        if (rejection.kind === "max_cost_usd") throw new FleetCostCapError(rejection.limit, rejection.observed);
-        if (rejection.kind === "max_context_load") throw new FleetContextOverflowError(rejection.limit, rejection.observed);
+        if (rejection.kind === "max_spawn_depth")
+          throw new FleetSpawnBudgetError("max_spawn_depth", rejection.limit, rejection.observed);
+        if (rejection.kind === "max_spawns")
+          throw new FleetSpawnBudgetError("max_spawns", rejection.limit, rejection.observed);
+        if (rejection.kind === "max_cost_usd")
+          throw new FleetCostCapError(rejection.limit, rejection.observed);
+        if (rejection.kind === "max_context_load")
+          throw new FleetContextOverflowError(rejection.limit, rejection.observed);
       }
     } else {
       if (this.spawnDepth >= this.maxSpawnDepth) {
@@ -13322,7 +13466,8 @@ var Director = class _Director {
         }
       }
       if (this.maxLeaderContextLoad < 1) {
-        const threshold = this.maxContext * this.maxLeaderContextLoad;
+        const maxContext = this.resolveMaxContext();
+        const threshold = maxContext * this.maxLeaderContextLoad;
         if (this.leaderContextPressure >= threshold) {
           throw new FleetContextOverflowError(threshold, this.leaderContextPressure);
         }
@@ -13336,7 +13481,9 @@ var Director = class _Director {
         this.fleetManager.assignNicknameAndRecord(config);
       } else {
         config.name = assignNickname(role, this._usedNicknames);
-        this._usedNicknames.add(config.name.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-"));
+        this._usedNicknames.add(
+          config.name.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-")
+        );
       }
     }
     result = await this.coordinator.spawn(config);
@@ -13571,7 +13718,11 @@ var Director = class _Director {
         subagentId: taskWithId.subagentId ?? "unassigned",
         taskId: taskWithId.id,
         status: "stopped",
-        error: { kind: "aborted_by_parent", message: "Director called workComplete() \u2014 no further tasks will run", retryable: false },
+        error: {
+          kind: "aborted_by_parent",
+          message: "Director called workComplete() \u2014 no further tasks will run",
+          retryable: false
+        },
         iterations: 0,
         toolCalls: 0,
         durationMs: 0
@@ -14497,12 +14648,12 @@ var DefaultModelsRegistry = class {
    */
   async loadOverlay(opts = {}) {
     if (this.overlayPayload && !opts.force) return this.overlayPayload;
-    if (this.overlay) {
+    if (hasEntries(this.overlay)) {
       this.overlayPayload = this.overlay;
       return this.overlayPayload;
     }
     const fetched = await this.loadOverlayFromUrl(opts);
-    if (fetched) {
+    if (hasEntries(fetched)) {
       this.overlayPayload = fetched;
       return fetched;
     }
@@ -14629,6 +14780,9 @@ var DefaultModelsRegistry = class {
     return path15.resolve(this.cacheFile);
   }
 };
+function hasEntries(payload) {
+  return payload !== void 0 && Object.keys(payload).length > 0;
+}
 
 // src/models/mode-store.ts
 init_atomic_write();