@wrongstack/core 0.250.0 → 0.256.0

package/dist/execution/index.d.ts

@@ -1,23 +1,23 @@
-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-UZg1xOzE.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-BjJpnLW4.js';
-import { P as Provider } from '../context-CLz3z_E8.js';
-import { b as BrainDecision, e as BrainDecisionRequest, B as BrainArbiter } from '../brain-sCZ3lCjq.js';
-import '../retry-policy-BVnkbMET.js';
-import '../compactor-BRfg3QPd.js';
-import '../config-eSsrto5d.js';
-import '../index-IehiNryU.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';
+import { P as Provider } from '../context-CGdgA0q6.js';
+import { b as BrainDecision, e as BrainDecisionRequest, B as BrainArbiter } from '../brain-TjEEwSpw.js';
+import '../retry-policy-Tg7LXkoK.js';
+import '../compactor-C5sT4U7I.js';
+import '../config-DuAu23zm.js';
+import '../index-CitPrI3a.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-D1n-gQI-.js';
+import '../pipeline-JG8XoudC.js';
 import '../observability-D-HZN_mF.js';
-import '../permission-DbWPbuoA.js';
-import '../agent-subagent-runner-Dz-9kiE6.js';
+import '../permission-CwBBpCoF.js';
+import '../agent-subagent-runner-US741uBH.js';
 import '../goal-store-CV9Yz2X_.js';
-import '../multi-agent-coordinator-CnbEqpv0.js';
+import '../multi-agent-coordinator-DqTUEAeC.js';
 import 'node:events';
-import '../skill-Bj6Ezqb8.js';
+import '../skill-DGIXCtdv.js';
 import '../wstack-paths-CJjEwPXn.js';
-import '../selector-Cb4_9-hf.js';
-import '../session-event-bridge-BhtkkFFy.js';
+import '../selector-DWsqVjGf.js';
+import '../session-event-bridge-BAFWdgQ3.js';
 
 /**
  * AutonomyBrain — a self-driving decision layer for autonomous workflows.

package/dist/execution/index.js

@@ -139,6 +139,14 @@ function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = C
     total
   };
 }
+function getCalibrationState(calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  const cal = calState(calibrationKey);
+  return {
+    ratio: cal.ratio,
+    count: cal.count,
+    calibrated: cal.count >= MIN_SAMPLES_FOR_CALIBRATION
+  };
+}
 function estimateRequestTokensCalibrated(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
   const result = estimateRequestTokens(messages, systemPrompt, tools, calibrationKey);
   const cal = calState(calibrationKey);
@@ -1324,6 +1332,13 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         tokens = this._estimator(ctx);
       } else if (msgCount === this._cachedMsgCount && toolCount === this._cachedToolCount && this._cachedTokens >= 0) {
         tokens = this._cachedTokens;
+      } else if (this.tryStashedTokens(ctx, msgCount, toolCount) !== null) {
+        const stashed = this.tryStashedTokens(ctx, msgCount, toolCount);
+        const cal = getCalibrationState(`${ctx.provider?.id ?? "unknown"}/${ctx.model}`);
+        tokens = cal.calibrated ? Math.round(stashed * Math.min(1.5, Math.max(0.5, cal.ratio))) : stashed;
+        this._cachedTokens = tokens;
+        this._cachedMsgCount = msgCount;
+        this._cachedToolCount = toolCount;
       } else {
         tokens = estimateRequestTokensCalibrated(
           ctx.messages,
@@ -1356,6 +1371,25 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
       return next(ctx);
     };
   }
+  /**
+   * H1: try to read a pre-computed token total from `ctx.lastRequestTokens`
+   * (set by the agent loop's pre-flight or its restash in emitContextPct).
+   * Returns the uncalibrated total when the stash is valid for the current
+   * context shape (positive number, and the message count it was computed
+   * at matches the current one — otherwise tool results have been appended
+   * since and the value is stale). Returns null when missing or stale so
+   * the caller falls back to a fresh walk.
+   */
+  tryStashedTokens(ctx, msgCount, toolCount) {
+    const stashed = ctx.lastRequestTokens;
+    if (typeof stashed !== "number" || stashed <= 0) return null;
+    const stashedAt = ctx.meta?.["lastRequestTokensAt"];
+    if (typeof stashedAt !== "object" || stashedAt === null) return null;
+    const meta = stashedAt;
+    if (meta.msgCount !== msgCount) return null;
+    if (typeof meta.toolCount === "number" && meta.toolCount !== toolCount) return null;
+    return stashed;
+  }
   /**
    * Returns true when the previous compaction at the same or higher pressure
    * level reduced nothing and context has not grown materially since. Prevents
@@ -1655,7 +1689,7 @@ var ToolExecutor = class _ToolExecutor {
       const tool = this.registry.get(use.name);
       if (!tool) {
         const result = this.unknownToolResult(use, () => this.registry.list().map((t) => t.name));
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       const validation = validateAgainstSchema(use.input, tool.inputSchema);
@@ -1672,20 +1706,20 @@ ${errorDetails}
 Please call the tool again with arguments that match its inputSchema. You can use the "tool-help" tool with name="${tool.name}" to see the exact expected schema.`,
           is_error: true
         };
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       const toolDangerousCaps = getDangerousCapabilities(tool);
       if (hasMalformedArguments(use.input)) {
         const result = this.malformedInputResult(use, extractMalformedRaw(use.input));
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       if (this.opts.hookRunner?.has("PreToolUse")) {
         const pre = await this.opts.hookRunner.preToolUse(tool.name, use.input, ctx);
         if (pre.block) {
           const result = this.blockedByHookResult(use, pre.reason);
-          budget = this.decrementBudget(result, budget);
+          budget = this.budgetForString(result.content, budget);
           return { result, tool, durationMs: Date.now() - start };
         }
         if (pre.input) {
@@ -1701,7 +1735,7 @@ Validation errors:
 ${errorDetails}`,
               is_error: true
             };
-            budget = this.decrementBudget(result, budget);
+            budget = this.budgetForString(result.content, budget);
             return { result, tool, durationMs: Date.now() - start };
           }
           use = { ...use, input: pre.input };
@@ -1716,7 +1750,7 @@ ${errorDetails}`,
       }
       if (effectivePermission === "deny") {
         const result = this.deniedResult(use, decision.reason);
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       if (effectivePermission === "confirm") {
@@ -1729,7 +1763,7 @@ ${errorDetails}`,
               content: `Tool "${tool.name}" denied by user.`,
               is_error: true
             };
-            budget = this.decrementBudget(result, budget);
+            budget = this.budgetForString(result.content, budget);
             return { result, tool, durationMs: Date.now() - start };
           }
         } else {
@@ -1753,7 +1787,8 @@ ${errorDetails}`,
         "tool.has_dangerous_capabilities": toolCapsForAudit.length > 0
       });
       try {
-        let result = await this.executeTool(tool, use, ctx, budget);
+        let { block: result, bytes } = await this.executeTool(tool, use, ctx, budget);
+        budget -= bytes;
         if (this.opts.hookRunner?.has("PostToolUse")) {
           const post = await this.opts.hookRunner.postToolUse(
             tool.name,
@@ -1762,12 +1797,13 @@ ${errorDetails}`,
             ctx
           );
           if (post.additionalContext) {
-            result = { ...result, content: `${result.content}
+            const appended = `
 
-${post.additionalContext}` };
+${post.additionalContext}`;
+            result = { ...result, content: `${result.content}${appended}` };
+            budget = Math.max(0, budget - Buffer.byteLength(appended, "utf8"));
           }
         }
-        budget = this.decrementBudget(result, budget);
         span?.setAttribute("tool.is_error", !!result.is_error);
         span?.setAttribute(
           "tool.output_bytes",
@@ -1784,7 +1820,7 @@ ${post.additionalContext}` };
           content: `Tool "${tool.name}" threw: ${scrubbed}`,
           is_error: true
         };
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         if (err instanceof Error) span?.recordError(err);
         span?.setAttribute("tool.is_error", true);
         return { result, tool, durationMs: Date.now() - start };
@@ -1804,7 +1840,7 @@ ${post.additionalContext}` };
           content: `Tool "${use.name}" execution failed: ${scrubbed}`,
           is_error: true
         };
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         return { result, tool: this.registry.get(use.name), durationMs: 0 };
       }
     };
@@ -1853,14 +1889,20 @@ ${post.additionalContext}` };
     const output = await this.runWithTimeout(tool, use.input, ctx.signal, ctx, use.id);
     const text = this.serializer.serialize(output);
     const scrubbed = this.opts.secretScrubber.scrub(text);
-    const { text: capped } = this.serializer.enforceCap(scrubbed, budget);
+    const { text: capped, newBudget } = this.serializer.enforceCap(scrubbed, budget);
     this.opts.renderer?.writeToolResult(tool.name, capped, false);
     return {
-      type: "tool_result",
-      tool_use_id: use.id,
-      name: tool.name,
-      content: capped,
-      is_error: false
+      block: {
+        type: "tool_result",
+        tool_use_id: use.id,
+        name: tool.name,
+        content: capped,
+        is_error: false
+      },
+      // `budget - newBudget` is the exact byte count enforceCap spent
+      // (capped at `budget` so a truncated output shows as `budget`
+      // consumed, matching the pre-fix `decrementBudget` semantics).
+      bytes: budget - newBudget
     };
   }
   async runWithTimeout(tool, input, parentSignal, ctx, toolUseId) {
@@ -2000,9 +2042,19 @@ ${excerpt}`;
       is_error: true
     };
   }
-  decrementBudget(result, budget) {
-    const contentBytes = typeof result.content === "string" ? Buffer.byteLength(result.content, "utf8") : Buffer.byteLength(JSON.stringify(result.content), "utf8");
-    return Math.max(0, budget - contentBytes);
+  /**
+   * Subtract a string-content result's UTF-8 byte length from the
+   * iteration output budget. Used for synthesized results (unknown tool,
+   * validation error, blocked, threw) where the content is a small
+   * string built in the executor. The success path no longer goes
+   * through here — `executeTool` carries the exact byte count it spent
+   * in its return value, derived from `enforceCap`'s `newBudget`.
+   *
+   * Floors the result at 0 to match the pre-fix `decrementBudget`
+   * semantics (over-budget spends don't underflow the running total).
+   */
+  budgetForString(content, budget) {
+    return Math.max(0, budget - Buffer.byteLength(content, "utf8"));
   }
   /**
    * Compute the suggestedPattern string for a tool+input pair.
@@ -8300,6 +8352,35 @@ var DefaultErrorHandler = class {
     return null;
   }
 };
+function stripFrontmatter(raw) {
+  if (!raw.startsWith("---")) return raw;
+  const end = raw.indexOf("\n---", 4);
+  if (end === -1) return raw;
+  let body = raw.slice(end + 4);
+  if (body.startsWith("\n")) body = body.slice(1);
+  return body;
+}
+function compactSkillBody(body) {
+  const sections = [];
+  const overviewMatch = body.match(/##\s*Overview\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
+  const overview = overviewMatch?.[1];
+  if (overview?.trim()) {
+    sections.push(overview.trim().slice(0, 200));
+  }
+  const rulesMatch = body.match(/##\s*Rules\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
+  const rules = rulesMatch?.[1];
+  if (rules?.trim()) {
+    const trimmed = rules.trim().slice(0, 350);
+    const ruleLines = trimmed.split("\n").filter((l) => /^\s*[-*]\s/.test(l) || /^\s*\d+[.)]\s/.test(l)).slice(0, 6).join("\n");
+    if (ruleLines) sections.push(ruleLines);
+  }
+  if (sections.length === 0) {
+    const first = body.trim().slice(0, 200);
+    if (first) sections.push(first);
+  }
+  const result = sections.join("\n\n");
+  return result.length > 450 ? result.slice(0, 447) + "\u2026" : result;
+}
 var DefaultSkillLoader = class {
   dirs;
   cache;
@@ -8381,6 +8462,24 @@ var DefaultSkillLoader = class {
     if (!m) throw new Error(`Skill "${name}" not found`);
     return fs.readFile(m.path, "utf8");
   }
+  async readSaveBody(name) {
+    const m = await this.find(name);
+    if (!m) throw new Error(`Skill "${name}" not found`);
+    const savePath = path2.join(path2.dirname(m.path), "SKILL.save.md");
+    try {
+      return await fs.readFile(savePath, "utf8");
+    } catch {
+      const full = await fs.readFile(m.path, "utf8");
+      const body = stripFrontmatter(full);
+      const compact = compactSkillBody(body);
+      if (compact) {
+        return `## Overview
+
+${compact}`;
+      }
+      return body.trim().slice(0, 300);
+    }
+  }
 };
 function parseFrontmatter(raw) {
   if (!raw.startsWith("---")) return {};