@wrongstack/core 0.256.1 → 0.257.0

package/dist/defaults/index.d.ts

@@ -3,7 +3,7 @@ export { A as AbandonedSession, a as AttachmentStoreOptions, C as ConfigLoaderOp
 export { D as DefaultSessionReader } from '../session-reader-CqRvaL5v.js';
 export { A as AuditLevel, S as SessionEventBridge, b as SessionEventBridgeOptions, c as SessionSamplingOptions, T as ToolProgressSamplingOptions, d as createSessionEventBridge, r as resolveAuditLevel, e as resolveSessionLoggingConfig } from '../session-event-bridge-BAFWdgQ3.js';
 export { a as DirectorStateCheckpoint, D as DirectorStateSnapshot, b as DirectorSubagentState, c as DirectorTaskState, l as loadDirectorState } from '../director-state-BfeCUbmk.js';
-export { D as DefaultSecretScrubber, a as DefaultSecretVault, S as SecretVaultOptions, d as decryptConfigSecrets, e as encryptConfigSecrets, 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, m as migratePlaintextSecrets, r as rewriteConfigEncrypted } from '../secret-vault-gxtFZYBt.js';
 export { A as AutoApprovePermissionPolicy, D as DefaultPermissionPolicy, P as PermissionPolicyOptions } from '../permission-policy-B8rSu908.js';
 export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, E as EternalAutonomyEngine, c as EternalAutonomyOptions, d as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, e as ParallelEternalEngine, f as ParallelEternalOptions, g as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-C0juOszP.js';
 export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, C as CompactorStrategy, D as DefaultSkillLoader, d as DoneCheckResult, e as DoneConditionChecker, I as IntelligentCompactor, f as IntelligentCompactorOptions, S as SelectiveCompactor, g as SelectiveCompactorOptions, h as SkillLoaderOptions, i as StrategyCompactorOptions, j as buildGoalPreamble, k as createStrategyCompactor, m as makeAutonomyPromptContributor } from '../goal-preamble-UiEkbNmW.js';

package/dist/defaults/index.js

@@ -12,8 +12,13 @@ import { EventEmitter } from 'events';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -3328,7 +3333,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;
@@ -4365,6 +4370,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)
@@ -4406,17 +4415,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) => {
@@ -5854,12 +5873,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;
 }
@@ -5868,13 +5890,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);
@@ -5987,6 +6007,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;
@@ -6003,37 +6042,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;
@@ -6059,7 +6139,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) {