@wrongstack/core 0.1.9 → 0.2.0

package/dist/execution/index.js

@@ -0,0 +1,1625 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+// src/utils/token-estimate.ts
+var RoughTokenEstimate = (text) => Math.max(1, Math.ceil(text.length / 4));
+var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
+var ESTIMATE_CACHE_MAX_SIZE = 1e4;
+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(keys[i]);
+    }
+  }
+  const estimate = compute();
+  ESTIMATE_CACHE.set(key, estimate);
+  return estimate;
+}
+function estimateToolInputTokens(input) {
+  if (typeof input === "string") return RoughTokenEstimate(input);
+  if (input === null || typeof input !== "object") {
+    return RoughTokenEstimate(String(input));
+  }
+  const key = JSON.stringify(input);
+  return getCachedEstimate(key, () => RoughTokenEstimate(key));
+}
+function estimateToolResultTokens(content) {
+  if (typeof content === "string") return RoughTokenEstimate(content);
+  const key = JSON.stringify(content);
+  return getCachedEstimate(key, () => RoughTokenEstimate(key));
+}
+function estimateTextTokens(text) {
+  return RoughTokenEstimate(text);
+}
+
+// src/execution/compactor.ts
+var HybridCompactor = class {
+  preserveK;
+  eliseThreshold;
+  estimator;
+  constructor(opts = {}) {
+    this.preserveK = opts.preserveK ?? 10;
+    this.eliseThreshold = opts.eliseThreshold ?? 2e3;
+    this.estimator = opts.estimator ?? estimateTextTokens;
+  }
+  async compact(ctx, opts = {}) {
+    const beforeTokens = this.estimateMessages(ctx.messages);
+    const reductions = [];
+    const phase1Saved = this.eliseOldToolResults(ctx);
+    if (phase1Saved > 0) reductions.push({ phase: "elision", saved: phase1Saved });
+    if (opts.aggressive) {
+      const phase2Saved = this.collapseAncientTurns(ctx);
+      if (phase2Saved > 0) reductions.push({ phase: "summary", saved: phase2Saved });
+    }
+    const afterTokens = this.estimateMessages(ctx.messages);
+    return { before: beforeTokens, after: afterTokens, reductions };
+  }
+  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 tokens = estimateToolResultTokens(b.content);
+        if (tokens < this.eliseThreshold) return b;
+        saved += tokens;
+        const elided = {
+          type: "tool_result",
+          tool_use_id: b.tool_use_id,
+          content: `[elided: ~${tokens} tokens removed. Call the tool again if needed.]`,
+          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;
+  }
+  collapseAncientTurns(ctx) {
+    const messages = ctx.messages;
+    const cutTarget = Math.max(0, messages.length - this.preserveK * 2);
+    if (cutTarget <= 0) return 0;
+    let boundary = -1;
+    for (let i = cutTarget; i < messages.length; i++) {
+      const m = messages[i];
+      if (!m) continue;
+      if (m.role === "user" && hasTextContent(m)) {
+        boundary = i;
+        break;
+      }
+    }
+    if (boundary <= 0) return 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 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;
+  }
+};
+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 {
+  provider;
+  warnThreshold;
+  softThreshold;
+  hardThreshold;
+  maxContext;
+  preserveK;
+  eliseThreshold;
+  summarizerPrompt;
+  summarizerModel;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.warnThreshold = opts.warnThreshold ?? 0.6;
+    this.softThreshold = opts.softThreshold ?? 0.75;
+    this.hardThreshold = opts.hardThreshold ?? 0.9;
+    this.maxContext = opts.maxContext ?? 128e3;
+    this.preserveK = opts.preserveK ?? 4;
+    this.eliseThreshold = opts.eliseThreshold ?? 500;
+    this.summarizerPrompt = opts.summarizerPrompt ?? "You are a context summarizer. Given a list of conversation messages, produce a concise but complete summary that preserves all factual information, decisions made, and any state changes (e.g. file edits, todo updates). Do not add commentary. Output only the summary.";
+    this.summarizerModel = opts.summarizerModel;
+  }
+  async compact(ctx, opts = {}) {
+    const beforeTokens = this.estimateTokens(ctx.messages);
+    const reductions = [];
+    const load = beforeTokens / this.maxContext;
+    const aggressive = load >= this.hardThreshold ? true : opts.aggressive ?? load >= this.softThreshold;
+    const saved1 = this.eliseOldToolResults(ctx);
+    if (saved1 > 0) reductions.push({ phase: "elision", saved: saved1 });
+    if (aggressive) {
+      const saved2 = await this.summarizeAncientTurns(ctx);
+      if (saved2 > 0) reductions.push({ phase: "summary", saved: saved2 });
+    } else if (load >= this.warnThreshold) {
+      const saved2 = this.lightweightCompact(ctx);
+      if (saved2 > 0) reductions.push({ phase: "elision", saved: saved2 });
+    }
+    const afterTokens = this.estimateTokens(ctx.messages);
+    return { before: beforeTokens, after: afterTokens, reductions };
+  }
+  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;
+    const toSummarize = messages.slice(0, boundary);
+    const removedTokens = this.estimateTokens(toSummarize);
+    let summaryText;
+    try {
+      summaryText = await this.callSummarizer(toSummarize, ctx);
+    } catch {
+      summaryText = `[${toSummarize.length} earlier turns omitted \u2014 key decisions and file states preserved in context]`;
+    }
+    const summaryMsg = {
+      role: "system",
+      content: `[prior_turns_summary: ${summaryText}]`
+    };
+    const summaryTokens = this.estimateTokens([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 hasToolUse = Array.isArray(m.content) ? m.content.some((b) => b.type === "tool_use") : false;
+        if (!hasToolUse) {
+          return i + 1;
+        }
+      } else if (m.role !== "user") ; else {
+        return i;
+      }
+    }
+    return 0;
+  }
+  async callSummarizer(messages, ctx) {
+    const prompt = [
+      { type: "text", text: this.summarizerPrompt },
+      { type: "text", text: "\n\nConversation to summarize:\n" },
+      ...this.messagesToText(messages)
+    ];
+    const req = {
+      model: this.summarizerModel ?? ctx.model,
+      system: prompt,
+      messages: [],
+      maxTokens: 1024
+    };
+    const ac = ctx.signal ? void 0 : new AbortController();
+    const signal = ctx.signal ?? ac.signal;
+    const res = await this.provider.complete(req, { signal });
+    const textBlocks = res.content.filter(isTextBlock);
+    return textBlocks.map((b) => b.text).join("\n").trim() || "(empty summary)";
+  }
+  messagesToText(messages) {
+    const lines = [];
+    for (const m of messages) {
+      const role = m.role.padEnd(10, " ");
+      if (typeof m.content === "string") {
+        lines.push(`[${role}]: ${m.content.slice(0, 500)}`);
+      } else if (Array.isArray(m.content)) {
+        const textParts = m.content.filter(isTextBlock).map((b) => b.text);
+        if (textParts.length > 0) {
+          lines.push(`[${role}]: ${textParts.join(" ").slice(0, 500)}`);
+        }
+      }
+    }
+    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;
+      }
+    }
+    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
+var DEFAULT_SYSTEM_PROMPT = `You are a context pruning assistant. Given a conversation history and a token budget, decide which message ranges are worth keeping verbatim and which should be collapsed into summaries.
+
+Output a JSON object with this structure:
+{
+  "kept": [{"from": 0, "to": 5, "importance": "critical"}],
+  "collapsed": [{"from": 6, "to": 20, "summary": "optional summary"}],
+  "reasoning": "brief explanation of decisions"
+}
+
+Importance tiers:
+- "critical": decisions, file edits, tool results that affect state, final answers
+- "high": substantive tool use, complex reasoning, non-obvious observations
+- "medium": routine exchanges, confirmations, straightforward Q&A
+
+Rules:
+- Always keep the most recent K pairs (preserve recency)
+- Never collapse the final 2 user/assistant pairs (working memory)
+- Preserve tool results that modified files or had external effects
+- Collapse old, low-information exchanges (greetings, acknowledgements, etc.)
+- 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;
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    const role = m.role.padEnd(10, " ");
+    let text;
+    if (typeof m.content === "string") {
+      text = m.content.slice(0, 500);
+    } else {
+      const content = m.content;
+      text = content.filter(isTextBlock).map((b) => b.text).join(" ");
+      const toolUses = content.filter((b) => b.type === "tool_use");
+      if (toolUses.length > 0) {
+        text += ` [tools: ${toolUses.map((b) => b.name).join(", ")}]`;
+      }
+    }
+    const line = `[${i}][${role}]: ${text}`;
+    if (used + line.length > maxChars) break;
+    lines.push(line);
+    used += line.length;
+  }
+  return lines.join("\n");
+}
+var LLMSelector = class {
+  provider;
+  model;
+  maxContextTokens;
+  systemPrompt;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.model = opts.model ?? "unknown";
+    this.maxContextTokens = opts.maxContextTokens ?? 4e4;
+    this.systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+  }
+  async select(messages, maxToKeep) {
+    const effectiveBudget = Math.min(maxToKeep, this.maxContextTokens);
+    const historyText = formatMessages(messages);
+    const totalTokens = estimateTokens(messages);
+    const systemText = `${this.systemPrompt}
+
+Conversation (${messages.length} messages, ~${totalTokens} tokens, budget: ${effectiveBudget}):
+`;
+    const budgetInstruction = totalTokens > effectiveBudget ? `
+
+IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiveBudget}). You MUST collapse enough to fit. Prefer collapsing older/lower-importance ranges.` : "";
+    const req = {
+      model: this.model,
+      system: [{ type: "text", text: systemText + budgetInstruction }],
+      messages: [{ role: "user", content: historyText }],
+      maxTokens: 1024
+    };
+    let raw;
+    try {
+      const ac = new AbortController();
+      const res = await this.provider.complete(req, { signal: ac.signal });
+      const textBlocks = res.content.filter(isTextBlock);
+      raw = textBlocks.map((b) => b.text).join("\n").trim();
+    } catch (err) {
+      return this.fallbackSelect(messages, effectiveBudget);
+    }
+    return this.parseSelectorOutput(raw, messages.length);
+  }
+  fallbackSelect(messages, budget) {
+    const toKeep = [];
+    const toCollapse = [];
+    let tokenCount = 0;
+    let startIdx = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = 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
+      );
+      if (tokenCount + cost <= budget) {
+        tokenCount += cost;
+      } else {
+        startIdx = i + 1;
+        break;
+      }
+    }
+    if (startIdx > 0) {
+      toCollapse.push({ from: 0, to: startIdx - 1 });
+    }
+    toKeep.push({ from: startIdx, to: messages.length - 1, importance: "high" });
+    return {
+      kept: toKeep,
+      collapsed: toCollapse,
+      reasoning: `Fallback: kept last ${messages.length - startIdx} messages within ${budget} token budget`
+    };
+  }
+  parseSelectorOutput(raw, messageCount) {
+    const jsonStart = raw.indexOf("{");
+    const jsonEnd = raw.lastIndexOf("}");
+    if (jsonStart === -1 || jsonEnd === -1) {
+      return this.fallbackSelect(
+        Array.from({ length: messageCount }, () => ({ role: "user", content: "" })),
+        this.maxContextTokens
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw.slice(jsonStart, jsonEnd + 1));
+    } catch {
+      return this.fallbackSelect(
+        Array.from({ length: messageCount }, () => ({ role: "user", content: "" })),
+        this.maxContextTokens
+      );
+    }
+    const obj = parsed;
+    const kept = obj.kept ?? [];
+    const collapsed = obj.collapsed ?? [];
+    return {
+      kept: kept.map((k) => ({
+        from: k.from,
+        to: k.to,
+        importance: k.importance ?? "medium"
+      })),
+      collapsed: collapsed.map((c) => ({ from: c.from, to: c.to, summary: c.summary })),
+      reasoning: typeof obj.reasoning === "string" ? obj.reasoning : ""
+    };
+  }
+};
+
+// src/execution/selective-compactor.ts
+var SelectiveCompactor = class {
+  provider;
+  selector;
+  warnThreshold;
+  softThreshold;
+  hardThreshold;
+  maxContext;
+  preserveK;
+  eliseThreshold;
+  summarizerModel;
+  summarizerPrompt;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.selector = opts.selector ?? new LLMSelector({ provider: opts.provider, model: opts.selectorModel });
+    this.warnThreshold = opts.warnThreshold ?? 0.6;
+    this.softThreshold = opts.softThreshold ?? 0.75;
+    this.hardThreshold = opts.hardThreshold ?? 0.9;
+    this.maxContext = opts.maxContext ?? 128e3;
+    this.preserveK = opts.preserveK ?? 4;
+    this.eliseThreshold = opts.eliseThreshold ?? 500;
+    this.summarizerModel = opts.summarizerModel ?? opts.selectorModel ?? "unknown";
+    this.summarizerPrompt = opts.summarizerPrompt ?? "You are a context summarizer. Given a list of messages, produce a concise summary that preserves all factual information, decisions, file changes, and state changes. Do not add commentary or opinions.";
+  }
+  async compact(ctx, opts = {}) {
+    const beforeTokens = this.estimateTokens(ctx.messages);
+    const reductions = [];
+    const load = beforeTokens / this.maxContext;
+    const shouldCompact = load >= this.warnThreshold || opts.aggressive;
+    if (!shouldCompact) {
+      const saved = this.eliseOldToolResults(ctx);
+      if (saved > 0) reductions.push({ phase: "elision", saved });
+      const afterTokens2 = this.estimateTokens(ctx.messages);
+      return { before: beforeTokens, after: afterTokens2, reductions };
+    }
+    const savedElision = this.eliseOldToolResults(ctx);
+    if (savedElision > 0) reductions.push({ phase: "elision", saved: savedElision });
+    const afterPhase1 = this.estimateTokens(ctx.messages);
+    const targetBudget = this.computeTargetBudget(load);
+    if (afterPhase1 > targetBudget) {
+      const savedSelective = await this.runSelector(ctx, targetBudget);
+      if (savedSelective > 0) reductions.push({ phase: "selective", saved: savedSelective });
+    }
+    const afterTokens = this.estimateTokens(ctx.messages);
+    return { before: beforeTokens, after: afterTokens, reductions };
+  }
+  /**
+   * Run the LLM selector to decide what to keep vs collapse.
+   * Returns the token savings achieved.
+   */
+  async runSelector(ctx, targetBudget) {
+    const before = this.estimateTokens(ctx.messages);
+    let result;
+    try {
+      result = await this.selector.select(ctx.messages, targetBudget);
+    } catch {
+      return this.aggressiveRecencyTrim(ctx);
+    }
+    await this.executePlan(ctx, result);
+    const after = this.estimateTokens(ctx.messages);
+    return Math.max(0, before - after);
+  }
+  /**
+   * Execute a SelectorResult plan: collapse/remove ranges and
+   * insert summaries where the selector provided them.
+   */
+  async executePlan(ctx, plan) {
+    if (ctx.messages.length === 0) return;
+    const messages = [...ctx.messages];
+    const sortedCollapsed = [...plan.collapsed].sort((a, b) => b.from - a.from);
+    for (const range of sortedCollapsed) {
+      if (range.from < 0 || range.to >= messages.length || range.from > range.to) continue;
+      let summary = range.summary;
+      if (!summary) {
+        const toSummarize = messages.slice(range.from, range.to + 1);
+        summary = await this.summarizeRange(toSummarize, ctx);
+      }
+      const summaryMsg = {
+        role: "system",
+        content: `[prior_turns_${range.from}-${range.to}: ${summary}]`
+      };
+      messages.splice(range.from, range.to - range.from + 1, summaryMsg);
+    }
+    ctx.state.replaceMessages(messages);
+  }
+  async summarizeRange(messages, ctx) {
+    const systemText = `${this.summarizerPrompt}
+
+Summarize the following message range:`;
+    const body = messages.map((m, i) => `[${i}] ${m.role}: ${this.messagePreview(m)}`).join("\n");
+    const req = {
+      model: this.summarizerModel,
+      system: [{ type: "text", text: systemText }],
+      messages: [{ role: "user", content: body }],
+      maxTokens: 512
+    };
+    try {
+      const res = await this.provider.complete(req, {
+        signal: ctx.signal ?? new AbortController().signal
+      });
+      return res.content.filter(isTextBlock).map((b) => b.text).join("\n").trim() || "(empty)";
+    } catch {
+      return `[${messages.length} earlier turns omitted]`;
+    }
+  }
+  messagePreview(m) {
+    if (typeof m.content === "string") return m.content.slice(0, 300);
+    return m.content.filter(isTextBlock).map((b) => b.text).join(" ").slice(0, 300);
+  }
+  /**
+   * Fallback when selector fails: aggressively trim from the oldest end
+   * until we hit targetBudget.
+   */
+  aggressiveRecencyTrim(ctx) {
+    const messages = ctx.messages;
+    const preserveIdx = Math.max(0, messages.length - this.preserveK * 2);
+    if (preserveIdx <= 0) return 0;
+    let boundary = preserveIdx;
+    for (let i = preserveIdx; i < messages.length && i < preserveIdx + 6; i++) {
+      const m = messages[i];
+      if (m.role === "user" && this.hasTextContent(m)) {
+        boundary = i;
+        break;
+      }
+    }
+    const removed = messages.slice(0, boundary);
+    const removedTokens = this.estimateTokens(removed);
+    const summaryMsg = {
+      role: "system",
+      content: `[${removed.length} earlier turns trimmed \u2014 see session log for details]`
+    };
+    const tail = messages.slice(boundary);
+    ctx.state.replaceMessages([summaryMsg, ...tail]);
+    return Math.max(0, removedTokens - this.estimateTokens([summaryMsg]));
+  }
+  computeTargetBudget(load) {
+    if (load >= this.hardThreshold) {
+      return Math.floor(this.maxContext * 0.5);
+    }
+    if (load >= this.softThreshold) {
+      return Math.floor(this.maxContext * 0.65);
+    }
+    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;
+  }
+  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 += this.roughTokenEstimate(m.content);
+      } else {
+        for (const b of m.content) {
+          if (b.type === "text") total += this.roughTokenEstimate(b.text);
+          else if (b.type === "tool_use") total += this.roughTokenEstimate(JSON.stringify(b.input));
+          else if (b.type === "tool_result") {
+            total += this.roughTokenEstimate(
+              typeof b.content === "string" ? b.content : JSON.stringify(b.content)
+            );
+          }
+        }
+      }
+    }
+    return total;
+  }
+  roughTokenEstimate(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
+  }
+};
+
+// src/types/errors.ts
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var AgentError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "agent",
+      severity: opts.code === "AGENT_ABORTED" ? "warning" : "error",
+      recoverable: opts.recoverable ?? opts.code === "AGENT_ITERATION_LIMIT",
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "AgentError";
+  }
+};
+function toWrongStackError(err, code = "AGENT_RUN_FAILED") {
+  if (err instanceof WrongStackError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  return new AgentError({
+    message,
+    code: code === "UNKNOWN" ? "AGENT_RUN_FAILED" : code,
+    cause: err
+  });
+}
+
+// src/execution/auto-compaction-middleware.ts
+var AutoCompactionMiddleware = class {
+  name = "AutoCompaction";
+  compactor;
+  warnThreshold;
+  softThreshold;
+  hardThreshold;
+  maxContext;
+  estimator;
+  aggressiveOn;
+  events;
+  failureMode;
+  /**
+   * @param compactor        Compactor to use for compaction.
+   * @param maxContext       Provider's max context window in tokens.
+   * @param estimator        Token estimation function.
+   * @param thresholds       Threshold fractions (0-1) of maxContext.
+   * @param opts             Optional behavior. By default, failures at the
+   *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
+   *                         the agent does not continue into a likely
+   *                         provider context overflow. Warn/soft failures
+   *                         still emit compaction.failed and continue.
+   */
+  constructor(compactor, maxContext, estimator, thresholds, optsOrAggressiveOn = {}, events) {
+    const opts = typeof optsOrAggressiveOn === "string" ? { aggressiveOn: optsOrAggressiveOn, events } : optsOrAggressiveOn;
+    this.compactor = compactor;
+    this.maxContext = maxContext;
+    this.estimator = estimator;
+    this.warnThreshold = thresholds.warn;
+    this.softThreshold = thresholds.soft;
+    this.hardThreshold = thresholds.hard;
+    this.aggressiveOn = opts.aggressiveOn ?? "soft";
+    this.events = opts.events;
+    this.failureMode = opts.failureMode ?? "throw_on_hard";
+  }
+  handler() {
+    return async (ctx, next) => {
+      const tokens = this.estimator(ctx);
+      const load = tokens / this.maxContext;
+      if (load >= this.hardThreshold) {
+        await this.compact(ctx, true, { level: "hard", tokens, load });
+      } else if (load >= this.softThreshold) {
+        await this.compact(ctx, this.aggressiveOn !== "hard", { level: "soft", tokens, load });
+      } else if (load >= this.warnThreshold) {
+        await this.compact(ctx, false, { level: "warn", tokens, load });
+      }
+      return next(ctx);
+    };
+  }
+  async compact(ctx, aggressive, pressure) {
+    try {
+      await this.compactor.compact(ctx, { aggressive });
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const fatal = this.failureMode === "throw" || this.failureMode === "throw_on_hard" && pressure.level === "hard";
+      this.events?.emit("compaction.failed", {
+        err: error,
+        aggressive,
+        level: pressure.level,
+        tokens: pressure.tokens,
+        maxContext: this.maxContext,
+        load: pressure.load,
+        fatal
+      });
+      if (fatal) {
+        throw new AgentError({
+          message: `Auto-compaction failed at ${pressure.level} threshold`,
+          code: "AGENT_CONTEXT_OVERFLOW",
+          recoverable: true,
+          context: {
+            level: pressure.level,
+            tokens: pressure.tokens,
+            maxContext: this.maxContext
+          },
+          cause: err
+        });
+      }
+    }
+  }
+};
+
+// src/utils/tool-output-serializer.ts
+function createToolOutputSerializer(opts = {}) {
+  const capBytes = opts.perIterationOutputCapBytes ?? 1e5;
+  function serialize(value) {
+    if (typeof value === "string") return value;
+    if (value === null || value === void 0) return "";
+    if (typeof value === "object") {
+      if (Array.isArray(value)) return value.map(serialize).join("\n");
+      if ("text" in value) {
+        const t = value.text;
+        return typeof t === "string" ? t : JSON.stringify(value, null, 2);
+      }
+      try {
+        return JSON.stringify(value, null, 2);
+      } catch {
+        return String(value);
+      }
+    }
+    return String(value);
+  }
+  function enforceCap(text, remainingBudget) {
+    if (remainingBudget <= 0) {
+      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+    }
+    const textBytes = Buffer.byteLength(text, "utf8");
+    if (textBytes <= remainingBudget) {
+      return { text, newBudget: remainingBudget - textBytes };
+    }
+    const marker = `
+\u2026[truncated ${textBytes - remainingBudget} bytes]\u2026
+`;
+    const markerBytes = Buffer.byteLength(marker, "utf8");
+    const available = remainingBudget - markerBytes;
+    if (available <= 0) {
+      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+    }
+    const half = Math.floor(available / 2);
+    const first = text.slice(0, half);
+    const second = text.slice(text.length - half);
+    return { text: `${first}${marker}${second}`, newBudget: 0 };
+  }
+  return { serialize, enforceCap, capBytes };
+}
+
+// src/execution/tool-executor.ts
+var ToolExecutor = class {
+  constructor(registry, opts) {
+    this.registry = registry;
+    this.opts = opts;
+    this.iterationTimeoutMs = opts.iterationTimeoutMs ?? 3e5;
+    this.serializer = createToolOutputSerializer({
+      perIterationOutputCapBytes: opts.perIterationOutputCapBytes ?? 1e5
+    });
+  }
+  registry;
+  opts;
+  serializer;
+  iterationTimeoutMs;
+  /**
+   * Execute a batch of tool uses using the configured strategy.
+   * Returns the execution results and the remaining output budget.
+   */
+  async executeBatch(toolUses, ctx, strategy) {
+    let budget = this.opts.perIterationOutputCapBytes ?? 1e5;
+    const runOne = async (use) => {
+      const start = Date.now();
+      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);
+        return { result, tool, durationMs: Date.now() - start };
+      }
+      const decision = await this.opts.permissionPolicy.evaluate(tool, use.input, ctx);
+      if (decision.permission === "deny") {
+        const result = this.deniedResult(use, decision.reason);
+        budget = this.decrementBudget(result, budget);
+        return { result, tool, durationMs: Date.now() - start };
+      }
+      if (decision.permission === "confirm") {
+        if (this.opts.confirmAwaiter) {
+          const choice = await this.opts.confirmAwaiter(tool, use.input, use.id, tool.name);
+          if (choice !== "yes" && choice !== "always") {
+            const result = {
+              type: "tool_result",
+              tool_use_id: use.id,
+              content: `Tool "${tool.name}" denied by user.`,
+              is_error: true
+            };
+            budget = this.decrementBudget(result, budget);
+            return { result, tool, durationMs: Date.now() - start };
+          }
+        } else {
+          const suggestedPattern = this.subjectFor(tool.name, use.input, tool.subjectKey) ?? tool.name;
+          const pending = {
+            type: "tool_confirm_pending",
+            toolUseId: use.id,
+            toolName: tool.name,
+            input: use.input,
+            suggestedPattern
+          };
+          return { result: pending, tool, durationMs: Date.now() - start };
+        }
+      }
+      const span = this.opts.tracer?.startSpan(`tool.${tool.name}`, {
+        "tool.name": tool.name,
+        "tool.mutating": tool.mutating,
+        "tool.permission": tool.permission
+      });
+      try {
+        const result = await this.executeTool(tool, use, ctx, budget);
+        budget = this.decrementBudget(result, budget);
+        span?.setAttribute("tool.is_error", !!result.is_error);
+        span?.setAttribute(
+          "tool.output_bytes",
+          typeof result.content === "string" ? result.content.length : 0
+        );
+        return { result, tool, durationMs: Date.now() - start };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const scrubbed = this.opts.secretScrubber.scrub(msg);
+        this.opts.renderer?.writeToolResult(tool.name, scrubbed, true);
+        const result = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Tool "${tool.name}" threw: ${scrubbed}`,
+          is_error: true
+        };
+        budget = this.decrementBudget(result, budget);
+        if (err instanceof Error) span?.recordError(err);
+        span?.setAttribute("tool.is_error", true);
+        return { result, tool, durationMs: Date.now() - start };
+      } finally {
+        span?.end();
+      }
+    };
+    const safeRun = async (use) => {
+      try {
+        return await runOne(use);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const scrubbed = this.opts.secretScrubber.scrub(msg);
+        const result = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Tool "${use.name}" execution failed: ${scrubbed}`,
+          is_error: true
+        };
+        budget = this.decrementBudget(result, budget);
+        return { result, tool: this.registry.get(use.name), durationMs: 0 };
+      }
+    };
+    if (strategy === "sequential") {
+      const outputs = [];
+      for (const use of toolUses) {
+        if (use) outputs.push(await safeRun(use));
+      }
+      return { outputs, remainingBudget: budget };
+    }
+    if (strategy === "parallel") {
+      const outputs = await Promise.all(toolUses.map((use) => safeRun(use)));
+      return { outputs, remainingBudget: budget };
+    }
+    const nonMutating = [];
+    const mutating = [];
+    for (const use of toolUses) {
+      if (!use) continue;
+      const tool = this.registry.get(use.name);
+      if (tool?.mutating) mutating.push(use);
+      else nonMutating.push(use);
+    }
+    const firstPass = await Promise.all(nonMutating.map((use) => safeRun(use)));
+    const secondPass = [];
+    for (const use of mutating) {
+      secondPass.push(await safeRun(use));
+    }
+    return {
+      outputs: [...firstPass, ...secondPass],
+      remainingBudget: budget
+    };
+  }
+  /**
+   * Execute a single tool with timeout, permission check, and output capping.
+   * Emits `tool.started` via the injected EventBus (if any) right before
+   * invoking the tool — closes the observability gap between "model decided
+   * to call a tool" and "tool.executed".
+   */
+  async executeTool(tool, use, ctx, budget) {
+    this.opts.events?.emit("tool.started", {
+      name: tool.name,
+      id: use.id,
+      input: use.input
+    });
+    this.opts.renderer?.writeToolCall(tool.name, use.input);
+    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);
+    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
+    };
+  }
+  async runWithTimeout(tool, input, parentSignal, ctx, toolUseId) {
+    if (parentSignal.aborted) {
+      if (parentSignal.reason instanceof Error) throw parentSignal.reason;
+      throw new Error(typeof parentSignal.reason === "string" ? parentSignal.reason : "aborted");
+    }
+    const timeoutMs = tool.timeoutMs ?? this.iterationTimeoutMs;
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(new Error("tool timeout")), timeoutMs);
+    const combined = AbortSignal.any([parentSignal, ctrl.signal]);
+    try {
+      if (typeof tool.executeStream === "function") {
+        return await this.runStreamedTool(tool, input, ctx, combined, toolUseId);
+      }
+      return await tool.execute(input, ctx, { signal: combined });
+    } catch (err) {
+      if (combined.aborted && typeof tool.cleanup === "function") {
+        try {
+          await tool.cleanup(input, ctx);
+        } catch {
+        }
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async runStreamedTool(tool, input, ctx, signal, toolUseId) {
+    let finalOutput;
+    let sawFinal = false;
+    const stream = tool.executeStream(input, ctx, { signal });
+    for await (const ev of stream) {
+      if (ev.type === "final") {
+        finalOutput = ev.output;
+        sawFinal = true;
+        break;
+      }
+      this.opts.events?.emit("tool.progress", {
+        name: tool.name,
+        id: toolUseId ?? "<unknown>",
+        event: ev
+      });
+    }
+    if (!sawFinal) {
+      throw new Error(`tool "${tool.name}" executeStream completed without a 'final' event`);
+    }
+    return finalOutput;
+  }
+  unknownToolResult(use, listFns) {
+    return {
+      type: "tool_result",
+      tool_use_id: use.id,
+      content: `Tool "${use.name}" is not registered. Available tools: ${listFns().join(", ")}`,
+      is_error: true
+    };
+  }
+  deniedResult(use, reason) {
+    return {
+      type: "tool_result",
+      tool_use_id: use.id,
+      content: `Tool "${use.name}" denied: ${reason ?? "policy"}`,
+      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);
+  }
+  /**
+   * Compute the suggestedPattern string for a tool+input pair.
+   * Matches the logic in DefaultPermissionPolicy so the TUI shows the
+   * same subject that the trust file would use.
+   */
+  subjectFor(toolName, input, subjectKey) {
+    if (!input || typeof input !== "object") return void 0;
+    const obj = input;
+    const globChars = /[*?\[\]]/g;
+    const escapeGlob = (s) => s.replace(globChars, (c) => `\\${c}`);
+    const normalizePath = (s) => escapeGlob(s.replace(/\\/g, "/"));
+    if (subjectKey) {
+      const v = obj[subjectKey];
+      if (typeof v === "string") {
+        return subjectKey === "path" || subjectKey === "file" || subjectKey === "files" ? normalizePath(v) : escapeGlob(v);
+      }
+    }
+    if (toolName === "bash" && typeof obj.command === "string") {
+      return escapeGlob(obj.command);
+    }
+    if (typeof obj.path === "string") {
+      return normalizePath(obj.path);
+    }
+    if (typeof obj.url === "string") {
+      return escapeGlob(obj.url);
+    }
+    if (typeof obj.name === "string") {
+      return escapeGlob(obj.name);
+    }
+    return void 0;
+  }
+};
+
+// src/execution/autonomous-runner.ts
+var DoneConditionChecker = class {
+  constructor(condition) {
+    this.condition = condition;
+    this.compiledRegex = condition.type === "output_match" && condition.pattern ? new RegExp(condition.pattern) : null;
+  }
+  condition;
+  compiledRegex;
+  check(state) {
+    switch (this.condition.type) {
+      case "iterations":
+        if (this.condition.maxIterations && state.iterations >= this.condition.maxIterations) {
+          return {
+            done: true,
+            reason: `max iterations (${this.condition.maxIterations}) reached`,
+            ...state
+          };
+        }
+        break;
+      case "tool_calls":
+        if (this.condition.maxToolCalls && state.toolCalls >= this.condition.maxToolCalls) {
+          return {
+            done: true,
+            reason: `max tool calls (${this.condition.maxToolCalls}) reached`,
+            ...state
+          };
+        }
+        break;
+      case "output_match":
+        if (this.compiledRegex && state.lastOutput && this.compiledRegex.test(state.lastOutput)) {
+          return {
+            done: true,
+            reason: `output matched pattern "${this.condition.pattern}"`,
+            ...state
+          };
+        }
+        break;
+    }
+    return { done: false, iterations: state.iterations, toolCalls: state.toolCalls };
+  }
+};
+var AutonomousRunner = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.doneChecker = new DoneConditionChecker(opts.doneCondition);
+  }
+  opts;
+  iterations = 0;
+  toolCalls = 0;
+  lastOutput;
+  stopped = false;
+  doneChecker;
+  async run() {
+    const offToolExecuted = this.opts.agent.events?.on?.("tool.executed", () => {
+      this.toolCalls++;
+    });
+    try {
+      return await this.runLoop();
+    } finally {
+      offToolExecuted?.();
+    }
+  }
+  async runLoop() {
+    while (!this.stopped) {
+      const check = this.doneChecker.check({
+        iterations: this.iterations,
+        toolCalls: this.toolCalls,
+        lastOutput: this.lastOutput
+      });
+      if (check.done) {
+        const result = {
+          status: "done",
+          iterations: this.iterations,
+          toolCalls: this.toolCalls,
+          reason: check.reason
+        };
+        this.opts.onDone?.(result);
+        return result;
+      }
+      this.opts.onIteration?.({ iteration: this.iterations, toolCalls: this.toolCalls });
+      const ctrl = new AbortController();
+      const timeout = setTimeout(() => ctrl.abort(), this.opts.iterationTimeoutMs ?? 3e4);
+      try {
+        const result = await this.opts.agent.run("", {
+          signal: ctrl.signal,
+          maxIterations: 1,
+          executionStrategy: "sequential"
+        });
+        this.iterations++;
+        if (result.status === "done") {
+          this.lastOutput = result.finalText;
+        }
+        if (result.status === "failed" || result.status === "aborted") {
+          const failedResult = {
+            status: result.status,
+            error: result.error,
+            iterations: this.iterations,
+            toolCalls: this.toolCalls
+          };
+          this.opts.onDone?.(failedResult);
+          return failedResult;
+        }
+      } catch (e) {
+        const isAbort = e instanceof DOMException && e.name === "AbortError" || e instanceof Error && e.name === "AbortError" || e instanceof Error && e.message.includes("iteration timeout");
+        if (isAbort) {
+          const timeoutResult = {
+            status: "failed",
+            error: toWrongStackError(e),
+            iterations: this.iterations,
+            toolCalls: this.toolCalls,
+            reason: "iteration timeout"
+          };
+          this.opts.onDone?.(timeoutResult);
+          return timeoutResult;
+        }
+        this.stopped = true;
+        const failedResult = {
+          status: "failed",
+          error: toWrongStackError(e),
+          iterations: this.iterations,
+          toolCalls: this.toolCalls,
+          reason: e instanceof Error ? e.message : String(e)
+        };
+        this.opts.onDone?.(failedResult);
+        return failedResult;
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+    return {
+      status: "aborted",
+      iterations: this.iterations,
+      toolCalls: this.toolCalls,
+      reason: "stopped externally"
+    };
+  }
+  stop() {
+    this.stopped = true;
+  }
+};
+
+// src/types/provider.ts
+var ProviderError = class extends WrongStackError {
+  status;
+  retryable;
+  providerId;
+  body;
+  constructor(message, status, retryable, providerId, opts = {}) {
+    super({
+      message,
+      code: providerStatusToCode(status, opts.body?.type),
+      subsystem: "provider",
+      severity: status >= 500 ? "error" : "warning",
+      recoverable: retryable,
+      context: { providerId, status },
+      cause: opts.cause
+    });
+    this.name = "ProviderError";
+    this.status = status;
+    this.retryable = retryable;
+    this.providerId = providerId;
+    this.body = opts.body;
+  }
+  /**
+   * Render a one-line, user-facing description. Designed for the CLI/TUI
+   * status line and the agent's retry warning. Avoids dumping raw JSON
+   * (which is what users see today when a 529 lands and the log message
+   * includes the full `{"type":"error",...}` body).
+   *
+   * Examples:
+   *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
+   *   "openai rate limited (429): Retry after 12s"
+   *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
+   *   "groq HTTP 500 (server error)"
+   */
+  describe() {
+    const kind = describeStatus(this.status, this.body?.type);
+    const head = `${this.providerId} ${kind}`;
+    const detail = this.body?.message?.trim();
+    const reqId = this.body?.requestId ? ` [req ${this.body.requestId.slice(0, 16)}${this.body.requestId.length > 16 ? "\u2026" : ""}]` : "";
+    if (detail && detail.length > 0) {
+      return `${head}: ${truncate(detail, 240)}${reqId}`;
+    }
+    return `${head}${reqId}`;
+  }
+};
+function describeStatus(status, type) {
+  if (status === 0) return "network error";
+  if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
+  if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
+  if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
+  if (type === "permission_error" || status === 403) return `forbidden (${status})`;
+  if (type === "not_found_error" || status === 404) return `not found (${status})`;
+  if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
+  if (status === 408) return `timeout (${status})`;
+  if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
+  if (type) return `${type} (${status})`;
+  return `HTTP ${status}`;
+}
+function truncate(s, n) {
+  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
+}
+function providerStatusToCode(status, type) {
+  if (status === 0) return "PROVIDER_NETWORK_ERROR";
+  if (type === "rate_limit_error" || status === 429) return "PROVIDER_RATE_LIMITED";
+  if (type === "authentication_error" || status === 401) return "PROVIDER_AUTH_FAILED";
+  if (type === "overloaded_error" || status === 529) return "PROVIDER_OVERLOADED";
+  if (type === "invalid_request_error" || status === 400) return "PROVIDER_INVALID_REQUEST";
+  if (status === 408) return "PROVIDER_NETWORK_ERROR";
+  if (status >= 500) return "PROVIDER_SERVER_ERROR";
+  return "PROVIDER_INVALID_REQUEST";
+}
+
+// src/execution/retry-policy.ts
+var DefaultRetryPolicy = class _DefaultRetryPolicy {
+  static NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
+  shouldRetry(err, attempt) {
+    if (err instanceof ProviderError) {
+      if (!err.retryable) return false;
+      return attempt < this.maxAttempts(err);
+    }
+    const msg = err.message ?? "";
+    const isNetwork = _DefaultRetryPolicy.NETWORK_ERR_RE.test(msg);
+    if (isNetwork) return attempt < 2;
+    return false;
+  }
+  maxAttempts(err) {
+    if (err instanceof ProviderError) {
+      if (err.status === 429) return 5;
+      if (err.status === 529) return 3;
+      if (err.status >= 500) return 3;
+      return 0;
+    }
+    return 2;
+  }
+  delayMs(attempt) {
+    const base = 1e3;
+    const exp = base * 2 ** attempt;
+    const jitter = Math.random() * base;
+    return Math.min(3e4, exp + jitter);
+  }
+};
+
+// src/execution/error-handler.ts
+var CONTEXT_OVERFLOW_RE = /context|too long|tokens/i;
+var NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
+function buildRecoveryStrategies(opts) {
+  return [
+    {
+      label: "context_overflow_reduce",
+      compactor: opts?.compactor,
+      async attempt(err, ctx) {
+        if (!(err instanceof ProviderError)) return null;
+        if (err.status !== 413 && !CONTEXT_OVERFLOW_RE.test(err.message)) return null;
+        if (this.compactor) {
+          try {
+            const report = await this.compactor.compact(ctx, { aggressive: true });
+            if (report.after < report.before) {
+              return { action: "retry", reason: "context_compacted" };
+            }
+          } catch {
+          }
+        }
+        return null;
+      }
+    },
+    {
+      label: "rate_limit_backoff",
+      async attempt(err) {
+        if (!(err instanceof ProviderError) || err.status !== 429) return null;
+        const delayMs = err.body?.retryAfterMs ?? 5e3;
+        const delay = Math.max(1e3, Math.min(delayMs, 6e4));
+        await new Promise((r) => setTimeout(r, delay));
+        return { action: "retry", reason: "rate_limit_backoff" };
+      }
+    },
+    {
+      label: "downgrade_model",
+      async attempt(err, ctx) {
+        if (!(err instanceof ProviderError)) return null;
+        if (err.status !== 429 && err.status !== 529 && err.status < 500) return null;
+        return null;
+      }
+    }
+  ];
+}
+var DEFAULT_RECOVERY_STRATEGIES = buildRecoveryStrategies();
+var DefaultErrorHandler = class {
+  strategies;
+  constructor(strategies = DEFAULT_RECOVERY_STRATEGIES) {
+    this.strategies = strategies;
+  }
+  classify(err) {
+    if (typeof DOMException !== "undefined" && err instanceof DOMException && err.name === "AbortError") {
+      return { kind: "abort", retryable: false };
+    }
+    if (err instanceof Error && err.name === "AbortError") {
+      return { kind: "abort", retryable: false };
+    }
+    if (err instanceof ProviderError) {
+      if (err.status === 429) return { kind: "rate_limit", retryable: true };
+      if (err.status === 529) return { kind: "overloaded", retryable: true };
+      if (err.status >= 500) return { kind: "server", retryable: true };
+      if (err.status === 413 || CONTEXT_OVERFLOW_RE.test(err.message)) {
+        return { kind: "context_overflow", retryable: false };
+      }
+      if (err.status >= 400) return { kind: "client", retryable: false };
+    }
+    if (err instanceof Error && NETWORK_ERR_RE.test(err.message)) {
+      return { kind: "network", retryable: true };
+    }
+    return { kind: "unknown", retryable: false };
+  }
+  async recover(err, ctx) {
+    for (const strategy of this.strategies) {
+      const result = await strategy.attempt(err, ctx);
+      if (result !== null) return result;
+    }
+    return null;
+  }
+};
+var DefaultSkillLoader = class {
+  dirs;
+  cache;
+  constructor(opts) {
+    this.dirs = [
+      { dir: opts.paths.inProjectSkills, source: "project" },
+      { dir: opts.paths.globalSkills, source: "user" }
+    ];
+    if (opts.bundledDir) {
+      this.dirs.push({ dir: opts.bundledDir, source: "bundled" });
+    }
+  }
+  async list() {
+    if (this.cache) return this.cache;
+    const found = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const { dir, source } of this.dirs) {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const e of entries) {
+          if (!e.isDirectory()) continue;
+          const skillFile = path.join(dir, e.name, "SKILL.md");
+          try {
+            const raw = await fs.readFile(skillFile, "utf8");
+            const meta = parseFrontmatter(raw);
+            if (!meta.name || !meta.description) continue;
+            if (seen.has(meta.name)) continue;
+            seen.add(meta.name);
+            found.push({
+              name: meta.name,
+              description: meta.description,
+              version: meta.version,
+              path: skillFile,
+              source
+            });
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    this.cache = found;
+    return found;
+  }
+  async find(name) {
+    const all = await this.list();
+    return all.find((s) => s.name === name);
+  }
+  async manifestText() {
+    const skills = await this.list();
+    if (skills.length === 0) return "";
+    const entries = await this.listEntries();
+    const lines = ["## Available skills"];
+    for (const e of entries) {
+      const scopeTag = e.scope.length > 0 ? ` \u2014 ${e.scope.slice(0, 3).join(", ")}` : "";
+      lines.push(`- **${e.name}**${scopeTag}`);
+      lines.push(`  Use when: ${e.trigger}`);
+    }
+    return lines.join("\n");
+  }
+  async listEntries() {
+    const skills = await this.list();
+    const entries = [];
+    for (const s of skills) {
+      try {
+        const raw = await fs.readFile(s.path, "utf8");
+        const { trigger, scope } = parseDescription(raw);
+        entries.push({ name: s.name, trigger, scope, source: s.source, path: s.path });
+      } catch {
+      }
+    }
+    return entries;
+  }
+  async readBody(name) {
+    const m = await this.find(name);
+    if (!m) throw new Error(`Skill "${name}" not found`);
+    return fs.readFile(m.path, "utf8");
+  }
+};
+function parseFrontmatter(raw) {
+  if (!raw.startsWith("---")) return {};
+  const end = raw.indexOf("\n---", 4);
+  if (end === -1) return {};
+  const block = raw.slice(4, end);
+  const out = {};
+  let key = null;
+  let value = [];
+  const flush = () => {
+    if (key) {
+      out[key] = value.join("\n").trim();
+    }
+    key = null;
+    value = [];
+  };
+  for (const line of block.split("\n")) {
+    const m = /^([a-zA-Z_]+):\s*(\|?)\s*(.*)$/.exec(line);
+    if (m) {
+      flush();
+      key = m[1] ?? "";
+      const pipe = m[2];
+      const rest = m[3] ?? "";
+      if (pipe === "|") {
+        value = [];
+      } else if (rest) {
+        value = [rest];
+      } else {
+        value = [];
+      }
+    } else if (key) {
+      value.push(line.replace(/^\s+/, ""));
+    }
+  }
+  flush();
+  return out;
+}
+function parseDescription(raw) {
+  const fm = parseFrontmatter(raw);
+  const desc = fm.description ?? "";
+  const firstSentenceEnd = desc.indexOf(". ");
+  const trigger = firstSentenceEnd !== -1 ? desc.slice(0, firstSentenceEnd + 1).trim() : desc.trim().split("\n")[0] ?? "";
+  const scope = [];
+  const coversMatch = /(?:covers|for|including)\s+([^.]+)/i.exec(desc);
+  if (coversMatch) {
+    const items = coversMatch[1].replace(/[·•]/g, ",").split(",").map((s) => s.trim()).filter(Boolean);
+    scope.push(...items);
+  }
+  return { trigger, scope };
+}
+
+export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, HybridCompactor, IntelligentCompactor, SelectiveCompactor, ToolExecutor };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map