@wrongstack/core 0.5.6 → 0.6.0

package/dist/{agent-bridge-B07AYFBk.d.ts → agent-bridge-BKNiE1VH.d.ts}

@@ -1,4 +1,4 @@
-import { B as BridgeTransport, l as BridgeMessage, A as AgentBridge, m as AgentBridgeConfig } from './multi-agent-Cv8wk47i.js';
+import { B as BridgeTransport, l as BridgeMessage, A as AgentBridge, m as AgentBridgeConfig } from './multi-agent-Cpp7FXUl.js';
 
 /**
  * In-memory pub/sub transport for agent-to-agent messaging.

package/dist/{compactor-BWhJXxsW.d.ts → compactor-RIPuTtWK.d.ts}

@@ -1,4 +1,4 @@
-import { a2 as Context } from './context-CLZXPPYk.js';
+import { a2 as Context } from './context-CDRyrkKQ.js';
 
 interface CompactRepairReport {
     removedToolUses: string[];

package/dist/{config-BgM0BIpz.d.ts → config-BGGuP_Ar.d.ts}

@@ -1,5 +1,5 @@
 import { W as WireFamily } from './models-registry-Y2xbog0E.js';
-import { P as Permission } from './context-CLZXPPYk.js';
+import { P as Permission } from './context-CDRyrkKQ.js';
 
 type ContextWindowModeId = 'balanced' | 'frugal' | 'deep' | 'archival';
 type ContextWindowAggressiveOn = 'hard' | 'soft' | 'warn';

package/dist/{context-CLZXPPYk.d.ts → context-CDRyrkKQ.d.ts}

@@ -887,6 +887,13 @@ interface RunOptions {
     model?: string;
     executionStrategy?: 'parallel' | 'sequential' | 'smart';
     maxIterations?: number;
+    /**
+     * Enable autonomous continue for this specific run. When true, the agent
+     * loop re-runs on `[continue]`/`[next step]`/`[proceed]` markers or
+     * `continue_to_next_iteration()` tool calls instead of returning.
+     * Overrides `AgentInit.autonomousContinue` for this call only.
+     */
+    autonomousContinue?: boolean;
 }
 interface ContextInit {
     systemPrompt: TextBlock[];

package/dist/coordination/index.d.ts

@@ -1,14 +1,14 @@
-export { A as ALL_FLEET_AGENTS, a as AUDIT_LOG_AGENT, b as AgentFactory, c as AgentFactoryResult, d as AgentRunnerOptions, B as BUG_HUNTER_AGENT, C as CreateDelegateToolOptions, D as DEFAULT_DIRECTOR_PREAMBLE, e as DEFAULT_SUBAGENT_BASELINE, f as DefaultMultiAgentCoordinator, g as DelegateHost, h as Director, i as DirectorBudgetError, G as DirectorCostCapError, j as DirectorPromptParts, k as DirectorSessionFactory, l as DirectorSessionFactoryOptions, F as FLEET_ROSTER, n as FleetBus, o as FleetEvent, p as FleetHandler, q as FleetUsage, r as FleetUsageAggregator, M as MultiAgentCoordinatorOptions, R as REFACTOR_PLANNER_AGENT, S as SECURITY_SCANNER_AGENT, s as SubagentPromptParts, t as SubagentUsageSnapshot, v as composeDirectorPrompt, w as composeSubagentPrompt, x as createDelegateTool, y as makeAgentSubagentRunner, z as makeDirectorSessionFactory, E as rosterSummaryFromConfigs } from '../index-BDnUCRvL.js';
-export { n as BudgetExceededError, o as BudgetKind, p as BudgetLimits, s as BudgetThresholdDecision, t as BudgetThresholdHandler, u as BudgetThresholdSignal, q as BudgetUsage, r as SubagentBudget } from '../multi-agent-Cv8wk47i.js';
-export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-B07AYFBk.js';
+export { A as ALL_FLEET_AGENTS, a as AUDIT_LOG_AGENT, b as AgentFactory, c as AgentFactoryResult, d as AgentRunnerOptions, B as BUG_HUNTER_AGENT, C as CreateDelegateToolOptions, D as DEFAULT_DIRECTOR_PREAMBLE, e as DEFAULT_SUBAGENT_BASELINE, f as DefaultMultiAgentCoordinator, g as DelegateHost, h as Director, i as DirectorPromptParts, j as DirectorSessionFactory, k as DirectorSessionFactoryOptions, F as FLEET_ROSTER, m as FleetBus, K as FleetCostCapError, n as FleetEvent, o as FleetHandler, p as FleetManager, q as FleetManagerOptions, r as FleetSpawnBudgetError, s as FleetUsage, t as FleetUsageAggregator, I as ICoordinator, u as IFleetManager, M as MultiAgentCoordinatorOptions, N as NULL_FLEET_BUS, R as REFACTOR_PLANNER_AGENT, S as SECURITY_SCANNER_AGENT, v as SubagentPromptParts, w as SubagentUsageSnapshot, y as composeDirectorPrompt, z as composeSubagentPrompt, E as createDelegateTool, G as makeAgentSubagentRunner, H as makeDirectorSessionFactory, J as rosterSummaryFromConfigs } from '../index-DkdRz6yK.js';
+export { n as BudgetExceededError, o as BudgetKind, p as BudgetLimits, s as BudgetThresholdDecision, t as BudgetThresholdHandler, u as BudgetThresholdSignal, q as BudgetUsage, r as SubagentBudget } from '../multi-agent-Cpp7FXUl.js';
+export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-BKNiE1VH.js';
 import '../director-state-BmYi3DGA.js';
-import '../context-CLZXPPYk.js';
-import '../events-qnDZbrtb.js';
+import '../context-CDRyrkKQ.js';
+import '../events-DPQKFX7W.js';
 import 'node:events';
-import '../index-DPLJw_ZI.js';
+import '../index-B0qTujQW.js';
 import '../logger-BMQgxvdy.js';
-import '../system-prompt-DI4Dtc1I.js';
+import '../system-prompt-Dl2QY1_B.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-BhJTNr9v.js';
-import '../config-BgM0BIpz.js';
+import '../secret-scrubber-CfMdAJ_l.js';
+import '../config-BGGuP_Ar.js';
 import '../models-registry-Y2xbog0E.js';

package/dist/coordination/index.js

@@ -73,8 +73,6 @@ async function renameWithRetry(from, to) {
   }
   throw lastErr;
 }
-
-// src/storage/director-state.ts
 async function acquireDirectorStateLock(lockPath, processId = process.pid) {
   let existing;
   try {
@@ -1631,10 +1629,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 DirectorCostCapError) {
+        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) };
@@ -1835,7 +1833,7 @@ function makeFleetHealthTool(director) {
 }
 
 // src/coordination/director.ts
-var DirectorBudgetError = class extends Error {
+var FleetSpawnBudgetError = class extends Error {
   kind;
   limit;
   observed;
@@ -1843,13 +1841,13 @@ 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 DirectorCostCapError = class extends Error {
+var FleetCostCapError = class extends Error {
   kind;
   limit;
   observed;
@@ -1857,16 +1855,34 @@ var DirectorCostCapError = class extends Error {
     super(
       `Director cost cap exceeded: total fleet spend ${observed.toFixed(4)} exceeds maxCostUsd ${limit.toFixed(4)}`
     );
-    this.name = "DirectorCostCapError";
+    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
@@ -1917,8 +1933,8 @@ var Director = class {
   /** Debounce timer for periodic manifest writes. */
   manifestTimer = null;
   manifestDebounceMs;
-  /** Fleet-wide cost cap. Infinity means no cap. */
-  maxCostUsd;
+  /** 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). */
@@ -1951,7 +1967,7 @@ var Director = class {
     this.spawnDepth = opts.spawnDepth ?? 0;
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
-    this.maxCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
     this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 2;
     this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? this.id;
@@ -1962,20 +1978,28 @@ var Director = class {
       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);
+      void fsp4.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(
+        (err) => this.logShutdownError("shared_scratchpad_mkdir", err)
+      );
     }
     this.transport = new InMemoryBridgeTransport();
     this.bridge = new InMemoryAgentBridge(
       { agentId: this.id, coordinatorId: this.id },
       this.transport
     );
-    this.fleet = new FleetBus();
-    this.usage = new FleetUsageAggregator(
-      this.fleet,
-      (id) => this.priceLookups.get(id),
-      (id) => this.subagentMeta.get(id)
-    );
+    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 }
@@ -2064,7 +2088,9 @@ var Director = class {
     if (this.manifestTimer) return;
     this.manifestTimer = setTimeout(() => {
       this.manifestTimer = null;
-      void this.writeManifest().catch(() => void 0);
+      void this.writeManifest().catch(
+        (err) => this.logShutdownError("manifest_write_debounced", err)
+      );
     }, this.manifestDebounceMs);
   }
   /**
@@ -2077,58 +2103,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.maxCostUsd < Number.POSITIVE_INFINITY) {
-      const totalCost = this.usage.snapshot().total?.cost ?? 0;
-      if (totalCost >= this.maxCostUsd) {
-        throw new DirectorCostCapError(this.maxCostUsd, totalCost);
+    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;
   }
   /**
@@ -2240,7 +2281,7 @@ var Director = class {
       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 });
+    await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
   /**
@@ -2295,8 +2336,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);
@@ -2494,8 +2539,9 @@ 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),
@@ -2764,9 +2810,11 @@ async function readSubagentPartial(opts, subagentId) {
     candidates.push(path4.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
   } else {
     try {
-      const runDirs = await fsp4.readdir(opts.sessionsRoot);
-      for (const r of runDirs) {
-        candidates.push(path4.join(opts.sessionsRoot, r, `${subagentId}.jsonl`));
+      const entries = await fsp4.readdir(opts.sessionsRoot, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          candidates.push(path4.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
+        }
       }
     } catch {
       return void 0;
@@ -3072,19 +3120,25 @@ var DefaultSessionStore = class {
         { cause: err }
       );
     }
-    const writer = new FileSessionWriter(
-      id,
-      handle,
-      (/* @__PURE__ */ new Date()).toISOString(),
-      {
+    try {
+      const writer = new FileSessionWriter(
         id,
-        model: data.metadata.model,
-        provider: data.metadata.provider
-      },
-      this.events,
-      { resumed: true, dir: this.dir, filePath: file }
-    );
-    return { writer, data };
+        handle,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        {
+          id,
+          model: data.metadata.model,
+          provider: data.metadata.provider
+        },
+        this.events,
+        { resumed: true, dir: this.dir, filePath: file }
+      );
+      return { writer, data };
+    } catch (err) {
+      await handle.close().catch(() => {
+      });
+      throw err;
+    }
   }
   async load(id) {
     const file = path4.join(this.dir, `${id}.jsonl`);
@@ -3130,7 +3184,7 @@ var DefaultSessionStore = class {
       const full = path4.join(this.dir, `${id}.jsonl`);
       const stat3 = await fsp4.stat(full);
       const summary = await this.summarize(id, stat3.mtime.toISOString());
-      await fsp4.writeFile(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
+      await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
           err instanceof Error ? err.message : String(err)
@@ -3358,7 +3412,7 @@ var FileSessionWriter = class {
     this.closed = true;
     if (this.manifestFile) {
       try {
-        await fsp4.writeFile(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
+        await atomicWrite(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
       } catch {
       }
     }
@@ -3483,6 +3537,211 @@ function makeDirectorSessionFactory(opts) {
   };
 }
 
-export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, BUG_HUNTER_AGENT, BudgetExceededError, BudgetThresholdSignal, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultMultiAgentCoordinator, Director, DirectorBudgetError, DirectorCostCapError, 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 atomicWrite(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((err) => {
+        const detail = err instanceof Error ? err.message : String(err);
+        process.emitWarning(
+          `FleetManager manifest write failed: ${detail}`,
+          "FleetManagerWarning"
+        );
+      });
+    }, 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