@wrongstack/core 0.10.2 → 0.10.3

package/dist/index.js

@@ -56,8 +56,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat8 = await fsp2.stat(targetPath);
-      mode = stat8.mode & 511;
+      const stat9 = await fsp2.stat(targetPath);
+      mode = stat9.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -1302,7 +1302,7 @@ var isColorTty = () => {
   return Boolean(process.stdout?.isTTY);
 };
 var COLOR = isColorTty();
-var wrap = (open3, close) => (s) => COLOR ? `\x1B[${open3}m${s}\x1B[${close}m` : s;
+var wrap = (open5, close) => (s) => COLOR ? `\x1B[${open5}m${s}\x1B[${close}m` : s;
 var color = {
   reset: wrap("0", "0"),
   bold: wrap("1", "22"),
@@ -2879,12 +2879,14 @@ var InMemoryAgentBridge = class {
   timeoutMs;
   /** Guards request() so concurrent calls on the same id can't silently overwrite. */
   inflightGuards = /* @__PURE__ */ new Set();
+  /** Stores the transport unsubscribe function so it can be called on stop(). */
+  _transportUnsubscribe;
   constructor(config, transport) {
     this.agentId = config.agentId;
     this.coordinatorId = config.coordinatorId;
     this.transport = transport;
     this.timeoutMs = config.timeoutMs ?? 3e4;
-    this.transport.subscribe(this.agentId, (msg) => {
+    this._transportUnsubscribe = this.transport.subscribe(this.agentId, (msg) => {
       if (msg.type === "heartbeat") return;
       const pending = this.pendingRequests.get(msg.id);
       if (pending) {
@@ -2959,6 +2961,8 @@ var InMemoryAgentBridge = class {
     this.pendingRequests.clear();
     this.inflightGuards.clear();
     this.subscriptions.clear();
+    this._transportUnsubscribe?.();
+    this._transportUnsubscribe = void 0;
     await this.transport.close(this.agentId);
   }
 };
@@ -3110,13 +3114,13 @@ var DANGEROUS_FOR_SUBAGENTS = [
 function hasDangerousCapabilityForSubagents(toolOrCaps) {
   if (!toolOrCaps) return false;
   const input = toolOrCaps;
-  const caps = Array.isArray(input) ? input : input?.capabilities ?? [];
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
   return caps.some((c) => DANGEROUS_FOR_SUBAGENTS.includes(c));
 }
 function getDangerousCapabilities(toolOrCaps) {
   if (!toolOrCaps) return [];
   const input = toolOrCaps;
-  const caps = Array.isArray(input) ? input : input?.capabilities ?? [];
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
   return caps.filter(
     (c) => DANGEROUS_FOR_SUBAGENTS.includes(c)
   );
@@ -3683,11 +3687,27 @@ var DefaultSessionReader = class {
     const data = await this.store.load(sessionId);
     for (const e of data.events) yield e;
   }
-  async search(q, sessionId) {
+  async search(q, sessionId, sessionQuery) {
     const limit = q.limit ?? 100;
     const matcher = buildMatcher(q);
     const allowedTypes = q.types ? new Set(q.types) : null;
-    const ids = sessionId ? [sessionId] : (await this.store.list(1e3)).map((s) => s.id);
+    let ids;
+    if (sessionId) {
+      ids = [sessionId];
+    } else {
+      const sessions = await this.store.list(1e3);
+      const titleNeedle = sessionQuery?.titleContains?.toLowerCase();
+      const filtered = sessions.filter((s) => {
+        if (sessionQuery?.since && s.startedAt < sessionQuery.since) return false;
+        if (sessionQuery?.until && s.startedAt > sessionQuery.until) return false;
+        if (sessionQuery?.provider && s.provider !== sessionQuery.provider) return false;
+        if (sessionQuery?.model && s.model !== sessionQuery.model) return false;
+        if (sessionQuery?.minTokens !== void 0 && s.tokenTotal < sessionQuery.minTokens) return false;
+        if (titleNeedle && !s.title.toLowerCase().includes(titleNeedle)) return false;
+        return true;
+      });
+      ids = filtered.map((s) => s.id);
+    }
     const hits = [];
     for (const id of ids) {
       let data;
@@ -4643,8 +4663,8 @@ var DefaultSessionStore = class {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat8 = await fsp2.stat(full);
-      const summary = await this.summarize(id, stat8.mtime.toISOString());
+      const stat9 = await fsp2.stat(full);
+      const summary = await this.summarize(id, stat9.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
@@ -9204,8 +9224,9 @@ var SubagentBudget = class _SubagentBudget {
     if (elapsedMs !== void 0) {
       const idle = this.idleMs();
       if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
-        exceeded.push({ kind: "timeout", used: idle, limit: this.limits.idleTimeoutMs });
-      } else if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs) {
+        exceeded.push({ kind: "idle_timeout", used: idle, limit: this.limits.idleTimeoutMs });
+      }
+      if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs) {
         exceeded.push({ kind: "timeout", used: elapsedMs, limit: this.limits.timeoutMs });
       }
     }
@@ -12418,10 +12439,6 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.drainPendingAsAborted("Coordinator stopAll() drained the pending queue");
     await Promise.allSettled([...this.subagents.keys()].map((id) => this.stop(id)));
   }
-  async remove(subagentId) {
-    await this.stop(subagentId);
-    this.subagents.delete(subagentId);
-  }
   /**
    * Get current coordinator stats for monitoring/debugging.
    */
@@ -12687,7 +12704,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
         durationMs: Date.now() - startTime
       };
     } catch (err) {
-      const status = err instanceof BudgetExceededError && err.kind === "timeout" ? "timeout" : subagent.abortController.signal.aborted ? "stopped" : "failed";
+      const status = err instanceof BudgetExceededError && (err.kind === "timeout" || err.kind === "idle_timeout") ? "timeout" : subagent.abortController.signal.aborted ? "stopped" : "failed";
       const usage = budget.usage();
       result = {
         subagentId,
@@ -12841,6 +12858,30 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       });
     }
   }
+  /**
+   * Stop a subagent and remove it from the coordinator. Releases all
+   * associated resources (AbortController, context, budget state).
+   * The subagent entry is deleted so the id can be reused in a future spawn.
+   */
+  async remove(subagentId) {
+    const subagent = this.subagents.get(subagentId);
+    if (!subagent) return;
+    if (subagent.status === "running" || subagent.status === "idle") {
+      this.terminating.add(subagentId);
+      subagent.abortController.abort();
+      subagent.status = "stopped";
+    }
+    this.subagents.delete(subagentId);
+    this.terminating.delete(subagentId);
+    this.pendingTasks = this.pendingTasks.filter((t2) => t2.subagentId !== subagentId);
+    this.fleetBus?.emit({
+      subagentId,
+      ts: Date.now(),
+      type: "subagent.removed",
+      payload: { subagentId }
+    });
+    this.emitCoordinatorStats();
+  }
   isDone() {
     if (this.config.doneCondition.type === "all_tasks_done") {
       return this.pendingTasks.length === 0 && this.inFlight === 0;
@@ -12864,7 +12905,8 @@ function classifySubagentError(err, hints = {}) {
       tool_calls: "budget_tool_calls",
       tokens: "budget_tokens",
       cost: "budget_cost",
-      timeout: "budget_timeout"
+      timeout: "budget_timeout",
+      idle_timeout: "budget_timeout"
     };
     return {
       kind: map[err.kind],
@@ -13626,14 +13668,36 @@ var FleetUsageAggregator = class {
   constructor(bus, priceLookup, metaLookup) {
     this.priceLookup = priceLookup;
     this.metaLookup = metaLookup;
-    bus.filter("provider.response", (e) => this.onProviderResponse(e));
-    bus.filter("tool.executed", (e) => this.onToolExecuted(e));
-    bus.filter("iteration.started", (e) => this.onIterationStarted(e));
+    this.unsub.push(bus.filter("provider.response", (e) => this.onProviderResponse(e)));
+    this.unsub.push(bus.filter("tool.executed", (e) => this.onToolExecuted(e)));
+    this.unsub.push(bus.filter("iteration.started", (e) => this.onIterationStarted(e)));
   }
   priceLookup;
   metaLookup;
   perSubagent = /* @__PURE__ */ new Map();
   total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  unsub = new Array();
+  /**
+   * Remove a terminated subagent's data from the aggregator and subtract its
+   * contribution from the running totals. Call this when a subagent is removed
+   * from the fleet so the aggregator doesn't accumulate unbounded data for
+   * entities that will never emit events again.
+   */
+  removeSubagent(subagentId) {
+    const snap = this.perSubagent.get(subagentId);
+    if (!snap) return;
+    this.perSubagent.delete(subagentId);
+    this.total.input -= snap.input;
+    this.total.output -= snap.output;
+    this.total.cacheRead -= snap.cacheRead;
+    this.total.cacheWrite -= snap.cacheWrite;
+    this.total.cost -= snap.cost;
+  }
+  /** Disposes all fleet-bus subscriptions. Call when the aggregator is no longer needed. */
+  dispose() {
+    for (const off of this.unsub) off();
+    this.unsub.length = 0;
+  }
   /** Live snapshot — safe to call from a tool's execute() body. */
   snapshot() {
     return {
@@ -14386,7 +14450,7 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
         this.cancel(`Director cancelled: ${role} ${payload.kind} threshold`);
         return;
       }
-      if (payload.kind === "timeout") {
+      if (payload.kind === "timeout" || payload.kind === "idle_timeout") {
         const progress = this.progressBySubagent.get(e.subagentId) ?? 0;
         const lastProgress = this.lastTimeoutProgress.get(e.subagentId) ?? -1;
         if (progress <= lastProgress) {
@@ -15124,7 +15188,7 @@ var Director = class {
     if (needsNickname) {
       const role = config.role ?? "subagent";
       if (this.fleetManager) {
-        this.fleetManager.assignNicknameAndRecord("", config, priceLookup);
+        this.fleetManager.assignNicknameAndRecord(config);
       } else {
         config.name = assignNickname(role, this._usedNicknames);
         this._usedNicknames.add(config.name.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-"));
@@ -15132,9 +15196,7 @@ var Director = class {
     }
     result = await this.coordinator.spawn(config);
     if (this.fleetManager) {
-      if (!needsNickname) {
-        this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
-      }
+      this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
     } else {
       this.spawnCount += 1;
       this.subagentMeta.set(result.subagentId, {
@@ -15422,6 +15484,7 @@ var Director = class {
   }
   async remove(subagentId) {
     await this.coordinator.remove(subagentId);
+    this.usage.removeSubagent(subagentId);
   }
   status() {
     const base = this.coordinator.getStatus();
@@ -15757,6 +15820,7 @@ function createDelegateTool(opts) {
             if (timer) clearTimeout(timer);
             offTool();
             offIter();
+            offProgress();
             resolve9(value);
           };
           const arm = () => {
@@ -15768,6 +15832,7 @@ function createDelegateTool(opts) {
           };
           const offTool = dir.fleet.filter("tool.executed", bump);
           const offIter = dir.fleet.filter("iteration.started", bump);
+          const offProgress = dir.fleet.filter("tool.progress", bump);
           arm();
           dir.awaitTasks([taskId]).then((r) => finish(r[0] ?? { __timeout: true })).catch(() => finish({ __timeout: true }));
         });
@@ -15987,7 +16052,8 @@ var FIELD_BY_KIND = {
   tool_calls: "maxToolCalls",
   tokens: "maxTokens",
   cost: "maxCostUsd",
-  timeout: "timeoutMs"
+  timeout: "timeoutMs",
+  idle_timeout: "timeoutMs"
 };
 function attachAutoExtend(events, policy = {}) {
   const factor = policy.factor ?? 0.5;
@@ -16005,7 +16071,7 @@ function attachAutoExtend(events, policy = {}) {
     }),
     events.on("budget.threshold_reached", (e) => {
       const { kind, limit, extend, deny } = e;
-      if (kind === "timeout") {
+      if (kind === "timeout" || kind === "idle_timeout") {
         if (progress > lastTimeoutProgress) {
           lastTimeoutProgress = progress;
           const next2 = Math.min(Math.ceil(limit * (1 + factor)), ceiling.timeoutMs);
@@ -16110,8 +16176,8 @@ async function loadProjectModes(modesDir) {
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path6.join(modesDir, entry);
-      const stat8 = await fsp2.stat(filePath);
-      if (!stat8.isFile()) continue;
+      const stat9 = await fsp2.stat(filePath);
+      if (!stat9.isFile()) continue;
       const content = await fsp2.readFile(filePath, "utf8");
       const id = path6.basename(entry, path6.extname(entry));
       modes.push({
@@ -20040,10 +20106,10 @@ var SkillInstaller = class {
           if (!resolved.startsWith(path6.resolve(destDir))) {
             throw new Error(`Path traversal detected in skill file: ${file}`);
           }
-          const stat8 = await fsp2.stat(srcPath);
-          if (stat8.size > MAX_SKILL_FILE_SIZE) {
+          const stat9 = await fsp2.stat(srcPath);
+          if (stat9.size > MAX_SKILL_FILE_SIZE) {
             throw new Error(
-              `Skill file "${file}" is too large (${(stat8.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
+              `Skill file "${file}" is too large (${(stat9.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
             );
           }
           await fsp2.mkdir(path6.dirname(destPath), { recursive: true });
@@ -20473,6 +20539,8 @@ var ReplayLogStore = class {
   writeChains = /* @__PURE__ */ new Map();
   /** Per-session hash → entry index, kept in memory after the first load. */
   cache = /* @__PURE__ */ new Map();
+  /** Per-session entry count on disk, to detect when compaction is needed. */
+  diskCount = /* @__PURE__ */ new Map();
   maxEntries;
   constructor(opts) {
     this.dir = opts.dir;
@@ -20495,17 +20563,30 @@ var ReplayLogStore = class {
         request: input.request,
         response: input.response
       };
-      let all = [...cache.values(), entry];
-      if (all.length > this.maxEntries) {
-        const evictCount = all.length - this.maxEntries;
-        all = all.slice(evictCount);
-      }
-      await this.writeAll(input.sessionId, all);
-      cache.clear();
-      for (const e of all) cache.set(e.hash, e);
+      cache.set(hash, entry);
+      const count = (this.diskCount.get(input.sessionId) ?? 0) + 1;
+      if (count > this.maxEntries) {
+        await this.compact(input.sessionId, cache);
+      } else {
+        await fsp2.appendFile(this.filePath(input.sessionId), JSON.stringify(entry) + "\n", "utf8");
+        this.diskCount.set(input.sessionId, count);
+      }
     });
     return hash;
   }
+  /**
+   * Compact the replay log to keep only the most recent maxEntries.
+   * Called when entry count exceeds the cap. Rewrites the entire file
+   * but only happens O(n / maxEntries) times per session.
+   */
+  async compact(sessionId, cache) {
+    const all = [...cache.values()];
+    const keep = all.slice(-this.maxEntries);
+    await this.writeAll(sessionId, keep);
+    cache.clear();
+    for (const e of keep) cache.set(e.hash, e);
+    this.diskCount.set(sessionId, keep.length);
+  }
   // ── Reads ───────────────────────────────────────────────────────────────
   /**
    * Look up an entry by hash. Returns `null` when the request has
@@ -20589,6 +20670,7 @@ var ReplayLogStore = class {
     cache = /* @__PURE__ */ new Map();
     for (const e of all) cache.set(e.hash, e);
     this.cache.set(sessionId, cache);
+    this.diskCount.set(sessionId, all.length);
     return cache;
   }
   enqueue(sessionId, fn) {
@@ -20618,14 +20700,50 @@ var SessionRecovery = class {
    */
   async detectStale(sessionId) {
     const fp = this.filePath(sessionId);
-    let raw;
+    const TAIL_SIZE = 8192;
+    let stat9;
     try {
-      raw = await fsp2.readFile(fp, "utf8");
+      stat9 = await fsp2.stat(fp);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
     }
-    return this.parseForStale(sessionId, fp, raw);
+    if (stat9.size === 0) return null;
+    const position = Math.max(0, stat9.size - TAIL_SIZE);
+    const buf = Buffer.alloc(TAIL_SIZE);
+    let fh;
+    try {
+      fh = await fsp2.open(fp, "r");
+      const { bytesRead } = await fh.read(buf, 0, TAIL_SIZE, position);
+      let eventCount = 0;
+      const raw = buf.subarray(0, bytesRead).toString("utf8");
+      for (const line of raw.split("\n")) {
+        if (line.trim()) eventCount++;
+      }
+      const lines = raw.split("\n").filter((l) => l.trim());
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const ev = JSON.parse(lines[i]);
+          if (ev.type === "in_flight_start") {
+            return {
+              sessionId,
+              path: fp,
+              lastEventTs: ev.ts,
+              context: ev.context,
+              eventCount
+            };
+          }
+          return null;
+        } catch {
+          continue;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    } finally {
+      if (fh) await fh.close();
+    }
   }
   /**
    * Generate a recovery plan for a session. The plan describes
@@ -20706,49 +20824,22 @@ var SessionRecovery = class {
     }
     return path6.join(this.dir, `${sessionId}.jsonl`);
   }
-  /**
-   * Stream-parse the last few lines of a JSONL log. We do NOT load
-   * the whole file into memory — for long-running sessions the log
-   * can be megabytes. Instead we read tail-ward and find the last
-   * `in_flight_start` / `in_flight_end` pair.
-   */
-  async parseForStale(sessionId, fp, raw) {
-    const lines = raw.split("\n");
-    let lastEvent = null;
-    let eventCount = 0;
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const ev = JSON.parse(line);
-        lastEvent = ev;
-        eventCount++;
-      } catch {
-      }
-    }
-    if (!lastEvent) return null;
-    if (lastEvent.type === "in_flight_start") {
-      return {
-        sessionId,
-        path: fp,
-        lastEventTs: lastEvent.ts,
-        context: lastEvent.context,
-        eventCount
-      };
-    }
-    return null;
-  }
 };
-
-// src/storage/tool-audit-log.ts
-init_atomic_write();
 var GENESIS_PREV = "0".repeat(64);
+var DEFAULT_FSYNC_EVERY = 100;
 var ToolAuditLog = class {
   dir;
   /** In-memory cache of the last entry's hash (per session), to compute chains efficiently. */
   tailHash = /* @__PURE__ */ new Map();
+  /** In-memory counter for entry indices — avoids re-reading the file on every write. */
+  tailIndex = /* @__PURE__ */ new Map();
+  /** Tracks writes since last fsync, per session. */
+  unSyncedWrites = /* @__PURE__ */ new Map();
   writeChains = /* @__PURE__ */ new Map();
+  fsyncEvery;
   constructor(opts) {
     this.dir = opts.dir;
+    this.fsyncEvery = opts.fsyncEvery ?? DEFAULT_FSYNC_EVERY;
   }
   /**
    * Append a tool call/result pair to the chain. Returns the
@@ -20760,6 +20851,7 @@ var ToolAuditLog = class {
     let entry = null;
     await this.enqueue(input.sessionId, async () => {
       const prevHash = this.tailHash.get(input.sessionId) ?? GENESIS_PREV;
+      const index = this.tailIndex.get(input.sessionId) ?? 0;
       const id = randomUUID();
       const ts = (/* @__PURE__ */ new Date()).toISOString();
       const content = {
@@ -20770,12 +20862,11 @@ var ToolAuditLog = class {
         toolUseId: input.toolUseId,
         input: input.input,
         output: input.output,
-        isError: input.isError
+        isError: input.isError,
+        index
       };
       const hash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
       entry = {
-        index: this.tailHash.has(input.sessionId) ? -1 : 0,
-        // placeholder; recomputed below
         id,
         ts,
         prevHash,
@@ -20784,15 +20875,12 @@ var ToolAuditLog = class {
         toolUseId: input.toolUseId,
         input: input.input,
         output: input.output,
-        isError: input.isError
+        isError: input.isError,
+        index
       };
-      const existing = await this.readAll(input.sessionId);
-      const index = existing.length;
-      const finalContent = { ...content, index };
-      const finalHash = createHash("sha256").update(stableStringify2(finalContent), "utf8").digest("hex");
-      entry = { ...entry, index, hash: finalHash };
       await this.appendLine(input.sessionId, entry);
-      this.tailHash.set(input.sessionId, finalHash);
+      this.tailHash.set(input.sessionId, hash);
+      this.tailIndex.set(input.sessionId, index + 1);
     });
     return entry;
   }
@@ -20874,9 +20962,34 @@ var ToolAuditLog = class {
   }
   async appendLine(sessionId, entry) {
     const fp = this.filePath(sessionId);
-    const existing = await this.readAll(sessionId);
-    const all = [...existing, entry];
-    await atomicWrite(fp, all.map((e) => JSON.stringify(e)).join("\n") + (all.length ? "\n" : ""));
+    const line = JSON.stringify(entry) + "\n";
+    await fsp2.appendFile(fp, line, "utf8");
+    const count = (this.unSyncedWrites.get(sessionId) ?? 0) + 1;
+    this.unSyncedWrites.set(sessionId, count);
+    if (this.fsyncEvery !== Infinity && count % this.fsyncEvery === 0) {
+      await this.sync(sessionId, fp);
+    }
+  }
+  /**
+   * Explicitly sync the file to disk. Called automatically every
+   * `fsyncEvery` writes, and available for callers who want to
+   * force a sync before closing or during graceful shutdown.
+   */
+  async flush(sessionId) {
+    await this.sync(sessionId, this.filePath(sessionId));
+  }
+  async sync(sessionId, fp) {
+    try {
+      const fh = await fsp2.open(fp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    } finally {
+      this.unSyncedWrites.set(sessionId, 0);
+    }
   }
   enqueue(sessionId, fn) {
     const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
@@ -21353,8 +21466,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat8 = await fsp2.stat(localPath);
-        if (stat8.isDirectory()) {
+        const stat9 = await fsp2.stat(localPath);
+        if (stat9.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp2.readFile(file, "utf8");
@@ -21379,8 +21492,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat8 = await fsp2.stat(localPath);
-        if (stat8.isDirectory()) {
+        const stat9 = await fsp2.stat(localPath);
+        if (stat9.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp2.readFile(file);
@@ -23434,14 +23547,18 @@ var FleetManager = class {
    * Call this INSTEAD of `recordSpawn` when you want automatic nicknames.
    * The nickname is written back to `config.name` BEFORE the coordinator
    * sees the config, so the manifest, logs, and fleet UI all show it.
+   *
+   * NOTE: This method ONLY assigns the nickname and marks it used.
+   * The caller MUST call `recordSpawn(subagentId, config, priceLookup)` AFTER
+   * `coordinator.spawn()` returns with the real subagentId. This is because
+   * the subagentId is not known until after the coordinator creates the subagent.
    */
-  assignNicknameAndRecord(subagentId, config, priceLookup) {
+  assignNicknameAndRecord(config) {
     const role = config.role ?? "subagent";
     const nickname = assignNickname(role, this._usedNicknames);
     const baseKey = nickname.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-");
     this._usedNicknames.add(baseKey);
     config.name = nickname;
-    this.recordSpawn(subagentId, config, priceLookup);
     return nickname;
   }
   /**
@@ -23619,6 +23736,14 @@ var FleetManager = class {
     }));
     return { pending, live: [] };
   }
+  /** Release all resources: clear the manifest debounce timer and dispose the usage aggregator. */
+  dispose() {
+    if (this.manifestTimer) {
+      clearTimeout(this.manifestTimer);
+      this.manifestTimer = null;
+    }
+    this.usage.dispose();
+  }
 };
 function createMcpControlTool(opts) {
   const { getConfig, configPath, registry } = opts;
@@ -25311,8 +25436,8 @@ var DefaultSystemPromptBuilder = class {
       return "";
     }
     if (!Array.isArray(parsed.items) || parsed.items.length === 0) return "";
-    const open3 = parsed.items.filter((i) => i?.status !== "done");
-    if (open3.length === 0) return "";
+    const open5 = parsed.items.filter((i) => i?.status !== "done");
+    if (open5.length === 0) return "";
     const lines = ["## Active plan"];
     if (parsed.title) lines.push(`*${parsed.title}*`, "");
     parsed.items.forEach((it, idx) => {
@@ -25528,8 +25653,8 @@ ${mem}`);
   }
   async dirExists(p) {
     try {
-      const stat8 = await fsp2.stat(p);
-      return stat8.isDirectory();
+      const stat9 = await fsp2.stat(p);
+      return stat9.isDirectory();
     } catch {
       return false;
     }