@wrongstack/core 0.7.8 → 0.8.0

package/dist/coordination/index.js

@@ -479,18 +479,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 });
     });
@@ -612,7 +611,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;
@@ -785,29 +784,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;
@@ -815,7 +820,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() {
@@ -831,16 +841,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);
@@ -857,8 +874,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 {
@@ -866,11 +883,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")) {
@@ -954,12 +966,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;
@@ -3433,6 +3445,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   coordinatorId;
   config;
   runner;
+  fleetBus;
   subagents = /* @__PURE__ */ new Map();
   pendingTasks = [];
   completedResults = [];
@@ -3461,6 +3474,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
@@ -3496,6 +3517,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) {
@@ -3528,6 +3561,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");
@@ -3559,6 +3599,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,
@@ -3733,7 +3789,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;
@@ -3877,13 +3941,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((t) => t.id === result.taskId) ?? { id: result.taskId },
       result
     });
+    this.fleetBus?.emit({
+      subagentId: result.subagentId,
+      taskId: result.taskId,
+      ts: Date.now(),
+      type: "subagent.completed",
+      payload: {
+        subagentId: result.subagentId,
+        taskId: result.taskId,
+        status: result.status,
+        iterations: result.iterations,
+        toolCalls: result.toolCalls,
+        durationMs: result.durationMs
+      }
+    });
     this.tryDispatchNext();
+    this.emitCoordinatorStats();
     if (this.isDone()) {
       this.emit("done", {
         results: this.completedResults,
@@ -3995,12 +4080,137 @@ function providerErrorToSubagentError(err, message, cause) {
   }
   return { kind: "unknown", message, retryable: err.retryable, cause };
 }
+
+// src/coordination/dispatcher.ts
+var DEFAULT_DISPATCH_ROLE = "executor";
+function normalize(text) {
+  return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
+}
+function scoreAgents(task, catalog = AGENT_CATALOG) {
+  const hay = normalize(task);
+  const out = [];
+  for (const def of Object.values(catalog)) {
+    if (!def?.config?.role) continue;
+    let score = 0;
+    const matched = [];
+    for (const kw of def.capability.keywords) {
+      const needle = normalize(kw);
+      if (hay.includes(needle.trimEnd() + " ") || hay.includes(" " + needle.trimStart())) {
+        const words = kw.trim().split(/\s+/).length;
+        score += words;
+        matched.push(kw);
+      }
+    }
+    if (score > 0) {
+      out.push({ role: def.config.role, name: def.config.name, score, matched });
+    }
+  }
+  out.sort((a, b) => b.score - a.score);
+  return out;
+}
+function heuristicConfidence(candidates) {
+  if (candidates.length === 0) return 0;
+  const top = candidates[0].score;
+  const second = candidates[1]?.score ?? 0;
+  const strength = Math.min(1, top / 3);
+  const margin = (top - second + 1) / (top + 1);
+  return Math.min(1, strength * margin);
+}
+async function dispatchAgent(task, opts = {}) {
+  const catalog = opts.catalog ?? AGENT_CATALOG;
+  const threshold = opts.confidenceThreshold ?? 0.4;
+  const maxCandidates = opts.maxCandidates ?? 6;
+  const candidates = scoreAgents(task, catalog);
+  const confidence = heuristicConfidence(candidates);
+  const top = candidates[0];
+  if (top && confidence >= threshold) {
+    return {
+      role: top.role,
+      definition: catalog[top.role],
+      confidence,
+      method: "heuristic",
+      reason: `Matched keywords: ${top.matched.slice(0, 4).join(", ")}`,
+      alternatives: candidates.slice(1, maxCandidates)
+    };
+  }
+  if (opts.classifier) {
+    const pool = (candidates.length > 0 ? candidates.slice(0, maxCandidates).map((c) => catalog[c.role]) : ALL_AGENT_DEFINITIONS).map((d) => ({
+      role: d.config.role,
+      name: d.config.name,
+      summary: d.capability.summary
+    }));
+    try {
+      const choice = await opts.classifier(task, pool);
+      if (choice && catalog[choice.role]) {
+        return {
+          role: choice.role,
+          definition: catalog[choice.role],
+          confidence: 1,
+          method: "llm",
+          reason: choice.reason ?? "Selected by LLM classifier",
+          alternatives: candidates.slice(0, maxCandidates).filter((c) => c.role !== choice.role)
+        };
+      }
+    } catch {
+    }
+  }
+  if (top) {
+    return {
+      role: top.role,
+      definition: catalog[top.role],
+      confidence,
+      method: "heuristic",
+      reason: `Weak match (${top.matched.slice(0, 3).join(", ") || "low signal"})`,
+      alternatives: candidates.slice(1, maxCandidates)
+    };
+  }
+  const fallbackRole = catalog[DEFAULT_DISPATCH_ROLE] ? DEFAULT_DISPATCH_ROLE : Object.keys(catalog)[0];
+  return {
+    role: fallbackRole,
+    definition: catalog[fallbackRole],
+    confidence: 0,
+    method: "fallback",
+    reason: "No keyword signal; defaulting to the generalist Executor",
+    alternatives: []
+  };
+}
+function makeLLMClassifier(complete) {
+  return async (task, candidates) => {
+    const list = candidates.map((c, i) => `${i + 1}. ${c.role} \u2014 ${c.summary}`).join("\n");
+    const prompt = `You are an agent router. Pick the single best agent for the task.
+
+Task:
+${task}
+
+Agents:
+${list}
+
+Reply with ONLY a compact JSON object: {"role":"<one role id from the list>","reason":"<short why>"}.
+Do not add prose, markdown, or code fences.`;
+    const raw = (await complete(prompt)).trim();
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) return null;
+    try {
+      const parsed = JSON.parse(match[0]);
+      if (typeof parsed.role !== "string") return null;
+      const role = parsed.role.trim();
+      const valid = candidates.some((c) => c.role === role);
+      if (!valid) return null;
+      return { role, reason: typeof parsed.reason === "string" ? parsed.reason : void 0 };
+    } catch {
+      return null;
+    }
+  };
+}
+
+// src/coordination/director-tools.ts
 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." },
@@ -4013,18 +4223,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;
@@ -4034,7 +4264,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 };
@@ -4158,12 +4388,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()
+      };
     }
   };
 }
@@ -4365,6 +4604,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;
@@ -4377,6 +4618,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;
@@ -4406,7 +4648,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)
       );
     }
@@ -4414,6 +4659,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);
@@ -4448,7 +4695,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();
@@ -4540,10 +4791,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(
@@ -4592,7 +4850,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 },
@@ -6110,129 +6370,6 @@ function makeDirectorSessionFactory(opts) {
   };
 }
 
-// src/coordination/dispatcher.ts
-var DEFAULT_DISPATCH_ROLE = "executor";
-function normalize(text) {
-  return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
-}
-function scoreAgents(task, catalog = AGENT_CATALOG) {
-  const hay = normalize(task);
-  const out = [];
-  for (const def of Object.values(catalog)) {
-    const role = def.config.role;
-    if (!role) continue;
-    let score = 0;
-    const matched = [];
-    for (const kw of def.capability.keywords) {
-      const needle = normalize(kw);
-      if (hay.includes(needle.trimEnd() + " ") || hay.includes(" " + needle.trimStart())) {
-        const words = kw.trim().split(/\s+/).length;
-        score += words;
-        matched.push(kw);
-      }
-    }
-    if (score > 0) {
-      out.push({ role, name: def.config.name, score, matched });
-    }
-  }
-  out.sort((a, b) => b.score - a.score);
-  return out;
-}
-function heuristicConfidence(candidates) {
-  if (candidates.length === 0) return 0;
-  const top = candidates[0].score;
-  const second = candidates[1]?.score ?? 0;
-  const strength = Math.min(1, top / 3);
-  const margin = (top - second + 1) / (top + 1);
-  return Math.min(1, strength * margin);
-}
-async function dispatchAgent(task, opts = {}) {
-  const catalog = opts.catalog ?? AGENT_CATALOG;
-  const threshold = opts.confidenceThreshold ?? 0.4;
-  const maxCandidates = opts.maxCandidates ?? 6;
-  const candidates = scoreAgents(task, catalog);
-  const confidence = heuristicConfidence(candidates);
-  const top = candidates[0];
-  if (top && confidence >= threshold) {
-    return {
-      role: top.role,
-      definition: catalog[top.role],
-      confidence,
-      method: "heuristic",
-      reason: `Matched keywords: ${top.matched.slice(0, 4).join(", ")}`,
-      alternatives: candidates.slice(1, maxCandidates)
-    };
-  }
-  if (opts.classifier) {
-    const pool = (candidates.length > 0 ? candidates.slice(0, maxCandidates).map((c) => catalog[c.role]) : ALL_AGENT_DEFINITIONS).map((d) => ({
-      role: d.config.role,
-      name: d.config.name,
-      summary: d.capability.summary
-    }));
-    try {
-      const choice = await opts.classifier(task, pool);
-      if (choice && catalog[choice.role]) {
-        return {
-          role: choice.role,
-          definition: catalog[choice.role],
-          confidence: 1,
-          method: "llm",
-          reason: choice.reason ?? "Selected by LLM classifier",
-          alternatives: candidates.slice(0, maxCandidates).filter((c) => c.role !== choice.role)
-        };
-      }
-    } catch {
-    }
-  }
-  if (top) {
-    return {
-      role: top.role,
-      definition: catalog[top.role],
-      confidence,
-      method: "heuristic",
-      reason: `Weak match (${top.matched.slice(0, 3).join(", ") || "low signal"})`,
-      alternatives: candidates.slice(1, maxCandidates)
-    };
-  }
-  const fallbackRole = catalog[DEFAULT_DISPATCH_ROLE] ? DEFAULT_DISPATCH_ROLE : Object.keys(catalog)[0];
-  return {
-    role: fallbackRole,
-    definition: catalog[fallbackRole],
-    confidence: 0,
-    method: "fallback",
-    reason: "No keyword signal; defaulting to the generalist Executor",
-    alternatives: []
-  };
-}
-function makeLLMClassifier(complete) {
-  return async (task, candidates) => {
-    const list = candidates.map((c, i) => `${i + 1}. ${c.role} \u2014 ${c.summary}`).join("\n");
-    const prompt = `You are an agent router. Pick the single best agent for the task.
-
-Task:
-${task}
-
-Agents:
-${list}
-
-Reply with ONLY a compact JSON object: {"role":"<one role id from the list>","reason":"<short why>"}.
-Do not add prose, markdown, or code fences.`;
-    const raw = (await complete(prompt)).trim();
-    const match = raw.match(/\{[\s\S]*\}/);
-    if (!match) return null;
-    try {
-      const parsed = JSON.parse(match[0]);
-      if (typeof parsed.role !== "string") return null;
-      const role = parsed.role.trim();
-      const valid = candidates.some((c) => c.role === role);
-      if (!valid) return null;
-      return { role, reason: typeof parsed.reason === "string" ? parsed.reason : void 0 };
-    } catch {
-      return null;
-    }
-  };
-}
-
 // src/coordination/auto-extend.ts
 var DEFAULT_CEILING = {
   maxIterations: 5e4,
@@ -6323,6 +6460,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;
@@ -6347,7 +6486,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)
     );
   }
@@ -6357,11 +6499,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
@@ -6398,7 +6555,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,
@@ -6454,9 +6613,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;
@@ -6469,6 +6640,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;
@@ -6486,6 +6675,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,