@wrongstack/core 0.256.0 → 0.257.0

package/dist/execution/index.js

@@ -6,16 +6,6 @@ import * as path2 from 'path';
 import * as os from 'os';
 import { EventEmitter } from 'events';
 
-// src/utils/expect-defined.ts
-function expectDefined(value, label) {
-  if (value === null || value === void 0) {
-    const err = new Error("Expected value to be defined");
-    err.name = "ExpectDefinedError";
-    throw err;
-  }
-  return value;
-}
-
 // src/utils/token-estimate.ts
 var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
 var CALIBRATION_GLOBAL_KEY = "__global__";
@@ -35,12 +25,15 @@ function getCachedEstimate(key, compute) {
   const existing = ESTIMATE_CACHE.get(key);
   if (existing !== void 0) return existing;
   if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
-    const keys = [...ESTIMATE_CACHE.keys()];
-    for (let i = 0; i < Math.floor(ESTIMATE_CACHE_MAX_SIZE / 4); i++) {
-      ESTIMATE_CACHE.delete(expectDefined(keys[i]));
+    let evicted = 0;
+    const maxEvict = Math.floor(ESTIMATE_CACHE_MAX_SIZE / 4);
+    for (const k of ESTIMATE_CACHE.keys()) {
+      if (evicted >= maxEvict) break;
+      ESTIMATE_CACHE.delete(k);
+      evicted++;
     }
   }
-  const estimate = compute();
+  const estimate = compute(key);
   ESTIMATE_CACHE.set(key, estimate);
   return estimate;
 }
@@ -49,13 +42,11 @@ function estimateToolInputTokens(input) {
   if (input === null || typeof input !== "object") {
     return RoughTokenEstimate(String(input));
   }
-  const key = JSON.stringify(input);
-  return getCachedEstimate(key, () => RoughTokenEstimate(key));
+  return getCachedEstimate(JSON.stringify(input), (key) => RoughTokenEstimate(key));
 }
 function estimateToolResultTokens(content) {
   if (typeof content === "string") return RoughTokenEstimate(content);
-  const key = JSON.stringify(content);
-  return getCachedEstimate(key, () => RoughTokenEstimate(key));
+  return getCachedEstimate(JSON.stringify(content), (key) => RoughTokenEstimate(key));
 }
 function estimateTextTokens(text) {
   return RoughTokenEstimate(text);
@@ -162,6 +153,16 @@ function estimateRequestTokensCalibrated(messages, systemPrompt, tools, calibrat
   return result;
 }
 
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
+  if (value === null || value === void 0) {
+    const err = new Error("Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
+  }
+  return value;
+}
+
 // src/utils/message-invariants.ts
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
@@ -260,6 +261,25 @@ function isTextBlock(b) {
 }
 
 // src/execution/compaction-core.ts
+function emitCompactionMetrics(event, metrics) {
+  console.log(
+    JSON.stringify({
+      level: "debug",
+      event,
+      messageCount: metrics.messageCount,
+      preserveStart: metrics.preserveStart,
+      fastPathIterations: metrics.fastPathIterations,
+      fastPathInnerIterations: metrics.fastPathInnerIterations,
+      // Ratios — anything > 2.0 indicates the inner loop is running more than expected
+      fastPathInnerPerOuter: metrics.fastPathIterations > 0 ? metrics.fastPathInnerIterations / metrics.fastPathIterations : 0,
+      fullPassIterations: metrics.fullPassIterations,
+      fullPassInnerIterations: metrics.fullPassInnerIterations,
+      fullPassInnerPerOuter: metrics.fullPassIterations > 0 ? metrics.fullPassInnerIterations / metrics.fullPassIterations : 0,
+      tokensSaved: metrics.tokensSaved,
+      changed: metrics.changed
+    })
+  );
+}
 var estimateMessages = estimateMessageTokens;
 function hasTextContent(m) {
   if (typeof m.content === "string") return m.content.trim().length > 0;
@@ -276,37 +296,78 @@ function findPreserveStart(messages, preserveK) {
       preserveStart = i;
     }
   }
+  let forwardWalkIterations = 0;
+  let forwardWalkInnerIterations = 0;
   for (let i = preserveStart; i < messages.length; i++) {
+    forwardWalkIterations++;
     const m = messages[i];
     if (!m || typeof m.content === "string" || !Array.isArray(m.content)) continue;
-    const hasToolUse3 = m.content.some((b) => b.type === "tool_use");
+    const hasToolUse3 = m.content.some((b) => {
+      forwardWalkInnerIterations++;
+      return b.type === "tool_use";
+    });
     if (hasToolUse3 && i + 1 < messages.length) {
       const next = messages[i + 1];
-      if (next && next.role === "user" && typeof next.content !== "string" && Array.isArray(next.content) && next.content.some((b) => b.type === "tool_result")) {
+      if (next && next.role === "user" && typeof next.content !== "string" && Array.isArray(next.content) && next.content.some((b) => {
+        forwardWalkInnerIterations++;
+        return b.type === "tool_result";
+      })) {
         preserveStart = i + 1;
       }
     }
   }
+  console.log(
+    JSON.stringify({
+      level: "debug",
+      event: "compaction.find_preserve_start.ended",
+      messageCount: messages.length,
+      preserveK,
+      preserveStart,
+      forwardWalkIterations,
+      forwardWalkInnerIterations,
+      forwardWalkInnerPerOuter: forwardWalkIterations > 0 ? forwardWalkInnerIterations / forwardWalkIterations : 0
+    })
+  );
   return preserveStart;
 }
 function eliseOldToolResults(messages, opts) {
   const preserveStart = findPreserveStart(messages, opts.preserveK);
   let hasOversized = false;
+  let fastPathIterations = 0;
+  let fastPathInnerIterations = 0;
   for (let i = 0; i < preserveStart && !hasOversized; i++) {
+    fastPathIterations++;
     const msg = messages[i];
     if (!msg || !Array.isArray(msg.content)) continue;
     for (const b of msg.content) {
+      fastPathInnerIterations++;
       if (b.type === "tool_result" && estimateToolResultTokens(b.content) >= opts.eliseThreshold) {
         hasOversized = true;
         break;
       }
     }
   }
+  emitCompactionMetrics(
+    hasOversized ? "compaction.elision.fast_path.oversized_found" : "compaction.elision.fast_path.no_oversized",
+    {
+      messageCount: messages.length,
+      preserveStart,
+      fastPathIterations,
+      fastPathInnerIterations,
+      fullPassIterations: 0,
+      fullPassInnerIterations: 0,
+      tokensSaved: 0,
+      changed: false
+    }
+  );
   if (!hasOversized) return { messages, saved: 0, changed: false };
   let saved = 0;
   let changed = false;
+  let fullPassIterations = 0;
+  let fullPassInnerIterations = 0;
   const next = new Array(messages.length);
   for (let i = 0; i < messages.length; i++) {
+    fullPassIterations++;
     const msg = messages[i];
     if (i >= preserveStart || !msg || !Array.isArray(msg.content)) {
       next[i] = msg;
@@ -332,7 +393,33 @@ function eliseOldToolResults(messages, opts) {
       next[i] = { ...msg, content: newContent };
       changed = true;
     }
+    fullPassInnerIterations += original.length;
+    if (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1") {
+      const ratio = fullPassInnerIterations / fullPassIterations;
+      if (ratio > 10) {
+        console.error(
+          JSON.stringify({
+            level: "error",
+            event: "compaction.elision.regression",
+            message: `fullPassInnerPerOuter=${ratio.toFixed(2)} exceeds threshold 10 \u2014 possible O(n\xB7m) regression`,
+            messageCount: messages.length,
+            fullPassIterations,
+            fullPassInnerIterations
+          })
+        );
+      }
+    }
   }
+  emitCompactionMetrics("compaction.elision.full_pass.ended", {
+    messageCount: messages.length,
+    preserveStart,
+    fastPathIterations,
+    fastPathInnerIterations,
+    fullPassIterations,
+    fullPassInnerIterations,
+    tokensSaved: saved,
+    changed
+  });
   return { messages: changed ? next : messages, saved, changed };
 }
 function buildLosslessDigest(messages) {