@wrongstack/core 0.2.0 → 0.3.1

package/dist/index.js

@@ -395,6 +395,7 @@ var Pipeline = class {
 // src/kernel/events.ts
 var EventBus = class {
   listeners = /* @__PURE__ */ new Map();
+  wildcards = [];
   logger;
   setLogger(logger) {
     this.logger = logger;
@@ -421,24 +422,73 @@ var EventBus = class {
       this.off(event, wrapper);
     };
   }
+  /**
+   * Subscribe to all events whose name matches a glob-style prefix.
+   * `'tool.*'` matches `tool.started`, `tool.executed`, `tool.progress`, etc.
+   * `'*'` matches every event.
+   *
+   * The handler receives `(eventName, payload)` with the event name as a
+   * string and the payload as `unknown`. Use for logging, debugging, or
+   * metrics collection across a family of events.
+   *
+   * Returns an unsubscribe function.
+   */
+  onPattern(pattern, fn) {
+    const match = makePatternMatcher(pattern);
+    const entry = { match, fn };
+    this.wildcards.push(entry);
+    return () => {
+      const idx = this.wildcards.indexOf(entry);
+      if (idx >= 0) this.wildcards.splice(idx, 1);
+    };
+  }
+  /**
+   * Subscribe to all events whose name matches a RegExp.
+   * More flexible than `onPattern` — use when you need regex features
+   * (alternation, character classes, capture groups).
+   *
+   * Returns an unsubscribe function.
+   */
+  onRegex(regex, fn) {
+    const entry = { match: (e) => regex.test(e), fn };
+    this.wildcards.push(entry);
+    return () => {
+      const idx = this.wildcards.indexOf(entry);
+      if (idx >= 0) this.wildcards.splice(idx, 1);
+    };
+  }
   emit(event, payload) {
     const set = this.listeners.get(event);
-    if (!set) return;
-    for (const fn of set) {
-      try {
-        fn(payload);
-      } catch (err) {
-        this.logger?.error(`EventBus listener for "${event}" threw`, err);
+    if (set) {
+      for (const fn of set) {
+        try {
+          fn(payload);
+        } catch (err) {
+          this.logger?.error(`EventBus listener for "${event}" threw`, err);
+        }
+      }
+    }
+    if (this.wildcards.length > 0) {
+      const name = event;
+      for (const { match, fn } of this.wildcards) {
+        if (!match(name)) continue;
+        try {
+          fn(name, payload);
+        } catch (err) {
+          this.logger?.error(`EventBus wildcard listener for "${name}" threw`, err);
+        }
       }
     }
   }
   clear() {
     this.listeners.clear();
+    this.wildcards.length = 0;
   }
   /**
    * V2-D: introspection helper. Pass an `event` to count handlers for a
    * single key, or omit to get the total across every event. Used by the
    * leak-detection smoke test to flag handler accumulation across runs.
+   * Does NOT include wildcard listeners.
    */
   listenerCount(event) {
     if (event !== void 0) return this.listeners.get(event)?.size ?? 0;
@@ -446,7 +496,21 @@ var EventBus = class {
     for (const set of this.listeners.values()) total += set.size;
     return total;
   }
+  /**
+   * Number of wildcard listeners currently registered.
+   */
+  wildcardCount() {
+    return this.wildcards.length;
+  }
 };
+function makePatternMatcher(pattern) {
+  if (pattern === "*") return () => true;
+  if (pattern.endsWith(".*")) {
+    const prefix = pattern.slice(0, -2);
+    return (e) => e.startsWith(`${prefix}.`);
+  }
+  return (e) => e === pattern;
+}
 
 // src/kernel/tokens.ts
 var t = (name) => Symbol(name);
@@ -468,7 +532,9 @@ var TOKENS = {
   SystemPromptBuilder: t("SystemPromptBuilder"),
   SecretScrubber: t("SecretScrubber"),
   ModelsRegistry: t("ModelsRegistry"),
-  ModeStore: t("ModeStore")
+  ModeStore: t("ModeStore"),
+  /** Replaces the entire provider call layer — retry, streaming, tracing. */
+  ProviderRunner: t("ProviderRunner")
 };
 
 // src/kernel/run-controller.ts
@@ -1539,7 +1605,7 @@ async function atomicWrite(targetPath, content, opts = {}) {
     if (mode !== void 0) {
       await fsp2.chmod(tmp, mode);
     }
-    await fsp2.rename(tmp, targetPath);
+    await renameWithRetry(tmp, targetPath);
   } catch (err) {
     try {
       await fsp2.unlink(tmp);
@@ -1551,6 +1617,29 @@ async function atomicWrite(targetPath, content, opts = {}) {
 async function ensureDir(dir) {
   await fsp2.mkdir(dir, { recursive: true });
 }
+var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    await fsp2.rename(from, to);
+    return;
+  }
+  const delays = [10, 25, 60, 120, 250];
+  let lastErr;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await fsp2.rename(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
+        throw err;
+      }
+      await new Promise((resolve4) => setTimeout(resolve4, delays[i]));
+    }
+  }
+  throw lastErr;
+}
 
 // src/models/models-registry.ts
 var DEFAULT_URL = "https://models.dev/api.json";
@@ -4889,501 +4978,424 @@ function parseDescription(raw) {
   return { trigger, scope };
 }
 
-// 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);
+// src/core/streaming-response-builder.ts
+function buildResponse(state) {
+  const content = [];
+  for (const b of state.blockOrder) {
+    if (b.kind === "text") {
+      const txt = state.textBuffers[b.idx] ?? "";
+      if (txt) content.push({ type: "text", text: txt });
+    } else if (b.kind === "thinking") {
+      const t2 = state.thinking[b.idx];
+      if (!t2) continue;
+      if (!t2.textBuf && !t2.signature) continue;
+      const block = { type: "thinking", thinking: t2.textBuf };
+      if (t2.signature) block.signature = t2.signature;
+      if (t2.providerMeta && Object.keys(t2.providerMeta).length > 0) {
+        block.providerMeta = t2.providerMeta;
       }
-    }
-    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;
+      content.push(block);
+    } else {
+      const tb = state.tools.get(b.id);
+      if (tb) {
+        const block = {
+          type: "tool_use",
+          id: b.id,
+          name: tb.name,
+          input: tb.input ?? {}
+        };
+        if (tb.providerMeta && Object.keys(tb.providerMeta).length > 0) {
+          block.providerMeta = tb.providerMeta;
         }
-      } else if (m.role !== "user") ; else {
-        return i;
+        content.push(block);
       }
     }
-    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)";
+  if (content.length === 0) content.push({ type: "text", text: "" });
+  return { content, stopReason: state.stopReason, usage: state.usage, model: state.model };
+}
+function createStreamingState(model) {
+  return {
+    model,
+    stopReason: "end_turn",
+    usage: { input: 0, output: 0 },
+    textBuffers: [],
+    currentTextIndex: -1,
+    tools: /* @__PURE__ */ new Map(),
+    thinking: [],
+    currentThinkingIndex: -1,
+    blockOrder: []
+  };
+}
+function handleMessageStart(state, model) {
+  state.model = model;
+}
+function handleContentBlockStart(state, ev) {
+  const kind = ev.kind ?? "text";
+  if (kind === "text") {
+    state.currentTextIndex = state.textBuffers.length;
+    state.textBuffers.push("");
+    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
+  } else if (kind === "tool_use") {
+    const id = ev.id ?? crypto.randomUUID();
+    state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
+    state.blockOrder.push({ kind: "tool", id });
+    state.currentTextIndex = -1;
+  } else if (kind === "thinking") {
+    state.currentThinkingIndex = state.thinking.length;
+    state.thinking.push({
+      textBuf: "",
+      ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
+    });
+    state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
+    state.currentTextIndex = -1;
   }
-  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") }];
+}
+function handleContentBlockStop(state, ev) {
+}
+function handleTextDelta(state, text) {
+  if (state.currentTextIndex === -1) {
+    state.currentTextIndex = state.textBuffers.length;
+    state.textBuffers.push("");
+    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
   }
-  lightweightCompact(ctx) {
-    return this.eliseOldToolResults(ctx);
+  state.textBuffers[state.currentTextIndex] = (state.textBuffers[state.currentTextIndex] ?? "") + text;
+}
+function handleToolUseStart(state, ev) {
+  state.currentTextIndex = -1;
+  state.tools.set(ev.id, { name: ev.name, partial: "" });
+  state.blockOrder.push({ kind: "tool", id: ev.id });
+}
+function handleToolUseInputDelta(state, ev) {
+  const t2 = state.tools.get(ev.id);
+  if (t2) t2.partial += ev.partial;
+}
+function safeJsonOrRaw(s) {
+  if (!s) return {};
+  try {
+    return JSON.parse(s);
+  } catch {
+    return { _raw: s };
   }
-  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;
+}
+function handleToolUseStop(state, ev) {
+  const t2 = state.tools.get(ev.id);
+  if (t2) {
+    t2.input = ev.input !== void 0 ? ev.input : safeJsonOrRaw(t2.partial);
+    if (ev.providerMeta) t2.providerMeta = ev.providerMeta;
   }
-  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);
+  state.currentTextIndex = -1;
+}
+function handleThinkingStart(state, ev) {
+  state.currentThinkingIndex = state.thinking.length;
+  state.thinking.push({
+    textBuf: "",
+    ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
+  });
+  state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
+  state.currentTextIndex = -1;
+}
+function handleThinkingDelta(state, text) {
+  if (state.currentThinkingIndex === -1) {
+    handleThinkingStart(state, {});
   }
-  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;
+  const t2 = state.thinking[state.currentThinkingIndex];
+  if (t2) t2.textBuf += text;
+}
+function handleThinkingSignature(state, signature) {
+  if (state.currentThinkingIndex === -1) {
+    handleThinkingStart(state, {});
   }
-};
-
-// 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"
+  const t2 = state.thinking[state.currentThinkingIndex];
+  if (t2) t2.signature = signature;
 }
-
-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);
+function handleThinkingStop(state) {
+  state.currentThinkingIndex = -1;
+}
+function handleMessageStop(state, ev) {
+  state.stopReason = ev.stopReason ?? "end_turn";
+  state.usage = ev.usage ?? { input: 0, output: 0 };
+}
+async function streamProviderToResponse(provider, req, signal, ctx, events) {
+  const state = createStreamingState(req.model);
+  const iter = provider.stream(req, { signal })[Symbol.asyncIterator]();
+  try {
+    for (; ; ) {
+      const next = await iter.next();
+      if (next.done) break;
+      const ev = next.value;
+      switch (ev.type) {
+        case "message_start":
+          handleMessageStart(state, ev.model);
+          break;
+        case "content_block_start":
+          handleContentBlockStart(state, ev);
+          break;
+        case "content_block_stop":
+          handleContentBlockStop(state, ev);
+          break;
+        case "text_delta":
+          handleTextDelta(state, ev.text);
+          events.emit("provider.text_delta", { ctx, text: ev.text });
+          break;
+        case "tool_use_start":
+          handleToolUseStart(state, ev);
+          events.emit("provider.tool_use_start", { ctx, id: ev.id, name: ev.name });
+          break;
+        case "tool_use_input_delta":
+          handleToolUseInputDelta(state, ev);
+          break;
+        case "tool_use_stop":
+          handleToolUseStop(state, ev);
+          events.emit("provider.tool_use_stop", { ctx, id: ev.id });
+          break;
+        case "thinking_start":
+          handleThinkingStart(state, ev);
+          break;
+        case "thinking_delta":
+          handleThinkingDelta(state, ev.text);
+          events.emit("provider.thinking_delta", { ctx, text: ev.text });
+          break;
+        case "thinking_signature":
+          handleThinkingSignature(state, ev.signature);
+          break;
+        case "thinking_stop":
+          handleThinkingStop(state);
+          break;
+        case "message_stop":
+          handleMessageStop(state, ev);
+          break;
       }
     }
-  }
-  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(", ")}]`;
+  } catch (err) {
+    if (signal.aborted) {
+      state.stopReason = "end_turn";
+      return buildResponse(state);
+    }
+    throw err;
+  } finally {
+    try {
+      let drainTimer = null;
+      try {
+        await Promise.race([
+          Promise.resolve(iter.return?.()),
+          new Promise((resolve4) => {
+            drainTimer = setTimeout(resolve4, 500);
+          })
+        ]);
+      } finally {
+        if (drainTimer) clearTimeout(drainTimer);
       }
+    } catch {
     }
-    const line = `[${i}][${role}]: ${text}`;
-    if (used + line.length > maxChars) break;
-    lines.push(line);
-    used += line.length;
   }
-  return lines.join("\n");
+  return buildResponse(state);
 }
-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;
+// src/core/provider-runner.ts
+async function runProviderWithRetry(opts) {
+  const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
+  let attempt = 0;
+  for (; ; ) {
+    const span = tracer?.startSpan("provider.complete", {
+      "provider.id": provider.id,
+      "provider.model": request.model,
+      "provider.streaming": provider.capabilities.streaming,
+      "provider.attempt": attempt
+    });
     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;
+      const res = provider.capabilities.streaming ? await streamProviderToResponse(provider, request, signal, ctx, events) : await provider.complete(request, { signal });
+      span?.setAttribute("provider.stopReason", res.stopReason);
+      span?.setAttribute("provider.usage_in", res.usage.input);
+      span?.setAttribute("provider.usage_out", res.usage.output);
+      span?.end();
+      return res;
+    } catch (err) {
+      if (err instanceof Error) span?.recordError(err);
+      span?.end();
+      if (signal.aborted) throw err;
+      const isProviderErr = err instanceof ProviderError;
+      const errAsErr = err instanceof Error ? err : new Error(String(err));
+      const canRetry = retry.shouldRetry(isProviderErr ? err : errAsErr, attempt);
+      const description = isProviderErr ? err.describe() : errAsErr.message;
+      if (!canRetry) {
+        if (isProviderErr) {
+          events.emit("provider.error", {
+            providerId: err.providerId,
+            status: err.status,
+            description,
+            retryable: false
+          });
+        }
+        throw err;
       }
+      const delay = Math.round(retry.delayMs(attempt));
+      const attemptNum = attempt + 1;
+      logger.warn(`Provider retry ${attemptNum} in ${delay}ms \u2014 ${description}`);
+      if (isProviderErr) {
+        events.emit("provider.retry", {
+          providerId: err.providerId,
+          attempt: attemptNum,
+          delayMs: delay,
+          status: err.status,
+          description
+        });
+      }
+      await new Promise((resolve4, reject) => {
+        let settled = false;
+        const onAbort = () => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(t2);
+          reject(new Error("aborted"));
+        };
+        const t2 = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(t2);
+          signal.removeEventListener("abort", onAbort);
+          resolve4();
+        }, delay);
+        if (signal.aborted) {
+          onAbort();
+          return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      });
+      attempt++;
     }
-    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/provider-runner-impl.ts
+var DefaultProviderRunner = class {
+  async run(opts) {
+    return runProviderWithRetry(opts);
   }
 };
 
-// src/execution/selective-compactor.ts
-var SelectiveCompactor = class {
+// src/execution/intelligent-compactor.ts
+var IntelligentCompactor = class {
   provider;
-  selector;
   warnThreshold;
   softThreshold;
   hardThreshold;
   maxContext;
   preserveK;
   eliseThreshold;
-  summarizerModel;
   summarizerPrompt;
+  summarizerModel;
   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.";
+    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 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 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 };
   }
-  /**
-   * 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;
+  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 {
-      result = await this.selector.select(ctx.messages, targetBudget);
+      summaryText = await this.callSummarizer(toSummarize, ctx);
     } 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);
+      summaryText = `[${toSummarize.length} earlier turns omitted \u2014 key decisions and file states preserved in context]`;
     }
-    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
+    const summaryMsg = {
+      role: "system",
+      content: `[prior_turns_summary: ${summaryText}]`
     };
-    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);
+    const summaryTokens = this.estimateTokens([summaryMsg]);
+    const tail = ctx.messages.slice(boundary);
+    ctx.state.replaceMessages([summaryMsg, ...tail]);
+    return Math.max(0, removedTokens - summaryTokens);
   }
-  /**
-   * 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++) {
+  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)) {
-        boundary = i;
-        break;
+        return this.findExchangeStart(messages, i);
       }
     }
-    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]));
+    return -1;
   }
-  computeTargetBudget(load) {
-    if (load >= this.hardThreshold) {
-      return Math.floor(this.maxContext * 0.5);
-    }
-    if (load >= this.softThreshold) {
-      return Math.floor(this.maxContext * 0.65);
+  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 Math.floor(this.maxContext * 0.75);
+    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;
@@ -5412,8 +5424,7 @@ Summarize the following message range:`;
       }
       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);
+        const tokens = estimateToolResultTokens(b.content);
         if (tokens < this.eliseThreshold) return b;
         saved += tokens;
         return {
@@ -5423,7 +5434,7 @@ Summarize the following message range:`;
           is_error: b.is_error
         };
       });
-      if (newContent.every((b, idx) => b === msg.content[idx])) {
+      if (newContent.length === msg.content.length && newContent.every((b, idx) => b === msg.content[idx])) {
         nextMessages[i] = msg;
       } else {
         nextMessages[i] = { ...msg, content: newContent };
@@ -5441,610 +5452,984 @@ Summarize the following message range:`;
     let total = 0;
     for (const m of messages) {
       if (typeof m.content === "string") {
-        total += this.roughTokenEstimate(m.content);
+        total += estimateTextTokens(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)
-            );
-          }
+          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;
   }
-  roughTokenEstimate(text) {
-    return Math.max(1, Math.ceil(text.length / 4));
-  }
 };
 
-// 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 });
+// 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 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
-        });
+  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}
 
-// 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;
+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);
   }
-  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
-          };
-        }
+  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;
+      }
     }
-    return { done: false, iterations: state.iterations, toolCalls: state.toolCalls };
+    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 : ""
+    };
   }
 };
-var AutonomousRunner = class {
+
+// src/execution/selective-compactor.ts
+var SelectiveCompactor = class {
+  provider;
+  selector;
+  warnThreshold;
+  softThreshold;
+  hardThreshold;
+  maxContext;
+  preserveK;
+  eliseThreshold;
+  summarizerModel;
+  summarizerPrompt;
   constructor(opts) {
-    this.opts = opts;
-    this.doneChecker = new DoneConditionChecker(opts.doneCondition);
+    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.";
   }
-  opts;
-  iterations = 0;
-  toolCalls = 0;
-  lastOutput;
-  stopped = false;
-  doneChecker;
-  async run() {
-    const offToolExecuted = this.opts.agent.events?.on?.("tool.executed", () => {
-      this.toolCalls++;
-    });
+  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 {
-      return await this.runLoop();
-    } finally {
-      offToolExecuted?.();
+      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);
   }
-  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);
+  /**
+   * 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);
     }
-    return {
-      status: "aborted",
-      iterations: this.iterations,
-      toolCalls: this.toolCalls,
-      reason: "stopped externally"
-    };
-  }
-  stop() {
-    this.stopped = true;
+    ctx.state.replaceMessages(messages);
   }
-};
-
-// src/coordination/director-prompts.ts
-var DEFAULT_DIRECTOR_PREAMBLE = `You are the Director of a multi-agent fleet. You orchestrate worker
-subagents by spawning them, assigning tasks, awaiting completions, and
-rolling up their outputs into your next decision.
+  async summarizeRange(messages, ctx) {
+    const systemText = `${this.summarizerPrompt}
 
-Core fleet tools available to you:
-  - spawn_subagent       \u2014 create a worker with a chosen provider / model / role
-  - assign_task          \u2014 hand a piece of work to a specific subagent
-  - await_tasks          \u2014 block until named task ids complete (parallel-safe)
-  - ask_subagent         \u2014 synchronously query a running subagent via the bridge
-  - roll_up              \u2014 aggregate finished tasks into a markdown/json summary
-  - terminate_subagent   \u2014 abort a stuck worker (use sparingly)
-  - fleet_status         \u2014 snapshot of all subagents and pending tasks
-  - fleet_usage          \u2014 token + cost breakdown per subagent and total
-
-Working rules:
-  1. Decompose first. Before spawning, decide which sub-tasks are
-     independent and can run in parallel. Sequential work doesn't need a
-     subagent \u2014 do it yourself.
-  2. Match worker to job. Cheap/fast model for triage, capable model for
-     synthesis. Different providers per sibling is allowed and encouraged.
-  3. Always pair an assign with an await. Don't fire-and-forget; you owe
-     the user a single coherent answer at the end.
-  4. Roll up before deciding. After await_tasks resolves, call roll_up so
-     the results are folded back into your context in a compact form.
-  5. Budget is real. Check fleet_usage periodically. If a subagent is
-     thrashing, terminate it rather than letting cost climb silently.
-  6. Never claim a subagent's work as your own without verifying it. If a
-     result looks wrong, ask_subagent for clarification before passing it
-     to the user.`;
-var DEFAULT_SUBAGENT_BASELINE = `You are a subagent operating under a Director. You were spawned to handle
-a specific slice of a larger plan \u2014 do that slice well and report back.
-
-Bridge contract:
-  - You have a parent (the Director). You may call \`request\` on the
-    parent bridge to ask a clarifying question. Use this sparingly; the
-    parent is also working.
-  - You MAY NOT request the parent's system prompt, tool list, or other
-    subagents' context. Those are not yours to read.
-  - Your final task output is what the Director sees. Be concise,
-    structured, and self-contained \u2014 assume the Director will paste your
-    output into its own context.`;
-function composeDirectorPrompt(parts = {}) {
-  const sections = [];
-  const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
-  if (preamble && preamble.trim().length > 0) sections.push(preamble.trim());
-  if (parts.rosterSummary && parts.rosterSummary.trim().length > 0) {
-    sections.push(`Available roles you can spawn:
-${parts.rosterSummary.trim()}`);
-  }
-  if (parts.basePrompt && parts.basePrompt.trim().length > 0) {
-    sections.push(parts.basePrompt.trim());
-  }
-  return sections.join("\n\n");
-}
-function composeSubagentPrompt(parts = {}) {
-  const sections = [];
-  const baseline = parts.baseline ?? DEFAULT_SUBAGENT_BASELINE;
-  if (baseline && baseline.trim().length > 0) sections.push(baseline.trim());
-  if (parts.role && parts.role.trim().length > 0) {
-    sections.push(`Role:
-${parts.role.trim()}`);
-  }
-  if (parts.task && parts.task.trim().length > 0) {
-    sections.push(`Task:
-${parts.task.trim()}`);
-  }
-  if (parts.sharedScratchpad && parts.sharedScratchpad.trim().length > 0) {
-    sections.push(
-      `Shared notes:
-A scratchpad shared with the rest of the fleet is mounted at \`${parts.sharedScratchpad.trim()}\`.
-- Write your final findings as markdown files there (e.g. \`findings.md\`, \`security.md\`).
-- Before starting, list the directory and read any sibling files relevant to your task \u2014 they may already contain context you can build on.
-- Use stable filenames (one file per concern); overwrite instead of appending so the Director sees the latest state.`
-    );
-  }
-  if (parts.override && parts.override.trim().length > 0) {
-    sections.push(parts.override.trim());
+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]`;
+    }
   }
-  return sections.join("\n\n");
-}
-function rosterSummaryFromConfigs(roster) {
-  const lines = [];
-  for (const [roleId, cfg] of Object.entries(roster)) {
-    const tag = cfg.provider && cfg.model ? ` (${cfg.provider}/${cfg.model})` : "";
-    const headline = cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").trim().slice(0, 80) : "";
-    const tail = headline ? ` \u2014 ${headline}` : "";
-    lines.push(`- ${roleId}: ${cfg.name}${tag}${tail}`);
+  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);
   }
-  return lines.join("\n");
-}
-
-// src/coordination/fleet-bus.ts
-var FleetBus = class {
-  byId = /* @__PURE__ */ new Map();
-  byType = /* @__PURE__ */ new Map();
-  any = /* @__PURE__ */ new Set();
   /**
-   * Hook a subagent's EventBus into the fleet. EventBus is strongly
-   * typed and doesn't expose an `onAny` hook, so we subscribe to the
-   * canonical set of event types a subagent emits during a run. New
-   * event types added to the kernel must be added here too — but the
-   * cost is a tiny single line per type, and the explicit list keeps
-   * the wire format clear.
-   *
-   * Returns a disposer that detaches every subscription; call on
-   * subagent teardown so the listeners don't outlive the run.
+   * Fallback when selector fails: aggressively trim from the oldest end
+   * until we hit targetBudget.
    */
-  attach(subagentId, bus, taskId) {
-    const FORWARDED_TYPES = [
-      "tool.started",
-      "tool.executed",
-      "tool.progress",
-      "tool.confirm_needed",
-      "iteration.started",
-      "iteration.completed",
-      "provider.text_delta",
-      // Subagent extended-thinking output. Forwarded so the FleetPanel /
-      // /fleet log can surface "the planner is thinking…" instead of a
-      // silent gap between iteration.started and the first text_delta.
-      "provider.thinking_delta",
-      "provider.response",
-      "provider.retry",
-      "provider.error",
-      "session.started",
-      "session.ended",
-      "session.damaged",
-      "compaction.fired",
-      "compaction.failed",
-      "token.threshold"
-    ];
-    const offs = [];
-    for (const t2 of FORWARDED_TYPES) {
-      offs.push(
-        bus.on(t2, (payload) => {
-          this.emit({ subagentId, taskId, ts: Date.now(), type: t2, payload });
-        })
-      );
+  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;
+      }
     }
-    return () => {
-      for (const off of offs) off();
+    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]));
   }
-  /** Subscribe to every event from one subagent. */
-  subscribe(subagentId, handler) {
-    let set = this.byId.get(subagentId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.byId.set(subagentId, set);
+  computeTargetBudget(load) {
+    if (load >= this.hardThreshold) {
+      return Math.floor(this.maxContext * 0.5);
     }
-    set.add(handler);
-    return () => {
-      set.delete(handler);
-    };
-  }
-  /** Subscribe to one event type across all subagents. */
-  filter(type, handler) {
-    let set = this.byType.get(type);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.byType.set(type, set);
+    if (load >= this.softThreshold) {
+      return Math.floor(this.maxContext * 0.65);
     }
-    set.add(handler);
-    return () => {
-      set.delete(handler);
-    };
-  }
-  /** Subscribe to literally everything. The fleet roll-up uses this. */
-  onAny(handler) {
-    this.any.add(handler);
-    return () => {
-      this.any.delete(handler);
-    };
+    return Math.floor(this.maxContext * 0.75);
   }
-  emit(event) {
-    const byId = this.byId.get(event.subagentId);
-    if (byId)
-      for (const h of byId) {
-        try {
-          h(event);
-        } catch {
-        }
+  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;
       }
-    const byType = this.byType.get(event.type);
-    if (byType)
-      for (const h of byType) {
-        try {
-          h(event);
-        } catch {
-        }
+    }
+    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;
       }
-    for (const h of this.any) {
-      try {
-        h(event);
-      } catch {
+      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;
   }
-};
-var FleetUsageAggregator = class {
-  constructor(bus, priceLookup, metaLookup) {
-    this.bus = bus;
-    this.priceLookup = priceLookup;
-    this.metaLookup = metaLookup;
-    bus.filter("provider.response", (e) => this.onProviderResponse(e));
-    bus.filter("tool.executed", (e) => this.onToolExecuted(e));
-    bus.filter("iteration.started", (e) => this.onIterationStarted(e));
-  }
-  bus;
-  priceLookup;
-  metaLookup;
-  perSubagent = /* @__PURE__ */ new Map();
-  total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
-  /** Live snapshot — safe to call from a tool's execute() body. */
-  snapshot() {
-    return {
-      total: { ...this.total },
-      perSubagent: Object.fromEntries(
-        Array.from(this.perSubagent.entries()).map(([k, v]) => [k, { ...v }])
-      )
-    };
-  }
-  ensure(subagentId) {
-    let snap = this.perSubagent.get(subagentId);
-    if (!snap) {
-      const meta = this.metaLookup?.(subagentId);
-      snap = {
-        subagentId,
-        provider: meta?.provider,
-        model: meta?.model,
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        cost: 0,
-        toolCalls: 0,
-        iterations: 0,
-        startedAt: Date.now(),
-        lastEventAt: Date.now()
-      };
-      this.perSubagent.set(subagentId, snap);
-    }
-    return snap;
-  }
-  onProviderResponse(e) {
-    const snap = this.ensure(e.subagentId);
-    const p = e.payload;
-    const usage = p?.usage;
-    if (!usage) return;
-    snap.input += usage.input ?? 0;
-    snap.output += usage.output ?? 0;
-    snap.cacheRead += usage.cacheRead ?? 0;
-    snap.cacheWrite += usage.cacheWrite ?? 0;
-    this.total.input += usage.input ?? 0;
-    this.total.output += usage.output ?? 0;
-    this.total.cacheRead += usage.cacheRead ?? 0;
-    this.total.cacheWrite += usage.cacheWrite ?? 0;
-    const price = this.priceLookup?.(e.subagentId);
-    if (price) {
-      const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
-      snap.cost += delta;
-      this.total.cost += delta;
-    }
-    snap.lastEventAt = e.ts;
+  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);
   }
-  onToolExecuted(e) {
-    const snap = this.ensure(e.subagentId);
-    snap.toolCalls += 1;
-    snap.lastEventAt = e.ts;
+  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;
   }
-  onIterationStarted(e) {
-    const snap = this.ensure(e.subagentId);
-    snap.iterations += 1;
-    snap.lastEventAt = e.ts;
+  roughTokenEstimate(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
   }
 };
 
-// src/coordination/subagent-budget.ts
-var BudgetExceededError = class extends Error {
-  kind;
-  limit;
-  observed;
-  constructor(kind, limit, observed) {
-    super(`Budget exceeded: ${kind} (limit=${limit}, observed=${observed})`);
-    this.name = "BudgetExceededError";
-    this.kind = kind;
-    this.limit = limit;
-    this.observed = observed;
-  }
-};
-var SubagentBudget = class {
-  limits;
-  iterations = 0;
-  toolCalls = 0;
-  tokenInput = 0;
-  tokenOutput = 0;
-  costUsd = 0;
-  startTime = null;
-  constructor(limits = {}) {
-    this.limits = Object.freeze({ ...limits });
-  }
-  start() {
-    this.startTime = Date.now();
-  }
-  recordIteration() {
-    this.iterations++;
-    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
-      throw new BudgetExceededError("iterations", this.limits.maxIterations, this.iterations);
-    }
-  }
-  recordToolCall() {
-    this.toolCalls++;
-    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
-      throw new BudgetExceededError("tool_calls", this.limits.maxToolCalls, this.toolCalls);
-    }
-  }
-  recordUsage(usage, costUsd = 0) {
-    this.tokenInput += usage.input;
-    this.tokenOutput += usage.output;
-    this.costUsd += costUsd;
-    const totalTokens = this.tokenInput + this.tokenOutput;
-    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
-      throw new BudgetExceededError("tokens", this.limits.maxTokens, totalTokens);
-    }
-    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
-      throw new BudgetExceededError("cost", this.limits.maxCostUsd, this.costUsd);
-    }
-  }
+// src/execution/auto-compaction-middleware.ts
+var AutoCompactionMiddleware = class {
+  name = "AutoCompaction";
+  compactor;
+  warnThreshold;
+  softThreshold;
+  hardThreshold;
+  maxContext;
+  estimator;
+  aggressiveOn;
+  events;
+  failureMode;
   /**
-   * Throws if the wall-clock budget is exhausted. Call this from the iteration
-   * loop so a hung tool can't keep a subagent running past its deadline.
+   * @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.
    */
-  checkTimeout() {
-    if (this.startTime === null || this.limits.timeoutMs === void 0) return;
-    const elapsed = Date.now() - this.startTime;
-    if (elapsed > this.limits.timeoutMs) {
-      throw new BudgetExceededError("timeout", this.limits.timeoutMs, elapsed);
-    }
-  }
-  /** Returns true if a timeout has occurred without throwing. Useful for races. */
-  isTimedOut() {
-    if (this.startTime === null || this.limits.timeoutMs === void 0) return false;
-    return Date.now() - this.startTime > this.limits.timeoutMs;
+  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";
   }
-  usage() {
-    return {
-      iterations: this.iterations,
-      toolCalls: this.toolCalls,
-      tokens: {
-        input: this.tokenInput,
-        output: this.tokenOutput,
-        total: this.tokenInput + this.tokenOutput
-      },
-      costUsd: this.costUsd,
-      elapsedMs: this.startTime === null ? 0 : Date.now() - this.startTime
+  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/coordination/multi-agent-coordinator.ts
-var DefaultMultiAgentCoordinator = class extends EventEmitter {
-  coordinatorId;
+// 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/coordination/director-prompts.ts
+var DEFAULT_DIRECTOR_PREAMBLE = `You are the Director of a multi-agent fleet. You orchestrate worker
+subagents by spawning them, assigning tasks, awaiting completions, and
+rolling up their outputs into your next decision.
+
+Core fleet tools available to you:
+  - spawn_subagent       \u2014 create a worker with a chosen provider / model / role
+  - assign_task          \u2014 hand a piece of work to a specific subagent
+  - await_tasks          \u2014 block until named task ids complete (parallel-safe)
+  - ask_subagent         \u2014 synchronously query a running subagent via the bridge
+  - roll_up              \u2014 aggregate finished tasks into a markdown/json summary
+  - terminate_subagent   \u2014 abort a stuck worker (use sparingly)
+  - fleet_status         \u2014 snapshot of all subagents and pending tasks
+  - fleet_usage          \u2014 token + cost breakdown per subagent and total
+
+Working rules:
+  1. Decompose first. Before spawning, decide which sub-tasks are
+     independent and can run in parallel. Sequential work doesn't need a
+     subagent \u2014 do it yourself.
+  2. Match worker to job. Cheap/fast model for triage, capable model for
+     synthesis. Different providers per sibling is allowed and encouraged.
+  3. Always pair an assign with an await. Don't fire-and-forget; you owe
+     the user a single coherent answer at the end.
+  4. Roll up before deciding. After await_tasks resolves, call roll_up so
+     the results are folded back into your context in a compact form.
+  5. Budget is real. Check fleet_usage periodically. If a subagent is
+     thrashing, terminate it rather than letting cost climb silently.
+  6. Never claim a subagent's work as your own without verifying it. If a
+     result looks wrong, ask_subagent for clarification before passing it
+     to the user.`;
+var DEFAULT_SUBAGENT_BASELINE = `You are a subagent operating under a Director. You were spawned to handle
+a specific slice of a larger plan \u2014 do that slice well and report back.
+
+Bridge contract:
+  - You have a parent (the Director). You may call \`request\` on the
+    parent bridge to ask a clarifying question. Use this sparingly; the
+    parent is also working.
+  - You MAY NOT request the parent's system prompt, tool list, or other
+    subagents' context. Those are not yours to read.
+  - Your final task output is what the Director sees. Be concise,
+    structured, and self-contained \u2014 assume the Director will paste your
+    output into its own context.`;
+function composeDirectorPrompt(parts = {}) {
+  const sections = [];
+  const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
+  if (preamble && preamble.trim().length > 0) sections.push(preamble.trim());
+  if (parts.rosterSummary && parts.rosterSummary.trim().length > 0) {
+    sections.push(`Available roles you can spawn:
+${parts.rosterSummary.trim()}`);
+  }
+  if (parts.basePrompt && parts.basePrompt.trim().length > 0) {
+    sections.push(parts.basePrompt.trim());
+  }
+  return sections.join("\n\n");
+}
+function composeSubagentPrompt(parts = {}) {
+  const sections = [];
+  const baseline = parts.baseline ?? DEFAULT_SUBAGENT_BASELINE;
+  if (baseline && baseline.trim().length > 0) sections.push(baseline.trim());
+  if (parts.role && parts.role.trim().length > 0) {
+    sections.push(`Role:
+${parts.role.trim()}`);
+  }
+  if (parts.task && parts.task.trim().length > 0) {
+    sections.push(`Task:
+${parts.task.trim()}`);
+  }
+  if (parts.sharedScratchpad && parts.sharedScratchpad.trim().length > 0) {
+    sections.push(
+      `Shared notes:
+A scratchpad shared with the rest of the fleet is mounted at \`${parts.sharedScratchpad.trim()}\`.
+- Write your final findings as markdown files there (e.g. \`findings.md\`, \`security.md\`).
+- Before starting, list the directory and read any sibling files relevant to your task \u2014 they may already contain context you can build on.
+- Use stable filenames (one file per concern); overwrite instead of appending so the Director sees the latest state.`
+    );
+  }
+  if (parts.override && parts.override.trim().length > 0) {
+    sections.push(parts.override.trim());
+  }
+  return sections.join("\n\n");
+}
+function rosterSummaryFromConfigs(roster) {
+  const lines = [];
+  for (const [roleId, cfg] of Object.entries(roster)) {
+    const tag = cfg.provider && cfg.model ? ` (${cfg.provider}/${cfg.model})` : "";
+    const headline = cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").trim().slice(0, 80) : "";
+    const tail = headline ? ` \u2014 ${headline}` : "";
+    lines.push(`- ${roleId}: ${cfg.name}${tag}${tail}`);
+  }
+  return lines.join("\n");
+}
+
+// src/coordination/fleet-bus.ts
+var FleetBus = class {
+  byId = /* @__PURE__ */ new Map();
+  byType = /* @__PURE__ */ new Map();
+  any = /* @__PURE__ */ new Set();
+  /**
+   * Hook a subagent's EventBus into the fleet. EventBus is strongly
+   * typed and doesn't expose an `onAny` hook, so we subscribe to the
+   * canonical set of event types a subagent emits during a run. New
+   * event types added to the kernel must be added here too — but the
+   * cost is a tiny single line per type, and the explicit list keeps
+   * the wire format clear.
+   *
+   * Returns a disposer that detaches every subscription; call on
+   * subagent teardown so the listeners don't outlive the run.
+   */
+  attach(subagentId, bus, taskId) {
+    const FORWARDED_TYPES = [
+      "tool.started",
+      "tool.executed",
+      "tool.progress",
+      "tool.confirm_needed",
+      "iteration.started",
+      "iteration.completed",
+      "provider.text_delta",
+      // Subagent extended-thinking output. Forwarded so the FleetPanel /
+      // /fleet log can surface "the planner is thinking…" instead of a
+      // silent gap between iteration.started and the first text_delta.
+      "provider.thinking_delta",
+      "provider.response",
+      "provider.retry",
+      "provider.error",
+      "session.started",
+      "session.ended",
+      "session.damaged",
+      "compaction.fired",
+      "compaction.failed",
+      "token.threshold"
+    ];
+    const offs = [];
+    for (const t2 of FORWARDED_TYPES) {
+      offs.push(
+        bus.on(t2, (payload) => {
+          this.emit({ subagentId, taskId, ts: Date.now(), type: t2, payload });
+        })
+      );
+    }
+    return () => {
+      for (const off of offs) off();
+    };
+  }
+  /** Subscribe to every event from one subagent. */
+  subscribe(subagentId, handler) {
+    let set = this.byId.get(subagentId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byId.set(subagentId, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  /** Subscribe to one event type across all subagents. */
+  filter(type, handler) {
+    let set = this.byType.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.byType.set(type, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  /** Subscribe to literally everything. The fleet roll-up uses this. */
+  onAny(handler) {
+    this.any.add(handler);
+    return () => {
+      this.any.delete(handler);
+    };
+  }
+  emit(event) {
+    const byId = this.byId.get(event.subagentId);
+    if (byId)
+      for (const h of byId) {
+        try {
+          h(event);
+        } catch {
+        }
+      }
+    const byType = this.byType.get(event.type);
+    if (byType)
+      for (const h of byType) {
+        try {
+          h(event);
+        } catch {
+        }
+      }
+    for (const h of this.any) {
+      try {
+        h(event);
+      } catch {
+      }
+    }
+  }
+};
+var FleetUsageAggregator = class {
+  constructor(bus, priceLookup, metaLookup) {
+    this.bus = bus;
+    this.priceLookup = priceLookup;
+    this.metaLookup = metaLookup;
+    bus.filter("provider.response", (e) => this.onProviderResponse(e));
+    bus.filter("tool.executed", (e) => this.onToolExecuted(e));
+    bus.filter("iteration.started", (e) => this.onIterationStarted(e));
+  }
+  bus;
+  priceLookup;
+  metaLookup;
+  perSubagent = /* @__PURE__ */ new Map();
+  total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+  /** Live snapshot — safe to call from a tool's execute() body. */
+  snapshot() {
+    return {
+      total: { ...this.total },
+      perSubagent: Object.fromEntries(
+        Array.from(this.perSubagent.entries()).map(([k, v]) => [k, { ...v }])
+      )
+    };
+  }
+  ensure(subagentId) {
+    let snap = this.perSubagent.get(subagentId);
+    if (!snap) {
+      const meta = this.metaLookup?.(subagentId);
+      snap = {
+        subagentId,
+        provider: meta?.provider,
+        model: meta?.model,
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: 0,
+        toolCalls: 0,
+        iterations: 0,
+        startedAt: Date.now(),
+        lastEventAt: Date.now()
+      };
+      this.perSubagent.set(subagentId, snap);
+    }
+    return snap;
+  }
+  onProviderResponse(e) {
+    const snap = this.ensure(e.subagentId);
+    const p = e.payload;
+    const usage = p?.usage;
+    if (!usage) return;
+    snap.input += usage.input ?? 0;
+    snap.output += usage.output ?? 0;
+    snap.cacheRead += usage.cacheRead ?? 0;
+    snap.cacheWrite += usage.cacheWrite ?? 0;
+    this.total.input += usage.input ?? 0;
+    this.total.output += usage.output ?? 0;
+    this.total.cacheRead += usage.cacheRead ?? 0;
+    this.total.cacheWrite += usage.cacheWrite ?? 0;
+    const price = this.priceLookup?.(e.subagentId);
+    if (price) {
+      const delta = (usage.input ?? 0) / 1e6 * (price.input ?? 0) + (usage.output ?? 0) / 1e6 * (price.output ?? 0) + (usage.cacheRead ?? 0) / 1e6 * (price.cacheRead ?? 0) + (usage.cacheWrite ?? 0) / 1e6 * (price.cacheWrite ?? 0);
+      snap.cost += delta;
+      this.total.cost += delta;
+    }
+    snap.lastEventAt = e.ts;
+  }
+  onToolExecuted(e) {
+    const snap = this.ensure(e.subagentId);
+    snap.toolCalls += 1;
+    snap.lastEventAt = e.ts;
+  }
+  onIterationStarted(e) {
+    const snap = this.ensure(e.subagentId);
+    snap.iterations += 1;
+    snap.lastEventAt = e.ts;
+  }
+};
+
+// src/coordination/subagent-budget.ts
+var BudgetExceededError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(kind, limit, observed) {
+    super(`Budget exceeded: ${kind} (limit=${limit}, observed=${observed})`);
+    this.name = "BudgetExceededError";
+    this.kind = kind;
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
+var SubagentBudget = class {
+  limits;
+  iterations = 0;
+  toolCalls = 0;
+  tokenInput = 0;
+  tokenOutput = 0;
+  costUsd = 0;
+  startTime = null;
+  constructor(limits = {}) {
+    this.limits = Object.freeze({ ...limits });
+  }
+  start() {
+    this.startTime = Date.now();
+  }
+  recordIteration() {
+    this.iterations++;
+    if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
+      throw new BudgetExceededError("iterations", this.limits.maxIterations, this.iterations);
+    }
+  }
+  recordToolCall() {
+    this.toolCalls++;
+    if (this.limits.maxToolCalls !== void 0 && this.toolCalls > this.limits.maxToolCalls) {
+      throw new BudgetExceededError("tool_calls", this.limits.maxToolCalls, this.toolCalls);
+    }
+  }
+  recordUsage(usage, costUsd = 0) {
+    this.tokenInput += usage.input;
+    this.tokenOutput += usage.output;
+    this.costUsd += costUsd;
+    const totalTokens = this.tokenInput + this.tokenOutput;
+    if (this.limits.maxTokens !== void 0 && totalTokens > this.limits.maxTokens) {
+      throw new BudgetExceededError("tokens", this.limits.maxTokens, totalTokens);
+    }
+    if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
+      throw new BudgetExceededError("cost", this.limits.maxCostUsd, this.costUsd);
+    }
+  }
+  /**
+   * Throws if the wall-clock budget is exhausted. Call this from the iteration
+   * loop so a hung tool can't keep a subagent running past its deadline.
+   */
+  checkTimeout() {
+    if (this.startTime === null || this.limits.timeoutMs === void 0) return;
+    const elapsed = Date.now() - this.startTime;
+    if (elapsed > this.limits.timeoutMs) {
+      throw new BudgetExceededError("timeout", this.limits.timeoutMs, elapsed);
+    }
+  }
+  /** Returns true if a timeout has occurred without throwing. Useful for races. */
+  isTimedOut() {
+    if (this.startTime === null || this.limits.timeoutMs === void 0) return false;
+    return Date.now() - this.startTime > this.limits.timeoutMs;
+  }
+  usage() {
+    return {
+      iterations: this.iterations,
+      toolCalls: this.toolCalls,
+      tokens: {
+        input: this.tokenInput,
+        output: this.tokenOutput,
+        total: this.tokenInput + this.tokenOutput
+      },
+      costUsd: this.costUsd,
+      elapsedMs: this.startTime === null ? 0 : Date.now() - this.startTime
+    };
+  }
+};
+
+// src/coordination/multi-agent-coordinator.ts
+var DefaultMultiAgentCoordinator = class extends EventEmitter {
+  coordinatorId;
   config;
   runner;
   subagents = /* @__PURE__ */ new Map();
@@ -9697,348 +10082,260 @@ var sentinelServer = () => ({
   // security tool — require explicit confirmation
 });
 var allServers = () => ({
-  filesystem: { ...filesystemServer(), enabled: false },
-  github: { ...githubServer(), enabled: false },
-  context7: { ...context7Server(), enabled: false },
-  "brave-search": { ...braveSearchServer(), enabled: false },
-  block: { ...blockServer(), enabled: false },
-  everart: { ...everArtServer(), enabled: false },
-  slack: { ...slackServer(), enabled: false },
-  aws: { ...awsServer(), enabled: false },
-  "google-maps": { ...googleMapsServer(), enabled: false },
-  sentinel: { ...sentinelServer(), enabled: false }
-});
-
-// src/core/iteration-limit.ts
-function requestLimitExtension(opts) {
-  const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
-  return new Promise((resolve4) => {
-    let resolved = false;
-    const timer = setTimeout(() => {
-      if (!resolved) {
-        resolved = true;
-        resolve4(0);
-      }
-    }, timeoutMs);
-    const deny = () => {
-      if (!resolved) {
-        resolved = true;
-        clearTimeout(timer);
-        resolve4(0);
-      }
+  filesystem: { ...filesystemServer(), enabled: false },
+  github: { ...githubServer(), enabled: false },
+  context7: { ...context7Server(), enabled: false },
+  "brave-search": { ...braveSearchServer(), enabled: false },
+  block: { ...blockServer(), enabled: false },
+  everart: { ...everArtServer(), enabled: false },
+  slack: { ...slackServer(), enabled: false },
+  aws: { ...awsServer(), enabled: false },
+  "google-maps": { ...googleMapsServer(), enabled: false },
+  sentinel: { ...sentinelServer(), enabled: false }
+});
+
+// src/extension/registry.ts
+var ExtensionRegistry = class {
+  extensions = [];
+  promptContributors = [];
+  log;
+  setLogger(log) {
+    this.log = log;
+  }
+  /**
+   * Register a system prompt contributor. Returns an unregister function.
+   * Contributors are called on every system prompt build in registration
+   * order. Their output blocks are inserted after the core environment
+   * block, before the mode and plan blocks.
+   */
+  registerSystemPromptContributor(c) {
+    this.promptContributors.push(c);
+    return () => {
+      const idx = this.promptContributors.indexOf(c);
+      if (idx >= 0) this.promptContributors.splice(idx, 1);
     };
-    const grant = (extra) => {
-      if (!resolved) {
-        resolved = true;
-        clearTimeout(timer);
-        resolve4(Math.max(0, extra));
+  }
+  /**
+   * Build all registered system prompt contributions.
+   * Failures are caught and logged — one bad contributor doesn't
+   * break the prompt assembly.
+   */
+  async buildSystemPromptContributions(ctx) {
+    const blocks = [];
+    for (const c of this.promptContributors) {
+      try {
+        const contributed = await c(ctx);
+        blocks.push(...contributed);
+      } catch (err) {
+        this.log?.error("SystemPromptContributor failed", err);
       }
-    };
-    events.emit("iteration.limit_reached", {
-      currentIterations,
-      currentLimit,
-      grant,
-      deny
-    });
-    if (autoExtend) {
-      setImmediate(() => {
-        if (!resolved) {
-          resolved = true;
-          clearTimeout(timer);
-          resolve4(100);
-        }
-      });
     }
-  });
-}
-
-// src/core/streaming-response-builder.ts
-function buildResponse(state) {
-  const content = [];
-  for (const b of state.blockOrder) {
-    if (b.kind === "text") {
-      const txt = state.textBuffers[b.idx] ?? "";
-      if (txt) content.push({ type: "text", text: txt });
-    } else if (b.kind === "thinking") {
-      const t2 = state.thinking[b.idx];
-      if (!t2) continue;
-      if (!t2.textBuf && !t2.signature) continue;
-      const block = { type: "thinking", thinking: t2.textBuf };
-      if (t2.signature) block.signature = t2.signature;
-      if (t2.providerMeta && Object.keys(t2.providerMeta).length > 0) {
-        block.providerMeta = t2.providerMeta;
-      }
-      content.push(block);
-    } else {
-      const tb = state.tools.get(b.id);
-      if (tb) {
-        const block = {
-          type: "tool_use",
-          id: b.id,
-          name: tb.name,
-          input: tb.input ?? {}
-        };
-        if (tb.providerMeta && Object.keys(tb.providerMeta).length > 0) {
-          block.providerMeta = tb.providerMeta;
-        }
-        content.push(block);
-      }
+    return blocks;
+  }
+  /**
+   * Returns the live array of contributors (readonly snapshot for
+   * passing to DefaultSystemPromptBuilder at build time).
+   */
+  listSystemPromptContributors() {
+    return this.promptContributors;
+  }
+  /**
+   * Register an extension. Duplicate names are rejected.
+   * Returns an unregister function.
+   */
+  register(ext) {
+    if (this.extensions.some((e) => e.name === ext.name)) {
+      throw new WrongStackError({
+        message: `Extension "${ext.name}" already registered`,
+        code: "REGISTRY_DUPLICATE",
+        subsystem: "container",
+        context: { extension: ext.name }
+      });
     }
+    this.extensions.push(ext);
+    return () => this.unregister(ext.name);
   }
-  if (content.length === 0) content.push({ type: "text", text: "" });
-  return { content, stopReason: state.stopReason, usage: state.usage, model: state.model };
-}
-function createStreamingState(model) {
-  return {
-    model,
-    stopReason: "end_turn",
-    usage: { input: 0, output: 0 },
-    textBuffers: [],
-    currentTextIndex: -1,
-    tools: /* @__PURE__ */ new Map(),
-    thinking: [],
-    currentThinkingIndex: -1,
-    blockOrder: []
-  };
-}
-function handleMessageStart(state, model) {
-  state.model = model;
-}
-function handleContentBlockStart(state, ev) {
-  const kind = ev.kind ?? "text";
-  if (kind === "text") {
-    state.currentTextIndex = state.textBuffers.length;
-    state.textBuffers.push("");
-    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
-  } else if (kind === "tool_use") {
-    const id = ev.id ?? crypto.randomUUID();
-    state.tools.set(id, { name: ev.name ?? "unknown", partial: "" });
-    state.blockOrder.push({ kind: "tool", id });
-    state.currentTextIndex = -1;
-  } else if (kind === "thinking") {
-    state.currentThinkingIndex = state.thinking.length;
-    state.thinking.push({
-      textBuf: "",
-      ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
-    });
-    state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
-    state.currentTextIndex = -1;
+  /**
+   * Register an extension, silently replacing any previous registration
+   * with the same name. Use this when overriding a default extension.
+   */
+  registerOrReplace(ext) {
+    const idx = this.extensions.findIndex((e) => e.name === ext.name);
+    if (idx >= 0) this.extensions.splice(idx, 1);
+    return this.register(ext);
   }
-}
-function handleContentBlockStop(state, ev) {
-}
-function handleTextDelta(state, text) {
-  if (state.currentTextIndex === -1) {
-    state.currentTextIndex = state.textBuffers.length;
-    state.textBuffers.push("");
-    state.blockOrder.push({ kind: "text", idx: state.currentTextIndex });
+  /**
+   * Unregister an extension by name. Returns true if found.
+   */
+  unregister(name) {
+    const idx = this.extensions.findIndex((e) => e.name === name);
+    if (idx === -1) return false;
+    this.extensions.splice(idx, 1);
+    return true;
   }
-  state.textBuffers[state.currentTextIndex] = (state.textBuffers[state.currentTextIndex] ?? "") + text;
-}
-function handleToolUseStart(state, ev) {
-  state.currentTextIndex = -1;
-  state.tools.set(ev.id, { name: ev.name, partial: "" });
-  state.blockOrder.push({ kind: "tool", id: ev.id });
-}
-function handleToolUseInputDelta(state, ev) {
-  const t2 = state.tools.get(ev.id);
-  if (t2) t2.partial += ev.partial;
-}
-function safeJsonOrRaw(s) {
-  if (!s) return {};
-  try {
-    return JSON.parse(s);
-  } catch {
-    return { _raw: s };
+  /**
+   * List registered extension names in order.
+   */
+  list() {
+    return this.extensions.map((e) => e.name);
   }
-}
-function handleToolUseStop(state, ev) {
-  const t2 = state.tools.get(ev.id);
-  if (t2) {
-    t2.input = ev.input !== void 0 ? ev.input : safeJsonOrRaw(t2.partial);
-    if (ev.providerMeta) t2.providerMeta = ev.providerMeta;
+  /**
+   * Check if an extension with the given name is registered.
+   */
+  has(name) {
+    return this.extensions.some((e) => e.name === name);
   }
-  state.currentTextIndex = -1;
-}
-function handleThinkingStart(state, ev) {
-  state.currentThinkingIndex = state.thinking.length;
-  state.thinking.push({
-    textBuf: "",
-    ...ev.providerMeta ? { providerMeta: ev.providerMeta } : {}
-  });
-  state.blockOrder.push({ kind: "thinking", idx: state.currentThinkingIndex });
-  state.currentTextIndex = -1;
-}
-function handleThinkingDelta(state, text) {
-  if (state.currentThinkingIndex === -1) {
-    handleThinkingStart(state, {});
+  /**
+   * Remove all registered extensions and contributors.
+   */
+  clear() {
+    this.extensions.length = 0;
+    this.promptContributors.length = 0;
   }
-  const t2 = state.thinking[state.currentThinkingIndex];
-  if (t2) t2.textBuf += text;
-}
-function handleThinkingSignature(state, signature) {
-  if (state.currentThinkingIndex === -1) {
-    handleThinkingStart(state, {});
+  // ── Hook runners ─────────────────────────────────────────────────
+  async runBeforeRun(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.beforeRun) continue;
+      try {
+        await ext.beforeRun(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeRun hook failed`, err);
+      }
+    }
   }
-  const t2 = state.thinking[state.currentThinkingIndex];
-  if (t2) t2.signature = signature;
-}
-function handleThinkingStop(state) {
-  state.currentThinkingIndex = -1;
-}
-function handleMessageStop(state, ev) {
-  state.stopReason = ev.stopReason ?? "end_turn";
-  state.usage = ev.usage ?? { input: 0, output: 0 };
-}
-async function streamProviderToResponse(provider, req, signal, ctx, events) {
-  const state = createStreamingState(req.model);
-  const iter = provider.stream(req, { signal })[Symbol.asyncIterator]();
-  try {
-    for (; ; ) {
-      const next = await iter.next();
-      if (next.done) break;
-      const ev = next.value;
-      switch (ev.type) {
-        case "message_start":
-          handleMessageStart(state, ev.model);
-          break;
-        case "content_block_start":
-          handleContentBlockStart(state, ev);
-          break;
-        case "content_block_stop":
-          handleContentBlockStop(state, ev);
-          break;
-        case "text_delta":
-          handleTextDelta(state, ev.text);
-          events.emit("provider.text_delta", { ctx, text: ev.text });
-          break;
-        case "tool_use_start":
-          handleToolUseStart(state, ev);
-          events.emit("provider.tool_use_start", { ctx, id: ev.id, name: ev.name });
-          break;
-        case "tool_use_input_delta":
-          handleToolUseInputDelta(state, ev);
-          break;
-        case "tool_use_stop":
-          handleToolUseStop(state, ev);
-          events.emit("provider.tool_use_stop", { ctx, id: ev.id });
-          break;
-        case "thinking_start":
-          handleThinkingStart(state, ev);
-          break;
-        case "thinking_delta":
-          handleThinkingDelta(state, ev.text);
-          events.emit("provider.thinking_delta", { ctx, text: ev.text });
-          break;
-        case "thinking_signature":
-          handleThinkingSignature(state, ev.signature);
-          break;
-        case "thinking_stop":
-          handleThinkingStop(state);
-          break;
-        case "message_stop":
-          handleMessageStop(state, ev);
-          break;
+  async runAfterRun(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.afterRun) continue;
+      try {
+        await ext.afterRun(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterRun hook failed`, err);
       }
     }
-  } catch (err) {
-    if (signal.aborted) {
-      state.stopReason = "end_turn";
-      return buildResponse(state);
+  }
+  async runBeforeIteration(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.beforeIteration) continue;
+      try {
+        await ext.beforeIteration(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeIteration hook failed`, err);
+      }
     }
-    throw err;
-  } finally {
-    try {
-      let drainTimer = null;
+  }
+  async runAfterIteration(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.afterIteration) continue;
       try {
-        await Promise.race([
-          Promise.resolve(iter.return?.()),
-          new Promise((resolve4) => {
-            drainTimer = setTimeout(resolve4, 500);
-          })
-        ]);
-      } finally {
-        if (drainTimer) clearTimeout(drainTimer);
+        await ext.afterIteration(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterIteration hook failed`, err);
       }
-    } catch {
     }
   }
-  return buildResponse(state);
-}
-
-// src/core/provider-runner.ts
-async function runProviderWithRetry(opts) {
-  const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
-  let attempt = 0;
-  for (; ; ) {
-    const span = tracer?.startSpan("provider.complete", {
-      "provider.id": provider.id,
-      "provider.model": request.model,
-      "provider.streaming": provider.capabilities.streaming,
-      "provider.attempt": attempt
-    });
-    try {
-      const res = provider.capabilities.streaming ? await streamProviderToResponse(provider, request, signal, ctx, events) : await provider.complete(request, { signal });
-      span?.setAttribute("provider.stopReason", res.stopReason);
-      span?.setAttribute("provider.usage_in", res.usage.input);
-      span?.setAttribute("provider.usage_out", res.usage.output);
-      span?.end();
-      return res;
-    } catch (err) {
-      if (err instanceof Error) span?.recordError(err);
-      span?.end();
-      if (signal.aborted) throw err;
-      const isProviderErr = err instanceof ProviderError;
-      const errAsErr = err instanceof Error ? err : new Error(String(err));
-      const canRetry = retry.shouldRetry(isProviderErr ? err : errAsErr, attempt);
-      const description = isProviderErr ? err.describe() : errAsErr.message;
-      if (!canRetry) {
-        if (isProviderErr) {
-          events.emit("provider.error", {
-            providerId: err.providerId,
-            status: err.status,
-            description,
-            retryable: false
-          });
+  /**
+   * Run onError hooks in order. The first hook that returns a non-void
+   * result wins; subsequent hooks are skipped.
+   */
+  async runOnError(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.onError) continue;
+      try {
+        const result = await ext.onError(...args);
+        if (result) return result;
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" onError hook failed`, err);
+      }
+    }
+  }
+  /**
+   * Build a composed provider runner. Extensions with `wrapProviderRunner`
+   * form a middleware-style chain: the innermost extension wraps the
+   * default runner, each subsequent wrapper wraps the previous.
+   */
+  wrapProviderRunner(inner) {
+    const wrappers = this.extensions.filter((e) => e.wrapProviderRunner).map((e) => ({ name: e.name, wrap: e.wrapProviderRunner }));
+    if (wrappers.length === 0) return inner;
+    let composed = inner;
+    for (let i = wrappers.length - 1; i >= 0; i--) {
+      const wrapper = wrappers[i];
+      const next = composed;
+      composed = async (ctx, req) => {
+        try {
+          return await wrapper.wrap(ctx, req, next);
+        } catch (err) {
+          this.log?.error(`Extension "${wrapper.name}" wrapProviderRunner failed`, err);
+          throw err;
         }
-        throw err;
+      };
+    }
+    return composed;
+  }
+  async runBeforeToolExecution(...args) {
+    let toolUses = args[1];
+    for (const ext of this.extensions) {
+      if (!ext.beforeToolExecution) continue;
+      try {
+        toolUses = await ext.beforeToolExecution(args[0], toolUses);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" beforeToolExecution hook failed`, err);
       }
-      const delay = Math.round(retry.delayMs(attempt));
-      const attemptNum = attempt + 1;
-      logger.warn(`Provider retry ${attemptNum} in ${delay}ms \u2014 ${description}`);
-      if (isProviderErr) {
-        events.emit("provider.retry", {
-          providerId: err.providerId,
-          attempt: attemptNum,
-          delayMs: delay,
-          status: err.status,
-          description
-        });
+    }
+    return toolUses;
+  }
+  async runAfterToolExecution(...args) {
+    for (const ext of this.extensions) {
+      if (!ext.afterToolExecution) continue;
+      try {
+        await ext.afterToolExecution(...args);
+      } catch (err) {
+        this.log?.error(`Extension "${ext.name}" afterToolExecution hook failed`, err);
       }
-      await new Promise((resolve4, reject) => {
-        let settled = false;
-        const onAbort = () => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(t2);
-          reject(new Error("aborted"));
-        };
-        const t2 = setTimeout(() => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(t2);
-          signal.removeEventListener("abort", onAbort);
-          resolve4();
-        }, delay);
-        if (signal.aborted) {
-          onAbort();
-          return;
+    }
+  }
+};
+
+// src/core/iteration-limit.ts
+function requestLimitExtension(opts) {
+  const { events, currentIterations, currentLimit, autoExtend, timeoutMs = 3e4 } = opts;
+  return new Promise((resolve4) => {
+    let resolved = false;
+    const timer = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        resolve4(0);
+      }
+    }, timeoutMs);
+    const deny = () => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve4(0);
+      }
+    };
+    const grant = (extra) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        resolve4(Math.max(0, extra));
+      }
+    };
+    events.emit("iteration.limit_reached", {
+      currentIterations,
+      currentLimit,
+      grant,
+      deny
+    });
+    if (autoExtend) {
+      setImmediate(() => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timer);
+          resolve4(100);
         }
-        signal.addEventListener("abort", onAbort, { once: true });
       });
-      attempt++;
     }
-  }
+  });
 }
 
 // src/core/agent.ts
@@ -10075,6 +10372,7 @@ var Agent = class {
   toolExecutor;
   autoExtendLimit;
   tracer;
+  extensions;
   constructor(init) {
     this.container = init.container;
     this.tools = init.tools;
@@ -10088,6 +10386,8 @@ var Agent = class {
     this.perIterationOutputCapBytes = init.perIterationOutputCapBytes ?? 1e5;
     this.autoExtendLimit = init.autoExtendLimit ?? true;
     this.tracer = init.tracer;
+    this.extensions = init.extensions ?? new ExtensionRegistry();
+    this.extensions.setLogger(this.container.resolve(TOKENS.Logger));
     this.toolExecutor = new ToolExecutor(this.tools, {
       permissionPolicy: init.permissionPolicy ?? this.permission,
       secretScrubber: this.scrubber,
@@ -10133,33 +10433,66 @@ var Agent = class {
       "agent.model": opts.model ?? this.ctx.model,
       "agent.executionStrategy": opts.executionStrategy ?? this.executionStrategy
     });
+    const { blocks, text } = normalizeInput(userInput);
+    const inputPayload = { content: blocks, text, ctx: this.ctx };
+    await this.extensions.runBeforeRun(this.ctx, inputPayload);
     try {
-      const result = await this.runInner(userInput, opts, controller);
+      const result = await this.runInner(inputPayload, opts, controller);
       span?.setAttribute("agent.status", result.status);
       span?.setAttribute("agent.iterations", result.iterations);
+      await this.extensions.runAfterRun(this.ctx, result);
       return result;
     } catch (err) {
       const wse = err instanceof AgentError ? err : toWrongStackError(err);
       this.events.emit("error", { err: toError(err), phase: "agent" });
       if (err instanceof Error) span?.recordError(err);
       span?.setAttribute("agent.status", "failed");
-      return {
+      const result = {
         status: signal.aborted ? "aborted" : "failed",
         iterations: 0,
         error: wse
       };
+      await this.extensions.runAfterRun(this.ctx, result);
+      return result;
     } finally {
       span?.end();
       await controller.dispose();
     }
   }
-  async runInner(userInput, opts, controller) {
-    await this.normalizeAndEmitUserInput(userInput);
+  async runInner(inputPayload, opts, controller) {
+    await this.pipelines.userInput.run(inputPayload);
+    this.ctx.state.appendMessage({ role: "user", content: inputPayload.content });
+    await this.ctx.session.append({
+      type: "user_input",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      content: inputPayload.content
+    });
     let finalText = "";
     let iterations = 0;
     let effectiveLimit = opts.maxIterations ?? this.maxIterations;
     const hasHardLimit = effectiveLimit > 0 && Number.isFinite(effectiveLimit);
     let recoveryRetries = 0;
+    const diRunner = this.container.has(TOKENS.ProviderRunner) ? this.container.resolve(TOKENS.ProviderRunner) : null;
+    const baseRunner = diRunner ? (ctx, req) => diRunner.run({
+      provider: ctx.provider,
+      request: req,
+      signal: controller.signal,
+      ctx,
+      events: this.events,
+      retry: this.retry,
+      logger: this.logger,
+      tracer: this.tracer
+    }) : async (ctx, req) => runProviderWithRetry({
+      provider: ctx.provider,
+      request: req,
+      signal: controller.signal,
+      ctx,
+      events: this.events,
+      retry: this.retry,
+      logger: this.logger,
+      tracer: this.tracer
+    });
+    const customRunner = this.extensions.wrapProviderRunner(baseRunner);
     for (let i = 0; ; i++) {
       iterations = i + 1;
       if (controller.signal.aborted) {
@@ -10175,26 +10508,39 @@ var Agent = class {
       if (limitCheck.exit) {
         return { ...limitCheck.exit, finalText };
       }
+      await this.extensions.runBeforeIteration(this.ctx, i);
       this.events.emit("iteration.started", { ctx: this.ctx, index: i });
       const req = await this.buildAndRunRequestPipeline(opts);
       let res;
       try {
-        res = await runProviderWithRetry({
-          provider: this.ctx.provider,
-          request: req,
-          signal: controller.signal,
-          ctx: this.ctx,
-          events: this.events,
-          retry: this.retry,
-          logger: this.logger,
-          tracer: this.tracer
-        });
+        res = await customRunner(this.ctx, req);
         recoveryRetries = 0;
       } catch (err) {
         if (controller.signal.aborted) {
           this.events.emit("error", { err: toError(err), phase: "provider" });
           return { status: "aborted", iterations, error: toWrongStackError(err, "AGENT_ABORTED") };
         }
+        const extDecision = await this.extensions.runOnError(this.ctx, err, "provider", i);
+        if (extDecision) {
+          if (extDecision.action === "fail") {
+            this.events.emit("error", { err: toError(err), phase: "provider" });
+            return { status: "failed", iterations, error: toWrongStackError(err) };
+          }
+          if (extDecision.action === "continue") {
+            await this.extensions.runAfterIteration(this.ctx, i);
+            continue;
+          }
+          if (extDecision.action === "retry") {
+            recoveryRetries++;
+            if (recoveryRetries > 2) {
+              this.events.emit("error", { err: toError(err), phase: "provider" });
+              return { status: "failed", iterations, error: toWrongStackError(err) };
+            }
+            if (extDecision.model) this.ctx.model = extDecision.model;
+            this.logger.info("Extension requested retry; retrying turn");
+            continue;
+          }
+        }
         const recovered = await this.errorHandler.recover(err, this.ctx);
         if (!recovered || recovered.action === "fail") {
           this.events.emit("error", { err: toError(err), phase: "provider" });
@@ -10233,21 +10579,9 @@ var Agent = class {
       await this.executeTools(toolUses);
       this.events.emit("iteration.completed", { ctx: this.ctx, index: i });
       await this.compactContextIfNeeded();
+      await this.extensions.runAfterIteration(this.ctx, i);
     }
   }
-  /**
-   * Normalize user input and emit through userInput pipeline + session append.
-   */
-  async normalizeAndEmitUserInput(userInput) {
-    const { blocks, text } = normalizeInput(userInput);
-    await this.pipelines.userInput.run({ content: blocks, text, ctx: this.ctx });
-    this.ctx.state.appendMessage({ role: "user", content: blocks });
-    await this.ctx.session.append({
-      type: "user_input",
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      content: blocks
-    });
-  }
   /**
    * Check if iteration limit has been reached and request extension if needed.
    * Returns the new effective limit (possibly extended) and a RunResult if
@@ -10331,6 +10665,7 @@ var Agent = class {
    * single tool.
    */
   async executeTools(toolUses) {
+    toolUses = await this.extensions.runBeforeToolExecution(this.ctx, toolUses);
     const { outputs } = await this.toolExecutor.executeBatch(
       toolUses,
       this.ctx,
@@ -10416,6 +10751,7 @@ var Agent = class {
       role: "user",
       content: outputs.map((o) => o.result)
     });
+    await this.extensions.runAfterToolExecution(this.ctx, outputs);
   }
   waitForConfirm(info) {
     return new Promise((resolve4) => {
@@ -10870,6 +11206,15 @@ var DefaultSystemPromptBuilder = class {
         cache_control: { type: "ephemeral" }
       });
     }
+    if (this.opts.contributors && this.opts.contributors.length > 0) {
+      for (const c of this.opts.contributors) {
+        try {
+          const contributed = await c(ctx);
+          blocks.push(...contributed);
+        } catch {
+        }
+      }
+    }
     return blocks;
   }
   /**
@@ -10911,12 +11256,38 @@ var DefaultSystemPromptBuilder = class {
   }
   buildToolUsage(tools) {
     if (tools.length === 0) return "## Tool usage\n\nNo tools registered.";
-    const lines = ["## Tool usage"];
+    const byCat = /* @__PURE__ */ new Map();
+    const uncategorized = [];
     for (const t2 of tools) {
-      const hint = t2.usageHint ?? t2.description;
+      if (t2.category) {
+        let group = byCat.get(t2.category);
+        if (!group) {
+          group = [];
+          byCat.set(t2.category, group);
+        }
+        group.push(t2);
+      } else {
+        uncategorized.push(t2);
+      }
+    }
+    const lines = ["## Tool usage"];
+    for (const [cat, catTools] of byCat) {
       lines.push(`
+### ${cat}`);
+      for (const t2 of catTools) {
+        const hint = t2.usageHint ?? t2.description;
+        const desc = hint.length > 80 ? `${hint.slice(0, 77)}...` : hint.trim();
+        lines.push(`- **${t2.name}** \u2014 ${desc}`);
+      }
+    }
+    if (uncategorized.length > 0) {
+      if (byCat.size > 0) lines.push("");
+      for (const t2 of uncategorized) {
+        const hint = t2.usageHint ?? t2.description;
+        lines.push(`
 ### ${t2.name}
 ${hint.trim()}`);
+      }
     }
     lines.push(`
 ## Common patterns
@@ -11188,6 +11559,21 @@ var ToolRegistry = class {
     this.tools.set(tool.name, { tool, owner });
     return true;
   }
+  /**
+   * Bulk-register multiple tools at once. Each tool that conflicts with an
+   * existing registration is silently skipped — use `registerAllOrThrow`
+   * if you want it to throw on conflicts.
+   */
+  registerAll(tools, owner = "core") {
+    for (const tool of tools) this.tryRegister(tool, owner);
+  }
+  /**
+   * Bulk-register and throw on the first conflict. Use when you need
+   * strict registration (e.g. at boot time).
+   */
+  registerAllOrThrow(tools, owner = "core") {
+    for (const tool of tools) this.register(tool, owner);
+  }
   /**
    * Register a tool as a default. If the tool name is already registered,
    * this is a no-op — the existing registration (from core or another
@@ -11215,6 +11601,30 @@ var ToolRegistry = class {
     }
     this.tools.set(name, { tool, owner });
   }
+  /**
+   * Wrap (decorate) an existing tool. The wrapper receives the current
+   * tool and must return a new tool — typically the same tool with a
+   * wrapped `execute` or `executeStream`. Throws if the tool is not
+   * registered.
+   *
+   * Multiple wraps stack: each wrapper gets the output of the previous.
+   *
+   * @example
+   * registry.wrap('bash', (t) => ({ ...t, permission: 'confirm' }));
+   */
+  wrap(name, wrapper, owner = "core") {
+    const entry = this.tools.get(name);
+    if (!entry) {
+      throw new WrongStackError({
+        message: `Tool "${name}" not registered; cannot wrap`,
+        code: "REGISTRY_NOT_FOUND",
+        subsystem: "container",
+        context: { tool: name }
+      });
+    }
+    const wrapped = wrapper(entry.tool);
+    this.tools.set(name, { tool: wrapped, owner: `${entry.owner}+${owner}` });
+  }
   get(name) {
     return this.tools.get(name)?.tool;
   }
@@ -11224,6 +11634,24 @@ var ToolRegistry = class {
   list() {
     return Array.from(this.tools.values()).map((e) => e.tool);
   }
+  /**
+   * Group tools by their `category` field. Tools without a category
+   * are placed under the key `""` (empty string). Returns a Map of
+   * category → tools, sorted by registration order within each category.
+   */
+  listByCategory() {
+    const map = /* @__PURE__ */ new Map();
+    for (const { tool } of this.tools.values()) {
+      const cat = tool.category ?? "";
+      let group = map.get(cat);
+      if (!group) {
+        group = [];
+        map.set(cat, group);
+      }
+      group.push(tool);
+    }
+    return map;
+  }
   listWithOwner() {
     return Array.from(this.tools.values());
   }
@@ -11243,6 +11671,12 @@ var ProviderRegistry = class {
   register(f) {
     this.factories.set(f.type, f);
   }
+  /**
+   * Bulk-register multiple provider factories at once.
+   */
+  registerAll(factories) {
+    for (const f of factories) this.register(f);
+  }
   /**
    * Override an existing factory. Throws if no factory is registered
    * for the given type. Use this to safely replace a provider at runtime
@@ -11311,6 +11745,12 @@ var SlashCommandRegistry = class {
     }
     return this.cmds.delete(name);
   }
+  /**
+   * Bulk-register multiple slash commands at once.
+   */
+  registerAll(cmds, owner = "core") {
+    for (const cmd of cmds) this.register(cmd, owner);
+  }
   get(name) {
     return this.cmds.get(name)?.cmd;
   }
@@ -11383,15 +11823,23 @@ var DefaultPluginAPI = class {
   providers;
   mcp;
   slashCommands;
+  extensions;
+  session;
+  metrics;
   config;
   log;
+  configStore;
   pluginCleanupFns = [];
   constructor(init) {
     const owner = init.ownerName;
     this.container = init.container;
     this.events = init.events;
     this.config = init.config;
+    this.configStore = init.configStore;
     this.log = init.log.child({ plugin: owner });
+    this.extensions = init.extensions ?? new ExtensionRegistry();
+    this.session = init.sessionWriter ?? noopSession;
+    this.metrics = init.metricsSink ? scopedMetrics(init.metricsSink, owner) : noopMetrics;
     const pipelines = init.pipelines;
     const readonlyPipelines = {};
     for (const [key, pipeline] of Object.entries(pipelines)) {
@@ -11402,6 +11850,7 @@ var DefaultPluginAPI = class {
     this.tools = {
       register: (t2) => tr.register(t2, owner),
       unregister: (name) => tr.unregister(name),
+      wrap: (name, wrapper) => tr.wrap(name, wrapper, owner),
       get: (name) => tr.get(name),
       list: () => tr.list()
     };
@@ -11425,6 +11874,19 @@ var DefaultPluginAPI = class {
     this.pluginCleanupFns.push(off);
     return off;
   }
+  onPattern(pattern, handler) {
+    const off = this.events.onPattern(pattern, handler);
+    this.pluginCleanupFns.push(off);
+    return off;
+  }
+  emitCustom(event, payload) {
+    this.events.emit(event, payload);
+  }
+  onConfigChange(handler) {
+    if (!this.configStore) return () => {
+    };
+    return this.configStore.watch(handler);
+  }
   /** Called by the plugin loader when uninstalling the plugin. */
   drainCleanup() {
     for (const fn of this.pluginCleanupFns.splice(0)) {
@@ -11434,6 +11896,9 @@ var DefaultPluginAPI = class {
       }
     }
   }
+  registerSystemPromptContributor(c) {
+    return this.extensions.registerSystemPromptContributor(c);
+  }
 };
 var noopMcp = {
   start: async () => void 0,
@@ -11454,6 +11919,32 @@ var noopSlashCommands = {
     return [];
   }
 };
+var noopSession = {
+  append: async () => {
+  }
+};
+var noopMetrics = {
+  counter() {
+  },
+  histogram() {
+  },
+  gauge() {
+  }
+};
+function scopedMetrics(sink, pluginName) {
+  const prefix = `plugin.${pluginName}.`;
+  return {
+    counter(name, value, labels) {
+      sink.counter(`${prefix}${name}`, value, labels);
+    },
+    histogram(name, value, labels) {
+      sink.histogram(`${prefix}${name}`, value, labels);
+    },
+    gauge(name, value, labels) {
+      sink.gauge(`${prefix}${name}`, value, labels);
+    }
+  };
+}
 
 // src/plugin/loader.ts
 var KERNEL_API_VERSION = "0.1.10";
@@ -11479,6 +11970,16 @@ function satisfies(range, version) {
 function normalizeDep(d) {
   return typeof d === "string" ? { name: d } : d;
 }
+function shallowMerge(defaults, overrides) {
+  if (overrides === void 0 || overrides === null) return { ...defaults };
+  if (typeof overrides !== "object") return { ...defaults };
+  const ov = overrides;
+  const out = { ...defaults };
+  for (const key of Object.keys(ov)) {
+    out[key] = ov[key];
+  }
+  return out;
+}
 function topoSort(plugins) {
   const map = /* @__PURE__ */ new Map();
   for (const p of plugins) map.set(p.name, p);
@@ -11574,6 +12075,11 @@ async function loadPlugins(plugins, opts) {
       failed.push({ plugin, err });
       continue;
     }
+    if (plugin.defaultConfig && opts.pluginOptions) {
+      const userOpts = opts.pluginOptions[plugin.name];
+      const merged = shallowMerge(plugin.defaultConfig, userOpts);
+      opts.pluginOptions[plugin.name] = merged;
+    }
     if (plugin.configSchema && opts.pluginOptions) {
       const pluginOpts = opts.pluginOptions[plugin.name];
       if (pluginOpts !== void 0) {
@@ -11595,7 +12101,7 @@ async function loadPlugins(plugins, opts) {
     }
     try {
       const rawApi = opts.apiFactory(plugin);
-      const api = plugin.capabilities ? wrapApiForCapabilityCheck(plugin, rawApi, opts.log) : rawApi;
+      const api = plugin.capabilities ? wrapApiForCapabilityCheck(plugin, rawApi, opts.log, opts.enforceCapabilities) : rawApi;
       await plugin.setup(api);
       loaded.push(plugin);
       opts.log.info(`Plugin "${plugin.name}" loaded`);
@@ -11619,10 +12125,18 @@ async function unloadPlugins(loadedPlugins, opts) {
     }
   }
 }
-function wrapApiForCapabilityCheck(plugin, api, log) {
+function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
   const caps = plugin.capabilities ?? {};
-  const warn = (subsystem, detail) => {
+  const violate = (subsystem, detail) => {
     const msg = `Plugin "${plugin.name}" used ${subsystem} without declaring capabilities.${subsystem} \u2014 ${detail}`;
+    if (enforce) {
+      throw new PluginError({
+        message: msg,
+        code: "PLUGIN_LOAD_FAILED",
+        pluginName: plugin.name,
+        context: { subsystem, detail }
+      });
+    }
     if (typeof log.warn === "function") log.warn(msg);
     else log.error(msg);
   };
@@ -11630,7 +12144,7 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
     get(target, prop, receiver) {
       if (prop === "register") {
         return (t2) => {
-          warn("tools", `register(${t2?.name ?? "<unknown>"})`);
+          violate("tools", `register(${t2?.name ?? "<unknown>"})`);
           return target.register(t2);
         };
       }
@@ -11641,7 +12155,7 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
     get(target, prop, receiver) {
       if (prop === "register") {
         return (f) => {
-          warn("providers", `register(${f?.type ?? "<unknown>"})`);
+          violate("providers", `register(${f?.type ?? "<unknown>"})`);
           return target.register(f);
         };
       }
@@ -11652,7 +12166,10 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
     get(target, prop, receiver) {
       if (prop === "register") {
         return (c) => {
-          warn("slashCommands", `register(${c?.name ?? "<unknown>"})`);
+          violate(
+            "slashCommands",
+            `register(${c?.name ?? "<unknown>"})`
+          );
           return target.register(c);
         };
       }
@@ -11663,7 +12180,7 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
     get(target, prop, receiver) {
       if (prop === "start") {
         return (cfg) => {
-          warn("mcp", `start(${cfg?.name ?? "<unknown>"})`);
+          violate("mcp", `start(${cfg?.name ?? "<unknown>"})`);
           return target.start(cfg);
         };
       }
@@ -11688,6 +12205,6 @@ function wrapApiForCapabilityCheck(plugin, api, log) {
   });
 }
 
-export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorBudgetError, DirectorStateCheckpoint, DoneConditionChecker, EventBus, FLEET_ROSTER, FleetBus, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, RunController, SECURITY_SCANNER_AGENT, SelectiveCompactor, SessionAnalyzer, SessionError, SlashCommandRegistry, SpecDrivenDev, SpecParser, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskTracker, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, asBlocks, asText, atomicWrite, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMessage, createToolOutputSerializer, decryptConfigSecrets, detectNewlineStyle, emptyPlan, encryptConfigSecrets, ensureDir, estimateTextTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatPlan, formatTodosList, githubServer, googleMapsServer, isAgentError, isConfigError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, loadDirectorState, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, normalizeToLf, projectHash, removePlanItem, renderPrometheus, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState };
+export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorBudgetError, DirectorStateCheckpoint, DoneConditionChecker, EventBus, ExtensionRegistry, FLEET_ROSTER, FleetBus, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, RunController, SECURITY_SCANNER_AGENT, SelectiveCompactor, SessionAnalyzer, SessionError, SlashCommandRegistry, SpecDrivenDev, SpecParser, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskTracker, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, asBlocks, asText, atomicWrite, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMessage, createToolOutputSerializer, decryptConfigSecrets, detectNewlineStyle, emptyPlan, encryptConfigSecrets, ensureDir, estimateTextTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatPlan, formatTodosList, githubServer, googleMapsServer, isAgentError, isConfigError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, loadDirectorState, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, normalizeToLf, projectHash, removePlanItem, renderPrometheus, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map