@wrongstack/core 0.8.0 → 0.8.4

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-Cx2ndr0L.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-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-BciJeH8g.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-Bzeueq2J.js';
-import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-tlSWD4cE.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 {
@@ -204,12 +204,28 @@ declare class AutoCompactionMiddleware {
     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.
+     * Calibration factor applied to the estimator output. The estimator is now
+     * expected to already include messages + system prompt + tool definitions
+     * (see `estimateRequestTokens.total`), so no overhead boost is needed. Kept
+     * as a constant so a future calibration against real provider tokenization
+     * (BPE vs the chars/3.5 rough estimator) can dial this without touching the
+     * threshold-check math.
+     *
+     * Historical note: was 1.3 when the estimator only counted messages — that
+     * double-counted system+tools once the estimator was upgraded, firing
+     * compaction ~30% earlier than intended (e.g. real 56% load showed as 73%).
      */
     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 +246,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;
@@ -1018,12 +1019,28 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   failureMode;
   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.
+   * Calibration factor applied to the estimator output. The estimator is now
+   * expected to already include messages + system prompt + tool definitions
+   * (see `estimateRequestTokens.total`), so no overhead boost is needed. Kept
+   * as a constant so a future calibration against real provider tokenization
+   * (BPE vs the chars/3.5 rough estimator) can dial this without touching the
+   * threshold-check math.
+   *
+   * Historical note: was 1.3 when the estimator only counted messages — that
+   * double-counted system+tools once the estimator was upgraded, firing
+   * compaction ~30% earlier than intended (e.g. real 56% load showed as 73%).
+   */
+  static OVERHEAD_FACTOR = 1;
+  /**
+   * 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 OVERHEAD_FACTOR = 1.3;
+  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 +1082,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,