@wrongstack/core 0.9.20 → 0.10.2

package/dist/sdd/index.js

@@ -2614,6 +2614,13 @@ var SubagentBudget = class _SubagentBudget {
   tokenOutput = 0;
   costUsd = 0;
   startTime = null;
+  /**
+   * 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.
+   */
+  lastActivityTime = null;
   _onThreshold;
   /**
    * Hard cap on how long `_negotiateExtension` waits for the coordinator to
@@ -2657,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() {
@@ -2704,8 +2729,13 @@ var SubagentBudget = class _SubagentBudget {
     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 (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) {
@@ -2810,6 +2840,9 @@ 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._pendingNegotiations.delete(kind);
@@ -2817,16 +2850,19 @@ var SubagentBudget = class _SubagentBudget {
   }
   recordIteration() {
     this.iterations++;
+    this.markActivity();
     void this.checkLimits();
   }
   recordToolCall() {
     this.toolCalls++;
+    this.markActivity();
     void this.checkLimits();
   }
   recordUsage(usage, costUsd = 0) {
     this.tokenInput += usage.input;
     this.tokenOutput += usage.output;
     this.costUsd += costUsd;
+    this.markActivity();
     void this.checkLimits();
   }
   /**
@@ -2841,15 +2877,22 @@ var SubagentBudget = class _SubagentBudget {
    * - `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) return;
+    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 {
@@ -2956,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) {
@@ -2972,6 +3016,7 @@ function makeAgentSubagentRunner(opts) {
         currentToolName = e.name;
       }),
       events.on("provider.text_delta", (e) => {
+        ctx.budget.markActivity();
         streamingTextAcc = (streamingTextAcc + e.text).slice(-200);
       })
     );
@@ -5309,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 },
@@ -5320,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
 };
@@ -5330,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,
@@ -5890,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) {
@@ -5943,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]);