@wrongstack/core 0.9.19 → 0.10.0

package/dist/sdd/index.js

@@ -2058,7 +2058,7 @@ function analyzeCriticalPath(graph) {
     blockedTasks
   };
 }
-function getTransitiveBlocked(graph, taskId, blocksMap) {
+function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
@@ -2074,7 +2074,7 @@ function getTransitiveBlocked(graph, taskId, blocksMap) {
   }
   return visited;
 }
-function computeCriticalPath(graph, topoOrder, blockedByMap) {
+function computeCriticalPath(graph, _topoOrder, blockedByMap) {
   const allIds = Array.from(graph.nodes.keys());
   if (allIds.length === 0) return [];
   const dist = /* @__PURE__ */ new Map();
@@ -2492,13 +2492,11 @@ function createAutoExecutor(opts) {
 
 // src/sdd/sdd-task-decomposer.ts
 var SddTaskDecomposer = class {
-  constructor(tracker, graph, opts = {}) {
+  constructor(tracker, _graph, opts = {}) {
     this.tracker = tracker;
-    this.graph = graph;
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
   }
   tracker;
-  graph;
   slots;
   wave = 0;
   // -------------------------------------------------------------------
@@ -2616,19 +2614,16 @@ var SubagentBudget = class _SubagentBudget {
   tokenOutput = 0;
   costUsd = 0;
   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`.
+   * Timestamp of the most recent activity (iteration / tool call / token
+   * usage / streamed progress). Drives the idle timeout — reset by
+   * `markActivity()`. Initialised to `start()` time so a never-active agent
+   * still eventually trips its idle window.
    */
-  pendingExtensions = /* @__PURE__ */ new Set();
+  lastActivityTime = null;
+  _onThreshold;
   /**
-   * 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.
@@ -2669,6 +2664,24 @@ var SubagentBudget = class _SubagentBudget {
   }
   start() {
     this.startTime = Date.now();
+    this.lastActivityTime = this.startTime;
+  }
+  /**
+   * Reset the idle clock. Called on any sign of forward progress —
+   * iterations, tool calls, token usage, and streamed tool/text progress —
+   * so a long-but-productive subagent never trips its `idleTimeoutMs`.
+   */
+  markActivity() {
+    this.lastActivityTime = Date.now();
+  }
+  /**
+   * Milliseconds since the last activity signal. Returns 0 before `start()`
+   * (nothing to measure yet). Used by the coordinator watchdog to decide
+   * whether to re-arm (still active) or reap (genuinely idle).
+   */
+  idleMs() {
+    const since = this.lastActivityTime ?? this.startTime;
+    return since === null ? 0 : Date.now() - since;
   }
   /** Returns true if we're within 10% of any limit — useful for pre-flight checks. */
   isNearLimit() {
@@ -2690,38 +2703,88 @@ 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) {
+      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: "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);
+    }
+    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);
     }
-    if (this.pendingExtensions.has(kind)) return;
-    this.pendingExtensions.add(kind);
-    const decision = this.negotiateExtension(kind, used, limit);
-    throw new BudgetThresholdSignal(kind, limit, used, decision);
+    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")) {
@@ -2738,20 +2801,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");
+                }
+              });
+            }
           });
         }
       });
@@ -2775,54 +2840,59 @@ var SubagentBudget = class _SubagentBudget {
       if (ext.timeoutMs !== void 0) {
         this.limits.timeoutMs = ext.timeoutMs;
       }
+      if (ext.idleTimeoutMs !== void 0) {
+        this.limits.idleTimeoutMs = ext.idleTimeoutMs;
+      }
       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);
-    }
+    this.markActivity();
+    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);
-    }
+    this.markActivity();
+    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);
-    }
+    this.markActivity();
+    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;
+    if (this.startTime === null) return;
+    const { timeoutMs, idleTimeoutMs } = this.limits;
+    if (timeoutMs === void 0 && idleTimeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
-    if (elapsed > this.limits.timeoutMs) {
-      void this.checkLimit("timeout", elapsed, this.limits.timeoutMs);
-    }
+    const wallTripped = timeoutMs !== void 0 && elapsed > timeoutMs;
+    const idleTripped = idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs;
+    if (!wallTripped && !idleTripped) return;
+    void this.checkLimits(elapsed);
   }
-  /** Returns true if a timeout has occurred without throwing. Useful for races. */
+  /** Returns true if a wall-clock or idle timeout has occurred without throwing. */
   isTimedOut() {
-    if (this.startTime === null || this.limits.timeoutMs === void 0) return false;
-    return Date.now() - this.startTime > this.limits.timeoutMs;
+    if (this.startTime === null) return false;
+    const { timeoutMs, idleTimeoutMs } = this.limits;
+    if (timeoutMs !== void 0 && Date.now() - this.startTime > timeoutMs) return true;
+    if (idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs) return true;
+    return false;
   }
   usage() {
     return {
@@ -2929,6 +2999,7 @@ function makeAgentSubagentRunner(opts) {
       // Cheap: O(1) per progress event, and the budget short-circuits
       // when timeoutMs is unset (most subagents have one set anyway).
       events.on("tool.progress", () => {
+        ctx.budget.markActivity();
         try {
           ctx.budget.checkTimeout();
         } catch (e) {
@@ -2945,6 +3016,7 @@ function makeAgentSubagentRunner(opts) {
         currentToolName = e.name;
       }),
       events.on("provider.text_delta", (e) => {
+        ctx.budget.markActivity();
         streamingTextAcc = (streamingTextAcc + e.text).slice(-200);
       })
     );
@@ -5282,6 +5354,7 @@ var ALL_AGENT_DEFINITIONS = [
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
   )
 });
+var DEFAULT_IDLE_TIMEOUT_MS = 15 * 60 * 1e3;
 var FLEET_ROSTER_BUDGETS = {
   "audit-log": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 5e3, maxToolCalls: 15e3 },
   "bug-hunter": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
@@ -5293,7 +5366,7 @@ var FLEET_ROSTER_BUDGETS = {
   )
 };
 var GENERIC_SUBAGENT_BUDGET = {
-  timeoutMs: 3 * 60 * 60 * 1e3,
+  idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
   maxIterations: 5e3,
   maxToolCalls: 15e3
 };
@@ -5303,7 +5376,13 @@ function applyRosterBudget(cfg) {
   if (!defaultBudget) return cfg;
   return {
     ...cfg,
-    timeoutMs: cfg.timeoutMs ?? defaultBudget.timeoutMs,
+    // Wall-clock cap is opt-in only: forward an explicit `cfg.timeoutMs`, but
+    // do NOT impose the roster's historical multi-hour wall-clock default — it
+    // killed agents that were still actively working. Reaping is idle-based.
+    timeoutMs: cfg.timeoutMs,
+    // Idle window is the default reaper. Resets on activity, so a long-but-
+    // productive run is never killed; only a genuine stall is reaped.
+    idleTimeoutMs: cfg.idleTimeoutMs ?? defaultBudget.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS,
     maxIterations: cfg.maxIterations ?? defaultBudget.maxIterations,
     maxToolCalls: cfg.maxToolCalls ?? defaultBudget.maxToolCalls,
     maxTokens: cfg.maxTokens ?? defaultBudget.maxTokens,
@@ -5371,6 +5450,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;
@@ -5378,6 +5558,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;
@@ -5426,7 +5615,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`);
@@ -5734,13 +5942,17 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     const rawMaxTokens = subagent.config.maxTokens;
     const rawMaxCostUsd = subagent.config.maxCostUsd;
     const rawTimeoutMs = subagent.config.timeoutMs;
+    const rawIdleTimeoutMs = subagent.config.idleTimeoutMs;
     const configWithRosterDefaults = applyRosterBudget(subagent.config);
     const budget = new SubagentBudget({
       maxIterations: rawMaxIterations ?? this.config.defaultBudget?.maxIterations ?? configWithRosterDefaults.maxIterations,
       maxToolCalls: rawMaxToolCalls ?? this.config.defaultBudget?.maxToolCalls ?? configWithRosterDefaults.maxToolCalls,
       maxTokens: rawMaxTokens ?? this.config.defaultBudget?.maxTokens ?? configWithRosterDefaults.maxTokens,
       maxCostUsd: rawMaxCostUsd ?? this.config.defaultBudget?.maxCostUsd ?? configWithRosterDefaults.maxCostUsd,
-      timeoutMs: rawTimeoutMs ?? this.config.defaultBudget?.timeoutMs ?? configWithRosterDefaults.timeoutMs
+      // Wall-clock cap is opt-in (explicit config / defaultBudget only); the
+      // roster no longer supplies one. Idle is the default reaper.
+      timeoutMs: rawTimeoutMs ?? this.config.defaultBudget?.timeoutMs ?? configWithRosterDefaults.timeoutMs,
+      idleTimeoutMs: rawIdleTimeoutMs ?? this.config.defaultBudget?.idleTimeoutMs ?? configWithRosterDefaults.idleTimeoutMs
     });
     subagent.activeBudget = budget;
     if (!this.runner) {
@@ -5787,63 +5999,79 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   }
   async executeWithTimeout(runner, task, ctx, budget) {
     const initialTimeoutMs = budget.limits.timeoutMs;
-    if (initialTimeoutMs === void 0) return runner(task, ctx);
+    const idleLimitMs = budget.limits.idleTimeoutMs;
+    if (initialTimeoutMs === void 0 && idleLimitMs === void 0) {
+      return runner(task, ctx);
+    }
     const start = Date.now();
     let timer = null;
     const timeoutPromise = new Promise((_, reject) => {
       const armFor = (ms) => {
         if (timer) clearTimeout(timer);
-        timer = setTimeout(async () => {
-          const elapsed = Date.now() - start;
-          const limit = budget.limits.timeoutMs ?? initialTimeoutMs;
-          if (!budget.onThreshold) {
-            this.subagents.get(ctx.subagentId)?.abortController.abort();
-            reject(new BudgetExceededError("timeout", limit, elapsed));
+        timer = setTimeout(onTick, Math.max(0, ms));
+      };
+      const scheduleNext = () => {
+        const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.timeoutMs ?? initialTimeoutMs) - (Date.now() - start);
+        const idleRemaining = idleLimitMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
+        armFor(Math.max(25, Math.min(wallRemaining, idleRemaining)));
+      };
+      const onTick = async () => {
+        const elapsed = Date.now() - start;
+        const wallLimit = initialTimeoutMs === void 0 ? void 0 : budget.limits.timeoutMs ?? initialTimeoutMs;
+        const idleLimit = idleLimitMs === void 0 ? void 0 : budget.limits.idleTimeoutMs ?? idleLimitMs;
+        const wallExceeded = wallLimit !== void 0 && elapsed >= wallLimit;
+        const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
+        if (idleExceeded && !wallExceeded) {
+          this.subagents.get(ctx.subagentId)?.abortController.abort();
+          reject(new BudgetExceededError("timeout", idleLimit, budget.idleMs()));
+          return;
+        }
+        if (!wallExceeded) {
+          scheduleNext();
+          return;
+        }
+        const limit = wallLimit;
+        if (!budget.onThreshold) {
+          this.subagents.get(ctx.subagentId)?.abortController.abort();
+          reject(new BudgetExceededError("timeout", limit, elapsed));
+          return;
+        }
+        try {
+          const result = budget.onThreshold({
+            kind: "timeout",
+            used: elapsed,
+            limit,
+            requestDecision: () => new Promise((resolveDecision) => {
+              budget._events?.emit("budget.threshold_reached", {
+                kind: "timeout",
+                used: elapsed,
+                limit,
+                timeoutMs: 6e4,
+                extend: (extra) => resolveDecision({ extend: extra }),
+                deny: () => resolveDecision("stop")
+              });
+            })
+          });
+          const decision = typeof result === "string" ? result : await result;
+          if (decision === "continue" || decision === "throw" || decision === "stop") {
+            armFor(Math.max(1e3, limit));
             return;
           }
-          try {
-            const result = budget.onThreshold({
-              kind: "timeout",
-              used: elapsed,
-              limit,
-              requestDecision: () => new Promise((resolveDecision) => {
-                budget._events?.emit("budget.threshold_reached", {
-                  kind: "timeout",
-                  used: elapsed,
-                  limit,
-                  timeoutMs: 6e4,
-                  extend: (extra) => resolveDecision({ extend: extra }),
-                  deny: () => resolveDecision("stop")
-                });
-              })
-            });
-            const decision = typeof result === "string" ? result : await result;
-            if (decision === "continue") {
-              armFor(Math.max(1e3, limit));
-              return;
-            }
-            if (decision === "throw" || decision === "stop") {
-              armFor(Math.max(1e3, limit));
-              return;
-            }
-            if (decision.extend.timeoutMs !== void 0) {
-              budget.limits.timeoutMs = decision.extend.timeoutMs;
-              const newLimit = decision.extend.timeoutMs;
-              const remaining = Math.max(1e3, newLimit - elapsed);
-              armFor(remaining);
-              return;
-            }
-            this.subagents.get(ctx.subagentId)?.abortController.abort();
-            reject(new BudgetExceededError("timeout", limit, elapsed));
-          } catch (err) {
-            this.subagents.get(ctx.subagentId)?.abortController.abort();
-            reject(
-              err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
-            );
+          if (decision.extend.timeoutMs !== void 0) {
+            budget.limits.timeoutMs = decision.extend.timeoutMs;
+            scheduleNext();
+            return;
           }
-        }, ms);
+          this.subagents.get(ctx.subagentId)?.abortController.abort();
+          reject(new BudgetExceededError("timeout", limit, elapsed));
+        } catch (err) {
+          this.subagents.get(ctx.subagentId)?.abortController.abort();
+          reject(
+            err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
+          );
+        }
       };
-      armFor(initialTimeoutMs);
+      scheduleNext();
     });
     try {
       return await Promise.race([runner(task, ctx), timeoutPromise]);
@@ -6085,7 +6313,7 @@ var SddParallelRun = class {
     this.coordinator.setRunner?.(runner);
   }
   defaultFactory() {
-    return async (config) => ({
+    return async (_config) => ({
       agent: this.opts.agent,
       events: this.opts.agent.events
     });