cascade-ai 0.72.0 → 0.73.0

package/dist/index.cjs

@@ -1792,6 +1792,15 @@ function findPricing(modelId, provider, opts = {}) {
   }
   return null;
 }
+function hasContextBands(model) {
+  if (model.isLocal) return false;
+  const fallbackProviders = model.provider === "azure" ? ["openai"] : model.provider === "gemini" ? ["vertex"] : [];
+  const match = findPricing(model.id, model.provider, {
+    baseModelId: model.baseModelId,
+    fallbackProviders
+  });
+  return (match?.entry.tiers?.length ?? 0) > 1;
+}
 function tierFor(entry, inputTokens = 0) {
   const tiers = entry.tiers;
   if (!tiers?.length) return null;
@@ -1908,7 +1917,7 @@ function reconcilePrice(model, live) {
 }
 
 // src/constants.ts
-var CASCADE_VERSION = "0.72.0";
+var CASCADE_VERSION = "0.73.0";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -2353,8 +2362,23 @@ var PROVIDER_DISPLAY_NAMES = {
 };
 
 // src/utils/cost.ts
-function resolveModelPricing(model) {
+function resolveModelPricing(model, opts = {}) {
   if (model.isLocal) return { input: 0, output: 0, unknown: false };
+  if (opts.inputTokens != null && hasContextBands(model)) {
+    const banded = resolvePricing(model, { inputTokens: opts.inputTokens });
+    const base = resolvePricing(model, { inputTokens: 0 });
+    if (!banded.unknown && !base.unknown) {
+      const scale = (stamped, baseRate) => stamped > 0 && baseRate > 0 ? stamped / baseRate : 1;
+      const inScale = scale(model.inputCostPer1kTokens, base.input);
+      const outScale = scale(model.outputCostPer1kTokens, base.output);
+      return {
+        input: banded.input * inScale,
+        output: banded.output * outScale,
+        unknown: false,
+        ...banded.estimatedFromProvider ? { estimatedFromProvider: banded.estimatedFromProvider } : {}
+      };
+    }
+  }
   if (model.inputCostPer1kTokens > 0 || model.outputCostPer1kTokens > 0) {
     return {
       input: model.inputCostPer1kTokens,
@@ -2362,7 +2386,7 @@ function resolveModelPricing(model) {
       unknown: false
     };
   }
-  const fromDataset = resolvePricing(model);
+  const fromDataset = resolvePricing(model, { inputTokens: opts.inputTokens });
   if (!fromDataset.unknown) {
     return {
       input: fromDataset.input,
@@ -2384,11 +2408,11 @@ function resolveModelPricing(model) {
   return { input: 0, output: 0, unknown: true };
 }
 function calculateCost(inputTokens, outputTokens, model) {
-  const { input, output } = resolveModelPricing(model);
+  const { input, output } = resolveModelPricing(model, { inputTokens });
   return inputTokens / 1e3 * input + outputTokens / 1e3 * output;
 }
 function buildTokenUsage(inputTokens, outputTokens, model) {
-  const { input, output, unknown } = resolveModelPricing(model);
+  const { input, output, unknown } = resolveModelPricing(model, { inputTokens });
   return {
     inputTokens,
     outputTokens,
@@ -2467,6 +2491,21 @@ function anthropicThinkingParam(modelId, maxTokens) {
   if (budget < 1024) return {};
   return { thinking: { type: "enabled", budget_tokens: budget } };
 }
+function toAnthropicTools(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.inputSchema
+  }));
+}
+function toAnthropicToolUse(toolCalls) {
+  return toolCalls.map((tc) => ({
+    type: "tool_use",
+    id: tc.id,
+    name: tc.name,
+    input: tc.input
+  }));
+}
 var AnthropicProvider = class extends BaseProvider {
   client;
   constructor(config, model) {
@@ -2488,11 +2527,7 @@ var AnthropicProvider = class extends BaseProvider {
   }
   async generateStream(options, onChunk) {
     const messages = this.convertMessages(options.messages);
-    const tools = options.tools?.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.inputSchema
-    }));
+    const tools = options.tools && toAnthropicTools(options.tools);
     let fullContent = "";
     let inputTokens = 0;
     let outputTokens = 0;
@@ -2620,14 +2655,7 @@ var AnthropicProvider = class extends BaseProvider {
         const content = [];
         const text = typeof m.content === "string" ? m.content : "";
         if (text) content.push({ type: "text", text });
-        for (const tc of m.toolCalls ?? []) {
-          content.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.name,
-            input: tc.input
-          });
-        }
+        content.push(...toAnthropicToolUse(m.toolCalls ?? []));
         if (content.length > 0) {
           result.push({ role: "assistant", content });
         }
@@ -2667,6 +2695,26 @@ function isParamShapeError(err) {
   const msg = String(e?.message ?? e?.error?.message ?? "").toLowerCase();
   return msg.includes("max_completion_tokens") || msg.includes("max_tokens") && (msg.includes("unsupported") || msg.includes("not supported") || msg.includes("use")) || msg.includes("temperature") && (msg.includes("unsupported") || msg.includes("does not support") || msg.includes("only the default"));
 }
+function toOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    }
+  }));
+}
+function toOpenAIToolCalls(toolCalls) {
+  return toolCalls.map((tc) => ({
+    id: tc.id,
+    type: "function",
+    function: {
+      name: tc.name,
+      arguments: JSON.stringify(tc.input)
+    }
+  }));
+}
 var OpenAIProvider = class extends BaseProvider {
   client;
   /** Once we learn (from the model id or an API error) that this deployment
@@ -2686,14 +2734,7 @@ var OpenAIProvider = class extends BaseProvider {
   }
   async generateStream(options, onChunk) {
     const messages = this.convertMessages(options.messages, options.systemPrompt);
-    const tools = options.tools?.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.inputSchema
-      }
-    }));
+    const tools = options.tools && toOpenAITools(options.tools);
     let fullContent = "";
     let inputTokens = 0;
     let outputTokens = 0;
@@ -2839,14 +2880,7 @@ var OpenAIProvider = class extends BaseProvider {
           result.push({
             role: "assistant",
             content: m.content || "",
-            tool_calls: m.toolCalls.map((toolCall) => ({
-              id: toolCall.id,
-              type: "function",
-              function: {
-                name: toolCall.name,
-                arguments: JSON.stringify(toolCall.input)
-              }
-            }))
+            tool_calls: toOpenAIToolCalls(m.toolCalls)
           });
         } else {
           result.push({ role: m.role, content: m.content });
@@ -3089,6 +3123,26 @@ function toGeminiParameters(inputSchema) {
 }
 
 // src/providers/gemini.ts
+function toGeminiTools(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    // Convert, never cast. Gemini's parameters field is an OpenAPI subset
+    // that 400s on unknown keys, and MCP servers ship schemas carrying their
+    // own extensions (GitHub's adds `x-mcp-header` to every header-bound
+    // property). Casting sent those through verbatim and every request failed
+    // before the model saw it. See providers/gemini-schema.ts.
+    parameters: toGeminiParameters(tool.inputSchema)
+  }));
+}
+function toGeminiFunctionCalls(toolCalls) {
+  return toolCalls.map((tc) => ({
+    functionCall: {
+      name: tc.name,
+      args: tc.input
+    }
+  }));
+}
 var GeminiProvider = class extends BaseProvider {
   client;
   constructor(config, model) {
@@ -3110,7 +3164,7 @@ var GeminiProvider = class extends BaseProvider {
           { category: genai.HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: genai.HarmBlockThreshold.BLOCK_NONE },
           { category: genai.HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: genai.HarmBlockThreshold.BLOCK_NONE }
         ],
-        tools: options.tools?.length ? [{ functionDeclarations: options.tools.map(this.convertTool) }] : void 0,
+        tools: options.tools?.length ? [{ functionDeclarations: toGeminiTools(options.tools) }] : void 0,
         abortSignal: options.signal
       }
     });
@@ -3251,14 +3305,7 @@ var GeminiProvider = class extends BaseProvider {
         const parts = [];
         const textContent = typeof m.content === "string" ? m.content : "";
         if (textContent) parts.push({ text: textContent });
-        for (const tc of m.toolCalls ?? []) {
-          parts.push({
-            functionCall: {
-              name: tc.name,
-              args: tc.input
-            }
-          });
-        }
+        parts.push(...toGeminiFunctionCalls(m.toolCalls ?? []));
         if (parts.length > 0) {
           contents.push({ role: "model", parts });
         }
@@ -3305,18 +3352,6 @@ var GeminiProvider = class extends BaseProvider {
     }
     return parts;
   }
-  convertTool(tool) {
-    return {
-      name: tool.name,
-      description: tool.description,
-      // Convert, never cast. Gemini's parameters field is an OpenAPI subset
-      // that 400s on unknown keys, and MCP servers ship schemas carrying their
-      // own extensions (GitHub's adds `x-mcp-header` to every header-bound
-      // property). Casting sent those through verbatim and every request failed
-      // before the model saw it. See providers/gemini-schema.ts.
-      parameters: toGeminiParameters(tool.inputSchema)
-    };
-  }
 };
 try {
   dns__default.default.setDefaultResultOrder("ipv4first");
@@ -3409,6 +3444,24 @@ function isToolCapable(modelName) {
   const name = modelName.toLowerCase();
   return TOOL_CAPABLE_FAMILIES.some((family) => name.includes(family));
 }
+function toOllamaTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    }
+  }));
+}
+function toOllamaToolCalls(toolCalls) {
+  return toolCalls.map((tc) => ({
+    function: {
+      name: tc.name,
+      arguments: tc.input
+    }
+  }));
+}
 var OllamaProvider = class extends BaseProvider {
   baseUrl;
   constructor(config, model) {
@@ -3421,14 +3474,7 @@ var OllamaProvider = class extends BaseProvider {
   }
   async generateStream(options, onChunk) {
     const messages = this.convertMessages(options.messages, options.systemPrompt);
-    const ollamaTools = options.tools?.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.inputSchema
-      }
-    }));
+    const ollamaTools = options.tools && toOllamaTools(options.tools);
     const response = await fetch(`${this.baseUrl}/api/chat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -3608,12 +3654,7 @@ var OllamaProvider = class extends BaseProvider {
         result.push({
           role: "assistant",
           content: typeof m.content === "string" ? m.content : "",
-          tool_calls: m.toolCalls.map((tc) => ({
-            function: {
-              name: tc.name,
-              arguments: tc.input
-            }
-          }))
+          tool_calls: toOllamaToolCalls(m.toolCalls)
         });
         continue;
       }
@@ -4014,6 +4055,21 @@ var DEFAULT_PROVIDER_TPM = {
   "openai-compatible": 3e4,
   ollama: Number.POSITIVE_INFINITY
 };
+function abortReason(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("Aborted while waiting for rate-limit capacity");
+}
+function sleepUnlessAborted(ms, signal) {
+  if (!signal) return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve2) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve2();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
 var TpmLimiter = class {
   buckets = /* @__PURE__ */ new Map();
   constructor(overrides = {}) {
@@ -4032,9 +4088,10 @@ var TpmLimiter = class {
    * are reported back via `refund` when short, or simply settled at the next
    * refill.
    */
-  async acquire(provider, estimatedTokens) {
+  async acquire(provider, estimatedTokens, signal) {
     const bucket = this.buckets.get(provider);
     if (!bucket || bucket.tokensPerMinute === Number.POSITIVE_INFINITY) return;
+    if (signal?.aborted) throw abortReason(signal);
     const want = Math.min(estimatedTokens, bucket.tokensPerMinute);
     for (; ; ) {
       this.refill(bucket);
@@ -4044,7 +4101,8 @@ var TpmLimiter = class {
       }
       const deficit = want - bucket.available;
       const waitMs = Math.max(50, Math.ceil(deficit / bucket.tokensPerMinute * 6e4));
-      await new Promise((resolve2) => setTimeout(resolve2, waitMs));
+      await sleepUnlessAborted(waitMs, signal);
+      if (signal?.aborted) throw abortReason(signal);
     }
   }
   /**
@@ -4090,6 +4148,9 @@ var TpmLimiter = class {
 };
 
 // src/core/router/local-queue.ts
+function abortReason2(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("Aborted while waiting for a local inference slot");
+}
 var LocalRequestQueue = class {
   maxConcurrent;
   active = 0;
@@ -4100,9 +4161,16 @@ var LocalRequestQueue = class {
   /**
    * Acquire a queue slot. Returns a `release` function that MUST be called
    * when the inference call is done (even on error). Rejects if the slot
-   * cannot be acquired within `timeoutMs`.
+   * cannot be acquired within `timeoutMs`, or as soon as `signal` fires.
+   *
+   * The signal matters as much as the timeout: with concurrency of 1 a caller
+   * can sit here for half the inference timeout — 150 seconds by default —
+   * and until it was wired up, neither cancelling the run nor spending its
+   * budget got it out. It waited out the window for a slot it would drop the
+   * moment it received one.
    */
-  async acquire(timeoutMs) {
+  async acquire(timeoutMs, signal) {
+    if (signal?.aborted) throw abortReason2(signal);
     if (this.active < this.maxConcurrent) {
       this.active++;
       return this.makeRelease();
@@ -4110,23 +4178,36 @@ var LocalRequestQueue = class {
     return new Promise((resolve2, reject) => {
       let settled = false;
       let timer;
+      const cleanup = () => {
+        if (timer !== void 0) clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+      };
       const resolver = (release) => {
         if (settled) return;
         settled = true;
-        if (timer !== void 0) clearTimeout(timer);
+        cleanup();
         resolve2(release);
       };
+      const abandon = () => {
+        if (settled) return false;
+        settled = true;
+        cleanup();
+        const idx = this.queue.indexOf(resolver);
+        if (idx !== -1) this.queue.splice(idx, 1);
+        return true;
+      };
+      function onAbort() {
+        if (abandon()) reject(abortReason2(signal));
+      }
       if (timeoutMs !== void 0 && timeoutMs > 0) {
         timer = setTimeout(() => {
-          if (settled) return;
-          settled = true;
-          const idx = this.queue.indexOf(resolver);
-          if (idx !== -1) this.queue.splice(idx, 1);
+          if (!abandon()) return;
           reject(new Error(
             `Local model queue: timed out waiting for a free slot after ${timeoutMs}ms. Active: ${this.active}, Queued: ${this.queue.length}. Consider increasing localConcurrency or localInferenceTimeoutMs in your config.`
           ));
         }, timeoutMs);
       }
+      signal?.addEventListener("abort", onAbort, { once: true });
       this.queue.push(resolver);
     });
   }
@@ -4263,6 +4344,116 @@ function fileDeadModelPersistence(filePath) {
   };
 }
 
+// src/core/context/compaction.ts
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.max(1, Math.ceil(text.length / CHARS_PER_TOKEN));
+}
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  return content.map((c) => c.type === "text" ? c.text : c.type === "tool_result" ? c.content : `[${c.type}]`).join(" ");
+}
+function messagesTokens(messages) {
+  return messages.reduce((n, m) => n + estimateTokens(contentToText(m.content)), 0);
+}
+function atomize(text, maxChars) {
+  const seps = ["\n\n", "\n", ". ", " "];
+  let units = [text];
+  for (const sep of seps) {
+    if (units.every((u) => u.length <= maxChars)) break;
+    const next = [];
+    for (const u of units) {
+      if (u.length <= maxChars) {
+        next.push(u);
+        continue;
+      }
+      const parts = u.split(sep);
+      parts.forEach((p, i) => next.push(i < parts.length - 1 ? p + sep : p));
+    }
+    units = next;
+  }
+  const out = [];
+  for (const u of units) {
+    if (u.length <= maxChars) out.push(u);
+    else for (let i = 0; i < u.length; i += maxChars) out.push(u.slice(i, i + maxChars));
+  }
+  return out;
+}
+function chunkText(text, opts) {
+  const maxChars = Math.max(1, Math.floor(opts.maxTokens * 4));
+  const overlap = Math.min(maxChars - 1, Math.max(0, Math.floor(maxChars * (opts.overlapRatio ?? 0.1))));
+  const trimmed = text.trim();
+  if (!trimmed) return [];
+  if (trimmed.length <= maxChars) return [trimmed];
+  const units = atomize(trimmed, maxChars);
+  const chunks = [];
+  let cur = "";
+  for (const u of units) {
+    if (cur && cur.length + u.length > maxChars) {
+      chunks.push(cur.trim());
+      cur = overlap > 0 ? cur.slice(-overlap) : "";
+    }
+    cur += u;
+  }
+  if (cur.trim()) chunks.push(cur.trim());
+  return chunks;
+}
+function needsCompaction(totalTokens, contextWindow, reserve = 0.2) {
+  if (!contextWindow || contextWindow <= 0) return false;
+  return totalTokens > contextWindow * (1 - reserve);
+}
+async function mapReduceCompact(text, opts) {
+  const capChars = opts.capTokens * 4;
+  let working = text;
+  let truncated = false;
+  if (working.length > capChars) {
+    working = working.slice(0, capChars);
+    truncated = true;
+  }
+  const instruction = opts.instruction ?? "Summarize this content, preserving key facts, names, numbers, and decisions.";
+  let chunks = chunkText(working, { maxTokens: opts.chunkTokens });
+  if (chunks.length <= 1) return { text: working, chunks: chunks.length, calls: 0, truncated };
+  let calls = 0;
+  let parts = await Promise.all(
+    chunks.map((c, i) => {
+      calls++;
+      return opts.summarize(c, `${instruction} (part ${i + 1} of ${chunks.length})`);
+    })
+  );
+  let combined = parts.join("\n\n");
+  const maxPasses = opts.maxReducePasses ?? 3;
+  for (let pass = 0; pass < maxPasses && estimateTokens(combined) > opts.targetTokens; pass++) {
+    const groups = chunkText(combined, { maxTokens: opts.chunkTokens });
+    if (groups.length <= 1) break;
+    parts = await Promise.all(
+      groups.map((g) => {
+        calls++;
+        return opts.summarize(g, "Merge these partial summaries into one cohesive summary; keep all distinct facts.");
+      })
+    );
+    combined = parts.join("\n\n");
+  }
+  const note = truncated ? "\n\n[Note: input exceeded the extended-context cap and was truncated.]" : "";
+  return { text: combined + note, chunks: chunks.length, calls, truncated };
+}
+async function rollingSummary(messages, opts) {
+  if (messages.length <= opts.keepRecent) return messages;
+  const older = messages.slice(0, messages.length - opts.keepRecent);
+  const recent = messages.slice(messages.length - opts.keepRecent);
+  const transcript = older.map((m) => `${m.role}: ${contentToText(m.content)}`).join("\n");
+  const summary = await opts.summarize(
+    transcript,
+    "Summarize this earlier conversation. Preserve facts, decisions, names, numbers, and any open threads or todos."
+  );
+  const summaryMessage = {
+    role: "system",
+    content: `Summary of earlier conversation (folded to fit the context window):
+${summary}`
+  };
+  return [summaryMessage, ...recent];
+}
+
 // src/utils/retry.ts
 var CascadeCancelledError = class extends Error {
   constructor(reason) {
@@ -4297,6 +4488,158 @@ async function withTimeout(promise, timeoutMs, errorMessage = "Operation timed o
     if (timer !== void 0) clearTimeout(timer);
   }
 }
+async function withTimeoutAbort(run, timeoutMs, errorMessage = "Operation timed out", outer) {
+  const outers = (Array.isArray(outer) ? outer : [outer]).filter((sig) => sig !== void 0);
+  const controller = new AbortController();
+  let timer;
+  let rejectRace;
+  const settle = (reason) => {
+    rejectRace?.(reason);
+    controller.abort(reason);
+  };
+  const abortOuter = () => {
+    const fired = outers.find((sig) => sig.aborted);
+    settle(fired?.reason instanceof Error ? fired.reason : new CascadeCancelledError("Run cancelled"));
+  };
+  const failPromise = new Promise((_, reject) => {
+    rejectRace = reject;
+    timer = setTimeout(() => settle(new Error(errorMessage)), timeoutMs);
+  });
+  try {
+    if (outers.some((sig) => sig.aborted)) {
+      abortOuter();
+      return await failPromise;
+    }
+    for (const sig of outers) sig.addEventListener("abort", abortOuter, { once: true });
+    return await Promise.race([run(controller.signal), failPromise]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    for (const sig of outers) sig.removeEventListener("abort", abortOuter);
+  }
+}
+function anySignal(sources) {
+  const live = sources.filter((s) => s !== void 0);
+  if (live.length === 0) return { release: () => {
+  } };
+  if (live.length === 1) return { signal: live[0], release: () => {
+  } };
+  const controller = new AbortController();
+  function detach() {
+    for (const s of live) s.removeEventListener("abort", onAbort);
+  }
+  function onAbort() {
+    const fired = live.find((s) => s.aborted);
+    controller.abort(fired?.reason instanceof Error ? fired.reason : new CascadeCancelledError("Run cancelled"));
+    detach();
+  }
+  if (live.some((s) => s.aborted)) {
+    onAbort();
+    return { signal: controller.signal, release: detach };
+  }
+  for (const s of live) s.addEventListener("abort", onAbort, { once: true });
+  return { signal: controller.signal, release: detach };
+}
+
+// src/core/router/wire-profile.ts
+var textAndImageOnly = (block) => block.type === "text" || block.type === "image";
+var ANTHROPIC = {
+  // convertMessages: `if (m.role === 'system') continue` — history system
+  // messages are skipped outright; only options.systemPrompt goes as system
+  // input. Compaction emits exactly such a message, holding a summary of the
+  // whole conversation, so charging it refused runs over input never sent.
+  dropsMessage: (m) => m.role === "system",
+  blockHandling: (m) => {
+    if (m.role === "tool") return "stringified";
+    if (m.role === "assistant") return "dropped";
+    return "blocks";
+  },
+  sendsToolCalls: (m) => m.role === "assistant",
+  sendsBlock: textAndImageOnly,
+  sendsToolCallId: true,
+  sizeToolCalls: toAnthropicToolUse,
+  sendsUrlImages: true,
+  readsTopLevelImages: false,
+  sizeTools: toAnthropicTools
+};
+var GEMINI = {
+  // buildContents folds a system message into the next user turn, but only
+  // when it has text: array content collapses to '' and the message is
+  // skipped, as is a whitespace-only string.
+  dropsMessage: (m) => m.role === "system" && !(typeof m.content === "string" ? m.content : "").trim(),
+  blockHandling: (m) => {
+    if (m.role === "tool") return "stringified";
+    if (m.role === "assistant" || m.role === "system") return "dropped";
+    return "blocks";
+  },
+  sendsToolCalls: (m) => m.role === "assistant",
+  sendsBlock: textAndImageOnly,
+  sendsToolCallId: true,
+  sizeToolCalls: toGeminiFunctionCalls,
+  sendsUrlImages: false,
+  readsTopLevelImages: true,
+  sizeTools: toGeminiTools
+};
+var OPENAI = {
+  dropsMessage: () => false,
+  blockHandling: (m) => {
+    if (m.role === "system" || m.role === "tool") return "dropped";
+    return "blocks";
+  },
+  // The tool_calls branch is inside `if (typeof m.content === 'string')`; an
+  // assistant turn with array content falls through to the parts branch and
+  // its tool calls are never attached.
+  sendsToolCalls: (m) => m.role === "assistant" && typeof m.content === "string",
+  sendsBlock: textAndImageOnly,
+  sendsToolCallId: true,
+  sizeToolCalls: toOpenAIToolCalls,
+  sendsUrlImages: true,
+  readsTopLevelImages: false,
+  sizeTools: toOpenAITools
+};
+var OLLAMA = {
+  dropsMessage: () => false,
+  blockHandling: (m) => {
+    if (m.role === "system") return "dropped";
+    if (m.role === "tool") return "stringified";
+    if (m.role === "assistant" && m.toolCalls?.length) return "dropped";
+    return "blocks";
+  },
+  sendsToolCalls: (m) => m.role === "assistant",
+  // The image split maps `b.image.data` with no check on `type`, so a URL is
+  // submitted too (as a URL string in the `images` array).
+  sendsBlock: textAndImageOnly,
+  sendsToolCallId: false,
+  sizeToolCalls: toOllamaToolCalls,
+  sendsUrlImages: true,
+  readsTopLevelImages: false,
+  sizeTools: toOllamaTools
+};
+var PROFILES = {
+  anthropic: ANTHROPIC,
+  gemini: GEMINI,
+  openai: OPENAI,
+  // AzureOpenAIProvider and OpenAICompatibleProvider both extend OpenAIProvider
+  // and neither overrides convertMessages.
+  azure: OPENAI,
+  "openai-compatible": OPENAI,
+  ollama: OLLAMA
+};
+function wireProfile(provider) {
+  return PROFILES[provider] ?? OPENAI;
+}
+function geminiImageCopies(messages) {
+  for (const m of messages) {
+    if (m.role === "user") {
+      const laterUserTurn = messages.slice(messages.indexOf(m) + 1).some((x) => x.role === "user");
+      return laterUserTurn ? 2 : 1;
+    }
+    const text = typeof m.content === "string" ? m.content : "";
+    if (m.role === "system" && text.trim()) return 1;
+    if (m.role === "tool") return 1;
+    if (m.role === "assistant" && (text || m.toolCalls?.length)) return 1;
+  }
+  return 1;
+}
 
 // src/core/router/model-profiler.ts
 var SKIP_PATTERN = /embed|dall-e|whisper|tts|vision|instruct-vision|rerank/i;
@@ -4801,6 +5144,36 @@ function azureModelForTier(tier, ranked) {
   if (tier === "T3") return ranked[ranked.length - 1];
   return ranked[Math.min(1, ranked.length - 1)];
 }
+var IMAGE_TOKENS_MAX = 2e3;
+var IMAGE_TOKENS_EACH = IMAGE_TOKENS_MAX;
+function safeJson(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function newRunAbort() {
+  const controller = new AbortController();
+  EventEmitter.setMaxListeners(64, controller.signal);
+  return controller;
+}
+var TOKENS_PER_MESSAGE_FRAMING = 4;
+function guardTokens(text) {
+  if (!text) return 0;
+  let asciiChars = 0;
+  let denseBytes = 0;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    if (cp <= 127) {
+      asciiChars++;
+      continue;
+    }
+    denseBytes += cp <= 2047 ? 2 : cp <= 65535 ? 3 : 4;
+  }
+  if (denseBytes === 0) return estimateTokens(text);
+  return Math.ceil(asciiChars / CHARS_PER_TOKEN) + denseBytes;
+}
 var DISCOVERY_TTL_MS = 15 * 60 * 1e3;
 var DISCOVERY_TIMEOUT_MS = 4e3;
 var cloudDiscoveryCache = /* @__PURE__ */ new Map();
@@ -4853,6 +5226,33 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
   // start of every `cascade run`, independent of the session-wide budget.
   runTokens = 0;
   runCostUsd = 0;
+  /**
+   * Budget held for calls that are IN FLIGHT — admitted by the preflight check
+   * but not yet counted by recordStats. Without these, concurrent calls all
+   * measure themselves against the same unspent allowance and are all admitted.
+   * Released when each call settles; reset by beginRun() alongside the totals.
+   */
+  reservedTokens = 0;
+  reservedCostUsd = 0;
+  /**
+   * Fires when this run's budget is spent, cancelling work already in flight.
+   *
+   * The kill switch was previously only a flag, which stops calls that have
+   * not yet submitted. A parallel wave's earlier members are already at the
+   * provider by then, and they carried on generating for a run whose output
+   * would be discarded. Every provider call chains to this, so tripping the
+   * ceiling reaches the requests that are running, not just the ones queued.
+   */
+  runAbort = newRunAbort();
+  /**
+   * Bumped by every beginRun(). A release handle remembers the generation it
+   * was issued in and does nothing if that has moved on: beginRun() zeroes the
+   * counters, so a call still in flight from the previous run would otherwise
+   * subtract its estimate from the NEW run's totals and drive them negative —
+   * leaving later preflights believing there is more allowance than the cap
+   * actually holds, which is worse than no gate at all.
+   */
+  runGeneration = 0;
   runBudgetExceeded = false;
   runBudgetExceededReason;
   /**
@@ -5022,7 +5422,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     try {
       const cfg = this.config.providers.find((p) => p.type === model.provider) ?? { type: model.provider };
       const provider = this.createProvider(cfg, model);
-      const result = await withTimeout(provider.generate({
+      const result = await withTimeoutAbort((signal) => provider.generate({
         messages: [{ role: "user", content: "Call the echo tool with text set to 'ping'. Use the tool; do not answer in prose." }],
         tools: [{
           name: "echo",
@@ -5030,7 +5430,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
           inputSchema: { type: "object", properties: { text: { type: "string", description: "Text to echo" } }, required: ["text"] }
         }],
         maxTokens: 80,
-        temperature: 0
+        temperature: 0,
+        signal
       }), 3e4, "tool-support probe timed out");
       return (result.toolCalls?.length ?? 0) > 0;
     } catch {
@@ -5151,9 +5552,12 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
         this.runBudgetExceededReason ?? "Per-task budget exceeded."
       );
     }
+    const runGeneration = this.runGeneration;
+    const runAbort = this.runAbort;
+    const runSignal = this.runSignal;
     options = applyTierLimits(options, tier, this.config?.tierLimits);
-    if (this.runSignal && !options.signal) {
-      options = { ...options, signal: this.runSignal };
+    if (runSignal && !options.signal) {
+      options = { ...options, signal: runSignal };
     }
     if (options.model && !requireVision) {
       this.ensureProvider(options.model, this.config.providers);
@@ -5175,58 +5579,84 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     if (!model) throw new Error(`No model available for tier ${tier}`);
     const provider = this.getProvider(model);
     if (!provider) throw new Error(`No provider for model ${model.id}`);
+    let releaseReservation = this.enforcePreflightBudget(model, options);
     const requestedTokens = options.maxTokens ?? model.maxOutputTokens ?? 1024;
     const estimatedTokens = Math.min(requestedTokens, model.maxOutputTokens ?? requestedTokens) + 512;
     if (this.tpmLimiter) {
-      await this.tpmLimiter.acquire(model.provider, estimatedTokens);
+      const wait = anySignal([options.signal, runAbort.signal]);
+      try {
+        await this.tpmLimiter.acquire(model.provider, estimatedTokens, wait.signal);
+      } catch (err) {
+        releaseReservation?.();
+        throw this.asAbortFailure(err, options.signal, runSignal);
+      } finally {
+        wait.release();
+      }
     }
     const useStream = Boolean(onChunk) && model.supportsStreaming && typeof provider.generateStream === "function";
     let releaseLocalSlot;
     if (model.isLocal) {
       const inferenceTimeoutMs = this.config.localInferenceTimeoutMs ?? 3e5;
       const queueWaitMs = Math.round(inferenceTimeoutMs / 2);
-      releaseLocalSlot = await this.localQueue.acquire(queueWaitMs);
+      const wait = anySignal([options.signal, runAbort.signal]);
+      try {
+        releaseLocalSlot = await this.localQueue.acquire(queueWaitMs, wait.signal);
+      } catch (err) {
+        releaseReservation?.();
+        throw this.asAbortFailure(err, options.signal, runSignal);
+      } finally {
+        wait.release();
+      }
     }
     try {
+      if (runGeneration === this.runGeneration && this.runBudgetExceeded) {
+        this.tpmLimiter?.refund(model.provider, estimatedTokens);
+        throw new _CascadeRouter.BudgetExceededError(
+          this.runBudgetExceededReason ?? "Per-task budget exceeded."
+        );
+      }
       let result;
       if (model.isLocal) {
         const inferenceTimeoutMs = this.config.localInferenceTimeoutMs ?? 3e5;
-        const inferencePromise = useStream && onChunk ? provider.generateStream(options, (chunk) => {
-          const text = typeof chunk?.text === "string" ? chunk.text : "";
-          if (text) onChunk({ ...chunk, text });
-        }) : provider.generate(options);
-        result = await withTimeout(
-          inferencePromise,
+        result = await withTimeoutAbort(
+          (signal) => useStream && onChunk ? provider.generateStream({ ...options, signal }, (chunk) => {
+            const text = typeof chunk?.text === "string" ? chunk.text : "";
+            if (text) onChunk({ ...chunk, text });
+          }) : provider.generate({ ...options, signal }),
           inferenceTimeoutMs,
-          `Local model ${model.id} inference timed out after ${inferenceTimeoutMs}ms`
+          `Local model ${model.id} inference timed out after ${inferenceTimeoutMs}ms`,
+          [options.signal, runAbort.signal]
         );
       } else if (useStream && onChunk) {
         const cloudTimeoutMs = this.config.cloudInferenceTimeoutMs ?? 12e4;
         try {
-          result = await withTimeout(
-            provider.generateStream(options, (chunk) => {
+          result = await withTimeoutAbort(
+            (signal) => provider.generateStream({ ...options, signal }, (chunk) => {
               const text = typeof chunk?.text === "string" ? chunk.text : "";
               if (text) onChunk({ ...chunk, text });
             }),
             cloudTimeoutMs,
-            `Model ${model.id} stream timed out after ${cloudTimeoutMs}ms`
+            `Model ${model.id} stream timed out after ${cloudTimeoutMs}ms`,
+            [options.signal, runAbort.signal]
           );
         } catch (streamErr) {
-          if (streamErr instanceof Error && streamErr.name === "AbortError" || this.runSignal?.aborted || options.signal?.aborted) {
+          if (streamErr instanceof Error && streamErr.name === "AbortError" || runSignal?.aborted || options.signal?.aborted) {
             throw streamErr;
           }
-          result = await withTimeout(
-            provider.generate(options),
+          result = await withTimeoutAbort(
+            (signal) => provider.generate({ ...options, signal }),
             cloudTimeoutMs,
-            `Model ${model.id} inference timed out after ${cloudTimeoutMs}ms`
+            `Model ${model.id} inference timed out after ${cloudTimeoutMs}ms`,
+            [options.signal, runAbort.signal]
           );
         }
       } else {
         const cloudTimeoutMs = this.config.cloudInferenceTimeoutMs ?? 12e4;
-        result = await withTimeout(
-          provider.generate(options),
+        result = await withTimeoutAbort(
+          (signal) => provider.generate({ ...options, signal }),
           cloudTimeoutMs,
-          `Model ${model.id} inference timed out after ${cloudTimeoutMs}ms`
+          `Model ${model.id} inference timed out after ${cloudTimeoutMs}ms`,
+          [options.signal, runAbort.signal]
         );
       }
       const corrected = buildTokenUsage(
@@ -5245,11 +5675,12 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
       if (!result || typeof result.content !== "string" || !result.usage) {
         throw new Error(`Provider ${model.provider}:${model.id} returned an invalid generation result.`);
       }
-      this.recordStats(tier, model, result.usage, options.featureTag);
+      this.recordStats(tier, model, result.usage, options.featureTag, runGeneration);
       this.failover.recordSuccess(model.provider);
       return result;
     } catch (err) {
-      if (err instanceof Error && err.name === "AbortError" || this.runSignal?.aborted || options.signal?.aborted) {
+      if (err instanceof _CascadeRouter.BudgetExceededError) throw err;
+      if (err instanceof Error && err.name === "AbortError" || runSignal?.aborted || options.signal?.aborted) {
         throw new CascadeCancelledError("Run cancelled");
       }
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -5267,6 +5698,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
           });
           releaseLocalSlot?.();
           releaseLocalSlot = void 0;
+          releaseReservation?.();
+          releaseReservation = void 0;
           const retryOpts = options.model && options.model.id === model.id ? { ...options, model: void 0 } : options;
           return this.generate(tier, retryOpts, onChunk, requireVision);
         }
@@ -5288,6 +5721,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
           });
           releaseLocalSlot?.();
           releaseLocalSlot = void 0;
+          releaseReservation?.();
+          releaseReservation = void 0;
           const base = options.model && options.model.id === model.id ? { ...options, model: void 0 } : options;
           const retryOpts = { ...base, _notFoundDepth: depth };
           return this.generate(tier, retryOpts, onChunk, requireVision);
@@ -5296,6 +5731,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
       throw err;
     } finally {
       releaseLocalSlot?.();
+      releaseReservation?.();
+      releaseReservation = void 0;
     }
   }
   getModelForTier(tier) {
@@ -5666,7 +6103,14 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     }
     return void 0;
   }
-  recordStats(tier, model, usage, featureTag) {
+  /**
+   * `runGeneration` is the generation the call was ADMITTED in — see
+   * `generate()`. Session-wide accounting always applies (the spend is real
+   * whenever it lands), but the per-RUN ceiling is only meaningful for the run
+   * the call belongs to, so a straggler from a finished run is left out of it.
+   * Omitted by the direct callers in tests, which have no run to straddle.
+   */
+  recordStats(tier, model, usage, featureTag, runGeneration) {
     this.stats.totalTokens += usage.totalTokens;
     this.stats.totalCostUsd += usage.estimatedCostUsd;
     this.sessionCostUsd += usage.estimatedCostUsd;
@@ -5691,10 +6135,13 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
         });
       }
     }
-    this.runTokens += usage.totalTokens;
-    this.runCostUsd += usage.estimatedCostUsd;
+    const currentRun = runGeneration === void 0 || runGeneration === this.runGeneration;
+    if (currentRun) {
+      this.runTokens += usage.totalTokens;
+      this.runCostUsd += usage.estimatedCostUsd;
+    }
     this.updateBudgetState();
-    this.enforceRunBudget();
+    if (currentRun) this.enforceRunBudget();
   }
   /**
    * Resets per-run accounting at the start of each `cascade run`. Session
@@ -5704,9 +6151,158 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
   beginRun() {
     this.runTokens = 0;
     this.runCostUsd = 0;
+    this.reservedTokens = 0;
+    this.reservedCostUsd = 0;
+    this.runAbort = newRunAbort();
+    this.runGeneration++;
     this.runBudgetExceeded = false;
     this.runBudgetExceededReason = void 0;
   }
+  /**
+   * Refuse a call whose input alone cannot fit what is left of the run budget.
+   *
+   * `enforceRunBudget()` below runs AFTER a call returns, which makes the caps
+   * a stop rather than a pre-authorisation: the tokens are already bought by
+   * the time it looks. That was tolerable while a prompt could not exceed
+   * 20,000 characters, and stopped being so when that cap was removed in
+   * 0.72.0 — a multi-megabyte prompt is billed in full on the very first call
+   * (the complexity classifier sends the whole thing), and no ceiling
+   * configured downstream can give that money back.
+   *
+   * Deliberately narrow, because a false refusal is worse than a late stop:
+   *
+   *   • INPUT ONLY. What a call returns is not knowable in advance, and
+   *     charging a worst-case `maxTokens` of output against the budget would
+   *     decline runs that would have finished comfortably. Input is the part
+   *     that is already determined, and it is the part the removed cap used to
+   *     bound.
+   *   • Compared against what REMAINS (`cap - spent`), not the whole cap, so a
+   *     call is judged on the budget it can actually draw from.
+   *   • Skipped when the model has no usable price. An estimate cannot be made,
+   *     and refusing on ignorance would break every self-hosted and local model
+   *     the moment a cost cap is set. The post-hoc stop still applies there.
+   *   • Skipped entirely when no cap is configured — there is nothing to
+   *     pre-authorise against.
+   *
+   * The message names the cap AND the estimate, because "too expensive" with
+   * no numbers gives the user nothing to change.
+   */
+  enforcePreflightBudget(model, options) {
+    const budget = this.config?.budget;
+    const maxCost = budget?.maxCostPerRunUsd;
+    const maxTokens = budget?.maxTokensPerRun;
+    if (maxCost == null && maxTokens == null) return void 0;
+    const inputTokens = this.estimateInputTokens(options, model);
+    if (maxTokens != null) {
+      const remaining = maxTokens - this.runTokens - this.reservedTokens;
+      if (inputTokens > remaining) {
+        this.failPreflight(
+          `This request's input is about ${inputTokens.toLocaleString()} tokens, but only ${Math.max(0, remaining).toLocaleString()} of the per-task cap of ${maxTokens.toLocaleString()} remain. Shorten the input, or raise budget.maxTokensPerRun.`
+        );
+      }
+    }
+    let estimatedUsd = 0;
+    if (maxCost != null) {
+      const { input: inputPer1k, unknown } = resolveModelPricing(model, { inputTokens });
+      if (!unknown && inputPer1k > 0) {
+        estimatedUsd = inputTokens / 1e3 * inputPer1k;
+        const remaining = maxCost - this.runCostUsd - this.reservedCostUsd;
+        if (estimatedUsd > remaining) {
+          this.failPreflight(
+            `Sending this request to ${model.provider}:${model.id} would cost about $${estimatedUsd.toFixed(4)} in input alone (~${inputTokens.toLocaleString()} tokens), and only $${Math.max(0, remaining).toFixed(4)} of the per-task cap of $${maxCost.toFixed(4)} remains. Shorten the input, choose a cheaper model, or raise budget.maxCostPerRunUsd.`
+          );
+        }
+      }
+    }
+    this.reservedTokens += inputTokens;
+    this.reservedCostUsd += estimatedUsd;
+    const generation = this.runGeneration;
+    let released = false;
+    return () => {
+      if (released || generation !== this.runGeneration) return;
+      released = true;
+      this.reservedTokens -= inputTokens;
+      this.reservedCostUsd -= estimatedUsd;
+    };
+  }
+  /**
+   * What this call will send, in tokens.
+   *
+   * Text is the bulk of it, but not all of it: providers bill the serialized
+   * TOOL DEFINITIONS on every native-tool call (Anthropic sends each name,
+   * description and input schema), and an image is billed by its own size
+   * rather than as the `[image]` placeholder `contentToText` reduces it to. A
+   * tool-heavy or vision request could therefore pass either cap while its real
+   * input already exceeded the allowance.
+   */
+  estimateInputTokens(options, model) {
+    let tokens = guardTokens(options.systemPrompt ?? "");
+    let images = 0;
+    const wire = wireProfile(model.provider);
+    const countsImage = (img) => wire.sendsUrlImages || img?.type === "base64";
+    for (const message of options.messages) {
+      if (wire.dropsMessage(message)) continue;
+      tokens += TOKENS_PER_MESSAGE_FRAMING;
+      if (typeof message.content === "string") {
+        tokens += guardTokens(message.content);
+      } else {
+        switch (wire.blockHandling(message)) {
+          case "blocks":
+            for (const block of message.content) {
+              if (!wire.sendsBlock(block)) continue;
+              if (block.type === "image") {
+                if (countsImage(block.image)) images++;
+                continue;
+              }
+              tokens += guardTokens(contentToText([block]));
+            }
+            break;
+          case "stringified":
+            tokens += guardTokens(safeJson(message.content));
+            break;
+        }
+      }
+      if (message.toolCalls?.length && wire.sendsToolCalls(message)) {
+        tokens += guardTokens(safeJson(wire.sizeToolCalls(message.toolCalls)));
+      }
+      if (message.toolCallId && message.role === "tool" && wire.sendsToolCallId) {
+        tokens += guardTokens(message.toolCallId);
+      }
+    }
+    if (options.tools?.length) {
+      tokens += guardTokens(safeJson(wire.sizeTools(options.tools)));
+    }
+    if (wire.readsTopLevelImages) {
+      const topLevel = (options.images ?? []).filter(countsImage).length;
+      images += topLevel * geminiImageCopies(options.messages);
+    }
+    tokens += images * IMAGE_TOKENS_EACH;
+    return tokens;
+  }
+  /**
+   * Report a wait that ended because something asked it to stop, the same way
+   * the provider call below reports one.
+   *
+   * The queue waits sit OUTSIDE the try/catch that maps aborts, so without
+   * this a cancellation surfaced as whatever the queue happened to throw and
+   * was retried or failed over like an ordinary error. A budget abort keeps
+   * saying it ran out of budget — otherwise the reason the run stopped is lost
+   * on the way up — and anything else that was aborted becomes a cancellation.
+   */
+  asAbortFailure(err, callSignal, runSignal) {
+    if (err instanceof _CascadeRouter.BudgetExceededError) return err;
+    if (err instanceof CascadeCancelledError) return err;
+    if (callSignal?.aborted || runSignal?.aborted) return new CascadeCancelledError("Run cancelled");
+    return err;
+  }
+  /** Trips the same run-level flag a post-hoc overrun does, and reports it the same way. */
+  failPreflight(reason) {
+    this.runBudgetExceeded = true;
+    this.runBudgetExceededReason = reason;
+    this.runAbort.abort(new _CascadeRouter.BudgetExceededError(reason));
+    this.emit("budget:exceeded", { reason, spentUsd: this.sessionCostUsd });
+    throw new _CascadeRouter.BudgetExceededError(reason);
+  }
   /**
    * Enforce the hard per-task ceiling. Once tripped, the flag makes every
    * subsequent (and concurrent) generate() call in this run fail fast.
@@ -5722,6 +6318,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     const reason = overTokens ? `Per-task token cap of ${maxTokens.toLocaleString()} reached (used ${this.runTokens.toLocaleString()}). Stopping this run to avoid runaway cost \u2014 raise budget.maxTokensPerRun for larger jobs.` : `Per-task cost cap of $${maxCost.toFixed(4)} reached (spent $${this.runCostUsd.toFixed(4)}). Stopping this run to avoid runaway cost.`;
     this.runBudgetExceeded = true;
     this.runBudgetExceededReason = reason;
+    this.runAbort.abort(new _CascadeRouter.BudgetExceededError(reason));
     this.emit("budget:exceeded", { reason, spentUsd: this.sessionCostUsd });
     throw new _CascadeRouter.BudgetExceededError(reason);
   }
@@ -6958,6 +7555,12 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         maxTokens: 4096,
         ...subtaskModel ? { model: subtaskModel } : {},
         featureTag: this.assignment?.sectionTitle,
+        // The wave signal, so cancel-and-respawn reaches the request that is
+        // RUNNING rather than only stopping the worker at its next checkpoint.
+        // It is a superset of the run signal the router injects when this is
+        // absent (T2 composes it from that signal plus its own per-wave one),
+        // so wiring it here loses no cancellation and adds the wave's.
+        ...this.signal ? { signal: this.signal } : {},
         ...this.localOnlyMatch ? { forceLocal: true } : {}
       };
       const result = await this.router.generate(
@@ -7436,6 +8039,7 @@ ${current}`
 HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
           maxTokens: 4096,
           featureTag: assignment.sectionTitle,
+          ...this.signal ? { signal: this.signal } : {},
           ...this.localOnlyMatch ? { forceLocal: true } : {}
         });
         const next = (improved.content ?? "").trim();
@@ -7497,6 +8101,7 @@ Reply with JSON: { "completeness": "pass"|"fail", "correctness": "pass"|"fail",
 
 HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
       featureTag: assignment.sectionTitle,
+      ...this.signal ? { signal: this.signal } : {},
       ...this.localOnlyMatch ? { forceLocal: true } : {}
     });
     try {
@@ -7536,6 +8141,7 @@ ${output.slice(0, 4e3)}`;
         messages: [{ role: "user", content: prompt }],
         maxTokens: 300,
         temperature: 0,
+        ...this.signal ? { signal: this.signal } : {},
         ...this.localOnlyMatch ? { forceLocal: true } : {}
       });
       const match = /\[[\s\S]*\]/.exec(result.content);
@@ -7647,6 +8253,10 @@ Begin execution now.`;
   }
 };
 var PeerBus = class extends EventEmitter__default.default {
+  constructor() {
+    super();
+    this.setMaxListeners(64);
+  }
   outputs = /* @__PURE__ */ new Map();
   waiters = /* @__PURE__ */ new Map();
   members = /* @__PURE__ */ new Set();
@@ -8894,6 +9504,7 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
       const waveSignal = AbortSignal.any(
         [this.signal, this.waveAbortController.signal].filter(Boolean)
       );
+      EventEmitter.setMaxListeners(64, waveSignal);
       const runOne = async (id) => {
         const assignment = sanitizedAssignments.find((a) => a.subtaskId === id);
         const worker = workerMap.get(id);
@@ -16537,115 +17148,6 @@ var GraphSearchTool = class extends BaseTool {
   }
 };
 
-// src/core/context/compaction.ts
-function estimateTokens(text) {
-  if (!text) return 0;
-  return Math.max(1, Math.ceil(text.length / 4));
-}
-function contentToText(content) {
-  if (typeof content === "string") return content;
-  return content.map((c) => c.type === "text" ? c.text : c.type === "tool_result" ? c.content : `[${c.type}]`).join(" ");
-}
-function messagesTokens(messages) {
-  return messages.reduce((n, m) => n + estimateTokens(contentToText(m.content)), 0);
-}
-function atomize(text, maxChars) {
-  const seps = ["\n\n", "\n", ". ", " "];
-  let units = [text];
-  for (const sep of seps) {
-    if (units.every((u) => u.length <= maxChars)) break;
-    const next = [];
-    for (const u of units) {
-      if (u.length <= maxChars) {
-        next.push(u);
-        continue;
-      }
-      const parts = u.split(sep);
-      parts.forEach((p, i) => next.push(i < parts.length - 1 ? p + sep : p));
-    }
-    units = next;
-  }
-  const out = [];
-  for (const u of units) {
-    if (u.length <= maxChars) out.push(u);
-    else for (let i = 0; i < u.length; i += maxChars) out.push(u.slice(i, i + maxChars));
-  }
-  return out;
-}
-function chunkText(text, opts) {
-  const maxChars = Math.max(1, Math.floor(opts.maxTokens * 4));
-  const overlap = Math.min(maxChars - 1, Math.max(0, Math.floor(maxChars * (opts.overlapRatio ?? 0.1))));
-  const trimmed = text.trim();
-  if (!trimmed) return [];
-  if (trimmed.length <= maxChars) return [trimmed];
-  const units = atomize(trimmed, maxChars);
-  const chunks = [];
-  let cur = "";
-  for (const u of units) {
-    if (cur && cur.length + u.length > maxChars) {
-      chunks.push(cur.trim());
-      cur = overlap > 0 ? cur.slice(-overlap) : "";
-    }
-    cur += u;
-  }
-  if (cur.trim()) chunks.push(cur.trim());
-  return chunks;
-}
-function needsCompaction(totalTokens, contextWindow, reserve = 0.2) {
-  if (!contextWindow || contextWindow <= 0) return false;
-  return totalTokens > contextWindow * (1 - reserve);
-}
-async function mapReduceCompact(text, opts) {
-  const capChars = opts.capTokens * 4;
-  let working = text;
-  let truncated = false;
-  if (working.length > capChars) {
-    working = working.slice(0, capChars);
-    truncated = true;
-  }
-  const instruction = opts.instruction ?? "Summarize this content, preserving key facts, names, numbers, and decisions.";
-  let chunks = chunkText(working, { maxTokens: opts.chunkTokens });
-  if (chunks.length <= 1) return { text: working, chunks: chunks.length, calls: 0, truncated };
-  let calls = 0;
-  let parts = await Promise.all(
-    chunks.map((c, i) => {
-      calls++;
-      return opts.summarize(c, `${instruction} (part ${i + 1} of ${chunks.length})`);
-    })
-  );
-  let combined = parts.join("\n\n");
-  const maxPasses = opts.maxReducePasses ?? 3;
-  for (let pass = 0; pass < maxPasses && estimateTokens(combined) > opts.targetTokens; pass++) {
-    const groups = chunkText(combined, { maxTokens: opts.chunkTokens });
-    if (groups.length <= 1) break;
-    parts = await Promise.all(
-      groups.map((g) => {
-        calls++;
-        return opts.summarize(g, "Merge these partial summaries into one cohesive summary; keep all distinct facts.");
-      })
-    );
-    combined = parts.join("\n\n");
-  }
-  const note = truncated ? "\n\n[Note: input exceeded the extended-context cap and was truncated.]" : "";
-  return { text: combined + note, chunks: chunks.length, calls, truncated };
-}
-async function rollingSummary(messages, opts) {
-  if (messages.length <= opts.keepRecent) return messages;
-  const older = messages.slice(0, messages.length - opts.keepRecent);
-  const recent = messages.slice(messages.length - opts.keepRecent);
-  const transcript = older.map((m) => `${m.role}: ${contentToText(m.content)}`).join("\n");
-  const summary = await opts.summarize(
-    transcript,
-    "Summarize this earlier conversation. Preserve facts, decisions, names, numbers, and any open threads or todos."
-  );
-  const summaryMessage = {
-    role: "system",
-    content: `Summary of earlier conversation (folded to fit the context window):
-${summary}`
-  };
-  return [summaryMessage, ...recent];
-}
-
 // src/core/steering/guidance.ts
 var GuidanceQueue = class {
   entries = [];
@@ -21788,10 +22290,10 @@ ${cur}`;
 }
 
 // src/retrieval/plan.ts
-var CHARS_PER_TOKEN = 4;
+var CHARS_PER_TOKEN2 = 4;
 function cagCharBudget(contextWindowTokens, opts = {}) {
   const docFraction = opts.docFraction ?? 0.5;
-  const charsPerToken = opts.charsPerToken ?? CHARS_PER_TOKEN;
+  const charsPerToken = opts.charsPerToken ?? CHARS_PER_TOKEN2;
   return Math.max(0, Math.floor(contextWindowTokens * docFraction * charsPerToken));
 }
 function planRetrieval(ctx) {
@@ -22370,7 +22872,7 @@ exports.CASCADE_IGNORE_FILE = CASCADE_IGNORE_FILE;
 exports.CASCADE_KEYSTORE_FILE = CASCADE_KEYSTORE_FILE;
 exports.CASCADE_MD_FILE = CASCADE_MD_FILE;
 exports.CASCADE_VERSION = CASCADE_VERSION;
-exports.CHARS_PER_TOKEN = CHARS_PER_TOKEN;
+exports.CHARS_PER_TOKEN = CHARS_PER_TOKEN2;
 exports.COMPLEXITY_T2_COUNT = COMPLEXITY_T2_COUNT;
 exports.Cascade = Cascade;
 exports.CascadeCancelledError = CascadeCancelledError;