@wrongstack/core 0.7.8 → 0.8.2

package/dist/{multi-agent-coordinator-3Ypfg-hr.d.ts → multi-agent-coordinator-IQKrMfXz.d.ts}

@@ -1,4 +1,5 @@
-import { m as SubagentConfig, k as MultiAgentCoordinator, M as MultiAgentConfig, s as SubagentRunner, S as SpawnResult, u as TaskSpec, B as BridgeMessage, A as AgentBridge, j as CoordinatorStatus, t as TaskResult } from './multi-agent-7OK4pEKW.js';
+import { n as SubagentConfig, l as MultiAgentCoordinator, M as MultiAgentConfig, t as SubagentRunner, S as SpawnResult, v as TaskSpec, B as BridgeMessage, A as AgentBridge, k as CoordinatorStatus, u as TaskResult } from './multi-agent-CRMznZmf.js';
+import { F as FleetBus } from './agent-subagent-runner-Cav3yEJM.js';
 import { EventEmitter } from 'node:events';
 
 /**
@@ -175,6 +176,7 @@ declare class DefaultMultiAgentCoordinator extends EventEmitter implements Multi
     readonly coordinatorId: string;
     readonly config: MultiAgentConfig;
     private runner?;
+    private fleetBus?;
     private readonly subagents;
     private pendingTasks;
     private completedResults;
@@ -196,6 +198,12 @@ declare class DefaultMultiAgentCoordinator extends EventEmitter implements Multi
      * the coordinator's owning Director is built.
      */
     setRunner(runner: SubagentRunner): void;
+    /**
+     * 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: FleetBus): void;
     /**
      * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
      * preempt running tasks — already-dispatched subagents finish their
@@ -226,6 +234,8 @@ declare class DefaultMultiAgentCoordinator extends EventEmitter implements Multi
         pending: number;
         completed: number;
     };
+    /** Emit a reactive coordinator.stats event on FleetBus so the TUI can subscribe. */
+    private emitCoordinatorStats;
     getStatus(): CoordinatorStatus;
     /** Expose snapshot of completed results — useful for callers awaiting all done. */
     results(): readonly TaskResult[];

package/dist/{null-fleet-bus-BZUrXVcd.d.ts → null-fleet-bus-sKnVwEd8.d.ts}

@@ -1,10 +1,10 @@
-import { c as AgentPhase, b as AgentDefinition } from './multi-agent-coordinator-3Ypfg-hr.js';
-import { m as SubagentConfig, t as TaskResult, j as CoordinatorStatus, u as TaskSpec, M as MultiAgentConfig, s as SubagentRunner } from './multi-agent-7OK4pEKW.js';
+import { c as AgentPhase, b as AgentDefinition, d as DefaultMultiAgentCoordinator, f as DispatchClassifier } from './multi-agent-coordinator-IQKrMfXz.js';
+import { n as SubagentConfig, u as TaskResult, k as CoordinatorStatus, v as TaskSpec, M as MultiAgentConfig, t as SubagentRunner } from './multi-agent-CRMznZmf.js';
 import { B as SessionWriter, Q as Tool, y as SessionStore } from './context-z2x5gv_V.js';
 import { a as DirectorStateSnapshot } from './director-state-BmYi3DGA.js';
-import { I as InMemoryAgentBridge } from './agent-bridge-hXRN-GO_.js';
-import { F as FleetBus, e as FleetUsage, f as FleetUsageAggregator } from './agent-subagent-runner-B2zguWzh.js';
-import { E as EventBus } from './events-D4pGukpI.js';
+import { I as InMemoryAgentBridge } from './agent-bridge-DPxcUVkn.js';
+import { F as FleetBus, e as FleetUsage, f as FleetUsageAggregator } from './agent-subagent-runner-Cav3yEJM.js';
+import { E as EventBus } from './events-DyhxkstG.js';
 
 /**
  * Agent catalog aggregator.
@@ -176,6 +176,11 @@ interface IFleetManager {
      * or null when no manifest path is configured.
      */
     writeManifest(): Promise<string | null>;
+    /**
+     * Bypass the debounce timer and write the manifest immediately.
+     * Clears any pending debounce timer before writing.
+     */
+    flushManifest(): Promise<void>;
     /**
      * Aggregate fleet-wide status: pending tasks with descriptions and
      * live subagent snapshot from the coordinator. Used by
@@ -204,6 +209,44 @@ interface IFleetManager {
      * pending list stays accurate.
      */
     removePendingTask(taskId: string): void;
+    /**
+     * Wire the coordinator so `getFleetStats()` can delegate to it.
+     * Called by `Director` after constructing the coordinator so
+     * FleetManager's stats reflect live subagent data.
+     */
+    setCoordinator(coordinator: {
+        getStats(): {
+            total: number;
+            running: number;
+            idle: number;
+            stopped: number;
+            inFlight: number;
+            pending: number;
+            completed: number;
+        };
+    }): void;
+    /**
+     * Coordinator stats snapshot for the TUI and monitoring tools.
+     * Returns actionable counts (total/running/idle/stopped/inFlight/
+     * pending/completed) plus per-subagent status details.
+     * Delegates to the coordinator when available; returns zeros
+     * if the coordinator has not yet been set.
+     */
+    getFleetStats(): {
+        total: number;
+        running: number;
+        idle: number;
+        stopped: number;
+        inFlight: number;
+        pending: number;
+        completed: number;
+        subagentStatuses: {
+            subagentId: string;
+            taskId: string;
+            status: string;
+            assigned: boolean;
+        }[];
+    };
 }
 
 /** Options for constructing a FleetManager. */
@@ -271,8 +314,16 @@ declare class FleetManager implements IFleetManager {
     private readonly pendingTasks;
     private readonly subagentMeta;
     private readonly priceLookups;
+    /** The coordinator (wired via setCoordinator by Director after construction). */
+    private coordinator;
     constructor(opts?: FleetManagerOptions);
     get fleetBus(): FleetBus;
+    /**
+     * 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: DefaultMultiAgentCoordinator): void;
     snapshot(): FleetUsage;
     getSubagentMeta(id: string): {
         provider?: string;
@@ -313,12 +364,33 @@ declare class FleetManager implements IFleetManager {
     /**
      * 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(): void;
+    /**
+     * Bypass the debounce timer and write the manifest immediately.
+     * Clears any pending debounce timer before writing.
+     */
+    flushManifest(): Promise<void>;
     /** Best-effort session event writer. Swallows failures. */
     private appendSessionEvent;
     addPendingTask(taskId: string, subagentId: string, description: string): void;
     removePendingTask(taskId: string): void;
+    getFleetStats(): {
+        total: number;
+        running: number;
+        idle: number;
+        stopped: number;
+        inFlight: number;
+        pending: number;
+        completed: number;
+        subagentStatuses: {
+            subagentId: string;
+            taskId: string;
+            status: string;
+            assigned: boolean;
+        }[];
+    };
     getFleetStatus(): {
         pending: {
             taskId: string;
@@ -492,6 +564,17 @@ interface DirectorOptions {
      * (same behavior as before this field was added).
      */
     fleetManager?: FleetManager;
+    /**
+     * Optional LLM classifier for the smart dispatcher. When set, the
+     * `spawn_subagent` tool can accept a free-form `description` field
+     * and the director will automatically route to the best-matching
+     * catalog agent using `dispatchAgent()`. When omitted, routing is
+     * pure heuristic (no provider call) — sufficient for most tasks.
+     *
+     * Build from a `complete(prompt) => string` function using
+     * `makeLLMClassifier(complete)` from the dispatcher module.
+     */
+    dispatchClassifier?: DispatchClassifier;
 }
 /**
  * Thrown by `Director.spawn()` when a configured spawn cap (`maxSpawns`,
@@ -612,6 +695,8 @@ declare class Director implements ICoordinator {
      * default cap.
      */
     private taskCompletedListener;
+    /** Optional LLM classifier for smart dispatch. Passed from options. */
+    readonly dispatchClassifier?: DispatchClassifier;
     constructor(opts: DirectorOptions);
     /**
      * Record a granted budget extension and broadcast it on the FleetBus so
@@ -625,7 +710,8 @@ declare class Director implements ICoordinator {
      *  must not break a fleet run because the session JSONL handle closed. */
     private appendSessionEvent;
     /** 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. */
     private scheduleManifest;
     /**
      * Spawn a subagent. Identical to the coordinator's `spawn()` but

package/dist/observability/index.d.ts

@@ -1,5 +1,5 @@
 import { e as MetricsSink, M as MetricLabels, f as MetricsSnapshot, b as HealthRegistry, H as HealthCheck, A as AggregateHealth, T as Tracer, S as Span } from '../observability-BhnVLBLS.js';
-import { E as EventBus } from '../events-D4pGukpI.js';
+import { E as EventBus } from '../events-DyhxkstG.js';
 import '../context-z2x5gv_V.js';
 
 /**

package/dist/{path-resolver-DPUjF10O.d.ts → path-resolver-1CIYbH2Q.d.ts}

@@ -1,4 +1,4 @@
-import { E as EventBus } from './events-D4pGukpI.js';
+import { E as EventBus } from './events-DyhxkstG.js';
 import { b as ModelsRegistry, R as ResolvedModel } from './models-registry-BcYJDKLm.js';
 import { O as TokenCounter, $ as Usage, C as CacheStats } from './context-z2x5gv_V.js';
 import { P as PathResolver } from './path-resolver-CPRj4bFY.js';

package/dist/{permission-policy-D5Gj1o2K.d.ts → permission-policy-BBa1M1xc.d.ts}

@@ -1,6 +1,6 @@
 import { Q as Tool, d as Context } from './context-z2x5gv_V.js';
 import { I as InputReader } from './input-reader-E-ffP2ee.js';
-import { a as PermissionPolicy, P as PermissionDecision } from './secret-scrubber-nI8qjaqW.js';
+import { a as PermissionPolicy, P as PermissionDecision } from './secret-scrubber-CyE1-EMG.js';
 
 interface PermissionPolicyOptions {
     trustFile: string;
@@ -100,6 +100,15 @@ declare class DefaultPermissionPolicy implements PermissionPolicy {
  * subagent capability override, not a deny-bypass).
  */
 declare class AutoApprovePermissionPolicy implements PermissionPolicy {
+    /**
+     * 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.
+     */
+    private static readonly DENY;
     evaluate(tool: Tool): Promise<PermissionDecision>;
     trust(): Promise<void>;
     deny(): Promise<void>;

package/dist/{plan-templates-C-IOLJ8Q.d.ts → plan-templates-BnlpEkX8.d.ts}

@@ -1,4 +1,4 @@
-import { E as EventBus } from './events-D4pGukpI.js';
+import { E as EventBus } from './events-DyhxkstG.js';
 import { y as SessionStore, x as SessionMetadata, B as SessionWriter, r as ResumedSession, S as SessionData, z as SessionSummary, c as ContentBlock, w as SessionEvent, N as TodoItem, f as ConversationState } from './context-z2x5gv_V.js';
 import { e as AttachmentStore, A as AddAttachmentInput, d as AttachmentRef, a as Attachment } from './session-reader-DsadjyF9.js';
 import { b as MemoryStore, a as MemoryScope } from './memory-CEXuo7sz.js';

package/dist/{provider-runner-iST8U3ni.d.ts → provider-runner-BrA0XR-l.d.ts}

@@ -1,4 +1,4 @@
-import { E as EventBus } from './events-D4pGukpI.js';
+import { E as EventBus } from './events-DyhxkstG.js';
 import { a as Logger } from './logger-DDd5C--Z.js';
 import { T as Tracer } from './observability-BhnVLBLS.js';
 import { m as Provider, p as Request, d as Context, q as Response } from './context-z2x5gv_V.js';

package/dist/sdd/index.d.ts

@@ -1,13 +1,13 @@
 import { h as Specification, S as SpecAnalysis, g as SpecValidationResult, l as TaskGraph, m as TaskNode, k as TaskFilter, p as TaskSort, o as TaskProgress, r as TaskType, n as TaskPriority, e as SpecStatus, f as SpecTemplate, b as SpecRequirement } from '../task-graph-D1YQbpxF.js';
-import { E as EventBus } from '../events-D4pGukpI.js';
-import { D as DoneCondition, t as TaskResult } from '../multi-agent-7OK4pEKW.js';
-import { c as Agent } from '../index-BtNRyJft.js';
-import { A as AgentFactory } from '../agent-subagent-runner-B2zguWzh.js';
+import { E as EventBus } from '../events-DyhxkstG.js';
+import { D as DoneCondition, u as TaskResult } from '../multi-agent-CRMznZmf.js';
+import { c as Agent } from '../index-oYZeWsuJ.js';
+import { A as AgentFactory } from '../agent-subagent-runner-Cav3yEJM.js';
 import '../context-z2x5gv_V.js';
 import '../logger-DDd5C--Z.js';
 import '../system-prompt-CWA6ml-d.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-nI8qjaqW.js';
+import '../secret-scrubber-CyE1-EMG.js';
 import '../config-Bi4Q0fnz.js';
 import '../models-registry-BcYJDKLm.js';
 

package/dist/sdd/index.js

@@ -2627,29 +2627,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;
@@ -2657,7 +2663,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() {
@@ -2673,16 +2684,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);
@@ -2699,8 +2717,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 {
@@ -2708,11 +2726,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")) {
@@ -2796,12 +2809,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;
@@ -5366,6 +5379,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   coordinatorId;
   config;
   runner;
+  fleetBus;
   subagents = /* @__PURE__ */ new Map();
   pendingTasks = [];
   completedResults = [];
@@ -5394,6 +5408,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
@@ -5429,6 +5451,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) {
@@ -5461,6 +5495,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");
@@ -5492,6 +5533,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,
@@ -5666,7 +5723,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;
@@ -5810,13 +5875,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,