@wrongstack/core 0.109.1 → 0.141.0

package/dist/execution/index.js

@@ -16,6 +16,17 @@ function expectDefined(value, label) {
 
 // src/utils/token-estimate.ts
 var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
+var CALIBRATION_GLOBAL_KEY = "__global__";
+var _cals = /* @__PURE__ */ new Map();
+function calState(key) {
+  let state = _cals.get(key);
+  if (!state) {
+    state = { ratio: 1, count: 0, prevEst: 0 };
+    _cals.set(key, state);
+  }
+  return state;
+}
+var MIN_SAMPLES_FOR_CALIBRATION = 3;
 var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
 var ESTIMATE_CACHE_MAX_SIZE = 1e4;
 function getCachedEstimate(key, compute) {
@@ -47,10 +58,25 @@ function estimateToolResultTokens(content) {
 function estimateTextTokens(text) {
   return RoughTokenEstimate(text);
 }
+function estimateMessageTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      total += estimateTextTokens(m.content);
+    } else {
+      for (const b of m.content) {
+        if (b.type === "text") total += estimateTextTokens(b.text);
+        else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
+        else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
+      }
+    }
+  }
+  return total;
+}
 function estimateToolDefTokens(tool) {
   return RoughTokenEstimate(tool.name) + RoughTokenEstimate(tool.description ?? "") + RoughTokenEstimate(JSON.stringify(tool.inputSchema));
 }
-function estimateRequestTokens(messages, systemPrompt, tools) {
+function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
   let messagesTokens = 0;
   if (typeof messages === "string") {
     messagesTokens = RoughTokenEstimate(messages);
@@ -89,6 +115,7 @@ function estimateRequestTokens(messages, systemPrompt, tools) {
     toolsTokens += estimateToolDefTokens(t);
   }
   const total = messagesTokens + systemTokens + toolsTokens;
+  calState(calibrationKey).prevEst = total;
   return {
     messages: messagesTokens,
     systemPrompt: systemTokens,
@@ -96,8 +123,18 @@ function estimateRequestTokens(messages, systemPrompt, tools) {
     total
   };
 }
-function estimateRequestTokensCalibrated(messages, systemPrompt, tools) {
-  const result = estimateRequestTokens(messages, systemPrompt, tools);
+function estimateRequestTokensCalibrated(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  const result = estimateRequestTokens(messages, systemPrompt, tools, calibrationKey);
+  const cal = calState(calibrationKey);
+  if (cal.count >= MIN_SAMPLES_FOR_CALIBRATION) {
+    const safeRatio = Math.min(1.5, Math.max(0.5, cal.ratio));
+    return {
+      messages: Math.round(result.messages * safeRatio),
+      systemPrompt: Math.round(result.systemPrompt * safeRatio),
+      tools: Math.round(result.tools * safeRatio),
+      total: Math.round(result.total * safeRatio)
+    };
+  }
   return result;
 }
 
@@ -193,34 +230,149 @@ function isEmptyMessage(msg) {
   return msg.content.length === 0;
 }
 
+// src/types/blocks.ts
+function isTextBlock(b) {
+  return b.type === "text";
+}
+
+// src/execution/compaction-core.ts
+var estimateMessages = estimateMessageTokens;
+function hasTextContent(m) {
+  if (typeof m.content === "string") return m.content.trim().length > 0;
+  return m.content.some((b) => b.type === "text" && b.text.trim().length > 0);
+}
+function findPreserveStart(messages, preserveK) {
+  let pairCount = 0;
+  let preserveStart = messages.length;
+  for (let i = messages.length - 1; i >= 0 && pairCount < preserveK; i--) {
+    const m = messages[i];
+    if (!m) continue;
+    if (m.role === "user" || m.role === "assistant") {
+      pairCount++;
+      preserveStart = i;
+    }
+  }
+  for (let i = preserveStart; i < messages.length; i++) {
+    const m = messages[i];
+    if (!m || typeof m.content === "string" || !Array.isArray(m.content)) continue;
+    const hasToolUse2 = m.content.some((b) => b.type === "tool_use");
+    if (hasToolUse2 && 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")) {
+        preserveStart = i + 1;
+      }
+    }
+  }
+  return preserveStart;
+}
+function eliseOldToolResults(messages, opts) {
+  const preserveStart = findPreserveStart(messages, opts.preserveK);
+  let saved = 0;
+  let changed = false;
+  const next = new Array(messages.length);
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (i >= preserveStart || !msg || !Array.isArray(msg.content)) {
+      next[i] = msg;
+      continue;
+    }
+    const original = msg.content;
+    const newContent = original.map((b) => {
+      if (b.type !== "tool_result") return b;
+      const tokens = estimateToolResultTokens(b.content);
+      if (tokens < opts.eliseThreshold) return b;
+      saved += tokens;
+      const elided = {
+        type: "tool_result",
+        tool_use_id: b.tool_use_id,
+        content: `[elided: ~${tokens} tokens]`,
+        is_error: b.is_error
+      };
+      return elided;
+    });
+    if (newContent.every((b, idx) => b === original[idx])) {
+      next[i] = msg;
+    } else {
+      next[i] = { ...msg, content: newContent };
+      changed = true;
+    }
+  }
+  return { messages: changed ? next : messages, saved, changed };
+}
+function buildLosslessDigest(messages) {
+  const lines = [];
+  for (const m of messages) {
+    let text;
+    let omitted = 0;
+    if (typeof m.content === "string") {
+      text = m.content;
+    } else {
+      const parts = [];
+      for (const b of m.content) {
+        if (isTextBlock(b)) parts.push(b.text);
+        else if (b.type === "tool_use" || b.type === "tool_result") omitted++;
+      }
+      text = parts.join(" ");
+    }
+    if (text.trim().length === 0 && omitted === 0) continue;
+    const marker = omitted > 0 ? ` [${omitted} tool call(s) omitted \u2014 see session log]` : "";
+    lines.push(`[${m.role}]: ${text}${marker}`);
+  }
+  return lines.join("\n");
+}
+function findSafeBoundary(messages, from, to) {
+  for (let i = to; i >= from; i--) {
+    const m = messages[i];
+    if (!m) continue;
+    if (m.role === "user" && hasTextContent(m)) {
+      return findExchangeStart(messages, i);
+    }
+  }
+  return -1;
+}
+function findExchangeStart(messages, userIndex) {
+  for (let i = userIndex - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (!m) continue;
+    if (m.role === "assistant") {
+      const hasToolUse2 = Array.isArray(m.content) ? m.content.some((b) => b.type === "tool_use") : false;
+      if (!hasToolUse2) return i + 1;
+    } else if (m.role === "user") {
+      return i;
+    }
+  }
+  return 0;
+}
+
 // src/execution/compactor.ts
 var HybridCompactor = class {
   preserveK;
   eliseThreshold;
-  estimator;
   constructor(opts = {}) {
     this.preserveK = opts.preserveK ?? 5;
     this.eliseThreshold = opts.eliseThreshold ?? 2e3;
-    this.estimator = opts.estimator ?? estimateTextTokens;
   }
   async compact(ctx, opts = {}) {
-    const beforeTokens = this.estimateMessages(ctx.messages);
+    const beforeTokens = estimateMessages(ctx.messages);
     const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
     const policy = readContextWindowPolicy(ctx);
     const preserveK = policy?.preserveK ?? this.preserveK;
     const eliseThreshold = policy?.eliseThreshold ?? this.eliseThreshold;
-    const phase1Saved = this.eliseOldToolResults(ctx, preserveK, eliseThreshold);
-    if (phase1Saved > 0) reductions.push({ phase: "elision", saved: phase1Saved });
+    const elide = eliseOldToolResults(ctx.messages, { preserveK, eliseThreshold });
+    if (elide.changed) ctx.state.replaceMessages(elide.messages);
+    if (elide.saved > 0) reductions.push({ phase: "elision", saved: elide.saved });
+    let collapsedDigest;
     if (opts.aggressive) {
-      const phase2Saved = this.collapseAncientTurns(ctx, preserveK);
-      if (phase2Saved > 0) reductions.push({ phase: "summary", saved: phase2Saved });
+      const phase2 = this.collapseAncientTurns(ctx, preserveK);
+      if (phase2.saved > 0) reductions.push({ phase: "summary", saved: phase2.saved });
+      collapsedDigest = phase2.digest;
     }
     const repaired = repairToolUseAdjacency(ctx.messages);
     if (repaired.report.changed) {
       ctx.state.replaceMessages(repaired.messages);
     }
-    const afterTokens = this.estimateMessages(ctx.messages);
+    const afterTokens = estimateMessages(ctx.messages);
     const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
@@ -228,6 +380,7 @@ var HybridCompactor = class {
       fullRequestTokensBefore: beforeFull,
       fullRequestTokensAfter: afterFull,
       reductions,
+      collapsedDigest,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
         removedToolResults: repaired.report.removedToolResults,
@@ -240,72 +393,23 @@ var HybridCompactor = class {
    * This is the accurate figure for context-window pressure monitoring.
    */
   estimateFullRequest(ctx) {
-    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
-    return breakdown.total;
-  }
-  eliseOldToolResults(ctx, preserveK = this.preserveK, eliseThreshold = this.eliseThreshold) {
-    const messages = ctx.messages;
-    let pairCount = 0;
-    let preserveStart = messages.length;
-    for (let i = messages.length - 1; i >= 0 && pairCount < preserveK; i--) {
-      const m = messages[i];
-      if (!m) continue;
-      if (m.role === "user" || m.role === "assistant") {
-        pairCount++;
-        preserveStart = i;
-      }
-    }
-    for (let i = preserveStart; i < messages.length; i++) {
-      const m = messages[i];
-      if (!m || typeof m.content === "string" || !Array.isArray(m.content)) continue;
-      const hasToolUse2 = m.content.some((b) => b.type === "tool_use");
-      if (hasToolUse2 && 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")) {
-          preserveStart = i + 1;
-        }
-      }
-    }
-    let saved = 0;
-    let changed = false;
-    const nextMessages = new Array(messages.length);
-    for (let i = 0; i < messages.length; i++) {
-      const msg = messages[i];
-      if (i >= preserveStart) {
-        nextMessages[i] = msg;
-        continue;
-      }
-      if (!msg || !Array.isArray(msg.content)) {
-        nextMessages[i] = msg;
-        continue;
-      }
-      const newContent = msg.content.map((b) => {
-        if (b.type !== "tool_result") return b;
-        const tokens = estimateToolResultTokens(b.content);
-        if (tokens < eliseThreshold) return b;
-        saved += tokens;
-        const elided = {
-          type: "tool_result",
-          tool_use_id: b.tool_use_id,
-          content: `[elided: ~${tokens} tokens]`,
-          is_error: b.is_error
-        };
-        return elided;
-      });
-      if (newContent.length === msg.content.length && newContent.every((b, idx) => b === msg.content[idx])) {
-        nextMessages[i] = msg;
-      } else {
-        nextMessages[i] = { ...msg, content: newContent };
-        changed = true;
-      }
-    }
-    if (changed) ctx.state.replaceMessages(nextMessages);
-    return saved;
+    return estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []).total;
   }
+  /**
+   * Lossless rule-based collapse of ancient turns into a single digest message.
+   *
+   * Preserves ALL textual content of the collapsed range — user instructions,
+   * assistant decisions/conclusions, and any prior digests (chained forward so
+   * the digest stays lossless across repeated compactions). Only `tool_use` /
+   * `tool_result` protocol blocks are dropped and replaced with a count marker;
+   * their full payload already lives in the session log. No sub-LLM call.
+   *
+   * Returns the token savings and the digest text (for audit logging).
+   */
   collapseAncientTurns(ctx, preserveK = this.preserveK) {
     const messages = ctx.messages;
     const cutTarget = Math.max(0, messages.length - preserveK * 2);
-    if (cutTarget <= 0) return 0;
+    if (cutTarget <= 0) return { saved: 0 };
     let boundary = -1;
     for (let i = cutTarget; i < messages.length; i++) {
       const m = messages[i];
@@ -315,34 +419,20 @@ var HybridCompactor = class {
         break;
       }
     }
-    if (boundary <= 0) return 0;
+    if (boundary <= 0) return { saved: 0 };
     const removed = messages.slice(0, boundary);
-    const removedTokens = this.estimateMessages(removed);
-    const summary = [
-      {
-        role: "user",
-        content: `[previous_session_summary: ${removed.length} earlier turns compacted. Todo state preserved in context.]`
-      },
-      { role: "assistant", content: "Continuing from compacted context." }
-    ];
+    const removedTokens = estimateMessages(removed);
+    const digest = buildLosslessDigest(removed) || `${removed.length} earlier turns (no textual content; tool I/O omitted \u2014 see session log)`;
+    const summaryMsg = {
+      role: "system",
+      content: `[prior_turns_digest: ${digest}]`
+    };
     const tail = ctx.messages.slice(boundary);
-    ctx.state.replaceMessages([...summary, ...tail]);
-    return Math.max(0, removedTokens - this.estimateMessages(summary));
-  }
-  estimateMessages(messages) {
-    let total = 0;
-    for (const m of messages) {
-      if (typeof m.content === "string") {
-        total += this.estimator(m.content);
-      } else {
-        for (const b of m.content) {
-          if (b.type === "text") total += this.estimator(b.text);
-          else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
-          else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
-        }
-      }
-    }
-    return total;
+    ctx.state.replaceMessages([summaryMsg, ...tail]);
+    return {
+      saved: Math.max(0, removedTokens - estimateMessages([summaryMsg])),
+      digest
+    };
   }
 };
 function readContextWindowPolicy(ctx) {
@@ -354,15 +444,6 @@ function readContextWindowPolicy(ctx) {
   }
   return candidate;
 }
-function hasTextContent(m) {
-  if (typeof m.content === "string") return m.content.trim().length > 0;
-  return m.content.some((b) => b.type === "text" && b.text.trim().length > 0);
-}
-
-// src/types/blocks.ts
-function isTextBlock(b) {
-  return b.type === "text";
-}
 
 // src/execution/intelligent-compactor.ts
 var IntelligentCompactor = class {
@@ -387,23 +468,25 @@ var IntelligentCompactor = class {
     this.summarizerModel = opts.summarizerModel;
   }
   async compact(ctx, opts = {}) {
-    const beforeTokens = this.estimateTokens(ctx.messages);
+    const beforeTokens = estimateMessages(ctx.messages);
     const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
     const load = beforeFull / this.maxContext;
     const aggressive = load >= this.hardThreshold ? true : opts.aggressive ?? load >= this.softThreshold;
-    const saved1 = this.eliseOldToolResults(ctx);
+    const saved1 = this.elide(ctx);
     if (saved1 > 0) reductions.push({ phase: "elision", saved: saved1 });
+    let collapsedDigest;
     if (aggressive) {
-      const saved2 = await this.summarizeAncientTurns(ctx);
-      if (saved2 > 0) reductions.push({ phase: "summary", saved: saved2 });
+      const phase2 = await this.summarizeAncientTurns(ctx);
+      if (phase2.saved > 0) reductions.push({ phase: "summary", saved: phase2.saved });
+      collapsedDigest = phase2.digest;
     } else if (load >= this.warnThreshold) {
-      const saved2 = this.lightweightCompact(ctx);
+      const saved2 = this.elide(ctx);
       if (saved2 > 0) reductions.push({ phase: "elision", saved: saved2 });
     }
     const repaired = repairToolUseAdjacency(ctx.messages);
     if (repaired.report.changed) ctx.state.replaceMessages(repaired.messages);
-    const afterTokens = this.estimateTokens(ctx.messages);
+    const afterTokens = estimateMessages(ctx.messages);
     const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
@@ -411,6 +494,7 @@ var IntelligentCompactor = class {
       fullRequestTokensBefore: beforeFull,
       fullRequestTokensAfter: afterFull,
       reductions,
+      collapsedDigest,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
         removedToolResults: repaired.report.removedToolResults,
@@ -423,75 +507,39 @@ var IntelligentCompactor = class {
    * This is the accurate figure for context-window pressure monitoring.
    */
   estimateFullRequest(ctx) {
-    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
-    return breakdown.total;
+    return estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []).total;
+  }
+  /** Run shared tool-result elision and commit through ConversationState. */
+  elide(ctx) {
+    const result = eliseOldToolResults(ctx.messages, {
+      preserveK: this.preserveK,
+      eliseThreshold: this.eliseThreshold
+    });
+    if (result.changed) ctx.state.replaceMessages(result.messages);
+    return result.saved;
   }
   async summarizeAncientTurns(ctx) {
     const messages = ctx.messages;
     const cutoff = Math.max(0, messages.length - this.preserveK * 2);
-    if (cutoff <= 2) return 0;
-    const boundary = this.findSafeBoundary(messages, 0, cutoff);
-    if (boundary <= 1) return 0;
+    if (cutoff <= 2) return { saved: 0 };
+    const boundary = findSafeBoundary(messages, 0, cutoff);
+    if (boundary <= 1) return { saved: 0 };
     const toSummarize = messages.slice(0, boundary);
-    const removedTokens = this.estimateTokens(toSummarize);
+    const removedTokens = estimateMessages(toSummarize);
     let summaryText;
     try {
       summaryText = await this.callSummarizer(toSummarize, ctx);
     } catch {
-      const preservedMessages = [];
-      for (const m of toSummarize) {
-        if (m.role === "system") continue;
-        if (typeof m.content === "string") {
-          preservedMessages.push(m);
-        } else if (Array.isArray(m.content)) {
-          const textParts = m.content.filter(isTextBlock);
-          const toolParts = m.content.filter((b) => b.type === "tool_use" || b.type === "tool_result");
-          const next = {
-            role: m.role,
-            content: [
-              ...textParts,
-              ...toolParts.length > 0 ? [{ type: "text", text: `[${toolParts.length} tool call(s) omitted]` }] : []
-            ]
-          };
-          preservedMessages.push(next);
-        }
-      }
-      summaryText = preservedMessages.map((m) => `[${m.role}]: ${typeof m.content === "string" ? m.content : m.content.filter(isTextBlock).map((b) => b.text).join(" ")}`).join("\n");
-      if (!summaryText) summaryText = `${toSummarize.length} earlier turns (semantic content preserved)`;
+      summaryText = buildLosslessDigest(toSummarize) || `${toSummarize.length} earlier turns (semantic content preserved)`;
     }
     const summaryMsg = {
       role: "system",
       content: `[prior_turns_summary: ${summaryText}]`
     };
-    const summaryTokens = this.estimateTokens([summaryMsg]);
+    const summaryTokens = estimateMessages([summaryMsg]);
     const tail = ctx.messages.slice(boundary);
     ctx.state.replaceMessages([summaryMsg, ...tail]);
-    return Math.max(0, removedTokens - summaryTokens);
-  }
-  findSafeBoundary(messages, from, to) {
-    for (let i = to; i >= from; i--) {
-      const m = messages[i];
-      if (!m) continue;
-      if (m.role === "user" && this.hasTextContent(m)) {
-        return this.findExchangeStart(messages, i);
-      }
-    }
-    return -1;
-  }
-  findExchangeStart(messages, userIndex) {
-    for (let i = userIndex - 1; i >= 0; i--) {
-      const m = messages[i];
-      if (!m) continue;
-      if (m.role === "assistant") {
-        const hasToolUse2 = Array.isArray(m.content) ? m.content.some((b) => b.type === "tool_use") : false;
-        if (!hasToolUse2) {
-          return i + 1;
-        }
-      } else if (m.role !== "user") ; else {
-        return i;
-      }
-    }
-    return 0;
+    return { saved: Math.max(0, removedTokens - summaryTokens), digest: summaryText };
   }
   async callSummarizer(messages, ctx) {
     const prompt = [
@@ -526,86 +574,6 @@ var IntelligentCompactor = class {
     }
     return [{ type: "text", text: lines.join("\n") }];
   }
-  lightweightCompact(ctx) {
-    return this.eliseOldToolResults(ctx);
-  }
-  eliseOldToolResults(ctx) {
-    const messages = ctx.messages;
-    let pairCount = 0;
-    let preserveStart = messages.length;
-    for (let i = messages.length - 1; i >= 0 && pairCount < this.preserveK; i--) {
-      const m = messages[i];
-      if (!m) continue;
-      if (m.role === "user" || m.role === "assistant") {
-        pairCount++;
-        preserveStart = i;
-      }
-    }
-    for (let i = preserveStart; i < messages.length; i++) {
-      const m = messages[i];
-      if (!m || typeof m.content === "string" || !Array.isArray(m.content)) continue;
-      const hasToolUse2 = m.content.some((b) => b.type === "tool_use");
-      if (hasToolUse2 && 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")) {
-          preserveStart = i + 1;
-        }
-      }
-    }
-    let saved = 0;
-    let changed = false;
-    const nextMessages = new Array(messages.length);
-    for (let i = 0; i < messages.length; i++) {
-      const msg = messages[i];
-      if (i >= preserveStart) {
-        nextMessages[i] = msg;
-        continue;
-      }
-      if (!msg || !Array.isArray(msg.content)) {
-        nextMessages[i] = msg;
-        continue;
-      }
-      const newContent = msg.content.map((b) => {
-        if (b.type !== "tool_result") return b;
-        const tokens = estimateToolResultTokens(b.content);
-        if (tokens < this.eliseThreshold) return b;
-        saved += tokens;
-        return {
-          type: "tool_result",
-          tool_use_id: b.tool_use_id,
-          content: `[elided: ~${tokens} tokens]`,
-          is_error: b.is_error
-        };
-      });
-      if (newContent.length === msg.content.length && newContent.every((b, idx) => b === msg.content[idx])) {
-        nextMessages[i] = msg;
-      } else {
-        nextMessages[i] = { ...msg, content: newContent };
-        changed = true;
-      }
-    }
-    if (changed) ctx.state.replaceMessages(nextMessages);
-    return saved;
-  }
-  hasTextContent(m) {
-    if (typeof m.content === "string") return m.content.trim().length > 0;
-    return m.content.some((b) => b.type === "text" && b.text.trim().length > 0);
-  }
-  estimateTokens(messages) {
-    let total = 0;
-    for (const m of messages) {
-      if (typeof m.content === "string") {
-        total += estimateTextTokens(m.content);
-      } else {
-        for (const b of m.content) {
-          if (b.type === "text") total += estimateTextTokens(b.text);
-          else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
-          else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
-        }
-      }
-    }
-    return total;
-  }
 };
 
 // src/models/llm-selector.ts
@@ -631,20 +599,6 @@ Rules:
 - If unsure, keep rather than collapse (errors are more costly than waste)
 
 Return ONLY the JSON object, no markdown, no explanation outside the JSON.`;
-function estimateTokens(messages) {
-  let total = 0;
-  for (const m of messages) {
-    if (typeof m.content === "string") {
-      total += Math.ceil(m.content.length / 4);
-    } else if (Array.isArray(m.content)) {
-      for (const b of m.content) {
-        if (b.type === "text") total += Math.ceil(b.text.length / 4);
-        else total += Math.ceil(JSON.stringify(b).length / 4);
-      }
-    }
-  }
-  return total;
-}
 function formatMessages(messages, maxChars = 8e3) {
   const lines = [];
   let used = 0;
@@ -683,7 +637,7 @@ var LLMSelector = class {
   async select(messages, maxToKeep) {
     const effectiveBudget = Math.min(maxToKeep, this.maxContextTokens);
     const historyText = formatMessages(messages);
-    const totalTokens = estimateTokens(messages);
+    const totalTokens = estimateMessageTokens(messages);
     const systemText = `${this.systemPrompt}
 
 Conversation (${messages.length} messages, ~${totalTokens} tokens, budget: ${effectiveBudget}):
@@ -715,10 +669,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
     let startIdx = 0;
     for (let i = messages.length - 1; i >= 0; i--) {
       const m = expectDefined(messages[i]);
-      const cost = typeof m.content === "string" ? Math.ceil(m.content.length / 4) : m.content.reduce(
-        (acc, b) => acc + (b.type === "text" ? Math.ceil(b.text.length / 4) : Math.ceil(JSON.stringify(b).length / 4)),
-        0
-      );
+      const cost = estimateMessageTokens([m]);
       if (tokenCount + cost <= budget) {
         tokenCount += cost;
       } else {
@@ -951,52 +902,12 @@ Summarize the following message range:`;
     return Math.floor(this.maxContext * 0.75);
   }
   eliseOldToolResults(ctx) {
-    const messages = ctx.messages;
-    let pairCount = 0;
-    let preserveStart = messages.length;
-    for (let i = messages.length - 1; i >= 0 && pairCount < this.preserveK; i--) {
-      const m = messages[i];
-      if (!m) continue;
-      if (m.role === "user" || m.role === "assistant") {
-        pairCount++;
-        preserveStart = i;
-      }
-    }
-    let saved = 0;
-    let changed = false;
-    const nextMessages = new Array(messages.length);
-    for (let i = 0; i < messages.length; i++) {
-      const msg = messages[i];
-      if (i >= preserveStart) {
-        nextMessages[i] = msg;
-        continue;
-      }
-      if (!msg || !Array.isArray(msg.content)) {
-        nextMessages[i] = msg;
-        continue;
-      }
-      const newContent = msg.content.map((b) => {
-        if (b.type !== "tool_result") return b;
-        const text = typeof b.content === "string" ? b.content : JSON.stringify(b.content);
-        const tokens = this.roughTokenEstimate(text);
-        if (tokens < this.eliseThreshold) return b;
-        saved += tokens;
-        return {
-          type: "tool_result",
-          tool_use_id: b.tool_use_id,
-          content: `[elided: ~${tokens} tokens]`,
-          is_error: b.is_error
-        };
-      });
-      if (newContent.every((b, idx) => b === msg.content[idx])) {
-        nextMessages[i] = msg;
-      } else {
-        nextMessages[i] = { ...msg, content: newContent };
-        changed = true;
-      }
-    }
-    if (changed) ctx.state.replaceMessages(nextMessages);
-    return saved;
+    const result = eliseOldToolResults(ctx.messages, {
+      preserveK: this.preserveK,
+      eliseThreshold: this.eliseThreshold
+    });
+    if (result.changed) ctx.state.replaceMessages(result.messages);
+    return result.saved;
   }
   hasTextContent(m) {
     if (typeof m.content === "string") return m.content.trim().length > 0;
@@ -1026,6 +937,73 @@ Summarize the following message range:`;
   }
 };
 
+// src/execution/strategy-compactor.ts
+function createStrategyCompactor(opts = {}) {
+  const requested = opts.strategy ?? (opts.llmSelector ? "selective" : "hybrid");
+  const strategy = requested;
+  if (strategy === "intelligent" || strategy === "selective") {
+    return new ProviderBackedCompactor(strategy, opts);
+  }
+  return new HybridCompactor({
+    preserveK: opts.preserveK,
+    eliseThreshold: opts.eliseThreshold
+  });
+}
+var ProviderBackedCompactor = class {
+  constructor(strategy, opts) {
+    this.strategy = strategy;
+    this.opts = opts;
+  }
+  strategy;
+  opts;
+  async compact(ctx, compactOpts = {}) {
+    return this.resolveInner(ctx).compact(ctx, compactOpts);
+  }
+  /**
+   * Construct the concrete compactor for this run. Rebuilt per call (cheap, no
+   * I/O) so a model switch — which changes `ctx.provider.capabilities.maxContext`
+   * — is always reflected. Reads the active ContextWindowPolicy from `ctx.meta`
+   * so the LLM compactors honor the same thresholds/preserveK as the policy.
+   */
+  resolveInner(ctx) {
+    const provider = ctx.provider;
+    if (!provider) {
+      return new HybridCompactor({
+        preserveK: this.opts.preserveK,
+        eliseThreshold: this.opts.eliseThreshold
+      });
+    }
+    const policy = readPolicy(ctx);
+    const maxContext = provider.capabilities?.maxContext || void 0;
+    const thresholds = policy?.thresholds;
+    const common = {
+      provider,
+      maxContext,
+      preserveK: this.opts.preserveK ?? policy?.preserveK,
+      eliseThreshold: this.opts.eliseThreshold ?? policy?.eliseThreshold,
+      ...thresholds ? { warnThreshold: thresholds.warn, softThreshold: thresholds.soft, hardThreshold: thresholds.hard } : {}
+    };
+    if (this.strategy === "selective") {
+      return new SelectiveCompactor({
+        ...common,
+        selectorModel: this.opts.summarizerModel,
+        summarizerModel: this.opts.summarizerModel
+      });
+    }
+    return new IntelligentCompactor({
+      ...common,
+      summarizerModel: this.opts.summarizerModel
+    });
+  }
+};
+function readPolicy(ctx) {
+  const policy = ctx.meta?.["contextWindowPolicy"];
+  if (!policy || typeof policy !== "object") return null;
+  const candidate = policy;
+  if (typeof candidate.preserveK !== "number" || !candidate.thresholds) return null;
+  return candidate;
+}
+
 // src/types/errors.ts
 var ERROR_CODES = {
   // Provider
@@ -1113,6 +1091,11 @@ var FsError = class extends WrongStackError {
 
 // src/execution/auto-compaction-middleware.ts
 var LEVEL_RANK = { warn: 0, soft: 1, hard: 2 };
+var MAX_DIGEST_LOG_CHARS = 4e3;
+function truncateDigest(digest) {
+  if (digest.length <= MAX_DIGEST_LOG_CHARS) return digest;
+  return `${digest.slice(0, MAX_DIGEST_LOG_CHARS)}\u2026 [+${digest.length - MAX_DIGEST_LOG_CHARS} chars; full turns in session log]`;
+}
 var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   name = "AutoCompaction";
   compactor;
@@ -1173,7 +1156,12 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   }
   handler() {
     return async (ctx, next) => {
-      const tokens = this._estimator ? this._estimator(ctx) : estimateRequestTokensCalibrated(ctx.messages, ctx.systemPrompt, ctx.tools ?? []).total;
+      const tokens = this._estimator ? this._estimator(ctx) : estimateRequestTokensCalibrated(
+        ctx.messages,
+        ctx.systemPrompt,
+        ctx.tools ?? [],
+        `${ctx.provider?.id ?? "unknown"}/${ctx.model}`
+      ).total;
       const load = tokens / this._maxContext;
       const policy = this.policyProvider?.(ctx);
       const thresholds = policy?.thresholds ?? {
@@ -1235,7 +1223,11 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         after: report.after,
         level: pressure.level,
         aggressive,
-        reductions: report.reductions?.map((r) => ({ phase: r.phase, saved: r.saved }))
+        reductions: report.reductions?.map((r) => ({ phase: r.phase, saved: r.saved })),
+        // Record what was collapsed so the audit trail shows the preserved
+        // content, not just token counts. Bounded to keep the log line small;
+        // the full original turns are already in the session JSONL.
+        ...report.collapsedDigest ? { digest: truncateDigest(report.collapsedDigest) } : {}
       });
       ctx.clearFileTracking();
     } catch (err) {
@@ -1271,6 +1263,8 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
 var ToolCapabilities = {
   /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
   SHELL_ARBITRARY: "shell.arbitrary",
+  /** Can execute a restricted set of commands (the `exec` tool). */
+  SHELL_RESTRICTED: "shell.restricted",
   /** Can write / modify / delete files inside the project. */
   FS_WRITE: "fs.write",
   /** Can write files outside the current project root (very high risk). */
@@ -1286,6 +1280,7 @@ var ToolCapabilities = {
 };
 var DANGEROUS_FOR_SUBAGENTS = [
   ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
   ToolCapabilities.FS_WRITE,
   ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
   ToolCapabilities.MCP_PROXY,
@@ -1863,6 +1858,13 @@ function extractMalformedRaw(input) {
   }
 }
 
+// src/utils/assert-never.ts
+function assertNever(x, message) {
+  throw new Error(
+    `Unhandled case: ${JSON.stringify(x)}`
+  );
+}
+
 // src/utils/regex-guard.ts
 var MAX_PATTERN_LEN = 512;
 var DANGEROUS_PATTERNS = [
@@ -1952,6 +1954,12 @@ var DoneConditionChecker = class {
           return { done: true, reason: `max tool calls (${this.condition.maxToolCalls}) reached`, ...state };
         }
         break;
+      case "all_tasks_done":
+        break;
+      case "custom":
+        break;
+      default:
+        return assertNever(this.condition.type);
     }
     return { done: false, iterations: state.iterations, toolCalls: state.toolCalls };
   }
@@ -2161,6 +2169,7 @@ function resolveWstackPaths(opts) {
     projectTrust: path2.join(projectDir, "trust.json"),
     projectMeta: path2.join(projectDir, "meta.json"),
     projectLocalConfig: path2.join(projectDir, "config.local.json"),
+    inProjectConfig: path2.join(opts.projectRoot, ".wrongstack", "config.json"),
     inProjectAgentsFile: path2.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
     inProjectSkills: path2.join(opts.projectRoot, ".wrongstack", "skills"),
     inProjectWorktrees: path2.join(opts.projectRoot, ".wrongstack", "worktrees"),
@@ -2185,16 +2194,20 @@ async function loadGoal(filePath) {
   let raw;
   try {
     raw = await fs.readFile(filePath, "utf8");
-  } catch {
-    return null;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return null;
+    throw err;
   }
   try {
     const parsed = JSON.parse(raw);
     if (parsed?.version !== 1 || typeof parsed.goal !== "string" || !Array.isArray(parsed.journal)) {
+      console.warn(`[goal-store] Corrupt goal.json at ${filePath} \u2014 invalid schema. Consider deleting it and re-creating.`);
       return null;
     }
     return parsed;
   } catch {
+    console.warn(`[goal-store] Corrupt goal.json at ${filePath} \u2014 JSON parse failed. Consider deleting it and re-creating.`);
     return null;
   }
 }
@@ -2227,9 +2240,9 @@ function parseProgressFromText(text) {
   const re = /\[progress:\s*(\d{1,3})%\]\s*(?:[—\-]\s*(.+))?/i;
   const m = text.match(re);
   if (!m) return null;
-  const progress = Math.min(100, Math.max(0, Number.parseInt(m[1], 10)));
+  const progress = Math.min(100, Math.max(0, Number.parseInt(m[1] ?? "0", 10)));
   const note = m[2]?.trim() || void 0;
-  return { progress, note };
+  return note === void 0 ? { progress } : { progress, note };
 }
 function recordProgress(goal, progress, note) {
   const clamped = Math.min(100, Math.max(0, progress));
@@ -2248,7 +2261,7 @@ function computeTrend(history) {
   const recent = history.slice(-5);
   const deltas = [];
   for (let i = 1; i < recent.length; i++) {
-    deltas.push(recent[i].progress - recent[i - 1].progress);
+    deltas.push((recent[i]?.progress ?? 0) - (recent[i - 1]?.progress ?? 0));
   }
   if (deltas.length < 2) return void 0;
   const avgDelta = deltas.reduce((a, b) => a + b, 0) / deltas.length;
@@ -2994,6 +3007,7 @@ ${recentJournal}` : "No prior iterations.",
       note: note.slice(0, 240)
     });
     await saveGoal(this.goalPath, withEntry);
+    this.opts.onEternalStop?.();
   }
   /**
    * Manually clear the goal — equivalent to `/goal clear` typed by the user.
@@ -3007,8 +3021,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned);
     }
     try {
-      const { unlink: unlink2 } = await import('fs/promises');
-      await unlink2(this.goalPath);
+      const { unlink: unlink3 } = await import('fs/promises');
+      await unlink3(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -4009,6 +4023,53 @@ Working rules:
         "flaws"
       ]
     }
+  },
+  {
+    config: {
+      id: "refactor-planner",
+      name: "Refactor Planner",
+      role: "refactor-planner",
+      tools: [...PLAN_TOOLS, "diff"],
+      prompt: `You are the Refactor Planner agent. Your job is to analyze code
+structure and produce a concrete, phased refactoring plan with risk
+assessment, dependency ordering, and rollback strategy.
+
+Scope:
+- Map module-level dependencies (import graph)
+- Identify coupling hotspots (high fan-in/out modules)
+- Assess refactoring risk by complexity and test coverage
+- Generate phased plans with checkpoint milestones
+- Produce diff-friendly task lists (one task = one concern)
+
+Input format you accept:
+{ "task": "plan | assess | roadmap", "target": "src/core", "constraint": "no-breaking-changes | minimal-downtime | full-rewrite", "focus": "architecture | performance | maintainability" }
+
+Output: Markdown refactor plan with phases (Low Risk / Medium Risk / High Risk),
+dependency graph, rollback strategy, and exit criteria.
+
+Working rules:
+- Always include rollback strategy \u2014 every refactor can fail
+- Merge tasks that take <1h into a single phase
+- Respect team constraints (reviewer availability, parallelization)
+- Never plan without analyzing the actual code first`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "Refactoring planner: analyzes code structure, maps dependencies, produces risk-scored phased plans with rollback strategy.",
+      keywords: [
+        "refactor",
+        "refactoring",
+        "restructure",
+        "debt",
+        "technical debt",
+        "clean up",
+        "modularize",
+        "decouple",
+        "dependency graph",
+        "code structure"
+      ]
+    }
   }
 ];
 
@@ -4548,6 +4609,157 @@ Working rules:
         "robustness"
       ]
     }
+  },
+  {
+    config: {
+      id: "security-scanner",
+      name: "Security Scanner",
+      role: "security-scanner",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Security Scanner agent. Your job is to scan code,
+configs, and dependencies for security issues from hardcoded secrets to
+supply chain risks.
+
+Scope:
+- Detect hardcoded secrets: API keys, tokens, passwords, private keys
+- Find injection vectors: eval, innerHTML, SQL concat, shell injection
+- Identify insecure patterns: weak crypto, hardcoded IVs, disabled TLS
+- Scan dependencies for known CVEs (via npm/pnpm audit)
+- Flag supply chain risks: postinstall hooks, unverified scripts
+
+Input format you accept:
+{ "task": "scan | audit | secrets | dependencies", "paths": ["src", "config"], "depth": "quick | normal | deep" }
+
+Output: Markdown security report with severity-ranked findings, injection
+vectors, dependency issues, and a remediation checklist.
+
+Working rules:
+- Never scan node_modules \u2014 use npm audit instead
+- Always provide remediation steps, not just findings
+- Verify regex-based secrets before flagging (false positive risk)
+- When in doubt, flag as medium rather than ignoring potential issues`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Security scanner: detects hardcoded secrets, injection vectors, insecure patterns, and supply-chain risks with remediation.",
+      keywords: [
+        "security",
+        "scan",
+        "vulnerability",
+        "secret",
+        "api key",
+        "hardcoded",
+        "injection",
+        "cve",
+        "audit dependencies",
+        "supply chain",
+        "xss",
+        "sqli",
+        "shell injection",
+        "sensitive data",
+        "credential"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "bug-hunter",
+      name: "Bug Hunter",
+      role: "bug-hunter",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Bug Hunter agent. Your job is to systematically scan
+source code for bugs, anti-patterns, and code smells using pattern matching
+and heuristics. Output a prioritized hit list with file:line references.
+
+Scope:
+- Detect common bug patterns (uncaught errors, resource leaks, race conditions)
+- Identify anti-patterns (callback hell, God objects, circular deps)
+- Find TypeScript-specific issues (unsafe any, missing null checks, branded types)
+- Flag security-sensitive constructs (eval, innerHTML, hardcoded secrets)
+- Rank findings: critical > high > medium > low
+
+Input format you accept:
+{ "task": "scan | hunt | check", "paths": ["src/**/*.ts"], "focus": "bugs | patterns | security | all", "severityThreshold": "medium" }
+
+Output: Markdown bug hunt report with critically/high/medium/low sections.
+Each entry: **[TYPE]** \`file:line\` \u2014 description + suggested fix
+
+Working rules:
+- Never scan node_modules \u2014 it's noise
+- Always include file:line for every finding
+- If >30% of findings are false positives, note the confidence level
+- Ask director for clarification if paths are ambiguous`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Bug hunter: scans source code for bugs, anti-patterns, and code smells, producing a file:line-ranked hit list with fixes.",
+      keywords: [
+        "bug",
+        "hunt",
+        "scan",
+        "code smell",
+        "anti-pattern",
+        "race condition",
+        "memory leak",
+        "null deref",
+        "type safety",
+        "unhandled error",
+        "find bugs",
+        "audit code",
+        "code quality"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "audit-log",
+      name: "Audit Log",
+      role: "audit-log",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Audit Log agent. Your job is to analyze structured JSONL
+session logs and produce actionable markdown reports.
+
+Scope:
+- Parse session logs (iteration counts, tool calls, errors, usage)
+- Detect repeated failure patterns across multiple runs
+- Identify tool usage anomalies (over-use, failures, unexpected chains)
+- Track token consumption trends
+- Generate structured audit reports with severity ratings
+
+Input format you accept:
+{ "task": "analyze | report | trends", "sessionPath": "<path>", "focus": "errors | tools | usage | all" }
+
+Output: Markdown audit report with Summary, Top Errors, Tool Usage table,
+Anomalies, and Cost Trend sections.
+
+Working rules:
+- Never fabricate numbers \u2014 read the actual logs first
+- Always include file:line references for errors
+- If sessionPath is missing, ask the director to provide it
+- Report confidence level: high (>90% accuracy), medium, low`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Audit log analyzer: parses session JSONL, detects failure patterns, tool anomalies, and cost trends with structured reports.",
+      keywords: [
+        "audit",
+        "log",
+        "logs",
+        "session",
+        "trace",
+        "analyze logs",
+        "error patterns",
+        "cost analysis",
+        "tool usage",
+        "token usage",
+        "post-mortem",
+        "trend",
+        "anomaly"
+      ]
+    }
   }
 ];
 
@@ -7555,6 +7767,7 @@ var DefaultRetryPolicy = class {
     if (err instanceof ProviderError) {
       if (err.status === 429) return 5;
       if (err.status === 529) return 3;
+      if (err.status === 599) return 5;
       if (err.status >= 500) return 3;
       return 0;
     }
@@ -7785,6 +7998,6 @@ function parseDescription(raw) {
   return { trigger, scope };
 }
 
-export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, buildGoalPreamble, createAutonomyBrain, formatDecisionSummary, makeAutonomyPromptContributor };
+export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, buildGoalPreamble, createAutonomyBrain, createStrategyCompactor, formatDecisionSummary, makeAutonomyPromptContributor };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map