@wrongstack/core 0.256.0 → 0.257.0

package/dist/types/index.d.ts

@@ -6,7 +6,7 @@ export { a as PermissionDecision, P as PermissionPolicy, T as TrustPolicy } from
 export { C as CheckpointInfo, R as RewindResult, a as RewindResultExtended, S as SessionRewinder } from '../session-rewinder-C9HnMkhP.js';
 export { a as AddAttachmentInput, c as Attachment, d as AttachmentKind, e as AttachmentMeta, b as AttachmentRef, A as AttachmentStore, D as DefaultSessionReader } from '../session-reader-CqRvaL5v.js';
 export { D as DEFAULT_AUTONOMY_CONFIG, a as DEFAULT_CONTEXT_CONFIG, b as DEFAULT_SESSION_LOGGING_CONFIG, c as DEFAULT_SESSION_PRUNE_DAYS, d as DEFAULT_TOOLS_CONFIG } from '../default-config-CXsDvOmP.js';
-export { D as DefaultSecretScrubber, a as DefaultSecretVault, S as SecretVaultOptions, d as decryptConfigSecrets, e as encryptConfigSecrets, i as isSecretField, m as migratePlaintextSecrets, r as rewriteConfigEncrypted } from '../secret-vault-BkYkJWQs.js';
+export { D as DefaultSecretScrubber, a as DefaultSecretVault, S as SecretVaultOptions, d as decryptConfigSecrets, e as encryptConfigSecrets, i as isSecretField, m as migratePlaintextSecrets, r as rewriteConfigEncrypted } from '../secret-vault-gxtFZYBt.js';
 export { D as DefaultLogger, a as DefaultLoggerOptions, L as LogFormat, n as noOpLogger } from '../logger-DmmQhf4P.js';
 export { D as DefaultPathResolver, a as DefaultTokenCounter } from '../path-resolver-CbkT-RMU.js';
 export { p as MEMORY_TYPE_LABELS, q as MemoryClearedPayload, r as MemoryConsolidatedPayload, k as MemoryEntry, s as MemoryForgottenPayload, t as MemoryPriority, m as MemoryRelevanceContext, u as MemoryRememberedPayload, M as MemoryScope, l as MemoryStore, v as MemoryType, S as ScoredEntry } from '../brain-TjEEwSpw.js';

package/dist/types/index.js

@@ -1098,16 +1098,6 @@ var MEMORY_TYPE_LABELS = {
   anti_pattern: "Anti-pattern"
 };
 
-// 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__";
@@ -1126,12 +1116,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;
 }
@@ -1140,13 +1133,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);
@@ -1231,6 +1222,16 @@ function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = C
   };
 }
 
+// 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 = [];
@@ -1324,6 +1325,25 @@ function isEmptyMessage(msg) {
 }
 
 // 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;
@@ -1340,37 +1360,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;
@@ -1396,7 +1457,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) {
@@ -1921,6 +2008,10 @@ var PATTERNS = [
     regex: /(?:^|\s)([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?(?:\s|$)/g
   }
 ];
+var SIMPLE_PATTERNS = PATTERNS.filter((p) => p.type !== "high_entropy_env");
+var COMBINED_REGEX = new RegExp(SIMPLE_PATTERNS.map((p) => `(${p.regex.source})`).join("|"), "g");
+var HIGH_ENTROPY_REGEX = PATTERNS.find((p) => p.type === "high_entropy_env").regex;
+var COMBINED_REPLACEMENTS = SIMPLE_PATTERNS.map((p) => `[REDACTED:${p.type}]`);
 var SCRUB_CHUNK_BYTES = 64 * 1024;
 function hasCredentialAnchors(text) {
   return text.includes("-----BEGIN") || // Private keys (most unique → cheap reject)
@@ -1962,17 +2053,27 @@ var DefaultSecretScrubber = class {
   }
   scrubOne(text) {
     if (!hasCredentialAnchors(text)) return text;
-    let out = text;
-    for (const p of PATTERNS) {
-      out = out.replace(p.regex, (_match, group1, group2) => {
-        if (p.type === "high_entropy_env" && group1 && group2) {
-          return `${group1}=[REDACTED:${p.type}]`;
-        }
-        return `[REDACTED:${p.type}]`;
-      });
-    }
+    let out = text.replace(
+      COMBINED_REGEX,
+      (match, ...groups) => {
+        const idx = groups.findIndex((g) => g !== void 0);
+        if (idx < 0) return match;
+        const replacement = COMBINED_REPLACEMENTS[idx];
+        return replacement !== void 0 ? replacement : match;
+      }
+    );
+    out = out.replace(HIGH_ENTROPY_REGEX, (_match, group1, _group2) => {
+      return `${group1}=[REDACTED:high_entropy_env]`;
+    });
     return out;
   }
+  /**
+   * Recursively scrub every string value in an object/array graph. Secrets can
+   * appear under any key — a URL query param, an `authorization` header, an
+   * arbitrarily-named nested field — so we don't gate recursion on key names.
+   * The per-string `scrub()` fast-path (anchor pre-scan) keeps this cheap: any
+   * value without a credential anchor returns immediately without regex work.
+   */
   scrubObject(obj) {
     const seen = /* @__PURE__ */ new WeakSet();
     const visit = (v) => {
@@ -3688,12 +3789,12 @@ var ConversationState = class {
     for (const m of messages) {
       if (m._estTokens === void 0) {
         m._estTokens = computeMessageTokens(m);
-      }
-      if (!hasToolBlock && Array.isArray(m.content)) {
-        for (const b of m.content) {
-          if (b.type === "tool_use" || b.type === "tool_result") {
-            hasToolBlock = true;
-            break;
+        if (Array.isArray(m.content)) {
+          for (const b of m.content) {
+            if (b.type === "tool_use" || b.type === "tool_result") {
+              hasToolBlock = true;
+              break;
+            }
           }
         }
       }
@@ -3949,7 +4050,7 @@ var DefaultSessionReader = class {
     this.store = opts.store;
   }
   async query(q = {}) {
-    const raw = await this.store.list(q.limit ? Math.max(q.limit * 4, 100) : 1e3);
+    const raw = await this.store.list(q.limit ? Math.max(q.limit, 100) : 1e3);
     const titleNeedle = q.titleContains?.toLowerCase();
     const filtered = raw.filter((s) => {
       if (q.since && s.startedAt < q.since) return false;