@wrongstack/core 0.1.8 → 0.1.10

package/dist/coordination/index.js

@@ -0,0 +1,1995 @@
+import { randomUUID, randomBytes } from 'crypto';
+import * as fsp2 from 'fs/promises';
+import * as path3 from 'path';
+import { EventEmitter } from 'events';
+
+// src/coordination/director.ts
+
+// 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((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.inflightGuards.delete(correlationId);
+        this.pendingRequests.delete(correlationId);
+        reject(new Error(`Request ${correlationId} timed out after ${timeout}ms`));
+      }, timeout);
+      this.pendingRequests.set(correlationId, {
+        resolve,
+        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);
+    }
+    this.pendingRequests.clear();
+    this.inflightGuards.clear();
+    this.subscriptions.clear();
+    await this.transport.close(this.agentId);
+  }
+};
+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()}`);
+  }
+  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 FORWARDED_TYPES = [
+      "tool.started",
+      "tool.executed",
+      "tool.progress",
+      "tool.confirm_needed",
+      "iteration.started",
+      "iteration.completed",
+      "provider.text_delta",
+      "provider.response",
+      "provider.retry",
+      "provider.error",
+      "session.started",
+      "session.ended",
+      "session.damaged",
+      "compaction.fired",
+      "compaction.failed",
+      "token.threshold"
+    ];
+    const offs = [];
+    for (const t of FORWARDED_TYPES) {
+      offs.push(
+        bus.on(t, (payload) => {
+          this.emit({ subagentId, taskId, ts: Date.now(), type: t, payload });
+        })
+      );
+    }
+    return () => {
+      for (const off of offs) off();
+    };
+  }
+  /** Subscribe to every event from one subagent. */
+  subscribe(subagentId, handler) {
+    let set = this.byId.get(subagentId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byId.set(subagentId, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  /** Subscribe to one event type across all subagents. */
+  filter(type, handler) {
+    let set = this.byType.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byType.set(type, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  /** Subscribe to literally everything. The fleet roll-up uses this. */
+  onAny(handler) {
+    this.any.add(handler);
+    return () => {
+      this.any.delete(handler);
+    };
+  }
+  emit(event) {
+    const byId = this.byId.get(event.subagentId);
+    if (byId)
+      for (const h of byId) {
+        try {
+          h(event);
+        } catch {
+        }
+      }
+    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 SubagentBudget = class {
+  limits;
+  iterations = 0;
+  toolCalls = 0;
+  tokenInput = 0;
+  tokenOutput = 0;
+  costUsd = 0;
+  startTime = null;
+  constructor(limits = {}) {
+    this.limits = Object.freeze({ ...limits });
+  }
+  start() {
+    this.startTime = Date.now();
+  }
+  recordIteration() {
+    this.iterations++;
+    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
+      throw new BudgetExceededError("iterations", this.limits.maxIterations, this.iterations);
+    }
+  }
+  recordToolCall() {
+    this.toolCalls++;
+    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
+      throw new BudgetExceededError("tool_calls", this.limits.maxToolCalls, this.toolCalls);
+    }
+  }
+  recordUsage(usage, costUsd = 0) {
+    this.tokenInput += usage.input;
+    this.tokenOutput += usage.output;
+    this.costUsd += costUsd;
+    const totalTokens = this.tokenInput + this.tokenOutput;
+    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
+      throw new BudgetExceededError("tokens", this.limits.maxTokens, totalTokens);
+    }
+    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
+      throw new BudgetExceededError("cost", this.limits.maxCostUsd, this.costUsd);
+    }
+  }
+  /**
+   * 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.
+   */
+  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);
+    }
+  }
+  /** Returns true if a timeout has occurred without throwing. Useful for races. */
+  isTimedOut() {
+    if (this.startTime === null || this.limits.timeoutMs === void 0) return false;
+    return Date.now() - this.startTime > this.limits.timeoutMs;
+  }
+  usage() {
+    return {
+      iterations: this.iterations,
+      toolCalls: this.toolCalls,
+      tokens: {
+        input: this.tokenInput,
+        output: this.tokenOutput,
+        total: this.tokenInput + this.tokenOutput
+      },
+      costUsd: this.costUsd,
+      elapsedMs: this.startTime === null ? 0 : Date.now() - this.startTime
+    };
+  }
+};
+
+// src/coordination/multi-agent-coordinator.ts
+var DefaultMultiAgentCoordinator = class extends EventEmitter {
+  coordinatorId;
+  config;
+  runner;
+  subagents = /* @__PURE__ */ new Map();
+  pendingTasks = [];
+  completedResults = [];
+  totalIterations = 0;
+  inFlight = 0;
+  constructor(config, options = {}) {
+    super();
+    this.coordinatorId = config.coordinatorId;
+    this.config = config;
+    this.runner = options.runner;
+  }
+  async spawn(subagent) {
+    const id = subagent.id || randomUUID();
+    const context = {
+      subagentId: id,
+      tasks: [],
+      // Wired later by the caller via setSubagentBridge() once the
+      // bidirectional bridge is created. Readers must null-check / use
+      // hasParentBridge() — the type now reflects this.
+      parentBridge: null,
+      doneCondition: this.config.doneCondition,
+      maxConcurrent: this.config.maxConcurrent ?? 4
+    };
+    this.subagents.set(id, {
+      config: { ...subagent, id },
+      context,
+      status: "idle",
+      abortController: new AbortController()
+    });
+    this.emit("subagent.started", { subagent: { ...subagent, id } });
+    return { subagentId: id, agentId: id };
+  }
+  async assign(task) {
+    this.pendingTasks.push(task);
+    this.tryDispatchNext();
+  }
+  async delegate(to, msg) {
+    const subagent = this.subagents.get(to);
+    if (!subagent) throw new Error(`Subagent "${to}" not found`);
+    if (!subagent.context.parentBridge) {
+      throw new Error(`Subagent "${to}" has no parentBridge \u2014 call setSubagentBridge() first`);
+    }
+    await subagent.context.parentBridge.send(msg);
+  }
+  /**
+   * Wire up the communication bridge for a subagent. Call after spawn() once
+   * the caller has created the bidirectional connection.
+   */
+  setSubagentBridge(subagentId, bridge) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) throw new Error(`Subagent "${subagentId}" not found`);
+    subagent.context.parentBridge = bridge;
+  }
+  async stop(subagentId) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) return;
+    subagent.abortController.abort();
+    subagent.status = "stopped";
+    subagent.currentTask = void 0;
+    subagent.context.parentBridge = null;
+    this.emit("subagent.stopped", { subagentId, reason: "stopped by coordinator" });
+  }
+  async stopAll() {
+    await Promise.allSettled([...this.subagents.keys()].map((id) => this.stop(id)));
+  }
+  getStatus() {
+    return {
+      coordinatorId: this.coordinatorId,
+      subagents: Array.from(this.subagents.entries()).map(([id, s]) => ({
+        id,
+        name: s.config.name,
+        status: s.status,
+        currentTask: s.currentTask
+      })),
+      pendingTasks: this.pendingTasks.length,
+      completedTasks: this.completedResults.length,
+      totalIterations: this.totalIterations,
+      done: this.isDone()
+    };
+  }
+  /** Expose snapshot of completed results — useful for callers awaiting all done. */
+  results() {
+    return this.completedResults;
+  }
+  /**
+   * Manual completion — for callers that drive subagents without a runner
+   * (e.g. external orchestrators). When a runner is configured the coordinator
+   * calls this itself.
+   */
+  completeTask(result) {
+    this.recordCompletion(result);
+  }
+  // --- internal dispatching ---------------------------------------------
+  tryDispatchNext() {
+    while (this.canDispatch()) {
+      const subagentId = this.findIdleSubagent();
+      if (!subagentId) return;
+      const task = this.pendingTasks.shift();
+      if (!task) return;
+      this.runDispatched(subagentId, task).catch((err) => {
+        this.recordCompletion({
+          subagentId,
+          taskId: task.id,
+          status: "failed",
+          error: err instanceof Error ? err.message : String(err),
+          iterations: 0,
+          toolCalls: 0,
+          durationMs: 0
+        });
+      });
+    }
+  }
+  canDispatch() {
+    const max = this.config.maxConcurrent ?? 4;
+    return this.inFlight < max && this.pendingTasks.length > 0;
+  }
+  findIdleSubagent() {
+    for (const [id, s] of this.subagents) {
+      if (s.status === "idle") return id;
+    }
+    return null;
+  }
+  async runDispatched(subagentId, task) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) return;
+    subagent.status = "running";
+    subagent.currentTask = task.id;
+    task.subagentId = subagentId;
+    subagent.context.tasks.push(task);
+    this.emit("task.assigned", { task, subagentId });
+    const budget = new SubagentBudget({
+      maxIterations: subagent.config.maxIterations ?? this.config.defaultBudget?.maxIterations,
+      maxToolCalls: task.maxToolCalls ?? subagent.config.maxToolCalls ?? this.config.defaultBudget?.maxToolCalls,
+      maxTokens: subagent.config.maxTokens ?? this.config.defaultBudget?.maxTokens,
+      maxCostUsd: subagent.config.maxCostUsd ?? this.config.defaultBudget?.maxCostUsd,
+      timeoutMs: task.timeoutMs ?? subagent.config.timeoutMs ?? this.config.defaultBudget?.timeoutMs
+    });
+    subagent.activeBudget = budget;
+    if (!this.runner) {
+      return;
+    }
+    this.inFlight++;
+    const startTime = Date.now();
+    const runCtx = {
+      subagentId,
+      config: subagent.config,
+      budget,
+      signal: subagent.abortController.signal,
+      bridge: subagent.context.parentBridge || null
+    };
+    let result;
+    budget.start();
+    try {
+      const outcome = await this.executeWithTimeout(this.runner, task, runCtx, budget);
+      result = {
+        subagentId,
+        taskId: task.id,
+        status: "success",
+        result: outcome.result,
+        iterations: outcome.iterations,
+        toolCalls: outcome.toolCalls,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      const status = err instanceof BudgetExceededError && err.kind === "timeout" ? "timeout" : subagent.abortController.signal.aborted ? "stopped" : "failed";
+      const usage = budget.usage();
+      result = {
+        subagentId,
+        taskId: task.id,
+        status,
+        error: err instanceof Error ? err.message : String(err),
+        iterations: usage.iterations,
+        toolCalls: usage.toolCalls,
+        durationMs: Date.now() - startTime
+      };
+    }
+    this.recordCompletion(result);
+  }
+  async executeWithTimeout(runner, task, ctx, budget) {
+    const timeoutMs = budget.limits.timeoutMs;
+    if (timeoutMs === void 0) return runner(task, ctx);
+    let timer = null;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        this.subagents.get(ctx.subagentId)?.abortController.abort();
+        reject(new BudgetExceededError("timeout", timeoutMs, Date.now()));
+      }, timeoutMs);
+    });
+    try {
+      return await Promise.race([runner(task, ctx), timeoutPromise]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  recordCompletion(result) {
+    this.completedResults.push(result);
+    this.totalIterations += result.iterations;
+    if (this.inFlight > 0) {
+      this.inFlight--;
+    } else if (this.runner) {
+      this.emit("warning", {
+        type: "inFlight_underflow",
+        taskId: result.taskId,
+        subagentId: result.subagentId
+      });
+      return;
+    }
+    const subagent = this.subagents.get(result.subagentId);
+    if (subagent && subagent.status !== "stopped") {
+      const failed = result.status === "failed" || result.status === "timeout";
+      subagent.status = failed ? "error" : "idle";
+      subagent.currentTask = void 0;
+      if (subagent.abortController.signal.aborted) {
+        subagent.abortController = new AbortController();
+      }
+      if (subagent.status === "error") {
+        queueMicrotask(() => {
+          if (subagent.status === "error") subagent.status = "idle";
+          this.tryDispatchNext();
+        });
+      }
+    }
+    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;
+  }
+};
+
+// src/coordination/director.ts
+var DirectorBudgetError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(kind, limit, observed) {
+    super(
+      kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`
+    );
+    this.name = "DirectorBudgetError";
+    this.kind = kind;
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
+var Director = class {
+  id;
+  fleet;
+  usage;
+  /**
+   * Director-side bridge endpoint. Subagents are wired to the same
+   * in-memory transport so the director can `ask()` them synchronously
+   * and they can `send()` progress back. Exposed so external code (e.g.
+   * the TUI) can subscribe to inbound messages.
+   */
+  bridge;
+  transport;
+  coordinator;
+  /** Resolves with the matching `TaskResult` the first time the
+   *  coordinator emits `task.completed` for a given task id. Each entry
+   *  is created lazily on first poll/await and cleared once consumed. */
+  taskWaiters = /* @__PURE__ */ new Map();
+  /** Cache of completed results in case the consumer asks AFTER the
+   *  coordinator already fired the event — `awaitTasks(['t-1'])` after
+   *  t-1 finished should resolve immediately, not hang. */
+  completed = /* @__PURE__ */ new Map();
+  /** Per-subagent provider/model metadata, captured at spawn time so the
+   *  FleetUsageAggregator's metaLookup can surface readable rows. */
+  subagentMeta = /* @__PURE__ */ new Map();
+  priceLookups = /* @__PURE__ */ new Map();
+  /** Bridge endpoints we created per subagent (so we can `stop()` them
+   *  on shutdown and free transport subscriptions). */
+  subagentBridges = /* @__PURE__ */ new Map();
+  /** Tracks per-spawn config + assigned task ids for manifest writing. */
+  manifestEntries = /* @__PURE__ */ new Map();
+  manifestPath;
+  roster;
+  directorPreamble;
+  subagentBaseline;
+  /** Absolute path to the fleet's shared scratchpad directory, or null
+   *  when none was configured. Exposed as a readonly getter for callers
+   *  that need to surface the path to the user (e.g. the CLI logging
+   *  the location after `--director` boots). */
+  sharedScratchpadPath;
+  /** Spawn cap (lifetime total). Infinity means unlimited. */
+  maxSpawns;
+  /** Nesting cap. The N-th director in a chain has `spawnDepth = N-1`. */
+  maxSpawnDepth;
+  /** This director's position in a director chain. Root director = 0. */
+  spawnDepth;
+  /** Live spawn counter for `maxSpawns` enforcement. */
+  spawnCount = 0;
+  constructor(opts) {
+    this.id = opts.config.coordinatorId || randomUUID();
+    this.manifestPath = opts.manifestPath;
+    this.roster = opts.roster;
+    this.directorPreamble = opts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
+    this.subagentBaseline = opts.subagentBaseline ?? DEFAULT_SUBAGENT_BASELINE;
+    this.sharedScratchpadPath = opts.sharedScratchpadPath ?? null;
+    this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
+    this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
+    this.spawnDepth = opts.spawnDepth ?? 0;
+    if (this.sharedScratchpadPath) {
+      void fsp2.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(() => void 0);
+    }
+    this.transport = new InMemoryBridgeTransport();
+    this.bridge = new InMemoryAgentBridge(
+      { agentId: this.id, coordinatorId: this.id },
+      this.transport
+    );
+    this.fleet = new FleetBus();
+    this.usage = new FleetUsageAggregator(
+      this.fleet,
+      (id) => this.priceLookups.get(id),
+      (id) => this.subagentMeta.get(id)
+    );
+    this.coordinator = new DefaultMultiAgentCoordinator(
+      { ...opts.config, coordinatorId: this.id },
+      { runner: opts.runner }
+    );
+    this.coordinator.on("task.completed", (payload) => {
+      const r = payload.result;
+      this.completed.set(r.taskId, r);
+      const waiter = this.taskWaiters.get(r.taskId);
+      if (waiter) {
+        waiter.resolve(r);
+        this.taskWaiters.delete(r.taskId);
+      }
+    });
+  }
+  /**
+   * Spawn a subagent. Identical to the coordinator's `spawn()` but
+   * captures provider/model metadata for the usage aggregator and
+   * lets the FleetBus attach to the runner's EventBus when the task
+   * actually runs (see `attachSubagentBus`).
+   *
+   * Caller-supplied `priceLookup` is optional but recommended — without
+   * it the `cost` column in `usage.snapshot()` stays at 0.
+   */
+  async spawn(config, priceLookup) {
+    if (this.spawnDepth >= this.maxSpawnDepth) {
+      throw new DirectorBudgetError("max_spawn_depth", this.maxSpawnDepth, this.spawnDepth);
+    }
+    if (this.spawnCount >= this.maxSpawns) {
+      throw new DirectorBudgetError("max_spawns", this.maxSpawns, this.spawnCount + 1);
+    }
+    this.spawnCount += 1;
+    const result = await this.coordinator.spawn(config);
+    this.subagentMeta.set(result.subagentId, {
+      provider: config.provider,
+      model: config.model
+    });
+    if (priceLookup) this.priceLookups.set(result.subagentId, priceLookup);
+    const subagentBridge = new InMemoryAgentBridge(
+      { agentId: result.subagentId, coordinatorId: this.id },
+      this.transport
+    );
+    this.coordinator.setSubagentBridge(result.subagentId, subagentBridge);
+    this.subagentBridges.set(result.subagentId, subagentBridge);
+    this.manifestEntries.set(result.subagentId, {
+      subagentId: result.subagentId,
+      name: config.name,
+      role: config.role,
+      provider: config.provider,
+      model: config.model,
+      taskIds: []
+    });
+    return result.subagentId;
+  }
+  /**
+   * Synchronously ask a subagent something via the bridge. Sends a
+   * `task` message addressed to the subagent and awaits a matching
+   * reply (matched by message id). Subagent runners that handle these
+   * requests subscribe to `ctx.bridge` and reply with a message whose
+   * `id` equals the incoming request's id (see `InMemoryAgentBridge`'s
+   * `request<T>` implementation).
+   *
+   * Returns the response payload directly (the bridge wrapper is
+   * unwrapped for ergonomics). Times out after `timeoutMs` (default
+   * matches the bridge's own default of 30s) — surface those rejections
+   * to the caller as actionable errors instead of letting tools hang.
+   */
+  async ask(subagentId, payload, timeoutMs) {
+    if (!this.subagentBridges.has(subagentId)) {
+      throw new Error(
+        `ask: unknown subagent "${subagentId}" (spawn() it first; current fleet: ${Array.from(this.subagentBridges.keys()).join(", ") || "(empty)"})`
+      );
+    }
+    const msg = {
+      id: randomUUID(),
+      type: "task",
+      from: this.id,
+      to: subagentId,
+      payload,
+      timestamp: Date.now(),
+      priority: "normal"
+    };
+    const reply = await this.bridge.request(msg, timeoutMs);
+    return reply.payload;
+  }
+  /**
+   * Read completed task results and format them as a structured text
+   * block the director's LLM can paste into its own context. The
+   * Director keeps every completed `TaskResult` in `completed` so this
+   * is a pure read — no bridge round-trip, cheap to call.
+   *
+   * The returned string is intentionally markdown-flavored: headers per
+   * subagent, a one-line meta row (iter / tools / ms), and the task's
+   * result text. Pass `style: 'json'` for a programmatic shape instead
+   * (useful when the director model is doing structured-output work).
+   */
+  rollUp(taskIds, style = "markdown") {
+    const rows = taskIds.map((id) => this.completed.get(id)).filter((r) => !!r);
+    if (style === "json") {
+      return JSON.stringify(
+        rows.map((r) => ({
+          taskId: r.taskId,
+          subagentId: r.subagentId,
+          status: r.status,
+          iterations: r.iterations,
+          toolCalls: r.toolCalls,
+          durationMs: r.durationMs,
+          result: r.result,
+          error: r.error
+        })),
+        null,
+        2
+      );
+    }
+    if (rows.length === 0) {
+      return "_No completed tasks for the requested ids \u2014 try waiting first._";
+    }
+    const lines = [];
+    for (const r of rows) {
+      const meta = this.subagentMeta.get(r.subagentId);
+      const tag = meta?.provider && meta?.model ? ` \xB7 ${meta.provider}/${meta.model}` : "";
+      lines.push(`### ${r.subagentId}${tag}`);
+      lines.push(`_${r.status} \u2014 ${r.iterations} iter \xB7 ${r.toolCalls} tools \xB7 ${r.durationMs}ms_`);
+      lines.push("");
+      if (r.error) lines.push(`**Error:** ${r.error}`);
+      else if (typeof r.result === "string") lines.push(r.result);
+      else if (r.result !== void 0)
+        lines.push("```json\n" + JSON.stringify(r.result, null, 2) + "\n```");
+      else lines.push("_(no output)_");
+      lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+  }
+  /**
+   * Write the fleet manifest to `manifestPath`. Returns the path written
+   * or null when no path was configured. Captures every spawn + its
+   * assigned tasks — paired with per-subagent JSONLs, this is enough to
+   * replay an entire director run.
+   */
+  async writeManifest() {
+    if (!this.manifestPath) return null;
+    const manifest = {
+      directorRunId: this.id,
+      writtenAt: (/* @__PURE__ */ new Date()).toISOString(),
+      children: Array.from(this.manifestEntries.values()).map((e) => ({
+        ...e,
+        // Surface final status from `completed` when available — manifest
+        // becomes much more useful for replay when it carries the
+        // success/failure state.
+        results: e.taskIds.map((tid) => {
+          const r = this.completed.get(tid);
+          return r ? {
+            taskId: tid,
+            status: r.status,
+            iterations: r.iterations,
+            toolCalls: r.toolCalls,
+            durationMs: r.durationMs
+          } : { taskId: tid, status: "pending" };
+        })
+      })),
+      usage: this.usage.snapshot()
+    };
+    await fsp2.mkdir(path3.dirname(this.manifestPath), { recursive: true });
+    await fsp2.writeFile(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
+    return this.manifestPath;
+  }
+  /**
+   * Tear down the director: stop every subagent, close every bridge
+   * endpoint, and (when configured) write the final manifest. Idempotent
+   * — calling shutdown twice is a no-op on the second invocation.
+   */
+  async shutdown() {
+    await this.coordinator.stopAll();
+    for (const b of this.subagentBridges.values()) {
+      await b.stop().catch(() => void 0);
+    }
+    this.subagentBridges.clear();
+    await this.bridge.stop().catch(() => void 0);
+    if (this.manifestPath) await this.writeManifest().catch(() => void 0);
+  }
+  /**
+   * Hand a task to the coordinator. Returns the assigned task id so
+   * callers can wait on it via `awaitTasks([id])`. The coordinator's
+   * concurrency limit applies — the task may queue before running.
+   */
+  async assign(task) {
+    const taskWithId = task.id ? task : { ...task, id: randomUUID() };
+    if (task.subagentId) {
+      const entry = this.manifestEntries.get(task.subagentId);
+      if (entry) entry.taskIds.push(taskWithId.id);
+    }
+    await this.coordinator.assign(taskWithId);
+    return taskWithId.id;
+  }
+  /**
+   * Block until every task id resolves. Returns results in the same
+   * order as the input. If any task hasn't completed by the time this
+   * is called, the promise hangs until it does — pair with a timeout
+   * at the caller if that's a concern. Resolves immediately for ids
+   * whose results were already cached.
+   */
+  awaitTasks(taskIds) {
+    return Promise.all(
+      taskIds.map((id) => {
+        const cached = this.completed.get(id);
+        if (cached) return cached;
+        const existing = this.taskWaiters.get(id);
+        if (existing) return existing.promise;
+        let resolve;
+        const promise = new Promise((res) => {
+          resolve = res;
+        });
+        this.taskWaiters.set(id, { promise, resolve });
+        return promise;
+      })
+    );
+  }
+  async terminate(subagentId) {
+    await this.coordinator.stop(subagentId);
+  }
+  async terminateAll() {
+    await this.coordinator.stopAll();
+  }
+  status() {
+    return this.coordinator.getStatus();
+  }
+  /**
+   * Subscribe to coordinator events. Currently only `task.completed` is
+   * exposed (the others are internal lifecycle). Returns an unsubscribe
+   * function. External callers (e.g. the CLI's `MultiAgentHost`) use this
+   * to drive their own pending/results tracking without poking the
+   * coordinator directly.
+   */
+  on(event, handler) {
+    this.coordinator.on(event, handler);
+    return () => {
+      this.coordinator.off(event, handler);
+    };
+  }
+  /**
+   * Snapshot of every task that has resolved (success, failed, timeout,
+   * stopped) since the director started. Returned in completion order
+   * via the internal map's iteration order. Used by `/fleet status` to
+   * paint the completed table without reaching into private state.
+   */
+  completedResults() {
+    return Array.from(this.completed.values());
+  }
+  snapshot() {
+    return this.usage.snapshot();
+  }
+  /**
+   * Compose the leader/director-agent system prompt: fleet preamble +
+   * (optional) roster summary + user base prompt. Pass the result to your
+   * leader Agent's `ctx.systemPrompt` when constructing it.
+   *
+   * `basePrompt` defaults to `config.leaderSystemPrompt` so callers can
+   * use the no-arg form when the multi-agent config already carries it.
+   */
+  leaderSystemPrompt(basePrompt) {
+    return composeDirectorPrompt({
+      basePrompt: basePrompt ?? this.coordinator.config.leaderSystemPrompt,
+      directorPreamble: this.directorPreamble,
+      rosterSummary: this.roster ? rosterSummaryFromConfigs(this.roster) : void 0
+    });
+  }
+  /**
+   * Compose a subagent's system prompt for a given `SubagentConfig`:
+   * baseline + role + task + per-spawn override. Returned by value — does
+   * not mutate the config. Factories (the user-supplied `AgentFactory`)
+   * should call this when building each subagent's Agent so the bridge
+   * contract, role context, and override are all surfaced.
+   *
+   * When `taskBrief` is omitted the Task section is dropped. Pass the
+   * actual task description here to reinforce it in the system prompt
+   * (the runner already passes it as user input — duplicating in the
+   * system prompt is optional but improves anchoring on small models).
+   */
+  subagentSystemPrompt(config, taskBrief) {
+    return composeSubagentPrompt({
+      baseline: this.subagentBaseline,
+      role: config.prompt,
+      task: taskBrief,
+      sharedScratchpad: this.sharedScratchpadPath ?? void 0,
+      override: config.systemPromptOverride
+    });
+  }
+  /**
+   * Build the tool set the LLM-driven director uses to orchestrate.
+   * Returns an array of `Tool` definitions; register these on the
+   * director's `Agent` to expose `spawn_subagent`, `assign_task`, etc.
+   * Each tool's `execute()` delegates straight to the matching method
+   * above.
+   *
+   * Tools all carry `permission: 'auto'` — the *user* has already
+   * approved running the director when they kicked off the run, so
+   * gating individual orchestration calls behind a confirm prompt
+   * would just be noise. The actual subagent tools they spawn are
+   * still permission-checked normally.
+   */
+  tools(roster) {
+    const t = [
+      makeSpawnTool(this, roster),
+      makeAssignTool(this),
+      makeAwaitTasksTool(this),
+      makeAskTool(this),
+      makeRollUpTool(this),
+      makeTerminateTool(this),
+      makeFleetStatusTool(this),
+      makeFleetUsageTool(this)
+    ];
+    return t;
+  }
+};
+function makeSpawnTool(director, roster) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      role: {
+        type: "string",
+        description: "Roster role id (preferred). When set, the spawn uses the matching config from the roster and ignores other fields."
+      },
+      name: {
+        type: "string",
+        description: "Display name for the subagent. Required when not using roster."
+      },
+      provider: {
+        type: "string",
+        description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the leader provider when omitted.'
+      },
+      model: {
+        type: "string",
+        description: "Model id within the provider. Defaults to the leader model when omitted."
+      },
+      systemPromptOverride: {
+        type: "string",
+        description: "Extra prompt text appended after the role-base prompt."
+      },
+      maxIterations: { type: "number" },
+      maxToolCalls: { type: "number" },
+      maxCostUsd: { type: "number" }
+    },
+    required: []
+  };
+  return {
+    name: "spawn_subagent",
+    description: "Create a new subagent under this director. Returns the subagent id. Use this when you need a worker with a specific provider, model, or role to handle a piece of the plan.",
+    usageHint: "Either pass `role` (matches the roster) OR pass `name` + optional `provider`/`model`. Returns `{ subagentId }`.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input ?? {};
+      const role = typeof i.role === "string" ? i.role : void 0;
+      const base = role && roster ? roster[role] : void 0;
+      if (role && !base) {
+        return {
+          error: `unknown role "${role}". roster has: ${roster ? Object.keys(roster).join(", ") : "(empty)"}`
+        };
+      }
+      const cfg = {
+        ...base ?? { name: i.name ?? "subagent" }
+      };
+      if (typeof i.name === "string") cfg.name = i.name;
+      if (typeof i.provider === "string") cfg.provider = i.provider;
+      if (typeof i.model === "string") cfg.model = i.model;
+      if (typeof i.systemPromptOverride === "string")
+        cfg.systemPromptOverride = i.systemPromptOverride;
+      if (typeof i.maxIterations === "number") cfg.maxIterations = i.maxIterations;
+      if (typeof i.maxToolCalls === "number") cfg.maxToolCalls = i.maxToolCalls;
+      if (typeof i.maxCostUsd === "number") cfg.maxCostUsd = i.maxCostUsd;
+      try {
+        const subagentId = await director.spawn(cfg);
+        return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name };
+      } catch (err) {
+        if (err instanceof DirectorBudgetError) {
+          return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
+        }
+        return { error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+  };
+}
+function makeAssignTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      subagentId: { type: "string", description: "Target subagent id. Required." },
+      description: {
+        type: "string",
+        description: "The task in natural language \u2014 what you want this subagent to do."
+      },
+      maxToolCalls: { type: "number", description: "Optional per-task tool-call budget override." },
+      timeoutMs: { type: "number", description: "Optional per-task timeout in ms." }
+    },
+    required: ["subagentId", "description"]
+  };
+  return {
+    name: "assign_task",
+    description: "Hand a task to a previously spawned subagent. Returns the task id \u2014 pass it to `await_tasks` to block on completion.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      const task = {
+        id: randomUUID(),
+        description: i.description,
+        subagentId: i.subagentId,
+        maxToolCalls: i.maxToolCalls,
+        timeoutMs: i.timeoutMs
+      };
+      const taskId = await director.assign(task);
+      return { taskId, subagentId: i.subagentId };
+    }
+  };
+}
+function makeAwaitTasksTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      taskIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "One or more task ids returned by `assign_task`. The call blocks until every id resolves."
+      }
+    },
+    required: ["taskIds"]
+  };
+  return {
+    name: "await_tasks",
+    description: "Block until every named task completes. Returns the array of TaskResult \u2014 use this to gather subagent output before deciding the next step.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      const results = await director.awaitTasks(i.taskIds);
+      return { results };
+    }
+  };
+}
+function makeAskTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      subagentId: {
+        type: "string",
+        description: "Subagent to ask. Must be a previously spawned id."
+      },
+      question: {
+        type: "string",
+        description: "The question or instruction. Sent as the bridge message payload."
+      },
+      timeoutMs: { type: "number", description: "Optional timeout in ms (default 30s)." }
+    },
+    required: ["subagentId", "question"]
+  };
+  return {
+    name: "ask_subagent",
+    description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge (or the timeout fires). Use this when you need a one-shot answer without spawning a fresh task.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      try {
+        const answer = await director.ask(i.subagentId, { question: i.question }, i.timeoutMs);
+        return { ok: true, answer };
+      } catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+  };
+}
+function makeRollUpTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      taskIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Completed task ids to aggregate. Pass the ids returned by previous `assign_task` calls."
+      },
+      style: {
+        type: "string",
+        enum: ["markdown", "json"],
+        description: "Output flavor \u2014 markdown (default) for in-prompt summarization, json for structured downstream processing."
+      }
+    },
+    required: ["taskIds"]
+  };
+  return {
+    name: "roll_up",
+    description: "Aggregate completed task results into a single formatted summary. Use this after `await_tasks` to fold subagent outputs back into the director's context before deciding the next step.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      const summary = director.rollUp(i.taskIds, i.style ?? "markdown");
+      return { summary, count: i.taskIds.length };
+    }
+  };
+}
+function makeTerminateTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      subagentId: { type: "string", description: "Subagent to abort." }
+    },
+    required: ["subagentId"]
+  };
+  return {
+    name: "terminate_subagent",
+    description: 'Forcibly abort a subagent. Use sparingly \u2014 prefer waiting on the natural budget to expire. The current task (if any) ends with status "stopped".',
+    permission: "auto",
+    mutating: true,
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      await director.terminate(i.subagentId);
+      return { ok: true };
+    }
+  };
+}
+function makeFleetStatusTool(director) {
+  return {
+    name: "fleet_status",
+    description: "Snapshot of the fleet \u2014 every subagent's current status, pending vs. completed task counts, and the running total iteration count. Cheap; call freely.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      return director.status();
+    }
+  };
+}
+function makeFleetUsageTool(director) {
+  return {
+    name: "fleet_usage",
+    description: "Token + cost breakdown across the fleet, per-subagent and totals. Use this to reason about which workers to assign costly tasks to or when to wrap up to stay within budget.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      return director.snapshot();
+    }
+  };
+}
+
+// src/coordination/agent-subagent-runner.ts
+function makeAgentSubagentRunner(opts) {
+  const format = opts.formatTaskInput ?? defaultFormatTaskInput;
+  return async (task, ctx) => {
+    const { agent, events } = await opts.factory(ctx.config);
+    const aborter = new AbortController();
+    let budgetError = null;
+    const onBudgetError = (err) => {
+      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})`;
+      }
+    };
+    const unsub = [];
+    unsub.push(
+      events.on("tool.started", () => {
+        try {
+          ctx.budget.recordToolCall();
+        } catch (e) {
+          onBudgetError(e);
+        }
+      }),
+      events.on("provider.response", (e) => {
+        try {
+          ctx.budget.recordUsage(e.usage);
+        } catch (e2) {
+          onBudgetError(e2);
+        }
+      }),
+      events.on("iteration.started", () => {
+        try {
+          ctx.budget.recordIteration();
+          ctx.budget.checkTimeout();
+        } catch (e) {
+          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 {
+      ctx.signal.removeEventListener("abort", onParentAbort);
+      for (const u of unsub) u();
+    }
+    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();
+    return {
+      result: result.finalText,
+      iterations: result.iterations,
+      toolCalls: usage.toolCalls
+    };
+  };
+}
+function defaultFormatTaskInput(task) {
+  return task.description ?? "";
+}
+async function ensureDir(dir) {
+  await fsp2.mkdir(dir, { recursive: true });
+}
+
+// src/storage/session-store.ts
+var DefaultSessionStore = class {
+  dir;
+  events;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.events = opts.events;
+  }
+  async create(meta) {
+    await ensureDir(this.dir);
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const id = meta.id ?? `${startedAt.replace(/[:.]/g, "-")}-${randomBytes(2).toString("hex")}`;
+    const file = path3.join(this.dir, `${id}.jsonl`);
+    let handle;
+    try {
+      handle = await fsp2.open(file, "a", 384);
+    } catch (err) {
+      throw new Error(
+        `Failed to open session file: ${err instanceof Error ? err.message : String(err)}`,
+        {
+          cause: err
+        }
+      );
+    }
+    try {
+      return new FileSessionWriter(id, handle, startedAt, meta, { dir: this.dir, filePath: file });
+    } catch (err) {
+      await handle.close().catch(() => {
+      });
+      throw err;
+    }
+  }
+  async resume(id) {
+    const data = await this.load(id);
+    const file = path3.join(this.dir, `${id}.jsonl`);
+    let handle;
+    try {
+      handle = await fsp2.open(file, "a", 384);
+    } catch (err) {
+      throw new Error(
+        `Failed to open session "${id}" for append: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      );
+    }
+    const writer = new FileSessionWriter(
+      id,
+      handle,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      {
+        id,
+        model: data.metadata.model,
+        provider: data.metadata.provider
+      },
+      { resumed: true, dir: this.dir, filePath: file }
+    );
+    return { writer, data };
+  }
+  async load(id) {
+    const file = path3.join(this.dir, `${id}.jsonl`);
+    const raw = await fsp2.readFile(file, "utf8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const events = [];
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
+          events.push(parsed);
+        }
+      } catch {
+      }
+    }
+    const meta = this.metaFromEvents(id, events);
+    const { messages, usage } = this.replay(events, id);
+    return { metadata: meta, events, messages, usage };
+  }
+  async list(limit = 20) {
+    try {
+      await ensureDir(this.dir);
+      const files = await fsp2.readdir(this.dir);
+      const ids = files.filter((f) => f.endsWith(".jsonl")).map((f) => f.replace(/\.jsonl$/, ""));
+      const sessions = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
+      const out = sessions.filter((s) => s !== null);
+      out.sort((a, b) => {
+        if (a.startedAt < b.startedAt) return 1;
+        if (a.startedAt > b.startedAt) return -1;
+        return a.id.localeCompare(b.id);
+      });
+      return out.slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
+  async summaryFor(id) {
+    const manifest = path3.join(this.dir, `${id}.summary.json`);
+    try {
+      const raw = await fsp2.readFile(manifest, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      const full = path3.join(this.dir, `${id}.jsonl`);
+      const stat3 = await fsp2.stat(full);
+      const summary = await this.summarize(id, stat3.mtime.toISOString());
+      await fsp2.writeFile(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
+        console.warn(
+          `[session-store] Failed to write manifest for "${id}":`,
+          err instanceof Error ? err.message : String(err)
+        );
+      });
+      return summary;
+    }
+  }
+  async delete(id) {
+    await fsp2.unlink(path3.join(this.dir, `${id}.jsonl`));
+    await fsp2.unlink(path3.join(this.dir, `${id}.summary.json`)).catch(() => void 0);
+  }
+  async summarize(id, mtime) {
+    try {
+      const data = await this.load(id);
+      const firstUser = data.events.find((e) => e.type === "user_input");
+      const title = firstUser && firstUser.type === "user_input" ? userInputTitle(firstUser.content) : "(empty session)";
+      return {
+        id,
+        title,
+        startedAt: data.metadata.startedAt,
+        model: data.metadata.model ?? "unknown",
+        provider: data.metadata.provider ?? "unknown",
+        tokenTotal: data.usage.input + data.usage.output
+      };
+    } catch {
+      return {
+        id,
+        title: "(damaged)",
+        startedAt: mtime,
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
+    }
+  }
+  metaFromEvents(id, events) {
+    const start = events.find((e) => e.type === "session_start");
+    const end = events.find((e) => e.type === "session_end");
+    return {
+      id,
+      startedAt: start?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      endedAt: end?.ts,
+      model: start?.model,
+      provider: start?.provider
+    };
+  }
+  replay(events, sessionId = "unknown") {
+    const messages = [];
+    let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    const openToolUses = /* @__PURE__ */ new Set();
+    for (const e of events) {
+      if (e.type === "user_input") {
+        openToolUses.clear();
+        messages.push({ role: "user", content: e.content });
+      } else if (e.type === "llm_response") {
+        messages.push({ role: "assistant", content: e.content });
+        for (const b of e.content) {
+          if (b.type === "tool_use") openToolUses.add(b.id);
+        }
+        usage = {
+          input: usage.input + (e.usage.input ?? 0),
+          output: usage.output + (e.usage.output ?? 0),
+          cacheRead: (usage.cacheRead ?? 0) + (e.usage.cacheRead ?? 0),
+          cacheWrite: (usage.cacheWrite ?? 0) + (e.usage.cacheWrite ?? 0)
+        };
+      } else if (e.type === "tool_result") {
+        if (!openToolUses.has(e.id)) {
+          this.events?.emit("session.damaged", {
+            sessionId,
+            detail: `Orphan tool_result "${e.id}" has no matching tool_use`
+          });
+          continue;
+        }
+        openToolUses.delete(e.id);
+        const content = [
+          {
+            type: "tool_result",
+            tool_use_id: e.id,
+            content: typeof e.content === "string" ? e.content : JSON.stringify(e.content),
+            is_error: e.isError
+          }
+        ];
+        const last = messages[messages.length - 1];
+        if (last && last.role === "user") {
+          if (Array.isArray(last.content)) {
+            last.content.push(...content);
+          } else if (typeof last.content === "string") {
+            last.content = [{ type: "text", text: last.content }, ...content];
+          } else {
+            messages.push({ role: "user", content });
+          }
+        } else {
+          messages.push({ role: "user", content });
+        }
+      }
+    }
+    if (openToolUses.size > 0) {
+      this.events?.emit("session.damaged", {
+        sessionId,
+        detail: `${openToolUses.size} tool_use blocks without matching results \u2014 replay truncated`
+      });
+      return { messages, usage };
+    }
+    return { messages, usage };
+  }
+};
+var FileSessionWriter = class {
+  constructor(id, handle, startedAt, meta, opts = {}) {
+    this.id = id;
+    this.handle = handle;
+    this.startedAt = startedAt;
+    this.meta = meta;
+    this.resumed = opts.resumed ?? false;
+    this.manifestFile = opts.dir ? path3.join(opts.dir, `${id}.summary.json`) : "";
+    this.filePath = opts.filePath ?? "";
+    this.summary = {
+      id,
+      title: "(empty session)",
+      startedAt,
+      model: meta.model ?? "unknown",
+      provider: meta.provider ?? "unknown",
+      tokenTotal: 0
+    };
+  }
+  id;
+  handle;
+  startedAt;
+  meta;
+  closed = false;
+  manifestFile;
+  summary;
+  tokenIn = 0;
+  tokenOut = 0;
+  filePath;
+  initDone = false;
+  resumed;
+  appendFailCount = 0;
+  lastAppendWarnAt = 0;
+  async writeSessionStart() {
+    if (this.initDone || this.closed) return;
+    this.initDone = true;
+    const record = `${JSON.stringify({
+      type: this.resumed ? "session_resumed" : "session_start",
+      ts: this.startedAt,
+      id: this.id,
+      model: this.meta.model ?? "unknown",
+      provider: this.meta.provider ?? "unknown"
+    })}
+`;
+    try {
+      if (this.filePath) {
+        await fsp2.writeFile(this.filePath, record, { flag: "a", mode: 384 });
+      }
+    } catch {
+    }
+  }
+  async append(event) {
+    if (this.closed) return;
+    if (!this.initDone) {
+      await this.writeSessionStart();
+    }
+    this.observeForSummary(event);
+    try {
+      await this.handle.appendFile(`${JSON.stringify(event)}
+`, "utf8");
+    } catch (err) {
+      this.appendFailCount++;
+      const now = Date.now();
+      if (now - this.lastAppendWarnAt > 5e3) {
+        const suppressed = this.appendFailCount - 1;
+        const tail = suppressed > 0 ? ` (+${suppressed} suppressed)` : "";
+        console.warn(
+          "[session] append failed:",
+          err instanceof Error ? err.message : String(err),
+          tail
+        );
+        this.lastAppendWarnAt = now;
+        this.appendFailCount = 0;
+      }
+    }
+  }
+  /**
+   * Watch events as they're appended and keep the summary state hot, so
+   * `close()` can flush a `<id>.summary.json` manifest without re-reading
+   * the JSONL. `list()` reads only manifests, turning a per-session full
+   * parse into a single stat+read.
+   */
+  observeForSummary(event) {
+    if (event.type === "user_input" && this.summary.title === "(empty session)") {
+      this.summary = { ...this.summary, title: userInputTitle(event.content) };
+    } else if (event.type === "llm_response") {
+      this.tokenIn += event.usage.input;
+      this.tokenOut += event.usage.output;
+      this.summary = { ...this.summary, tokenTotal: this.tokenIn + this.tokenOut };
+    } else if (event.type === "session_end") {
+      const total = event.usage.input + event.usage.output;
+      if (total > 0) this.summary = { ...this.summary, tokenTotal: total };
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.manifestFile) {
+      try {
+        await fsp2.writeFile(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
+      } catch {
+      }
+    }
+    try {
+      await this.handle.close();
+    } catch {
+    }
+  }
+};
+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(" ");
+  return (text || "(non-text input)").slice(0, 60);
+}
+
+// src/coordination/director-session.ts
+function makeDirectorSessionFactory(opts) {
+  const runId = opts.directorRunId ?? `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-director`;
+  let store;
+  let dir;
+  if (opts.store) {
+    store = opts.store;
+    dir = opts.sessionsRoot ? path3.join(opts.sessionsRoot, runId) : "(caller-managed)";
+  } else if (opts.sessionsRoot) {
+    dir = path3.join(opts.sessionsRoot, runId);
+    store = new DefaultSessionStore({ dir });
+  } else {
+    throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
+  }
+  return {
+    dir,
+    directorRunId: runId,
+    async createSubagentSession({ subagentId, provider, model, title }) {
+      return store.create({
+        id: subagentId,
+        title: title ?? subagentId,
+        provider: provider ?? "unknown",
+        model: model ?? "unknown"
+      });
+    }
+  };
+}
+
+// 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`,
+  maxIterations: 50,
+  maxToolCalls: 200,
+  timeoutMs: 12e4
+};
+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.
+
+Scope:
+- Detect common bug patterns (uncaught errors, resource leaks, race conditions)
+- Identify anti-patterns (callback hell, God objects, circular deps)
+- Find TypeScript-specific issues (unsafe any, missing null checks, branded types)
+- Flag security-sensitive constructs (eval, innerHTML, hardcoded secrets)
+- Rank findings: critical > high > medium > low
+
+Input format you accept:
+{ "task": "scan | hunt | check", "paths": ["src/**/*.ts"], "focus": "bugs | patterns | security | all", "severityThreshold": "medium" }
+
+Output: Markdown bug hunt report:
+- ## Critical (must fix first)
+- ## High (should fix)
+- ## Medium
+- ## Low (consider)
+Each entry: **[TYPE]** \`file:line\` \u2014 description + suggested fix
+
+Bug pattern reference you know:
+| Pattern | Regex hint | Severity |
+|---------|------------|----------|
+| Uncaught promise | /.then\\(.*\\)/ without catch | high |
+| Event leak | on\\( without off/removeListener | high |
+| Hardcoded secret | [a-zA-Z0-9/_-]{20,} in config files | critical |
+| unsafe any | : any\\b or <any> | medium |
+| innerHTML | innerHTML\\s*= | high |
+
+Working rules:
+- Never scan node_modules \u2014 it's noise
+- Always include file:line for every finding
+- If >30% of findings are false positives, note the confidence level
+- Ask director for clarification if paths are ambiguous`,
+  maxIterations: 80,
+  maxToolCalls: 300,
+  timeoutMs: 18e4
+};
+var REFACTOR_PLANNER_AGENT = {
+  id: "refactor-planner",
+  name: "Refactor Planner",
+  role: "refactor-planner",
+  prompt: `You are the Refactor Planner agent. Your job is to analyze code
+structure and produce a concrete, phased refactoring plan with risk
+assessment, dependency ordering, and rollback strategy.
+
+Scope:
+- Map module-level dependencies (import graph)
+- Identify coupling hotspots (high fan-in/out modules)
+- Assess refactoring risk by complexity and test coverage
+- Generate phased plans with checkpoint milestones
+- Produce diff-friendly task lists (one task = one concern)
+
+Input format you accept:
+{ "task": "plan | assess | roadmap", "target": "src/core", "constraint": "no-breaking-changes | minimal-downtime | full-rewrite", "focus": "architecture | performance | maintainability" }
+
+Output: Markdown refactor plan:
+- ## Phase 1: Low Risk / High Payoff (do first)
+  Table: | # | Task | Module | Risk | Est. Time |
+- ## Phase 2: Medium Risk
+- ## Phase 3: High Risk (requires full regression)
+- ## Dependency Graph (abbreviated ASCII)
+- ## Rollback Strategy
+- ## Exit Criteria (checkbox list)
+
+Risk scoring criteria:
+| Factor | Low | Medium | High |
+|--------|-----|--------|------|
+| Cyclomatic complexity | <10 | 10-20 | >20 |
+| Test coverage | >80% | 50-80% | <50% |
+| Fan-out (imports) | <5 | 5-15 | >15 |
+
+Working rules:
+- Always include rollback strategy \u2014 every refactor can fail
+- Merge tasks that take <1h into a single phase
+- Respect team constraints (reviewer availability, parallelization)
+- Never plan without analyzing the actual code first`,
+  maxIterations: 60,
+  maxToolCalls: 250,
+  timeoutMs: 15e4
+};
+var SECURITY_SCANNER_AGENT = {
+  id: "security-scanner",
+  name: "Security Scanner",
+  role: "security-scanner",
+  prompt: `You are the Security Scanner agent. Your job is to scan code,
+configs, and dependencies for security issues from hardcoded secrets to
+supply chain risks.
+
+Scope:
+- Detect hardcoded secrets: API keys, tokens, passwords, private keys
+- Find injection vectors: eval, innerHTML, SQL concat, shell injection
+- Identify insecure patterns: weak crypto, hardcoded IVs, disabled TLS
+- Scan dependencies for known CVEs (via npm/pnpm audit)
+- Flag supply chain risks: postinstall hooks, unverified scripts, .npmrc
+
+Input format you accept:
+{ "task": "scan | audit | secrets | dependencies", "paths": ["src", "config"], "depth": "quick | normal | deep" }
+
+Output: Markdown security report:
+- ## CRITICAL: Secrets Found (with code snippets)
+- ## HIGH: Injection Vectors
+- ## MEDIUM: Insecure Patterns
+- ## Dependency Issues (CVE list)
+- ## Summary table (severity \u2192 count)
+- ## Remediation Checklist (with checkboxes)
+
+Secret patterns you detect:
+| Pattern | Example | Severity |
+|---------|---------|----------|
+| AWS Access Key | AKIAIOSFODNN7EXAMPLE | critical |
+| AWS Secret Key | [a-zA-Z0-9/+=]{40} base64 | critical |
+| GitHub Token | ghp_[a-zA-Z0-9]{36} | critical |
+| Private Key PEM | -----BEGIN.*PRIVATE KEY----- | critical |
+| JWT | eyJ[a-zA-Z0-9_-]+ | high |
+
+Injection patterns:
+| Construct | Safe alternative |
+|-----------|-----------------|
+| eval(str) | new Function() or parse |
+| innerHTML = x | textContent or sanitize |
+| exec(\`cmd \${x}\`) | execFile with args array |
+
+Working rules:
+- Never scan node_modules \u2014 use npm audit instead
+- Always provide remediation steps, not just findings
+- Verify regex-based secrets before flagging (false positive risk)
+- When in doubt, flag as medium rather than ignoring potential issues`,
+  maxIterations: 70,
+  maxToolCalls: 280,
+  timeoutMs: 16e4
+};
+var FLEET_ROSTER = {
+  "audit-log": AUDIT_LOG_AGENT,
+  "bug-hunter": BUG_HUNTER_AGENT,
+  "refactor-planner": REFACTOR_PLANNER_AGENT,
+  "security-scanner": SECURITY_SCANNER_AGENT
+};
+var ALL_FLEET_AGENTS = Object.values(FLEET_ROSTER);
+
+export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, BUG_HUNTER_AGENT, BudgetExceededError, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultMultiAgentCoordinator, Director, DirectorBudgetError, FLEET_ROSTER, FleetBus, FleetUsageAggregator, InMemoryAgentBridge, InMemoryBridgeTransport, REFACTOR_PLANNER_AGENT, SECURITY_SCANNER_AGENT, SubagentBudget, composeDirectorPrompt, composeSubagentPrompt, createMessage, makeAgentSubagentRunner, makeDirectorSessionFactory, rosterSummaryFromConfigs };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map