@wrongstack/core 0.280.1 → 0.281.1

package/dist/coordination/index.js

@@ -371,6 +371,27 @@ function safeParse(input, maxBytes = 5e6) {
     };
   }
 }
+function safeStringify(value, pretty = false) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const replacer = (_k, v) => {
+    if (typeof v === "bigint") return v.toString();
+    if (v instanceof Error) {
+      return { name: v.name, message: v.message, stack: v.stack };
+    }
+    if (typeof v === "object" && v !== null) {
+      if (seen.has(v)) return "[Circular]";
+      seen.add(v);
+    }
+    return v;
+  };
+  try {
+    return JSON.stringify(value, replacer, pretty ? 2 : void 0) ?? "null";
+  } catch (err) {
+    return JSON.stringify({
+      __serialization_error: toErrorMessage(err)
+    });
+  }
+}
 function sessionScopedPath(dir, sessionId, suffix) {
   if (!sessionId || sessionId.includes("\\") || sessionId.includes("..")) {
     throw invalid(sessionId);
@@ -1385,20 +1406,32 @@ var TOOLS = {
   /** Web research. */
   research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
 };
+var promptCache = /* @__PURE__ */ new Map();
+var candidateCache = /* @__PURE__ */ new Map();
 function agentPrompt(id) {
+  const envDir = process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"] ?? "";
+  const cacheKey = `${envDir}\0${id}`;
+  const cached = promptCache.get(cacheKey);
+  if (cached !== void 0) return cached;
   const fileName = `${id}.md`;
-  for (const dir of agentPromptDirCandidates()) {
+  let resolved = "";
+  for (const dir of agentPromptDirCandidates(envDir)) {
     try {
-      return readFileSync(path9.join(dir, fileName), "utf8").trimEnd();
+      resolved = readFileSync(path9.join(dir, fileName), "utf8").trimEnd();
+      break;
     } catch {
     }
   }
-  return "";
+  promptCache.set(cacheKey, resolved);
+  return resolved;
 }
-function agentPromptDirCandidates() {
-  const here = path9.dirname(fileURLToPath(import.meta.url));
-  const explicitDir = process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"];
+function agentPromptDirCandidates(envDir) {
   const globalRoot = process.env["WRONGSTACK_HOME"] || path9.join(os.homedir(), ".wrongstack");
+  const candKey = `${envDir}\0${globalRoot}`;
+  const cached = candidateCache.get(candKey);
+  if (cached !== void 0) return cached;
+  const here = path9.dirname(fileURLToPath(import.meta.url));
+  const explicitDir = envDir || void 0;
   const candidates = [
     ...explicitDir ? [path9.resolve(explicitDir)] : [],
     path9.join(globalRoot, "instructions", "agents"),
@@ -1408,7 +1441,9 @@ function agentPromptDirCandidates() {
     path9.resolve(here, "../instructions/agents"),
     path9.resolve(here, "instructions/agents")
   ];
-  return candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+  const ordered = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+  candidateCache.set(candKey, ordered);
+  return ordered;
 }
 function isDirectory(candidate) {
   try {
@@ -4670,14 +4705,21 @@ var DirectorStateCheckpoint = class {
     }
   }
 };
+var textCache = /* @__PURE__ */ new Map();
+var rootCandidates;
 function readBundledInstructionText(relativePath) {
+  const cached = textCache.get(relativePath);
+  if (cached !== void 0) return cached;
+  let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      return readFileSync(path9.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync(path9.join(root, relativePath), "utf8").trimEnd();
+      break;
     } catch {
     }
   }
-  return "";
+  textCache.set(relativePath, resolved);
+  return resolved;
 }
 function renderInstructionTemplate(template, values) {
   return template.replace(
@@ -4686,13 +4728,15 @@ function renderInstructionTemplate(template, values) {
   );
 }
 function instructionRootCandidates() {
+  if (rootCandidates !== void 0) return rootCandidates;
   const here = path9.dirname(fileURLToPath(import.meta.url));
   const candidates = [
     path9.resolve(here, "../../instructions"),
     path9.resolve(here, "../instructions"),
     path9.resolve(here, "instructions")
   ];
-  return candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
+  rootCandidates = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
+  return rootCandidates;
 }
 function isDirectory2(candidate) {
   try {
@@ -5012,13 +5056,31 @@ function makeAssignTool(director) {
 function makeAwaitTasksTool(director) {
   return {
     name: "await_tasks",
-    description: "Block until every named task completes. Returns the array of TaskResult.",
+    description: 'Wait for assigned tasks. mode:"all" (default) blocks until EVERY named task completes and returns all results. mode:"any" returns as soon as AT LEAST ONE completes \u2014 use it for independent tasks so you can handle each finisher immediately (reassign work, spawn helpers) instead of idling on the slowest; call again with the returned `pending` ids to pick up the next finisher.',
     permission: "auto",
     mutating: false,
     capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
-    inputSchema: { type: "object", properties: { taskIds: { type: "array", items: { type: "string" }, description: "One or more task ids returned by `assign_task`." } }, required: ["taskIds"] },
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskIds: { type: "array", items: { type: "string" }, description: "One or more task ids returned by `assign_task`." },
+        mode: { type: "string", enum: ["all", "any"], description: '"all" (default): block until every task completes. "any": return on the first completion with the rest listed as pending.' },
+        timeoutMs: { type: "number", minimum: 1, description: 'mode:"any" only \u2014 return {timedOut:true, completed:[]} if nothing completes within this window instead of blocking.' }
+      },
+      required: ["taskIds"]
+    },
     async execute(input) {
       const i = input;
+      if (i.mode === "any") {
+        const r = await director.awaitTasksAny(i.taskIds, i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : void 0);
+        return {
+          mode: "any",
+          completed: r.completed,
+          pending: r.pending,
+          ...r.timedOut ? { timedOut: true } : {},
+          ...r.pending.length > 0 ? { hint: 'Handle the completed results now. Re-call await_tasks with the pending ids (mode:"any") for the next finisher \u2014 or assign new work to the now-idle subagent first.' } : {}
+        };
+      }
       const results = await director.awaitTasks(i.taskIds);
       return { results };
     }
@@ -6104,6 +6166,30 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   results() {
     return this.completedResults;
   }
+  /** Defensive snapshot of the still-queued (not yet dispatched) tasks. */
+  listPendingTasks() {
+    return this.pendingTasks.map((t) => ({ ...t }));
+  }
+  /**
+   * Re-pin a still-PENDING task to a different subagent (`undefined` =
+   * unpin, any idle worker may take it), then try to dispatch. Returns
+   * `false` when the task is not in the pending queue — already
+   * dispatched, completed, or unknown. Running tasks can never be pulled;
+   * they can only be steered or terminated. The mutation is synchronous
+   * (same tick as the check), so it cannot race a concurrent dispatch:
+   * `tryDispatchNext` runs on this same call stack or a later one.
+   *
+   * The task keeps its id, so waiters, the report-back notifier, and
+   * checkpoint bookkeeping resolve unchanged when it eventually completes.
+   */
+  retargetPendingTask(taskId, subagentId) {
+    const task = this.pendingTasks.find((t) => t.id === taskId);
+    if (!task) return false;
+    if (subagentId !== void 0 && !this.subagents.has(subagentId)) return false;
+    task.subagentId = subagentId;
+    this.tryDispatchNext();
+    return true;
+  }
   /**
    * Wait for one or more tasks to complete and return their results.
    * If a task is already done when called, returns immediately.
@@ -6131,6 +6217,43 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       })
     );
   }
+  /**
+   * Wait until AT LEAST ONE of the named tasks completes. Returns every
+   * requested result already available at that moment (drain-what's-done)
+   * plus the ids still outstanding, so callers can loop "handle finishers,
+   * re-await the remainder" instead of blocking on the whole batch.
+   *
+   * Unlike `awaitTasks`, this never rejects and deliberately does NOT
+   * inherit `config.timeoutMs` — a "return whatever is done" call has no
+   * business timing out unless the caller asks for a window explicitly.
+   */
+  async awaitTasksAny(taskIds, opts) {
+    const ids = new Set(taskIds);
+    const completed = this.completedResults.filter((r) => ids.has(r.taskId));
+    if (completed.length > 0 || ids.size === 0) {
+      const done = new Set(completed.map((r) => r.taskId));
+      return { completed, pending: taskIds.filter((id) => !done.has(id)) };
+    }
+    return new Promise((resolve6) => {
+      let timer;
+      const handler = ({ result }) => {
+        if (!ids.has(result.taskId)) return;
+        if (timer) clearTimeout(timer);
+        this.off("task.completed", handler);
+        resolve6({
+          completed: [result],
+          pending: taskIds.filter((id) => id !== result.taskId)
+        });
+      };
+      if (opts?.timeoutMs !== void 0) {
+        timer = setTimeout(() => {
+          this.off("task.completed", handler);
+          resolve6({ completed: [], pending: [...taskIds], timedOut: true });
+        }, opts.timeoutMs);
+      }
+      this.on("task.completed", handler);
+    });
+  }
   /**
    * Manual completion — for callers that drive subagents without a runner
    * (e.g. external orchestrators). When a runner is configured the coordinator
@@ -6755,6 +6878,13 @@ var Director = class _Director {
    *  coordinator emits `task.completed` for a given task id. Each entry
    *  is created lazily on first poll/await and cleared once consumed. */
   taskWaiters = /* @__PURE__ */ new Map();
+  /** First-completion waiters registered by `awaitTasksAny`. Kept separate
+   *  from `taskWaiters` on purpose: a `taskWaiters` entry marks a result as
+   *  "will be delivered in-band" and suppresses the fire-and-forget
+   *  report-back — but an any-await only consumes ONE of its ids, so the
+   *  losers must stay eligible for the mailbox notifier. Entries carry an
+   *  optional timeout timer so `shutdown()` can clear them. */
+  anyWaiters = /* @__PURE__ */ new Set();
   /** Cache of completed results in case the consumer asks AFTER the
    *  coordinator already fired the event — `awaitTasks(['t-1'])` after
    *  t-1 finished should resolve immediately, not hang. */
@@ -6776,6 +6906,8 @@ var Director = class _Director {
   roster;
   directorPreamble;
   subagentBaseline;
+  /** See {@link DirectorOptions.taskResultNotifier}. */
+  taskResultNotifier;
   /** Absolute path to the fleet's shared scratchpad directory, or null
    *  when none was configured. Exposed as a readonly getter for callers
    *  that need to surface the path to the user (e.g. the CLI logging
@@ -6873,6 +7005,7 @@ var Director = class _Director {
     this.roster = opts.roster;
     this.directorPreamble = opts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
     this.subagentBaseline = opts.subagentBaseline ?? DEFAULT_SUBAGENT_BASELINE;
+    this.taskResultNotifier = opts.taskResultNotifier;
     this.sharedScratchpadPath = opts.sharedScratchpadPath ?? null;
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
@@ -6945,8 +7078,38 @@ var Director = class _Director {
         waiter.resolve(r);
         this.taskWaiters.delete(r.taskId);
       }
+      let anyConsumed = false;
+      for (const aw of [...this.anyWaiters]) {
+        if (!aw.ids.has(r.taskId)) continue;
+        if (aw.timer) clearTimeout(aw.timer);
+        this.anyWaiters.delete(aw);
+        aw.resolve(r);
+        anyConsumed = true;
+      }
+      const consumedInBand = !!waiter || anyConsumed;
       if (internalTask) return;
       const title = this.taskDescriptions.get(r.taskId) ?? payload.task.description ?? r.taskId;
+      if (!consumedInBand && this.taskResultNotifier) {
+        const resultText = typeof r.result === "string" ? r.result : r.result !== void 0 ? safeStringify(r.result) : void 0;
+        try {
+          void Promise.resolve(
+            this.taskResultNotifier({
+              taskId: r.taskId,
+              title,
+              status: r.status,
+              subagentId: r.subagentId,
+              subagentName: this.manifestEntries.get(r.subagentId)?.name,
+              resultText,
+              errorText: r.error ? `${r.error.kind}: ${r.error.message}` : void 0,
+              iterations: r.iterations,
+              toolCalls: r.toolCalls,
+              durationMs: r.durationMs
+            })
+          ).catch(() => {
+          });
+        } catch {
+        }
+      }
       const failed = r.status !== "success";
       const errorString = r.error ? `${r.error.kind}: ${r.error.message}` : void 0;
       this.stateCheckpoint?.recordTaskStatus(r.taskId, {
@@ -7532,6 +7695,10 @@ var Director = class _Director {
       this.coordinator.off("task.completed", this.taskCompletedListener);
       this.taskCompletedListener = null;
     }
+    for (const aw of this.anyWaiters) {
+      if (aw.timer) clearTimeout(aw.timer);
+    }
+    this.anyWaiters.clear();
     if (this.toolExecFilter) {
       this.toolExecFilter();
       this.toolExecFilter = null;
@@ -7600,6 +7767,12 @@ var Director = class _Director {
         waiter.resolve(synthetic);
         this.taskWaiters.delete(taskWithId.id);
       }
+      for (const aw of [...this.anyWaiters]) {
+        if (!aw.ids.has(taskWithId.id)) continue;
+        if (aw.timer) clearTimeout(aw.timer);
+        this.anyWaiters.delete(aw);
+        aw.resolve(synthetic);
+      }
       return taskWithId.id;
     }
     if (task.subagentId) {
@@ -7670,6 +7843,85 @@ var Director = class _Director {
       })
     );
   }
+  /**
+   * Wait until AT LEAST ONE of the named tasks completes, then return every
+   * requested result already cached plus the still-pending ids. This is the
+   * leader's "handle whichever finishes next" primitive — unlike
+   * `awaitTasks` it never blocks on the slowest sibling, and the siblings
+   * that complete later still reach the leader through the fire-and-forget
+   * report-back (see the consumed-in-band rule in `taskCompletedListener`).
+   *
+   * Deliberately does NOT register `taskWaiters` entries for the pending
+   * ids: a `taskWaiters` entry would mark those results as in-band-consumed
+   * and silence the mailbox notifier for results this caller never receives.
+   *
+   * With `timeoutMs`, resolves (never rejects) `{timedOut: true}` and zero
+   * completions when the window elapses first.
+   */
+  awaitTasksAny(taskIds, opts) {
+    const completed = taskIds.map((id) => this.completed.get(id)).filter((r) => r !== void 0);
+    if (completed.length > 0 || taskIds.length === 0) {
+      const done = new Set(completed.map((r) => r.taskId));
+      return Promise.resolve({
+        completed,
+        pending: taskIds.filter((id) => !done.has(id))
+      });
+    }
+    return new Promise((resolve6) => {
+      const entry = {
+        ids: new Set(taskIds),
+        resolve: (r) => resolve6({
+          completed: [r],
+          pending: taskIds.filter((id) => id !== r.taskId)
+        })
+      };
+      if (opts?.timeoutMs !== void 0) {
+        entry.timer = setTimeout(() => {
+          this.anyWaiters.delete(entry);
+          resolve6({ completed: [], pending: [...taskIds], timedOut: true });
+        }, opts.timeoutMs);
+      }
+      this.anyWaiters.add(entry);
+    });
+  }
+  /** Defensive snapshot of tasks still queued (not yet dispatched). */
+  listPendingTasks() {
+    return this.coordinator.listPendingTasks();
+  }
+  /**
+   * Re-pin a still-pending task to a different subagent (`undefined` =
+   * unpin) — the rebalancing primitive used by the FleetSupervisor and
+   * available to hosts. Only queued tasks can move; a dispatched task
+   * returns `false` (steer or terminate its worker instead). Keeps
+   * ownership bookkeeping (taskOwners, checkpoint, fleet manifest) in
+   * sync with the coordinator's queue.
+   */
+  retargetPendingTask(taskId, subagentId) {
+    const ok = this.coordinator.retargetPendingTask(taskId, subagentId);
+    if (!ok) return false;
+    if (subagentId) {
+      this.taskOwners.set(taskId, subagentId);
+      if (this.fleetManager) {
+        this.fleetManager.addTaskToSubagent(subagentId, taskId);
+      } else {
+        const entry = this.manifestEntries.get(subagentId);
+        if (entry && !entry.taskIds.includes(taskId)) entry.taskIds.push(taskId);
+      }
+    } else {
+      this.taskOwners.delete(taskId);
+    }
+    const description = this.taskDescriptions.get(taskId) ?? taskId;
+    this.fleetManager?.addPendingTask(taskId, subagentId ?? "", description);
+    this.stateCheckpoint?.recordTaskAssigned({
+      taskId,
+      subagentId,
+      description,
+      status: "running",
+      assignedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.scheduleManifest();
+    return true;
+  }
   async terminate(subagentId) {
     await this.coordinator.stop(subagentId);
   }
@@ -8595,6 +8847,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   dir;
   events;
   secretScrubber;
+  isSessionInUse;
   /**
    * In-memory cache for load() results, keyed by session ID. The cache is
    * invalidated when the file's mtimeMs or size changes (indicating the
@@ -8614,6 +8867,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this.dir = opts.dir;
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
+    this.isSessionInUse = opts.isSessionInUse;
   }
   /**
    * Clear the load() cache. Useful for testing or when the caller knows
@@ -9505,19 +9759,74 @@ var DefaultSessionStore = class _DefaultSessionStore {
     });
     await this.writeTombstone(id);
   }
+  /**
+   * Read the session id currently marked active in `active.json`, or `null`
+   * when the lock is absent/unreadable. Shared by {@link delete} and
+   * {@link prune} to avoid clobbering a session a live process is writing to.
+   */
+  async readActiveSessionId() {
+    try {
+      const raw = await fsp7.readFile(path9.join(this.dir, "active.json"), "utf8");
+      const active = JSON.parse(raw);
+      return active.sessionId ?? null;
+    } catch {
+      return null;
+    }
+  }
   async delete(id) {
+    const activeId = await this.readActiveSessionId();
+    if (activeId && id === activeId) {
+      throw new Error(
+        `Session ${id} is currently active in this project and cannot be deleted. Resume or start another session first.`
+      );
+    }
+    if (this.isSessionInUse) {
+      const reason = await this.isSessionInUse(id);
+      if (reason) {
+        throw new Error(`Session ${id} is in use (${reason}) and cannot be deleted.`);
+      }
+    }
     await this.deleteSession(id);
   }
+  async rename(id, name) {
+    const trimmed = name.trim();
+    const manifest = this.sessionPath(id, ".summary.json");
+    const jsonlPath = this.sessionPath(id, ".jsonl");
+    try {
+      await fsp7.stat(jsonlPath);
+    } catch (err) {
+      const code = err?.code;
+      if (code === "ENOENT") {
+        throw new Error(`Session not found: ${id}`);
+      }
+      throw err;
+    }
+    const summary = await this.summaryFor(id);
+    const { name: _drop, ...rest } = summary;
+    const updated = trimmed ? { ...rest, name: trimmed } : rest;
+    const t0 = Date.now();
+    let outcome = "success";
+    let errorMsg;
+    try {
+      await atomicWrite(manifest, JSON.stringify(updated), { mode: 384 });
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = toErrorMessage(err);
+      this.emitError(id, manifest, "rename", errorMsg, false);
+      throw err;
+    } finally {
+      this.emitWrite(id, manifest, "close", outcome, Date.now() - t0, void 0, errorMsg);
+    }
+    await this.appendToIndex(updated);
+    this.invalidateShardManifestBySessionId(id);
+    this._indexCache = null;
+    this.clearLoadCache(id);
+    return updated;
+  }
   async prune(maxAgeDays = 30) {
     const cutoff = Date.now() - maxAgeDays * 864e5;
     let deleted = 0;
-    let activeSessionId = null;
-    try {
-      const raw = await fsp7.readFile(path9.join(this.dir, "active.json"), "utf8");
-      const active = JSON.parse(raw);
-      activeSessionId = active.sessionId ?? null;
-    } catch {
-    }
+    const activeSessionId = await this.readActiveSessionId();
     const isPrunableJsonl = (name) => name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path9.join(dir, name);
@@ -11317,6 +11626,651 @@ function makeMailInboxTool(opts = {}) {
     }
   };
 }
+
+// src/coordination/fleet-status-tool.ts
+var TASK_SNIPPET_CHARS = 120;
+function snippet(s) {
+  if (!s) return void 0;
+  return s.length > TASK_SNIPPET_CHARS ? `${s.slice(0, TASK_SNIPPET_CHARS)}\u2026` : s;
+}
+function makeFleetStatusTool(opts = {}) {
+  const resolveMailbox = opts.resolveMailbox ?? ((ctx) => new GlobalMailbox(opts.projectDir ?? defaultResolveProjectDir(ctx), opts.events));
+  return {
+    name: "fleet_status",
+    description: "Live snapshot of every agent working on this project (this process AND other terminals/TUIs/WebUIs): who is online, what task each is on, which tool is running, and progress counters. Check it before starting work that might overlap with a peer, when deciding whether to wait for someone or proceed, or when a task mentions another agent. Read-only. To talk to a peer, use mail_send with the returned id.",
+    usageHint: "fleet_status  (optionally: onlineOnly=false to include recently-offline agents)",
+    category: "Coordination",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        onlineOnly: {
+          type: "boolean",
+          description: "Only agents with a live heartbeat (default true)."
+        }
+      }
+    },
+    async execute(input, ctx) {
+      const i = input ?? {};
+      const onlineOnly = i.onlineOnly ?? true;
+      const mb = resolveMailbox(ctx);
+      const identity = resolveMailboxIdentity(ctx);
+      try {
+        await mb.registerAgent({
+          agentId: identity.callerId,
+          sessionId: identity.sessionId,
+          name: identity.name,
+          role: identity.role,
+          pid: process.pid,
+          source: ctx.meta["source"] ?? "cli"
+        });
+        await mb.heartbeat({ agentId: identity.callerId });
+      } catch {
+      }
+      const statuses = await mb.getAgentStatuses().catch(() => []);
+      const local = /* @__PURE__ */ new Map();
+      try {
+        for (const e of opts.getLocalAgents?.() ?? []) local.set(e.name, e);
+      } catch {
+      }
+      const rows = statuses.filter((s) => onlineOnly ? s.online : true).map((s) => {
+        const rich = local.get(s.name);
+        return {
+          id: s.agentId,
+          name: s.name,
+          role: s.role,
+          you: s.agentId === identity.callerId,
+          status: s.status,
+          online: s.online,
+          currentTask: snippet(s.currentTask),
+          currentTool: rich?.currentTool ?? s.currentTool,
+          iterations: rich?.iterations ?? s.iterations,
+          toolCalls: rich?.toolCalls ?? s.toolCalls,
+          lastSeenAt: s.lastSeenAt,
+          ...rich?.ctxPct !== void 0 ? { ctxPct: rich.ctxPct } : {},
+          ...rich?.costUsd !== void 0 ? { costUsd: rich.costUsd } : {}
+        };
+      });
+      const peers = rows.filter((r) => !r.you);
+      return {
+        ok: true,
+        you: identity.callerId,
+        onlineCount: rows.filter((r) => r.online).length,
+        agents: rows,
+        summary: peers.length === 0 ? "No other agents are active on this project right now." : `${peers.length} peer agent(s): ${peers.map((p) => `${p.name} (${p.status}${p.currentTask ? ` \u2014 ${p.currentTask}` : ""})`).join("; ")}`
+      };
+    }
+  };
+}
+var COLLAB_ID_PREFIXES = ["bug-hunter-", "refactor-planner-", "critic-"];
+var DEFAULTS = {
+  intervalMs: 2e4,
+  cooldownMs: 12e4,
+  maxInterventionsPerSubagent: 3,
+  pinnedWaitMs: 6e4,
+  overloadPinnedThreshold: 2,
+  backlogFactor: 2,
+  stuckMs: 18e4,
+  failureStreak: 2
+};
+var HISTORY_MAX = 100;
+var FleetSupervisor = class {
+  constructor(opts) {
+    this.opts = opts;
+    const c = opts.config ?? {};
+    this.cfg = {
+      enabled: c.enabled !== false,
+      intervalMs: c.intervalMs ?? DEFAULTS.intervalMs,
+      cooldownMs: c.cooldownMs ?? DEFAULTS.cooldownMs,
+      maxInterventionsPerSubagent: c.maxInterventionsPerSubagent ?? DEFAULTS.maxInterventionsPerSubagent,
+      pinnedWaitMs: c.pinnedWaitMs ?? DEFAULTS.pinnedWaitMs,
+      overloadPinnedThreshold: c.overloadPinnedThreshold ?? DEFAULTS.overloadPinnedThreshold,
+      backlogFactor: c.backlogFactor ?? DEFAULTS.backlogFactor,
+      stuckMs: c.stuckMs ?? DEFAULTS.stuckMs,
+      failureStreak: c.failureStreak ?? DEFAULTS.failureStreak,
+      allowSpawn: c.allowSpawn !== false,
+      allowTerminate: c.allowTerminate === true
+    };
+    this.now = opts.now ?? Date.now;
+  }
+  opts;
+  cfg;
+  now;
+  timer = null;
+  offHandles = [];
+  engaging = false;
+  stopped = false;
+  // ── observation state ─────────────────────────────────────────────────
+  /** taskId → first tick timestamp we saw it pending. */
+  pendingSince = /* @__PURE__ */ new Map();
+  /** subagentId → last tool.executed timestamp (fleet-wide activity map). */
+  lastActivityAt = /* @__PURE__ */ new Map();
+  /** subagentId → consecutive non-success completions. */
+  failStreaks = /* @__PURE__ */ new Map();
+  /** Consecutive ticks the backlog condition held. */
+  backlogTicks = 0;
+  // ── rate-limit state ──────────────────────────────────────────────────
+  /** `${kind}|${subject}` → last engagement ts. */
+  lastEngagedAt = /* @__PURE__ */ new Map();
+  interventionsBySubagent = /* @__PURE__ */ new Map();
+  /** Tasks already retargeted once — never bounced twice. */
+  retargetedTasks = /* @__PURE__ */ new Set();
+  log = [];
+  /** Idempotent; also re-arms after a stop() so `/supervisor on` works. */
+  start() {
+    if (!this.cfg.enabled || this.timer) return;
+    this.stopped = false;
+    this.offHandles.push(
+      this.opts.fleet.filter("tool.executed", (e) => {
+        this.lastActivityAt.set(e.subagentId, this.now());
+      })
+    );
+    this.offHandles.push(
+      this.opts.events.on("subagent.task_completed", (e) => {
+        if (this.isCollab(e.subagentId)) return;
+        if (e.status === "success") {
+          this.failStreaks.delete(e.subagentId);
+        } else {
+          this.failStreaks.set(e.subagentId, (this.failStreaks.get(e.subagentId) ?? 0) + 1);
+        }
+        this.scheduleNudge();
+      })
+    );
+    this.timer = setInterval(() => {
+      void this.evaluate();
+    }, this.cfg.intervalMs);
+    this.timer.unref?.();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (this.nudgeTimer) clearTimeout(this.nudgeTimer);
+    this.nudgeTimer = null;
+    for (const off of this.offHandles.splice(0)) off();
+  }
+  history() {
+    return this.log;
+  }
+  /** True while the evaluation loop is armed. */
+  isRunning() {
+    return this.timer !== null;
+  }
+  /** Resolved (defaulted) configuration — for status surfaces. */
+  configSnapshot() {
+    return { ...this.cfg };
+  }
+  nudgeTimer = null;
+  scheduleNudge() {
+    if (this.nudgeTimer || this.stopped || !this.cfg.enabled) return;
+    this.nudgeTimer = setTimeout(() => {
+      this.nudgeTimer = null;
+      void this.evaluate();
+    }, 5e3);
+    this.nudgeTimer.unref?.();
+  }
+  isCollab(subagentId) {
+    return COLLAB_ID_PREFIXES.some((p) => subagentId.startsWith(p));
+  }
+  /** One evaluation pass. Public for tests; production runs it on the tick. */
+  async evaluate() {
+    if (this.stopped || !this.cfg.enabled || this.engaging) return;
+    if (this.opts.source.isWorkComplete()) return;
+    const now = this.now();
+    const subagents = this.opts.source.subagents().filter((s) => !this.isCollab(s.id));
+    const pending = this.opts.source.listPendingTasks().filter((t) => !t.subagentId || !this.isCollab(t.subagentId));
+    const pendingIds = new Set(pending.map((t) => t.id));
+    for (const id of this.pendingSince.keys()) {
+      if (!pendingIds.has(id)) this.pendingSince.delete(id);
+    }
+    for (const t of pending) {
+      if (!this.pendingSince.has(t.id)) this.pendingSince.set(t.id, now);
+    }
+    const idle = subagents.filter((s) => s.status === "idle");
+    const running = subagents.filter((s) => s.status === "running");
+    const live = idle.length + running.length;
+    for (const [subagentId, streak] of this.failStreaks) {
+      if (streak >= this.cfg.failureStreak) {
+        this.failStreaks.delete(subagentId);
+        await this.engageFailureStreak(subagentId, streak);
+        return;
+      }
+    }
+    if (idle.length > 0) {
+      const runningIds = new Set(running.map((s) => s.id));
+      const pinnedByWorker = /* @__PURE__ */ new Map();
+      for (const t of pending) {
+        if (!t.subagentId || this.retargetedTasks.has(t.id)) continue;
+        if (!runningIds.has(t.subagentId)) continue;
+        const list = pinnedByWorker.get(t.subagentId) ?? [];
+        list.push(t);
+        pinnedByWorker.set(t.subagentId, list);
+      }
+      for (const [workerId, tasks] of pinnedByWorker) {
+        const overloaded = tasks.length >= this.cfg.overloadPinnedThreshold;
+        const starved = tasks.filter(
+          (t) => now - (this.pendingSince.get(t.id) ?? now) >= this.cfg.pinnedWaitMs
+        );
+        if (overloaded || starved.length > 0) {
+          const movable = overloaded ? tasks.slice(1) : starved;
+          if (movable.length > 0) {
+            await this.engageRebalance(
+              overloaded ? "overloaded_worker" : "pinned_starvation",
+              workerId,
+              movable,
+              idle.map((s) => s.id)
+            );
+            return;
+          }
+        }
+      }
+    }
+    const backlogged = live > 0 && pending.length > this.cfg.backlogFactor * live;
+    this.backlogTicks = backlogged ? this.backlogTicks + 1 : 0;
+    if (backlogged && this.backlogTicks >= 2 && this.cfg.allowSpawn) {
+      this.backlogTicks = 0;
+      await this.engageBacklog(pending.length, live);
+      return;
+    }
+    for (const s of running) {
+      const lastSeen = this.lastActivityAt.get(s.id);
+      if (lastSeen !== void 0 && now - lastSeen >= this.cfg.stuckMs) {
+        this.lastActivityAt.set(s.id, now);
+        await this.engageStuck(s);
+        return;
+      }
+    }
+    if (idle.length > 0 && pending.length > 0) {
+      const oldest = Math.min(...pending.map((t) => this.pendingSince.get(t.id) ?? now));
+      if (now - oldest >= this.cfg.pinnedWaitMs) {
+        await this.engageIdleWithWork(idle.length, pending.length);
+      }
+    }
+  }
+  // ── engagements ────────────────────────────────────────────────────────
+  cooldownOk(kind, subject) {
+    const key = `${kind}|${subject}`;
+    const last = this.lastEngagedAt.get(key) ?? 0;
+    if (this.now() - last < this.cfg.cooldownMs) return false;
+    this.lastEngagedAt.set(key, this.now());
+    return true;
+  }
+  interventionBudgetOk(subagentId) {
+    return (this.interventionsBySubagent.get(subagentId) ?? 0) < this.cfg.maxInterventionsPerSubagent;
+  }
+  recordIntervention(subagentId) {
+    this.interventionsBySubagent.set(
+      subagentId,
+      (this.interventionsBySubagent.get(subagentId) ?? 0) + 1
+    );
+  }
+  emitSignal(kind, detail, subagentId, taskId) {
+    this.opts.events.emit("fleet.supervisor.signal", {
+      sessionId: this.opts.sessionId?.(),
+      kind,
+      subagentId,
+      taskId,
+      detail
+    });
+  }
+  record(entry) {
+    this.log.push({ at: this.now(), ...entry });
+    if (this.log.length > HISTORY_MAX) this.log.splice(0, this.log.length - HISTORY_MAX);
+    this.opts.events.emit("fleet.supervisor.decision", {
+      sessionId: this.opts.sessionId?.(),
+      kind: entry.kind,
+      proposedAction: entry.proposedAction,
+      via: "brain",
+      outcome: entry.outcome === "error" ? "skipped" : entry.outcome,
+      rationale: entry.detail
+    });
+  }
+  emitAction(action, ok, detail, subagentId, taskId) {
+    this.opts.events.emit("fleet.supervisor.action", {
+      sessionId: this.opts.sessionId?.(),
+      action,
+      subagentId,
+      taskId,
+      ok,
+      detail
+    });
+  }
+  /**
+   * Ask the brain to approve a proposal. Same contract as BrainMonitor:
+   * `source:'system'`, the rule's proposal `recommended:true`, fallback
+   * 'ask_human' (routes to the LLM tier under the risk ceiling before any
+   * human). Returns the chosen option id, or null for deny/escalate.
+   */
+  async decide(question, context, options, risk) {
+    const request = {
+      id: `fleetsup-${randomUUID()}`,
+      sessionId: this.opts.sessionId?.(),
+      source: "system",
+      question,
+      context,
+      options,
+      risk,
+      fallback: "ask_human"
+    };
+    const decision = await this.opts.brain.decide(request);
+    if (decision.type !== "answer") return { choice: null, decision };
+    const choice = decision.optionId ?? options.find((o) => o.recommended)?.id ?? null;
+    return { choice, decision };
+  }
+  async engageRebalance(kind, fromWorkerId, tasks, idleWorkerIds) {
+    if (!this.cooldownOk(kind, fromWorkerId) || !this.interventionBudgetOk(fromWorkerId)) return;
+    this.engaging = true;
+    try {
+      const taskList = tasks.map((t) => `- ${t.id}: ${t.description.slice(0, 80)}`).join("\n");
+      this.emitSignal(
+        kind,
+        `${tasks.length} pending task(s) pinned to busy worker ${fromWorkerId} while ${idleWorkerIds.length} worker(s) idle`,
+        fromWorkerId,
+        tasks[0]?.id
+      );
+      const { choice, decision } = await this.decide(
+        `Worker ${fromWorkerId} is busy with ${tasks.length} more task(s) queued behind it while ${idleWorkerIds.length} sibling worker(s) sit idle. Rebalance the queued tasks to the idle workers?`,
+        `Queued behind ${fromWorkerId}:
+${taskList}
+Idle workers: ${idleWorkerIds.join(", ")}`,
+        [
+          {
+            id: "rebalance",
+            label: "Move the queued task(s) to idle worker(s)",
+            consequence: "Only unstarted tasks move; the running task is untouched.",
+            risk: "low",
+            recommended: true
+          },
+          { id: "wait", label: "Leave the queue as is", risk: "low" }
+        ],
+        "low"
+      );
+      if (choice !== "rebalance") {
+        this.record({
+          kind,
+          subagentId: fromWorkerId,
+          proposedAction: "retarget",
+          outcome: decision.type === "answer" ? "denied" : "escalated",
+          detail: decision.type === "answer" ? decision.rationale ?? decision.text : decision.type
+        });
+        return;
+      }
+      this.recordIntervention(fromWorkerId);
+      const moved = [];
+      for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        const target = idleWorkerIds[i % idleWorkerIds.length];
+        if (!task || !target) continue;
+        const ok = await this.opts.actions.retargetPendingTask(task.id, target);
+        this.emitAction("retarget", ok, `\u2192 ${target}`, fromWorkerId, task.id);
+        if (ok) {
+          this.retargetedTasks.add(task.id);
+          moved.push(`${task.id} \u2192 ${target}`);
+        }
+      }
+      this.record({
+        kind,
+        subagentId: fromWorkerId,
+        taskId: tasks[0]?.id,
+        proposedAction: "retarget",
+        outcome: "approved",
+        detail: moved.length > 0 ? `moved ${moved.join(", ")}` : "nothing movable (already dispatched)"
+      });
+      if (moved.length > 0) {
+        await this.opts.actions.steerAgent(
+          fromWorkerId,
+          "Workload reduced by fleet supervisor",
+          `The fleet supervisor moved ${moved.length} of your queued task(s) to idle workers: ${moved.join(
+            ", "
+          )}. Do not start them \u2014 focus on your current task.`
+        ).catch(() => {
+        });
+        await this.opts.actions.notifyLeader(
+          "Fleet rebalanced",
+          `Supervisor moved ${moved.length} queued task(s) off busy worker ${fromWorkerId}: ${moved.join(", ")}.`
+        ).catch(() => {
+        });
+      }
+    } catch {
+    } finally {
+      this.engaging = false;
+    }
+  }
+  async engageBacklog(pendingCount, liveWorkers) {
+    if (!this.cooldownOk("backlog", "fleet")) return;
+    this.engaging = true;
+    try {
+      this.emitSignal(
+        "backlog",
+        `${pendingCount} pending tasks vs ${liveWorkers} live worker(s)`
+      );
+      const { choice, decision } = await this.decide(
+        `The task queue is deep: ${pendingCount} pending tasks for ${liveWorkers} live worker(s). Spawn one additional helper worker to drain it?`,
+        `Pending: ${pendingCount}, live workers: ${liveWorkers}, factor threshold: ${this.cfg.backlogFactor}x`,
+        [
+          {
+            id: "spawn",
+            label: "Spawn one helper worker",
+            consequence: "One more subagent joins the fleet and takes queued work.",
+            risk: "medium",
+            recommended: true
+          },
+          { id: "wait", label: "Let the current fleet drain the queue", risk: "low" }
+        ],
+        "medium"
+      );
+      if (choice !== "spawn") {
+        this.record({
+          kind: "backlog",
+          proposedAction: "spawn_helper",
+          outcome: decision.type === "answer" ? "denied" : "escalated",
+          detail: decision.type === "answer" ? decision.rationale ?? decision.text : decision.type
+        });
+        return;
+      }
+      const res = await this.opts.actions.spawnHelper({
+        reason: `queue backlog: ${pendingCount} pending / ${liveWorkers} workers`
+      });
+      if ("subagentId" in res) {
+        this.emitAction("spawn_helper", true, res.subagentId, res.subagentId);
+        this.record({
+          kind: "backlog",
+          subagentId: res.subagentId,
+          proposedAction: "spawn_helper",
+          outcome: "approved",
+          detail: `spawned ${res.subagentId}`
+        });
+        await this.opts.actions.notifyLeader(
+          "Fleet helper spawned",
+          `Supervisor spawned helper ${res.subagentId} to drain a ${pendingCount}-task backlog.`
+        ).catch(() => {
+        });
+      } else {
+        this.emitAction("spawn_helper", false, res.error);
+        this.record({
+          kind: "backlog",
+          proposedAction: "spawn_helper",
+          outcome: "error",
+          detail: res.error
+        });
+        await this.opts.actions.notifyLeader(
+          "Fleet backlog needs attention",
+          `Queue is ${pendingCount} deep for ${liveWorkers} worker(s); supervisor could not spawn a helper (${res.error}). Consider rebalancing or finishing tasks before assigning more.`
+        ).catch(() => {
+        });
+      }
+    } catch {
+    } finally {
+      this.engaging = false;
+    }
+  }
+  async engageStuck(s) {
+    if (!this.cooldownOk("stuck_agent", s.id) || !this.interventionBudgetOk(s.id)) return;
+    this.engaging = true;
+    try {
+      this.emitSignal(
+        "stuck_agent",
+        `no tool activity for \u2265${Math.round(this.cfg.stuckMs / 1e3)}s`,
+        s.id
+      );
+      const { choice, decision } = await this.decide(
+        `Worker ${s.name} (${s.id}) is marked running but produced no tool activity for over ${Math.round(this.cfg.stuckMs / 1e3)}s. Nudge it with a steer message?`,
+        `Current task: ${s.currentTask ?? "unknown"}`,
+        [
+          {
+            id: "steer",
+            label: "Send a corrective steer to the worker",
+            consequence: "A steer mail is injected before its next step.",
+            risk: "low",
+            recommended: true
+          },
+          { id: "wait", label: "Give it more time", risk: "low" }
+        ],
+        "medium"
+      );
+      if (choice !== "steer") {
+        this.record({
+          kind: "stuck_agent",
+          subagentId: s.id,
+          proposedAction: "steer",
+          outcome: decision.type === "answer" ? "denied" : "escalated",
+          detail: decision.type === "answer" ? decision.rationale ?? decision.text : decision.type
+        });
+        return;
+      }
+      this.recordIntervention(s.id);
+      await this.opts.actions.steerAgent(
+        s.id,
+        "Progress check from fleet supervisor",
+        `You appear stalled (no tool activity for ${Math.round(this.cfg.stuckMs / 1e3)}s on: ${s.currentTask ?? "your current task"}). If you are blocked, say so via mail_send to the leader and either narrow the scope or hand the task back \u2014 do not keep silently retrying the same step.`
+      );
+      this.emitAction("steer", true, "stuck nudge", s.id);
+      await this.opts.actions.notifyLeader(
+        `Worker ${s.name} may be stuck`,
+        `No tool activity for ${Math.round(this.cfg.stuckMs / 1e3)}s. Supervisor nudged it; consider terminate_subagent + reassigning if it stays silent.`
+      ).catch(() => {
+      });
+      this.record({
+        kind: "stuck_agent",
+        subagentId: s.id,
+        proposedAction: "steer",
+        outcome: "approved",
+        detail: "steered + leader notified"
+      });
+    } catch {
+    } finally {
+      this.engaging = false;
+    }
+  }
+  async engageFailureStreak(subagentId, streak) {
+    if (!this.cooldownOk("failure_streak", subagentId) || !this.interventionBudgetOk(subagentId)) {
+      return;
+    }
+    this.engaging = true;
+    try {
+      this.emitSignal("failure_streak", `${streak} consecutive failed/timeout tasks`, subagentId);
+      const options = [
+        {
+          id: "steer",
+          label: "Steer the worker to change approach",
+          risk: "low",
+          recommended: true
+        },
+        { id: "observe", label: "Keep observing", risk: "low" }
+      ];
+      if (this.cfg.allowTerminate) {
+        options.push({
+          id: "terminate",
+          label: "Terminate the worker",
+          consequence: "Its current task fails; pending pinned tasks need reassignment.",
+          risk: "high"
+        });
+      }
+      const { choice, decision } = await this.decide(
+        `Worker ${subagentId} produced ${streak} consecutive failed/timed-out tasks. Intervene?`,
+        `Consecutive failures: ${streak}`,
+        options,
+        "high"
+      );
+      if (choice === "terminate" && this.cfg.allowTerminate) {
+        this.recordIntervention(subagentId);
+        await this.opts.actions.terminate(subagentId);
+        this.emitAction("terminate", true, `${streak} consecutive failures`, subagentId);
+        await this.opts.actions.notifyLeader(
+          `Worker ${subagentId} terminated`,
+          `Supervisor terminated ${subagentId} after ${streak} consecutive failures. Reassign its pending work.`
+        ).catch(() => {
+        });
+        this.record({
+          kind: "failure_streak",
+          subagentId,
+          proposedAction: "terminate",
+          outcome: "approved",
+          detail: `terminated after ${streak} failures`
+        });
+        return;
+      }
+      if (choice === "steer") {
+        this.recordIntervention(subagentId);
+        await this.opts.actions.steerAgent(
+          subagentId,
+          "Change of approach required",
+          `Your last ${streak} tasks failed. Stop, re-read the task, and take a different approach \u2014 if the task itself is impossible or under-specified, report that to the leader via mail_send instead of retrying.`
+        );
+        this.emitAction("steer", true, "failure streak", subagentId);
+        await this.opts.actions.notifyLeader(
+          `Worker ${subagentId} failing repeatedly`,
+          `${streak} consecutive failures. Supervisor steered it; consider reassigning its work if the next task also fails.`
+        ).catch(() => {
+        });
+        this.record({
+          kind: "failure_streak",
+          subagentId,
+          proposedAction: "steer",
+          outcome: "approved",
+          detail: `steered after ${streak} failures`
+        });
+        return;
+      }
+      this.record({
+        kind: "failure_streak",
+        subagentId,
+        proposedAction: this.cfg.allowTerminate ? "steer|terminate" : "steer",
+        outcome: decision.type === "answer" ? "denied" : "escalated",
+        detail: decision.type === "answer" ? decision.rationale ?? decision.text : decision.type
+      });
+    } catch {
+    } finally {
+      this.engaging = false;
+    }
+  }
+  async engageIdleWithWork(idleCount, pendingCount) {
+    if (!this.cooldownOk("idle_with_work", "fleet")) return;
+    this.engaging = true;
+    try {
+      this.emitSignal(
+        "idle_with_work",
+        `${idleCount} idle worker(s) while ${pendingCount} task(s) cannot dispatch`
+      );
+      await this.opts.actions.notifyLeader(
+        "Idle workers with undispatchable tasks",
+        `${idleCount} worker(s) idle while ${pendingCount} task(s) stay pending (likely pinned to stopped/errored workers). Reassign them with assign_task or let the supervisor retarget by unpinning.`
+      );
+      this.emitAction("notify_leader", true, "idle_with_work");
+      this.record({
+        kind: "idle_with_work",
+        proposedAction: "notify_leader",
+        outcome: "approved",
+        detail: `${idleCount} idle / ${pendingCount} pending`
+      });
+    } catch {
+    } finally {
+      this.engaging = false;
+    }
+  }
+};
 var MAILBOX_FILE2 = "_mailbox.jsonl";
 var LINE_SEPARATOR2 = "\n";
 var MESSAGE_CACHE_MAX_ENTRIES2 = 1e4;
@@ -12041,7 +12995,8 @@ function detectEcosystem(manifestPath) {
   if (name === "package.json") return "npm";
   if (name === "go.mod") return "go";
   if (name === "cargo.toml") return "cargo";
-  if (name === "pyproject.toml" || name === "requirements.txt" || name === "pipfile" || name === "pipfile.lock") return "pip";
+  if (name === "pyproject.toml" || name === "requirements.txt" || name === "pipfile" || name === "pipfile.lock")
+    return "pip";
   if (name === "gemfile" || name === "gemfile.lock") return "gem";
   if (name === "composer.json" || name === "composer.lock") return "composer";
   if (name.endsWith(".csproj") || name === "packages.config") return "nuget";
@@ -12050,7 +13005,7 @@ function detectEcosystem(manifestPath) {
   if (name === "pubspec.yaml" || name === "pubspec.lock") return "dart";
   if (name === "vcpkg.json") return "vcpkg";
   if (name === "conanfile.txt" || name === "conanfile.py") return "conan";
-  if (name === "cmakeLists.txt") return "cmake";
+  if (name === "cmakelists.txt") return "cmake";
   return "unknown";
 }
 async function recordPackageAction(opts, entry) {
@@ -12081,9 +13036,7 @@ async function getPackageAuthor(opts, manifestPath, packageName) {
 async function getManifestPackages(opts, manifestPath) {
   const log = await loadLog(opts.storageDir, opts.projectRoot);
   const normalizedManifest = manifestPath.replace(/\\/g, "/");
-  return log.entries.filter(
-    (e) => e.manifestPath.replace(/\\/g, "/") === normalizedManifest
-  );
+  return log.entries.filter((e) => e.manifestPath.replace(/\\/g, "/") === normalizedManifest);
 }
 async function getPackagesByAgent(opts, agentId) {
   const log = await loadLog(opts.storageDir, opts.projectRoot);
@@ -12130,7 +13083,7 @@ function parseOutdatedPackages(body) {
         latestVersion: cols[2] ?? "",
         wantedVersion: cols[3] ?? "",
         manifestPath: cols[4] ?? "",
-        ecosystem: detectEcosystem2(cols[4] ?? "")
+        ecosystem: detectEcosystem(cols[4] ?? "")
       });
     }
   }
@@ -12151,20 +13104,6 @@ function parseOutdatedPackages(body) {
   }
   return results;
 }
-function detectEcosystem2(manifestPath) {
-  const name = manifestPath.split("/").pop()?.split("\\").pop() ?? manifestPath;
-  if (name === "package.json") return "npm";
-  if (name === "go.mod") return "go";
-  if (name === "cargo.toml") return "cargo";
-  if (name === "pyproject.toml" || name === "requirements.txt") return "pip";
-  if (name === "gemfile" || name === "gemfile.lock") return "gem";
-  if (name === "composer.json" || name === "composer.lock") return "composer";
-  if (name.endsWith(".csproj") || name === "packages.config") return "nuget";
-  if (name === "mix.exs" || name === "mix.lock") return "elixir";
-  if (name === "pom.xml" || name.startsWith("build.gradle")) return "maven";
-  if (name === "pubspec.yaml" || name === "pubspec.lock") return "dart";
-  return "unknown";
-}
 function startPackageOutdatedWatcher(opts) {
   const {
     mailbox,
@@ -12214,11 +13153,7 @@ function startPackageOutdatedWatcher(opts) {
     log(`[pkg-outdated-watcher] Processing ${entries.length} outdated package(s) from ${msg.from}`);
     for (const entry of entries) {
       try {
-        const author = await getPackageAuthor(
-          packageTrackerOpts,
-          entry.manifestPath,
-          entry.name
-        );
+        const author = await getPackageAuthor(packageTrackerOpts, entry.manifestPath, entry.name);
         const notifyTarget = author?.agentId ?? "*";
         const notifyBody = buildNotifyBody(entry, author?.agentName);
         const notifyMsg = {
@@ -12273,13 +13208,7 @@ function buildNotifyBody(entry, authorName) {
       `This package appears to have been added by an agent no longer on record. Consider reviewing and updating it.`
     );
   }
-  lines.push(
-    "",
-    `Update with:`,
-    `\`\`\``,
-    `${getUpdateCommand(entry)}`,
-    `\`\`\``
-  );
+  lines.push("", `Update with:`, `\`\`\``, `${getUpdateCommand(entry)}`, `\`\`\``);
   return lines.join("\n");
 }
 function getUpdateCommand(entry) {
@@ -15343,6 +16272,6 @@ ${input.detail}`
   }
 };
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, AgentMonitorService, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_QUALITY_CHECKS, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, GlobalMailbox, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MAILBOX_BRIDGE_LOCK_FILENAME, MAILBOX_BRIDGE_TOKEN_FILENAME, MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD, MAILBOX_HEALTH_DEFAULT_FROM, MAILBOX_HEALTH_DEFAULT_INTERVAL_MS, MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS, MEDIUM_BUDGET, META_AGENTS, MailboxHealthWatchdog, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, acquireOrJoin, actionToAckInput, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, buildDownAlert, buildRecoveryAlert, composeDirectorPrompt, composeSubagentPrompt, createAgentMonitorService, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, finalize, formatHumanPrompt, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetTool as makeFleetHealthTool, makeFleetTool as makeFleetSessionTool, makeFleetTool as makeFleetStatusTool, makeFleetTool, makeFleetTool as makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateAllTool, makeTerminateTool, makeWorkCompleteTool, normalizeRecipient, readLiveLock, recordPackageAction, release, resolveMailboxIdentity, resolveProjectDir, rosterSummaryFromConfigs, scoreAgents, startPackageOutdatedWatcher, updatePackageOutdatedStatus, validateWatchdogOptions, withDisabledToolFiltering };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, TOOLS as AGENT_TOOL_PRESETS, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AdaptiveConcurrencyController, AgentMonitorService, AutonomousBrain, AutonomousCoordinator, BUG_HUNTER_AGENT, BUILD_AGENTS, BrainDecisionQueue, BrainMonitor, BudgetExceededError, BudgetThresholdSignal, ChangeManager, CollabSession, ConsensusProtocol, DECISION_TIMEOUT_MS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_QUALITY_CHECKS, DEFAULT_SUBAGENT_BASELINE, DELIVERY_AGENTS, DEPENDENCY_FILE_PATTERNS, DISCOVERY_AGENTS, DOMAIN_AGENTS, DefaultBrainArbiter, DefaultMailbox, DefaultMultiAgentCoordinator, Director, DirectorAlertLevel, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetSupervisor, FleetUsageAggregator, GlobalMailbox, HEAVY_BUDGET, HumanEscalatingBrainArbiter, InMemoryAgentBridge, InMemoryBridgeTransport, KNOWLEDGE_AGENTS, KnowledgeGraph, LIGHT_BUDGET, LargeAnswerStore, MAILBOX_BRIDGE_LOCK_FILENAME, MAILBOX_BRIDGE_TOKEN_FILENAME, MAILBOX_HEALTH_DEFAULT_FAILURE_THRESHOLD, MAILBOX_HEALTH_DEFAULT_FROM, MAILBOX_HEALTH_DEFAULT_INTERVAL_MS, MAILBOX_HEALTH_DEFAULT_TIMEOUT_MS, MEDIUM_BUDGET, META_AGENTS, MailboxHealthWatchdog, NULL_FLEET_BUS, ObservableBrainArbiter, PLANNING_AGENTS, REFACTOR_PLANNER_AGENT, REVIEW_AGENTS, SECURITY_SCANNER_AGENT, SubagentBudget, TIMEOUT_PREEMPT_FRACTION, TaskAuctioneer, TaskDAG, VERIFY_AGENTS, acquireOrJoin, actionToAckInput, applyRosterBudget, attachAutoExtend, attachDepWatcherBridge, buildDownAlert, buildRecoveryAlert, composeDirectorPrompt, composeSubagentPrompt, createAgentMonitorService, createDelegateTool, createMailboxHooks, createMessage, detectEcosystem, dispatchAgent, finalize, formatHumanPrompt, getAgentDefinition, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, mailboxSessionTag, makeAgentSubagentRunner, makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeCollabDebugTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetTool as makeFleetHealthTool, makeFleetTool as makeFleetSessionTool, makeFleetStatusTool, makeFleetTool, makeFleetTool as makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateAllTool, makeTerminateTool, makeWorkCompleteTool, normalizeRecipient, readLiveLock, recordPackageAction, release, resolveMailboxIdentity, resolveProjectDir, rosterSummaryFromConfigs, scoreAgents, startPackageOutdatedWatcher, updatePackageOutdatedStatus, validateWatchdogOptions, withDisabledToolFiltering };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map