@wrongstack/core 0.6.0 → 0.6.1

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

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

package/dist/coordination/index.d.ts

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

package/dist/coordination/index.js

@@ -792,7 +792,7 @@ var BudgetThresholdSignal = class extends Error {
     this.decision = decision;
   }
 };
-var SubagentBudget = class {
+var SubagentBudget = class _SubagentBudget {
   limits;
   iterations = 0;
   toolCalls = 0;
@@ -801,6 +801,26 @@ var SubagentBudget = class {
   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 `checkLimitAsync`'s
+   * `finally`.
+   */
+  pendingExtensions = /* @__PURE__ */ new Set();
+  /**
+   * Hard cap on how long `checkLimitAsync` 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, since
+   * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
+   * Hardcoded for now — most fleets set their own per-task timeout that
+   * dwarfs this anyway. 30 s matches the existing event-emit timeoutMs.
+   */
+  static DECISION_TIMEOUT_MS = 3e4;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
    * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
@@ -843,56 +863,92 @@ var SubagentBudget = class {
     if (kind === "timeout" || !this._onThreshold) {
       throw new BudgetExceededError(kind, limit, used);
     }
-    void this.checkLimitAsync(kind, used, limit);
+    const bus = this._events;
+    if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+      throw new BudgetExceededError(kind, limit, 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);
   }
   /**
-   * Async threshold negotiation with the coordinator. Fire-and-forget —
-   * any error thrown here becomes an unhandled rejection in the test environment
-   * because the runner's catch only handles the synchronous throw from `checkLimit`.
+   * 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`.
+   *
+   * The 'continue' return from a sync handler is treated as
+   * `{ extend: {} }` — keep going without patching, next overrun will
+   * fire a fresh signal.
    */
-  async checkLimitAsync(kind, used, limit) {
-    const result = this._onThreshold({
-      kind,
-      used,
-      limit,
-      // Inject a requestDecision helper the handler can call to emit the
-      // budget.threshold_reached event and wait for the coordinator's verdict.
-      // The runner wires this by injecting its EventBus into ctx.budget._events.
-      requestDecision: () => {
-        return new Promise((resolve) => {
-          this._events?.emit("budget.threshold_reached", {
-            kind,
-            used,
-            limit,
-            timeoutMs: 3e4,
-            extend: (extra) => resolve({ extend: extra }),
-            deny: () => resolve("stop")
+  async negotiateExtension(kind, used, limit) {
+    try {
+      const result = this._onThreshold({
+        kind,
+        used,
+        limit,
+        // Inject a requestDecision helper the handler can call to emit the
+        // budget.threshold_reached event and wait for the coordinator's verdict.
+        // A hard fallback timer guarantees the promise eventually resolves
+        // even if no listener responds — without it, an absent/detached
+        // Director would leave the budget permanently in "asking" state.
+        requestDecision: () => {
+          const bus = this._events;
+          if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+            return Promise.resolve("stop");
+          }
+          return new Promise((resolve) => {
+            let resolved = false;
+            const respond = (d) => {
+              if (resolved) return;
+              resolved = true;
+              resolve(d);
+            };
+            const fallback = setTimeout(
+              () => 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");
+              }
+            });
           });
-        });
+        }
+      });
+      if (result === "throw") return "stop";
+      if (result === "continue") return { extend: {} };
+      const decision = await result;
+      if (decision === "stop") return "stop";
+      const ext = decision.extend;
+      if (ext.maxIterations !== void 0) {
+        this.limits.maxIterations = ext.maxIterations;
       }
-    });
-    if (result === "throw") {
-      throw new BudgetExceededError(kind, limit, used);
-    }
-    if (result === "continue") {
-      return;
-    }
-    const decision = await result;
-    if (decision === "stop") {
-      throw new BudgetExceededError(kind, limit, used);
-    }
-    const ext = decision.extend;
-    if (ext.maxIterations !== void 0) {
-      this.limits.maxIterations = ext.maxIterations;
-    }
-    if (ext.maxToolCalls !== void 0) {
-      this.limits.maxToolCalls = ext.maxToolCalls;
-    }
-    if (ext.maxTokens !== void 0) {
-      this.limits.maxTokens = ext.maxTokens;
-    }
-    if (ext.maxCostUsd !== void 0) {
-      this.limits.maxCostUsd = ext.maxCostUsd;
+      if (ext.maxToolCalls !== void 0) {
+        this.limits.maxToolCalls = ext.maxToolCalls;
+      }
+      if (ext.maxTokens !== void 0) {
+        this.limits.maxTokens = ext.maxTokens;
+      }
+      if (ext.maxCostUsd !== void 0) {
+        this.limits.maxCostUsd = ext.maxCostUsd;
+      }
+      if (ext.timeoutMs !== void 0) {
+        this.limits.timeoutMs = ext.timeoutMs;
+      }
+      return decision;
+    } finally {
+      this.pendingExtensions.delete(kind);
     }
   }
   recordIteration() {
@@ -1175,6 +1231,19 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   setRunner(runner) {
     this.runner = runner;
   }
+  /**
+   * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
+   * preempt running tasks — already-dispatched subagents finish their
+   * current task; only future dispatches respect the new cap. Raising
+   * immediately tries to fill the freed slots from the pending queue.
+   */
+  setMaxConcurrent(n) {
+    if (!Number.isFinite(n) || n < 1) {
+      throw new Error(`maxConcurrent must be a finite integer >= 1, got ${n}`);
+    }
+    this.config.maxConcurrent = Math.floor(n);
+    this.tryDispatchNext();
+  }
   async spawn(subagent) {
     const id = subagent.id || randomUUID();
     if (this.subagents.has(id)) {
@@ -1434,14 +1503,65 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.recordCompletion(result);
   }
   async executeWithTimeout(runner, task, ctx, budget) {
-    const timeoutMs = budget.limits.timeoutMs;
-    if (timeoutMs === void 0) return runner(task, ctx);
+    const initialTimeoutMs = budget.limits.timeoutMs;
+    if (initialTimeoutMs === void 0) return runner(task, ctx);
+    const start = Date.now();
     let timer = null;
     const timeoutPromise = new Promise((_, reject) => {
-      timer = setTimeout(() => {
-        this.subagents.get(ctx.subagentId)?.abortController.abort();
-        reject(new BudgetExceededError("timeout", timeoutMs, Date.now()));
-      }, timeoutMs);
+      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));
+            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: 3e4,
+                  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") {
+              this.subagents.get(ctx.subagentId)?.abortController.abort();
+              reject(new BudgetExceededError("timeout", limit, elapsed));
+              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)
+            );
+          }
+        }, ms);
+      };
+      armFor(initialTimeoutMs);
     });
     try {
       return await Promise.race([runner(task, ctx), timeoutPromise]);
@@ -2052,7 +2172,7 @@ var Director = class {
         return;
       }
       extendCounts.set(guardKey, prior + 1);
-      setTimeout(() => {
+      setImmediate(() => {
         const extra = {};
         switch (payload.kind) {
           case "iterations":
@@ -2067,9 +2187,12 @@ var Director = class {
           case "cost":
             extra.maxCostUsd = Math.min(payload.limit * 1.5, 10);
             break;
+          case "timeout":
+            extra.timeoutMs = Math.min(Math.ceil(payload.limit * 1.5), 60 * 6e4);
+            break;
         }
         payload.extend(extra);
-      }, Math.min(payload.timeoutMs, 3e4));
+      });
     });
   }
   /** Best-effort session-writer append. Swallows failures — the director
@@ -2864,6 +2987,7 @@ function makeAgentSubagentRunner(opts) {
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     ctx.budget._events = events;
+    ctx.budget.onThreshold = ({ requestDecision }) => requestDecision();
     let budgetError = null;
     const onBudgetError = (err) => {
       if (err instanceof BudgetThresholdSignal) {