@wrongstack/core 0.155.0 → 0.236.0

package/dist/execution/index.d.ts

@@ -1,23 +1,23 @@
-export { C as CompactorOptions, D as DefaultErrorHandler, a as DefaultRetryPolicy, E as EternalAutonomyEngine, b as EternalAutonomyOptions, c as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, d as ParallelEternalEngine, e as ParallelEternalOptions, f as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-CYoTKjsz.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-CbV8pXLD.js';
-import { P as Provider } from '../context-C7G_MtLV.js';
-import { B as BrainDecision, a as BrainDecisionRequest, b as BrainArbiter } from '../brain-CS_B0vIE.js';
-import '../retry-policy-rutAfVeR.js';
-import '../compactor-BueGt7LG.js';
-import '../config-BaVThgnT.js';
-import '../index-B5wz-GXm.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-DtG1fjc9.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-CnbzyVvl.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-Koq6f3fs.js';
+import '../index-C2eSNPsB.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-BG7UgbDc.js';
+import '../pipeline-DsmlwTXu.js';
 import '../observability-D-HZN_mF.js';
-import '../permission-B7nKnEvQ.js';
-import '../agent-subagent-runner-Bsueu0J2.js';
+import '../permission-DbWPbuoA.js';
+import '../agent-subagent-runner-C658wj_c.js';
 import '../goal-store-CV9Yz2X_.js';
-import '../multi-agent-coordinator-BSKSFNhv.js';
+import '../multi-agent-coordinator-60weDZoA.js';
 import 'node:events';
 import '../skill-Bj6Ezqb8.js';
-import '../wstack-paths-DD50Omgn.js';
-import '../selector-4vDFZKt3.js';
-import '../session-event-bridge-DWlvglC2.js';
+import '../wstack-paths-CJjEwPXn.js';
+import '../selector-Cb4_9-hf.js';
+import '../session-event-bridge-BhtkkFFy.js';
 
 /**
  * AutonomyBrain — a self-driving decision layer for autonomous workflows.
@@ -69,6 +69,35 @@ interface AutonomyBrainOptions {
      */
     onDecision?: ((summary: string, decision: BrainDecision, request: BrainDecisionRequest) => void) | undefined;
 }
+/** Runtime-adjustable autonomy ceiling for the tiered brain. */
+type BrainAutoRisk = 'off' | 'low' | 'medium' | 'high' | 'all';
+interface TieredBrainArbiterOptions {
+    /** Fast deterministic policy layer (DefaultBrainArbiter). Consulted first. */
+    policy: BrainArbiter;
+    /** LLM-backed autonomous layer (createAutonomyBrain). Consulted when the
+     *  policy layer would escalate to the human and the request's risk is
+     *  within the live ceiling. */
+    autonomous?: BrainArbiter | undefined;
+    /**
+     * Live autonomy ceiling — read on EVERY decision so `/brain risk <level>`
+     * changes take effect immediately. 'off' disables the autonomous layer
+     * entirely (everything the policy can't answer goes to the human).
+     */
+    getMaxAutoRisk?: (() => BrainAutoRisk) | undefined;
+}
+/**
+ * The standard Brain positioning: policy first, LLM second, human last.
+ *
+ *   1. POLICY  — deterministic DefaultBrainArbiter (low-risk fast path,
+ *      fallback semantics). Answers and denies pass through untouched.
+ *   2. LLM     — when the policy says `ask_human` and the request's risk is
+ *      within the live ceiling, the autonomous brain gets a chance to
+ *      answer. Only a real `answer` short-circuits; LLM denials/failures
+ *      fall through.
+ *   3. HUMAN   — anything left escalates (callers wrap this in
+ *      HumanEscalatingBrainArbiter so `ask_human` becomes a real prompt).
+ */
+declare function createTieredBrainArbiter(opts: TieredBrainArbiterOptions): BrainArbiter;
 /**
  * Create a self-driving brain that makes autonomous decisions.
  * Never asks the human — within its risk boundary it answers, above it denies.
@@ -79,4 +108,4 @@ declare function createAutonomyBrain(opts: AutonomyBrainOptions): BrainArbiter;
  */
 declare function formatDecisionSummary(decision: BrainDecision, request: BrainDecisionRequest): string;
 
-export { type AutonomyBrainOptions, createAutonomyBrain, formatDecisionSummary };
+export { type AutonomyBrainOptions, type BrainAutoRisk, type TieredBrainArbiterOptions, createAutonomyBrain, createTieredBrainArbiter, formatDecisionSummary };

package/dist/execution/index.js

@@ -9,7 +9,9 @@ import { EventEmitter } from 'events';
 // src/utils/expect-defined.ts
 function expectDefined(value, label) {
   if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
+    const err = new Error("Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
   }
   return value;
 }
@@ -58,22 +60,31 @@ function estimateToolResultTokens(content) {
 function estimateTextTokens(text) {
   return RoughTokenEstimate(text);
 }
+function computeMessageTokens(msg) {
+  if (typeof msg.content === "string") return estimateTextTokens(msg.content);
+  let total = 0;
+  for (const b of msg.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);
+    else total += RoughTokenEstimate(JSON.stringify(b));
+  }
+  return total;
+}
 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);
-      }
+    if (typeof m._estTokens === "number" && m._estTokens > 0) {
+      total += m._estTokens;
+      continue;
     }
+    total += computeMessageTokens(m);
   }
   return total;
 }
 function estimateToolDefTokens(tool) {
+  const cached = tool._estDefTokens;
+  if (typeof cached === "number" && cached > 0) return cached;
   return RoughTokenEstimate(tool.name) + RoughTokenEstimate(tool.description ?? "") + RoughTokenEstimate(JSON.stringify(tool.inputSchema));
 }
 function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
@@ -83,6 +94,11 @@ function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = C
   } else if (Array.isArray(messages)) {
     for (const m of messages) {
       if (typeof m === "object" && m !== null && "content" in m) {
+        const cached = m._estTokens;
+        if (typeof cached === "number" && cached > 0) {
+          messagesTokens += cached;
+          continue;
+        }
         const content = m.content;
         if (typeof content === "string") {
           messagesTokens += RoughTokenEstimate(content);
@@ -267,6 +283,18 @@ function findPreserveStart(messages, preserveK) {
 }
 function eliseOldToolResults(messages, opts) {
   const preserveStart = findPreserveStart(messages, opts.preserveK);
+  let hasOversized = false;
+  for (let i = 0; i < preserveStart && !hasOversized; i++) {
+    const msg = messages[i];
+    if (!msg || !Array.isArray(msg.content)) continue;
+    for (const b of msg.content) {
+      if (b.type === "tool_result" && estimateToolResultTokens(b.content) >= opts.eliseThreshold) {
+        hasOversized = true;
+        break;
+      }
+    }
+  }
+  if (!hasOversized) return { messages, saved: 0, changed: false };
   let saved = 0;
   let changed = false;
   const next = new Array(messages.length);
@@ -1245,6 +1273,15 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   static NOOP_RETRY_DELTA_TOKENS = 2e3;
   /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
   lastNoopAttempt = null;
+  /**
+   * Cached token estimate from the last handler() invocation. When the
+   * message count and tool count haven't changed since the last estimate
+   * (autonomous idle loops), we skip the expensive O(n) token estimation
+   * and reuse this value. Reset to -1 when the context changes.
+   */
+  _cachedTokens = -1;
+  _cachedMsgCount = -1;
+  _cachedToolCount = -1;
   /**
    * @param compactor        Compactor to use for compaction.
    * @param maxContext Provider's max context window in tokens.
@@ -1280,12 +1317,24 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
   }
   handler() {
     return async (ctx, next) => {
-      const tokens = this._estimator ? this._estimator(ctx) : estimateRequestTokensCalibrated(
-        ctx.messages,
-        ctx.systemPrompt,
-        ctx.tools ?? [],
-        `${ctx.provider?.id ?? "unknown"}/${ctx.model}`
-      ).total;
+      const msgCount = ctx.messages.length;
+      const toolCount = (ctx.tools ?? []).length;
+      let tokens;
+      if (this._estimator) {
+        tokens = this._estimator(ctx);
+      } else if (msgCount === this._cachedMsgCount && toolCount === this._cachedToolCount && this._cachedTokens >= 0) {
+        tokens = this._cachedTokens;
+      } else {
+        tokens = estimateRequestTokensCalibrated(
+          ctx.messages,
+          ctx.systemPrompt,
+          ctx.tools ?? [],
+          `${ctx.provider?.id ?? "unknown"}/${ctx.model}`
+        ).total;
+        this._cachedTokens = tokens;
+        this._cachedMsgCount = msgCount;
+        this._cachedToolCount = toolCount;
+      }
       const load = tokens / this._maxContext;
       const policy = this.policyProvider?.(ctx);
       const thresholds = policy?.thresholds ?? {
@@ -1566,7 +1615,7 @@ function createToolOutputSerializer(opts = {}) {
 }
 
 // src/execution/tool-executor.ts
-var ToolExecutor = class {
+var ToolExecutor = class _ToolExecutor {
   constructor(registry, opts) {
     this.registry = registry;
     this.opts = opts;
@@ -1578,6 +1627,10 @@ var ToolExecutor = class {
   }
   registry;
   opts;
+  /** Minimum gap between coalesced `partial_output` tool.progress emits. */
+  static PROGRESS_EMIT_INTERVAL_MS = 100;
+  /** Max chars of accumulated stream text carried per coalesced emit. */
+  static PROGRESS_TAIL_CHARS = 16384;
   serializer;
   iterationTimeoutMs;
   maxToolTimeoutMs;
@@ -1623,9 +1676,6 @@ Please call the tool again with arguments that match its inputSchema. You can us
         return { result, tool, durationMs: Date.now() - start };
       }
       const toolDangerousCaps = getDangerousCapabilities(tool);
-      if (toolDangerousCaps.length > 0) {
-        if (this.opts.events) ;
-      }
       if (hasMalformedArguments(use.input)) {
         const result = this.malformedInputResult(use, extractMalformedRaw(use.input));
         budget = this.decrementBudget(result, budget);
@@ -1863,17 +1913,48 @@ ${post.additionalContext}` };
       throw new Error(`Tool "${tool.name}" does not support streaming execution`);
     }
     const stream = tool.executeStream(input, ctx, { signal });
-    for await (const ev of stream) {
-      if (ev.type === "final") {
-        finalOutput = ev.output;
-        sawFinal = true;
-        break;
-      }
+    const iter = stream[Symbol.asyncIterator]();
+    let progressTail = "";
+    let lastProgressEmitAt = 0;
+    const emitProgress = (ev) => {
       this.opts.events?.emit("tool.progress", {
         name: tool.name,
         id: toolUseId ?? "<unknown>",
         event: ev
       });
+    };
+    const flushProgressTail = (force) => {
+      if (progressTail.length === 0) return;
+      const now = Date.now();
+      if (!force && now - lastProgressEmitAt < _ToolExecutor.PROGRESS_EMIT_INTERVAL_MS) return;
+      const text = progressTail;
+      progressTail = "";
+      lastProgressEmitAt = now;
+      emitProgress({ type: "partial_output", text });
+    };
+    try {
+      while (true) {
+        const { done, value: ev } = await iter.next();
+        if (done) break;
+        if (ev.type === "final") {
+          finalOutput = ev.output;
+          sawFinal = true;
+          break;
+        }
+        if (ev.type === "partial_output" && typeof ev.text === "string") {
+          progressTail += ev.text;
+          if (progressTail.length > _ToolExecutor.PROGRESS_TAIL_CHARS) {
+            progressTail = progressTail.slice(-_ToolExecutor.PROGRESS_TAIL_CHARS);
+          }
+          flushProgressTail(false);
+          continue;
+        }
+        flushProgressTail(true);
+        emitProgress(ev);
+      }
+      flushProgressTail(true);
+    } finally {
+      await iter.return?.(void 0);
     }
     if (!sawFinal) {
       throw new Error(`tool "${tool.name}" executeStream completed without a 'final' event`);
@@ -1984,9 +2065,11 @@ function extractMalformedRaw(input) {
 
 // src/utils/assert-never.ts
 function assertNever(x, message) {
-  throw new Error(
+  const err = new Error(
     `Unhandled case: ${JSON.stringify(x)}`
   );
+  err.name = "AssertNeverError";
+  throw err;
 }
 
 // src/utils/regex-guard.ts
@@ -2033,7 +2116,13 @@ var DoneConditionChecker = class {
       const result = compileUserRegex(condition.pattern, "");
       this.compiledRegex = result.ok ? result.regex : null;
       if (!result.ok) {
-        console.warn(`[DoneConditionChecker] Invalid regex pattern "${condition.pattern}": ${result.reason}`);
+        console.warn(JSON.stringify({
+          level: "warn",
+          event: "autonomous.done_condition_invalid_regex",
+          pattern: condition.pattern,
+          reason: result.reason,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
       }
     } else {
       this.compiledRegex = null;
@@ -2267,9 +2356,13 @@ function projectSlug(absRoot) {
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
 }
+function wstackGlobalRoot() {
+  const fromEnv = process.env["WRONGSTACK_HOME"];
+  if (fromEnv && fromEnv.trim().length > 0) return path2.resolve(fromEnv);
+  return path2.join(os.homedir(), ".wrongstack");
+}
 function resolveWstackPaths(opts) {
-  const home = opts.userHome ?? os.homedir();
-  const globalRoot = opts.globalRoot ?? path2.join(home, ".wrongstack");
+  const globalRoot = opts.globalRoot ?? (opts.userHome ? path2.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
   const hash = projectHash(opts.projectRoot);
   const slug = projectSlug(opts.projectRoot);
   const projectDir = path2.join(globalRoot, "projects", slug);
@@ -2326,12 +2419,24 @@ async function loadGoal(filePath) {
   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.`);
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "goal_store.invalid_schema",
+        path: filePath,
+        message: "invalid schema \u2014 consider deleting and re-creating",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
       return null;
     }
     return parsed;
   } catch {
-    console.warn(`[goal-store] Corrupt goal.json at ${filePath} \u2014 JSON parse failed. Consider deleting it and re-creating.`);
+    console.warn(JSON.stringify({
+      level: "warn",
+      event: "goal_store.parse_failed",
+      path: filePath,
+      message: "JSON parse failed \u2014 consider deleting and re-creating",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }));
     return null;
   }
 }
@@ -2406,6 +2511,25 @@ var RISK_LEVELS = {
   high: 2,
   critical: 3
 };
+function createTieredBrainArbiter(opts) {
+  return {
+    async decide(request) {
+      const policyDecision = await opts.policy.decide(request);
+      if (policyDecision.type !== "ask_human") return policyDecision;
+      const ceiling = opts.getMaxAutoRisk?.() ?? "medium";
+      if (!opts.autonomous || ceiling === "off") return policyDecision;
+      const ceilingLevel = ceiling === "all" ? 3 : RISK_LEVELS[ceiling] ?? 1;
+      const requestLevel = RISK_LEVELS[request.risk] ?? 2;
+      if (requestLevel > ceilingLevel) return policyDecision;
+      try {
+        const llmDecision = await opts.autonomous.decide(request);
+        if (llmDecision.type === "answer") return llmDecision;
+      } catch {
+      }
+      return policyDecision;
+    }
+  };
+}
 function createAutonomyBrain(opts) {
   const maxRisk = opts.maxAutoRisk ?? "high";
   const maxRiskLevel = RISK_LEVELS[maxRisk] ?? 2;
@@ -2612,7 +2736,14 @@ var EternalAutonomyEngine = class {
   stop() {
     this.stopRequested = true;
     this.currentCtrl?.abort();
-    void this.persistEngineState("stopped").catch(() => {
+    void this.persistEngineState("stopped").catch((err) => {
+      console.error(JSON.stringify({
+        level: "error",
+        event: "engine.persist_state_failed",
+        message: err instanceof Error ? err.message : String(err),
+        context: { expectedState: "stopped" },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
     });
     this.state = "stopped";
   }
@@ -3728,21 +3859,40 @@ function makeAgentSubagentRunner(opts) {
       if (budgetError) throw budgetError;
     }
     if (result.status === "failed") {
-      throw result.error instanceof Error ? result.error : new Error(String(result.error ?? "agent failed"));
+      throw result.error instanceof AgentError ? result.error : new AgentError({
+        message: result.error instanceof Error ? result.error.message : String(result.error ?? "agent failed"),
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        cause: result.error
+      });
     }
     if (result.status === "aborted") {
-      throw new Error("agent aborted");
+      throw new AgentError({
+        message: "agent aborted",
+        code: ERROR_CODES.AGENT_ABORTED
+      });
     }
     if (result.status === "max_iterations") {
-      throw new Error("agent exhausted iteration limit");
+      throw new AgentError({
+        message: "agent exhausted iteration limit",
+        code: ERROR_CODES.AGENT_ITERATION_LIMIT,
+        recoverable: true
+      });
     }
     const usage = ctx.budget.usage();
     const finalText = (result.finalText ?? "").trim();
     if (finalText.length === 0 && usage.toolCalls === 0) {
-      throw new Error("empty response");
+      throw new AgentError({
+        message: "empty response \u2014 agent produced no text and no tool calls",
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        context: { iterations: result.iterations }
+      });
     }
     if (finalText.length === 0 && lastToolFailed !== null) {
-      throw new Error(`tool failed: ${lastToolFailed}`);
+      throw new AgentError({
+        message: `unrecovered tool failure: ${lastToolFailed} \u2014 agent ended turn without acknowledging the error`,
+        code: ERROR_CODES.AGENT_RUN_FAILED,
+        context: { tool: lastToolFailed, iterations: result.iterations }
+      });
     }
     return {
       result: result.finalText,
@@ -3774,11 +3924,11 @@ var HEAVY_BUDGET = {
 };
 var TOOLS = {
   /** Pure read/inspect — safe for analysis and review agents. */
-  read: ["read", "grep", "glob", "search", "tree"],
+  read: ["read", "grep", "glob", "search", "tree", "mailbox"],
   /** Read + structured inspection (logs, diffs, json, dependency audit). */
-  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit"],
+  inspect: ["read", "grep", "glob", "search", "tree", "json", "diff", "logs", "audit", "mailbox"],
   /** Read + edit (no shell). For agents that write code/docs but don't run it. */
-  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch"],
+  write: ["read", "grep", "glob", "search", "tree", "write", "edit", "replace", "patch", "mailbox"],
   /** Full build loop: edit + run (lint/format/typecheck/test/bash). */
   build: [
     "read",
@@ -3795,16 +3945,17 @@ var TOOLS = {
     "lint",
     "format",
     "typecheck",
-    "test"
+    "test",
+    "mailbox"
   ],
   /** Version control. */
   vcs: ["read", "grep", "glob", "git", "diff"],
   /** Dependency management + CVE audit. */
-  deps: ["read", "grep", "glob", "install", "outdated", "audit", "json"],
+  deps: ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"],
   /** Documentation authoring. */
-  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document"],
+  docs: ["read", "grep", "glob", "search", "tree", "write", "edit", "document", "mailbox"],
   /** Web research. */
-  research: ["read", "grep", "glob", "search", "fetch"]
+  research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
 };
 
 // src/coordination/agents/phase1-discovery.ts
@@ -6217,7 +6368,7 @@ Working rules:
       id: "tech-stack",
       name: "Tech Stack Validator",
       role: "tech-stack",
-      tools: ["search", "fetch", "read", "grep", "glob", "outdated", "audit", "json"],
+      tools: ["search", "fetch", "read", "grep", "glob", "outdated", "audit", "json", "mailbox"],
       prompt: `You are the Tech Stack Validator \u2014 a single-shot validation agent that fires
 before any package, library, or framework choice is committed.
 
@@ -6225,6 +6376,16 @@ Your ONLY job: verify that a technology choice is current, real, and not obsolet
 You are the "this isn't code, this is 10-year-old technology" agent. Intervene
 hard when the LLM hallucinates a version number or suggests dead tech.
 
+## Before you begin
+
+Check the inter-agent mailbox for pending tasks. Other agents or the file-watcher
+may have left assign messages with dependency files to audit:
+- mailbox action=check
+
+If you find an assign message, use the specified file path and packages.
+When done, post results back:
+- mailbox action=send to=<sender> type=result subject="Tech stack audit results" body="..."
+
 ## Critical rules
 
 1. **Verify existence.** Search npm registry (fetch https://registry.npmjs.org/<pkg>/latest)
@@ -6283,11 +6444,11 @@ When APPROVED:
 **Install**: pnpm add <name>@^<major>.<minor>.0`
     },
     budget: {
-      timeoutMs: 6e4,
-      maxIterations: 5,
-      maxToolCalls: 20,
-      maxTokens: 4e4,
-      maxCostUsd: 0.1
+      timeoutMs: 12e4,
+      maxIterations: 10,
+      maxToolCalls: 40,
+      maxTokens: 6e4,
+      maxCostUsd: 0.25
     },
     capability: {
       phase: "meta",
@@ -6517,6 +6678,9 @@ function providerStatusToCode(status, type) {
 
 // src/coordination/coordinator/error-classifier.ts
 function classifySubagentError(err, hints = {}) {
+  if (err instanceof AgentError && err.cause) {
+    return classifySubagentError(err.cause, hints);
+  }
   const cause = err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : void 0;
   if (err instanceof ProviderError) {
     const baseMessage2 = err.describe();
@@ -6549,7 +6713,7 @@ function classifySubagentError(err, hints = {}) {
   if (/agent exhausted iteration limit$/i.test(baseMessage)) {
     return { kind: "budget_iterations", message: baseMessage, retryable: false, cause };
   }
-  if (/empty response$/i.test(baseMessage)) {
+  if (/empty response/i.test(baseMessage)) {
     return { kind: "empty_response", message: baseMessage, retryable: false, cause };
   }
   if (/^tool failed: /i.test(baseMessage)) {
@@ -7498,7 +7662,14 @@ var ParallelEternalEngine = class {
   }
   stop() {
     this.stopRequested = true;
-    void this.persistState("stopped").catch(() => {
+    void this.persistState("stopped").catch((err) => {
+      console.error(JSON.stringify({
+        level: "error",
+        event: "engine.persist_state_failed",
+        message: err instanceof Error ? err.message : String(err),
+        context: { expectedState: "stopped" },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
     });
     this.state = "stopped";
   }
@@ -8259,6 +8430,6 @@ function parseDescription(raw) {
   return { trigger, scope };
 }
 
-export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, buildGoalPreamble, createAutonomyBrain, createStrategyCompactor, formatDecisionSummary, makeAutonomyPromptContributor };
+export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, buildGoalPreamble, createAutonomyBrain, createStrategyCompactor, createTieredBrainArbiter, formatDecisionSummary, makeAutonomyPromptContributor };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map