@wrongstack/core 0.9.19 → 0.9.20

package/dist/execution/index.js

@@ -39,6 +39,54 @@ function estimateToolResultTokens(content) {
 function estimateTextTokens(text) {
   return RoughTokenEstimate(text);
 }
+function estimateToolDefTokens(tool) {
+  return RoughTokenEstimate(tool.name) + RoughTokenEstimate(tool.description ?? "") + RoughTokenEstimate(JSON.stringify(tool.inputSchema));
+}
+function estimateRequestTokens(messages, systemPrompt, tools) {
+  let messagesTokens = 0;
+  if (typeof messages === "string") {
+    messagesTokens = RoughTokenEstimate(messages);
+  } else if (Array.isArray(messages)) {
+    for (const m of messages) {
+      if (typeof m === "object" && m !== null && "content" in m) {
+        const content = m.content;
+        if (typeof content === "string") {
+          messagesTokens += RoughTokenEstimate(content);
+        } else if (Array.isArray(content)) {
+          for (const b of content) {
+            if (typeof b === "object" && b !== null) {
+              if (b.type === "text") {
+                messagesTokens += RoughTokenEstimate(b.text);
+              } else {
+                messagesTokens += RoughTokenEstimate(JSON.stringify(b));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  let systemTokens = 0;
+  if (typeof systemPrompt === "string") {
+    systemTokens = RoughTokenEstimate(systemPrompt);
+  } else if (Array.isArray(systemPrompt)) {
+    for (const b of systemPrompt) {
+      if (typeof b === "object" && b !== null && b.type === "text") {
+        systemTokens += RoughTokenEstimate(b.text);
+      }
+    }
+  }
+  let toolsTokens = 0;
+  for (const t of tools) {
+    toolsTokens += estimateToolDefTokens(t);
+  }
+  return {
+    messages: messagesTokens,
+    systemPrompt: systemTokens,
+    tools: toolsTokens,
+    total: messagesTokens + systemTokens + toolsTokens
+  };
+}
 
 // src/utils/message-invariants.ts
 function repairToolUseAdjacency(messages) {
@@ -144,6 +192,7 @@ var HybridCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateMessages(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
     const policy = readContextWindowPolicy(ctx);
     const preserveK = policy?.preserveK ?? this.preserveK;
@@ -159,9 +208,12 @@ var HybridCompactor = class {
       ctx.state.replaceMessages(repaired.messages);
     }
     const afterTokens = this.estimateMessages(ctx.messages);
+    const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
       after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
       reductions,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
@@ -170,6 +222,14 @@ var HybridCompactor = class {
       } : void 0
     };
   }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
+  }
   eliseOldToolResults(ctx, preserveK = this.preserveK, eliseThreshold = this.eliseThreshold) {
     const messages = ctx.messages;
     let pairCount = 0;
@@ -315,8 +375,9 @@ var IntelligentCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateTokens(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
-    const load = beforeTokens / this.maxContext;
+    const load = beforeFull / this.maxContext;
     const aggressive = load >= this.hardThreshold ? true : opts.aggressive ?? load >= this.softThreshold;
     const saved1 = this.eliseOldToolResults(ctx);
     if (saved1 > 0) reductions.push({ phase: "elision", saved: saved1 });
@@ -330,9 +391,12 @@ var IntelligentCompactor = class {
     const repaired = repairToolUseAdjacency(ctx.messages);
     if (repaired.report.changed) ctx.state.replaceMessages(repaired.messages);
     const afterTokens = this.estimateTokens(ctx.messages);
+    const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
       after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
       reductions,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
@@ -341,6 +405,14 @@ var IntelligentCompactor = class {
       } : void 0
     };
   }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
+  }
   async summarizeAncientTurns(ctx) {
     const messages = ctx.messages;
     const cutoff = Math.max(0, messages.length - this.preserveK * 2);
@@ -353,29 +425,26 @@ var IntelligentCompactor = class {
     try {
       summaryText = await this.callSummarizer(toSummarize, ctx);
     } catch {
-      const toolNames = /* @__PURE__ */ new Set();
-      const filePaths = /* @__PURE__ */ new Set();
-      let userTurns = 0;
-      let assistantTurns = 0;
+      const preservedMessages = [];
       for (const m of toSummarize) {
-        if (m.role === "user") userTurns++;
-        else if (m.role === "assistant") {
-          assistantTurns++;
-          if (Array.isArray(m.content)) {
-            for (const b of m.content) {
-              if (b.type === "tool_use") toolNames.add(b.name ?? "unknown");
-            }
-          }
+        if (m.role === "system") continue;
+        if (typeof m.content === "string") {
+          preservedMessages.push(m);
+        } else if (Array.isArray(m.content)) {
+          const textParts = m.content.filter(isTextBlock);
+          const toolParts = m.content.filter((b) => b.type === "tool_use" || b.type === "tool_result");
+          const next = {
+            role: m.role,
+            content: [
+              ...textParts,
+              ...toolParts.length > 0 ? [{ type: "text", text: `[${toolParts.length} tool call(s) omitted]` }] : []
+            ]
+          };
+          preservedMessages.push(next);
         }
-        const text = typeof m.content === "string" ? m.content : "";
-        const matches = text.matchAll(/(?:[\w.,\-/@]+\/)*[\w.,\-/@]+\.\w+/g);
-        for (const m_ of matches) filePaths.add(m_[0]);
       }
-      const parts = [`${toSummarize.length} turns (${userTurns} user, ${assistantTurns} assistant)`];
-      if (toolNames.size > 0) parts.push(`tools: ${[...toolNames].join(", ")}`);
-      if (filePaths.size > 0) parts.push(`files: ${[...filePaths].slice(0, 10).join(", ")}`);
-      summaryText = parts.join(" | ");
-      if (!summaryText) summaryText = `${toSummarize.length} earlier turns omitted`;
+      summaryText = preservedMessages.map((m) => `[${m.role}]: ${typeof m.content === "string" ? m.content : m.content.filter(isTextBlock).map((b) => b.text).join(" ")}`).join("\n");
+      if (!summaryText) summaryText = `${toSummarize.length} earlier turns (semantic content preserved)`;
     }
     const summaryMsg = {
       role: "system",
@@ -621,7 +690,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       const res = await this.provider.complete(req, { signal: ac.signal });
       const textBlocks = res.content.filter(isTextBlock);
       raw = textBlocks.map((b) => b.text).join("\n").trim();
-    } catch (err) {
+    } catch (_err) {
       return this.fallbackSelect(messages, effectiveBudget);
     }
     return this.parseSelectorOutput(raw, messages.length);
@@ -713,15 +782,24 @@ var SelectiveCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateTokens(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
-    const load = beforeTokens / this.maxContext;
+    const load = beforeFull / this.maxContext;
     const shouldCompact = load >= this.warnThreshold || opts.aggressive;
     if (!shouldCompact) {
       const saved = this.eliseOldToolResults(ctx);
       if (saved > 0) reductions.push({ phase: "elision", saved });
       const repair2 = this.repairProtocolAdjacency(ctx);
       const afterTokens2 = this.estimateTokens(ctx.messages);
-      return { before: beforeTokens, after: afterTokens2, reductions, repaired: repair2 };
+      const afterFull2 = this.estimateFullRequest(ctx);
+      return {
+        before: beforeTokens,
+        after: afterTokens2,
+        fullRequestTokensBefore: beforeFull,
+        fullRequestTokensAfter: afterFull2,
+        reductions,
+        repaired: repair2
+      };
     }
     const savedElision = this.eliseOldToolResults(ctx);
     if (savedElision > 0) reductions.push({ phase: "elision", saved: savedElision });
@@ -733,7 +811,23 @@ var SelectiveCompactor = class {
     }
     const repair = this.repairProtocolAdjacency(ctx);
     const afterTokens = this.estimateTokens(ctx.messages);
-    return { before: beforeTokens, after: afterTokens, reductions, repaired: repair };
+    const afterFull = this.estimateFullRequest(ctx);
+    return {
+      before: beforeTokens,
+      after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
+      reductions,
+      repaired: repair
+    };
+  }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
   }
   repairProtocolAdjacency(ctx) {
     const repaired = repairToolUseAdjacency(ctx.messages);
@@ -1008,7 +1102,8 @@ var LEVEL_RANK = { warn: 0, soft: 1, hard: 2 };
 var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   name = "AutoCompaction";
   compactor;
-  estimator;
+  /** Deprecated. Kept for backward compat with tests that pass simpleEstimator. */
+  _estimator;
   warnThreshold;
   softThreshold;
   hardThreshold;
@@ -1018,19 +1113,6 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   events;
   failureMode;
   policyProvider;
-  /**
-   * Calibration factor applied to the estimator output. The estimator is now
-   * expected to already include messages + system prompt + tool definitions
-   * (see `estimateRequestTokens.total`), so no overhead boost is needed. Kept
-   * as a constant so a future calibration against real provider tokenization
-   * (BPE vs the chars/3.5 rough estimator) can dial this without touching the
-   * threshold-check math.
-   *
-   * Historical note: was 1.3 when the estimator only counted messages — that
-   * double-counted system+tools once the estimator was upgraded, firing
-   * compaction ~30% earlier than intended (e.g. real 56% load showed as 73%).
-   */
-  static OVERHEAD_FACTOR = 1;
   /**
    * Once a compaction attempt reduces nothing (preserveK protects everything,
    * no oversized tool_results remain to elide), retrying on every iteration
@@ -1043,8 +1125,11 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   lastNoopAttempt = null;
   /**
    * @param compactor        Compactor to use for compaction.
-   * @param maxContext       Provider's max context window in tokens.
-   * @param estimator        Token estimation function.
+   * @param maxContext Provider's max context window in tokens.
+   * @param _estimator       Deprecated parameter kept for backward compatibility.
+   *                         The middleware now uses `estimateRequestTokens` internally
+   *                         for accurate full-request token counting (messages +
+   *                         systemPrompt + toolDefs).
    * @param thresholds       Threshold fractions (0-1) of maxContext.
    * @param opts             Optional behavior. By default, failures at the
    *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
@@ -1052,11 +1137,11 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
    *                         provider context overflow. Warn/soft failures
    *                         still emit compaction.failed and continue.
    */
-  constructor(compactor, maxContext, estimator, thresholds, optsOrAggressiveOn = {}, events) {
+  constructor(compactor, maxContext, _estimator, thresholds, optsOrAggressiveOn = {}, events) {
     const opts = typeof optsOrAggressiveOn === "string" ? { aggressiveOn: optsOrAggressiveOn, events } : optsOrAggressiveOn;
     this.compactor = compactor;
     this._maxContext = maxContext;
-    this.estimator = estimator;
+    this._estimator = _estimator;
     this.warnThreshold = thresholds.warn;
     this.softThreshold = thresholds.soft;
     this.hardThreshold = thresholds.hard;
@@ -1072,8 +1157,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   }
   handler() {
     return async (ctx, next) => {
-      const rawTokens = this.estimator(ctx);
-      const tokens = Math.ceil(rawTokens * _AutoCompactionMiddleware.OVERHEAD_FACTOR);
+      const tokens = this._estimator ? this._estimator(ctx) : estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []).total;
       const load = tokens / this._maxContext;
       const policy = this.policyProvider?.(ctx);
       const thresholds = policy?.thresholds ?? {
@@ -1108,7 +1192,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
     return delta < _AutoCompactionMiddleware.NOOP_RETRY_DELTA_TOKENS;
   }
   recordAttempt(level, tokens, report) {
-    const reduced = report.before > report.after;
+    const reduced = (report.fullRequestTokensBefore ?? report.before) > (report.fullRequestTokensAfter ?? report.after);
     const repaired = !!report.repaired;
     if (reduced || repaired) {
       this.lastNoopAttempt = null;
@@ -2449,17 +2533,7 @@ var SubagentBudget = class _SubagentBudget {
   startTime = null;
   _onThreshold;
   /**
-   * Tracks which budget kinds currently have an extension request
-   * in flight. While a kind is here, further `checkLimit` calls for the
-   * same kind are no-ops — without this dedup, every `recordIteration`
-   * after the limit is reached spawns a fresh decision Promise (until
-   * the first one lands and patches limits), flooding the FleetBus
-   * with redundant threshold events. Cleared in `negotiateExtension`'s
-   * `finally`.
-   */
-  pendingExtensions = /* @__PURE__ */ new Set();
-  /**
-   * Hard cap on how long `negotiateExtension` waits for the coordinator to
+   * Hard cap on how long `_negotiateExtension` waits for the coordinator to
    * respond before defaulting to 'stop'. Without this fallback an absent
    * or hung listener (Director not built / event filter detached mid-run)
    * leaves the budget over-limit and never enforces anything.
@@ -2521,38 +2595,83 @@ var SubagentBudget = class _SubagentBudget {
    * - `mode === 'auto'` + no listener  → throw `BudgetExceededError` (hard stop; no one to ask)
    * - `mode === 'auto'` + listener     → throw `BudgetThresholdSignal` with async decision promise
    */
-  checkLimit(kind, used, limit) {
+  /**
+   * Collects all exceeded budget kinds into a single NOOP-free negotiation.
+   * Called by recordIteration / recordToolCall / recordUsage — each may call
+   * this for its own kind. The first call starts the negotiation and stores
+   * the Promise in _pendingNegotiation. Subsequent calls for DIFFERENT
+   * kinds (while a negotiation is in flight) are NOOPs — they don't start
+   * new conversations with the coordinator. This prevents an EventBus flood
+   * when multiple budget kinds are exceeded simultaneously in one iteration.
+   *
+   * Returns the kinds that were found to be exceeded (for logging/debugging).
+   */
+  checkLimits(elapsedMs) {
+    const exceeded = [];
+    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
+      exceeded.push({ kind: "iterations", used: this.iterations, limit: this.limits.maxIterations });
+    }
+    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
+      exceeded.push({ kind: "tool_calls", used: this.toolCalls, limit: this.limits.maxToolCalls });
+    }
+    const totalTokens = this.tokenInput + this.tokenOutput;
+    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
+      exceeded.push({ kind: "tokens", used: totalTokens, limit: this.limits.maxTokens });
+    }
+    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
+      exceeded.push({ kind: "cost", used: this.costUsd, limit: this.limits.maxCostUsd });
+    }
+    if (elapsedMs !== void 0 && this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs) {
+      exceeded.push({ kind: "timeout", used: elapsedMs, limit: this.limits.timeoutMs });
+    }
+    if (exceeded.length === 0) return [];
     if (!this._onThreshold) {
-      throw new BudgetExceededError(kind, limit, used);
+      const first2 = exceeded[0];
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     if (this._mode === "sync") {
-      throw new BudgetExceededError(kind, limit, used);
+      const first2 = exceeded[0];
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     const bus = this._events;
     if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
-      throw new BudgetExceededError(kind, limit, used);
+      const first2 = exceeded[0];
+      throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
-    if (this.pendingExtensions.has(kind)) return;
-    this.pendingExtensions.add(kind);
-    const decision = this.negotiateExtension(kind, used, limit);
-    throw new BudgetThresholdSignal(kind, limit, used, decision);
+    for (const entry of exceeded) {
+      if (this._pendingNegotiations.has(entry.kind)) continue;
+      const decision2 = this._negotiateExtension(entry.kind, exceeded);
+      this._pendingNegotiations.set(entry.kind, decision2);
+    }
+    const first = exceeded[0];
+    const decision = this._pendingNegotiations.get(first.kind);
+    throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
   }
+  /**
+   * Per-kind in-flight negotiation Promises. Each budget kind can have its
+   * own concurrent negotiation — e.g. iterations and timeout can both
+   * be exceeded simultaneously without blocking each other. The same kind
+   * cannot start two concurrent negotiations (dedup guard).
+   * Cleared in `_negotiateExtension`'s `finally` block.
+   */
+  _pendingNegotiations = /* @__PURE__ */ new Map();
   /**
    * Drive the threshold handler to a decision. Resolves with `'stop'`
    * (signal the runner to abort) or `{ extend: ... }` (limits already
-   * patched in-place; the runner should not abort). Always releases the
-   * `pendingExtensions` slot in `finally`.
+   * patched in-place; the runner should not abort). Clears the
+   * per-kind slot in `_pendingNegotiations` in `finally`.
    *
    * The 'continue' return from a sync handler is treated as
    * `{ extend: {} }` — keep going without patching; next overrun fires
    * a fresh signal.
    */
-  async negotiateExtension(kind, used, limit) {
+  async _negotiateExtension(kind, exceeded) {
     try {
+      const first = exceeded[0];
       const result = this._onThreshold({
-        kind,
-        used,
-        limit,
+        kind: first.kind,
+        used: first.used,
+        limit: first.limit,
         requestDecision: () => {
           const bus = this._events;
           if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
@@ -2569,20 +2688,22 @@ var SubagentBudget = class _SubagentBudget {
               () => respond("stop"),
               _SubagentBudget.DECISION_TIMEOUT_MS
             );
-            bus.emit("budget.threshold_reached", {
-              kind,
-              used,
-              limit,
-              timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
-              extend: (extra) => {
-                clearTimeout(fallback);
-                respond({ extend: extra });
-              },
-              deny: () => {
-                clearTimeout(fallback);
-                respond("stop");
-              }
-            });
+            for (const { kind: kind2, used, limit } of exceeded) {
+              bus.emit("budget.threshold_reached", {
+                kind: kind2,
+                used,
+                limit,
+                timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+                extend: (extra) => {
+                  clearTimeout(fallback);
+                  respond({ extend: extra });
+                },
+                deny: () => {
+                  clearTimeout(fallback);
+                  respond("stop");
+                }
+              });
+            }
           });
         }
       });
@@ -2608,47 +2729,39 @@ var SubagentBudget = class _SubagentBudget {
       }
       return decision;
     } finally {
-      this.pendingExtensions.delete(kind);
+      this._pendingNegotiations.delete(kind);
     }
   }
   recordIteration() {
     this.iterations++;
-    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
-      void this.checkLimit("iterations", this.iterations, this.limits.maxIterations);
-    }
+    void this.checkLimits();
   }
   recordToolCall() {
     this.toolCalls++;
-    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
-      void this.checkLimit("tool_calls", this.toolCalls, this.limits.maxToolCalls);
-    }
+    void this.checkLimits();
   }
   recordUsage(usage, costUsd = 0) {
     this.tokenInput += usage.input;
     this.tokenOutput += usage.output;
     this.costUsd += costUsd;
-    const totalTokens = this.tokenInput + this.tokenOutput;
-    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
-      void this.checkLimit("tokens", totalTokens, this.limits.maxTokens);
-    }
-    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
-      void this.checkLimit("cost", this.costUsd, this.limits.maxCostUsd);
-    }
+    void this.checkLimits();
   }
   /**
-   * Wall-clock budget check. Unlike other limits, timeout check passes through
-   * `checkLimit` and is subject to the same negotiation-mode decision table.
-   * In practice, `'sync'` mode (the usual test configuration) means a timeout
-   * immediately throws `BudgetExceededError`. In production with a coordinator,
-   * a timeout emits `budget.threshold_reached` so the Director can decide whether
-   * to extend or abort.
+   * Wall-clock budget check. Unlike other limits, timeout is always a hard stop
+   * — wall-clock time cannot be "extended" by the coordinator, so it throws
+   * synchronously rather than entering the negotiation flow.
+   *
+   * Decision table:
+   * - no `onThreshold` handler         → throw `BudgetExceededError`
+   * - `mode === 'sync'`               → throw `BudgetExceededError`
+   * - `mode === 'auto'` + no listener  → throw `BudgetExceededError`
+   * - `mode === 'auto'` + listener     → throw `BudgetExceededError` (timeout is not extendable)
    */
   checkTimeout() {
     if (this.startTime === null || this.limits.timeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
-    if (elapsed > this.limits.timeoutMs) {
-      void this.checkLimit("timeout", elapsed, this.limits.timeoutMs);
-    }
+    if (elapsed <= this.limits.timeoutMs) return;
+    void this.checkLimits(elapsed);
   }
   /** Returns true if a timeout has occurred without throwing. Useful for races. */
   isTimedOut() {
@@ -5258,6 +5371,107 @@ FLEET_ROSTER_BUDGETS["goose"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations:
   ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
 });
 
+// src/coordination/subagent-nicknames.ts
+var NICKNAME_POOL = {
+  // Physics & fundamental sciences
+  "einstein": { name: "Einstein", domain: "physics" },
+  "newton": { name: "Newton", domain: "physics" },
+  "feynman": { name: "Feynman", domain: "physics" },
+  "dirac": { name: "Dirac", domain: "physics" },
+  "bohr": { name: "Bohr", domain: "physics" },
+  "planck": { name: "Planck", domain: "physics" },
+  "curie": { name: "Curie", domain: "physics" },
+  "fermi": { name: "Fermi", domain: "physics" },
+  "heisenberg": { name: "Heisenberg", domain: "physics" },
+  "schrodinger": { name: "Schr\xF6dinger", domain: "physics" },
+  // Mathematics
+  "euclid": { name: "Euclid", domain: "math" },
+  "gauss": { name: "Gauss", domain: "math" },
+  "turing": { name: "Turing", domain: "math" },
+  "poincare": { name: "Poincar\xE9", domain: "math" },
+  "riemann": { name: "Riemann", domain: "math" },
+  "hilbert": { name: "Hilbert", domain: "math" },
+  "pythagoras": { name: "Pythagoras", domain: "math" },
+  // Computing & information theory
+  "von-neumann": { name: "Von Neumann", domain: "computing" },
+  "shannon": { name: "Shannon", domain: "computing" },
+  "hopper": { name: "Hopper", domain: "computing" },
+  "backus": { name: "Backus", domain: "computing" },
+  "knuth": { name: "Knuth", domain: "computing" },
+  "torvalds": { name: "Torvalds", domain: "computing" },
+  "stallman": { name: "Stallman", domain: "computing" },
+  "berners-lee": { name: "Berners-Lee", domain: "computing" },
+  "babbage": { name: "Babbage", domain: "computing" },
+  "lovelace": { name: "Lovelace", domain: "computing" },
+  "klein": { name: "Klein", domain: "computing" },
+  // Electronics & electrical engineering
+  "edison": { name: "Edison", domain: "ee" },
+  "tesla": { name: "Tesla", domain: "ee" },
+  "faraday": { name: "Faraday", domain: "ee" },
+  "maxwell": { name: "Maxwell", domain: "ee" },
+  "ohm": { name: "Ohm", domain: "ee" },
+  "bell": { name: "Bell", domain: "ee" },
+  "marconi": { name: "Marconi", domain: "ee" },
+  "lamarr": { name: "Lamarr", domain: "ee" },
+  // General science / multi-disciplinary
+  "darwin": { name: "Darwin", domain: "biology" },
+  "mendel": { name: "Mendel", domain: "biology" },
+  "pasteur": { name: "Pasteur", domain: "biology" },
+  "hawking": { name: "Hawking", domain: "cosmology" },
+  "sagan": { name: "Sagan", domain: "cosmology" },
+  // Chemistry / materials
+  "lavoisier": { name: "Lavoisier", domain: "chemistry" },
+  "mendeleev": { name: "Mendeleev", domain: "chemistry" }
+};
+var ALL_NICKNAMES = Object.values(NICKNAME_POOL);
+var DOMAIN_PREFERENCES = {
+  "security": ["shannon", "turing", "lamarr", "stallman"],
+  "bug-hunter": ["darwin", "curie", "feynman", "fermi"],
+  "refactor": ["gauss", "hilbert", "euclid", "planck"],
+  "audit-log": ["sagan", "hawking", "poincare", "newton"],
+  "planner": ["hilbert", "gauss", "turing", "euclid"],
+  "researcher": ["sagan", "hawking", "darwin", "pasteur"],
+  "explorer": ["marconi", "bell", "columbus", "polo"],
+  "testing": ["pasteur", "curie", "fermi", "bohr"],
+  "frontend": ["lovelace", "hopper", "babbage", "backus"],
+  "backend": ["torvalds", "stallman", "von-neumann", "backus"],
+  "database": ["turing", "shannon", "backus", "knuth"],
+  "devops": ["tesla", "edison", "faraday", "bell"],
+  "security-scanner": ["shannon", "turing", "lamarr", "stallman"],
+  "refactor-planner": ["gauss", "hilbert", "planck", "newton"],
+  "architect": ["von-neumann", "turing", "gauss", "hilbert"],
+  "critic": ["einstein", "feynman", "dirac", "bohr"],
+  "e2e": ["hopper", "bell", "marconi", "tesla"],
+  "performance": ["knuth", "gauss", "planck", "feynman"],
+  "chaos": ["tesla", "edison", "curie", "fermi"],
+  "cost": ["ohm", "bell", "marconi", "tesla"],
+  // default fallback
+  "default": ["einstein", "newton", "curie", "tesla", "edison", "turing", "shannon", "hopper", "knuth", "stallman"]
+};
+function assignNickname(role, used) {
+  const preferences = [
+    ...DOMAIN_PREFERENCES[role] ?? [],
+    ...DOMAIN_PREFERENCES["default"] ?? []
+  ];
+  for (const key of preferences) {
+    const entry = NICKNAME_POOL[key];
+    if (entry && !used.has(key)) {
+      return `${entry.name} (${formatRole(role)})`;
+    }
+  }
+  for (const entry of ALL_NICKNAMES) {
+    const key = Object.entries(NICKNAME_POOL).find(([, v]) => v.name === entry.name)?.[0];
+    if (key && !used.has(key)) {
+      return `${entry.name} (${formatRole(role)})`;
+    }
+  }
+  const counter = used.size + 1;
+  return `Scientist #${counter} (${formatRole(role)})`;
+}
+function formatRole(role) {
+  return role.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+
 // src/coordination/multi-agent-coordinator.ts
 var DefaultMultiAgentCoordinator = class extends EventEmitter {
   coordinatorId;
@@ -5265,6 +5479,15 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   runner;
   fleetBus;
   subagents = /* @__PURE__ */ new Map();
+  /**
+   * Base nickname keys already handed out this run (e.g. `einstein`, `tesla`).
+   * Prevents two workers sharing a name. Direct `coordinator.spawn()` callers
+   * (parallel/eternal engine, SDD parallel run) don't go through
+   * `Director.spawn()` where nicknames are normally assigned, so the
+   * coordinator upgrades placeholder names ("Executor", "slot-ab12cd", role
+   * names) to memorable ones here — that's what surfaces in the fleet monitor.
+   */
+  usedNicknames = /* @__PURE__ */ new Set();
   pendingTasks = [];
   completedResults = [];
   totalIterations = 0;
@@ -5313,7 +5536,26 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.config.maxConcurrent = Math.floor(n);
     this.tryDispatchNext();
   }
+  /**
+   * Upgrade a placeholder/role-derived name to a memorable scientist nickname
+   * (e.g. "Einstein (Executor)"). A name is treated as a placeholder when it is
+   * empty, equals the role (case-insensitive), is a generic default
+   * ("subagent"/"adhoc"/"generic"), or is an auto-generated `slot-…` id.
+   * Explicit, human-chosen names — including nicknames already assigned by
+   * `Director.spawn()` — are left untouched, so this never double-assigns.
+   */
+  withNickname(subagent) {
+    const role = subagent.role ?? "subagent";
+    const name = subagent.name?.trim() ?? "";
+    const isPlaceholder = name === "" || name.toLowerCase() === role.toLowerCase() || name === "subagent" || name === "adhoc" || name === "generic" || /^slot-/.test(name);
+    if (!isPlaceholder) return subagent;
+    const nickname = assignNickname(role, this.usedNicknames);
+    const baseKey = nickname.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    this.usedNicknames.add(baseKey);
+    return { ...subagent, name: nickname };
+  }
   async spawn(subagent) {
+    subagent = this.withNickname(subagent);
     const id = subagent.id || randomUUID();
     if (this.subagents.has(id)) {
       throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
@@ -5907,12 +6149,12 @@ var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
   constructor(opts) {
     this.opts = opts;
-    this.goalPath = goalFilePath(opts.projectRoot);
+    this.goalPath = opts.goalPath ?? goalFilePath(opts.projectRoot);
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
     this.timeoutMs = opts.iterationTimeoutMs ?? 3e5;
     this.dispatchEnabled = opts.dispatch !== false;
     this.dispatchClassifier = opts.dispatchClassifier;
-    this.agentFactory = opts.subagentFactory ?? (async (config) => ({
+    this.agentFactory = opts.subagentFactory ?? (async (_config) => ({
       agent: this.opts.agent,
       events: this.opts.agent.events
     }));
@@ -6006,7 +6248,6 @@ var ParallelEternalEngine = class {
     }
     const tasks = await this.decomposeGoal(goal);
     if (!tasks || tasks.length === 0) {
-      await sleep2(5e3);
       return false;
     }
     const fanOut = await this.fanOut(goal, tasks);
@@ -6027,6 +6268,7 @@ var ParallelEternalEngine = class {
     });
     if (fanOut.goalComplete) {
       this.stopRequested = true;
+      this.state = "stopped";
       return true;
     }
     await this.maybeCompact();
@@ -6207,7 +6449,11 @@ ${lastFew}` : "No prior iterations.",
       } finally {
         clearTimeout(timer);
       }
-    } catch {
+    } catch (err) {
+      this.opts.onError?.(
+        err instanceof Error ? err : new Error(String(err)),
+        this.consecutiveFailures
+      );
       return [];
     }
   }