@wrongstack/core 0.4.1 → 0.5.0

package/dist/{events-BBaKeMfb.d.ts → events-DYAbU84e.d.ts}

@@ -1,4 +1,4 @@
-import { U as Usage, a0 as Context, y as ToolProgressEvent, u as Tool } from './context-B1kBj1lY.js';
+import { U as Usage, a0 as Context, y as ToolProgressEvent, u as Tool } from './context-P207fTpo.js';
 
 /**
  * EventBus — observe-only typed event bus.
@@ -163,6 +163,33 @@ interface EventMap {
         used: number;
         limit: number;
     };
+    /**
+     * Fired when the subagent budget hits a soft limit and the coordinator
+     * is being asked for an extension. The coordinator should call `extend()`
+     * to grant more budget, or the promise auto-resolves to `deny` after
+     * `timeoutMs` (default 30s), treating it as a hard stop.
+     *
+     * This event lets the CLI/TUI observe budget pressure in real time,
+     * surface extension requests to users, and give the coordinator a
+     * hook to implement custom extension policy without coupling to the
+     * runner/budget classes.
+     */
+    'budget.threshold_reached': {
+        kind: 'iterations' | 'tool_calls' | 'tokens' | 'cost';
+        used: number;
+        limit: number;
+        /** Call to grant more of the same budget type. */
+        extend: (extra: Partial<{
+            maxIterations: number;
+            maxToolCalls: number;
+            maxTokens: number;
+            maxCostUsd: number;
+        }>) => void;
+        /** Call to deny the extension — subagent will stop. */
+        deny: () => void;
+        /** Auto-resolves to deny after timeout. */
+        timeoutMs: number;
+    };
     'context.repaired': {
         ctx: Context;
         changed: boolean;
@@ -218,6 +245,19 @@ interface EventMap {
         taskId: string;
         description?: string;
     };
+    /**
+     * Fired by `MultiAgentHost` when a subagent hits a soft budget limit
+     * and the coordinator is auto-extending. TUI renders this as a
+     * status-line notice: "⚡ agent#name hitting kind limit (used/limit) — extending".
+     * After the auto-extend the task either continues or the coordinator
+     * denies the extension and the task ends with 'budget_exhausted'.
+     */
+    'subagent.budget_warning': {
+        subagentId: string;
+        kind: string;
+        used: number;
+        limit: number;
+    };
     /**
      * Per-tool-call event re-emitted from a subagent's own EventBus
      * onto the host EventBus, so the TUI / non-director surfaces can

package/dist/execution/index.d.ts

@@ -1,18 +1,19 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-B5bgmEgE.js';
-import { g as Provider, a0 as Context } from '../context-B1kBj1lY.js';
-import { a as Compactor, C as CompactReport } from '../compactor-CFky6JKM.js';
-import { M as MessageSelector } from '../selector-DBEiwXBk.js';
-import { E as EventBus } from '../events-BBaKeMfb.js';
-import { c as MiddlewareHandler } from '../system-prompt-DNetCecu.js';
-import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-RlhKLjme.js';
-import { r as Agent, R as RunResult } from '../index-meJRuQtc.js';
-import { D as DoneCondition } from '../multi-agent-D5m66hzB.js';
-import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-DayhFUBb.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-CYe5cp5U.js';
+import { g as Provider, a0 as Context } from '../context-P207fTpo.js';
+import { a as Compactor, C as CompactReport } from '../compactor-CTHjZAwf.js';
+import { M as MessageSelector } from '../selector-B-CGOshv.js';
+import { E as EventBus } from '../events-DYAbU84e.js';
+import { c as MiddlewareHandler } from '../system-prompt-CzY1zrbC.js';
+import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-DO2eCKgq.js';
+import { r as Agent, R as RunResult } from '../index-BNzUUDVR.js';
+import { D as DoneCondition } from '../multi-agent-B1Nn9eC0.js';
+import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
 import { a as WstackPaths } from '../wstack-paths-BGu2INTm.js';
+import '../retry-policy-CnYVKGPv.js';
 import '../models-registry-Y2xbog0E.js';
 import '../logger-BMQgxvdy.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-DyUAWS09.js';
+import '../secret-scrubber-Buo9zLGs.js';
 
 interface SkillLoaderOptions {
     paths: WstackPaths;
@@ -33,6 +34,7 @@ declare class DefaultSkillLoader implements SkillLoader {
     find(name: string): Promise<SkillManifest | undefined>;
     manifestText(): Promise<string>;
     listEntries(): Promise<SkillEntry[]>;
+    invalidateCache(): void;
     readBody(name: string): Promise<string>;
 }
 
@@ -187,11 +189,12 @@ interface AutoCompactionOptions {
 declare class AutoCompactionMiddleware {
     readonly name = "AutoCompaction";
     private readonly compactor;
+    private readonly estimator;
     private readonly warnThreshold;
     private readonly softThreshold;
     private readonly hardThreshold;
-    private readonly maxContext;
-    private readonly estimator;
+    /** Writable so model-switch can update the denominator without re-registering the middleware. */
+    private _maxContext;
     private readonly aggressiveOn;
     private readonly events?;
     private readonly failureMode;
@@ -212,6 +215,9 @@ declare class AutoCompactionMiddleware {
         soft: number;
         hard: number;
     }, optsOrAggressiveOn?: AutoCompactionOptions | ContextWindowAggressiveOn, events?: EventBus);
+    /** Allow callers (e.g. model-switch in WebUI) to update the context window
+     *  denominator when the active model changes. */
+    setMaxContext(maxContext: number): void;
     handler(): MiddlewareHandler<Context>;
     private compact;
 }

package/dist/execution/index.js

@@ -926,11 +926,12 @@ function toWrongStackError(err, code = "AGENT_RUN_FAILED") {
 var AutoCompactionMiddleware = class {
   name = "AutoCompaction";
   compactor;
+  estimator;
   warnThreshold;
   softThreshold;
   hardThreshold;
-  maxContext;
-  estimator;
+  /** Writable so model-switch can update the denominator without re-registering the middleware. */
+  _maxContext;
   aggressiveOn;
   events;
   failureMode;
@@ -949,7 +950,7 @@ var AutoCompactionMiddleware = class {
   constructor(compactor, maxContext, estimator, thresholds, optsOrAggressiveOn = {}, events) {
     const opts = typeof optsOrAggressiveOn === "string" ? { aggressiveOn: optsOrAggressiveOn, events } : optsOrAggressiveOn;
     this.compactor = compactor;
-    this.maxContext = maxContext;
+    this._maxContext = maxContext;
     this.estimator = estimator;
     this.warnThreshold = thresholds.warn;
     this.softThreshold = thresholds.soft;
@@ -959,10 +960,15 @@ var AutoCompactionMiddleware = class {
     this.failureMode = opts.failureMode ?? "throw_on_hard";
     this.policyProvider = opts.policyProvider;
   }
+  /** Allow callers (e.g. model-switch in WebUI) to update the context window
+   *  denominator when the active model changes. */
+  setMaxContext(maxContext) {
+    this._maxContext = maxContext;
+  }
   handler() {
     return async (ctx, next) => {
       const tokens = this.estimator(ctx);
-      const load = tokens / this.maxContext;
+      const load = tokens / this._maxContext;
       const policy = this.policyProvider?.(ctx);
       const thresholds = policy?.thresholds ?? {
         warn: this.warnThreshold,
@@ -991,7 +997,7 @@ var AutoCompactionMiddleware = class {
         aggressive,
         level: pressure.level,
         tokens: pressure.tokens,
-        maxContext: this.maxContext,
+        maxContext: this._maxContext,
         load: pressure.load,
         fatal
       });
@@ -1003,7 +1009,7 @@ var AutoCompactionMiddleware = class {
           context: {
             level: pressure.level,
             tokens: pressure.tokens,
-            maxContext: this.maxContext
+            maxContext: this._maxContext
           },
           cause: err
         });
@@ -1765,6 +1771,9 @@ var DefaultSkillLoader = class {
     }
     return entries;
   }
+  invalidateCache() {
+    this.cache = void 0;
+  }
   async readBody(name) {
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);