@wrongstack/core 0.7.8 → 0.8.2

package/dist/index.js

@@ -586,6 +586,16 @@ var EventBus = class {
       this.off(event, wrapper);
     };
   }
+  /**
+   * Subscribe to all events, regardless of name. Short-hand for
+   * `onPattern('*')`. Use for logging, debugging, or forwarding every
+   * event to another bus (as FleetBus does).
+   *
+   * Returns an unsubscribe function.
+   */
+  onAny(fn) {
+    return this.onPattern("*", fn);
+  }
   /**
    * Subscribe to all events whose name matches a glob-style prefix.
    * `'tool.*'` matches `tool.started`, `tool.executed`, `tool.progress`, etc.
@@ -720,6 +730,19 @@ var ScopedEventBus = class extends EventBus {
     this.registrations.set(key, unsub);
     return unsub;
   }
+  /**
+   * Subscribe to all events. Alias for `onPattern('*')` — the listener is
+   * tracked so that `teardown()` will remove it automatically.
+   */
+  onAny(fn) {
+    const key = this.nextKey++;
+    const unsub = EventBus.prototype.onPattern.call(this, "*", fn);
+    this.registrations.set(key, unsub);
+    return () => {
+      this.registrations.delete(key);
+      unsub();
+    };
+  }
   /**
    * Identical to `EventBus.onPattern` but the listener is tracked so that
    * `teardown()` will remove it automatically.
@@ -6159,10 +6182,36 @@ var DefaultPermissionPolicy = class {
     return void 0;
   }
 };
-var AutoApprovePermissionPolicy = class {
+var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
+  /**
+   * Tools that are too dangerous to auto-approve even in a delegated
+   * subagent context. Subagents run non-interactively under a director
+   * and cannot answer prompts, but inherited authorization does not
+   * imply blanket permission for destructive or privilege-escalating
+   * operations. These tools remain at their declared `permission`
+   * level so the leader must explicitly allow them per-spawn.
+   */
+  static DENY = /* @__PURE__ */ new Set([
+    "bash",
+    // arbitrary shell — use exec for constrained shell
+    "write",
+    // arbitrary file write
+    "scaffold",
+    // arbitrary file generation outside project root
+    "patch",
+    // arbitrary diff application
+    "install",
+    // installs from arbitrary package sources
+    "exec"
+    // restricted shell but with arbitrary command args
+  ]);
   async evaluate(tool) {
-    if (tool.permission === "deny") {
-      return { permission: "deny", source: "default", reason: "tool default deny" };
+    if (tool.permission === "deny" || _AutoApprovePermissionPolicy.DENY.has(tool.name)) {
+      return {
+        permission: "deny",
+        source: "subagent_guard",
+        reason: _AutoApprovePermissionPolicy.DENY.has(tool.name) ? `tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : "tool default deny"
+      };
     }
     return { permission: "auto", source: "yolo" };
   }
@@ -7239,6 +7288,7 @@ Summarize the following message range:`;
 };
 
 // src/execution/auto-compaction-middleware.ts
+var LEVEL_RANK2 = { warn: 0, soft: 1, hard: 2 };
 var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   name = "AutoCompaction";
   compactor;
@@ -7259,6 +7309,16 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
    * short conversations, causing premature compaction triggers.
    */
   static OVERHEAD_FACTOR = 1.3;
+  /**
+   * Once a compaction attempt reduces nothing (preserveK protects everything,
+   * no oversized tool_results remain to elide), retrying on every iteration
+   * just spams `compaction.fired` events without making progress. We remember
+   * the no-op and skip until either the pressure level escalates or context
+   * has grown by at least this many tokens since the failed attempt.
+   */
+  static NOOP_RETRY_DELTA_TOKENS = 2e3;
+  /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
+  lastNoopAttempt = null;
   /**
    * @param compactor        Compactor to use for compaction.
    * @param maxContext       Provider's max context window in tokens.
@@ -7300,19 +7360,44 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         hard: this.hardThreshold
       };
       const aggressiveOn = policy?.aggressiveOn ?? this.aggressiveOn;
-      if (load >= thresholds.hard) {
-        await this.compact(ctx, true, { level: "hard", tokens, load });
-      } else if (load >= thresholds.soft) {
-        await this.compact(ctx, aggressiveOn !== "hard", { level: "soft", tokens, load });
-      } else if (load >= thresholds.warn) {
-        await this.compact(ctx, aggressiveOn === "warn", { level: "warn", tokens, load });
+      const level = load >= thresholds.hard ? "hard" : load >= thresholds.soft ? "soft" : load >= thresholds.warn ? "warn" : null;
+      if (!level) {
+        this.lastNoopAttempt = null;
+        return next(ctx);
+      }
+      if (this.shouldSkipNoopRetry(level, tokens)) {
+        return next(ctx);
       }
+      const aggressive = level === "hard" ? true : level === "soft" ? aggressiveOn !== "hard" : aggressiveOn === "warn";
+      await this.compact(ctx, aggressive, { level, tokens, load });
       return next(ctx);
     };
   }
+  /**
+   * Returns true when the previous compaction at the same or higher pressure
+   * level reduced nothing and context has not grown materially since. Prevents
+   * a stuck preserveK window from spamming compaction events every iteration.
+   */
+  shouldSkipNoopRetry(level, tokens) {
+    const stuck = this.lastNoopAttempt;
+    if (!stuck) return false;
+    if (LEVEL_RANK2[level] > LEVEL_RANK2[stuck.level]) return false;
+    const delta = tokens - stuck.tokens;
+    return delta < _AutoCompactionMiddleware.NOOP_RETRY_DELTA_TOKENS;
+  }
+  recordAttempt(level, tokens, report) {
+    const reduced = report.before > report.after;
+    const repaired = !!report.repaired;
+    if (reduced || repaired) {
+      this.lastNoopAttempt = null;
+    } else {
+      this.lastNoopAttempt = { level, tokens };
+    }
+  }
   async compact(ctx, aggressive, pressure) {
     try {
       const report = await this.compactor.compact(ctx, { aggressive });
+      this.recordAttempt(pressure.level, pressure.tokens, report);
       this.events?.emit("compaction.fired", {
         level: pressure.level,
         tokens: pressure.tokens,
@@ -8239,29 +8324,35 @@ var SubagentBudget = class _SubagentBudget {
    * 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
+   * with redundant threshold events. Cleared in `negotiateExtension`'s
    * `finally`.
    */
   pendingExtensions = /* @__PURE__ */ new Set();
   /**
-   * Hard cap on how long `checkLimitAsync` waits for the coordinator to
+   * Hard cap on how long `negotiateExtension` waits for the coordinator to
    * respond before defaulting to 'stop'. Without this fallback an absent
    * or hung listener (Director not built / event filter detached mid-run)
-   * leaves the budget over-limit and never enforces anything, since
-   * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
-   * Raised from 30s to 60s to give subagents more headroom before
-   * the threshold negotiation times out and triggers a hard stop.
+   * leaves the budget over-limit and never enforces anything.
    */
   static DECISION_TIMEOUT_MS = 6e4;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
-   * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
+   * Used to emit `budget.threshold_reached` events in `'auto'` mode.
    */
   _events;
+  /**
+   * Negotiation mode — controls whether a threshold hit tries to emit
+   * `budget.threshold_reached` and wait for a coordinator decision, or
+   * falls straight through to a synchronous hard stop.
+   *
+   * `'auto'` (default) — emit on the EventBus and wait; times out to 'stop'.
+   * `'sync'` — throw `BudgetExceededError` immediately regardless of listeners.
+   */
+  _mode;
   /**
    * Optional callback for soft-limit handling. When set, the budget will
-   * call this instead of throwing when a limit is first reached. The
-   * handler decides whether to throw, continue, or ask the coordinator.
+   * invoke it rather than throw immediately. The handler decides whether to
+   * throw synchronously, continue, or ask the coordinator for an extension.
    */
   get onThreshold() {
     return this._onThreshold;
@@ -8269,7 +8360,12 @@ var SubagentBudget = class _SubagentBudget {
   set onThreshold(fn) {
     this._onThreshold = fn;
   }
-  constructor(limits = {}) {
+  /** Returns the current negotiation mode. */
+  get mode() {
+    return this._mode;
+  }
+  constructor(limits = {}, mode = "auto") {
+    this._mode = mode;
     this.limits = { ...limits };
   }
   start() {
@@ -8285,16 +8381,23 @@ var SubagentBudget = class _SubagentBudget {
     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.
+   * Synchronous budget check. Always throws synchronously so callers (especially
+   * test event handlers using `expect().toThrow()`) get an unhandled rejection
+   * when the budget is exceeded without a handler.
+   *
+   * Decision table:
+   * - no `onThreshold` handler         → throw `BudgetExceededError` (hard stop, always)
+   * - `mode === 'sync'`               → throw `BudgetExceededError` (hard stop, always)
+   * - `mode === 'auto'` + no listener  → throw `BudgetExceededError` (hard stop; no one to ask)
+   * - `mode === 'auto'` + listener     → throw `BudgetThresholdSignal` with async decision promise
    */
   checkLimit(kind, used, limit) {
     if (!this._onThreshold) {
       throw new BudgetExceededError(kind, limit, used);
     }
+    if (this._mode === "sync") {
+      throw new BudgetExceededError(kind, limit, used);
+    }
     const bus = this._events;
     if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
       throw new BudgetExceededError(kind, limit, used);
@@ -8311,8 +8414,8 @@ var SubagentBudget = class _SubagentBudget {
    * `pendingExtensions` slot in `finally`.
    *
    * The 'continue' return from a sync handler is treated as
-   * `{ extend: {} }` — keep going without patching, next overrun will
-   * fire a fresh signal.
+   * `{ extend: {} }` — keep going without patching; next overrun fires
+   * a fresh signal.
    */
   async negotiateExtension(kind, used, limit) {
     try {
@@ -8320,11 +8423,6 @@ var SubagentBudget = class _SubagentBudget {
         kind,
         used,
         limit,
-        // Inject a requestDecision helper the handler can call to emit the
-        // budget.threshold_reached event and wait for the coordinator's verdict.
-        // A hard fallback timer guarantees the promise eventually resolves
-        // even if no listener responds — without it, an absent/detached
-        // Director would leave the budget permanently in "asking" state.
         requestDecision: () => {
           const bus = this._events;
           if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
@@ -8408,12 +8506,12 @@ var SubagentBudget = class _SubagentBudget {
     }
   }
   /**
-   * 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.
+   * Wall-clock budget check. Unlike other limits, timeout check passes through
+   * `checkLimit` and is subject to the same negotiation-mode decision table.
+   * In practice, `'sync'` mode (the usual test configuration) means a timeout
+   * immediately throws `BudgetExceededError`. In production with a coordinator,
+   * a timeout emits `budget.threshold_reached` so the Director can decide whether
+   * to extend or abort.
    */
   checkTimeout() {
     if (this.startTime === null || this.limits.timeoutMs === void 0) return;
@@ -10794,8 +10892,7 @@ function scoreAgents(task, catalog = AGENT_CATALOG) {
   const hay = normalize2(task);
   const out = [];
   for (const def of Object.values(catalog)) {
-    const role = def.config.role;
-    if (!role) continue;
+    if (!def?.config?.role) continue;
     let score = 0;
     const matched = [];
     for (const kw of def.capability.keywords) {
@@ -10807,7 +10904,7 @@ function scoreAgents(task, catalog = AGENT_CATALOG) {
       }
     }
     if (score > 0) {
-      out.push({ role, name: def.config.name, score, matched });
+      out.push({ role: def.config.role, name: def.config.name, score, matched });
     }
   }
   out.sort((a, b) => b.score - a.score);
@@ -11178,6 +11275,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   coordinatorId;
   config;
   runner;
+  fleetBus;
   subagents = /* @__PURE__ */ new Map();
   pendingTasks = [];
   completedResults = [];
@@ -11206,6 +11304,14 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   setRunner(runner) {
     this.runner = runner;
   }
+  /**
+   * Wire a FleetBus for director-mode event emission. Call after the
+   * FleetManager is constructed so the coordinator can emit lifecycle
+   * events the TUI and monitoring tools subscribe to.
+   */
+  setFleetBus(fleet) {
+    this.fleetBus = fleet;
+  }
   /**
    * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
    * preempt running tasks — already-dispatched subagents finish their
@@ -11241,6 +11347,18 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       abortController: new AbortController()
     });
     this.emit("subagent.started", { subagent: { ...subagent, id } });
+    this.fleetBus?.emit({
+      subagentId: id,
+      ts: Date.now(),
+      type: "subagent.assigned",
+      payload: {
+        subagentId: id,
+        name: subagent.name,
+        provider: subagent.provider,
+        model: subagent.model
+      }
+    });
+    this.emitCoordinatorStats();
     return { subagentId: id, agentId: id };
   }
   async assign(task) {
@@ -11273,6 +11391,13 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     subagent.currentTask = void 0;
     subagent.context.parentBridge = null;
     this.emit("subagent.stopped", { subagentId, reason: "stopped by coordinator" });
+    this.fleetBus?.emit({
+      subagentId,
+      ts: Date.now(),
+      type: "subagent.stopped",
+      payload: { subagentId, reason: "stopped by coordinator" }
+    });
+    this.emitCoordinatorStats();
   }
   async stopAll() {
     this.drainPendingAsAborted("Coordinator stopAll() drained the pending queue");
@@ -11304,6 +11429,22 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       completed: this.completedResults.length
     };
   }
+  /** Emit a reactive coordinator.stats event on FleetBus so the TUI can subscribe. */
+  emitCoordinatorStats() {
+    const stats = this.getStats();
+    const subagentStatuses = Array.from(this.subagents.entries()).map(([id, s]) => ({
+      subagentId: id,
+      taskId: s.currentTask ?? "",
+      status: s.status,
+      assigned: s.context.parentBridge !== null
+    }));
+    this.fleetBus?.emit({
+      subagentId: this.coordinatorId,
+      ts: Date.now(),
+      type: "coordinator.stats",
+      payload: { ...stats, subagentStatuses }
+    });
+  }
   getStatus() {
     return {
       coordinatorId: this.coordinatorId,
@@ -11478,7 +11619,15 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     subagent.currentTask = task.id;
     task.subagentId = subagentId;
     subagent.context.tasks.push(task);
+    this.fleetBus?.emit({
+      subagentId,
+      taskId: task.id,
+      ts: Date.now(),
+      type: "subagent.running",
+      payload: { subagentId, taskId: task.id }
+    });
     this.emit("task.assigned", { task, subagentId });
+    this.emitCoordinatorStats();
     const rawMaxIterations = subagent.config.maxIterations;
     const rawMaxToolCalls = subagent.config.maxToolCalls;
     const rawMaxTokens = subagent.config.maxTokens;
@@ -11622,13 +11771,34 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       if (subagent.abortController.signal.aborted) {
         subagent.abortController = new AbortController();
       }
+      this.fleetBus?.emit({
+        subagentId: result.subagentId,
+        ts: Date.now(),
+        type: "subagent.idle",
+        payload: { subagentId: result.subagentId }
+      });
     }
     this.terminating.delete(result.subagentId);
     this.emit("task.completed", {
       task: subagent?.context.tasks.find((t2) => t2.id === result.taskId) ?? { id: result.taskId },
       result
     });
+    this.fleetBus?.emit({
+      subagentId: result.subagentId,
+      taskId: result.taskId,
+      ts: Date.now(),
+      type: "subagent.completed",
+      payload: {
+        subagentId: result.subagentId,
+        taskId: result.taskId,
+        status: result.status,
+        iterations: result.iterations,
+        toolCalls: result.toolCalls,
+        durationMs: result.durationMs
+      }
+    });
     this.tryDispatchNext();
+    this.emitCoordinatorStats();
     if (this.isDone()) {
       this.emit("done", {
         results: this.completedResults,
@@ -12335,18 +12505,17 @@ var FleetBus = class {
   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.
+   * Hook a subagent's EventBus into the fleet. Uses `onAny()` (an alias for
+   * `onPattern('*')`) to forward all events with subagent attribution, so
+   * new kernel event types are automatically forwarded without any manual
+   * registration. `subagent.*` events are excluded because they originate
+   * from MultiAgentHost on the parent bus, not the subagent's own bus.
    *
    * Returns a disposer that detaches every subscription; call on
    * subagent teardown so the listeners don't outlive the run.
    */
   attach(subagentId, bus, taskId) {
-    const off = bus.onPattern("*", (type, payload) => {
+    const off = bus.onAny((type, payload) => {
       if (type.startsWith("subagent.")) return;
       this.emit({ subagentId, taskId, ts: Date.now(), type, payload });
     });
@@ -12468,7 +12637,7 @@ var FleetUsageAggregator = class {
     this.total.output += usage.output ?? 0;
     this.total.cacheRead += usage.cacheRead ?? 0;
     this.total.cacheWrite += usage.cacheWrite ?? 0;
-    const price = this.priceLookup?.(e.subagentId);
+    const price = this.priceLookup?.(e.subagentId, snap.provider, snap.model);
     if (price) {
       const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
       snap.cost += delta;
@@ -12491,8 +12660,9 @@ 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." },
+      role: { type: "string", description: "Roster role id. When set, the spawn uses the matching config from the roster and ignores other fields." },
+      description: { type: "string", description: "Free-form task description. When `role` is not set, the director uses the smart dispatcher to route this to the best-matching catalog agent. Use this when you don't know the exact role name." },
+      name: { type: "string", description: "Display name for the subagent. Used as a fallback when description-based dispatch does not resolve a role." },
       provider: { type: "string", description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the leader provider when omitted.' },
       model: { type: "string", description: "Model id within the provider. Defaults to the leader model when omitted." },
       systemPromptOverride: { type: "string", description: "Extra prompt text appended after the role-base prompt." },
@@ -12505,18 +12675,38 @@ function makeSpawnTool(director, roster) {
   return {
     name: "spawn_subagent",
     description: "Create a new subagent under this director. Returns the subagent id.",
-    usageHint: "Either pass `role` (matches the roster) OR pass `name` + optional `provider`/`model`. Returns `{ subagentId }`.",
+    usageHint: "Pass `role` (matches the roster), `description` (smart dispatch to best agent), or `name` + `provider`/`model`. Returns `{ subagentId }`.",
     permission: "auto",
     mutating: false,
     inputSchema,
     async execute(input) {
       const i = input ?? {};
       const role = typeof i.role === "string" ? i.role : void 0;
-      const base = role && roster ? roster[role] : void 0;
-      if (role && !base) {
-        return { error: `unknown role "${role}". roster has: ${roster ? Object.keys(roster).join(", ") : "(empty)"}` };
+      const description = typeof i.description === "string" ? i.description : void 0;
+      let cfg;
+      if (role && roster) {
+        const base = roster[role];
+        if (!base) return { error: `unknown role "${role}". roster has: ${Object.keys(roster).join(", ")}` };
+        cfg = instantiateRosterConfig(role, base);
+      } else if (description && !role) {
+        const dispatchResult = await dispatchAgent(description, {
+          classifier: director.dispatchClassifier,
+          catalog: roster
+        });
+        const dispatchRole = dispatchResult.role;
+        if (roster && roster[dispatchRole]) {
+          cfg = instantiateRosterConfig(dispatchRole, roster[dispatchRole]);
+        } else {
+          const def = dispatchResult.definition;
+          cfg = {
+            name: def.config.name ?? dispatchRole,
+            role: dispatchRole,
+            provider: def.config.provider,
+            model: def.config.model
+          };
+        }
       }
-      const cfg = base ? instantiateRosterConfig(role, base) : { name: i.name ?? "subagent" };
+      cfg ??= { name: i.name ?? "subagent" };
       if (typeof i.name === "string") cfg.name = i.name;
       if (typeof i.provider === "string") cfg.provider = i.provider;
       if (typeof i.model === "string") cfg.model = i.model;
@@ -12526,7 +12716,7 @@ function makeSpawnTool(director, roster) {
       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 };
+        return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name, role: cfg.role };
       } catch (err) {
         if (err instanceof FleetSpawnBudgetError) {
           return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
@@ -12650,12 +12840,21 @@ function makeTerminateTool(director) {
 function makeFleetStatusTool(director) {
   return {
     name: "fleet_status",
-    description: "Snapshot of the fleet \u2014 every subagent's current status, pending vs. completed task counts.",
+    description: "Snapshot of the fleet \u2014 every subagent's current status, coordinator counts (total/running/idle/stopped), pending task descriptions, and usage rollup.",
     permission: "auto",
     mutating: false,
     inputSchema: { type: "object", properties: {}, required: [] },
     async execute() {
-      return director.status();
+      const base = director.status();
+      const fm = director.fleetManager;
+      const stats = fm?.getFleetStats();
+      const fleetStatus = fm?.getFleetStatus();
+      return {
+        subagents: base.subagents,
+        coordinatorStats: stats ? { total: stats.total, running: stats.running, idle: stats.idle, stopped: stats.stopped } : void 0,
+        pending: fleetStatus?.pending ?? [],
+        usage: fm?.snapshot()
+      };
     }
   };
 }
@@ -12857,6 +13056,8 @@ var Director = class {
    * default cap.
    */
   taskCompletedListener = null;
+  /** Optional LLM classifier for smart dispatch. Passed from options. */
+  dispatchClassifier;
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID();
     this.manifestPath = opts.manifestPath;
@@ -12869,6 +13070,7 @@ var Director = class {
     this.spawnDepth = opts.spawnDepth ?? 0;
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
+    this.dispatchClassifier = opts.dispatchClassifier;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
     this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
     this.sessionsRoot = opts.sessionsRoot;
@@ -12898,7 +13100,10 @@ var Director = class {
       this.fleet = new FleetBus();
       this.usage = new FleetUsageAggregator(
         this.fleet,
-        (id) => this.priceLookups.get(id),
+        (id, provider, model) => {
+          if (provider && model) return this.priceLookups.get(`${provider}/${model}`);
+          return void 0;
+        },
         (id) => this.subagentMeta.get(id)
       );
     }
@@ -12906,6 +13111,8 @@ var Director = class {
       { ...opts.config, coordinatorId: this.id },
       { runner: opts.runner }
     );
+    this.coordinator.setFleetBus(this.fleet);
+    this.fleetManager?.setCoordinator(this.coordinator);
     this.taskCompletedListener = (payload) => {
       const r = payload.result;
       this.completed.set(r.taskId, r);
@@ -12940,7 +13147,11 @@ var Director = class {
           title
         }
       );
-      this.scheduleManifest();
+      if (this.fleetManager) {
+        this.fleetManager.flushManifest();
+      } else {
+        this.scheduleManifest();
+      }
     };
     this.coordinator.on("task.completed", this.taskCompletedListener);
     const extendCounts = /* @__PURE__ */ new Map();
@@ -13032,10 +13243,17 @@ var Director = class {
     }
   }
   /** Debounced manifest writer. A burst of spawn/assign/complete events
-   *  collapses into one write. Set `manifestDebounceMs` to 0 to disable. */
+   *  collapses into one write. Set `manifestDebounceMs` to 0 to write
+   *  synchronously (no debounce); set to negative to disable entirely. */
   scheduleManifest() {
-    if (!this.manifestPath || this.manifestDebounceMs <= 0) return;
-    if (this.manifestTimer) return;
+    if (!this.manifestPath) return;
+    if (this.manifestDebounceMs === 0) {
+      void this.writeManifest().catch(
+        (err) => this.logShutdownError("manifest_write_debounced", err)
+      );
+      return;
+    }
+    if (this.manifestDebounceMs < 0) return;
     this.manifestTimer = setTimeout(() => {
       this.manifestTimer = null;
       void this.writeManifest().catch(
@@ -13084,7 +13302,9 @@ var Director = class {
         provider: config.provider,
         model: config.model
       });
-      if (priceLookup) this.priceLookups.set(result.subagentId, priceLookup);
+      if (priceLookup && config.provider && config.model) {
+        this.priceLookups.set(`${config.provider}/${config.model}`, priceLookup);
+      }
     }
     const subagentBridge = new InMemoryAgentBridge(
       { agentId: result.subagentId, coordinatorId: this.id },
@@ -20198,6 +20418,8 @@ var FleetManager = class {
   pendingTasks = /* @__PURE__ */ new Map();
   subagentMeta = /* @__PURE__ */ new Map();
   priceLookups = /* @__PURE__ */ new Map();
+  /** The coordinator (wired via setCoordinator by Director after construction). */
+  coordinator = null;
   constructor(opts = {}) {
     this.manifestPath = opts.manifestPath;
     this.sessionsRoot = opts.sessionsRoot;
@@ -20222,7 +20444,10 @@ var FleetManager = class {
     this.fleet = new FleetBus();
     this.usage = new FleetUsageAggregator(
       this.fleet,
-      (id) => this.priceLookups.get(id),
+      (id, provider, model) => {
+        if (provider && model) return this.priceLookups.get(`${provider}/${model}`);
+        return void 0;
+      },
       (id) => this.subagentMeta.get(id)
     );
   }
@@ -20232,11 +20457,26 @@ var FleetManager = class {
   get fleetBus() {
     return this.fleet;
   }
+  /**
+   * Wire the coordinator after Director construction. The coordinator
+   * is not available when FleetManager is constructed standalone.
+   * Once set, `getFleetStats()` delegates to `coordinator.getStats()`.
+   */
+  setCoordinator(coordinator) {
+    this.coordinator = coordinator;
+  }
   snapshot() {
     return this.usage.snapshot();
   }
   getSubagentMeta(id) {
-    return this.subagentMeta.get(id);
+    const meta = this.subagentMeta.get(id);
+    const manifest = this.manifestEntries.get(id);
+    if (!meta && !manifest) return void 0;
+    return {
+      provider: meta?.provider ?? manifest?.provider,
+      model: meta?.model ?? manifest?.model,
+      name: manifest?.name
+    };
   }
   /**
    * Returns null if the spawn is allowed, or an object describing
@@ -20273,7 +20513,9 @@ var FleetManager = class {
       provider: config.provider,
       model: config.model
     });
-    if (priceLookup) this.priceLookups.set(subagentId, priceLookup);
+    if (priceLookup && config.provider && config.model) {
+      this.priceLookups.set(`${config.provider}/${config.model}`, priceLookup);
+    }
     this.manifestEntries.set(subagentId, {
       subagentId,
       name: config.name,
@@ -20329,9 +20571,21 @@ var FleetManager = class {
   /**
    * Debounced manifest write. Call after any state mutation
    * (spawn, assign, complete) so a burst collapses into one write.
+   * When `manifestDebounceMs` is 0, writes are synchronous (no debounce).
    */
   scheduleManifest() {
-    if (!this.manifestPath || this.manifestDebounceMs <= 0) return;
+    if (!this.manifestPath) return;
+    if (this.manifestDebounceMs === 0) {
+      void this.writeManifest().catch((err) => {
+        const detail = err instanceof Error ? err.message : String(err);
+        process.emitWarning(
+          `FleetManager manifest write failed: ${detail}`,
+          "FleetManagerWarning"
+        );
+      });
+      return;
+    }
+    if (this.manifestDebounceMs < 0) return;
     if (this.manifestTimer) return;
     this.manifestTimer = setTimeout(() => {
       this.manifestTimer = null;
@@ -20344,6 +20598,24 @@ var FleetManager = class {
       });
     }, this.manifestDebounceMs);
   }
+  /**
+   * Bypass the debounce timer and write the manifest immediately.
+   * Clears any pending debounce timer before writing.
+   */
+  async flushManifest() {
+    if (!this.manifestPath) return;
+    if (this.manifestTimer) {
+      clearTimeout(this.manifestTimer);
+      this.manifestTimer = null;
+    }
+    await this.writeManifest().catch((err) => {
+      const detail = err instanceof Error ? err.message : String(err);
+      process.emitWarning(
+        `FleetManager manifest write failed: ${detail}`,
+        "FleetManagerWarning"
+      );
+    });
+  }
   /** Best-effort session event writer. Swallows failures. */
   async appendSessionEvent(event) {
     if (!this.sessionWriter) return;
@@ -20361,6 +20633,31 @@ var FleetManager = class {
   removePendingTask(taskId) {
     this.pendingTasks.delete(taskId);
   }
+  getFleetStats() {
+    if (!this.coordinator) {
+      return {
+        total: 0,
+        running: 0,
+        idle: 0,
+        stopped: 0,
+        inFlight: 0,
+        pending: 0,
+        completed: 0,
+        subagentStatuses: []
+      };
+    }
+    const stats = this.coordinator.getStats();
+    const subagentStatuses = [];
+    for (const [subagentId, s] of this.coordinator["subagents"]) {
+      subagentStatuses.push({
+        subagentId,
+        taskId: s.currentTask ?? "",
+        status: s.status,
+        assigned: s.context.parentBridge !== null
+      });
+    }
+    return { ...stats, subagentStatuses };
+  }
   getFleetStatus() {
     const pending = Array.from(this.pendingTasks.entries()).map(([taskId, v]) => ({
       taskId,