@wrongstack/core 0.32.0 → 0.41.0

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)}
@@ -11200,84 +11214,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,280 +11363,746 @@ 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);
-    }
-    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);
+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 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 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 {
-          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);
+  /**
+   * 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;
     }
-    return snap;
+    if (this.options.contextWindow !== void 0) {
+      return Math.max(5, Math.floor(this.options.contextWindow * 0.4 / 2e3));
+    }
+    return DEFAULT_MAX_TARGET_FILES;
   }
-  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;
+  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);
     }
-    snap.lastEventAt = e.ts;
+    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;
   }
-  onToolExecuted(e) {
-    const snap = this.ensure(e.subagentId);
-    snap.toolCalls += 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 }
+    });
+  }
+  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];
+    }
+    const defaults = {
+      "bug-hunter": { maxIterations: 2e3, maxToolCalls: 5e3, timeoutMs: 10 * 60 * 1e3 },
+      "refactor-planner": { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 },
+      "critic": { maxIterations: 1e3, maxToolCalls: 3e3, timeoutMs: 6 * 60 * 1e3 }
+    };
+    return defaults[role] ?? { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 };
+  }
+  async spawnAgent(role, taskBrief) {
+    const budget = this.budgetForRole(role);
+    const cfg = {
+      id: `${role}-${this.sessionId}`,
+      name: role,
+      role,
+      tools: ["fleet_emit", "fleet_status", "read", "grep", "glob", "bash", "write"],
+      maxIterations: budget.maxIterations,
+      maxToolCalls: budget.maxToolCalls,
+      timeoutMs: budget.timeoutMs
+    };
+    const subagentId = await this.director.spawn(cfg);
+    await this.director.assign({ id: randomUUID(), subagentId, description: taskBrief });
+    return subagentId;
+  }
+  buildBugHunterTask() {
+    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
+${f.content}`).join("\n\n");
+    return `You are BugHunter. Scan the following files for bugs and code smells.
+
+Target files:
+${fileContents}
+
+For each bug found, emit it using the fleet_emit tool immediately:
+{ "type": "bug.found", "payload": { "finding": { "id": "<uuid>", "type": "<pattern>", "severity": "<critical|high|medium|low>", "location": { "file": "<path>", "line": <n> }, "description": "<explain>", "suggestedFix": "<optional>" } } }
+
+After scanning all files, write your full markdown bug report to:
+${scratchpad}/bug-hunter-report-${this.sessionId}.md
+
+Important: emit each finding as soon as you find it. Do not batch or wait until the end.`;
+  }
+  buildRefactorPlannerTask() {
+    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
+    const bugHunterReportPath = `${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
+    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
+${f.content}`).join("\n\n");
+    return `You are RefactorPlanner. Plan refactorings for the following files.
+
+Target files:
+${fileContents}
+
+Read the BugHunter report at: ${bugHunterReportPath}
+
+For each bug you can address, emit a refactor plan using fleet_emit:
+{ "type": "refactor.plan", "payload": { "plan": { "id": "<uuid>", "basedOnBugIds": ["<bug-id>"], "phases": [{ "number": 1, "title": "<phase>", "tasks": ["<task>"], "risk": "<low|medium|high>" }], "riskScore": "<low|medium|high>", "estimatedChangeCount": <n>, "rollbackStrategy": "<text>" } } }
+
+Also write your full markdown plan to:
+${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}
+
+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");
   }
-  onIterationStarted(e) {
-    const snap = this.ensure(e.subagentId);
-    snap.iterations += 1;
-    snap.lastEventAt = e.ts;
+  cleanup() {
+    for (const dispose of this.disposers) dispose();
+    this.disposers.length = 0;
   }
 };
+
+// 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());
+  }
+  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",
@@ -11969,813 +12373,442 @@ function makeFleetUsageTool(director) {
   };
 }
 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.",
+  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: {
-        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."
-        }
+        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: ["type"]
+      required: ["subagentId"]
     },
     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 };
+      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 makeWorkCompleteTool(director) {
+function makeFleetHealthTool(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.",
+    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() {
-      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: []
+      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
+            }
+          };
+        })
       };
     }
-  }
-  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 });
+  };
+}
+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." };
       }
-    }
-    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;
+      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.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,
+  };
+}
+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,
-        payload: obj
+        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 });
+    });
+    return () => {
+      off();
+    };
   }
-  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;
-        }
-      }
+  /** 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);
     }
-    return objects;
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
   }
-  budgetForRole(role) {
-    if (this.options.budgetOverrides?.[role]) {
-      return this.options.budgetOverrides[role];
+  /** 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 defaults = {
-      "bug-hunter": { maxIterations: 2e3, maxToolCalls: 5e3, timeoutMs: 10 * 60 * 1e3 },
-      "refactor-planner": { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 },
-      "critic": { maxIterations: 1e3, maxToolCalls: 3e3, timeoutMs: 6 * 60 * 1e3 }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
     };
-    return defaults[role] ?? { maxIterations: 1500, maxToolCalls: 4e3, timeoutMs: 8 * 60 * 1e3 };
   }
-  async spawnAgent(role, taskBrief) {
-    const budget = this.budgetForRole(role);
-    const cfg = {
-      id: `${role}-${this.sessionId}`,
-      name: role,
-      role,
-      tools: ["fleet_emit", "fleet_status", "read", "grep", "glob", "bash", "write"],
-      maxIterations: budget.maxIterations,
-      maxToolCalls: budget.maxToolCalls,
-      timeoutMs: budget.timeoutMs
+  /** Subscribe to literally everything. The fleet roll-up uses this. */
+  onAny(handler) {
+    this.any.add(handler);
+    return () => {
+      this.any.delete(handler);
     };
-    const subagentId = await this.director.spawn(cfg);
-    await this.director.assign({ id: randomUUID(), subagentId, description: taskBrief });
-    return subagentId;
-  }
-  buildBugHunterTask() {
-    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
-    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
-${f.content}`).join("\n\n");
-    return `You are BugHunter. Scan the following files for bugs and code smells.
-
-Target files:
-${fileContents}
-
-For each bug found, emit it using the fleet_emit tool immediately:
-{ "type": "bug.found", "payload": { "finding": { "id": "<uuid>", "type": "<pattern>", "severity": "<critical|high|medium|low>", "location": { "file": "<path>", "line": <n> }, "description": "<explain>", "suggestedFix": "<optional>" } } }
-
-After scanning all files, write your full markdown bug report to:
-${scratchpad}/bug-hunter-report-${this.sessionId}.md
-
-Important: emit each finding as soon as you find it. Do not batch or wait until the end.`;
-  }
-  buildRefactorPlannerTask() {
-    const scratchpad = this.director.sharedScratchpadPath ?? "/tmp";
-    const bugHunterReportPath = `${scratchpad}/bug-hunter-report-${this.sessionId}.md`;
-    const fileContents = this.snapshot.files.map((f) => `=== ${f.path} ===
-${f.content}`).join("\n\n");
-    return `You are RefactorPlanner. Plan refactorings for the following files.
-
-Target files:
-${fileContents}
-
-Read the BugHunter report at: ${bugHunterReportPath}
-
-For each bug you can address, emit a refactor plan using fleet_emit:
-{ "type": "refactor.plan", "payload": { "plan": { "id": "<uuid>", "basedOnBugIds": ["<bug-id>"], "phases": [{ "number": 1, "title": "<phase>", "tasks": ["<task>"], "risk": "<low|medium|high>" }], "riskScore": "<low|medium|high>", "estimatedChangeCount": <n>, "rollbackStrategy": "<text>" } } }
-
-Also write your full markdown plan to:
-${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}
-
-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;
+  emit(event) {
+    const byId = this.byId.get(event.subagentId);
+    if (byId)
+      for (const h of byId) {
+        try {
+          h(event);
+        } catch {
         }
-        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);
+    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);
+    }
+  }
+};
+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)));
   }
-  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;
+  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;
   }
-  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);
+  /** 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 {
@@ -12947,6 +12980,9 @@ var Director = class _Director {
   maxLeaderContextLoad;
   /** Provider's max context window in tokens. */
   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
@@ -12977,20 +13013,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(
@@ -13168,7 +13207,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 +13344,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) {
@@ -13336,7 +13392,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 +13629,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