cascade-ai 0.72.0 → 0.74.0

package/dist/desktop-core.cjs

@@ -64564,7 +64564,7 @@ var init_dist2 = __esm({
         }
         this._maxListeners = this._maxListeners || void 0;
       };
-      EventEmitter9.prototype.setMaxListeners = function setMaxListeners2(n8) {
+      EventEmitter9.prototype.setMaxListeners = function setMaxListeners4(n8) {
         if (typeof n8 !== "number" || n8 < 0 || NumberIsNaN(n8)) throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n8 + ".");
         this._maxListeners = n8;
         return this;
@@ -291665,6 +291665,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;
@@ -291781,7 +291790,7 @@ function reconcilePrice(model, live) {
 }
 
 // src/constants.ts
-var CASCADE_VERSION = "0.72.0";
+var CASCADE_VERSION = "0.74.0";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -292226,8 +292235,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,
@@ -292235,7 +292259,7 @@ function resolveModelPricing(model) {
       unknown: false
     };
   }
-  const fromDataset = resolvePricing(model);
+  const fromDataset = resolvePricing(model, { inputTokens: opts.inputTokens });
   if (!fromDataset.unknown) {
     return {
       input: fromDataset.input,
@@ -292257,11 +292281,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: unknown2 } = resolveModelPricing(model);
+  const { input, output, unknown: unknown2 } = resolveModelPricing(model, { inputTokens });
   return {
     inputTokens,
     outputTokens,
@@ -292272,6 +292296,13 @@ function buildTokenUsage(inputTokens, outputTokens, model) {
 }
 
 // src/providers/base.ts
+var ProviderUnreachableError = class extends Error {
+  transient = true;
+  constructor(message) {
+    super(message);
+    this.name = "ProviderUnreachableError";
+  }
+};
 var BaseProvider = class {
   config;
   model;
@@ -292340,6 +292371,21 @@ function anthropicThinkingParam(modelId, maxTokens) {
   if (budget < 1024) return {};
   return { thinking: { type: "enabled", budget_tokens: budget } };
 }
+function toAnthropicTools(tools) {
+  return tools.map((t4) => ({
+    name: t4.name,
+    description: t4.description,
+    input_schema: t4.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(config2, model) {
@@ -292361,11 +292407,7 @@ var AnthropicProvider = class extends BaseProvider {
   }
   async generateStream(options, onChunk) {
     const messages = this.convertMessages(options.messages);
-    const tools = options.tools?.map((t4) => ({
-      name: t4.name,
-      description: t4.description,
-      input_schema: t4.inputSchema
-    }));
+    const tools = options.tools && toAnthropicTools(options.tools);
     let fullContent = "";
     let inputTokens = 0;
     let outputTokens = 0;
@@ -292493,14 +292535,7 @@ var AnthropicProvider = class extends BaseProvider {
         const content = [];
         const text = typeof m3.content === "string" ? m3.content : "";
         if (text) content.push({ type: "text", text });
-        for (const tc of m3.toolCalls ?? []) {
-          content.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.name,
-            input: tc.input
-          });
-        }
+        content.push(...toAnthropicToolUse(m3.toolCalls ?? []));
         if (content.length > 0) {
           result.push({ role: "assistant", content });
         }
@@ -300413,6 +300448,26 @@ function isParamShapeError(err) {
   const msg = String(e3?.message ?? e3?.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((t4) => ({
+    type: "function",
+    function: {
+      name: t4.name,
+      description: t4.description,
+      parameters: t4.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
@@ -300432,14 +300487,7 @@ var OpenAIProvider = class extends BaseProvider {
   }
   async generateStream(options, onChunk) {
     const messages = this.convertMessages(options.messages, options.systemPrompt);
-    const tools = options.tools?.map((t4) => ({
-      type: "function",
-      function: {
-        name: t4.name,
-        description: t4.description,
-        parameters: t4.inputSchema
-      }
-    }));
+    const tools = options.tools && toOpenAITools(options.tools);
     let fullContent = "";
     let inputTokens = 0;
     let outputTokens = 0;
@@ -300585,14 +300633,7 @@ var OpenAIProvider = class extends BaseProvider {
           result.push({
             role: "assistant",
             content: m3.content || "",
-            tool_calls: m3.toolCalls.map((toolCall) => ({
-              id: toolCall.id,
-              type: "function",
-              function: {
-                name: toolCall.name,
-                arguments: JSON.stringify(toolCall.input)
-              }
-            }))
+            tool_calls: toOpenAIToolCalls(m3.toolCalls)
           });
         } else {
           result.push({ role: m3.role, content: m3.content });
@@ -318863,6 +318904,38 @@ 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
+    }
+  }));
+}
+function isGeminiAuthStatus(status) {
+  return status === 400 || status === 401 || status === 403;
+}
+async function describeGeminiError(resp) {
+  try {
+    const body = await resp.json();
+    const detail = body?.error?.message ?? body?.error?.status;
+    return detail ? ` \u2014 ${detail}` : "";
+  } catch {
+    return "";
+  }
+}
 var GeminiProvider = class extends BaseProvider {
   client;
   constructor(config2, model) {
@@ -318884,7 +318957,7 @@ var GeminiProvider = class extends BaseProvider {
           { category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_NONE },
           { category: HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: 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
       }
     });
@@ -318946,9 +319019,7 @@ var GeminiProvider = class extends BaseProvider {
   }
   async listModels() {
     try {
-      const resp = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models?key=${this.config.apiKey}`
-      );
+      const resp = await this.fetchModelList();
       if (!resp.ok) {
         return Object.values(MODELS).filter((m3) => m3.provider === "gemini");
       }
@@ -318979,18 +319050,61 @@ var GeminiProvider = class extends BaseProvider {
       return Object.values(MODELS).filter((m3) => m3.provider === "gemini");
     }
   }
+  /**
+   * Is this KEY usable — not "does one particular model answer".
+   *
+   * This used to call countTokens() against `this.model.id`, which the router
+   * fills from the first Gemini entry in the bundled catalogue. That made the
+   * whole provider's fate depend on one hard-coded model id: a key that cannot
+   * reach that one model — retired, not enabled for the key's project, served
+   * on a different API version — failed the probe, and because every later step
+   * is gated on the result (`validateCloudProviderModels` and
+   * `discoverProviderModels` both return early for an unavailable provider) the
+   * real model list was never fetched. Gemini vanished entirely, and the CLI
+   * reported "add a provider API key first" about a key that was present and
+   * working.
+   *
+   * Listing models asks the account-level question instead, the same one
+   * OpenAI's probe asks, and it is the same request `listModels()` already
+   * makes for discovery.
+   *
+   * Throws rather than returning false. The router logs the reason it catches,
+   * and "bad key, wrong endpoint/deployment, or unreachable" — three guesses,
+   * no answer — is what made this take a user report to find. A swallowed probe
+   * error is the same defect that once hid a misconfigured Azure deployment.
+   */
   async isAvailable() {
+    if (!this.config.apiKey) throw new Error("no Gemini API key configured");
+    let resp;
     try {
-      await this.client.models.countTokens({
-        model: this.model.id,
-        contents: [{ role: "user", parts: [{ text: "ping" }] }]
-      });
-      return true;
-    } catch {
-      return false;
+      resp = await this.fetchModelList();
+    } catch (err) {
+      throw new ProviderUnreachableError(
+        `could not reach the Gemini API: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (resp.ok) return true;
+    const status = `HTTP ${resp.status} ${resp.statusText}`.trim();
+    const detail = await describeGeminiError(resp);
+    if (isGeminiAuthStatus(resp.status)) {
+      throw new Error(`Gemini rejected the API key: ${status}${detail}`);
     }
+    throw new ProviderUnreachableError(`Gemini model list failed: ${status}${detail}`);
   }
   // ── Private ──────────────────────────────────
+  /**
+   * The account's model list. One place so the availability probe and
+   * discovery cannot ask different questions of the same endpoint.
+   *
+   * The key goes in a header, not the query string: a URL carries into proxy
+   * logs, error reports and shell history, and this one would carry the key
+   * with it.
+   */
+  fetchModelList() {
+    return fetch("https://generativelanguage.googleapis.com/v1beta/models", {
+      headers: { "x-goog-api-key": this.config.apiKey ?? "" }
+    });
+  }
   buildContents(messages, extraImages) {
     const contents = [];
     for (const m3 of messages) {
@@ -319025,14 +319139,7 @@ var GeminiProvider = class extends BaseProvider {
         const parts = [];
         const textContent = typeof m3.content === "string" ? m3.content : "";
         if (textContent) parts.push({ text: textContent });
-        for (const tc of m3.toolCalls ?? []) {
-          parts.push({
-            functionCall: {
-              name: tc.name,
-              args: tc.input
-            }
-          });
-        }
+        parts.push(...toGeminiFunctionCalls(m3.toolCalls ?? []));
         if (parts.length > 0) {
           contents.push({ role: "model", parts });
         }
@@ -319079,18 +319186,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");
@@ -319183,6 +319278,24 @@ function isToolCapable(modelName) {
   const name = modelName.toLowerCase();
   return TOOL_CAPABLE_FAMILIES.some((family) => name.includes(family));
 }
+function toOllamaTools(tools) {
+  return tools.map((t4) => ({
+    type: "function",
+    function: {
+      name: t4.name,
+      description: t4.description,
+      parameters: t4.inputSchema
+    }
+  }));
+}
+function toOllamaToolCalls(toolCalls) {
+  return toolCalls.map((tc) => ({
+    function: {
+      name: tc.name,
+      arguments: tc.input
+    }
+  }));
+}
 var OllamaProvider = class extends BaseProvider {
   baseUrl;
   constructor(config2, model) {
@@ -319195,14 +319308,7 @@ var OllamaProvider = class extends BaseProvider {
   }
   async generateStream(options, onChunk) {
     const messages = this.convertMessages(options.messages, options.systemPrompt);
-    const ollamaTools = options.tools?.map((t4) => ({
-      type: "function",
-      function: {
-        name: t4.name,
-        description: t4.description,
-        parameters: t4.inputSchema
-      }
-    }));
+    const ollamaTools = options.tools && toOllamaTools(options.tools);
     const response = await fetch(`${this.baseUrl}/api/chat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -319382,12 +319488,7 @@ var OllamaProvider = class extends BaseProvider {
         result.push({
           role: "assistant",
           content: typeof m3.content === "string" ? m3.content : "",
-          tool_calls: m3.toolCalls.map((tc) => ({
-            function: {
-              name: tc.name,
-              arguments: tc.input
-            }
-          }))
+          tool_calls: toOllamaToolCalls(m3.toolCalls)
         });
         continue;
       }
@@ -319790,6 +319891,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(ms2, signal) {
+  if (!signal) return new Promise((resolve2) => setTimeout(resolve2, ms2));
+  return new Promise((resolve2) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve2();
+    };
+    const timer = setTimeout(done, ms2);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
 var TpmLimiter = class {
   buckets = /* @__PURE__ */ new Map();
   constructor(overrides = {}) {
@@ -319808,9 +319924,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);
@@ -319820,7 +319937,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);
     }
   }
   /**
@@ -319866,6 +319984,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;
@@ -319876,9 +319997,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();
@@ -319886,23 +320014,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);
     });
   }
@@ -320039,6 +320180,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((c4) => c4.type === "text" ? c4.text : c4.type === "tool_result" ? c4.content : `[${c4.type}]`).join(" ");
+}
+function messagesTokens(messages) {
+  return messages.reduce((n8, m3) => n8 + estimateTokens(contentToText(m3.content)), 0);
+}
+function atomize(text, maxChars) {
+  const seps = ["\n\n", "\n", ". ", " "];
+  let units = [text];
+  for (const sep3 of seps) {
+    if (units.every((u2) => u2.length <= maxChars)) break;
+    const next = [];
+    for (const u2 of units) {
+      if (u2.length <= maxChars) {
+        next.push(u2);
+        continue;
+      }
+      const parts = u2.split(sep3);
+      parts.forEach((p3, i4) => next.push(i4 < parts.length - 1 ? p3 + sep3 : p3));
+    }
+    units = next;
+  }
+  const out = [];
+  for (const u2 of units) {
+    if (u2.length <= maxChars) out.push(u2);
+    else for (let i4 = 0; i4 < u2.length; i4 += maxChars) out.push(u2.slice(i4, i4 + 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 trimmed2 = text.trim();
+  if (!trimmed2) return [];
+  if (trimmed2.length <= maxChars) return [trimmed2];
+  const units = atomize(trimmed2, maxChars);
+  const chunks = [];
+  let cur = "";
+  for (const u2 of units) {
+    if (cur && cur.length + u2.length > maxChars) {
+      chunks.push(cur.trim());
+      cur = overlap > 0 ? cur.slice(-overlap) : "";
+    }
+    cur += u2;
+  }
+  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((c4, i4) => {
+      calls++;
+      return opts.summarize(c4, `${instruction} (part ${i4 + 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((g2) => {
+        calls++;
+        return opts.summarize(g2, "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((m3) => `${m3.role}: ${contentToText(m3.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) {
@@ -320073,6 +320324,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((_4, 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((s3) => s3 !== 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 s3 of live) s3.removeEventListener("abort", onAbort);
+  }
+  function onAbort() {
+    const fired = live.find((s3) => s3.aborted);
+    controller.abort(fired?.reason instanceof Error ? fired.reason : new CascadeCancelledError("Run cancelled"));
+    detach();
+  }
+  if (live.some((s3) => s3.aborted)) {
+    onAbort();
+    return { signal: controller.signal, release: detach };
+  }
+  for (const s3 of live) s3.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: (m3) => m3.role === "system",
+  blockHandling: (m3) => {
+    if (m3.role === "tool") return "stringified";
+    if (m3.role === "assistant") return "dropped";
+    return "blocks";
+  },
+  sendsToolCalls: (m3) => m3.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: (m3) => m3.role === "system" && !(typeof m3.content === "string" ? m3.content : "").trim(),
+  blockHandling: (m3) => {
+    if (m3.role === "tool") return "stringified";
+    if (m3.role === "assistant" || m3.role === "system") return "dropped";
+    return "blocks";
+  },
+  sendsToolCalls: (m3) => m3.role === "assistant",
+  sendsBlock: textAndImageOnly,
+  sendsToolCallId: true,
+  sizeToolCalls: toGeminiFunctionCalls,
+  sendsUrlImages: false,
+  readsTopLevelImages: true,
+  sizeTools: toGeminiTools
+};
+var OPENAI = {
+  dropsMessage: () => false,
+  blockHandling: (m3) => {
+    if (m3.role === "system" || m3.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: (m3) => m3.role === "assistant" && typeof m3.content === "string",
+  sendsBlock: textAndImageOnly,
+  sendsToolCallId: true,
+  sizeToolCalls: toOpenAIToolCalls,
+  sendsUrlImages: true,
+  readsTopLevelImages: false,
+  sizeTools: toOpenAITools
+};
+var OLLAMA = {
+  dropsMessage: () => false,
+  blockHandling: (m3) => {
+    if (m3.role === "system") return "dropped";
+    if (m3.role === "tool") return "stringified";
+    if (m3.role === "assistant" && m3.toolCalls?.length) return "dropped";
+    return "blocks";
+  },
+  sendsToolCalls: (m3) => m3.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 m3 of messages) {
+    if (m3.role === "user") {
+      const laterUserTurn = messages.slice(messages.indexOf(m3) + 1).some((x5) => x5.role === "user");
+      return laterUserTurn ? 2 : 1;
+    }
+    const text = typeof m3.content === "string" ? m3.content : "";
+    if (m3.role === "system" && text.trim()) return 1;
+    if (m3.role === "tool") return 1;
+    if (m3.role === "assistant" && (text || m3.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;
@@ -320577,6 +320980,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();
@@ -320629,6 +321062,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;
   /**
@@ -320798,7 +321258,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     try {
       const cfg = this.config.providers.find((p3) => p3.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",
@@ -320806,7 +321266,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 {
@@ -320927,9 +321388,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);
@@ -320951,58 +321415,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(
@@ -321021,11 +321511,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);
@@ -321043,6 +321534,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);
         }
@@ -321064,6 +321557,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);
@@ -321072,6 +321567,8 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
       throw err;
     } finally {
       releaseLocalSlot?.();
+      releaseReservation?.();
+      releaseReservation = void 0;
     }
   }
   getModelForTier(tier) {
@@ -321334,12 +321831,28 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     return this.selector?.getAllAvailableModels() ?? [];
   }
   // ── Private ──────────────────────────────────
+  /**
+   * Why each configured provider failed its availability probe, kept so the
+   * surfaces can say something better than "add an API key" to a user who
+   * already has one. Cleared and refilled by each detectAvailableProviders().
+   */
+  probeFailures = /* @__PURE__ */ new Map();
+  /**
+   * What stopped the configured providers from being usable, if anything.
+   * Empty when every configured provider passed — or when none was configured,
+   * which is a different problem with a different answer.
+   */
+  providerProbeFailures() {
+    return [...this.probeFailures].map(([provider, reason]) => ({ provider, reason }));
+  }
   /** Logs why a configured provider failed its availability probe. */
   emitProbeFailure(type, reason) {
+    this.probeFailures.set(type, reason);
     console.warn(`[router] provider "${type}" is not available: ${reason}`);
   }
   async detectAvailableProviders(configs) {
     const available = /* @__PURE__ */ new Set();
+    this.probeFailures.clear();
     const checks = configs.map(async (cfg) => {
       try {
         const testModel = this.getAnyModelForProvider(cfg.type);
@@ -321349,7 +321862,13 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
         if (ok) available.add(cfg.type);
         else this.emitProbeFailure(cfg.type, "availability check returned false (bad key, wrong endpoint/deployment, or unreachable)");
       } catch (err) {
-        this.emitProbeFailure(cfg.type, err instanceof Error ? err.message : String(err));
+        const reason = err instanceof Error ? err.message : String(err);
+        if (err instanceof ProviderUnreachableError) {
+          available.add(cfg.type);
+          console.warn(`[router] provider "${cfg.type}" probe did not complete: ${reason} \u2014 continuing with it enabled`);
+          return;
+        }
+        this.emitProbeFailure(cfg.type, reason);
       }
     });
     await Promise.allSettled(checks);
@@ -321442,7 +321961,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;
@@ -321467,10 +321993,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
@@ -321480,9 +322009,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: unknown2 } = resolveModelPricing(model, { inputTokens });
+      if (!unknown2 && 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.
@@ -321498,6 +322176,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);
   }
@@ -322734,6 +323413,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(
@@ -323212,6 +323897,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();
@@ -323273,6 +323959,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 {
@@ -323312,6 +323999,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);
@@ -323423,6 +324111,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();
@@ -324670,6 +325362,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((a2) => a2.subtaskId === id);
         const worker = workerMap.get(id);
@@ -372617,115 +373310,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((c4) => c4.type === "text" ? c4.text : c4.type === "tool_result" ? c4.content : `[${c4.type}]`).join(" ");
-}
-function messagesTokens(messages) {
-  return messages.reduce((n8, m3) => n8 + estimateTokens(contentToText(m3.content)), 0);
-}
-function atomize(text, maxChars) {
-  const seps = ["\n\n", "\n", ". ", " "];
-  let units = [text];
-  for (const sep3 of seps) {
-    if (units.every((u2) => u2.length <= maxChars)) break;
-    const next = [];
-    for (const u2 of units) {
-      if (u2.length <= maxChars) {
-        next.push(u2);
-        continue;
-      }
-      const parts = u2.split(sep3);
-      parts.forEach((p3, i4) => next.push(i4 < parts.length - 1 ? p3 + sep3 : p3));
-    }
-    units = next;
-  }
-  const out = [];
-  for (const u2 of units) {
-    if (u2.length <= maxChars) out.push(u2);
-    else for (let i4 = 0; i4 < u2.length; i4 += maxChars) out.push(u2.slice(i4, i4 + 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 trimmed2 = text.trim();
-  if (!trimmed2) return [];
-  if (trimmed2.length <= maxChars) return [trimmed2];
-  const units = atomize(trimmed2, maxChars);
-  const chunks = [];
-  let cur = "";
-  for (const u2 of units) {
-    if (cur && cur.length + u2.length > maxChars) {
-      chunks.push(cur.trim());
-      cur = overlap > 0 ? cur.slice(-overlap) : "";
-    }
-    cur += u2;
-  }
-  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((c4, i4) => {
-      calls++;
-      return opts.summarize(c4, `${instruction} (part ${i4 + 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((g2) => {
-        calls++;
-        return opts.summarize(g2, "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((m3) => `${m3.role}: ${contentToText(m3.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 = [];
@@ -374277,7 +374861,16 @@ ${finalOutput}` : ""
     const selector = this.router.getSelector();
     const model = options.fastAnswerModel ? selector.selectForTier(tier, options.fastAnswerModel) : selector.getCandidatesForTier(tier)[0] ?? selector.selectForTier(tier);
     if (!model) {
-      throw new Error("No model is available for a fast answer \u2014 add a provider API key first.");
+      const failures2 = this.router.providerProbeFailures();
+      const context = failures2.length ? ` Configured providers: ${failures2.map((f4) => `${f4.provider}: ${f4.reason}`).join("; ")}` : "";
+      if (options.fastAnswerModel) {
+        throw new Error(
+          `No model is available for a fast answer: the pinned model "${options.fastAnswerModel}" could not be resolved \u2014 check it is spelled correctly and served by a configured provider.${context}`
+        );
+      }
+      throw new Error(
+        failures2.length ? `No model is available for a fast answer.${context}` : "No model is available for a fast answer \u2014 add a provider API key first."
+      );
     }
     this.recordDecision(
       "model",
@@ -378652,10 +379245,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) {
@@ -379659,7 +380252,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;