@wrongstack/core 0.7.8 → 0.8.2

package/dist/{events-D4pGukpI.d.ts → events-DyhxkstG.d.ts}

@@ -397,6 +397,26 @@ interface EventMap {
         revertedFiles: string[];
         removedEvents: number;
     };
+    /**
+     * Fired by the multi-agent coordinator on FleetBus whenever subagent
+     * counts change (spawn/stop/complete). The TUI subscribes to render
+     * live fleet counters without polling.
+     */
+    'coordinator.stats': {
+        total: number;
+        running: number;
+        idle: number;
+        stopped: number;
+        inFlight: number;
+        pending: number;
+        completed: number;
+        subagentStatuses: {
+            subagentId: string;
+            taskId: string;
+            status: string;
+            assigned: boolean;
+        }[];
+    };
     error: {
         err: Error;
         phase: string;
@@ -415,6 +435,14 @@ declare class EventBus {
     on<E extends EventName>(event: E, fn: Listener<E>): () => void;
     off<E extends EventName>(event: E, fn: Listener<E>): void;
     once<E extends EventName>(event: E, fn: Listener<E>): () => void;
+    /**
+     * Subscribe to all events, regardless of name. Short-hand for
+     * `onPattern('*')`. Use for logging, debugging, or forwarding every
+     * event to another bus (as FleetBus does).
+     *
+     * Returns an unsubscribe function.
+     */
+    onAny(fn: (event: string, payload: unknown) => void): () => void;
     /**
      * Subscribe to all events whose name matches a glob-style prefix.
      * `'tool.*'` matches `tool.started`, `tool.executed`, `tool.progress`, etc.
@@ -496,6 +524,11 @@ declare class ScopedEventBus extends EventBus {
      * our registration entry under a different key).
      */
     once<E extends EventName>(event: E, fn: Listener<E>): () => void;
+    /**
+     * Subscribe to all events. Alias for `onPattern('*')` — the listener is
+     * tracked so that `teardown()` will remove it automatically.
+     */
+    onAny(fn: (event: string, payload: unknown) => void): () => void;
     /**
      * Identical to `EventBus.onPattern` but the listener is tracked so that
      * `teardown()` will remove it automatically.

package/dist/execution/index.d.ts

@@ -1,22 +1,22 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-CSwXjifK.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-QwfWnQZ8.js';
 import { m as Provider, d as Context } from '../context-z2x5gv_V.js';
 import { a as Compactor, C as CompactReport } from '../compactor-Mw7-rNyb.js';
 import { M as MessageSelector } from '../selector-DkvgYVS4.js';
-import { E as EventBus } from '../events-D4pGukpI.js';
+import { E as EventBus } from '../events-DyhxkstG.js';
 import { b as MiddlewareHandler } from '../system-prompt-CWA6ml-d.js';
 import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-Bi4Q0fnz.js';
-import { c as Agent, R as RunResult, w as SystemPromptContributor } from '../index-BtNRyJft.js';
-import { D as DoneCondition } from '../multi-agent-7OK4pEKW.js';
+import { c as Agent, R as RunResult, w as SystemPromptContributor } from '../index-oYZeWsuJ.js';
+import { D as DoneCondition } from '../multi-agent-CRMznZmf.js';
 import { J as JournalEntry } from '../goal-store-C7jcumEh.js';
-import { A as AgentFactory } from '../agent-subagent-runner-B2zguWzh.js';
-import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-3Ypfg-hr.js';
+import { A as AgentFactory } from '../agent-subagent-runner-Cav3yEJM.js';
+import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-IQKrMfXz.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
 import { a as WstackPaths } from '../wstack-paths-gCrJ631C.js';
 import '../retry-policy-OwtKNxo8.js';
 import '../models-registry-BcYJDKLm.js';
 import '../logger-DDd5C--Z.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-nI8qjaqW.js';
+import '../secret-scrubber-CyE1-EMG.js';
 import 'node:events';
 
 interface SkillLoaderOptions {
@@ -210,6 +210,16 @@ declare class AutoCompactionMiddleware {
      * short conversations, causing premature compaction triggers.
      */
     private static readonly OVERHEAD_FACTOR;
+    /**
+     * Once a compaction attempt reduces nothing (preserveK protects everything,
+     * no oversized tool_results remain to elide), retrying on every iteration
+     * just spams `compaction.fired` events without making progress. We remember
+     * the no-op and skip until either the pressure level escalates or context
+     * has grown by at least this many tokens since the failed attempt.
+     */
+    private static readonly NOOP_RETRY_DELTA_TOKENS;
+    /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
+    private lastNoopAttempt;
     /**
      * @param compactor        Compactor to use for compaction.
      * @param maxContext       Provider's max context window in tokens.
@@ -230,6 +240,13 @@ declare class AutoCompactionMiddleware {
      *  denominator when the active model changes. */
     setMaxContext(maxContext: number): void;
     handler(): MiddlewareHandler<Context>;
+    /**
+     * Returns true when the previous compaction at the same or higher pressure
+     * level reduced nothing and context has not grown materially since. Prevents
+     * a stuck preserveK window from spamming compaction events every iteration.
+     */
+    private shouldSkipNoopRetry;
+    private recordAttempt;
     private compact;
 }
 

package/dist/execution/index.js

@@ -1004,6 +1004,7 @@ var FsError = class extends WrongStackError {
 };
 
 // src/execution/auto-compaction-middleware.ts
+var LEVEL_RANK = { warn: 0, soft: 1, hard: 2 };
 var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   name = "AutoCompaction";
   compactor;
@@ -1024,6 +1025,16 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
    * short conversations, causing premature compaction triggers.
    */
   static OVERHEAD_FACTOR = 1.3;
+  /**
+   * Once a compaction attempt reduces nothing (preserveK protects everything,
+   * no oversized tool_results remain to elide), retrying on every iteration
+   * just spams `compaction.fired` events without making progress. We remember
+   * the no-op and skip until either the pressure level escalates or context
+   * has grown by at least this many tokens since the failed attempt.
+   */
+  static NOOP_RETRY_DELTA_TOKENS = 2e3;
+  /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
+  lastNoopAttempt = null;
   /**
    * @param compactor        Compactor to use for compaction.
    * @param maxContext       Provider's max context window in tokens.
@@ -1065,19 +1076,44 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         hard: this.hardThreshold
       };
       const aggressiveOn = policy?.aggressiveOn ?? this.aggressiveOn;
-      if (load >= thresholds.hard) {
-        await this.compact(ctx, true, { level: "hard", tokens, load });
-      } else if (load >= thresholds.soft) {
-        await this.compact(ctx, aggressiveOn !== "hard", { level: "soft", tokens, load });
-      } else if (load >= thresholds.warn) {
-        await this.compact(ctx, aggressiveOn === "warn", { level: "warn", tokens, load });
+      const level = load >= thresholds.hard ? "hard" : load >= thresholds.soft ? "soft" : load >= thresholds.warn ? "warn" : null;
+      if (!level) {
+        this.lastNoopAttempt = null;
+        return next(ctx);
+      }
+      if (this.shouldSkipNoopRetry(level, tokens)) {
+        return next(ctx);
       }
+      const aggressive = level === "hard" ? true : level === "soft" ? aggressiveOn !== "hard" : aggressiveOn === "warn";
+      await this.compact(ctx, aggressive, { level, tokens, load });
       return next(ctx);
     };
   }
+  /**
+   * Returns true when the previous compaction at the same or higher pressure
+   * level reduced nothing and context has not grown materially since. Prevents
+   * a stuck preserveK window from spamming compaction events every iteration.
+   */
+  shouldSkipNoopRetry(level, tokens) {
+    const stuck = this.lastNoopAttempt;
+    if (!stuck) return false;
+    if (LEVEL_RANK[level] > LEVEL_RANK[stuck.level]) return false;
+    const delta = tokens - stuck.tokens;
+    return delta < _AutoCompactionMiddleware.NOOP_RETRY_DELTA_TOKENS;
+  }
+  recordAttempt(level, tokens, report) {
+    const reduced = report.before > report.after;
+    const repaired = !!report.repaired;
+    if (reduced || repaired) {
+      this.lastNoopAttempt = null;
+    } else {
+      this.lastNoopAttempt = { level, tokens };
+    }
+  }
   async compact(ctx, aggressive, pressure) {
     try {
       const report = await this.compactor.compact(ctx, { aggressive });
+      this.recordAttempt(pressure.level, pressure.tokens, report);
       this.events?.emit("compaction.fired", {
         level: pressure.level,
         tokens: pressure.tokens,
@@ -2393,29 +2429,35 @@ var SubagentBudget = class _SubagentBudget {
    * 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
+   * with redundant threshold events. Cleared in `negotiateExtension`'s
    * `finally`.
    */
   pendingExtensions = /* @__PURE__ */ new Set();
   /**
-   * Hard cap on how long `checkLimitAsync` 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, since
-   * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
-   * Raised from 30s to 60s to give subagents more headroom before
-   * the threshold negotiation times out and triggers a hard stop.
+   * leaves the budget over-limit and never enforces anything.
    */
   static DECISION_TIMEOUT_MS = 6e4;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
-   * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
+   * Used to emit `budget.threshold_reached` events in `'auto'` mode.
    */
   _events;
+  /**
+   * Negotiation mode — controls whether a threshold hit tries to emit
+   * `budget.threshold_reached` and wait for a coordinator decision, or
+   * falls straight through to a synchronous hard stop.
+   *
+   * `'auto'` (default) — emit on the EventBus and wait; times out to 'stop'.
+   * `'sync'` — throw `BudgetExceededError` immediately regardless of listeners.
+   */
+  _mode;
   /**
    * Optional callback for soft-limit handling. When set, the budget will
-   * call this instead of throwing when a limit is first reached. The
-   * handler decides whether to throw, continue, or ask the coordinator.
+   * invoke it rather than throw immediately. The handler decides whether to
+   * throw synchronously, continue, or ask the coordinator for an extension.
    */
   get onThreshold() {
     return this._onThreshold;
@@ -2423,7 +2465,12 @@ var SubagentBudget = class _SubagentBudget {
   set onThreshold(fn) {
     this._onThreshold = fn;
   }
-  constructor(limits = {}) {
+  /** Returns the current negotiation mode. */
+  get mode() {
+    return this._mode;
+  }
+  constructor(limits = {}, mode = "auto") {
+    this._mode = mode;
     this.limits = { ...limits };
   }
   start() {
@@ -2439,16 +2486,23 @@ var SubagentBudget = class _SubagentBudget {
     return false;
   }
   /**
-   * Synchronous budget check — always throws synchronously so callers
-   * (especially test event handlers using `expect().toThrow()`) get an
-   * unhandled rejection when the budget is exceeded without a handler.
-   * When `onThreshold` IS configured, the actual async threshold-handling
-   * is dispatched as a fire-and-forget promise.
+   * Synchronous budget check. Always throws synchronously so callers (especially
+   * test event handlers using `expect().toThrow()`) get an unhandled rejection
+   * when the budget is exceeded without a handler.
+   *
+   * Decision table:
+   * - no `onThreshold` handler         → throw `BudgetExceededError` (hard stop, always)
+   * - `mode === 'sync'`               → throw `BudgetExceededError` (hard stop, always)
+   * - `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) {
     if (!this._onThreshold) {
       throw new BudgetExceededError(kind, limit, used);
     }
+    if (this._mode === "sync") {
+      throw new BudgetExceededError(kind, limit, used);
+    }
     const bus = this._events;
     if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
       throw new BudgetExceededError(kind, limit, used);
@@ -2465,8 +2519,8 @@ var SubagentBudget = class _SubagentBudget {
    * `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.
+   * `{ extend: {} }` — keep going without patching; next overrun fires
+   * a fresh signal.
    */
   async negotiateExtension(kind, used, limit) {
     try {
@@ -2474,11 +2528,6 @@ var SubagentBudget = class _SubagentBudget {
         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.hasListenerFor("budget.threshold_reached")) {
@@ -2562,12 +2611,12 @@ var SubagentBudget = class _SubagentBudget {
     }
   }
   /**
-   * Wall-clock budget check. Unlike other limits, timeout is treated as a
-   * warning-only event — it NEVER hard-stops the subagent. When the
-   * elapsed time exceeds timeoutMs, emits `budget.threshold_reached` with
-   * kind='timeout' so the Director can decide whether to extend or warn.
-   * Call this from the iteration loop so a hung tool gets a chance to
-   * negotiate more time before the coordinator's Promise.race kills it.
+   * 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.
    */
   checkTimeout() {
     if (this.startTime === null || this.limits.timeoutMs === void 0) return;
@@ -4934,8 +4983,7 @@ function scoreAgents(task, catalog = AGENT_CATALOG) {
   const hay = normalize(task);
   const out = [];
   for (const def of Object.values(catalog)) {
-    const role = def.config.role;
-    if (!role) continue;
+    if (!def?.config?.role) continue;
     let score = 0;
     const matched = [];
     for (const kw of def.capability.keywords) {
@@ -4947,7 +4995,7 @@ function scoreAgents(task, catalog = AGENT_CATALOG) {
       }
     }
     if (score > 0) {
-      out.push({ role, name: def.config.name, score, matched });
+      out.push({ role: def.config.role, name: def.config.name, score, matched });
     }
   }
   out.sort((a, b) => b.score - a.score);
@@ -5189,6 +5237,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   coordinatorId;
   config;
   runner;
+  fleetBus;
   subagents = /* @__PURE__ */ new Map();
   pendingTasks = [];
   completedResults = [];
@@ -5217,6 +5266,14 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   setRunner(runner) {
     this.runner = runner;
   }
+  /**
+   * Wire a FleetBus for director-mode event emission. Call after the
+   * FleetManager is constructed so the coordinator can emit lifecycle
+   * events the TUI and monitoring tools subscribe to.
+   */
+  setFleetBus(fleet) {
+    this.fleetBus = fleet;
+  }
   /**
    * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
    * preempt running tasks — already-dispatched subagents finish their
@@ -5252,6 +5309,18 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       abortController: new AbortController()
     });
     this.emit("subagent.started", { subagent: { ...subagent, id } });
+    this.fleetBus?.emit({
+      subagentId: id,
+      ts: Date.now(),
+      type: "subagent.assigned",
+      payload: {
+        subagentId: id,
+        name: subagent.name,
+        provider: subagent.provider,
+        model: subagent.model
+      }
+    });
+    this.emitCoordinatorStats();
     return { subagentId: id, agentId: id };
   }
   async assign(task) {
@@ -5284,6 +5353,13 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     subagent.currentTask = void 0;
     subagent.context.parentBridge = null;
     this.emit("subagent.stopped", { subagentId, reason: "stopped by coordinator" });
+    this.fleetBus?.emit({
+      subagentId,
+      ts: Date.now(),
+      type: "subagent.stopped",
+      payload: { subagentId, reason: "stopped by coordinator" }
+    });
+    this.emitCoordinatorStats();
   }
   async stopAll() {
     this.drainPendingAsAborted("Coordinator stopAll() drained the pending queue");
@@ -5315,6 +5391,22 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       completed: this.completedResults.length
     };
   }
+  /** Emit a reactive coordinator.stats event on FleetBus so the TUI can subscribe. */
+  emitCoordinatorStats() {
+    const stats = this.getStats();
+    const subagentStatuses = Array.from(this.subagents.entries()).map(([id, s]) => ({
+      subagentId: id,
+      taskId: s.currentTask ?? "",
+      status: s.status,
+      assigned: s.context.parentBridge !== null
+    }));
+    this.fleetBus?.emit({
+      subagentId: this.coordinatorId,
+      ts: Date.now(),
+      type: "coordinator.stats",
+      payload: { ...stats, subagentStatuses }
+    });
+  }
   getStatus() {
     return {
       coordinatorId: this.coordinatorId,
@@ -5489,7 +5581,15 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     subagent.currentTask = task.id;
     task.subagentId = subagentId;
     subagent.context.tasks.push(task);
+    this.fleetBus?.emit({
+      subagentId,
+      taskId: task.id,
+      ts: Date.now(),
+      type: "subagent.running",
+      payload: { subagentId, taskId: task.id }
+    });
     this.emit("task.assigned", { task, subagentId });
+    this.emitCoordinatorStats();
     const rawMaxIterations = subagent.config.maxIterations;
     const rawMaxToolCalls = subagent.config.maxToolCalls;
     const rawMaxTokens = subagent.config.maxTokens;
@@ -5633,13 +5733,34 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       if (subagent.abortController.signal.aborted) {
         subagent.abortController = new AbortController();
       }
+      this.fleetBus?.emit({
+        subagentId: result.subagentId,
+        ts: Date.now(),
+        type: "subagent.idle",
+        payload: { subagentId: result.subagentId }
+      });
     }
     this.terminating.delete(result.subagentId);
     this.emit("task.completed", {
       task: subagent?.context.tasks.find((t) => t.id === result.taskId) ?? { id: result.taskId },
       result
     });
+    this.fleetBus?.emit({
+      subagentId: result.subagentId,
+      taskId: result.taskId,
+      ts: Date.now(),
+      type: "subagent.completed",
+      payload: {
+        subagentId: result.subagentId,
+        taskId: result.taskId,
+        status: result.status,
+        iterations: result.iterations,
+        toolCalls: result.toolCalls,
+        durationMs: result.durationMs
+      }
+    });
     this.tryDispatchNext();
+    this.emitCoordinatorStats();
     if (this.isDone()) {
       this.emit("done", {
         results: this.completedResults,