@wrongstack/core 0.6.3 → 0.6.5

package/dist/defaults/index.js

@@ -436,6 +436,20 @@ var DefaultSessionStore = class {
     await fsp.unlink(path3.join(this.dir, `${id}.jsonl`));
     await fsp.unlink(path3.join(this.dir, `${id}.summary.json`)).catch(() => void 0);
   }
+  async clearHistory(id) {
+    const file = path3.join(this.dir, `${id}.jsonl`);
+    const meta = path3.join(this.dir, `${id}.summary.json`);
+    const record = `${JSON.stringify({
+      type: "session_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      id,
+      model: "unknown",
+      provider: "unknown"
+    })}
+`;
+    await fsp.writeFile(file, record, "utf8");
+    await fsp.unlink(meta).catch(() => void 0);
+  }
   async summarize(id, mtime) {
     try {
       const data = await this.load(id);
@@ -741,10 +755,21 @@ var FileSessionWriter = class {
     });
     return removedCount;
   }
+  async clearSession() {
+    if (!this.filePath) return;
+    const record = `${JSON.stringify({
+      type: "session_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      id: this.id,
+      model: this.meta.model ?? "unknown",
+      provider: this.meta.provider ?? "unknown"
+    })}
+`;
+    await fsp.writeFile(this.filePath, record, "utf8");
+  }
 };
 function userInputTitle(content) {
-  if (typeof content === "string") return content.slice(0, 60);
-  const text = content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
+  const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
   return (text || "(non-text input)").slice(0, 60);
 }
 
@@ -5867,644 +5892,108 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
-// src/execution/autonomy-prompt-contributor.ts
-function makeAutonomyPromptContributor(opts) {
-  return async (ctx) => {
-    if (ctx.subagent) return [];
-    if (!opts.enabled()) return [];
-    let goal;
-    try {
-      goal = await loadGoal(opts.goalPath);
-    } catch {
-      return [];
-    }
-    if (!goal) return [];
-    const missionState = goal.goalState ?? "active";
-    if (missionState !== "active") return [];
-    const tailSize = opts.journalTailSize ?? 5;
-    const journalTail = goal.journal.slice(-tailSize).map((e) => {
-      const note = e.note ? ` \u2014 ${e.note.slice(0, 80)}` : "";
-      return `  #${e.iteration} [${e.status}] ${e.task}${note}`;
-    });
-    const text = [
-      "## ETERNAL AUTONOMY \u2014 active mission",
-      "",
-      "You are inside a long-running autonomous loop. The user is asleep",
-      "and is not available to confirm decisions. Each turn you receive a",
-      "directive describing one concrete sub-task that advances the mission.",
-      "",
-      `Mission: ${goal.goal}`,
-      `Iteration: #${goal.iterations}`,
-      journalTail.length > 0 ? `Recent journal (last ${journalTail.length}):
-${journalTail.join("\n")}` : "Recent journal: (none \u2014 this is the first iteration)",
-      "",
-      "### Loop control markers",
-      "Emit these on their own line in your final text \u2014 case-insensitive,",
-      "whitespace-tolerant, but they must occupy the entire line:",
-      "- `[continue]` \u2014 chain to the next internal step without returning.",
-      "- `[done]` \u2014 the current sub-task is finished; return to the engine.",
-      "- `[GOAL_COMPLETE]` \u2014 emit ONLY when the OVERALL mission is",
-      "  verifiably done. Must be followed by a one-paragraph verification",
-      "  recipe (artifact path, test command, or 10-second reproduction).",
-      "  The engine halts on this marker \u2014 false positives waste real",
-      "  human time. If unsure, emit `[done]` and let the next iteration",
-      "  decide.",
-      "",
-      "### Operating principles",
-      "- YOLO is active. Do NOT ask for confirmation, do NOT propose",
-      "  options. Pick the best path and execute it.",
-      "- Use tools freely; multiple calls per turn are normal and expected.",
-      "- When working on a todo, mark it `in_progress` via the todos tool",
-      "  before tool work and `completed` (or `cancelled` with a reason)",
-      "  when done. The loop reads todo state between iterations.",
-      "- If an approach fails twice in a row, pivot. Don't grind on the",
-      "  same wall \u2014 try a different angle, file a cancel on the todo, or",
-      "  surface the obstacle via `[done]` and let the next iteration",
-      "  re-plan."
-    ].join("\n");
-    return [
-      {
-        type: "text",
-        text,
-        cache_control: { type: "ephemeral" }
-      }
-    ];
-  };
-}
-
-// src/execution/goal-preamble.ts
-function buildGoalPreamble(goal) {
-  return [
-    "[GOAL \u2014 LOCKED IN. You will work on this until it is verifiably done.",
-    "The user granted you full autonomy. Read these constraints once, then act.",
-    "",
-    "YOUR GOAL:",
-    "---",
-    goal,
-    "---",
-    "",
-    "AUTHORITY YOU HAVE:",
-    "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
-    "  Parallel + recursive fan-out are both fine. There is no spawn budget.",
-    "- Use any provider/model per subagent \u2014 pick the right tool for each",
-    "  piece of work. Heavy reasoning model for planning, fast model for",
-    "  batch work, specialist model for domain code.",
-    "- Run unlimited tool calls and iterations. There is NO hidden budget.",
-    "  The Agent loop auto-extends every 100 iterations forever.",
-    "- Retry failed tools with different inputs, alternative paths, fresh",
-    "  subagents. Switch providers mid-run if one is rate-limited.",
-    "- Re-plan freely when an approach hits a dead end. You are not obliged",
-    "  to stick with the first plan you proposed.",
-    "",
-    'WHAT "DONE" MEANS \u2014 non-negotiable:',
-    "- You can name a concrete artifact (a passing test, a written file at",
-    "  a specific path, a fixed bug verified by re-running the failing case,",
-    "  a clean grep that previously had matches).",
-    "- You can tell the user HOW to verify it themselves in 10 seconds.",
-    '- You have NOT hedged. None of: "looks like it should work", "I',
-    '  believe this fixes it", "the changes appear correct".',
-    "",
-    "WHAT IS NOT DONE \u2014 never report any of these as completion:",
-    "- An error message you didn't recover from.",
-    '- An empty result, a 0-line file, a "no matches found" you accepted',
-    "  without questioning the search.",
-    '- "Should I continue?" / "Want me to also...?" / "Let me know if you',
-    '  want X." Those are hedges. The user already told you to finish the',
-    "  goal \u2014 just do it.",
-    "- Partial progress dressed up as success. Fixed 3 of 5 bugs = 60%",
-    "  done, not done.",
-    "- A subagent's failed/timeout/stopped TaskResult that you didn't",
-    "  respond to with a fresh attempt (different role, different model,",
-    "  tighter prompt).",
-    "",
-    "PERSISTENCE PROTOCOL:",
-    "- If blocked, try at least 3 different angles before reporting the",
-    "  problem to the user. Different tool inputs, different subagent",
-    "  roles, different providers, different decomposition of the task.",
-    "- If a tool fails, read its error, alter the input, try again. Do",
-    "  not just report the failure back.",
-    "- If a subagent returns useless output, respawn with a tighter prompt",
-    '  or a different role. Do not accept "I could not determine\u2026" as the',
-    "  final answer.",
-    "- Use `ask_subagent` for one-shot questions when you don't need a",
-    "  full delegated task.",
-    "",
-    "REPORTING:",
-    "- Stream short progress notes between major actions so the user can",
-    "  monitor. Do not go silent for 50 tool calls then dump a wall of",
-    "  text \u2014 but also do not narrate every tool call.",
-    "- Use the shared scratchpad (if available) to leave breadcrumbs",
-    "  subagents can read.",
-    "- Final response must include: (a) what was accomplished, (b) how",
-    "  to verify, (c) any caveats (residual TODOs, things the user",
-    "  should know about).",
-    "",
-    "BEGIN.]"
-  ].join("\n");
-}
-
-// src/coordination/director.ts
-init_atomic_write();
-
-// src/coordination/in-memory-transport.ts
-var InMemoryBridgeTransport = class {
-  subs = /* @__PURE__ */ new Map();
-  send(msg, to) {
-    if (to === "*") {
-      for (const [id, handlers2] of this.subs) {
-        if (id === msg.from) continue;
-        for (const h of handlers2) {
-          try {
-            h(msg);
-          } catch {
-          }
-        }
-      }
-      return Promise.resolve();
-    }
-    const handlers = this.subs.get(to);
-    if (handlers) {
-      for (const h of handlers) {
-        try {
-          h(msg);
-        } catch {
-        }
-      }
-    }
-    return Promise.resolve();
-  }
-  subscribe(agentId, handler) {
-    if (!this.subs.has(agentId)) this.subs.set(agentId, /* @__PURE__ */ new Set());
-    this.subs.get(agentId).add(handler);
-    return () => this.subs.get(agentId)?.delete(handler);
-  }
-  close(agentId) {
-    this.subs.delete(agentId);
-    return Promise.resolve();
+// src/coordination/subagent-budget.ts
+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;
   }
 };
-
-// src/coordination/agent-bridge.ts
-var InMemoryAgentBridge = class {
-  agentId;
-  coordinatorId;
-  transport;
-  subscriptions = /* @__PURE__ */ new Set();
-  pendingRequests = /* @__PURE__ */ new Map();
-  stopped = false;
-  timeoutMs;
-  /** Guards request() so concurrent calls on the same id can't silently overwrite. */
-  inflightGuards = /* @__PURE__ */ new Set();
-  constructor(config, transport) {
-    this.agentId = config.agentId;
-    this.coordinatorId = config.coordinatorId;
-    this.transport = transport;
-    this.timeoutMs = config.timeoutMs ?? 3e4;
-    this.transport.subscribe(this.agentId, (msg) => {
-      if (msg.type === "heartbeat") return;
-      const pending = this.pendingRequests.get(msg.id);
-      if (pending) {
-        clearTimeout(pending.timer);
-        this.pendingRequests.delete(msg.id);
-        this.inflightGuards.delete(msg.id);
-        pending.resolve(msg);
-        return;
-      }
-      for (const h of this.subscriptions) {
-        try {
-          h(msg);
-        } catch {
-        }
-      }
-    });
-  }
-  async send(msg) {
-    msg.timestamp = Date.now();
-    await this.transport.send(msg, msg.to ?? this.coordinatorId);
-  }
-  async broadcast(msg) {
-    msg.timestamp = Date.now();
-    msg.to = "*";
-    await this.transport.send(msg, "*");
-  }
-  subscribe(handler) {
-    this.subscriptions.add(handler);
-    return () => this.subscriptions.delete(handler);
-  }
-  async request(msg, timeoutMs) {
-    if (this.stopped) throw new Error("Bridge is stopped");
-    const timeout = timeoutMs ?? this.timeoutMs;
-    const correlationId = msg.id;
-    if (this.inflightGuards.has(correlationId)) {
-      throw new Error(
-        `Bridge request id "${correlationId}" collides with an in-flight request \u2014 caller is reusing message ids`
-      );
-    }
-    this.inflightGuards.add(correlationId);
-    return new Promise((resolve2, reject) => {
-      const timer = setTimeout(() => {
-        this.inflightGuards.delete(correlationId);
-        this.pendingRequests.delete(correlationId);
-        reject(new Error(`Request ${correlationId} timed out after ${timeout}ms`));
-      }, timeout);
-      if (this.stopped) {
-        clearTimeout(timer);
-        this.inflightGuards.delete(correlationId);
-        this.pendingRequests.delete(correlationId);
-        reject(new Error("Bridge stopped"));
-        return;
-      }
-      this.pendingRequests.set(correlationId, {
-        resolve: resolve2,
-        reject,
-        timer
-      });
-      msg.timestamp = Date.now();
-      this.transport.send(msg, msg.to ?? this.coordinatorId).catch((e) => {
-        clearTimeout(timer);
-        this.inflightGuards.delete(correlationId);
-        this.pendingRequests.delete(correlationId);
-        reject(e);
-      });
-    });
-  }
-  async stop() {
-    this.stopped = true;
-    for (const [, p] of this.pendingRequests) {
-      clearTimeout(p.timer);
-      p.reject(new Error("Bridge stopped"));
-    }
-    this.pendingRequests.clear();
-    this.inflightGuards.clear();
-    this.subscriptions.clear();
-    await this.transport.close(this.agentId);
+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;
   }
 };
-function createMessage(type, from, payload, to) {
-  return {
-    id: randomUUID(),
-    type,
-    from,
-    to,
-    payload,
-    timestamp: Date.now(),
-    priority: "normal"
-  };
-}
-
-// src/coordination/director-prompts.ts
-var DEFAULT_DIRECTOR_PREAMBLE = `You are the Director of a multi-agent fleet. You orchestrate worker
-subagents by spawning them, assigning tasks, awaiting completions, and
-rolling up their outputs into your next decision.
-
-Core fleet tools available to you:
-  - spawn_subagent       \u2014 create a worker with a chosen provider / model / role
-  - assign_task          \u2014 hand a piece of work to a specific subagent
-  - await_tasks          \u2014 block until named task ids complete (parallel-safe)
-  - ask_subagent         \u2014 synchronously query a running subagent via the bridge
-  - roll_up              \u2014 aggregate finished tasks into a markdown/json summary
-  - terminate_subagent   \u2014 abort a stuck worker (use sparingly)
-  - fleet_status         \u2014 snapshot of all subagents and pending tasks
-  - fleet_usage          \u2014 token + cost breakdown per subagent and total
-
-Working rules:
-  1. Decompose first. Before spawning, decide which sub-tasks are
-     independent and can run in parallel. Sequential work doesn't need a
-     subagent \u2014 do it yourself.
-  2. Match worker to job. Cheap/fast model for triage, capable model for
-     synthesis. Different providers per sibling is allowed and encouraged.
-  3. Always pair an assign with an await. Don't fire-and-forget; you owe
-     the user a single coherent answer at the end.
-  4. Roll up before deciding. After await_tasks resolves, call roll_up so
-     the results are folded back into your context in a compact form.
-  5. Budget is real. Check fleet_usage periodically. If a subagent is
-     thrashing, terminate it rather than letting cost climb silently.
-  6. Never claim a subagent's work as your own without verifying it. If a
-     result looks wrong, ask_subagent for clarification before passing it
-     to the user.`;
-var DEFAULT_SUBAGENT_BASELINE = `You are a subagent operating under a Director. You were spawned to handle
-a specific slice of a larger plan \u2014 do that slice well and report back.
-
-Bridge contract:
-  - You have a parent (the Director). You may call \`request\` on the
-    parent bridge to ask a clarifying question. Use this sparingly; the
-    parent is also working.
-  - You MAY NOT request the parent's system prompt, tool list, or other
-    subagents' context. Those are not yours to read.
-  - Your final task output is what the Director sees. Be concise,
-    structured, and self-contained \u2014 assume the Director will paste your
-    output into its own context.`;
-function composeDirectorPrompt(parts = {}) {
-  const sections = [];
-  const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
-  if (preamble && preamble.trim().length > 0) sections.push(preamble.trim());
-  if (parts.rosterSummary && parts.rosterSummary.trim().length > 0) {
-    sections.push(`Available roles you can spawn:
-${parts.rosterSummary.trim()}`);
-  }
-  if (parts.basePrompt && parts.basePrompt.trim().length > 0) {
-    sections.push(parts.basePrompt.trim());
-  }
-  return sections.join("\n\n");
-}
-function composeSubagentPrompt(parts = {}) {
-  const sections = [];
-  const baseline = parts.baseline ?? DEFAULT_SUBAGENT_BASELINE;
-  if (baseline && baseline.trim().length > 0) sections.push(baseline.trim());
-  if (parts.role && parts.role.trim().length > 0) {
-    sections.push(`Role:
-${parts.role.trim()}`);
+var SubagentBudget = class _SubagentBudget {
+  limits;
+  iterations = 0;
+  toolCalls = 0;
+  tokenInput = 0;
+  tokenOutput = 0;
+  costUsd = 0;
+  startTime = null;
+  _onThreshold;
+  /**
+   * Tracks which budget kinds currently have an extension request
+   * in flight. While a kind is here, further `checkLimit` calls for the
+   * same kind are no-ops — without this dedup, every `recordIteration`
+   * after the limit is reached spawns a fresh decision Promise (until
+   * the first one lands and patches limits), flooding the FleetBus
+   * with redundant threshold events. Cleared in `checkLimitAsync`'s
+   * `finally`.
+   */
+  pendingExtensions = /* @__PURE__ */ new Set();
+  /**
+   * Hard cap on how long `checkLimitAsync` 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, since
+   * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
+   * Hardcoded for now — most fleets set their own per-task timeout that
+   * dwarfs this anyway. 30 s matches the existing event-emit timeoutMs.
+   */
+  static DECISION_TIMEOUT_MS = 3e4;
+  /**
+   * Injected by the runner when wiring the budget to its EventBus.
+   * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
+   */
+  _events;
+  /**
+   * Optional callback for soft-limit handling. When set, the budget will
+   * call this instead of throwing when a limit is first reached. The
+   * handler decides whether to throw, continue, or ask the coordinator.
+   */
+  get onThreshold() {
+    return this._onThreshold;
   }
-  if (parts.task && parts.task.trim().length > 0) {
-    sections.push(`Task:
-${parts.task.trim()}`);
+  set onThreshold(fn) {
+    this._onThreshold = fn;
   }
-  if (parts.sharedScratchpad && parts.sharedScratchpad.trim().length > 0) {
-    sections.push(
-      `Shared notes:
-A scratchpad shared with the rest of the fleet is mounted at \`${parts.sharedScratchpad.trim()}\`.
-- Write your final findings as markdown files there (e.g. \`findings.md\`, \`security.md\`).
-- Before starting, list the directory and read any sibling files relevant to your task \u2014 they may already contain context you can build on.
-- Use stable filenames (one file per concern); overwrite instead of appending so the Director sees the latest state.`
-    );
+  constructor(limits = {}) {
+    this.limits = Object.freeze({ ...limits });
   }
-  if (parts.override && parts.override.trim().length > 0) {
-    sections.push(parts.override.trim());
+  start() {
+    this.startTime = Date.now();
   }
-  return sections.join("\n\n");
-}
-function rosterSummaryFromConfigs(roster) {
-  const lines = [];
-  for (const [roleId, cfg] of Object.entries(roster)) {
-    const tag = cfg.provider && cfg.model ? ` (${cfg.provider}/${cfg.model})` : "";
-    const headline = cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").trim().slice(0, 80) : "";
-    const tail = headline ? ` \u2014 ${headline}` : "";
-    lines.push(`- ${roleId}: ${cfg.name}${tag}${tail}`);
+  /** 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;
   }
-  return lines.join("\n");
-}
-
-// src/coordination/fleet-bus.ts
-var FleetBus = class {
-  byId = /* @__PURE__ */ new Map();
-  byType = /* @__PURE__ */ new Map();
-  any = /* @__PURE__ */ new Set();
   /**
-   * Hook a subagent's EventBus into the fleet. EventBus is strongly
-   * typed and doesn't expose an `onAny` hook, so we subscribe to the
-   * canonical set of event types a subagent emits during a run. New
-   * event types added to the kernel must be added here too — but the
-   * cost is a tiny single line per type, and the explicit list keeps
-   * the wire format clear.
-   *
-   * Returns a disposer that detaches every subscription; call on
-   * subagent teardown so the listeners don't outlive the run.
+   * 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.
+   * When `onThreshold` IS configured, the actual async threshold-handling
+   * is dispatched as a fire-and-forget promise.
    */
-  attach(subagentId, bus, taskId) {
-    const off = bus.onPattern("*", (type, payload) => {
-      if (type.startsWith("subagent.")) return;
-      this.emit({ subagentId, taskId, ts: Date.now(), type, payload });
-    });
-    return () => {
-      off();
-    };
-  }
-  /** Subscribe to every event from one subagent. */
-  subscribe(subagentId, handler) {
-    let set = this.byId.get(subagentId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.byId.set(subagentId, set);
+  checkLimit(kind, used, limit) {
+    if (!this._onThreshold) {
+      throw new BudgetExceededError(kind, limit, used);
     }
-    set.add(handler);
-    return () => {
-      set.delete(handler);
-    };
-  }
-  /** Subscribe to one event type across all subagents. */
-  filter(type, handler) {
-    let set = this.byType.get(type);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.byType.set(type, set);
-    }
-    set.add(handler);
-    return () => {
-      set.delete(handler);
-    };
-  }
-  /** Subscribe to literally everything. The fleet roll-up uses this. */
-  onAny(handler) {
-    this.any.add(handler);
-    return () => {
-      this.any.delete(handler);
-    };
-  }
-  emit(event) {
-    const byId = this.byId.get(event.subagentId);
-    if (byId)
-      for (const h of byId) {
-        try {
-          h(event);
-        } catch {
-        }
-      }
-    const byType = this.byType.get(event.type);
-    if (byType)
-      for (const h of byType) {
-        try {
-          h(event);
-        } catch {
-        }
-      }
-    for (const h of this.any) {
-      try {
-        h(event);
-      } catch {
-      }
-    }
-  }
-};
-var FleetUsageAggregator = class {
-  constructor(bus, priceLookup, metaLookup) {
-    this.bus = bus;
-    this.priceLookup = priceLookup;
-    this.metaLookup = metaLookup;
-    bus.filter("provider.response", (e) => this.onProviderResponse(e));
-    bus.filter("tool.executed", (e) => this.onToolExecuted(e));
-    bus.filter("iteration.started", (e) => this.onIterationStarted(e));
-  }
-  bus;
-  priceLookup;
-  metaLookup;
-  perSubagent = /* @__PURE__ */ new Map();
-  total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
-  /** Live snapshot — safe to call from a tool's execute() body. */
-  snapshot() {
-    return {
-      total: { ...this.total },
-      perSubagent: Object.fromEntries(
-        Array.from(this.perSubagent.entries()).map(([k, v]) => [k, { ...v }])
-      )
-    };
-  }
-  ensure(subagentId) {
-    let snap = this.perSubagent.get(subagentId);
-    if (!snap) {
-      const meta = this.metaLookup?.(subagentId);
-      snap = {
-        subagentId,
-        provider: meta?.provider,
-        model: meta?.model,
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        cost: 0,
-        toolCalls: 0,
-        iterations: 0,
-        startedAt: Date.now(),
-        lastEventAt: Date.now()
-      };
-      this.perSubagent.set(subagentId, snap);
-    }
-    return snap;
-  }
-  onProviderResponse(e) {
-    const snap = this.ensure(e.subagentId);
-    const p = e.payload;
-    const usage = p?.usage;
-    if (!usage) return;
-    snap.input += usage.input ?? 0;
-    snap.output += usage.output ?? 0;
-    snap.cacheRead += usage.cacheRead ?? 0;
-    snap.cacheWrite += usage.cacheWrite ?? 0;
-    this.total.input += usage.input ?? 0;
-    this.total.output += usage.output ?? 0;
-    this.total.cacheRead += usage.cacheRead ?? 0;
-    this.total.cacheWrite += usage.cacheWrite ?? 0;
-    const price = this.priceLookup?.(e.subagentId);
-    if (price) {
-      const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
-      snap.cost += delta;
-      this.total.cost += delta;
-    }
-    snap.lastEventAt = e.ts;
-  }
-  onToolExecuted(e) {
-    const snap = this.ensure(e.subagentId);
-    snap.toolCalls += 1;
-    snap.lastEventAt = e.ts;
-  }
-  onIterationStarted(e) {
-    const snap = this.ensure(e.subagentId);
-    snap.iterations += 1;
-    snap.lastEventAt = e.ts;
-  }
-};
-
-// src/coordination/subagent-budget.ts
-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;
-  iterations = 0;
-  toolCalls = 0;
-  tokenInput = 0;
-  tokenOutput = 0;
-  costUsd = 0;
-  startTime = null;
-  _onThreshold;
-  /**
-   * Tracks which budget kinds currently have an extension request
-   * in flight. While a kind is here, further `checkLimit` calls for the
-   * same kind are no-ops — without this dedup, every `recordIteration`
-   * after the limit is reached spawns a fresh decision Promise (until
-   * the first one lands and patches limits), flooding the FleetBus
-   * with redundant threshold events. Cleared in `checkLimitAsync`'s
-   * `finally`.
-   */
-  pendingExtensions = /* @__PURE__ */ new Set();
-  /**
-   * Hard cap on how long `checkLimitAsync` 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, since
-   * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
-   * Hardcoded for now — most fleets set their own per-task timeout that
-   * dwarfs this anyway. 30 s matches the existing event-emit timeoutMs.
-   */
-  static DECISION_TIMEOUT_MS = 3e4;
-  /**
-   * Injected by the runner when wiring the budget to its EventBus.
-   * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
-   */
-  _events;
-  /**
-   * Optional callback for soft-limit handling. When set, the budget will
-   * call this instead of throwing when a limit is first reached. The
-   * handler decides whether to throw, continue, or ask the coordinator.
-   */
-  get onThreshold() {
-    return this._onThreshold;
-  }
-  set onThreshold(fn) {
-    this._onThreshold = fn;
-  }
-  constructor(limits = {}) {
-    this.limits = Object.freeze({ ...limits });
-  }
-  start() {
-    this.startTime = Date.now();
-  }
-  /** 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.
-   * When `onThreshold` IS configured, the actual async threshold-handling
-   * is dispatched as a fire-and-forget promise.
-   */
-  checkLimit(kind, used, limit) {
-    if (kind === "timeout" || !this._onThreshold) {
-      throw new BudgetExceededError(kind, limit, used);
-    }
-    const bus = this._events;
-    if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
-      throw new BudgetExceededError(kind, limit, used);
+    const bus = this._events;
+    if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+      throw new BudgetExceededError(kind, limit, used);
     }
     if (this.pendingExtensions.has(kind)) return;
     this.pendingExtensions.add(kind);
@@ -6615,14 +6104,18 @@ var SubagentBudget = class _SubagentBudget {
     }
   }
   /**
-   * Throws if the wall-clock budget is exhausted. Call this from the iteration
-   * loop so a hung tool can't keep a subagent running past its deadline.
+   * Wall-clock budget check. Unlike other limits, timeout is treated as a
+   * warning-only event — it NEVER hard-stops the subagent. When the
+   * elapsed time exceeds timeoutMs, emits `budget.threshold_reached` with
+   * kind='timeout' so the Director can decide whether to extend or warn.
+   * Call this from the iteration loop so a hung tool gets a chance to
+   * negotiate more time before the coordinator's Promise.race kills it.
    */
   checkTimeout() {
     if (this.startTime === null || this.limits.timeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
     if (elapsed > this.limits.timeoutMs) {
-      throw new BudgetExceededError("timeout", this.limits.timeoutMs, elapsed);
+      void this.checkLimit("timeout", elapsed, this.limits.timeoutMs);
     }
   }
   /** Returns true if a timeout has occurred without throwing. Useful for races. */
@@ -6645,45 +6138,213 @@ var SubagentBudget = class _SubagentBudget {
   }
 };
 
-// src/coordination/fleet.ts
-var AUDIT_LOG_AGENT = {
-  id: "audit-log",
-  name: "Audit Log",
-  role: "audit-log",
-  prompt: `You are the Audit Log agent. Your job is to analyze structured JSONL
-session logs and produce actionable markdown reports.
-
-Scope:
-- Parse session logs (iteration counts, tool calls, errors, usage)
-- Detect repeated failure patterns across multiple runs
-- Identify tool usage anomalies (over-use, failures, unexpected chains)
-- Track token consumption trends
-- Generate structured audit reports with severity ratings
-
-Input format you accept:
-{ "task": "analyze | report | trends", "sessionPath": "<path>", "focus": "errors | tools | usage | all" }
-
-Output: Markdown audit report with sections:
-- ## Summary (totals, error rate)
-- ## Top Errors (count + context)
-- ## Tool Usage (table with calls, failures, avg duration)
-- ## Anomalies (pattern \u2192 severity)
-
-Working rules:
-- Never fabricate numbers \u2014 read the actual logs first
-- Always include file:line references for errors
-- If sessionPath is missing, ask the director to provide it
-- Report confidence level: high (>90% accuracy), medium, low`
-  // No hardcoded budgets — the orchestrator (delegate tool or
-  // spawn_subagent) decides per-task how much room a subagent gets.
-  // A monorepo audit needs hours; a single-file lint check needs
-  // seconds. Pinning a number here forces the orchestrator to fight
-  // the role's default instead of just asking for what it needs.
-};
-var BUG_HUNTER_AGENT = {
-  id: "bug-hunter",
-  name: "Bug Hunter",
-  role: "bug-hunter",
+// src/coordination/agent-subagent-runner.ts
+function makeAgentSubagentRunner(opts) {
+  const format = opts.formatTaskInput ?? defaultFormatTaskInput;
+  return async (task, ctx) => {
+    const factoryResult = await opts.factory(ctx.config);
+    const { agent, events } = factoryResult;
+    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) {
+        err.decision.then((decision) => {
+          if (decision === "stop") {
+            budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
+            aborter.abort();
+          }
+        }).catch(() => {
+          budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
+          aborter.abort();
+        });
+        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) => {
+        try {
+          ctx.budget.recordToolCall();
+        } catch (eb) {
+          onBudgetError(eb);
+        }
+        if (e.ok === false) {
+          lastToolFailed = e.name;
+        } else if (e.ok === true) {
+          lastToolFailed = null;
+        }
+      }),
+      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", () => {
+        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) => {
+        streamingTextAcc = (streamingTextAcc + e.text).slice(-200);
+      })
+    );
+    const onParentAbort = () => aborter.abort();
+    ctx.signal.addEventListener("abort", onParentAbort);
+    let result;
+    try {
+      result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
+    } 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) {
+        const decision = await budgetError.decision;
+        if (decision === "stop") {
+          budgetError = new BudgetExceededError(
+            budgetError.kind,
+            budgetError.limit,
+            budgetError.used
+          );
+        } else {
+          budgetError = null;
+        }
+      }
+      if (budgetError) throw budgetError;
+    }
+    if (result.status === "failed") {
+      throw result.error instanceof Error ? result.error : new Error(String(result.error ?? "agent failed"));
+    }
+    if (result.status === "aborted") {
+      throw new Error("agent aborted");
+    }
+    if (result.status === "max_iterations") {
+      throw new Error("agent exhausted iteration limit");
+    }
+    const usage = ctx.budget.usage();
+    const finalText = (result.finalText ?? "").trim();
+    if (finalText.length === 0 && usage.toolCalls === 0) {
+      throw new Error("empty response");
+    }
+    if (finalText.length === 0 && lastToolFailed !== null) {
+      throw new Error(`tool failed: ${lastToolFailed}`);
+    }
+    return {
+      result: result.finalText,
+      iterations: result.iterations,
+      toolCalls: usage.toolCalls
+    };
+  };
+}
+function defaultFormatTaskInput(task) {
+  return task.description ?? "";
+}
+
+// src/coordination/fleet.ts
+var AUDIT_LOG_AGENT = {
+  id: "audit-log",
+  name: "Audit Log",
+  role: "audit-log",
+  prompt: `You are the Audit Log agent. Your job is to analyze structured JSONL
+session logs and produce actionable markdown reports.
+
+Scope:
+- Parse session logs (iteration counts, tool calls, errors, usage)
+- Detect repeated failure patterns across multiple runs
+- Identify tool usage anomalies (over-use, failures, unexpected chains)
+- Track token consumption trends
+- Generate structured audit reports with severity ratings
+
+Input format you accept:
+{ "task": "analyze | report | trends", "sessionPath": "<path>", "focus": "errors | tools | usage | all" }
+
+Output: Markdown audit report with sections:
+- ## Summary (totals, error rate)
+- ## Top Errors (count + context)
+- ## Tool Usage (table with calls, failures, avg duration)
+- ## Anomalies (pattern \u2192 severity)
+
+Working rules:
+- Never fabricate numbers \u2014 read the actual logs first
+- Always include file:line references for errors
+- If sessionPath is missing, ask the director to provide it
+- Report confidence level: high (>90% accuracy), medium, low`
+  // No hardcoded budgets — the orchestrator (delegate tool or
+  // spawn_subagent) decides per-task how much room a subagent gets.
+  // A monorepo audit needs hours; a single-file lint check needs
+  // seconds. Pinning a number here forces the orchestrator to fight
+  // the role's default instead of just asking for what it needs.
+};
+var BUG_HUNTER_AGENT = {
+  id: "bug-hunter",
+  name: "Bug Hunter",
+  role: "bug-hunter",
   prompt: `You are the Bug Hunter agent. Your job is to systematically scan
 source code for bugs, anti-patterns, and code smells using pattern matching
 and heuristics. Output a prioritized hit list with file:line references.
@@ -6818,10 +6479,10 @@ var FLEET_ROSTER = {
   "security-scanner": SECURITY_SCANNER_AGENT
 };
 var FLEET_ROSTER_BUDGETS = {
-  "audit-log": { timeoutMs: 5 * 60 * 1e3, maxIterations: 80, maxToolCalls: 300 },
-  "bug-hunter": { timeoutMs: 10 * 60 * 1e3, maxIterations: 120, maxToolCalls: 400 },
-  "refactor-planner": { timeoutMs: 8 * 60 * 1e3, maxIterations: 100, maxToolCalls: 350 },
-  "security-scanner": { timeoutMs: 10 * 60 * 1e3, maxIterations: 120, maxToolCalls: 400 }
+  "audit-log": { timeoutMs: 8 * 60 * 1e3, maxIterations: 150, maxToolCalls: 500 },
+  "bug-hunter": { timeoutMs: 15 * 60 * 1e3, maxIterations: 200, maxToolCalls: 600 },
+  "refactor-planner": { timeoutMs: 12 * 60 * 1e3, maxIterations: 180, maxToolCalls: 550 },
+  "security-scanner": { timeoutMs: 15 * 60 * 1e3, maxIterations: 200, maxToolCalls: 600 }
 };
 function applyRosterBudget(cfg) {
   const defaultBudget = FLEET_ROSTER_BUDGETS[cfg.role ?? ""];
@@ -6961,6 +6622,33 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   results() {
     return this.completedResults;
   }
+  /**
+   * 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) {
+    return Promise.all(
+      taskIds.map((id) => {
+        const cached = this.completedResults.find((r) => r.taskId === id);
+        if (cached) return cached;
+        return new Promise((resolve2, reject) => {
+          const timeout = setTimeout(() => {
+            this.off("task.completed", handler);
+            reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
+          }, this.config.timeoutMs ?? 3e5);
+          const handler = ({ result }) => {
+            if (result.taskId === id) {
+              clearTimeout(timeout);
+              this.off("task.completed", handler);
+              resolve2(result);
+            }
+          };
+          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
@@ -7179,8 +6867,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
               return;
             }
             if (decision === "throw" || decision === "stop") {
-              this.subagents.get(ctx.subagentId)?.abortController.abort();
-              reject(new BudgetExceededError("timeout", limit, elapsed));
+              armFor(Math.max(1e3, limit));
               return;
             }
             if (decision.extend.timeoutMs !== void 0) {
@@ -7230,123 +6917,981 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
         subagent.abortController = new AbortController();
       }
     }
-    this.terminating.delete(result.subagentId);
-    this.emit("task.completed", {
-      task: subagent?.context.tasks.find((t) => t.id === result.taskId) ?? { id: result.taskId },
-      result
-    });
-    this.tryDispatchNext();
-    if (this.isDone()) {
-      this.emit("done", {
-        results: this.completedResults,
-        totalIterations: this.totalIterations
+    this.terminating.delete(result.subagentId);
+    this.emit("task.completed", {
+      task: subagent?.context.tasks.find((t) => t.id === result.taskId) ?? { id: result.taskId },
+      result
+    });
+    this.tryDispatchNext();
+    if (this.isDone()) {
+      this.emit("done", {
+        results: this.completedResults,
+        totalIterations: this.totalIterations
+      });
+    }
+  }
+  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;
+  }
+};
+function classifySubagentError(err, hints = {}) {
+  const cause = err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : void 0;
+  if (err instanceof ProviderError) {
+    const baseMessage2 = err.describe();
+    return providerErrorToSubagentError(err, baseMessage2, cause);
+  }
+  const baseMessage = err instanceof Error ? err.message : String(err);
+  if (err instanceof BudgetExceededError) {
+    const map = {
+      iterations: "budget_iterations",
+      tool_calls: "budget_tool_calls",
+      tokens: "budget_tokens",
+      cost: "budget_cost",
+      timeout: "budget_timeout"
+    };
+    return {
+      kind: map[err.kind],
+      message: baseMessage,
+      // Budgets are user-configured ceilings, not transient failures —
+      // retrying with the same budget will hit the same ceiling. The
+      // orchestrator must raise the budget or narrow the task first.
+      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) {
+  const status = err.status;
+  if (status === 429 || err.body?.type === "rate_limit_error") {
+    return {
+      kind: "provider_rate_limit",
+      message,
+      retryable: true,
+      // Conservative default: 5s. Provider-specific code can override
+      // by emitting an error whose body carries an explicit hint.
+      backoffMs: 5e3,
+      cause
+    };
+  }
+  if (status === 401 || status === 403 || err.body?.type === "authentication_error") {
+    return { kind: "provider_auth", message, retryable: false, cause };
+  }
+  if (status === 408 || status === 0) {
+    return { kind: "provider_timeout", message, retryable: true, cause };
+  }
+  if (status >= 500 && status < 600) {
+    return {
+      kind: "provider_5xx",
+      message,
+      retryable: true,
+      backoffMs: 3e3,
+      cause
+    };
+  }
+  return { kind: "unknown", message, retryable: err.retryable, cause };
+}
+
+// src/execution/parallel-eternal-engine.ts
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
+var ParallelEternalEngine = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.goalPath = goalFilePath(opts.projectRoot);
+    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
+    this.timeoutMs = opts.iterationTimeoutMs ?? 3e5;
+    this.agentFactory = opts.subagentFactory ?? (async (config) => ({
+      agent: this.opts.agent,
+      events: this.opts.agent.events
+    }));
+  }
+  opts;
+  state = "idle";
+  stopRequested = false;
+  iterationsSinceCompact = 0;
+  iterations = 0;
+  consecutiveFailures = 0;
+  goalPath;
+  slots;
+  timeoutMs;
+  coordinator = null;
+  agentFactory;
+  get currentState() {
+    return this.state;
+  }
+  stop() {
+    this.stopRequested = true;
+    void this.persistState("stopped").catch(() => {
+    });
+    this.state = "stopped";
+  }
+  async prime() {
+    this.stopRequested = false;
+    this.state = "running";
+    await this.persistState("running");
+  }
+  async run() {
+    this.state = "running";
+    await this.persistState("running");
+    const config = {
+      coordinatorId: `parallel-${randomUUID().slice(0, 8)}`,
+      maxConcurrent: this.slots,
+      doneCondition: { type: "all_tasks_done" }
+    };
+    this.coordinator = new DefaultMultiAgentCoordinator(config);
+    const runner = makeAgentSubagentRunner({ factory: this.agentFactory });
+    this.coordinator.setRunner?.(runner);
+    try {
+      while (!this.stopRequested) {
+        try {
+          await this.runOneIteration();
+        } catch (err) {
+          this.consecutiveFailures++;
+          this.opts.onError?.(err instanceof Error ? err : new Error(String(err)), this.consecutiveFailures);
+          await this.appendFailure("engine error", err instanceof Error ? err.message : String(err));
+        }
+        if (this.stopRequested) break;
+        await sleep2(2e3);
+      }
+    } finally {
+      this.state = "stopped";
+      await this.persistState("stopped").catch(() => {
+      });
+    }
+  }
+  /**
+   * Execute one tick: decompose → fan-out → aggregate → compact.
+   * Called by the REPL in its main loop (REPL drives, engine is stateless per tick).
+   */
+  async runOneIteration() {
+    this.iterations++;
+    const goal = await loadGoal(this.goalPath);
+    if (!goal) {
+      this.stopRequested = true;
+      return false;
+    }
+    if (goal.goalState !== "active") {
+      this.stopRequested = true;
+      return false;
+    }
+    if (!this.coordinator) {
+      const config = {
+        coordinatorId: `parallel-${randomUUID().slice(0, 8)}`,
+        maxConcurrent: this.slots,
+        doneCondition: { type: "all_tasks_done" }
+      };
+      this.coordinator = new DefaultMultiAgentCoordinator(config);
+      const runner = makeAgentSubagentRunner({ factory: this.agentFactory });
+      this.coordinator.setRunner?.(runner);
+    }
+    const tasks = await this.decomposeGoal(goal);
+    if (!tasks || tasks.length === 0) {
+      await sleep2(5e3);
+      return false;
+    }
+    const fanOut = await this.fanOut(goal, tasks);
+    this.iterationsSinceCompact++;
+    const successCount = fanOut.results.filter((r) => r.status === "success").length;
+    const status = fanOut.goalComplete ? "success" : fanOut.allSuccessful ? "success" : "failure";
+    const note = [
+      `${successCount}/${fanOut.results.length} subagents succeeded`,
+      fanOut.goalComplete ? "[GOAL_COMPLETE]" : "",
+      fanOut.partialOutput ? `Output: ${fanOut.partialOutput.slice(0, 120)}` : ""
+    ].filter(Boolean).join(" | ");
+    await this.appendIterationEntry({
+      source: "parallel",
+      task: `parallel:${tasks.length} slots \u2014 ${tasks.slice(0, 3).join(", ")}${tasks.length > 3 ? "..." : ""}`,
+      status,
+      note
+    });
+    if (fanOut.goalComplete) {
+      this.stopRequested = true;
+      return true;
+    }
+    await this.maybeCompact();
+    return fanOut.allSuccessful;
+  }
+  // -------------------------------------------------------------------------
+  // Fan-out
+  // -------------------------------------------------------------------------
+  async fanOut(goal, tasks) {
+    const coordinator = this.coordinator;
+    const slotCount = Math.min(this.slots, tasks.length);
+    const recentJournal = goal.journal.slice(-5).map((e) => `  #${e.iteration} [${e.status}] ${e.task}${e.note ? ` \u2014 ${e.note.slice(0, 80)}` : ""}`).join("\n");
+    const directivePreamble = [
+      "\u2550\u2550\u2550 ETERNAL AUTONOMY \u2014 parallel task slot \u2550\u2550\u2550",
+      "",
+      `Mission: ${goal.goal}`,
+      `Total parallel slots: ${slotCount}`,
+      "",
+      recentJournal ? `Recent journal (last 5):
+${recentJournal}` : "No prior iterations.",
+      "",
+      "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
+      "\u2022 Execute the assigned task end-to-end using multiple tool calls.",
+      "\u2022 Emit `[done]` on its own line when the task is complete.",
+      "\u2022 Do not ask for confirmation \u2014 YOLO is active.",
+      "\u2022 If the overall Mission is accomplished, emit `[GOAL_COMPLETE]` followed by a verification recipe.",
+      "\u2022 Keep output concise \u2014 summarize findings, do not transcribe files."
+    ].join("\n");
+    const taskIds = [];
+    const subagentIds = [];
+    const spawnPromises = [];
+    for (let i = 0; i < slotCount; i++) {
+      const task = tasks[i];
+      const subagentId = `parallel-${this.iterations}-${i}`;
+      const taskId = randomUUID();
+      const spec = {
+        id: taskId,
+        description: `${directivePreamble}
+
+\u2500\u2500 SLOT ${i + 1}/${slotCount} \u2500\u2500
+Task: ${task}
+`,
+        subagentId
+      };
+      spawnPromises.push((async () => {
+        try {
+          await coordinator.spawn({
+            id: subagentId,
+            name: `slot-${subagentId.slice(-6)}`,
+            maxIterations: 50,
+            maxToolCalls: 200,
+            timeoutMs: this.timeoutMs
+          });
+          subagentIds.push(subagentId);
+          taskIds.push(taskId);
+          await coordinator.assign(spec);
+        } catch {
+        }
+      })());
+    }
+    await Promise.all(spawnPromises);
+    if (taskIds.length === 0) {
+      return { results: [], allSuccessful: false, goalComplete: false, partialOutput: "" };
+    }
+    let results = [];
+    try {
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), this.timeoutMs + 6e4);
+      try {
+        results = await coordinator.awaitTasks(taskIds);
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+      results = coordinator.results().slice(-taskIds.length);
+    }
+    const allSuccessful = results.length > 0 && results.every((r) => r.status === "success");
+    const goalComplete = results.some(
+      (r) => r.status === "success" && typeof r.result === "string" && GOAL_COMPLETE_MARKER2.test(r.result)
+    );
+    const partialOutput = results.map((r) => typeof r.result === "string" ? r.result : "").filter(Boolean).join("\n\n");
+    return { results, allSuccessful, goalComplete, partialOutput };
+  }
+  // -------------------------------------------------------------------------
+  // Goal decomposition
+  // -------------------------------------------------------------------------
+  async decomposeGoal(goal) {
+    const todos = this.opts.agent.ctx?.todos;
+    const tasks = [];
+    if (Array.isArray(todos)) {
+      const pending = todos.filter((t) => t.status === "pending").slice(0, this.slots);
+      for (const t of pending) {
+        tasks.push(`[todo] ${t.content}`);
+      }
+    }
+    if (tasks.length < this.slots) {
+      try {
+        const gitStatus = await (this.opts.gitStatusReader?.() ?? this.readGitStatus());
+        const dirty = gitStatus.trim();
+        if (dirty) {
+          const lines = dirty.split("\n").slice(0, this.slots - tasks.length);
+          for (const line of lines) {
+            const file = line.replace(/^[ MADRUC?]{2}\s*/, "").trim();
+            if (file) tasks.push(`[git] inspect and fix: ${file}`);
+          }
+        }
+      } catch {
+      }
+    }
+    if (tasks.length < this.slots) {
+      const remaining = this.slots - tasks.length;
+      const brainstormed = await this.brainstormSubtasks(goal, remaining);
+      tasks.push(...brainstormed);
+    }
+    return tasks.length > 0 ? tasks.slice(0, this.slots) : null;
+  }
+  async readGitStatus() {
+    const { execFile: execFile2 } = await import('child_process');
+    const { promisify: promisify2 } = await import('util');
+    const execFileP2 = promisify2(execFile2);
+    const { stdout } = await execFileP2("git", ["status", "--porcelain"], {
+      cwd: this.opts.projectRoot,
+      timeout: 5e3
+    });
+    return stdout;
+  }
+  async brainstormSubtasks(goal, count) {
+    const lastFew = goal.journal.slice(-5).map((e) => `  - [${e.status}] ${e.task}`).join("\n");
+    const directive = [
+      `Decompose this goal into exactly ${count} independent sub-tasks for parallel execution.`,
+      "",
+      `Goal: ${goal.goal}`,
+      "",
+      lastFew ? `Recent:
+${lastFew}` : "No prior iterations.",
+      "",
+      `Output exactly ${count} tasks, one per line, under 120 chars each.`,
+      "Format: TASK-1 | TASK-2 | ... (pipe-separated, no numbering, no preamble).",
+      "Each task must be independently actionable with no shared dependencies."
+    ].join("\n");
+    try {
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), 6e4);
+      try {
+        const result = await this.opts.agent.run([{ type: "text", text: directive }], {
+          signal: ctrl.signal,
+          maxIterations: 1
+        });
+        if (result.status !== "done") return [];
+        const text = (result.finalText ?? "").trim();
+        if (!text) return [];
+        const tasks = text.split("|").map((t) => t.trim()).filter((t) => t.length > 10 && t.length < 240);
+        return tasks.slice(0, count);
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+      return [];
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Compaction
+  // -------------------------------------------------------------------------
+  async maybeCompact() {
+    const compactor = this.opts.compactor;
+    if (!compactor) return;
+    const ctx = this.opts.agent.ctx;
+    if (!ctx) return;
+    const shouldRun = this.iterationsSinceCompact >= (this.opts.compactEveryNIterations ?? 25);
+    if (!shouldRun) return;
+    const report = await compactor.compact(ctx, { aggressive: false });
+    this.iterationsSinceCompact = 0;
+    await this.appendIterationEntry({
+      source: "manual",
+      task: "compaction (cadence)",
+      status: "success",
+      note: `saved ~${report.before - report.after} tokens`
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Helpers
+  // -------------------------------------------------------------------------
+  async appendIterationEntry(entry) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    const updated = appendJournal(current, entry);
+    await saveGoal(this.goalPath, updated);
+    const entryWithMeta = {
+      at: (this.opts.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+      iteration: updated.iterations,
+      ...entry
+    };
+    this.opts.onIteration?.(entryWithMeta);
+  }
+  async appendFailure(task, note) {
+    await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
+  }
+  async persistState(state) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    if (current.engineState === state) return;
+    await saveGoal(this.goalPath, { ...current, engineState: state });
+  }
+};
+
+// src/execution/autonomy-prompt-contributor.ts
+function makeAutonomyPromptContributor(opts) {
+  return async (ctx) => {
+    if (ctx.subagent) return [];
+    if (!opts.enabled()) return [];
+    let goal;
+    try {
+      goal = await loadGoal(opts.goalPath);
+    } catch {
+      return [];
+    }
+    if (!goal) return [];
+    const missionState = goal.goalState ?? "active";
+    if (missionState !== "active") return [];
+    const tailSize = opts.journalTailSize ?? 5;
+    const journalTail = goal.journal.slice(-tailSize).map((e) => {
+      const note = e.note ? ` \u2014 ${e.note.slice(0, 80)}` : "";
+      return `  #${e.iteration} [${e.status}] ${e.task}${note}`;
+    });
+    const text = [
+      "## ETERNAL AUTONOMY \u2014 active mission",
+      "",
+      "You are inside a long-running autonomous loop. The user is asleep",
+      "and is not available to confirm decisions. Each turn you receive a",
+      "directive describing one concrete sub-task that advances the mission.",
+      "",
+      `Mission: ${goal.goal}`,
+      `Iteration: #${goal.iterations}`,
+      journalTail.length > 0 ? `Recent journal (last ${journalTail.length}):
+${journalTail.join("\n")}` : "Recent journal: (none \u2014 this is the first iteration)",
+      "",
+      "### Loop control markers",
+      "Emit these on their own line in your final text \u2014 case-insensitive,",
+      "whitespace-tolerant, but they must occupy the entire line:",
+      "- `[continue]` \u2014 chain to the next internal step without returning.",
+      "- `[done]` \u2014 the current sub-task is finished; return to the engine.",
+      "- `[GOAL_COMPLETE]` \u2014 emit ONLY when the OVERALL mission is",
+      "  verifiably done. Must be followed by a one-paragraph verification",
+      "  recipe (artifact path, test command, or 10-second reproduction).",
+      "  The engine halts on this marker \u2014 false positives waste real",
+      "  human time. If unsure, emit `[done]` and let the next iteration",
+      "  decide.",
+      "",
+      "### Operating principles",
+      "- YOLO is active. Do NOT ask for confirmation, do NOT propose",
+      "  options. Pick the best path and execute it.",
+      "- Use tools freely; multiple calls per turn are normal and expected.",
+      "- When working on a todo, mark it `in_progress` via the todos tool",
+      "  before tool work and `completed` (or `cancelled` with a reason)",
+      "  when done. The loop reads todo state between iterations.",
+      "- If an approach fails twice in a row, pivot. Don't grind on the",
+      "  same wall \u2014 try a different angle, file a cancel on the todo, or",
+      "  surface the obstacle via `[done]` and let the next iteration",
+      "  re-plan."
+    ].join("\n");
+    return [
+      {
+        type: "text",
+        text,
+        cache_control: { type: "ephemeral" }
+      }
+    ];
+  };
+}
+
+// src/execution/goal-preamble.ts
+function buildGoalPreamble(goal) {
+  return [
+    "[GOAL \u2014 LOCKED IN. You will work on this until it is verifiably done.",
+    "The user granted you full autonomy. Read these constraints once, then act.",
+    "",
+    "YOUR GOAL:",
+    "---",
+    goal,
+    "---",
+    "",
+    "AUTHORITY YOU HAVE:",
+    "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
+    "  Parallel + recursive fan-out are both fine. There is no spawn budget.",
+    "- Use any provider/model per subagent \u2014 pick the right tool for each",
+    "  piece of work. Heavy reasoning model for planning, fast model for",
+    "  batch work, specialist model for domain code.",
+    "- Run unlimited tool calls and iterations. There is NO hidden budget.",
+    "  The Agent loop auto-extends every 100 iterations forever.",
+    "- Retry failed tools with different inputs, alternative paths, fresh",
+    "  subagents. Switch providers mid-run if one is rate-limited.",
+    "- Re-plan freely when an approach hits a dead end. You are not obliged",
+    "  to stick with the first plan you proposed.",
+    "",
+    'WHAT "DONE" MEANS \u2014 non-negotiable:',
+    "- You can name a concrete artifact (a passing test, a written file at",
+    "  a specific path, a fixed bug verified by re-running the failing case,",
+    "  a clean grep that previously had matches).",
+    "- You can tell the user HOW to verify it themselves in 10 seconds.",
+    '- You have NOT hedged. None of: "looks like it should work", "I',
+    '  believe this fixes it", "the changes appear correct".',
+    "",
+    "WHAT IS NOT DONE \u2014 never report any of these as completion:",
+    "- An error message you didn't recover from.",
+    '- An empty result, a 0-line file, a "no matches found" you accepted',
+    "  without questioning the search.",
+    '- "Should I continue?" / "Want me to also...?" / "Let me know if you',
+    '  want X." Those are hedges. The user already told you to finish the',
+    "  goal \u2014 just do it.",
+    "- Partial progress dressed up as success. Fixed 3 of 5 bugs = 60%",
+    "  done, not done.",
+    "- A subagent's failed/timeout/stopped TaskResult that you didn't",
+    "  respond to with a fresh attempt (different role, different model,",
+    "  tighter prompt).",
+    "",
+    "PERSISTENCE PROTOCOL:",
+    "- If blocked, try at least 3 different angles before reporting the",
+    "  problem to the user. Different tool inputs, different subagent",
+    "  roles, different providers, different decomposition of the task.",
+    "- If a tool fails, read its error, alter the input, try again. Do",
+    "  not just report the failure back.",
+    "- If a subagent returns useless output, respawn with a tighter prompt",
+    '  or a different role. Do not accept "I could not determine\u2026" as the',
+    "  final answer.",
+    "- Use `ask_subagent` for one-shot questions when you don't need a",
+    "  full delegated task.",
+    "",
+    "REPORTING:",
+    "- Stream short progress notes between major actions so the user can",
+    "  monitor. Do not go silent for 50 tool calls then dump a wall of",
+    "  text \u2014 but also do not narrate every tool call.",
+    "- Use the shared scratchpad (if available) to leave breadcrumbs",
+    "  subagents can read.",
+    "- Final response must include: (a) what was accomplished, (b) how",
+    "  to verify, (c) any caveats (residual TODOs, things the user",
+    "  should know about).",
+    "",
+    "BEGIN.]"
+  ].join("\n");
+}
+
+// src/coordination/director.ts
+init_atomic_write();
+
+// src/coordination/in-memory-transport.ts
+var InMemoryBridgeTransport = class {
+  subs = /* @__PURE__ */ new Map();
+  send(msg, to) {
+    if (to === "*") {
+      for (const [id, handlers2] of this.subs) {
+        if (id === msg.from) continue;
+        for (const h of handlers2) {
+          try {
+            h(msg);
+          } catch {
+          }
+        }
+      }
+      return Promise.resolve();
+    }
+    const handlers = this.subs.get(to);
+    if (handlers) {
+      for (const h of handlers) {
+        try {
+          h(msg);
+        } catch {
+        }
+      }
+    }
+    return Promise.resolve();
+  }
+  subscribe(agentId, handler) {
+    if (!this.subs.has(agentId)) this.subs.set(agentId, /* @__PURE__ */ new Set());
+    this.subs.get(agentId).add(handler);
+    return () => this.subs.get(agentId)?.delete(handler);
+  }
+  close(agentId) {
+    this.subs.delete(agentId);
+    return Promise.resolve();
+  }
+};
+
+// src/coordination/agent-bridge.ts
+var InMemoryAgentBridge = class {
+  agentId;
+  coordinatorId;
+  transport;
+  subscriptions = /* @__PURE__ */ new Set();
+  pendingRequests = /* @__PURE__ */ new Map();
+  stopped = false;
+  timeoutMs;
+  /** Guards request() so concurrent calls on the same id can't silently overwrite. */
+  inflightGuards = /* @__PURE__ */ new Set();
+  constructor(config, transport) {
+    this.agentId = config.agentId;
+    this.coordinatorId = config.coordinatorId;
+    this.transport = transport;
+    this.timeoutMs = config.timeoutMs ?? 3e4;
+    this.transport.subscribe(this.agentId, (msg) => {
+      if (msg.type === "heartbeat") return;
+      const pending = this.pendingRequests.get(msg.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(msg.id);
+        this.inflightGuards.delete(msg.id);
+        pending.resolve(msg);
+        return;
+      }
+      for (const h of this.subscriptions) {
+        try {
+          h(msg);
+        } catch {
+        }
+      }
+    });
+  }
+  async send(msg) {
+    msg.timestamp = Date.now();
+    await this.transport.send(msg, msg.to ?? this.coordinatorId);
+  }
+  async broadcast(msg) {
+    msg.timestamp = Date.now();
+    msg.to = "*";
+    await this.transport.send(msg, "*");
+  }
+  subscribe(handler) {
+    this.subscriptions.add(handler);
+    return () => this.subscriptions.delete(handler);
+  }
+  async request(msg, timeoutMs) {
+    if (this.stopped) throw new Error("Bridge is stopped");
+    const timeout = timeoutMs ?? this.timeoutMs;
+    const correlationId = msg.id;
+    if (this.inflightGuards.has(correlationId)) {
+      throw new Error(
+        `Bridge request id "${correlationId}" collides with an in-flight request \u2014 caller is reusing message ids`
+      );
+    }
+    this.inflightGuards.add(correlationId);
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.inflightGuards.delete(correlationId);
+        this.pendingRequests.delete(correlationId);
+        reject(new Error(`Request ${correlationId} timed out after ${timeout}ms`));
+      }, timeout);
+      if (this.stopped) {
+        clearTimeout(timer);
+        this.inflightGuards.delete(correlationId);
+        this.pendingRequests.delete(correlationId);
+        reject(new Error("Bridge stopped"));
+        return;
+      }
+      this.pendingRequests.set(correlationId, {
+        resolve: resolve2,
+        reject,
+        timer
       });
-    }
+      msg.timestamp = Date.now();
+      this.transport.send(msg, msg.to ?? this.coordinatorId).catch((e) => {
+        clearTimeout(timer);
+        this.inflightGuards.delete(correlationId);
+        this.pendingRequests.delete(correlationId);
+        reject(e);
+      });
+    });
   }
-  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;
+  async stop() {
+    this.stopped = true;
+    for (const [, p] of this.pendingRequests) {
+      clearTimeout(p.timer);
+      p.reject(new Error("Bridge stopped"));
     }
-    return false;
+    this.pendingRequests.clear();
+    this.inflightGuards.clear();
+    this.subscriptions.clear();
+    await this.transport.close(this.agentId);
   }
 };
-function classifySubagentError(err, hints = {}) {
-  const cause = err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : void 0;
-  if (err instanceof ProviderError) {
-    const baseMessage2 = err.describe();
-    return providerErrorToSubagentError(err, baseMessage2, cause);
+function createMessage(type, from, payload, to) {
+  return {
+    id: randomUUID(),
+    type,
+    from,
+    to,
+    payload,
+    timestamp: Date.now(),
+    priority: "normal"
+  };
+}
+
+// src/coordination/director-prompts.ts
+var DEFAULT_DIRECTOR_PREAMBLE = `You are the Director of a multi-agent fleet. You orchestrate worker
+subagents by spawning them, assigning tasks, awaiting completions, and
+rolling up their outputs into your next decision.
+
+Core fleet tools available to you:
+  - spawn_subagent       \u2014 create a worker with a chosen provider / model / role
+  - assign_task          \u2014 hand a piece of work to a specific subagent
+  - await_tasks          \u2014 block until named task ids complete (parallel-safe)
+  - ask_subagent         \u2014 synchronously query a running subagent via the bridge
+  - roll_up              \u2014 aggregate finished tasks into a markdown/json summary
+  - terminate_subagent   \u2014 abort a stuck worker (use sparingly)
+  - fleet_status         \u2014 snapshot of all subagents and pending tasks
+  - fleet_usage          \u2014 token + cost breakdown per subagent and total
+
+Working rules:
+  1. Decompose first. Before spawning, decide which sub-tasks are
+     independent and can run in parallel. Sequential work doesn't need a
+     subagent \u2014 do it yourself.
+  2. Match worker to job. Cheap/fast model for triage, capable model for
+     synthesis. Different providers per sibling is allowed and encouraged.
+  3. Always pair an assign with an await. Don't fire-and-forget; you owe
+     the user a single coherent answer at the end.
+  4. Roll up before deciding. After await_tasks resolves, call roll_up so
+     the results are folded back into your context in a compact form.
+  5. Budget is real. Check fleet_usage periodically. If a subagent is
+     thrashing, terminate it rather than letting cost climb silently.
+  6. Never claim a subagent's work as your own without verifying it. If a
+     result looks wrong, ask_subagent for clarification before passing it
+     to the user.`;
+var DEFAULT_SUBAGENT_BASELINE = `You are a subagent operating under a Director. You were spawned to handle
+a specific slice of a larger plan \u2014 do that slice well and report back.
+
+Bridge contract:
+  - You have a parent (the Director). You may call \`request\` on the
+    parent bridge to ask a clarifying question. Use this sparingly; the
+    parent is also working.
+  - You MAY NOT request the parent's system prompt, tool list, or other
+    subagents' context. Those are not yours to read.
+  - Your final task output is what the Director sees. Be concise,
+    structured, and self-contained \u2014 assume the Director will paste your
+    output into its own context.`;
+function composeDirectorPrompt(parts = {}) {
+  const sections = [];
+  const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
+  if (preamble && preamble.trim().length > 0) sections.push(preamble.trim());
+  if (parts.rosterSummary && parts.rosterSummary.trim().length > 0) {
+    sections.push(`Available roles you can spawn:
+${parts.rosterSummary.trim()}`);
   }
-  const baseMessage = err instanceof Error ? err.message : String(err);
-  if (err instanceof BudgetExceededError) {
-    const map = {
-      iterations: "budget_iterations",
-      tool_calls: "budget_tool_calls",
-      tokens: "budget_tokens",
-      cost: "budget_cost",
-      timeout: "budget_timeout"
-    };
-    return {
-      kind: map[err.kind],
-      message: baseMessage,
-      // Budgets are user-configured ceilings, not transient failures —
-      // retrying with the same budget will hit the same ceiling. The
-      // orchestrator must raise the budget or narrow the task first.
-      retryable: false,
-      cause
-    };
+  if (parts.basePrompt && parts.basePrompt.trim().length > 0) {
+    sections.push(parts.basePrompt.trim());
   }
-  if (hints.parentAborted) {
-    return {
-      kind: "aborted_by_parent",
-      message: baseMessage,
-      retryable: false,
-      cause
-    };
+  return sections.join("\n\n");
+}
+function composeSubagentPrompt(parts = {}) {
+  const sections = [];
+  const baseline = parts.baseline ?? DEFAULT_SUBAGENT_BASELINE;
+  if (baseline && baseline.trim().length > 0) sections.push(baseline.trim());
+  if (parts.role && parts.role.trim().length > 0) {
+    sections.push(`Role:
+${parts.role.trim()}`);
   }
-  const lower = baseMessage.toLowerCase();
-  if (/agent aborted$/i.test(baseMessage)) {
-    return {
-      kind: "aborted_by_parent",
-      message: baseMessage,
-      retryable: false,
-      cause
+  if (parts.task && parts.task.trim().length > 0) {
+    sections.push(`Task:
+${parts.task.trim()}`);
+  }
+  if (parts.sharedScratchpad && parts.sharedScratchpad.trim().length > 0) {
+    sections.push(
+      `Shared notes:
+A scratchpad shared with the rest of the fleet is mounted at \`${parts.sharedScratchpad.trim()}\`.
+- Write your final findings as markdown files there (e.g. \`findings.md\`, \`security.md\`).
+- Before starting, list the directory and read any sibling files relevant to your task \u2014 they may already contain context you can build on.
+- Use stable filenames (one file per concern); overwrite instead of appending so the Director sees the latest state.`
+    );
+  }
+  if (parts.override && parts.override.trim().length > 0) {
+    sections.push(parts.override.trim());
+  }
+  return sections.join("\n\n");
+}
+function rosterSummaryFromConfigs(roster) {
+  const lines = [];
+  for (const [roleId, cfg] of Object.entries(roster)) {
+    const tag = cfg.provider && cfg.model ? ` (${cfg.provider}/${cfg.model})` : "";
+    const headline = cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").trim().slice(0, 80) : "";
+    const tail = headline ? ` \u2014 ${headline}` : "";
+    lines.push(`- ${roleId}: ${cfg.name}${tag}${tail}`);
+  }
+  return lines.join("\n");
+}
+
+// src/coordination/fleet-bus.ts
+var FleetBus = class {
+  byId = /* @__PURE__ */ new Map();
+  byType = /* @__PURE__ */ new Map();
+  any = /* @__PURE__ */ new Set();
+  /**
+   * Hook a subagent's EventBus into the fleet. EventBus is strongly
+   * typed and doesn't expose an `onAny` hook, so we subscribe to the
+   * canonical set of event types a subagent emits during a run. New
+   * event types added to the kernel must be added here too — but the
+   * cost is a tiny single line per type, and the explicit list keeps
+   * the wire format clear.
+   *
+   * Returns a disposer that detaches every subscription; call on
+   * subagent teardown so the listeners don't outlive the run.
+   */
+  attach(subagentId, bus, taskId) {
+    const off = bus.onPattern("*", (type, payload) => {
+      if (type.startsWith("subagent.")) return;
+      this.emit({ subagentId, taskId, ts: Date.now(), type, payload });
+    });
+    return () => {
+      off();
     };
   }
-  if (/agent exhausted iteration limit$/i.test(baseMessage)) {
-    return { kind: "budget_iterations", message: baseMessage, retryable: false, cause };
+  /** Subscribe to every event from one subagent. */
+  subscribe(subagentId, handler) {
+    let set = this.byId.get(subagentId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byId.set(subagentId, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
   }
-  if (/empty response$/i.test(baseMessage)) {
-    return { kind: "empty_response", message: baseMessage, retryable: false, cause };
+  /** Subscribe to one event type across all subagents. */
+  filter(type, handler) {
+    let set = this.byType.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byType.set(type, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
   }
-  if (/^tool failed: /i.test(baseMessage)) {
-    return { kind: "tool_failed", message: baseMessage, retryable: false, cause };
+  /** Subscribe to literally everything. The fleet roll-up uses this. */
+  onAny(handler) {
+    this.any.add(handler);
+    return () => {
+      this.any.delete(handler);
+    };
   }
-  if (lower.includes("bridge transport") || /bridge.*(closed|disconnect)/i.test(baseMessage)) {
-    return { kind: "bridge_failed", message: baseMessage, retryable: false, cause };
+  emit(event) {
+    const byId = this.byId.get(event.subagentId);
+    if (byId)
+      for (const h of byId) {
+        try {
+          h(event);
+        } catch {
+        }
+      }
+    const byType = this.byType.get(event.type);
+    if (byType)
+      for (const h of byType) {
+        try {
+          h(event);
+        } catch {
+        }
+      }
+    for (const h of this.any) {
+      try {
+        h(event);
+      } catch {
+      }
+    }
   }
-  if (/context length|max.*tokens?.*exceeded|prompt is too long/i.test(baseMessage)) {
-    return { kind: "context_overflow", message: baseMessage, retryable: false, cause };
+};
+var FleetUsageAggregator = class {
+  constructor(bus, priceLookup, metaLookup) {
+    this.bus = bus;
+    this.priceLookup = priceLookup;
+    this.metaLookup = metaLookup;
+    bus.filter("provider.response", (e) => this.onProviderResponse(e));
+    bus.filter("tool.executed", (e) => this.onToolExecuted(e));
+    bus.filter("iteration.started", (e) => this.onIterationStarted(e));
   }
-  return {
-    kind: "unknown",
-    message: baseMessage,
-    retryable: false,
-    cause
-  };
-}
-function providerErrorToSubagentError(err, message, cause) {
-  const status = err.status;
-  if (status === 429 || err.body?.type === "rate_limit_error") {
+  bus;
+  priceLookup;
+  metaLookup;
+  perSubagent = /* @__PURE__ */ new Map();
+  total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  /** Live snapshot — safe to call from a tool's execute() body. */
+  snapshot() {
     return {
-      kind: "provider_rate_limit",
-      message,
-      retryable: true,
-      // Conservative default: 5s. Provider-specific code can override
-      // by emitting an error whose body carries an explicit hint.
-      backoffMs: 5e3,
-      cause
+      total: { ...this.total },
+      perSubagent: Object.fromEntries(
+        Array.from(this.perSubagent.entries()).map(([k, v]) => [k, { ...v }])
+      )
     };
   }
-  if (status === 401 || status === 403 || err.body?.type === "authentication_error") {
-    return { kind: "provider_auth", message, retryable: false, cause };
+  ensure(subagentId) {
+    let snap = this.perSubagent.get(subagentId);
+    if (!snap) {
+      const meta = this.metaLookup?.(subagentId);
+      snap = {
+        subagentId,
+        provider: meta?.provider,
+        model: meta?.model,
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: 0,
+        toolCalls: 0,
+        iterations: 0,
+        startedAt: Date.now(),
+        lastEventAt: Date.now()
+      };
+      this.perSubagent.set(subagentId, snap);
+    }
+    return snap;
   }
-  if (status === 408 || status === 0) {
-    return { kind: "provider_timeout", message, retryable: true, cause };
+  onProviderResponse(e) {
+    const snap = this.ensure(e.subagentId);
+    const p = e.payload;
+    const usage = p?.usage;
+    if (!usage) return;
+    snap.input += usage.input ?? 0;
+    snap.output += usage.output ?? 0;
+    snap.cacheRead += usage.cacheRead ?? 0;
+    snap.cacheWrite += usage.cacheWrite ?? 0;
+    this.total.input += usage.input ?? 0;
+    this.total.output += usage.output ?? 0;
+    this.total.cacheRead += usage.cacheRead ?? 0;
+    this.total.cacheWrite += usage.cacheWrite ?? 0;
+    const price = this.priceLookup?.(e.subagentId);
+    if (price) {
+      const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
+      snap.cost += delta;
+      this.total.cost += delta;
+    }
+    snap.lastEventAt = e.ts;
   }
-  if (status >= 500 && status < 600) {
-    return {
-      kind: "provider_5xx",
-      message,
-      retryable: true,
-      backoffMs: 3e3,
-      cause
-    };
+  onToolExecuted(e) {
+    const snap = this.ensure(e.subagentId);
+    snap.toolCalls += 1;
+    snap.lastEventAt = e.ts;
   }
-  return { kind: "unknown", message, retryable: err.retryable, cause };
-}
+  onIterationStarted(e) {
+    const snap = this.ensure(e.subagentId);
+    snap.iterations += 1;
+    snap.lastEventAt = e.ts;
+  }
+};
 function makeSpawnTool(director, roster) {
   const inputSchema = {
     type: "object",
@@ -7727,7 +8272,7 @@ var Director = class {
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
-    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 2;
+    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
     this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? this.id;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
@@ -7815,19 +8360,19 @@ var Director = class {
         const extra = {};
         switch (payload.kind) {
           case "iterations":
-            extra.maxIterations = Math.min(payload.used + 50, 500);
+            extra.maxIterations = Math.min(payload.used + 100, 800);
             break;
           case "tool_calls":
-            extra.maxToolCalls = Math.min(Math.ceil(payload.limit * 1.5), 1e3);
+            extra.maxToolCalls = Math.min(Math.ceil(payload.limit * 2), 1500);
             break;
           case "tokens":
-            extra.maxTokens = Math.min(Math.ceil(payload.limit * 1.5), 5e5);
+            extra.maxTokens = Math.min(Math.ceil(payload.limit * 2), 8e5);
             break;
           case "cost":
-            extra.maxCostUsd = Math.min(payload.limit * 1.5, 10);
+            extra.maxCostUsd = Math.min(payload.limit * 2, 25);
             break;
           case "timeout":
-            extra.timeoutMs = Math.min(Math.ceil(payload.limit * 1.5), 60 * 6e4);
+            extra.timeoutMs = Math.min(Math.ceil(payload.limit * 2), 2 * 60 * 6e4);
             break;
         }
         payload.extend(extra);
@@ -8616,136 +9161,6 @@ async function readSubagentPartial(opts, subagentId) {
   }
   return void 0;
 }
-
-// src/coordination/agent-subagent-runner.ts
-function makeAgentSubagentRunner(opts) {
-  const format = opts.formatTaskInput ?? defaultFormatTaskInput;
-  return async (task, ctx) => {
-    const factoryResult = await opts.factory(ctx.config);
-    const { agent, events } = factoryResult;
-    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) {
-        err.decision.then((decision) => {
-          if (decision === "stop") {
-            budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
-            aborter.abort();
-          }
-        }).catch(() => {
-          budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
-          aborter.abort();
-        });
-        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) => {
-        try {
-          ctx.budget.recordToolCall();
-        } catch (eb) {
-          onBudgetError(eb);
-        }
-        if (e.ok === false) {
-          lastToolFailed = e.name;
-        } else if (e.ok === true) {
-          lastToolFailed = null;
-        }
-      }),
-      events.on("provider.response", (e) => {
-        try {
-          ctx.budget.recordUsage(e.usage);
-        } catch (e2) {
-          void onBudgetError(e2);
-        }
-      }),
-      events.on("iteration.started", () => {
-        try {
-          ctx.budget.recordIteration();
-          ctx.budget.checkTimeout();
-        } catch (e) {
-          void onBudgetError(e);
-        }
-      }),
-      // 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", () => {
-        try {
-          ctx.budget.checkTimeout();
-        } catch (e) {
-          void onBudgetError(e);
-        }
-      })
-    );
-    const onParentAbort = () => aborter.abort();
-    ctx.signal.addEventListener("abort", onParentAbort);
-    let result;
-    try {
-      result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
-    } finally {
-      detachFleet?.();
-      ctx.signal.removeEventListener("abort", onParentAbort);
-      for (const u of unsub) u();
-      if (factoryResult.dispose) {
-        try {
-          await factoryResult.dispose();
-        } catch {
-        }
-      }
-    }
-    if (budgetError) throw budgetError;
-    if (result.status === "failed") {
-      throw result.error instanceof Error ? result.error : new Error(String(result.error ?? "agent failed"));
-    }
-    if (result.status === "aborted") {
-      throw new Error("agent aborted");
-    }
-    if (result.status === "max_iterations") {
-      throw new Error("agent exhausted iteration limit");
-    }
-    const usage = ctx.budget.usage();
-    const finalText = (result.finalText ?? "").trim();
-    if (finalText.length === 0 && usage.toolCalls === 0) {
-      throw new Error("empty response");
-    }
-    if (finalText.length === 0 && lastToolFailed !== null) {
-      throw new Error(`tool failed: ${lastToolFailed}`);
-    }
-    return {
-      result: result.finalText,
-      iterations: result.iterations,
-      toolCalls: usage.toolCalls
-    };
-  };
-}
-function defaultFormatTaskInput(task) {
-  return task.description ?? "";
-}
 function makeDirectorSessionFactory(opts) {
   const runId = opts.directorRunId ?? `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-director`;
   let store;
@@ -9002,7 +9417,7 @@ When designing or reviewing architecture:
 - Evaluate scalability and future growth
 - Check for appropriate design patterns
 - Assess coupling and cohesion
-- Look forSOLID principle violations
+- Look for SOLID principle violations
 - Evaluate data modeling decisions
 - Check for eventual consistency issues
 - Assess API design and contract stability
@@ -9089,37 +9504,26 @@ When refactoring code:
     prompt: `## Brief Mode
 
 You are WrongStack, a fast, no-nonsense AI coding agent.
-
-You operate inside the user's terminal. Read files, run commands, make changes \u2014 get to the point.
+Get to the point \u2014 read files, run commands, make changes.
 
 ### Operating rules
-
 1. **Read first.** Inspect relevant files before touching anything.
 2. **Edit surgically.** Use edit tool for existing files, write only for new ones.
-3. **One sentence before action.** State what you're doing, then do it. No preambles.
+3. **One sentence before action.** State what you're doing, then do it.
 4. **Say what happened.** After tool calls, one line: success, failure, or what's next.
-5. **Be honest.** Admit when you don't know or something failed. No fake progress.
+5. **Be honest.** Admit when you don't know or something failed. No filler.
 6. **Keep moving.** Task done? Stop. More work needed? State it and continue.
 
 ### Decision rules
-
 - **Ambiguous task?** Ask. One question, get clarity, proceed.
 - **Clear task, unknown approach?** Pick one reasonable path, execute, report.
 - **Tool fails?** Retry once with adjusted params, then report.
-- **Permission denied?** Stop. Acknowledge. Ask what they want instead.
-- **Context filling up?** Compact proactively, don't wait.
 
 ### Output style
-
 - Prose paragraphs (no bullet points unless unavoidable)
 - Code blocks for code, backticks for paths/commands
 - One-liner sufficient? One liner.
-- No "Great question!", "Here's what I did:", or similar filler.
-- Max 3 sentences per paragraph.
-
-### Focus
-
-Stay on task. Fix only what's asked. Don't refactor surrounding code unless explicitly requested. Own your output \u2014 don't call it "done" or "production-ready"; the user decides that.`,
+- Max 3 sentences per paragraph.`,
     tags: ["fast", "concise", "direct"],
     toolPreferences: ["read", "edit", "bash"]
   },
@@ -12713,6 +13117,6 @@ var allServers = () => ({
   "minimax-vision": { ...miniMaxVisionServer(), enabled: false }
 });
 
-export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeDirectorSessionFactory, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
+export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeDirectorSessionFactory, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map