@wrongstack/core 0.6.7 → 0.7.2

package/dist/{director-state-BmYi3DGA.d.ts → director-state-BUB7JRUr.d.ts}

@@ -105,4 +105,4 @@ declare class DirectorStateCheckpoint {
     private persist;
 }
 
-export { DirectorStateCheckpoint as D, type DirectorStateSnapshot as a, type DirectorSubagentState as b, type DirectorTaskState as c, loadDirectorState as l };
+export { type DirectorStateSnapshot as D, DirectorStateCheckpoint as a, type DirectorSubagentState as b, type DirectorTaskState as c, loadDirectorState as l };

package/dist/{events-DounT6pP.d.ts → events-AjrvHJ9V.d.ts}

@@ -1,4 +1,4 @@
-import { U as Usage, a2 as Context, z as ToolProgressEvent, v as Tool } from './context-C8mBUzBv.js';
+import { U as Usage, a5 as Context, D as ToolProgressEvent, x as Tool } from './context-BwxhvyW8.js';
 
 /**
  * EventBus — observe-only typed event bus.
@@ -281,6 +281,21 @@ interface EventMap {
         used: number;
         limit: number;
     };
+    /**
+     * Emitted when the coordinator/director actually GRANTS a budget
+     * extension to a subagent (the resolution of a `budget.threshold_reached`
+     * negotiation). Distinct from `subagent.budget_warning`, which fires when
+     * a limit is merely *hit*. UIs use this to render a persistent "⚡ extended
+     * ×N" badge so users can see how often an agent self-extended to stay
+     * alive. `totalExtensions` is the cumulative count for this subagent across
+     * all kinds; `newLimit` is the patched value for `kind`.
+     */
+    'subagent.budget_extended': {
+        subagentId: string;
+        kind: string;
+        newLimit: number;
+        totalExtensions: number;
+    };
     /**
      * Per-tool-call event re-emitted from a subagent's own EventBus
      * onto the host EventBus, so the TUI / non-director surfaces can
@@ -433,6 +448,15 @@ declare class EventBus {
      * Number of wildcard listeners currently registered.
      */
     wildcardCount(): number;
+    /**
+     * True if anything would receive an emit for `event` — a named listener
+     * OR a wildcard/regex pattern that matches the event name. Unlike
+     * `listenerCount`, this DOES account for wildcards, so callers that gate
+     * behavior on "is anyone listening?" (e.g. SubagentBudget deciding whether
+     * to negotiate a soft limit vs hard-stop) don't misfire when the only
+     * subscriber is a pattern listener like the FleetBus's `onPattern('*')`.
+     */
+    hasListenerFor(event: string): boolean;
 }
 /**
  * A decorator over `EventBus` that records every listener registration

package/dist/execution/index.d.ts

@@ -1,21 +1,22 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-CwpjhwHC.js';
-import { g as Provider, a2 as Context } from '../context-C8mBUzBv.js';
-import { a as Compactor, C as CompactReport } from '../compactor-BUJ8550X.js';
-import { M as MessageSelector } from '../selector-DVo3eT-P.js';
-import { E as EventBus } from '../events-DounT6pP.js';
-import { c as MiddlewareHandler } from '../system-prompt-BBGles-N.js';
-import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-BHkYGzUT.js';
-import { A as Agent, R as RunResult, j as SystemPromptContributor } from '../index-DiIGZh5I.js';
-import { D as DoneCondition } from '../multi-agent-Iy8YUe3v.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-BoM0U0qn.js';
+import { i as Provider, a5 as Context } from '../context-BwxhvyW8.js';
+import { a as Compactor, C as CompactReport } from '../compactor-BFKGzKd5.js';
+import { M as MessageSelector } from '../selector-BmUma5iG.js';
+import { E as EventBus } from '../events-AjrvHJ9V.js';
+import { c as MiddlewareHandler } from '../system-prompt-BKrzd_ci.js';
+import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-BXAhlqJb.js';
+import { A as Agent, R as RunResult, j as SystemPromptContributor } from '../index-B2WWETRP.js';
+import { D as DoneCondition } from '../multi-agent-DenFfUv5.js';
 import { J as JournalEntry } from '../goal-store-HHgaq5ue.js';
-import { A as AgentFactory } from '../agent-subagent-runner-BTloSwjE.js';
+import { c as AgentFactory, i as DispatchClassifier, g as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-DGUn-5Bb.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
 import { W as WstackPaths } from '../wstack-paths-86YPFktR.js';
-import '../retry-policy-DOnwHAyz.js';
+import '../retry-policy-mEBn5qpv.js';
 import '../models-registry-Y2xbog0E.js';
 import '../logger-BMQgxvdy.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-C9UJxFCJ.js';
+import '../secret-scrubber-bZ5AyhwJ.js';
+import 'node:events';
 
 interface SkillLoaderOptions {
     paths: WstackPaths;
@@ -201,6 +202,13 @@ declare class AutoCompactionMiddleware {
     private readonly events?;
     private readonly failureMode;
     private readonly policyProvider?;
+    /**
+     * Overhead factor applied to the rough message-token estimate to produce a
+     * figure comparable to the real API request size (system prompt + tool defs).
+     * Without this factor, raw message tokens undercount real load by 15-50% in
+     * short conversations, causing premature compaction triggers.
+     */
+    private static readonly OVERHEAD_FACTOR;
     /**
      * @param compactor        Compactor to use for compaction.
      * @param maxContext       Provider's max context window in tokens.
@@ -301,7 +309,8 @@ interface EternalAutonomyOptions {
      * Maximum number of internal agent.run iterations the engine grants per
      * eternal-loop tick. The engine sets `autonomousContinue: true` so the
      * agent can run multi-step tasks end-to-end within one tick instead of
-     * bouncing back to the engine after every single tool call. Default 50.
+     * bouncing back to the engine after every single tool call. Default 500.
+     * Previous 50 was far too low — agents hit the limit and restart constantly.
      */
     iterationMaxAgentSteps?: number;
     /**
@@ -546,6 +555,20 @@ interface ParallelEternalOptions {
     maxContextTokens?: number;
     /** Override the default agent factory (uses main agent if not provided). */
     subagentFactory?: AgentFactory;
+    /**
+     * Route each decomposed slot task to the best-fit catalog agent via the
+     * smart dispatcher (heuristic keyword scoring). When enabled (default), each
+     * slot spawns in-role — the role's budget tier applies and a persona line is
+     * injected into the task — instead of as a faceless generic worker. Set
+     * false to keep the legacy generic spawn.
+     */
+    dispatch?: boolean;
+    /**
+     * Optional LLM fallback for ambiguous tasks. Passed straight to
+     * `dispatchAgent`; when omitted, routing is pure heuristic (instant, no
+     * provider call — preferred for a continuously-ticking autonomous loop).
+     */
+    dispatchClassifier?: DispatchClassifier;
 }
 /**
  * Sense → Decide → Fan-out (4–8 parallel agents) → Aggregate → Loop.
@@ -571,8 +594,14 @@ declare class ParallelEternalEngine {
     private readonly timeoutMs;
     private coordinator;
     private agentFactory;
+    private readonly dispatchEnabled;
+    private readonly dispatchClassifier?;
     constructor(opts: ParallelEternalOptions);
     get currentState(): ParallelEngineState;
+    /**
+     * Get the underlying coordinator for stats/monitoring.
+     */
+    getCoordinator(): DefaultMultiAgentCoordinator | null;
     stop(): void;
     prime(): Promise<void>;
     run(): Promise<void>;