@wrongstack/core 0.5.5 → 0.5.7

package/dist/coordination/index.js

@@ -3,7 +3,12 @@ import * as fsp4 from 'fs/promises';
 import * as path4 from 'path';
 import { EventEmitter } from 'events';
 
-// src/coordination/director.ts
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 async function atomicWrite(targetPath, content, opts = {}) {
   const dir = path4.dirname(targetPath);
   await fsp4.mkdir(dir, { recursive: true });
@@ -70,15 +75,48 @@ async function renameWithRetry(from, to) {
 }
 
 // src/storage/director-state.ts
+async function acquireDirectorStateLock(lockPath, processId = process.pid) {
+  let existing;
+  try {
+    existing = await fsp4.readFile(lockPath, "utf8");
+  } catch {
+  }
+  if (existing) {
+    try {
+      const lock2 = JSON.parse(existing);
+      try {
+        process.kill(lock2.pid, 0);
+        return false;
+      } catch {
+      }
+    } catch {
+    }
+  }
+  const lock = {
+    pid: processId,
+    hostname: __require("os").hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await atomicWrite(lockPath, JSON.stringify(lock), { mode: 384 });
+  return true;
+}
+async function releaseDirectorStateLock(lockPath) {
+  try {
+    await fsp4.unlink(lockPath);
+  } catch {
+  }
+}
 var DirectorStateCheckpoint = class {
   snapshot;
   filePath;
+  lockPath;
   timer = null;
   debounceMs;
   writing = false;
   rewriteRequested = false;
   constructor(filePath, init, debounceMs = 250) {
     this.filePath = filePath;
+    this.lockPath = `${filePath}.lock`;
     this.debounceMs = debounceMs;
     this.snapshot = {
       version: 1,
@@ -88,10 +126,36 @@ var DirectorStateCheckpoint = class {
       maxSpawns: init.maxSpawns,
       spawnDepth: init.spawnDepth,
       maxSpawnDepth: init.maxSpawnDepth,
+      directorBudget: init.directorBudget,
       subagents: [],
       tasks: []
     };
   }
+  /**
+   * Attempt to acquire the lock for this checkpoint. Call this before
+   * resuming a crashed director run. If it returns false, another
+   * director process is still running this fleet — do not resume.
+   */
+  async acquireLock() {
+    return acquireDirectorStateLock(this.lockPath);
+  }
+  /**
+   * Release the lock on graceful shutdown. Call `flush()` first to ensure
+   * the final checkpoint state is on disk before removing the lock.
+   * Without this, the next resume will see a stale-lock and refuse.
+   */
+  async releaseLock() {
+    return releaseDirectorStateLock(this.lockPath);
+  }
+  /**
+   * Resume from a snapshot previously loaded via `loadDirectorState()`.
+   * Use this when `--resume <runId>` is triggered — the snapshot has
+   * the full fleet state (subagents, tasks) from before the crash; the
+   * checkpoint continues from there.
+   */
+  resume(snapshot) {
+    this.snapshot = snapshot;
+  }
   current() {
     return this.snapshot;
   }
@@ -1567,7 +1631,10 @@ function makeSpawnTool(director, roster) {
         const subagentId = await director.spawn(cfg);
         return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name };
       } catch (err) {
-        if (err instanceof DirectorBudgetError) {
+        if (err instanceof FleetSpawnBudgetError) {
+          return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
+        }
+        if (err instanceof FleetCostCapError) {
           return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
         }
         return { error: err instanceof Error ? err.message : String(err) };
@@ -1707,9 +1774,68 @@ function makeFleetUsageTool(director) {
     }
   };
 }
+function makeFleetSessionTool(director) {
+  return {
+    name: "fleet_session",
+    description: "Read a subagent's JSONL transcript and extract its last assistant text, stop reason, and tool-use count. Use this to see what a running or timed-out subagent actually produced.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        subagentId: { type: "string", description: "Subagent id to read the transcript of." },
+        /** Number of trailing lines to return (last N JSONL lines). Default: all. */
+        tail: { type: "number", description: "Number of trailing JSONL lines to return. Omit for the full transcript." }
+      },
+      required: ["subagentId"]
+    },
+    async execute(input) {
+      const i = input;
+      const result = await director.readSession(i.subagentId, i.tail);
+      if (!result) {
+        return {
+          error: `fleet_session: transcript unavailable for "${i.subagentId}". Is sessionsRoot configured?`
+        };
+      }
+      return result;
+    }
+  };
+}
+function makeFleetHealthTool(director) {
+  return {
+    name: "fleet_health",
+    description: "Per-subagent health report: budget pressure (pct of limits consumed), last activity timestamp, and current status. Use to decide whether to assign more work to a subagent or spawn a fresh one.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      const status = director.status();
+      const snapshot = director.snapshot();
+      const subagents = status.subagents ?? [];
+      const perSubagent = snapshot.perSubagent ?? {};
+      return {
+        subagents: subagents.map((s) => {
+          const usage = perSubagent[s.id];
+          return {
+            id: s.id,
+            status: s.status,
+            lastEventAt: usage?.lastEventAt,
+            // Budget pressure: fraction of each limit consumed if we have it.
+            // BudgetWarning events carry used/limit ratios; surface them here.
+            budgetPressure: {
+              iterations: usage?.iterations,
+              toolCalls: usage?.toolCalls,
+              costUsd: usage?.cost
+            }
+          };
+        })
+      };
+    }
+  };
+}
 
 // src/coordination/director.ts
-var DirectorBudgetError = class extends Error {
+var FleetSpawnBudgetError = class extends Error {
   kind;
   limit;
   observed;
@@ -1717,16 +1843,48 @@ var DirectorBudgetError = class extends Error {
     super(
       kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`
     );
-    this.name = "DirectorBudgetError";
+    this.name = "FleetSpawnBudgetError";
     this.kind = kind;
     this.limit = limit;
     this.observed = observed;
   }
 };
+var FleetCostCapError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(limit, observed) {
+    super(
+      `Director cost cap exceeded: total fleet spend ${observed.toFixed(4)} exceeds maxCostUsd ${limit.toFixed(4)}`
+    );
+    this.name = "FleetCostCapError";
+    this.kind = "max_cost_usd";
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
 var Director = class {
+  /** Alias for the ICoordinator contract. `id` is retained for backward compatibility. */
+  get coordinatorId() {
+    return this.id;
+  }
   id;
+  /**
+   * The fleet event bus. Backed by `fleetManager?.fleet` when a FleetManager
+   * is injected; otherwise own FleetBus instance (preserves existing behavior).
+   */
   fleet;
+  /**
+   * Usage rollup. Backed by `fleetManager?.usage` when a FleetManager is
+   * injected; otherwise own FleetUsageAggregator.
+   */
   usage;
+  /**
+   * Optional fleet-level policy container. When provided the Director
+   * delegates spawn budgeting, manifest entries, and checkpointing to it
+   * instead of managing those internally. All other behavior is unchanged.
+   */
+  fleetManager;
   /**
    * Director-side bridge endpoint. Subagents are wired to the same
    * in-memory transport so the director can `ask()` them synchronously
@@ -1777,6 +1935,14 @@ var Director = class {
   /** Debounce timer for periodic manifest writes. */
   manifestTimer = null;
   manifestDebounceMs;
+  /** Fleet-wide cost cap (entire fleet total, distinct from SubagentBudget limits). Infinity means no cap. */
+  maxFleetCostUsd;
+  /** Max auto-extensions per subagent per budget kind before denying. */
+  maxBudgetExtensions;
+  /** Sessions root for direct subagent JSONL reads (fleet_session tool). */
+  sessionsRoot;
+  /** Director run id for JSONL path resolution. */
+  directorRunId;
   /** Resolves task descriptions back from `assign()` so completion events
    *  can also carry a human-readable title. */
   taskDescriptions = /* @__PURE__ */ new Map();
@@ -1803,12 +1969,18 @@ var Director = class {
     this.spawnDepth = opts.spawnDepth ?? 0;
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
+    this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 2;
+    this.sessionsRoot = opts.sessionsRoot;
+    this.directorRunId = opts.directorRunId ?? this.id;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
       directorRunId: this.id,
       maxSpawns: opts.maxSpawns,
       spawnDepth: this.spawnDepth,
-      maxSpawnDepth: this.maxSpawnDepth
-    }) : null;
+      maxSpawnDepth: this.maxSpawnDepth,
+      directorBudget: opts.directorBudget
+    }, opts.checkpointDebounceMs ?? 250) : null;
+    this.fleetManager = opts.fleetManager;
     if (this.sharedScratchpadPath) {
       void fsp4.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(() => void 0);
     }
@@ -1817,12 +1989,17 @@ var Director = class {
       { agentId: this.id, coordinatorId: this.id },
       this.transport
     );
-    this.fleet = new FleetBus();
-    this.usage = new FleetUsageAggregator(
-      this.fleet,
-      (id) => this.priceLookups.get(id),
-      (id) => this.subagentMeta.get(id)
-    );
+    if (this.fleetManager) {
+      this.fleet = this.fleetManager.fleet;
+      this.usage = this.fleetManager.usage;
+    } else {
+      this.fleet = new FleetBus();
+      this.usage = new FleetUsageAggregator(
+        this.fleet,
+        (id) => this.priceLookups.get(id),
+        (id) => this.subagentMeta.get(id)
+      );
+    }
     this.coordinator = new DefaultMultiAgentCoordinator(
       { ...opts.config, coordinatorId: this.id },
       { runner: opts.runner }
@@ -1869,7 +2046,7 @@ var Director = class {
       const payload = e.payload;
       const guardKey = `${e.subagentId}:${payload.kind}`;
       const prior = extendCounts.get(guardKey) ?? 0;
-      if (prior >= 2) {
+      if (prior >= this.maxBudgetExtensions) {
         payload.deny();
         extendCounts.delete(guardKey);
         return;
@@ -1924,52 +2101,73 @@ var Director = class {
    * it the `cost` column in `usage.snapshot()` stays at 0.
    */
   async spawn(config, priceLookup) {
-    if (this.spawnDepth >= this.maxSpawnDepth) {
-      throw new DirectorBudgetError("max_spawn_depth", this.maxSpawnDepth, this.spawnDepth);
-    }
-    if (this.spawnCount >= this.maxSpawns) {
-      throw new DirectorBudgetError("max_spawns", this.maxSpawns, this.spawnCount + 1);
+    if (this.fleetManager) {
+      const rejection = this.fleetManager.canSpawn(config);
+      if (rejection) {
+        if (rejection.kind === "max_spawn_depth") throw new FleetSpawnBudgetError("max_spawn_depth", rejection.limit, rejection.observed);
+        if (rejection.kind === "max_spawns") throw new FleetSpawnBudgetError("max_spawns", rejection.limit, rejection.observed);
+        if (rejection.kind === "max_cost_usd") throw new FleetCostCapError(rejection.limit, rejection.observed);
+      }
+    } else {
+      if (this.spawnDepth >= this.maxSpawnDepth) {
+        throw new FleetSpawnBudgetError("max_spawn_depth", this.maxSpawnDepth, this.spawnDepth);
+      }
+      if (this.spawnCount >= this.maxSpawns) {
+        throw new FleetSpawnBudgetError("max_spawns", this.maxSpawns, this.spawnCount + 1);
+      }
+      if (this.maxFleetCostUsd < Number.POSITIVE_INFINITY) {
+        const totalCost = this.usage.snapshot().total?.cost ?? 0;
+        if (totalCost >= this.maxFleetCostUsd) {
+          throw new FleetCostCapError(this.maxFleetCostUsd, totalCost);
+        }
+      }
     }
     const result = await this.coordinator.spawn(config);
-    this.spawnCount += 1;
-    this.subagentMeta.set(result.subagentId, {
-      provider: config.provider,
-      model: config.model
-    });
-    if (priceLookup) this.priceLookups.set(result.subagentId, priceLookup);
+    if (this.fleetManager) {
+      this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
+    } else {
+      this.spawnCount += 1;
+      this.subagentMeta.set(result.subagentId, {
+        provider: config.provider,
+        model: config.model
+      });
+      if (priceLookup) this.priceLookups.set(result.subagentId, priceLookup);
+    }
     const subagentBridge = new InMemoryAgentBridge(
       { agentId: result.subagentId, coordinatorId: this.id },
       this.transport
     );
     this.coordinator.setSubagentBridge(result.subagentId, subagentBridge);
     this.subagentBridges.set(result.subagentId, subagentBridge);
-    this.manifestEntries.set(result.subagentId, {
-      subagentId: result.subagentId,
-      name: config.name,
-      role: config.role,
-      provider: config.provider,
-      model: config.model,
-      taskIds: []
-    });
-    const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.stateCheckpoint?.recordSpawn(
-      {
-        id: result.subagentId,
+    if (!this.fleetManager) {
+      this.manifestEntries.set(result.subagentId, {
+        subagentId: result.subagentId,
         name: config.name,
         role: config.role,
         provider: config.provider,
         model: config.model,
-        spawnedAt
-      },
-      this.spawnCount
-    );
-    void this.appendSessionEvent({
-      type: "agent_spawned",
-      ts: spawnedAt,
-      agentId: result.subagentId,
-      role: config.role ?? config.name
-    });
-    this.scheduleManifest();
+        taskIds: []
+      });
+      const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.stateCheckpoint?.recordSpawn(
+        {
+          id: result.subagentId,
+          name: config.name,
+          role: config.role,
+          provider: config.provider,
+          model: config.model,
+          spawnedAt
+        },
+        this.spawnCount
+      );
+      void this.appendSessionEvent({
+        type: "agent_spawned",
+        ts: spawnedAt,
+        agentId: result.subagentId,
+        role: config.role ?? config.name
+      });
+      this.scheduleManifest();
+    }
     return result.subagentId;
   }
   /**
@@ -2109,6 +2307,7 @@ var Director = class {
     if (this.stateCheckpoint) {
       this.stateCheckpoint.setUsage(this.usage.snapshot());
       await this.stateCheckpoint.flush().catch((err) => this.logShutdownError("state_checkpoint_flush", err));
+      await this.stateCheckpoint.releaseLock().catch((err) => this.logShutdownError("state_checkpoint_lock_release", err));
     }
   }
   /**
@@ -2135,8 +2334,12 @@ var Director = class {
   async assign(task) {
     const taskWithId = task.id ? task : { ...task, id: randomUUID() };
     if (task.subagentId) {
-      const entry = this.manifestEntries.get(task.subagentId);
-      if (entry) entry.taskIds.push(taskWithId.id);
+      if (this.fleetManager) {
+        this.fleetManager.addTaskToSubagent(task.subagentId, taskWithId.id);
+      } else {
+        const entry = this.manifestEntries.get(task.subagentId);
+        if (entry) entry.taskIds.push(taskWithId.id);
+      }
     }
     await this.coordinator.assign(taskWithId);
     this.taskDescriptions.set(taskWithId.id, taskWithId.description);
@@ -2212,6 +2415,58 @@ var Director = class {
   completedResults() {
     return Array.from(this.completed.values());
   }
+  /**
+   * Inject a previously-saved checkpoint snapshot. Call this right after
+   * constructing a Director during a `--resume` run so the in-memory state
+   * (subagents, tasks, waiters) reflects the pre-crash reality instead of
+   * starting from a blank slate. The director then resumes from there —
+   * completing any in-flight tasks and ignoring tasks that already reached
+   * a terminal state in the prior run.
+   */
+  setCheckpointState(snapshot) {
+    this.stateCheckpoint?.resume(snapshot);
+  }
+  /**
+   * Read a subagent's JSONL transcript directly from disk (no bridge
+   * round-trip needed). Returns the last assistant text, stop reason,
+   * tool-use count, and line count — or null if the file is unavailable.
+   * Requires `sessionsRoot` to be set on construction.
+   */
+  async readSession(subagentId, tail) {
+    if (!this.sessionsRoot) return null;
+    const filePath = path4.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
+    let raw;
+    try {
+      raw = await fsp4.readFile(filePath, "utf8");
+    } catch {
+      return null;
+    }
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const targetLines = tail ? lines.slice(-tail) : lines;
+    let lastAssistantText;
+    let lastStopReason;
+    let toolUses = 0;
+    for (const line of targetLines) {
+      try {
+        const ev = JSON.parse(line);
+        if (ev.type === "assistant" && typeof ev.text === "string") {
+          lastAssistantText = ev.text;
+        } else if (ev.type === "stop" && ev.stopReason) {
+          lastStopReason = ev.stopReason;
+        } else if (ev.type === "tool_use") {
+          toolUses++;
+        }
+      } catch {
+      }
+    }
+    return {
+      lastAssistantText,
+      lastStopReason,
+      toolUsesObserved: toolUses,
+      events: targetLines.length,
+      path: filePath
+    };
+  }
   snapshot() {
     return this.usage.snapshot();
   }
@@ -2282,18 +2537,37 @@ var Director = class {
    * still permission-checked normally.
    */
   tools(roster) {
+    const effectiveRoster = roster ?? this.roster;
     const t = [
-      makeSpawnTool(this, roster),
+      makeSpawnTool(this, effectiveRoster),
       makeAssignTool(this),
       makeAwaitTasksTool(this),
       makeAskTool(this),
       makeRollUpTool(this),
       makeTerminateTool(this),
       makeFleetStatusTool(this),
-      makeFleetUsageTool(this)
+      makeFleetUsageTool(this),
+      makeFleetSessionTool(this),
+      makeFleetHealthTool(this)
     ];
     return t;
   }
+  /**
+   * Attempt to acquire the checkpoint lock. Must be called before
+   * resuming — if another director process is alive, this returns
+   * false and the caller should not proceed with the resume.
+   */
+  async acquireCheckpointLock() {
+    return this.stateCheckpoint ? this.stateCheckpoint.acquireLock() : true;
+  }
+  /**
+   * Resume from a prior checkpoint snapshot (loaded via
+   * `loadDirectorState()`). Re-attach to the fleet mid-flight so
+   * subsequent spawn/assign calls update the checkpoint normally.
+   */
+  resumeFromCheckpoint(snapshot) {
+    this.stateCheckpoint?.resume(snapshot);
+  }
 };
 function createDelegateTool(opts) {
   const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
@@ -2399,7 +2673,7 @@ function createDelegateTool(opts) {
         if (typeof i.maxToolCalls === "number" && i.maxToolCalls > 0) {
           cfg.maxToolCalls = i.maxToolCalls;
         }
-        const SUBAGENT_TIMEOUT_BUFFER_MS = 3e4;
+        const SUBAGENT_TIMEOUT_BUFFER_MS = opts.subagentTimeoutBufferMs ?? 3e4;
         const desiredSubTimeout = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
         if (!cfg.timeoutMs || cfg.timeoutMs > desiredSubTimeout) {
           cfg.timeoutMs = desiredSubTimeout;
@@ -2451,7 +2725,7 @@ function createDelegateTool(opts) {
           toolCalls: result.toolCalls,
           durationMs: result.durationMs,
           ...partial ? { partial } : {},
-          ...hintForKind(errorKind, retryable, backoffMs) ? { hint: hintForKind(errorKind, retryable, backoffMs) } : {}
+          ...hintForKind(errorKind, retryable, backoffMs, partial) ? { hint: hintForKind(errorKind, retryable, backoffMs, partial) } : {}
         };
       } catch (err) {
         return {
@@ -2471,7 +2745,7 @@ function instantiateRosterConfig2(role, base) {
     id: `${role}-${randomUUID().slice(0, 8)}`
   };
 }
-function hintForKind(kind, retryable, backoffMs) {
+function hintForKind(kind, retryable, backoffMs, partial) {
   if (!kind) return void 0;
   switch (kind) {
     case "provider_rate_limit":
@@ -2487,16 +2761,40 @@ function hintForKind(kind, retryable, backoffMs) {
     case "budget_iterations":
     case "budget_tool_calls":
     case "budget_tokens":
-    case "budget_cost":
-      return "Subagent exhausted its budget. The coordinator may auto-extend; otherwise raise the matching `max*` field (e.g. maxToolCalls: 600) on the next delegate, or split the task.";
-    case "budget_timeout":
-      return "Subagent hit its wall-clock budget. Raise `timeoutMs` on the next delegate or split the task.";
+    case "budget_cost": {
+      const base = "Subagent exhausted its budget. The coordinator may auto-extend; otherwise raise the matching `max*` field (e.g. maxToolCalls: 600) on the next delegate, or split the task.";
+      if (partial?.lastAssistantText) {
+        return `${base}
+
+Partial output produced before budget hit:
+${partial.lastAssistantText}`;
+      }
+      return base;
+    }
+    case "budget_timeout": {
+      const base = "Subagent hit its wall-clock budget. Raise `timeoutMs` on the next delegate or split the task.";
+      if (partial?.lastAssistantText) {
+        return `${base}
+
+Partial output produced before timeout:
+${partial.lastAssistantText}`;
+      }
+      return base;
+    }
     case "aborted_by_parent":
       return "Subagent was aborted (user Ctrl+C, parent unwound, or sibling failure cascade). Not retryable until the abort condition is resolved.";
     case "empty_response":
       return "Subagent ended its turn with no text and no tool calls. Almost always a prompt / config issue \u2014 clarify the task or check the model.";
-    case "tool_failed":
-      return "A tool inside the subagent returned ok:false. Inspect `partial.lastAssistantText` for the agent reasoning, then retry with corrected inputs.";
+    case "tool_failed": {
+      const base = "A tool inside the subagent returned ok:false. Retry with corrected inputs.";
+      if (partial?.lastAssistantText) {
+        return `${base}
+
+Agent reasoning before failure:
+${partial.lastAssistantText}`;
+      }
+      return base;
+    }
     case "bridge_failed":
       return "Parent-child bridge transport failed. This is rare \u2014 restart the session and retry.";
     default:
@@ -3229,6 +3527,205 @@ function makeDirectorSessionFactory(opts) {
   };
 }
 
-export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, BUG_HUNTER_AGENT, BudgetExceededError, BudgetThresholdSignal, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultMultiAgentCoordinator, Director, DirectorBudgetError, FLEET_ROSTER, FleetBus, FleetUsageAggregator, InMemoryAgentBridge, InMemoryBridgeTransport, REFACTOR_PLANNER_AGENT, SECURITY_SCANNER_AGENT, SubagentBudget, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMessage, makeAgentSubagentRunner, makeDirectorSessionFactory, rosterSummaryFromConfigs };
+// src/coordination/null-fleet-bus.ts
+var NULL_FLEET_BUS = new FleetBus();
+var FleetManager = class {
+  /** The fleet-wide event bus. */
+  fleet;
+  /** Usage rollup across all subagents. */
+  usage;
+  manifestPath;
+  sessionsRoot;
+  directorRunId;
+  /** Spawn cap (lifetime total). Infinity means unlimited. */
+  maxSpawns;
+  /** Nesting cap. */
+  maxSpawnDepth;
+  /** This director's depth in a director chain. Root = 0. */
+  spawnDepth;
+  /** Live spawn counter. */
+  spawnCount = 0;
+  stateCheckpoint;
+  sessionWriter;
+  manifestTimer = null;
+  manifestDebounceMs;
+  /** Fleet-wide cost cap. Infinity = no cap. Distinct from SubagentBudget limits,
+   *  which track per-subagent spend — this field caps the entire fleet total. */
+  maxFleetCostUsd;
+  manifestEntries = /* @__PURE__ */ new Map();
+  /** Pending tasks with their descriptions — populated by `addPendingTask`
+   *  and cleared by `removePendingTask`. Replaces the host-side `pending`
+   *  Map so task descriptions live in one place (FleetManager). */
+  pendingTasks = /* @__PURE__ */ new Map();
+  subagentMeta = /* @__PURE__ */ new Map();
+  priceLookups = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.manifestPath = opts.manifestPath;
+    this.sessionsRoot = opts.sessionsRoot;
+    this.directorRunId = opts.directorRunId ?? randomUUID();
+    this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
+    this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
+    this.spawnDepth = opts.spawnDepth ?? 0;
+    this.sessionWriter = opts.sessionWriter ?? null;
+    this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
+    this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(
+      opts.stateCheckpointPath,
+      {
+        directorRunId: this.directorRunId,
+        maxSpawns: opts.maxSpawns,
+        spawnDepth: this.spawnDepth,
+        maxSpawnDepth: this.maxSpawnDepth,
+        directorBudget: opts.directorBudget
+      },
+      opts.checkpointDebounceMs ?? 250
+    ) : null;
+    this.fleet = new FleetBus();
+    this.usage = new FleetUsageAggregator(
+      this.fleet,
+      (id) => this.priceLookups.get(id),
+      (id) => this.subagentMeta.get(id)
+    );
+  }
+  // -----------------------------------------------------------------------
+  // IFleetManager surface
+  // -----------------------------------------------------------------------
+  get fleetBus() {
+    return this.fleet;
+  }
+  snapshot() {
+    return this.usage.snapshot();
+  }
+  getSubagentMeta(id) {
+    return this.subagentMeta.get(id);
+  }
+  /**
+   * Returns null if the spawn is allowed, or an object describing
+   * which cap was exceeded. Does NOT throw — the caller decides
+   * how to surface the rejection.
+   */
+  canSpawn(config) {
+    if (this.spawnDepth >= this.maxSpawnDepth) {
+      return { kind: "max_spawn_depth", limit: this.maxSpawnDepth, observed: this.spawnDepth };
+    }
+    if (this.spawnCount >= this.maxSpawns) {
+      return { kind: "max_spawns", limit: this.maxSpawns, observed: this.spawnCount + 1 };
+    }
+    if (this.maxFleetCostUsd < Number.POSITIVE_INFINITY) {
+      const totalCost = this.usage.snapshot().total?.cost ?? 0;
+      if (totalCost >= this.maxFleetCostUsd) {
+        return { kind: "max_cost_usd", limit: this.maxFleetCostUsd, observed: totalCost };
+      }
+    }
+    return null;
+  }
+  /**
+   * Records a spawn: increments counter, stores metadata, updates state checkpoint,
+   * and schedules a debounced manifest write. Call AFTER the coordinator
+   * has successfully spawned the subagent.
+   *
+   * @param subagentId The subagent's id (from coordinator.spawn result)
+   * @param config The SubagentConfig that was used
+   * @param priceLookup Optional per-subagent pricing data
+   */
+  recordSpawn(subagentId, config, priceLookup) {
+    this.spawnCount += 1;
+    this.subagentMeta.set(subagentId, {
+      provider: config.provider,
+      model: config.model
+    });
+    if (priceLookup) this.priceLookups.set(subagentId, priceLookup);
+    this.manifestEntries.set(subagentId, {
+      subagentId,
+      name: config.name,
+      role: config.role,
+      provider: config.provider,
+      model: config.model,
+      taskIds: []
+    });
+    this.stateCheckpoint?.recordSpawn({
+      id: subagentId,
+      name: config.name,
+      role: config.role,
+      provider: config.provider,
+      model: config.model,
+      spawnedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }, this.spawnCount);
+    void this.appendSessionEvent({
+      type: "agent_spawned",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId: subagentId,
+      role: config.role ?? config.name
+    });
+    this.scheduleManifest();
+  }
+  async writeManifest() {
+    if (!this.manifestPath) return null;
+    const manifest = {
+      version: 1,
+      directorRunId: this.directorRunId,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      children: Array.from(this.manifestEntries.values()).map((entry) => ({
+        id: entry.subagentId,
+        name: entry.name,
+        role: entry.role,
+        provider: entry.provider,
+        model: entry.model,
+        taskIds: entry.taskIds
+      })),
+      usage: this.usage.snapshot()
+    };
+    await fsp4.mkdir(path4.dirname(this.manifestPath), { recursive: true });
+    await fsp4.writeFile(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
+    return this.manifestPath;
+  }
+  /**
+   * Attach task ids to an already-spawned subagent. Called by
+   * `Director.assign()` after the coordinator assigns a task.
+   */
+  addTaskToSubagent(subagentId, taskId) {
+    const entry = this.manifestEntries.get(subagentId);
+    if (entry) entry.taskIds.push(taskId);
+  }
+  /**
+   * Debounced manifest write. Call after any state mutation
+   * (spawn, assign, complete) so a burst collapses into one write.
+   */
+  scheduleManifest() {
+    if (!this.manifestPath || this.manifestDebounceMs <= 0) return;
+    if (this.manifestTimer) return;
+    this.manifestTimer = setTimeout(() => {
+      this.manifestTimer = null;
+      void this.writeManifest().catch(() => void 0);
+    }, this.manifestDebounceMs);
+  }
+  /** Best-effort session event writer. Swallows failures. */
+  async appendSessionEvent(event) {
+    if (!this.sessionWriter) return;
+    try {
+      await this.sessionWriter.append(event);
+    } catch {
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Pending task management — eliminates host-side state duplication
+  // -----------------------------------------------------------------------
+  addPendingTask(taskId, subagentId, description) {
+    this.pendingTasks.set(taskId, { subagentId, description });
+  }
+  removePendingTask(taskId) {
+    this.pendingTasks.delete(taskId);
+  }
+  getFleetStatus() {
+    const pending = Array.from(this.pendingTasks.entries()).map(([taskId, v]) => ({
+      taskId,
+      description: v.description,
+      subagentId: v.subagentId
+    }));
+    return { pending, live: [] };
+  }
+};
+
+export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, BUG_HUNTER_AGENT, BudgetExceededError, BudgetThresholdSignal, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultMultiAgentCoordinator, Director, FLEET_ROSTER, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, InMemoryAgentBridge, InMemoryBridgeTransport, NULL_FLEET_BUS, REFACTOR_PLANNER_AGENT, SECURITY_SCANNER_AGENT, SubagentBudget, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMessage, makeAgentSubagentRunner, makeDirectorSessionFactory, rosterSummaryFromConfigs };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map