@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-T3KGZBU5.js

@@ -0,0 +1,3171 @@
+import {
+  AGENT_CATALOG,
+  ALL_AGENT_DEFINITIONS,
+  ROLE_SKILL_SETS,
+  SHADOW_AGENT_SKILLS,
+  TOOLS,
+  agentPrompt
+} from "./chunk-FHAMQS7Q.js";
+import {
+  setBtwNote
+} from "./chunk-SQJVFEBV.js";
+import {
+  ToolCapabilities
+} from "./chunk-A455ATZB.js";
+import {
+  SECRET_FILE_MODE
+} from "./chunk-H5E77KUJ.js";
+import {
+  ProviderError
+} from "./chunk-NFAYHPRH.js";
+import {
+  safeParse
+} from "./chunk-RPOA7IAE.js";
+import {
+  readBundledInstructionText,
+  renderInstructionTemplate
+} from "./chunk-5S437PRC.js";
+import {
+  AgentError,
+  ERROR_CODES
+} from "./chunk-WOEZV3Q4.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/coordination/subagent-finish.ts
+var SUBAGENT_FINISH_REQUESTED_EVENT = "subagent.finish_requested";
+var DEFAULT_SUBAGENT_FINISH_GRACE_MS = 12e4;
+function resolveGracefulFinish(config) {
+  const raw = config.gracefulFinish;
+  if (raw === void 0 || raw === false) return void 0;
+  if (raw === true) return { graceMs: DEFAULT_SUBAGENT_FINISH_GRACE_MS };
+  const graceMs = typeof raw.graceMs === "number" && Number.isFinite(raw.graceMs) && raw.graceMs > 0 ? Math.floor(raw.graceMs) : DEFAULT_SUBAGENT_FINISH_GRACE_MS;
+  return { graceMs };
+}
+function buildSubagentFinishNotice(input) {
+  const localTime = new Date(input.deadlineMs).toISOString();
+  const seconds = Math.max(1, Math.round(input.graceMs / 1e3));
+  const timeLeft = input.graceMs > 0 ? `You have roughly ${seconds} seconds (until ${localTime}) of legitimate working time left.` : `Your working-time window is already spent (deadline was ${localTime}) \u2014 finish now.`;
+  return [
+    "[SUBAGENT FINISH] The leader agent has finished its work.",
+    `Reason: ${input.reason}`,
+    timeLeft,
+    "Finish your task now, in this turn: complete the thought you are working on, stop",
+    "starting new tool calls unless one is strictly required to finish, and write your",
+    "final answer or report as your final output, then end your turn.",
+    "Do not restart the task and do not begin new work."
+  ].join("\n");
+}
+
+// src/coordination/subagent-budget.ts
+var TIMEOUT_PREEMPT_FRACTION = 0.85;
+var DECISION_TIMEOUT_MS = 6e4;
+var BudgetExceededError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(kind, limit, observed) {
+    super(`Budget exceeded: ${kind} (limit=${limit}, observed=${observed})`);
+    this.name = "BudgetExceededError";
+    this.kind = kind;
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
+var BudgetThresholdSignal = class extends Error {
+  kind;
+  limit;
+  used;
+  /** Resolves to 'extend' (with optional new limits) or 'stop' */
+  decision;
+  constructor(kind, limit, used, decision) {
+    super(`Budget soft limit: ${kind} (limit=${limit}, used=${used})`);
+    this.name = "BudgetThresholdSignal";
+    this.kind = kind;
+    this.limit = limit;
+    this.used = used;
+    this.decision = decision;
+  }
+};
+var SubagentBudget = class _SubagentBudget {
+  limits;
+  /** Patch one or more budget limits in-place after construction.
+   * Used by the coordinator watchdog when granting an extension.
+   * All fields are optional — only provided fields are updated.
+   * This is the single write path for limit mutations so that future
+   * validation or side-effects live in one place (M1). */
+  patchLimits(ext) {
+    if (ext.maxIterations !== void 0) {
+      this.limits.maxIterations = ext.maxIterations;
+    }
+    if (ext.maxToolCalls !== void 0) {
+      this.limits.maxToolCalls = ext.maxToolCalls;
+    }
+    if (ext.maxTokens !== void 0) {
+      this.limits.maxTokens = ext.maxTokens;
+    }
+    if (ext.maxCostUsd !== void 0) {
+      this.limits.maxCostUsd = ext.maxCostUsd;
+    }
+    if (ext.timeoutMs !== void 0) {
+      this.limits.timeoutMs = ext.timeoutMs;
+    }
+    if (ext.idleTimeoutMs !== void 0) {
+      this.limits.idleTimeoutMs = ext.idleTimeoutMs;
+    }
+  }
+  /**
+   * Graceful-finish state (see coordination/subagent-finish.ts).
+   * `_finishNotified` guards the single in-band emission; `_grace` records a
+   * granted working-time extension past the original wall-clock deadline.
+   * They are separate because the two callers want different semantics:
+   * the watchdog grants grace at the deadline crossing (notify + extend),
+   * while an explicit leader-finished request only notifies — a subagent
+   * well inside its budget keeps its full legitimate working time and simply
+   * accelerates.
+   */
+  _finishNotified = false;
+  _grace = null;
+  /** True once the in-band finish notification has been emitted. */
+  get finishNotified() {
+    return this._finishNotified;
+  }
+  /** True once a grace window has been granted past the original deadline. */
+  get graceGranted() {
+    return this._grace !== null;
+  }
+  /**
+   * Notify the subagent in-band to finish its task in its own turn:
+   * `subagent.finish_requested` is emitted on the wired EventBus and the
+   * agent loop folds the notice into the conversation between tool batches.
+   * Nothing aborts — this is a notification, never an interrupt.
+   *
+   * `opts.graceMs` additionally extends the wall-clock ceiling by that window
+   * (used by the watchdog at a deadline crossing, so the model gets working
+   * time instead of a kill). Omit it to notify without touching the budget —
+   * the subagent keeps its existing time budget and just accelerates.
+   *
+   * Returns `true` when this call did something (emitted the notification
+   * and/or granted grace); `false` when there was nothing to do (already
+   * notified, grace already granted, no EventBus wired, budget not started).
+   */
+  notifyFinish(reason, opts, now = Date.now) {
+    if (!this._events) return false;
+    if (this.startTime === null) return false;
+    const shouldEmit = !this._finishNotified;
+    const rawGrace = opts?.graceMs;
+    const shouldGrant = rawGrace !== void 0 && this._grace === null;
+    if (!shouldEmit && !shouldGrant) return false;
+    let grantedGraceMs = 0;
+    let graceDeadlineMs;
+    if (shouldGrant && rawGrace !== void 0) {
+      grantedGraceMs = Number.isFinite(rawGrace) && rawGrace > 0 ? Math.floor(rawGrace) : DEFAULT_SUBAGENT_FINISH_GRACE_MS;
+      graceDeadlineMs = now() + grantedGraceMs;
+      this._grace = { deadlineMs: graceDeadlineMs, graceMs: grantedGraceMs };
+      this.patchLimits({ timeoutMs: graceDeadlineMs - this.startTime });
+    }
+    if (shouldEmit) {
+      this._finishNotified = true;
+      const effectiveDeadlineMs = graceDeadlineMs ?? (this.limits.timeoutMs !== void 0 ? this.startTime + this.limits.timeoutMs : now() + DEFAULT_SUBAGENT_FINISH_GRACE_MS);
+      const effectiveGraceMs = Math.max(0, effectiveDeadlineMs - now());
+      const subagentId = this._subagentId;
+      this._events.emit(SUBAGENT_FINISH_REQUESTED_EVENT, {
+        // Omitted entirely when the budget was built without an id — an
+        // empty string is an address that matches nothing.
+        ...subagentId !== void 0 ? { subagentId } : {},
+        reason,
+        deadlineMs: effectiveDeadlineMs,
+        graceMs: effectiveGraceMs,
+        notice: buildSubagentFinishNotice({
+          reason,
+          deadlineMs: effectiveDeadlineMs,
+          graceMs: effectiveGraceMs
+        })
+      });
+    }
+    return true;
+  }
+  /** Epoch ms by which the subagent should have produced its final output,
+   *  once a grace window was granted. Undefined before that. */
+  get finishDeadlineMs() {
+    return this._grace?.deadlineMs;
+  }
+  iterations = 0;
+  toolCalls = 0;
+  tokenInput = 0;
+  tokenOutput = 0;
+  costUsd = 0;
+  startTime = null;
+  /**
+   * Timestamp of the most recent activity (iteration / tool call / token
+   * usage / streamed progress). Drives the idle timeout — reset by
+   * `markActivity()`. Initialised to `start()` time so a never-active agent
+   * still eventually trips its idle window.
+   */
+  lastActivityTime = null;
+  _onThreshold;
+  _sessionId;
+  /** Owning subagent id — used to address the graceful-finish event. */
+  _subagentId;
+  /** True when only the coordinator watchdog may enforce wall-clock limits. */
+  _wallClockWatchdogOwned;
+  /**
+   * Hard cap on how long `_negotiateExtension` waits for the coordinator to
+   * respond before defaulting to 'stop'. Without this fallback an absent
+   * or hung listener (Director not built / event filter detached mid-run)
+   * leaves the budget over-limit and never enforces anything.
+   */
+  static DECISION_TIMEOUT_MS = DECISION_TIMEOUT_MS;
+  /**
+   * Injected by the runner when wiring the budget to its EventBus.
+   * Used to emit `budget.threshold_reached` events in `'auto'` mode.
+   */
+  _events;
+  /**
+   * Guard against dual-path races between the coordinator watchdog
+   * (`executeWithTimeout`) and the budget's own `checkTimeout()`.
+   * Both paths detect `elapsed >= timeoutMs` and can emit
+   * `budget.threshold_reached` for kind `'timeout'` simultaneously.
+   * Set to the current `timeoutMs` ceiling by the coordinator BEFORE
+   * calling `onThreshold`, and cleared after the negotiation resolves.
+   * `checkTimeout()` skips its wall-clock check while this is set so
+   * the coordinator's watchdog is the sole source of wall-clock timeout
+   * events — `checkTimeout()` focuses exclusively on `idle_timeout`.
+   */
+  _watchdogActive;
+  /** Returns the timeout ceiling currently being negotiated by the watchdog,
+   * or `undefined` when no wall-clock negotiation is in flight.
+   * Used by `executeWithTimeout` to detect a stale lock (M3). */
+  get watchdogActive() {
+    return this._watchdogActive;
+  }
+  /** Called by the coordinator watchdog BEFORE calling `onThreshold` so that
+   * `checkTimeout()` skips its wall-clock check for this ceiling. Prevents
+   * the budget's own `checkTimeout()` from emitting a second
+   * `budget.threshold_reached` event while the watchdog is already
+   * negotiating the same wall-clock deadline (C1). */
+  setWatchdogNegotiation(timeoutMs) {
+    this._watchdogActive = timeoutMs;
+  }
+  /** Clears the watchdog guard after negotiation resolves. Called in the
+   * `finally` block of both the pre-empt and deadline branches so it fires
+   * on every exit path: grant, deny, throw, or error. */
+  clearWatchdogNegotiation() {
+    this._watchdogActive = void 0;
+  }
+  /**
+   * Negotiation mode — controls whether a threshold hit tries to emit
+   * `budget.threshold_reached` and wait for a coordinator decision, or
+   * falls straight through to a synchronous hard stop.
+   *
+   * `'auto'` (default) — emit on the EventBus and wait; times out to 'stop'.
+   * `'sync'` — throw `BudgetExceededError` immediately regardless of listeners.
+   */
+  _mode;
+  /**
+   * Optional callback for soft-limit handling. When set, the budget will
+   * invoke it rather than throw immediately. The handler decides whether to
+   * throw synchronously, continue, or ask the coordinator for an extension.
+   */
+  get onThreshold() {
+    return this._onThreshold;
+  }
+  set onThreshold(fn) {
+    this._onThreshold = fn;
+  }
+  /** Returns the current negotiation mode. */
+  get mode() {
+    return this._mode;
+  }
+  constructor(limits = {}, mode = "auto", options = {}) {
+    this._mode = mode;
+    this._sessionId = options.sessionId;
+    this._subagentId = options.subagentId;
+    this._wallClockWatchdogOwned = options.wallClockWatchdogOwned === true;
+    this.limits = { ...limits };
+  }
+  currentSessionId() {
+    const value = typeof this._sessionId === "function" ? this._sessionId() : this._sessionId;
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  }
+  start() {
+    this.startTime = Date.now();
+    this.lastActivityTime = this.startTime;
+  }
+  /**
+   * Reset the idle clock. Called on any sign of forward progress —
+   * iterations, tool calls, token usage, and streamed tool/text progress —
+   * so a long-but-productive subagent never trips its `idleTimeoutMs`.
+   */
+  markActivity() {
+    this.lastActivityTime = Date.now();
+  }
+  /**
+   * Milliseconds since the last activity signal. Returns 0 before `start()`
+   * (nothing to measure yet). Used by the coordinator watchdog to decide
+   * whether to re-arm (still active) or reap (genuinely idle).
+   */
+  idleMs() {
+    const since = this.lastActivityTime ?? this.startTime;
+    return since === null ? 0 : Date.now() - since;
+  }
+  /** Returns true if we're within 10% of any limit — useful for pre-flight checks. */
+  isNearLimit() {
+    const { maxIterations, maxToolCalls, maxTokens, maxCostUsd } = this.limits;
+    if (maxIterations && this.iterations >= maxIterations * 0.9) return true;
+    if (maxToolCalls && this.toolCalls >= maxToolCalls * 0.9) return true;
+    if (maxTokens && this.tokenInput + this.tokenOutput >= maxTokens * 0.9) return true;
+    if (maxCostUsd && this.costUsd >= maxCostUsd * 0.9) return true;
+    return false;
+  }
+  /**
+   * Synchronous budget check. Always throws synchronously so callers (especially
+   * test event handlers using `expect().toThrow()`) get an unhandled rejection
+   * when the budget is exceeded without a handler.
+   *
+   * Decision table:
+   * - no `onThreshold` handler         → throw `BudgetExceededError` (hard stop, always)
+   * - `mode === 'sync'`               → throw `BudgetExceededError` (hard stop, always)
+   * - `mode === 'auto'` + no listener  → throw `BudgetExceededError` (hard stop; no one to ask)
+   * - `mode === 'auto'` + listener     → throw `BudgetThresholdSignal` with async decision promise
+   */
+  /**
+   * Collects all exceeded budget kinds into a single NOOP-free negotiation.
+   * Called by recordIteration / recordToolCall / recordUsage — each may call
+   * this for its own kind. The first call starts the negotiation and stores
+   * the Promise in _pendingNegotiation. Subsequent calls for DIFFERENT
+   * kinds (while a negotiation is in flight) are NOOPs — they don't start
+   * new conversations with the coordinator. This prevents an EventBus flood
+   * when multiple budget kinds are exceeded simultaneously in one iteration.
+   *
+   * Returns the kinds that were found to be exceeded (for logging/debugging).
+   */
+  checkLimits(elapsedMs) {
+    const exceeded = [];
+    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
+      exceeded.push({ kind: "iterations", used: this.iterations, limit: this.limits.maxIterations });
+    }
+    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
+      exceeded.push({ kind: "tool_calls", used: this.toolCalls, limit: this.limits.maxToolCalls });
+    }
+    const totalTokens = this.tokenInput + this.tokenOutput;
+    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
+      exceeded.push({ kind: "tokens", used: totalTokens, limit: this.limits.maxTokens });
+    }
+    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
+      exceeded.push({ kind: "cost", used: this.costUsd, limit: this.limits.maxCostUsd });
+    }
+    if (elapsedMs !== void 0) {
+      const idle = this.idleMs();
+      if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
+        exceeded.push({ kind: "idle_timeout", used: idle, limit: this.limits.idleTimeoutMs });
+      }
+      const wallOwnedByWatchdog = this._wallClockWatchdogOwned || this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
+      if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs && !wallOwnedByWatchdog) {
+        exceeded.push({ kind: "timeout", used: elapsedMs, limit: this.limits.timeoutMs });
+      }
+    }
+    if (exceeded.length === 0) return [];
+    if (!this._onThreshold) {
+      const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
+    }
+    if (this._mode === "sync") {
+      const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
+    }
+    const bus = this._events;
+    if (!bus) {
+      const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
+    }
+    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
+    if (bus.hasListenerFor("budget.threshold_reached")) {
+      for (const entry of exceeded) {
+        if (this._pendingNegotiations.has(entry.kind)) continue;
+        this._pendingNegotiations.set(entry.kind, this._negotiateExtension(entry));
+      }
+      const decision = this._pendingNegotiations.get(first.kind);
+      if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
+      throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
+    }
+    let hardStop = null;
+    for (const entry of exceeded) {
+      if (this._pendingNegotiations.has(entry.kind)) continue;
+      const marker = Promise.resolve("stop");
+      this._pendingNegotiations.set(entry.kind, marker);
+      void marker.finally(() => this._pendingNegotiations.delete(entry.kind));
+      const sync = this._invokeHandlerSync(entry);
+      if (!sync) hardStop ??= new BudgetExceededError(entry.kind, entry.limit, entry.used);
+    }
+    if (hardStop) throw hardStop;
+    return exceeded;
+  }
+  /**
+   * Invoke `onThreshold` once for `entry` on the NO-LISTENER path and report
+   * whether it decided synchronously. Returns `true` when the handler returned
+   * a synchronous decision (already honored — an `extend` patched the limits),
+   * or `false` when it returned a Promise (async; the caller hard-stops, since
+   * there is no listener to resolve the negotiation). The handler is given the
+   * full info shape (`requestDecision` plus direct `extend`/`deny`) so both
+   * recording handlers and policy handlers work without a wired listener.
+   */
+  _invokeHandlerSync(entry) {
+    const handler = this._onThreshold;
+    if (!handler) return false;
+    let extendArg;
+    const result = handler({
+      kind: entry.kind,
+      used: entry.used,
+      limit: entry.limit,
+      requestDecision: () => this._busRequestDecision(entry),
+      // Direct hooks for synchronous policy/recording handlers.
+      extend: (extra) => {
+        extendArg = extra;
+      },
+      deny: () => {
+      }
+    });
+    if (result && typeof result.then === "function") return false;
+    if (result === "throw") return false;
+    if (result && typeof result === "object" && "extend" in result) {
+      extendArg = result.extend;
+    }
+    if (extendArg) this.patchLimits(extendArg);
+    return true;
+  }
+  /**
+   * Emit `budget.threshold_reached` and resolve to the listener's verdict.
+   * Resolves to `'stop'` immediately when there is no listener (or no bus) so
+   * no negotiation can hang and no fallback timer leaks. Mirrors the
+   * coordinator watchdog's own request path so both agree on the no-listener
+   * default.
+   */
+  _busRequestDecision(entry) {
+    const bus = this._events;
+    if (!bus?.hasListenerFor("budget.threshold_reached")) {
+      return Promise.resolve("stop");
+    }
+    return new Promise((resolve) => {
+      let resolved = false;
+      const respond = (d) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(fallback);
+        resolve(d);
+      };
+      const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
+      const sessionId = this.currentSessionId();
+      bus.emit("budget.threshold_reached", {
+        ...sessionId ? { sessionId } : {},
+        kind: entry.kind,
+        used: entry.used,
+        limit: entry.limit,
+        timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+        // deny() wins over a same-dispatch extend(): a listener that both grants
+        // and denies (or two listeners disagreeing) is resolved as a stop. The
+        // grant is deferred a microtask so a synchronous deny in the same emit
+        // pre-empts it; async grants still resolve normally.
+        extend: (extra) => queueMicrotask(() => respond({ extend: extra })),
+        deny: () => respond("stop")
+      });
+    });
+  }
+  /**
+   * Per-kind in-flight negotiation Promises. Each budget kind can have its
+   * own concurrent negotiation — e.g. iterations and timeout can both
+   * be exceeded simultaneously without blocking each other. The same kind
+   * cannot start two concurrent negotiations (dedup guard).
+   * Cleared in `_negotiateExtension`'s `finally` block.
+   */
+  _pendingNegotiations = /* @__PURE__ */ new Map();
+  /**
+   * Drive the threshold handler to a decision. Resolves with `'stop'`
+   * (signal the runner to abort) or `{ extend: ... }` (limits already
+   * patched in-place; the runner should not abort). Clears the
+   * per-kind slot in `_pendingNegotiations` in `finally`.
+   *
+   * The 'continue' return from a sync handler is treated as
+   * `{ extend: {} }` — keep going without patching; next overrun fires
+   * a fresh signal.
+   */
+  async _negotiateExtension(entry) {
+    if (!this._onThreshold) {
+      return "stop";
+    }
+    try {
+      const result = this._onThreshold({
+        kind: entry.kind,
+        used: entry.used,
+        limit: entry.limit,
+        // One event for THIS kind only — each exceeded kind has its own
+        // negotiation (and its own resolve), so there is no cross-kind
+        // first-wins drop and no O(N^2) re-emission.
+        requestDecision: () => this._busRequestDecision(entry),
+        extend: (extra) => {
+          this.patchLimits(extra);
+        },
+        deny: () => {
+        }
+      });
+      if (result === "throw") return "stop";
+      if (result === "continue") return { extend: {} };
+      const decision = await result;
+      if (decision === "stop") return "stop";
+      this.patchLimits(decision.extend);
+      return decision;
+    } finally {
+      this._pendingNegotiations.delete(entry.kind);
+    }
+  }
+  recordIteration() {
+    this.iterations++;
+    this.markActivity();
+    void this.checkLimits();
+  }
+  recordToolCall() {
+    this.toolCalls++;
+    this.markActivity();
+    void this.checkLimits();
+  }
+  recordUsage(usage, costUsd = 0) {
+    this.tokenInput += usage.input;
+    this.tokenOutput += usage.output;
+    this.costUsd += costUsd;
+    this.markActivity();
+    void this.checkLimits();
+  }
+  /**
+   * Wall-clock / idle budget check. Delegates to `checkLimits(elapsed)`, so
+   * `timeout` and `idle_timeout` follow the SAME negotiation path as the other
+   * kinds — they are NOT a special-cased hard stop. This is deliberate: a
+   * heartbeat-aware policy (see `attachAutoExtend` and `CollabSession`) grants
+   * a timeout extension only while the agent is making progress and denies it
+   * once the agent is genuinely stuck, which is safer than an unconditional
+   * hard kill of a long-but-working agent. The runner translates the resulting
+   * `BudgetThresholdSignal` decision (`extend` → patch limits in place,
+   * `stop` → abort) just like every other kind.
+   *
+   * Decision table (same as `checkLimits`):
+   * - no `onThreshold` handler        → throw `BudgetExceededError` (hard stop)
+   * - `mode === 'sync'`               → throw `BudgetExceededError` (hard stop)
+   * - `mode === 'auto'` + no listener → throw `BudgetExceededError` (no one to ask)
+   * - `mode === 'auto'` + listener    → throw `BudgetThresholdSignal` (negotiated;
+   *                                     a heartbeat-aware policy may extend the timeout)
+   */
+  checkTimeout() {
+    if (this.startTime === null) return;
+    const { timeoutMs, idleTimeoutMs } = this.limits;
+    if (timeoutMs === void 0 && idleTimeoutMs === void 0) return;
+    const elapsed = Date.now() - this.startTime;
+    const wallSkipped = this._onThreshold !== void 0 && this._watchdogActive !== void 0 && timeoutMs !== void 0 && this._watchdogActive === timeoutMs;
+    const wallTripped = this._wallClockWatchdogOwned || wallSkipped ? false : timeoutMs !== void 0 && elapsed > timeoutMs;
+    const idleTripped = idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs;
+    if (!wallTripped && !idleTripped) return;
+    void this.checkLimits(elapsed);
+  }
+  /** Returns true if a wall-clock or idle timeout has occurred without throwing. */
+  isTimedOut() {
+    if (this.startTime === null) return false;
+    const { timeoutMs, idleTimeoutMs } = this.limits;
+    if (timeoutMs !== void 0 && Date.now() - this.startTime > timeoutMs) return true;
+    if (idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs) return true;
+    return false;
+  }
+  usage() {
+    return {
+      iterations: this.iterations,
+      toolCalls: this.toolCalls,
+      tokens: {
+        input: this.tokenInput,
+        output: this.tokenOutput,
+        total: this.tokenInput + this.tokenOutput
+      },
+      costUsd: this.costUsd,
+      elapsedMs: this.startTime === null ? 0 : Date.now() - this.startTime
+    };
+  }
+};
+
+// src/coordination/subagent-result-tool.ts
+var SUBAGENT_STRUCTURED_REPORT_META_KEY = "subagentStructuredReport";
+var MAX_SUBAGENT_STRUCTURED_REPORT_CHARS = 8e3;
+var MAX_SUMMARY_CHARS = 1500;
+var MAX_FINDINGS = 16;
+var MAX_FILES = 64;
+var MAX_NEXT_STEPS = 12;
+var MAX_ITEM_CHARS = 500;
+function normalizeSubagentStructuredReport(value) {
+  if (!isRecord(value)) return void 0;
+  const summary = nonEmptyString(value["summary"]);
+  const findings = stringArray(value["findings"]);
+  const filesExamined = stringArray(value["files_examined"]);
+  const nextSteps = stringArray(value["suggested_next_steps"]);
+  const confidence = value["confidence"];
+  const completion = value["completion"];
+  const remainingWork = optionalString(value["remaining_work"]);
+  if (!summary || summary.length > MAX_SUMMARY_CHARS || !findings || findings.length > MAX_FINDINGS || !filesExamined || filesExamined.length > MAX_FILES || !nextSteps || nextSteps.length > MAX_NEXT_STEPS || [...findings, ...filesExamined, ...nextSteps].some(
+    (item) => item.trim().length > MAX_ITEM_CHARS
+  ) || typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1 || completion !== void 0 && completion !== "complete" && completion !== "partial" || completion === "partial" && !remainingWork || remainingWork !== void 0 && remainingWork.length > MAX_SUMMARY_CHARS) {
+    return void 0;
+  }
+  const report = {
+    summary,
+    findings: findings.map((item) => item.trim()).filter(Boolean),
+    files_examined: filesExamined.map((item) => item.trim()).filter(Boolean),
+    confidence,
+    suggested_next_steps: nextSteps.map((item) => item.trim()).filter(Boolean),
+    ...completion === "complete" || completion === "partial" ? { completion } : {},
+    ...remainingWork ? { remaining_work: remainingWork } : {}
+  };
+  return JSON.stringify(report).length <= MAX_SUBAGENT_STRUCTURED_REPORT_CHARS ? report : void 0;
+}
+function readSubagentStructuredReport(ctx) {
+  return normalizeSubagentStructuredReport(ctx?.meta?.[SUBAGENT_STRUCTURED_REPORT_META_KEY]);
+}
+function formatSubagentStructuredReport(report) {
+  const findings = report.findings.length ? report.findings.map((item) => `- ${item}`).join("\n") : "- (none)";
+  const files = report.files_examined.length ? report.files_examined.join(", ") : "(none)";
+  const next = report.suggested_next_steps.length ? report.suggested_next_steps.map((item) => `- ${item}`).join("\n") : "- (none)";
+  return [
+    report.summary,
+    report.completion ? `Completion: ${report.completion}` : void 0,
+    report.remaining_work ? `Remaining work: ${report.remaining_work}` : void 0,
+    `
+Findings:
+${findings}`,
+    `
+Files examined: ${files}`,
+    `Confidence: ${report.confidence.toFixed(2)}`,
+    `
+Suggested next steps:
+${next}`
+  ].filter((line) => typeof line === "string").join("\n");
+}
+function makeSubagentResultTool() {
+  return {
+    name: "submit_result",
+    description: "Submit the task result as a compact structured report for the Director. Call once near the end, before your final text response.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_RESULT_SUBMIT],
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: {
+          type: "string",
+          maxLength: MAX_SUMMARY_CHARS,
+          description: "Concise outcome summary."
+        },
+        findings: {
+          type: "array",
+          maxItems: MAX_FINDINGS,
+          items: { type: "string" },
+          description: "Atomic findings or changes, with evidence when useful."
+        },
+        files_examined: {
+          type: "array",
+          maxItems: MAX_FILES,
+          items: { type: "string" },
+          description: "Project-relative files materially read or changed."
+        },
+        confidence: {
+          type: "number",
+          minimum: 0,
+          maximum: 1,
+          description: "Confidence from 0.0 to 1.0."
+        },
+        suggested_next_steps: {
+          type: "array",
+          maxItems: MAX_NEXT_STEPS,
+          items: { type: "string" },
+          description: "Concrete follow-ups; use an empty array when none remain."
+        },
+        completion: {
+          type: "string",
+          enum: ["complete", "partial"],
+          description: "Use `partial` only when the task is intentionally stopping at a clean checkpoint and another worker should continue."
+        },
+        remaining_work: {
+          type: "string",
+          maxLength: MAX_SUMMARY_CHARS,
+          description: "Concrete work left for a successor. Required by runtime validation when completion is `partial`."
+        }
+      },
+      required: ["summary", "findings", "files_examined", "confidence", "suggested_next_steps"],
+      additionalProperties: false
+    },
+    async execute(input, ctx) {
+      const report = normalizeSubagentStructuredReport(input);
+      if (!report) {
+        return {
+          ok: false,
+          error: "Invalid report: summary/findings/files_examined/confidence/suggested_next_steps are required and confidence must be 0..1."
+        };
+      }
+      ctx.meta[SUBAGENT_STRUCTURED_REPORT_META_KEY] = report;
+      return {
+        ok: true,
+        findings: report.findings.length,
+        filesExamined: report.files_examined.length,
+        confidence: report.confidence
+      };
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function optionalString(value) {
+  return value === void 0 ? void 0 : nonEmptyString(value);
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+
+// src/coordination/agent-subagent-runner.ts
+function withDisabledToolFiltering(factory) {
+  return async (config, task) => {
+    const result = await factory(config, task);
+    const disabled = config.disabledTools ?? [];
+    if (disabled.length === 0) return result;
+    const registry = result.agent.tools;
+    if (registry && typeof registry.unregister === "function") {
+      for (const toolName of disabled) {
+        registry.unregister(toolName);
+      }
+    }
+    return result;
+  };
+}
+function makeAgentSubagentRunner(opts) {
+  const format = opts.formatTaskInput ?? defaultFormatTaskInput;
+  return async (task, ctx) => {
+    const taskStartedAt = Date.now();
+    const factoryResult = await opts.factory(ctx.config, task);
+    const { agent, events } = factoryResult;
+    const taskContext = task.context ?? {};
+    const hasExplicitTelemetryTask = typeof taskContext["telemetryTaskId"] === "string";
+    const telemetryTaskId = hasExplicitTelemetryTask ? taskContext["telemetryTaskId"] : task.id;
+    const telemetryRunId = typeof taskContext["telemetryRunId"] === "string" ? taskContext["telemetryRunId"] : void 0;
+    const telemetryBoardId = typeof taskContext["telemetryBoardId"] === "string" ? taskContext["telemetryBoardId"] : void 0;
+    const agentContext = agent.ctx;
+    if (agentContext?.meta) {
+      agentContext.meta["subagentTaskId"] = task.id;
+      const kanbanContext = taskContext["kanban"];
+      if (kanbanContext && typeof kanbanContext === "object") {
+        agentContext.meta["kanban"] = kanbanContext;
+      }
+      if (hasExplicitTelemetryTask) {
+        agentContext.meta["telemetryTaskId"] = telemetryTaskId;
+        if (telemetryRunId) agentContext.meta["telemetryRunId"] = telemetryRunId;
+      }
+    }
+    if (hasExplicitTelemetryTask) {
+      agentContext?.setCurrentKanbanTask?.(telemetryTaskId, telemetryBoardId);
+    } else {
+      const kanbanContext = taskContext["kanban"];
+      if (kanbanContext && typeof kanbanContext === "object") {
+        const kanban = kanbanContext;
+        const boardId = typeof kanban["boardId"] === "string" ? kanban["boardId"] : void 0;
+        const taskId = typeof kanban["taskId"] === "string" ? kanban["taskId"] : void 0;
+        if (taskId) agentContext?.setCurrentKanbanTask?.(taskId, boardId);
+      }
+    }
+    const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
+    const aborter = new AbortController();
+    ctx.budget._events = events;
+    ctx.budget.onThreshold = ({ requestDecision }) => requestDecision();
+    let budgetError = null;
+    const onBudgetError = (err) => {
+      if (err instanceof BudgetThresholdSignal) {
+        budgetError = err;
+        return;
+      }
+      aborter.abort();
+      budgetError = err instanceof BudgetExceededError ? err : new BudgetExceededError(
+        "tool_calls",
+        0,
+        0
+      );
+      if (budgetError !== err && err instanceof Error) {
+        budgetError.message += ` (caused by: ${err.message})`;
+      }
+    };
+    let lastToolFailed = null;
+    const unsub = [];
+    unsub.push(
+      events.on("tool.executed", (e) => {
+        if (hasExplicitTelemetryTask) {
+          opts.hostEvents?.emit("subagent.tool_executed", {
+            sessionId: e.sessionId,
+            subagentId: ctx.subagentId,
+            agentSessionId: e.sessionId,
+            agentName: e.agentName ?? ctx.config.name,
+            taskId: telemetryTaskId,
+            runId: telemetryRunId,
+            traceId: e.traceId,
+            id: e.id,
+            name: e.name,
+            durationMs: e.durationMs,
+            ok: e.ok,
+            // Raw tool inputs may contain credentials or sensitive arguments.
+            // Task telemetry crosses from the isolated worker bus to the shared
+            // host bus, so expose only execution metadata at this boundary.
+            outputBytes: e.outputBytes,
+            outputTokens: e.outputTokens,
+            outputLines: e.outputLines
+          });
+        }
+        try {
+          ctx.budget.recordToolCall();
+        } catch (eb) {
+          onBudgetError(eb);
+        }
+        if (e.ok === false) {
+          lastToolFailed = e.name;
+        } else if (e.ok === true) {
+          lastToolFailed = null;
+        }
+      }),
+      events.on("file.event", (e) => {
+        if (!hasExplicitTelemetryTask) return;
+        if (e.runId === telemetryRunId && e.taskId === telemetryTaskId) return;
+        opts.hostEvents?.emit("file.event", {
+          ...e,
+          scope: "task",
+          taskId: telemetryTaskId,
+          boardId: telemetryBoardId,
+          runId: telemetryRunId
+        });
+      }),
+      events.on("provider.response", (e) => {
+        try {
+          ctx.budget.recordUsage(e.usage);
+        } catch (e2) {
+          void onBudgetError(e2);
+        }
+      }),
+      events.on("iteration.started", () => {
+        try {
+          ctx.budget.recordIteration();
+        } catch (e) {
+          void onBudgetError(e);
+        }
+        const u = ctx.budget.usage();
+        const since = u.iterations - lastSummaryAtIteration;
+        if (since >= SUMMARY_INTERVAL) {
+          lastSummaryAtIteration = u.iterations;
+          events.emit("subagent.iteration_summary", {
+            subagentId: ctx.subagentId,
+            iteration: u.iterations,
+            toolCalls: u.toolCalls,
+            costUsd: u.costUsd,
+            currentTool: currentToolName,
+            partialText: streamingTextAcc.trim() || void 0
+          });
+        }
+      }),
+      // D3: cooperative timeout enforcement DURING a long tool call.
+      // The iteration-loop checkTimeout() only fires between agent
+      // iterations — a single `bash sleep 3600` call would otherwise
+      // park inside one tool execution while the timeout silently
+      // passes, relying solely on the coordinator's hard Promise.race
+      // to interrupt. Tools that emit `tool.progress` (bash chunks,
+      // fetch byte progress, spawn-stream stdout) give us a heartbeat
+      // we can hang the check on. When the budget trips here:
+      //   1. onBudgetError sets budgetError + aborter.abort()
+      //   2. aborter signal propagates to agent.run → tool executor
+      //   3. tool's own signal listener kills the child process
+      // Cheap: O(1) per progress event, and the budget short-circuits
+      // when timeoutMs is unset (most subagents have one set anyway).
+      events.on("tool.progress", () => {
+        ctx.budget.markActivity();
+        try {
+          ctx.budget.checkTimeout();
+        } catch (e) {
+          void onBudgetError(e);
+        }
+      })
+    );
+    let currentToolName;
+    let streamingTextAcc = "";
+    let lastSummaryAtIteration = 0;
+    const SUMMARY_INTERVAL = 25;
+    unsub.push(
+      events.on("tool.started", (e) => {
+        currentToolName = e.name;
+      }),
+      events.on("provider.text_delta", (e) => {
+        ctx.budget.markActivity();
+        streamingTextAcc = (streamingTextAcc + e.text).slice(-2e3);
+        const text = streamingTextAcc.trim();
+        if (text) {
+          ctx.reportProgress?.({ text, source: "stream", capturedAt: Date.now() });
+        }
+      })
+    );
+    const onParentAbort = () => aborter.abort();
+    ctx.signal.addEventListener("abort", onParentAbort);
+    if (resolveGracefulFinish(ctx.config)) {
+      unsub.push(
+        events.on("subagent.finish_requested", (e) => {
+          if (e.subagentId && e.subagentId !== ctx.subagentId) return;
+          setBtwNote(agent.ctx, e.notice);
+        })
+      );
+    }
+    let result;
+    try {
+      result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
+      const finalText2 = result.finalText?.trim();
+      if (finalText2) {
+        ctx.reportProgress?.({ text: finalText2, source: "run_result", capturedAt: Date.now() });
+      }
+      events.emit("subagent.task_completed", {
+        subagentId: ctx.subagentId,
+        taskId: task.id,
+        status: result.status === "done" ? "success" : "failed",
+        iterations: result.iterations,
+        toolCalls: ctx.budget.usage().toolCalls,
+        durationMs: Date.now() - taskStartedAt,
+        finalText: result.finalText?.trim() || void 0
+      });
+    } finally {
+      detachFleet?.();
+      ctx.signal.removeEventListener("abort", onParentAbort);
+      for (const u of unsub) u();
+      if (factoryResult.dispose) {
+        try {
+          await factoryResult.dispose();
+        } catch {
+        }
+      }
+    }
+    if (budgetError) {
+      if ("decision" in budgetError) {
+        try {
+          const decision = await budgetError.decision;
+          if (decision === "stop") {
+            budgetError = new BudgetExceededError(
+              budgetError.kind,
+              budgetError.limit,
+              budgetError.used
+            );
+          } else {
+            budgetError = null;
+          }
+        } catch {
+          budgetError = new BudgetExceededError(
+            budgetError.kind,
+            budgetError.limit,
+            budgetError.used
+          );
+        }
+      }
+      if (budgetError) throw budgetError;
+    }
+    if (result.status === "failed") {
+      throw result.error instanceof AgentError ? result.error : new AgentError({
+        message: result.error instanceof Error ? result.error.message : String(result.error ?? "agent failed"),
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        cause: result.error
+      });
+    }
+    if (result.status === "aborted") {
+      throw new AgentError({
+        message: "agent aborted",
+        code: ERROR_CODES.AGENT_ABORTED
+      });
+    }
+    if (result.status === "max_iterations") {
+      throw new AgentError({
+        message: "agent exhausted iteration limit",
+        code: ERROR_CODES.AGENT_ITERATION_LIMIT,
+        recoverable: true
+      });
+    }
+    const usage = ctx.budget.usage();
+    const finalText = (result.finalText ?? "").trim();
+    if (finalText.length === 0 && usage.toolCalls === 0) {
+      throw new AgentError({
+        message: "empty response \u2014 agent produced no text and no tool calls",
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        context: { iterations: result.iterations }
+      });
+    }
+    if (finalText.length === 0 && lastToolFailed !== null) {
+      throw new AgentError({
+        message: `unrecovered tool failure: ${lastToolFailed} \u2014 agent ended turn without acknowledging the error`,
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        context: { tool: lastToolFailed, iterations: result.iterations }
+      });
+    }
+    return {
+      result: result.finalText,
+      report: readSubagentStructuredReport(agentContext),
+      iterations: result.iterations,
+      toolCalls: usage.toolCalls
+    };
+  };
+}
+function defaultFormatTaskInput(task) {
+  return task.description ?? "";
+}
+
+// src/coordination/brain-heuristics.ts
+var BLOCKED_RESOLVED_MARKERS = /\b(?:resolved|fixed|completed|unblocked|available|done|merged|landed|shipped)\b/;
+var COMPETING_ALTERNATIVE = /\bor\b/;
+function isBlockedResolved(question, context, markers = BLOCKED_RESOLVED_MARKERS) {
+  return question.includes("blocked") && !COMPETING_ALTERNATIVE.test(question) && markers.test(context);
+}
+var DEFAULT_BRAIN_HEURISTICS = {
+  lowRiskAutoAnswer: true,
+  blockedResolved: true,
+  deadlockSkip: true,
+  retryExhausted: true,
+  continuePing: true
+};
+var escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function compileResolutionMarkers(words) {
+  const cleaned = (words ?? []).map((w) => w.trim()).filter((w) => w.length > 0);
+  if (cleaned.length === 0) return BLOCKED_RESOLVED_MARKERS;
+  return new RegExp(`\\b(?:${cleaned.map(escapeRegex).join("|")})\\b`, "i");
+}
+function resolveBrainHeuristics(cfg) {
+  return {
+    lowRiskAutoAnswer: cfg?.lowRiskAutoAnswer ?? DEFAULT_BRAIN_HEURISTICS.lowRiskAutoAnswer,
+    blockedResolved: cfg?.blockedResolved ?? DEFAULT_BRAIN_HEURISTICS.blockedResolved,
+    deadlockSkip: cfg?.deadlockSkip ?? DEFAULT_BRAIN_HEURISTICS.deadlockSkip,
+    retryExhausted: cfg?.retryExhausted ?? DEFAULT_BRAIN_HEURISTICS.retryExhausted,
+    continuePing: cfg?.continuePing ?? DEFAULT_BRAIN_HEURISTICS.continuePing,
+    blockedResolvedMarkers: compileResolutionMarkers(cfg?.blockedResolvedMarkers)
+  };
+}
+
+// src/coordination/brain-telemetry.ts
+var DETERMINISTIC_BRAIN_TIERS = /* @__PURE__ */ new Set(
+  ["rule", "policy", "heuristic", "cache", "ledger-guard", "terminal"]
+);
+var tierByRequest = /* @__PURE__ */ new WeakMap();
+function markDecisionTier(request, tier) {
+  tierByRequest.set(request, tier);
+}
+function readDecisionTier(request) {
+  return tierByRequest.get(request);
+}
+function isDeterministicTier(tier) {
+  return tier !== void 0 && DETERMINISTIC_BRAIN_TIERS.has(tier);
+}
+var BrainTierCounter = class {
+  counts = /* @__PURE__ */ new Map();
+  total = 0;
+  unattributed = 0;
+  /** Count one decision. `undefined` counts toward `unattributed`. */
+  record(tier) {
+    this.total += 1;
+    if (tier === void 0) {
+      this.unattributed += 1;
+      return;
+    }
+    this.counts.set(tier, (this.counts.get(tier) ?? 0) + 1);
+  }
+  snapshot() {
+    const byTier = {};
+    let deterministic = 0;
+    let llmBacked = 0;
+    for (const [tier, count] of this.counts) {
+      byTier[tier] = count;
+      if (DETERMINISTIC_BRAIN_TIERS.has(tier)) deterministic += count;
+      else if (tier === "council" || tier === "llm") llmBacked += count;
+    }
+    return {
+      byTier,
+      total: this.total,
+      deterministic,
+      llmBacked,
+      unattributed: this.unattributed
+    };
+  }
+  reset() {
+    this.counts.clear();
+    this.total = 0;
+    this.unattributed = 0;
+  }
+};
+
+// src/coordination/brain.ts
+var BRAIN_RISK_LEVELS = {
+  low: 0,
+  medium: 1,
+  high: 2,
+  critical: 3
+};
+var ObservableBrainArbiter = class {
+  constructor(inner, events) {
+    this.inner = inner;
+    this.events = events;
+  }
+  inner;
+  events;
+  async decide(request) {
+    this.events.emit("brain.decision_requested", { sessionId: request.sessionId, request, at: Date.now() });
+    const decision = await this.inner.decide(request);
+    const event = decision.type === "ask_human" ? "brain.decision_ask_human" : decision.type === "deny" ? "brain.decision_denied" : "brain.decision_answered";
+    const tier = readDecisionTier(request);
+    this.events.emit(event, {
+      sessionId: request.sessionId,
+      request,
+      decision,
+      at: Date.now(),
+      ...tier ? { tier } : {}
+    });
+    return decision;
+  }
+};
+var BrainDecisionQueue = class {
+  constructor(events, opts = {}) {
+    this.events = events;
+    this.opts = opts;
+    this.offAnswer = this.events.on("brain.human_answered", (answer) => {
+      const pending = this.pending.get(answer.id);
+      if (!pending) return;
+      this.pending.delete(answer.id);
+      if (pending.timer) clearTimeout(pending.timer);
+      markDecisionTier(pending.request, "human");
+      if (answer.deny) {
+        pending.resolve({ type: "deny", reason: answer.text ?? "Denied by human." });
+        return;
+      }
+      const option = pending.request.options?.find((o) => o.id === answer.optionId);
+      pending.resolve({
+        type: "answer",
+        optionId: answer.optionId,
+        text: answer.text ?? option?.label ?? answer.optionId ?? "Human answered.",
+        rationale: "Human answered a Brain escalation prompt."
+      });
+    });
+  }
+  events;
+  opts;
+  pending = /* @__PURE__ */ new Map();
+  offAnswer;
+  async requestHumanDecision(request) {
+    const ask = {
+      type: "ask_human",
+      prompt: formatHumanPrompt(request),
+      options: request.options,
+      rationale: "Decision escalated to human authority."
+    };
+    const pending = new Promise((resolve) => {
+      const entry = { request, resolve };
+      if (this.opts.timeoutMs && this.opts.timeoutMs > 0) {
+        entry.timer = setTimeout(() => {
+          this.pending.delete(request.id);
+          markDecisionTier(request, "terminal");
+          resolve(
+            this.opts.onTimeout?.(request) ?? {
+              type: "deny",
+              reason: "Brain human decision timed out."
+            }
+          );
+        }, this.opts.timeoutMs);
+      }
+      this.pending.set(request.id, entry);
+    });
+    this.events.emit("brain.decision_ask_human", { sessionId: request.sessionId, request, decision: ask, at: Date.now() });
+    return pending;
+  }
+  dispose() {
+    this.offAnswer();
+    for (const [id, pending] of this.pending) {
+      if (pending.timer) clearTimeout(pending.timer);
+      pending.resolve({ type: "deny", reason: "Brain decision queue disposed." });
+      this.pending.delete(id);
+    }
+  }
+};
+function terminalPolicyDecision(request, policy = "conservative") {
+  if (policy === "deny-all") {
+    return {
+      type: "deny",
+      reason: `Headless terminal policy "deny-all": "${request.question}" was not auto-approved (risk: ` + request.risk + "). The proposed action was not taken."
+    };
+  }
+  const recommended = request.options?.find((option) => option.recommended);
+  const acceptRecommended = recommended !== void 0 && (policy === "continue-on-recommended" || request.risk === "low" || request.risk === "medium");
+  if (recommended && acceptRecommended) {
+    return {
+      type: "answer",
+      optionId: recommended.id,
+      text: recommended.label,
+      rationale: `Headless terminal policy: caller-recommended option accepted at ${request.risk} risk (no human available by configuration).`
+    };
+  }
+  if (request.fallback === "continue") {
+    return {
+      type: "answer",
+      text: "Continue with the caller default.",
+      rationale: "Headless terminal policy: request declares continue as its safe fallback."
+    };
+  }
+  return {
+    type: "deny",
+    reason: `Headless terminal policy: no safe automatic option for "${request.question}" (risk: ${request.risk}). The proposed action was not taken.`
+  };
+}
+var EscalationRoutingBrainArbiter = class {
+  constructor(inner, queue, getMode, getTerminalPolicy) {
+    this.inner = inner;
+    this.queue = queue;
+    this.getMode = getMode;
+    this.getTerminalPolicy = getTerminalPolicy;
+  }
+  inner;
+  queue;
+  getMode;
+  getTerminalPolicy;
+  async decide(request) {
+    const decision = await this.inner.decide(request);
+    if (decision.type !== "ask_human") return decision;
+    if (this.getMode() === "interactive" && this.queue) {
+      return this.queue.requestHumanDecision(request);
+    }
+    markDecisionTier(request, "terminal");
+    return terminalPolicyDecision(request, this.getTerminalPolicy?.() ?? "conservative");
+  }
+};
+var HumanEscalatingBrainArbiter = class {
+  constructor(inner, queue) {
+    this.inner = inner;
+    this.queue = queue;
+  }
+  inner;
+  queue;
+  async decide(request) {
+    const decision = await this.inner.decide(request);
+    if (decision.type !== "ask_human") return decision;
+    return this.queue.requestHumanDecision(request);
+  }
+};
+var DefaultBrainArbiter = class {
+  heuristics;
+  constructor(opts = {}) {
+    const resolved = resolveBrainHeuristics(opts.heuristics);
+    this.heuristics = {
+      ...resolved,
+      lowRiskAutoAnswer: opts.allowLowRiskAutoAnswer ?? resolved.lowRiskAutoAnswer
+    };
+  }
+  async decide(request) {
+    const recommended = request.options?.find((option) => option.recommended);
+    if (this.heuristics.lowRiskAutoAnswer && request.risk === "low" && recommended) {
+      markDecisionTier(request, "heuristic");
+      return {
+        type: "answer",
+        optionId: recommended.id,
+        text: recommended.label,
+        rationale: "Low-risk request with an explicit recommended option."
+      };
+    }
+    if (this.heuristics.blockedResolved && !request.options?.length && request.fallback === "continue" && request.context) {
+      if (isBlockedResolved(
+        request.question.toLowerCase(),
+        request.context.toLowerCase(),
+        this.heuristics.blockedResolvedMarkers
+      )) {
+        markDecisionTier(request, "heuristic");
+        return {
+          type: "answer",
+          text: "Blocker resolved. Continue with the previously blocked work.",
+          rationale: "Heuristic: blocking dependency explicitly resolved \u2014 resuming."
+        };
+      }
+    }
+    markDecisionTier(request, "policy");
+    switch (request.fallback) {
+      case "deny":
+        return {
+          type: "deny",
+          reason: `Brain could not safely decide: ${request.question}`
+        };
+      case "continue":
+        return {
+          type: "answer",
+          text: "Continue with the caller default.",
+          rationale: "No safe Brain decision was available; request fallback is continue."
+        };
+      case "ask_human":
+        return {
+          type: "ask_human",
+          prompt: formatHumanPrompt(request),
+          options: request.options,
+          rationale: "Decision requires human authority or lacks a safe automatic option."
+        };
+      default:
+        return {
+          type: "deny",
+          reason: `Brain could not safely decide (unknown fallback: ${String(request.fallback)}): ${request.question}`
+        };
+    }
+  }
+};
+function formatHumanPrompt(request) {
+  const lines = [
+    `Brain requires human decision for ${request.source}:`,
+    `Question: ${request.question}`
+  ];
+  if (request.context?.trim()) {
+    lines.push("", "Context:", request.context.trim());
+  }
+  if (request.options?.length) {
+    lines.push("", "Options:");
+    for (const option of request.options) {
+      const risk = option.risk ? ` [risk: ${option.risk}]` : "";
+      const consequence = option.consequence ? ` \u2014 ${option.consequence}` : "";
+      lines.push(`- ${option.id}: ${option.label}${risk}${consequence}`);
+    }
+  }
+  lines.push("", `Risk: ${request.risk}`);
+  return lines.join("\n");
+}
+
+// src/coordination/brain-ledger.ts
+import { createReadStream } from "node:fs";
+import { access, appendFile, mkdir, rename, stat } from "node:fs/promises";
+import { dirname } from "node:path";
+import { createInterface } from "node:readline";
+var QUESTION_MAX = 200;
+var DETAIL_MAX = 240;
+var truncate = (s, max) => s === void 0 ? void 0 : s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+function brainDecisionKey(source, question) {
+  const normalized = question.toLowerCase().replace(/[^\s]*\d[^\s]*/g, "#").replace(/\s+/g, " ").trim().slice(0, 100);
+  return `${source ?? "?"}:${normalized}`;
+}
+function fmtAge(ms) {
+  const s = Math.max(0, Math.round(ms / 1e3));
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.round(s / 60)}m ago`;
+  return `${Math.round(s / 3600)}h ago`;
+}
+function createLedgerGuardBrainArbiter(opts) {
+  const denyAfter = opts.denyAfter ?? 3;
+  return {
+    async decide(request) {
+      if (denyAfter > 0) {
+        const streak = opts.failureStreakFor(request);
+        if (streak >= denyAfter) {
+          markDecisionTier(request, "ledger-guard");
+          return {
+            type: "deny",
+            reason: `Ledger guard: the last ${streak} approved decisions of this kind all ended in observed failures \u2014 denying deterministically until a success is recorded. (${request.question.slice(0, 120)})`
+          };
+        }
+      }
+      return opts.inner.decide(request);
+    }
+  };
+}
+var BrainDecisionLedger = class _BrainDecisionLedger {
+  constructor(opts) {
+    this.opts = opts;
+    this.maxMemoryEntries = opts.maxMemoryEntries ?? 500;
+    this.retryWindowMs = opts.interventionRetryWindowMs ?? 10 * 6e4;
+    this.now = opts.now ?? Date.now;
+  }
+  opts;
+  entries = [];
+  outcomeByRequest = /* @__PURE__ */ new Map();
+  /** subagentId → decision request ids awaiting that subagent's task result. */
+  pendingBudgetOutcomes = /* @__PURE__ */ new Map();
+  lastInterventionByKind = /* @__PURE__ */ new Map();
+  unsubscribers = [];
+  /** Serialized fire-and-forget writes — awaited by `stop()` (drain). */
+  writeChain = Promise.resolve();
+  pendingWriteCount = 0;
+  pendingWriteBytes = 0;
+  static MAX_PENDING_WRITES = 1e3;
+  static MAX_PENDING_WRITE_BYTES = 8 * 1024 * 1024;
+  /** Rotate the JSONL to `.1` past this size so it can't grow unbounded. */
+  static MAX_FILE_BYTES = 5 * 1024 * 1024;
+  /** Stat the file for rotation only once per this many writes. */
+  static ROTATE_CHECK_EVERY = 100;
+  writesSinceRotateCheck = 0;
+  dirReady = false;
+  maxMemoryEntries;
+  retryWindowMs;
+  now;
+  /**
+   * Subscribe to the EventBus and seed the in-memory ring from the JSONL
+   * tail. The returned promise resolves once the seed load finished
+   * (best-effort — a missing/corrupt file is an empty history, not an error).
+   */
+  async start() {
+    const { events } = this.opts;
+    this.unsubscribers.push(
+      events.on("brain.decision_answered", (e) => {
+        this.record({
+          at: e.at,
+          sessionId: e.sessionId,
+          requestId: e.request.id,
+          kind: "answered",
+          source: e.request.source,
+          risk: e.request.risk,
+          question: truncate(e.request.question, QUESTION_MAX),
+          optionId: e.decision.type === "answer" ? e.decision.optionId : void 0,
+          detail: e.decision.type === "answer" ? truncate(e.decision.rationale ?? e.decision.text, DETAIL_MAX) : void 0
+        });
+      }),
+      events.on("brain.decision_denied", (e) => {
+        this.record({
+          at: e.at,
+          sessionId: e.sessionId,
+          requestId: e.request.id,
+          kind: "denied",
+          source: e.request.source,
+          risk: e.request.risk,
+          question: truncate(e.request.question, QUESTION_MAX),
+          detail: e.decision.type === "deny" ? truncate(e.decision.reason, DETAIL_MAX) : void 0
+        });
+      }),
+      events.on("brain.decision_ask_human", (e) => {
+        this.record({
+          at: e.at,
+          sessionId: e.sessionId,
+          requestId: e.request.id,
+          kind: "ask_human",
+          source: e.request.source,
+          risk: e.request.risk,
+          question: truncate(e.request.question, QUESTION_MAX)
+        });
+      }),
+      events.on("brain.intervention", (e) => {
+        this.record({
+          at: e.at,
+          sessionId: e.sessionId,
+          requestId: e.request.id,
+          kind: "intervention",
+          source: e.request.source,
+          risk: e.request.risk,
+          question: truncate(`[${e.kind}] ${e.request.question}`, QUESTION_MAX),
+          detail: e.intervened ? "steered" : "observed only"
+        });
+        if (!e.intervened) return;
+        const prev = this.lastInterventionByKind.get(e.kind);
+        if (prev && e.at - prev.at <= this.retryWindowMs) {
+          this.recordOutcome(
+            prev.requestId,
+            "failure",
+            `same signal (${e.kind}) re-triggered ${fmtAge(e.at - prev.at).replace(" ago", " later")}`,
+            e.sessionId
+          );
+        }
+        this.lastInterventionByKind.set(e.kind, { requestId: e.request.id, at: e.at });
+      }),
+      // ── Outcome correlation: budget extensions ────────────────────────
+      events.on("subagent.budget_extended", (e) => {
+        const requestId = `director-budget-${e.subagentId}-${e.kind}`;
+        if (!this.entries.some((entry) => entry.requestId === requestId)) return;
+        let set = this.pendingBudgetOutcomes.get(e.subagentId);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this.pendingBudgetOutcomes.set(e.subagentId, set);
+        }
+        set.add(requestId);
+      }),
+      events.on("subagent.task_completed", (e) => {
+        const pending = this.pendingBudgetOutcomes.get(e.subagentId);
+        if (!pending) return;
+        this.pendingBudgetOutcomes.delete(e.subagentId);
+        const outcome = e.status === "success" ? "success" : "failure";
+        for (const requestId of pending) {
+          this.recordOutcome(
+            requestId,
+            outcome,
+            `budget-extended subagent's task ${e.status}`,
+            e.sessionId
+          );
+        }
+      })
+    );
+    await this.load();
+  }
+  /** Unsubscribe and drain pending writes. Safe to call twice. */
+  async stop() {
+    for (const off of this.unsubscribers) off();
+    this.unsubscribers.length = 0;
+    await this.writeChain.catch(() => {
+    });
+  }
+  /**
+   * Attach a real-world outcome to an earlier decision. Appended to the
+   * JSONL, folded into future digests, and re-emitted as `brain.outcome`.
+   */
+  recordOutcome(requestId, outcome, detail, sessionId) {
+    this.outcomeByRequest.set(requestId, outcome);
+    this.record({
+      at: this.now(),
+      sessionId,
+      requestId,
+      kind: "outcome",
+      outcome,
+      detail: truncate(detail, DETAIL_MAX)
+    });
+    this.opts.events.emit("brain.outcome", {
+      sessionId,
+      requestId,
+      outcome,
+      detail,
+      at: this.now()
+    });
+  }
+  /** Last `n` ledger rows, oldest first. */
+  tail(n) {
+    return this.entries.slice(-n);
+  }
+  /**
+   * Consecutive most-recent FAILURE outcomes among answered decisions of
+   * this request's group. Decisions whose outcome is still unknown are
+   * skipped (they neither extend nor break the streak); the first known
+   * SUCCESS ends it. Powers the deterministic ledger guard: "the last K
+   * times we approved this, it went wrong — stop approving".
+   */
+  failureStreakFor(request) {
+    const key = brainDecisionKey(request.source, request.question);
+    let streak = 0;
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const e = this.entries[i];
+      if (e?.kind !== "answered" || e.requestId === request.id || e.question === void 0 || brainDecisionKey(e.source, e.question) !== key) {
+        continue;
+      }
+      const outcome = this.outcomeByRequest.get(e.requestId);
+      if (outcome === void 0) continue;
+      if (outcome === "success") break;
+      streak += 1;
+    }
+    return streak;
+  }
+  /**
+   * Short decision-history block for the LLM/council prompt: how similar
+   * past decisions went and — when known — how they turned OUT. Returns
+   * undefined when there is no relevant history (no prompt noise).
+   */
+  digestFor(request) {
+    const key = brainDecisionKey(request.source, request.question);
+    const related = this.entries.filter(
+      (e) => (e.kind === "answered" || e.kind === "denied") && e.requestId !== request.id && e.question !== void 0 && brainDecisionKey(e.source, e.question) === key
+    );
+    if (related.length === 0) return void 0;
+    const recent = related.slice(-5).reverse();
+    const now = this.now();
+    const lines = recent.map((e) => {
+      const what = e.kind === "denied" ? "denied" : e.optionId ? `chose [${e.optionId}]` : "answered";
+      const outcome = this.outcomeByRequest.get(e.requestId);
+      const suffix = outcome === "failure" ? " \u2192 later FAILED" : outcome === "success" ? " \u2192 later succeeded" : "";
+      return `- ${fmtAge(now - e.at)}: ${what}${suffix}`;
+    });
+    const approved = related.filter((e) => e.kind === "answered");
+    const failedAfter = approved.filter(
+      (e) => this.outcomeByRequest.get(e.requestId) === "failure"
+    ).length;
+    const summary = `Summary: ${related.length} similar decision(s); ${approved.length} answered${failedAfter > 0 ? ` (${failedAfter} later failed)` : ""}, ${related.length - approved.length} denied.`;
+    return [...lines, summary].join("\n");
+  }
+  // ── Private ───────────────────────────────────────────────────────────
+  record(entry) {
+    this.entries.push(entry);
+    if (this.entries.length > this.maxMemoryEntries) {
+      const evictedRequestIds = /* @__PURE__ */ new Set();
+      const evictCount = this.entries.length - this.maxMemoryEntries;
+      const evicted = this.entries.splice(0, evictCount);
+      for (const e of evicted) {
+        if (e.requestId) evictedRequestIds.add(e.requestId);
+      }
+      if (evictedRequestIds.size > 0) {
+        const remainingRequestIds = /* @__PURE__ */ new Set();
+        for (const e of this.entries) {
+          if (e.requestId) remainingRequestIds.add(e.requestId);
+        }
+        for (const id of evictedRequestIds) {
+          if (!remainingRequestIds.has(id)) this.outcomeByRequest.delete(id);
+        }
+      }
+    }
+    this.append(entry);
+  }
+  append(entry) {
+    let line;
+    try {
+      line = `${JSON.stringify(entry)}
+`;
+    } catch {
+      return;
+    }
+    const bytes = Buffer.byteLength(line, "utf8");
+    if (this.pendingWriteCount >= _BrainDecisionLedger.MAX_PENDING_WRITES || bytes > _BrainDecisionLedger.MAX_PENDING_WRITE_BYTES || this.pendingWriteBytes + bytes > _BrainDecisionLedger.MAX_PENDING_WRITE_BYTES) {
+      return;
+    }
+    this.pendingWriteCount += 1;
+    this.pendingWriteBytes += bytes;
+    this.writeChain = this.writeChain.then(async () => {
+      if (!this.dirReady) {
+        await mkdir(dirname(this.opts.filePath), { recursive: true });
+        this.dirReady = true;
+      }
+      await this.maybeRotate();
+      await appendFile(this.opts.filePath, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
+    }).catch(() => {
+    }).finally(() => {
+      this.pendingWriteCount = Math.max(0, this.pendingWriteCount - 1);
+      this.pendingWriteBytes = Math.max(0, this.pendingWriteBytes - bytes);
+    });
+  }
+  /**
+   * Size-bounded rotation: past {@link MAX_FILE_BYTES} the file moves to a
+   * single `.1` sibling (previous `.1` is overwritten), bounding disk to
+   * ~2× the cap. Checked once per {@link ROTATE_CHECK_EVERY} writes; runs on
+   * the write chain, so it never races an append. The ring `load()` reads
+   * only the tail, so rotation never costs queryable history.
+   */
+  async maybeRotate() {
+    this.writesSinceRotateCheck += 1;
+    if (this.writesSinceRotateCheck < _BrainDecisionLedger.ROTATE_CHECK_EVERY) return;
+    this.writesSinceRotateCheck = 0;
+    try {
+      const info = await stat(this.opts.filePath);
+      if (info.size < _BrainDecisionLedger.MAX_FILE_BYTES) return;
+      await rename(this.opts.filePath, `${this.opts.filePath}.1`);
+    } catch {
+    }
+  }
+  /** Seed the in-memory ring from the JSONL tail (cross-session learning). */
+  async load() {
+    try {
+      await access(this.opts.filePath);
+    } catch {
+      return;
+    }
+    const seed = [];
+    const input = createReadStream(this.opts.filePath, { encoding: "utf8" });
+    const lines = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+    try {
+      for await (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (typeof parsed?.requestId === "string" && typeof parsed.at === "number") {
+            seed.push(parsed);
+            if (seed.length > this.maxMemoryEntries) seed.shift();
+          }
+        } catch {
+        }
+      }
+    } catch {
+      return;
+    } finally {
+      lines.close();
+      input.destroy();
+    }
+    this.entries.unshift(...seed);
+    if (this.entries.length > this.maxMemoryEntries) {
+      this.entries.splice(0, this.entries.length - this.maxMemoryEntries);
+    }
+    for (const e of this.entries) {
+      if (e.kind === "outcome" && e.outcome) this.outcomeByRequest.set(e.requestId, e.outcome);
+    }
+  }
+};
+
+// src/coordination/dispatcher.ts
+var DEFAULT_DISPATCH_ROLE = "executor";
+var FALLBACK_DEFINITION = {
+  config: { role: "unknown", name: "Unknown Agent" },
+  budget: {},
+  capability: { phase: "meta", summary: "", keywords: [] }
+};
+function normalize(text) {
+  return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
+}
+function scoreAgents(task, catalog = AGENT_CATALOG) {
+  const haySet = new Set(normalize(task).split(/\s+/).filter(Boolean));
+  const out = [];
+  for (const def of Object.values(catalog)) {
+    if (!def?.config?.role) continue;
+    let score = 0;
+    const matched = [];
+    for (const kw of def.capability.keywords) {
+      const needleWords = normalize(kw).split(/\s+/).filter(Boolean);
+      const allPresent = needleWords.every((w) => haySet.has(w));
+      if (allPresent) {
+        score += needleWords.length;
+        matched.push(kw);
+      }
+    }
+    if (score > 0) {
+      out.push({ role: def.config.role, name: def.config.name, score, matched });
+    }
+  }
+  out.sort((a, b) => b.score - a.score);
+  return out;
+}
+function heuristicConfidence(candidates) {
+  if (candidates.length === 0) return 0;
+  const top = candidates[0]?.score ?? 0;
+  const second = candidates[1]?.score ?? 0;
+  const strength = Math.min(1, top / 3);
+  const margin = (top - second + 1) / (top + 1);
+  return Math.min(1, strength * margin);
+}
+async function dispatchAgent(task, opts = {}) {
+  const catalog = opts.catalog ?? AGENT_CATALOG;
+  const threshold = opts.confidenceThreshold ?? 0.4;
+  const maxCandidates = opts.maxCandidates ?? 6;
+  const candidates = scoreAgents(task, catalog);
+  const confidence = heuristicConfidence(candidates);
+  const top = candidates[0];
+  if (top && confidence >= threshold) {
+    return {
+      role: top.role,
+      definition: catalog[top.role] ?? FALLBACK_DEFINITION,
+      confidence,
+      method: "heuristic",
+      reason: `Matched keywords: ${top.matched.slice(0, 4).join(", ")}`,
+      alternatives: candidates.slice(1, maxCandidates)
+    };
+  }
+  if (opts.classifier) {
+    const pool = (candidates.length > 0 ? candidates.slice(0, maxCandidates).map((c) => catalog[c.role] ?? FALLBACK_DEFINITION) : Object.values(catalog)).map((d) => ({
+      role: d.config.role,
+      name: d.config.name,
+      summary: d.capability.summary
+    }));
+    try {
+      const choice = await opts.classifier(task, pool);
+      if (choice && catalog[choice.role]) {
+        return {
+          role: choice.role,
+          definition: catalog[choice.role] ?? FALLBACK_DEFINITION,
+          confidence: 1,
+          method: "llm",
+          reason: choice.reason ?? "Selected by LLM classifier",
+          alternatives: candidates.slice(0, maxCandidates).filter((c) => c.role !== choice.role)
+        };
+      }
+    } catch {
+    }
+  }
+  if (top) {
+    return {
+      role: top.role,
+      definition: catalog[top.role] ?? FALLBACK_DEFINITION,
+      confidence,
+      method: "heuristic",
+      reason: `Weak match (${top.matched.slice(0, 3).join(", ") || "low signal"})`,
+      alternatives: candidates.slice(1, maxCandidates)
+    };
+  }
+  const fallbackRole = catalog[DEFAULT_DISPATCH_ROLE] ? DEFAULT_DISPATCH_ROLE : Object.keys(catalog)[0] ?? DEFAULT_DISPATCH_ROLE;
+  return {
+    role: fallbackRole,
+    definition: catalog[fallbackRole] ?? FALLBACK_DEFINITION,
+    confidence: 0,
+    method: "fallback",
+    reason: "No keyword signal; defaulting to the generalist Executor",
+    alternatives: []
+  };
+}
+function makeLLMClassifier(complete) {
+  return async (task, candidates) => {
+    const list = candidates.map((c, i) => `${i + 1}. ${c.role} \u2014 ${c.summary}`).join("\n");
+    const prompt = renderInstructionTemplate(readBundledInstructionText("llm/agent-router.md"), {
+      task,
+      agents: list
+    });
+    const raw = (await complete(prompt)).trim();
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) return null;
+    const parsed = safeParse(
+      match[0]
+    );
+    if (!parsed.ok || !parsed.value || typeof parsed.value.role !== "string") return null;
+    const role = parsed.value.role.trim();
+    const valid = candidates.some((c) => c.role === role);
+    if (!valid) return null;
+    return {
+      role,
+      reason: typeof parsed.value.reason === "string" ? parsed.value.reason : void 0
+    };
+  };
+}
+
+// src/coordination/subagent-nicknames.ts
+var NICKNAME_POOL = {
+  // Physics & fundamental sciences
+  "einstein": { name: "Einstein", domain: "physics" },
+  "newton": { name: "Newton", domain: "physics" },
+  "feynman": { name: "Feynman", domain: "physics" },
+  "dirac": { name: "Dirac", domain: "physics" },
+  "bohr": { name: "Bohr", domain: "physics" },
+  "planck": { name: "Planck", domain: "physics" },
+  "curie": { name: "Curie", domain: "physics" },
+  "fermi": { name: "Fermi", domain: "physics" },
+  "heisenberg": { name: "Heisenberg", domain: "physics" },
+  "schrodinger": { name: "Schr\xF6dinger", domain: "physics" },
+  // Mathematics
+  "euclid": { name: "Euclid", domain: "math" },
+  "gauss": { name: "Gauss", domain: "math" },
+  "turing": { name: "Turing", domain: "math" },
+  "poincare": { name: "Poincar\xE9", domain: "math" },
+  "riemann": { name: "Riemann", domain: "math" },
+  "hilbert": { name: "Hilbert", domain: "math" },
+  "pythagoras": { name: "Pythagoras", domain: "math" },
+  // Computing & information theory
+  "von-neumann": { name: "Von Neumann", domain: "computing" },
+  "shannon": { name: "Shannon", domain: "computing" },
+  "hopper": { name: "Hopper", domain: "computing" },
+  "backus": { name: "Backus", domain: "computing" },
+  "knuth": { name: "Knuth", domain: "computing" },
+  "torvalds": { name: "Torvalds", domain: "computing" },
+  "stallman": { name: "Stallman", domain: "computing" },
+  "berners-lee": { name: "Berners-Lee", domain: "computing" },
+  "babbage": { name: "Babbage", domain: "computing" },
+  "lovelace": { name: "Lovelace", domain: "computing" },
+  "klein": { name: "Klein", domain: "computing" },
+  // Electronics & electrical engineering
+  "edison": { name: "Edison", domain: "ee" },
+  "tesla": { name: "Tesla", domain: "ee" },
+  "faraday": { name: "Faraday", domain: "ee" },
+  "maxwell": { name: "Maxwell", domain: "ee" },
+  "ohm": { name: "Ohm", domain: "ee" },
+  "bell": { name: "Bell", domain: "ee" },
+  "marconi": { name: "Marconi", domain: "ee" },
+  "lamarr": { name: "Lamarr", domain: "ee" },
+  // General science / multi-disciplinary
+  "darwin": { name: "Darwin", domain: "biology" },
+  "mendel": { name: "Mendel", domain: "biology" },
+  "pasteur": { name: "Pasteur", domain: "biology" },
+  "hawking": { name: "Hawking", domain: "cosmology" },
+  "sagan": { name: "Sagan", domain: "cosmology" },
+  // Exploration & navigation
+  "columbus": { name: "Columbus", domain: "exploration" },
+  "polo": { name: "Polo", domain: "exploration" },
+  "magellan": { name: "Magellan", domain: "exploration" },
+  // Chemistry / materials
+  "lavoisier": { name: "Lavoisier", domain: "chemistry" },
+  "mendeleev": { name: "Mendeleev", domain: "chemistry" }
+};
+var ALL_NICKNAMES = Object.entries(NICKNAME_POOL);
+var NAME_TO_KEY = Object.fromEntries(
+  ALL_NICKNAMES.map(([key, entry]) => [entry.name, key])
+);
+var DOMAIN_PREFERENCES = {
+  "security": ["shannon", "turing", "lamarr", "stallman"],
+  "bug-hunter": ["darwin", "curie", "feynman", "fermi"],
+  "refactor": ["gauss", "hilbert", "euclid", "planck"],
+  "audit-log": ["sagan", "hawking", "poincare", "newton"],
+  "planner": ["hilbert", "gauss", "turing", "euclid"],
+  "researcher": ["sagan", "hawking", "darwin", "pasteur"],
+  "explorer": ["marconi", "bell", "columbus", "polo"],
+  "testing": ["pasteur", "curie", "fermi", "bohr"],
+  "frontend": ["lovelace", "hopper", "babbage", "backus"],
+  "backend": ["torvalds", "stallman", "von-neumann", "backus"],
+  "database": ["turing", "shannon", "backus", "knuth"],
+  "devops": ["tesla", "edison", "faraday", "bell"],
+  "security-scanner": ["shannon", "turing", "lamarr", "stallman"],
+  "refactor-planner": ["gauss", "hilbert", "planck", "newton"],
+  "architect": ["von-neumann", "turing", "gauss", "hilbert"],
+  "critic": ["einstein", "feynman", "dirac", "bohr"],
+  "e2e": ["hopper", "bell", "marconi", "tesla"],
+  "performance": ["knuth", "gauss", "planck", "feynman"],
+  "chaos": ["tesla", "edison", "curie", "fermi"],
+  "cost": ["ohm", "bell", "marconi", "tesla"],
+  // default fallback
+  "default": ["einstein", "newton", "curie", "tesla", "edison", "turing", "shannon", "hopper", "knuth", "stallman"]
+};
+function assignNickname(role, used) {
+  const preferences = [
+    ...DOMAIN_PREFERENCES[role] ?? [],
+    ...DOMAIN_PREFERENCES["default"] ?? []
+  ];
+  for (const key of preferences) {
+    const entry = NICKNAME_POOL[key];
+    if (entry && !used.has(key)) {
+      return { key, display: `${entry.name} (${formatRole(role)})` };
+    }
+  }
+  for (const [key, entry] of ALL_NICKNAMES) {
+    if (!used.has(key)) {
+      return { key, display: `${entry.name} (${formatRole(role)})` };
+    }
+  }
+  const counter = used.size + 1;
+  return { key: `scientist-${counter}`, display: `Scientist #${counter} (${formatRole(role)})` };
+}
+function nicknameKeyFromDisplay(display) {
+  const base = display.replace(/\s*\([^)]*\)\s*$/, "").trim();
+  const key = NAME_TO_KEY[base];
+  if (key) return key;
+  const synthesized = base.match(/^Scientist #(\d+)$/);
+  return synthesized ? `scientist-${synthesized[1]}` : void 0;
+}
+function formatRole(role) {
+  return role.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+
+// src/coordination/fleet.ts
+function defineAgent(id, name, promptRole = id, provider) {
+  return {
+    id,
+    name,
+    role: id,
+    prompt: agentPrompt(promptRole),
+    ...provider === void 0 ? {} : { provider }
+  };
+}
+var AUDIT_LOG_AGENT = defineAgent("audit-log", "Audit Log");
+var BUG_HUNTER_AGENT = defineAgent("bug-hunter", "Bug Hunter");
+var REFACTOR_PLANNER_AGENT = defineAgent("refactor-planner", "Refactor Planner");
+var SECURITY_SCANNER_AGENT = defineAgent("security-scanner", "Security Scanner");
+var SHADOW_AGENT = {
+  ...defineAgent("shadow-agent", "Shadow"),
+  skillNames: [...SHADOW_AGENT_SKILLS]
+};
+var EXPLORE_COMPANION_AGENT = {
+  ...defineAgent("explore-companion", "Explore Companion"),
+  tools: [...TOOLS.read, ...TOOLS.index],
+  // Read-only, triple-enforced: allowlist has no write/bash, and the
+  // disabled list blocks the escape hatches explicitly.
+  disabledTools: [
+    "write",
+    "edit",
+    "replace",
+    "patch",
+    "bash",
+    "exec",
+    "delegate",
+    "spawn_subagent",
+    "assign_task"
+  ],
+  skillNames: [...ROLE_SKILL_SETS["explore-companion"]],
+  spawnBudgetExempt: true,
+  // Findings travel via mailbox + submit_result, not the leader's stream.
+  textStream: "silent",
+  toolStream: "silent"
+};
+var CHAOS_MONKEY_AGENT = {
+  ...defineAgent("chaos-monkey", "Chaos Monkey"),
+  tools: [...TOOLS.build],
+  skillNames: ["testing", "typescript-strict"],
+  spawnBudgetExempt: true,
+  // Run in the live checkout: mutation targets are usually freshly
+  // written and uncommitted — a worktree spawned from HEAD would not
+  // contain them and every mutant would drift. The mutation_test tool
+  // honors this value as its default; callers can still override per
+  // call via its `chaosWorktree` input when targets are committed and
+  // isolation is wanted.
+  worktree: "off",
+  // Report travels via submit_result + final text, not the leader's stream.
+  textStream: "silent",
+  toolStream: "silent"
+};
+var CRITIC_AGENT = defineAgent("critic", "Critic");
+var GENERIC_AGENT = defineAgent("generic", "Generic Project Agent");
+function withDispatchMetadata(definition) {
+  const summary = definition.capability?.summary?.trim();
+  if (!summary) return definition.config;
+  return {
+    ...definition.config,
+    dispatch: { summary, keywords: [...definition.capability.keywords ?? []] }
+  };
+}
+var FLEET_ROSTER = {
+  "audit-log": AUDIT_LOG_AGENT,
+  "bug-hunter": BUG_HUNTER_AGENT,
+  "refactor-planner": REFACTOR_PLANNER_AGENT,
+  "security-scanner": SECURITY_SCANNER_AGENT,
+  critic: CRITIC_AGENT,
+  generic: GENERIC_AGENT,
+  "shadow-agent": SHADOW_AGENT,
+  "explore-companion": EXPLORE_COMPANION_AGENT,
+  "chaos-monkey": CHAOS_MONKEY_AGENT,
+  ...Object.fromEntries(
+    ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, withDispatchMetadata(d)])
+  )
+};
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
+var FLEET_ROSTER_BUDGETS = {
+  "audit-log": { timeoutMs: 3 * 60 * 60 * 1e3, maxIterations: 2500, maxToolCalls: 7500 },
+  "bug-hunter": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 1e4 },
+  "refactor-planner": { timeoutMs: 4 * 60 * 60 * 1e3, maxIterations: 3e3, maxToolCalls: 9e3 },
+  "security-scanner": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 1e4 },
+  critic: { timeoutMs: 3 * 60 * 60 * 1e3, maxIterations: 2e3, maxToolCalls: 6e3 },
+  generic: { idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS, maxIterations: 2500, maxToolCalls: 7500 },
+  "shadow-agent": {
+    idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+    maxIterations: 1e3,
+    maxToolCalls: 2500,
+    // Monitoring passes routinely include a large system prompt plus fleet
+    // context. 30k was below observed single-pass usage and therefore triggered
+    // a post-response negotiation every run; 96k leaves headroom while the cost
+    // and tool/iteration caps still bound runaway work.
+    maxTokens: 96e3,
+    maxCostUsd: 0.5
+  },
+  "explore-companion": {
+    idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+    maxIterations: 3e3,
+    maxToolCalls: 8e3,
+    maxTokens: 96e3,
+    maxCostUsd: 0.5
+  },
+  "chaos-monkey": {
+    // A mutation pass is many short apply/run/restore cycles — per-mutant
+    // work is tiny, but a large plan (25 mutants/file × N files) needs
+    // headroom. Idle-based reaping covers a stalled pass.
+    idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+    maxIterations: 2e3,
+    maxToolCalls: 6e3,
+    maxTokens: 96e3,
+    maxCostUsd: 0.5
+  },
+  ...Object.fromEntries(
+    ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.budget])
+  )
+};
+var GENERIC_SUBAGENT_BUDGET = {
+  idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+  maxIterations: 2500,
+  maxToolCalls: 7500
+};
+function applyRosterBudget(cfg) {
+  const roleBudget = cfg.role ? FLEET_ROSTER_BUDGETS[cfg.role] : void 0;
+  const defaultBudget = roleBudget ?? (cfg.name ? GENERIC_SUBAGENT_BUDGET : void 0);
+  if (!defaultBudget) return cfg;
+  return {
+    ...cfg,
+    // Wall-clock cap is opt-in only: forward an explicit `cfg.timeoutMs`, but
+    // do NOT impose the roster's historical multi-hour wall-clock default — it
+    // killed agents that were still actively working. Reaping is idle-based.
+    timeoutMs: cfg.timeoutMs,
+    // Idle window is the default reaper. Resets on activity, so a long-but-
+    // productive run is never killed; only a genuine stall is reaped.
+    idleTimeoutMs: cfg.idleTimeoutMs ?? defaultBudget.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS,
+    maxIterations: cfg.maxIterations ?? defaultBudget.maxIterations,
+    maxToolCalls: cfg.maxToolCalls ?? defaultBudget.maxToolCalls,
+    maxTokens: cfg.maxTokens ?? defaultBudget.maxTokens,
+    maxCostUsd: cfg.maxCostUsd ?? defaultBudget.maxCostUsd
+  };
+}
+var ALL_FLEET_AGENTS = Object.values(FLEET_ROSTER);
+var CLINE_AGENT = defineAgent("cline", "Cline", "acp-cline", "acp");
+var GEMINI_CLI_AGENT = defineAgent("gemini-cli", "Gemini CLI", "acp-gemini-cli", "acp");
+var COPILOT_AGENT = defineAgent("copilot", "GitHub Copilot", "acp-copilot", "acp");
+var OPENHANDS_AGENT = defineAgent("openhands", "OpenHands", "acp-openhands", "acp");
+var GOOSE_AGENT = defineAgent("goose", "Goose", "acp-goose", "acp");
+var ACP_AGENTS = [
+  CLINE_AGENT,
+  GEMINI_CLI_AGENT,
+  COPILOT_AGENT,
+  OPENHANDS_AGENT,
+  GOOSE_AGENT
+];
+var ACP_AGENT_BUDGET = {
+  timeoutMs: 10 * 60 * 60 * 1e3,
+  maxIterations: 8e3,
+  maxToolCalls: 2e4
+};
+for (const agent of ACP_AGENTS) {
+  FLEET_ROSTER_BUDGETS[agent.role] = { ...ACP_AGENT_BUDGET };
+}
+var FLEET_ROSTER_WITHACP = {
+  ...FLEET_ROSTER,
+  ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
+};
+
+// src/coordination/multi-agent-coordinator.ts
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+
+// src/coordination/coordinator/error-classifier.ts
+function classifySubagentError(err, hints = {}) {
+  if (err instanceof AgentError && err.cause) {
+    return classifySubagentError(err.cause, hints);
+  }
+  const cause = err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : void 0;
+  if (ProviderError.isProviderError(err)) {
+    const baseMessage2 = err.describe();
+    return providerErrorToSubagentError(err, baseMessage2, cause);
+  }
+  const baseMessage = toErrorMessage(err);
+  if (err instanceof BudgetExceededError) {
+    const map = {
+      iterations: "budget_iterations",
+      tool_calls: "budget_tool_calls",
+      tokens: "budget_tokens",
+      cost: "budget_cost",
+      timeout: "budget_timeout",
+      idle_timeout: "budget_timeout"
+    };
+    return {
+      kind: map[err.kind],
+      message: baseMessage,
+      retryable: false,
+      cause
+    };
+  }
+  if (hints.parentAborted) {
+    return { kind: "aborted_by_parent", message: baseMessage, retryable: false, cause };
+  }
+  const lower = baseMessage.toLowerCase();
+  if (/agent aborted$/i.test(baseMessage)) {
+    return { kind: "aborted_by_parent", message: baseMessage, retryable: false, cause };
+  }
+  if (/agent exhausted iteration limit$/i.test(baseMessage)) {
+    return { kind: "budget_iterations", message: baseMessage, retryable: false, cause };
+  }
+  if (/empty response/i.test(baseMessage)) {
+    return { kind: "empty_response", message: baseMessage, retryable: false, cause };
+  }
+  if (/^tool failed: /i.test(baseMessage)) {
+    return { kind: "tool_failed", message: baseMessage, retryable: false, cause };
+  }
+  if (lower.includes("bridge transport") || /bridge.*(closed|disconnect)/i.test(baseMessage)) {
+    return { kind: "bridge_failed", message: baseMessage, retryable: false, cause };
+  }
+  if (/context length|max.*tokens?.*exceeded|prompt is too long/i.test(baseMessage)) {
+    return { kind: "context_overflow", message: baseMessage, retryable: false, cause };
+  }
+  return { kind: "unknown", message: baseMessage, retryable: false, cause };
+}
+function providerErrorToSubagentError(err, message, cause) {
+  switch (err.kind) {
+    case "rate_limit":
+    case "quota_exhausted":
+      return {
+        kind: "provider_rate_limit",
+        message,
+        retryable: true,
+        backoffMs: err.body?.retryAfterMs ?? 5e3,
+        cause
+      };
+    case "auth":
+      return { kind: "provider_auth", message, retryable: false, cause };
+    case "timeout":
+    case "network":
+      return { kind: "provider_timeout", message, retryable: true, cause };
+    case "overloaded":
+    case "server":
+    case "stream_hang":
+      return { kind: "provider_5xx", message, retryable: true, backoffMs: 3e3, cause };
+    case "context_overflow":
+      return { kind: "context_overflow", message, retryable: false, cause };
+    case "invalid_request":
+    case "content_filter":
+    case "unknown":
+      return { kind: "unknown", message, retryable: err.retryable, cause };
+  }
+}
+
+// src/coordination/multi-agent-timeout.ts
+async function executeSubagentWithTimeout({
+  runner,
+  task,
+  ctx,
+  budget,
+  preemptFraction = TIMEOUT_PREEMPT_FRACTION,
+  abortSubagent,
+  currentSessionId,
+  gracefulFinish
+}) {
+  const initialTimeoutMs = budget.limits.timeoutMs;
+  const idleLimitMs = budget.limits.idleTimeoutMs;
+  if (initialTimeoutMs === void 0 && idleLimitMs === void 0) {
+    return runner(task, ctx);
+  }
+  const start = Date.now();
+  let timer = null;
+  let PreemptState;
+  ((PreemptState2) => {
+    PreemptState2["ACTIVE"] = "active";
+    PreemptState2["LOCKED"] = "locked";
+  })(PreemptState || (PreemptState = {}));
+  let preemptedCeiling = null;
+  let preemptState = "active" /* ACTIVE */;
+  let lastGrantActivityTs = -1;
+  const timeoutPromise = new Promise((_, reject) => {
+    const terminate = (kind, limit, used) => {
+      abortSubagent(ctx.subagentId);
+      reject(
+        budget._events?.hasListenerFor("budget.threshold_reached") ? new Error(`subagent stopped: budget ${kind} (limit=${limit}, used=${used})`) : new BudgetExceededError(kind, limit, used)
+      );
+    };
+    const armFor = (ms) => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(onTick, Math.max(0, ms));
+    };
+    const scheduleNext = () => {
+      const wallLimit = budget.limits.timeoutMs ?? initialTimeoutMs;
+      const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : wallLimit - (Date.now() - start);
+      const idleRemaining = idleLimitMs === void 0 || gracefulFinish !== void 0 && initialTimeoutMs !== void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
+      const preemptRemaining = initialTimeoutMs === void 0 || preemptedCeiling === wallLimit || gracefulFinish !== void 0 ? Number.POSITIVE_INFINITY : wallLimit * preemptFraction - (Date.now() - start);
+      const next = Math.min(wallRemaining, idleRemaining, preemptRemaining);
+      if (!Number.isFinite(next)) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        return;
+      }
+      armFor(Math.max(25, next));
+    };
+    const negotiateTimeout = async (used, limit) => {
+      const handler = budget.onThreshold;
+      if (!handler) return "stop";
+      const result = handler({
+        kind: "timeout",
+        used,
+        limit,
+        requestDecision: () => {
+          if (!budget._events?.hasListenerFor("budget.threshold_reached")) {
+            return Promise.resolve("stop");
+          }
+          return new Promise((resolveDecision) => {
+            let settled = false;
+            const resolve = (d) => {
+              if (settled) return;
+              settled = true;
+              resolveDecision(d);
+            };
+            const fallback = setTimeout(() => resolve("stop"), DECISION_TIMEOUT_MS);
+            const sessionId = currentSessionId();
+            budget._events?.emit("budget.threshold_reached", {
+              ...sessionId ? { sessionId } : {},
+              kind: "timeout",
+              used,
+              limit,
+              timeoutMs: DECISION_TIMEOUT_MS,
+              extend: (extra) => {
+                clearTimeout(fallback);
+                queueMicrotask(() => resolve({ extend: extra }));
+              },
+              deny: () => {
+                clearTimeout(fallback);
+                resolve("stop");
+              }
+            });
+          });
+        }
+      });
+      return typeof result === "string" ? result : await result;
+    };
+    const onTick = async () => {
+      const elapsed = Date.now() - start;
+      const wallLimit = initialTimeoutMs === void 0 ? void 0 : budget.limits.timeoutMs ?? initialTimeoutMs;
+      const idleLimit = idleLimitMs === void 0 ? void 0 : budget.limits.idleTimeoutMs ?? idleLimitMs;
+      const wallExceeded = wallLimit !== void 0 && elapsed >= wallLimit;
+      const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
+      if (idleExceeded && !wallExceeded) {
+        if (gracefulFinish !== void 0 && initialTimeoutMs !== void 0) {
+          scheduleNext();
+          return;
+        }
+        const sessionId = currentSessionId();
+        budget._events?.emit("budget.threshold_reached", {
+          ...sessionId ? { sessionId } : {},
+          kind: "idle_timeout",
+          used: budget.idleMs(),
+          limit: idleLimit ?? 0,
+          timeoutMs: DECISION_TIMEOUT_MS,
+          extend: () => {
+          },
+          deny: () => {
+          }
+        });
+        abortSubagent(ctx.subagentId);
+        reject(new BudgetExceededError("idle_timeout", idleLimit ?? 0, budget.idleMs()));
+        return;
+      }
+      if (wallLimit !== void 0 && !wallExceeded && gracefulFinish === void 0 && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed >= wallLimit * preemptFraction) {
+        const activityTs = Date.now() - budget.idleMs();
+        if (activityTs <= lastGrantActivityTs) {
+          preemptState = "locked" /* LOCKED */;
+          preemptedCeiling = wallLimit;
+          scheduleNext();
+          return;
+        }
+        budget.setWatchdogNegotiation(wallLimit);
+        try {
+          const decision = await negotiateTimeout(elapsed, wallLimit);
+          if (typeof decision !== "string" && decision.extend.timeoutMs !== void 0) {
+            budget.patchLimits({ timeoutMs: decision.extend.timeoutMs });
+            lastGrantActivityTs = Date.now() - budget.idleMs();
+            preemptState = "active" /* ACTIVE */;
+            preemptedCeiling = null;
+          } else {
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
+          }
+        } catch {
+          preemptState = "locked" /* LOCKED */;
+          preemptedCeiling = wallLimit;
+        } finally {
+          budget.clearWatchdogNegotiation();
+        }
+        scheduleNext();
+        return;
+      }
+      if (!wallExceeded) {
+        scheduleNext();
+        return;
+      }
+      const limit = wallLimit ?? 0;
+      if (gracefulFinish !== void 0) {
+        if (!budget.graceGranted) {
+          const reason = `wall-clock budget of ${Math.round(limit / 1e3)}s reached`;
+          if (budget.notifyFinish(reason, { graceMs: gracefulFinish.graceMs })) {
+            scheduleNext();
+            return;
+          }
+          abortSubagent(ctx.subagentId);
+          reject(new BudgetExceededError("timeout", limit, elapsed));
+          return;
+        } else {
+          abortSubagent(ctx.subagentId);
+          reject(new BudgetExceededError("timeout", limit, elapsed));
+          return;
+        }
+      }
+      if (!budget.onThreshold) {
+        abortSubagent(ctx.subagentId);
+        reject(new BudgetExceededError("timeout", limit, elapsed));
+        return;
+      }
+      budget.setWatchdogNegotiation(limit);
+      try {
+        const decision = await negotiateTimeout(elapsed, limit);
+        if (decision === "throw") {
+          terminate("timeout", limit, elapsed);
+          return;
+        }
+        if (decision === "continue") {
+          preemptState = "locked" /* LOCKED */;
+          preemptedCeiling = wallLimit;
+          armFor(Math.max(1e3, limit));
+          return;
+        }
+        if (decision === "stop") {
+          terminate("timeout", limit, elapsed);
+          return;
+        }
+        if (decision.extend.timeoutMs !== void 0) {
+          budget.patchLimits({ timeoutMs: decision.extend.timeoutMs });
+          lastGrantActivityTs = Date.now() - budget.idleMs();
+          preemptState = "active" /* ACTIVE */;
+          preemptedCeiling = null;
+          scheduleNext();
+          return;
+        }
+        terminate("timeout", limit, elapsed);
+        return;
+      } catch (err) {
+        abortSubagent(ctx.subagentId);
+        reject(
+          err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
+        );
+        return;
+      } finally {
+        budget.clearWatchdogNegotiation();
+      }
+    };
+    scheduleNext();
+  });
+  try {
+    return await Promise.race([runner(task, ctx), timeoutPromise]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// src/coordination/multi-agent-coordinator.ts
+var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends EventEmitter {
+  coordinatorId;
+  config;
+  runner;
+  sessionId;
+  fleetBus;
+  subagents = /* @__PURE__ */ new Map();
+  /**
+   * Base nickname keys already handed out this run (e.g. `einstein`, `tesla`).
+   * Prevents two workers sharing a name. Direct `coordinator.spawn()` callers
+   * (parallel/eternal engine, SDD parallel run) don't go through
+   * `Director.spawn()` where nicknames are normally assigned, so the
+   * coordinator upgrades placeholder names ("Executor", "slot-ab12cd", role
+   * names) to memorable ones here — that's what surfaces in the fleet monitor.
+   */
+  usedNicknames = /* @__PURE__ */ new Set();
+  /** Maps subagentId → nickname key (e.g. 'einstein'). Used to free the slot on remove(). */
+  subagentNicknames = /* @__PURE__ */ new Map();
+  pendingTasks = [];
+  completedResults = [];
+  /** Prevents completedResults from growing unbounded in long-running coordinators. */
+  static MAX_COMPLETED_RESULTS = 2e5;
+  /** Caps each subagent's retained task history (see assign()); bounds RAM + the recordCompletion lookup. */
+  static MAX_SUBAGENT_TASK_HISTORY = 64;
+  totalIterations = 0;
+  inFlight = 0;
+  /**
+   * Subagents currently being stopped. Set on entry to `stop()`, cleared
+   * once `recordCompletion` lands the terminal TaskResult. Used by
+   * `runDispatched` and `findIdleSubagent` to refuse mid-flight dispatch
+   * to a subagent the caller has already asked to terminate — closes the
+   * assign+terminate race where a fresh task could land on a worker that
+   * was about to be killed.
+   */
+  terminating = /* @__PURE__ */ new Set();
+  constructor(config, options = {}) {
+    super();
+    this.setMaxListeners(0);
+    this.coordinatorId = config.coordinatorId;
+    this.config = config;
+    this.runner = options.runner;
+    this.sessionId = options.sessionId;
+  }
+  currentSessionId() {
+    const value = typeof this.sessionId === "function" ? this.sessionId() : this.sessionId;
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  }
+  /**
+   * Replace the runner after construction. Used when the runner depends
+   * on infrastructure (e.g. FleetBus) that isn't available until after
+   * the coordinator's owning Director is built.
+   */
+  setRunner(runner) {
+    this.runner = runner;
+  }
+  /**
+   * Wire a FleetBus for director-mode event emission. Call after the
+   * FleetManager is constructed so the coordinator can emit lifecycle
+   * events the TUI and monitoring tools subscribe to.
+   */
+  setFleetBus(fleet) {
+    this.fleetBus = fleet;
+  }
+  /**
+   * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
+   * preempt running tasks — already-dispatched subagents finish their
+   * current task; only future dispatches respect the new cap. Raising
+   * immediately tries to fill the freed slots from the pending queue.
+   */
+  setMaxConcurrent(n) {
+    if (!Number.isFinite(n) || n < 1) {
+      throw new Error(`maxConcurrent must be a finite integer >= 1, got ${n}`);
+    }
+    this.config.maxConcurrent = Math.floor(n);
+    this.tryDispatchNext();
+  }
+  /**
+   * Upgrade a placeholder/role-derived name to a memorable scientist nickname
+   * (e.g. "Einstein (Executor)"). A name is treated as a placeholder when it is
+   * empty, equals the role (case-insensitive), is a generic default
+   * ("subagent"/"adhoc"/"generic"), or is an auto-generated `slot-…` id.
+   * Explicit, human-chosen names — including nicknames already assigned by
+   * `Director.spawn()` — are left untouched, so this never double-assigns.
+   */
+  withNickname(subagent, subagentId) {
+    const role = subagent.role ?? "subagent";
+    const name = subagent.name?.trim() ?? "";
+    const isPlaceholder = name === "" || name.toLowerCase() === role.toLowerCase() || name === "subagent" || name === "adhoc" || name === "generic" || /^slot-/.test(name);
+    if (!isPlaceholder) return subagent;
+    const { key, display } = assignNickname(role, this.usedNicknames);
+    this.usedNicknames.add(key);
+    this.subagentNicknames.set(subagentId, key);
+    return { ...subagent, name: display };
+  }
+  async spawn(subagent) {
+    const id = subagent.id || randomUUID();
+    const cfg = this.withNickname(subagent, id);
+    if (this.subagents.has(id)) {
+      throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
+    }
+    const context = {
+      subagentId: id,
+      tasks: [],
+      // Wired later by the caller via setSubagentBridge() once the
+      // bidirectional bridge is created. Readers must null-check / use
+      // hasParentBridge() — the type now reflects this.
+      parentBridge: null,
+      doneCondition: this.config.doneCondition,
+      maxConcurrent: this.config.maxConcurrent ?? 16
+    };
+    this.subagents.set(id, {
+      config: { ...cfg, id },
+      context,
+      status: "idle",
+      abortController: new AbortController()
+    });
+    this.emit("subagent.started", { subagent: { ...cfg, id } });
+    this.fleetBus?.emit({
+      subagentId: id,
+      ts: Date.now(),
+      type: "subagent.assigned",
+      payload: {
+        subagentId: id,
+        name: subagent.name,
+        provider: subagent.provider,
+        model: subagent.model
+      }
+    });
+    this.emitCoordinatorStats();
+    return { subagentId: id, agentId: id };
+  }
+  async assign(task) {
+    this.pendingTasks.push(task);
+    this.tryDispatchNext();
+  }
+  async delegate(to, msg) {
+    const subagent = this.subagents.get(to);
+    if (!subagent) throw new Error(`Subagent "${to}" not found`);
+    if (!subagent.context.parentBridge) {
+      throw new Error(`Subagent "${to}" has no parentBridge \u2014 call setSubagentBridge() first`);
+    }
+    await subagent.context.parentBridge.send(msg);
+  }
+  /**
+   * Wire up the communication bridge for a subagent. Call after spawn() once
+   * the caller has created the bidirectional connection.
+   */
+  setSubagentBridge(subagentId, bridge) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) throw new Error(`Subagent "${subagentId}" not found`);
+    subagent.context.parentBridge = bridge;
+  }
+  async stop(subagentId) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) return;
+    this.terminating.add(subagentId);
+    subagent.abortController.abort();
+    subagent.status = "stopped";
+    subagent.currentTask = void 0;
+    subagent.context.parentBridge = null;
+    this.emit("subagent.stopped", { subagentId, reason: "stopped by coordinator" });
+    this.fleetBus?.emit({
+      subagentId,
+      ts: Date.now(),
+      type: "subagent.stopped",
+      payload: { subagentId, reason: "stopped by coordinator" }
+    });
+    this.emitCoordinatorStats();
+  }
+  async stopAll() {
+    this.drainPendingAsAborted("Coordinator stopAll() drained the pending queue");
+    await Promise.allSettled([...this.subagents.keys()].map((id) => this.stop(id)));
+  }
+  /**
+   * Get current coordinator stats for monitoring/debugging.
+   */
+  getStats() {
+    let running = 0;
+    let idle = 0;
+    let stopped = 0;
+    for (const [, entry] of this.subagents) {
+      if (entry.status === "running") running++;
+      else if (entry.status === "idle") idle++;
+      else stopped++;
+    }
+    return {
+      total: this.subagents.size,
+      running,
+      idle,
+      stopped,
+      inFlight: this.inFlight,
+      pending: this.pendingTasks.length,
+      completed: this.completedResults.length
+    };
+  }
+  /** Emit a reactive coordinator.stats event on FleetBus so the TUI can subscribe. */
+  emitCoordinatorStats() {
+    const stats = this.getStats();
+    const subagentStatuses = Array.from(this.subagents.entries()).map(([id, s]) => ({
+      subagentId: id,
+      taskId: s.currentTask ?? "",
+      status: s.status,
+      assigned: s.context.parentBridge !== null
+    }));
+    const sessionId = this.currentSessionId();
+    this.fleetBus?.emit({
+      subagentId: this.coordinatorId,
+      ts: Date.now(),
+      type: "coordinator.stats",
+      payload: {
+        ...sessionId ? { sessionId } : {},
+        ...stats,
+        subagentStatuses
+      }
+    });
+  }
+  getStatus() {
+    return {
+      coordinatorId: this.coordinatorId,
+      subagents: Array.from(this.subagents.entries()).map(([id, s]) => ({
+        id,
+        name: s.config.name,
+        status: s.status,
+        currentTask: s.currentTask
+      })),
+      pendingTasks: this.pendingTasks.length,
+      completedTasks: this.completedResults.length,
+      totalIterations: this.totalIterations,
+      done: this.isDone()
+    };
+  }
+  /** Expose snapshot of completed results — useful for callers awaiting all done. */
+  results() {
+    return this.completedResults;
+  }
+  /** Defensive snapshot of the still-queued (not yet dispatched) tasks. */
+  listPendingTasks() {
+    return this.pendingTasks.map((t) => ({ ...t }));
+  }
+  /**
+   * Re-pin a still-PENDING task to a different subagent (`undefined` =
+   * unpin, any idle worker may take it), then try to dispatch. Returns
+   * `false` when the task is not in the pending queue — already
+   * dispatched, completed, or unknown. Running tasks can never be pulled;
+   * they can only be steered or terminated. The mutation is synchronous
+   * (same tick as the check), so it cannot race a concurrent dispatch:
+   * `tryDispatchNext` runs on this same call stack or a later one.
+   *
+   * The task keeps its id, so waiters, the report-back notifier, and
+   * checkpoint bookkeeping resolve unchanged when it eventually completes.
+   */
+  retargetPendingTask(taskId, subagentId) {
+    const task = this.pendingTasks.find((t) => t.id === taskId);
+    if (!task) return false;
+    if (subagentId !== void 0 && !this.subagents.has(subagentId)) return false;
+    task.subagentId = subagentId;
+    this.tryDispatchNext();
+    return true;
+  }
+  /**
+   * Wait for one or more tasks to complete and return their results.
+   * If a task is already done when called, returns immediately.
+   * Resolves to an array in the same order as `taskIds`.
+   */
+  async awaitTasks(taskIds, opts) {
+    const timeoutMs = opts?.timeoutMs ?? this.config.timeoutMs ?? 3e5;
+    return Promise.all(
+      taskIds.map((id) => {
+        const cached = this.completedResults.find((r) => r.taskId === id);
+        if (cached) return cached;
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            this.off("task.completed", handler);
+            reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
+          }, timeoutMs);
+          const handler = ({ result }) => {
+            if (result.taskId === id) {
+              clearTimeout(timeout);
+              this.off("task.completed", handler);
+              resolve(result);
+            }
+          };
+          this.on("task.completed", handler);
+        });
+      })
+    );
+  }
+  /**
+   * Wait until AT LEAST ONE of the named tasks completes. Returns every
+   * requested result already available at that moment (drain-what's-done)
+   * plus the ids still outstanding, so callers can loop "handle finishers,
+   * re-await the remainder" instead of blocking on the whole batch.
+   *
+   * Unlike `awaitTasks`, this never rejects and deliberately does NOT
+   * inherit `config.timeoutMs` — a "return whatever is done" call has no
+   * business timing out unless the caller asks for a window explicitly.
+   */
+  async awaitTasksAny(taskIds, opts) {
+    const ids = new Set(taskIds);
+    const completed = this.completedResults.filter((r) => ids.has(r.taskId));
+    if (completed.length > 0 || ids.size === 0) {
+      const done = new Set(completed.map((r) => r.taskId));
+      return { completed, pending: taskIds.filter((id) => !done.has(id)) };
+    }
+    return new Promise((resolve) => {
+      let timer;
+      const handler = ({ result }) => {
+        if (!ids.has(result.taskId)) return;
+        if (timer) clearTimeout(timer);
+        this.off("task.completed", handler);
+        resolve({
+          completed: [result],
+          pending: taskIds.filter((id) => id !== result.taskId)
+        });
+      };
+      if (opts?.timeoutMs !== void 0) {
+        timer = setTimeout(() => {
+          this.off("task.completed", handler);
+          resolve({ completed: [], pending: [...taskIds], timedOut: true });
+        }, opts.timeoutMs);
+      }
+      this.on("task.completed", handler);
+    });
+  }
+  /**
+   * Manual completion — for callers that drive subagents without a runner
+   * (e.g. external orchestrators). When a runner is configured the coordinator
+   * calls this itself.
+   */
+  completeTask(result) {
+    this.recordCompletion(result);
+  }
+  /**
+   * Ask every RUNNING subagent that opted into `gracefulFinish` to finish its
+   * task in its own turn (see coordination/subagent-finish.ts). This is the
+   * leader-side entry point for "the leader agent has finished": it delivers
+   * an in-band notification between tool batches — never an interrupt, never
+   * an abort. Each notified subagent keeps its existing time budget and
+   * accelerates; the watchdog still bounds the maximum lifetime.
+   *
+   * Subagents without the policy opted in are deliberately untouched — their
+   * lifecycle remains the legacy watchdog contract.
+   *
+   * Returns the number of subagents actually notified.
+   */
+  requestFinish(reason) {
+    let notified = 0;
+    for (const subagent of this.subagents.values()) {
+      if (subagent.status !== "running") continue;
+      if (!resolveGracefulFinish(subagent.config)) continue;
+      const budget = subagent.activeBudget;
+      if (!budget) continue;
+      const usage = budget.usage();
+      if (usage.iterations === 0 && usage.toolCalls === 0) continue;
+      if (budget.notifyFinish(reason)) notified++;
+    }
+    return notified;
+  }
+  // --- internal dispatching ---------------------------------------------
+  tryDispatchNext() {
+    while (this.canDispatch()) {
+      const dispatchable = this.takeNextDispatchableTask();
+      if (!dispatchable) {
+        if (this.pendingTasks.length > 0 && !this.hasLiveSubagent()) {
+          this.drainPendingAsAborted(
+            "No live subagent available \u2014 all stopped or mid-termination"
+          );
+        }
+        return;
+      }
+      const { subagentId, task } = dispatchable;
+      this.runDispatched(subagentId, task).catch((err) => {
+        this.recordCompletion({
+          subagentId,
+          taskId: task.id,
+          status: "failed",
+          error: classifySubagentError(err),
+          iterations: 0,
+          toolCalls: 0,
+          durationMs: 0
+        });
+      });
+    }
+  }
+  canDispatch() {
+    const max = this.config.maxConcurrent ?? 16;
+    return this.inFlight < max && this.pendingTasks.length > 0;
+  }
+  takeNextDispatchableTask() {
+    for (let i = 0; i < this.pendingTasks.length; i++) {
+      const task = this.pendingTasks[i];
+      if (!task) continue;
+      const subagentId = task.subagentId ? this.isIdleSubagent(task.subagentId) ? task.subagentId : null : this.findIdleSubagent();
+      if (!subagentId) continue;
+      this.pendingTasks.splice(i, 1);
+      return { subagentId, task };
+    }
+    return null;
+  }
+  findIdleSubagent() {
+    for (const [id, s] of this.subagents) {
+      if (s.status === "idle" && !this.terminating.has(id)) return id;
+    }
+    return null;
+  }
+  isIdleSubagent(id) {
+    const subagent = this.subagents.get(id);
+    return !!subagent && subagent.status === "idle" && !this.terminating.has(id);
+  }
+  /**
+   * Returns true iff at least one spawned subagent could still
+   * process a task. A "live" subagent is one that is not stopped
+   * AND not mid-termination — `running` workers count because they
+   * will eventually finish and become idle.
+   *
+   * When no subagent has ever been spawned, returns `true` so a
+   * pre-spawn `assign()` simply queues (legacy behaviour). The
+   * dead-end detection only fires after `stop()` has retired every
+   * spawned worker.
+   *
+   * Used by `tryDispatchNext` to detect a dead-end pending queue.
+   */
+  hasLiveSubagent() {
+    if (this.subagents.size === 0) return true;
+    for (const [id, s] of this.subagents) {
+      if (s.status !== "stopped" && !this.terminating.has(id)) return true;
+    }
+    return false;
+  }
+  /**
+   * Drain every pending task with a synthetic `aborted_by_parent`
+   * completion event. Same shape as the `stopAll()` drain — we go
+   * around `recordCompletion` because pending tasks were never
+   * counted in `inFlight` and routing them through would trip the
+   * underflow guard on every task after the first.
+   */
+  drainPendingAsAborted(message) {
+    const dropped = this.pendingTasks.splice(0, this.pendingTasks.length);
+    for (const t of dropped) this.emitPendingAborted(t, message);
+  }
+  /**
+   * Emit a synthetic `stopped`/`aborted_by_parent` completion for a single
+   * PENDING task — one that was never counted in `inFlight`. This MUST bypass
+   * `recordCompletion`: that path does `inFlight--`, which for a pending task
+   * steals a decrement from a genuinely in-flight task and trips the underflow
+   * guard — suppressing that real task's `task.completed` and hanging its
+   * `awaitTasks()` caller. Pushes the result and fires the event directly.
+   */
+  emitPendingAborted(task, message) {
+    const synthetic = {
+      subagentId: task.subagentId ?? "unassigned",
+      taskId: task.id,
+      status: "stopped",
+      error: {
+        kind: "aborted_by_parent",
+        message,
+        retryable: false
+      },
+      iterations: 0,
+      toolCalls: 0,
+      durationMs: 0
+    };
+    this.completedResults.push(synthetic);
+    this.trimCompletedResults();
+    this.emit("task.completed", { task, result: synthetic });
+  }
+  trimCompletedResults() {
+    if (this.completedResults.length > _DefaultMultiAgentCoordinator.MAX_COMPLETED_RESULTS) {
+      this.completedResults.splice(
+        0,
+        this.completedResults.length - _DefaultMultiAgentCoordinator.MAX_COMPLETED_RESULTS
+      );
+    }
+  }
+  async runDispatched(subagentId, task) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) return;
+    if (this.terminating.has(subagentId) || subagent.status === "stopped") {
+      this.recordCompletion({
+        subagentId,
+        taskId: task.id,
+        status: "stopped",
+        error: {
+          kind: "aborted_by_parent",
+          message: "Subagent was terminated before task could start",
+          retryable: false
+        },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      });
+      return;
+    }
+    subagent.status = "running";
+    subagent.currentTask = task.id;
+    task.subagentId = subagentId;
+    subagent.context.tasks.push(task);
+    if (subagent.context.tasks.length > _DefaultMultiAgentCoordinator.MAX_SUBAGENT_TASK_HISTORY) {
+      subagent.context.tasks.splice(
+        0,
+        subagent.context.tasks.length - _DefaultMultiAgentCoordinator.MAX_SUBAGENT_TASK_HISTORY
+      );
+    }
+    this.fleetBus?.emit({
+      subagentId,
+      taskId: task.id,
+      ts: Date.now(),
+      type: "subagent.running",
+      payload: { subagentId, taskId: task.id }
+    });
+    this.emit("task.assigned", { task, subagentId });
+    this.emitCoordinatorStats();
+    const rawMaxIterations = subagent.config.maxIterations;
+    const rawMaxToolCalls = subagent.config.maxToolCalls;
+    const rawMaxTokens = subagent.config.maxTokens;
+    const rawMaxCostUsd = subagent.config.maxCostUsd;
+    const rawTimeoutMs = subagent.config.timeoutMs;
+    const rawIdleTimeoutMs = subagent.config.idleTimeoutMs;
+    const configWithRosterDefaults = applyRosterBudget(subagent.config);
+    const budget = new SubagentBudget(
+      {
+        maxIterations: rawMaxIterations ?? this.config.defaultBudget?.maxIterations ?? configWithRosterDefaults.maxIterations,
+        maxToolCalls: rawMaxToolCalls ?? this.config.defaultBudget?.maxToolCalls ?? configWithRosterDefaults.maxToolCalls,
+        maxTokens: rawMaxTokens ?? this.config.defaultBudget?.maxTokens ?? configWithRosterDefaults.maxTokens,
+        maxCostUsd: rawMaxCostUsd ?? this.config.defaultBudget?.maxCostUsd ?? configWithRosterDefaults.maxCostUsd,
+        // Wall-clock cap is opt-in (explicit config / defaultBudget only); the
+        // roster no longer supplies one. Idle is the default reaper.
+        timeoutMs: rawTimeoutMs ?? this.config.defaultBudget?.timeoutMs ?? configWithRosterDefaults.timeoutMs,
+        idleTimeoutMs: rawIdleTimeoutMs ?? this.config.defaultBudget?.idleTimeoutMs ?? configWithRosterDefaults.idleTimeoutMs
+      },
+      "auto",
+      {
+        sessionId: () => this.currentSessionId(),
+        subagentId,
+        // Graceful-finish runs own wall-clock enforcement to the watchdog so
+        // the notify-then-bound lifecycle cannot be raced by tool.progress
+        // heartbeats calling checkTimeout() (see subagent-budget.ts).
+        ...resolveGracefulFinish(subagent.config) ? { wallClockWatchdogOwned: true } : {}
+      }
+    );
+    subagent.activeBudget = budget;
+    if (!this.runner) {
+      return;
+    }
+    this.inFlight++;
+    const startTime = Date.now();
+    let latestPartial;
+    const runCtx = {
+      subagentId,
+      config: subagent.config,
+      budget,
+      signal: subagent.abortController.signal,
+      bridge: subagent.context.parentBridge || null,
+      reportProgress: (partial) => {
+        const text = partial.text.trim();
+        if (!text) return;
+        latestPartial = {
+          ...partial,
+          // A partial is context recovery, not a transcript replacement.
+          text: text.slice(-4e3)
+        };
+      }
+    };
+    let result;
+    budget.start();
+    try {
+      const outcome = await this.executeWithTimeout(
+        this.runner,
+        task,
+        runCtx,
+        budget,
+        subagent.config.preemptFraction,
+        resolveGracefulFinish(subagent.config)
+      );
+      result = {
+        subagentId,
+        taskId: task.id,
+        status: "success",
+        result: outcome.result,
+        ...outcome.report ? { report: outcome.report } : {},
+        iterations: outcome.iterations,
+        toolCalls: outcome.toolCalls,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      const status = err instanceof BudgetExceededError && (err.kind === "timeout" || err.kind === "idle_timeout") ? "timeout" : subagent.abortController.signal.aborted ? "stopped" : "failed";
+      const usage = budget.usage();
+      result = {
+        subagentId,
+        taskId: task.id,
+        status,
+        error: classifySubagentError(err, {
+          parentAborted: subagent.abortController.signal.aborted
+        }),
+        ...latestPartial ? { partial: latestPartial } : {},
+        iterations: usage.iterations,
+        toolCalls: usage.toolCalls,
+        durationMs: Date.now() - startTime
+      };
+    }
+    this.recordCompletion(result);
+  }
+  async executeWithTimeout(runner, task, ctx, budget, preemptFraction, gracefulFinish) {
+    return executeSubagentWithTimeout({
+      runner,
+      task,
+      ctx,
+      budget,
+      preemptFraction,
+      gracefulFinish,
+      abortSubagent: (subagentId) => this.subagents.get(subagentId)?.abortController.abort(),
+      currentSessionId: () => this.currentSessionId()
+    });
+  }
+  recordCompletion(result) {
+    this.completedResults.push(result);
+    this.trimCompletedResults();
+    this.totalIterations += result.iterations;
+    if (this.inFlight > 0) {
+      this.inFlight--;
+    } else if (this.runner) {
+      this.emit("warning", {
+        type: "inFlight_underflow",
+        taskId: result.taskId,
+        subagentId: result.subagentId
+      });
+      return;
+    }
+    const subagent = this.subagents.get(result.subagentId);
+    if (subagent && subagent.status !== "stopped") {
+      const failed = result.status === "failed" || result.status === "timeout";
+      subagent.status = "idle";
+      void failed;
+      subagent.currentTask = void 0;
+      if (subagent.abortController.signal.aborted) {
+        subagent.abortController = new AbortController();
+      }
+      this.fleetBus?.emit({
+        subagentId: result.subagentId,
+        ts: Date.now(),
+        type: "subagent.idle",
+        payload: { subagentId: result.subagentId }
+      });
+    }
+    this.terminating.delete(result.subagentId);
+    this.emit("task.completed", {
+      task: subagent?.context.tasks.find((t) => t.id === result.taskId) ?? { id: result.taskId },
+      result
+    });
+    this.fleetBus?.emit({
+      subagentId: result.subagentId,
+      taskId: result.taskId,
+      ts: Date.now(),
+      type: "subagent.completed",
+      payload: {
+        subagentId: result.subagentId,
+        taskId: result.taskId,
+        status: result.status,
+        result: result.result,
+        report: result.report,
+        partial: result.partial,
+        iterations: result.iterations,
+        toolCalls: result.toolCalls,
+        durationMs: result.durationMs
+      }
+    });
+    this.tryDispatchNext();
+    this.emitCoordinatorStats();
+    if (this.isDone()) {
+      this.emit("done", {
+        results: this.completedResults,
+        totalIterations: this.totalIterations
+      });
+    }
+  }
+  /**
+   * Stop a subagent and remove it from the coordinator. Releases all
+   * associated resources (AbortController, context, budget state).
+   * The subagent entry is deleted so the id can be reused in a future spawn.
+   */
+  async remove(subagentId) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) return;
+    if (subagent.status === "running" || subagent.status === "idle") {
+      this.terminating.add(subagentId);
+      subagent.abortController.abort();
+      subagent.status = "stopped";
+    }
+    this.subagents.delete(subagentId);
+    this.terminating.delete(subagentId);
+    const nicknameKey = this.subagentNicknames.get(subagentId);
+    if (nicknameKey) {
+      this.usedNicknames.delete(nicknameKey);
+      this.subagentNicknames.delete(subagentId);
+    }
+    const orphaned = this.pendingTasks.filter((t) => t.subagentId === subagentId);
+    this.pendingTasks = this.pendingTasks.filter((t) => t.subagentId !== subagentId);
+    for (const t of orphaned) {
+      this.emitPendingAborted(
+        t,
+        `Subagent "${subagentId}" was removed while task "${t.id}" was pending`
+      );
+    }
+    this.fleetBus?.emit({
+      subagentId,
+      ts: Date.now(),
+      type: "subagent.removed",
+      payload: { subagentId }
+    });
+    this.emitCoordinatorStats();
+  }
+  isDone() {
+    if (this.config.doneCondition.type === "all_tasks_done") {
+      return this.pendingTasks.length === 0 && this.inFlight === 0;
+    }
+    if (this.config.doneCondition.maxIterations !== void 0 && this.totalIterations >= this.config.doneCondition.maxIterations) {
+      return true;
+    }
+    return false;
+  }
+};
+
+export {
+  TIMEOUT_PREEMPT_FRACTION,
+  DECISION_TIMEOUT_MS,
+  BudgetExceededError,
+  BudgetThresholdSignal,
+  SubagentBudget,
+  SUBAGENT_STRUCTURED_REPORT_META_KEY,
+  MAX_SUBAGENT_STRUCTURED_REPORT_CHARS,
+  normalizeSubagentStructuredReport,
+  readSubagentStructuredReport,
+  formatSubagentStructuredReport,
+  makeSubagentResultTool,
+  withDisabledToolFiltering,
+  makeAgentSubagentRunner,
+  BLOCKED_RESOLVED_MARKERS,
+  COMPETING_ALTERNATIVE,
+  isBlockedResolved,
+  DEFAULT_BRAIN_HEURISTICS,
+  compileResolutionMarkers,
+  resolveBrainHeuristics,
+  DETERMINISTIC_BRAIN_TIERS,
+  markDecisionTier,
+  readDecisionTier,
+  isDeterministicTier,
+  BrainTierCounter,
+  BRAIN_RISK_LEVELS,
+  ObservableBrainArbiter,
+  BrainDecisionQueue,
+  terminalPolicyDecision,
+  EscalationRoutingBrainArbiter,
+  HumanEscalatingBrainArbiter,
+  DefaultBrainArbiter,
+  formatHumanPrompt,
+  brainDecisionKey,
+  createLedgerGuardBrainArbiter,
+  BrainDecisionLedger,
+  DEFAULT_DISPATCH_ROLE,
+  scoreAgents,
+  dispatchAgent,
+  makeLLMClassifier,
+  assignNickname,
+  nicknameKeyFromDisplay,
+  AUDIT_LOG_AGENT,
+  BUG_HUNTER_AGENT,
+  REFACTOR_PLANNER_AGENT,
+  SECURITY_SCANNER_AGENT,
+  GENERIC_AGENT,
+  FLEET_ROSTER,
+  FLEET_ROSTER_BUDGETS,
+  applyRosterBudget,
+  ALL_FLEET_AGENTS,
+  ACP_AGENTS,
+  FLEET_ROSTER_WITHACP,
+  DefaultMultiAgentCoordinator
+};
+//# sourceMappingURL=chunk-T3KGZBU5.js.map