cascade-ai 0.49.0 → 0.51.0

package/dist/index.cjs

@@ -1891,7 +1891,7 @@ function reconcilePrice(model, live) {
 }
 
 // src/constants.ts
-var CASCADE_VERSION = "0.49.0";
+var CASCADE_VERSION = "0.51.0";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -2404,46 +2404,37 @@ var BaseProvider = class {
 };
 
 // src/providers/model-filter.ts
-var NON_CHAT_PATTERNS = [
-  "embed",
+var MODALITY_PATTERNS = [
+  ["embedding", ["embed"]],
   // text-embedding-3, nomic-embed, mxbai-embed, snowflake-arctic-embed
-  "(?:^|[-_/])tts(?:[-_/]|$)",
-  "text-to-speech",
-  "speech",
-  // text-to-speech
-  "whisper",
-  "transcrib",
-  "(?:^|[-_/])stt(?:[-_/]|$)",
-  // speech-to-text
-  "dall[-]?e",
-  "imagen",
-  "image-generation",
-  "gpt-image",
-  "(?:^|[-_/])image(?:[-_/]|$)",
-  "stable-diffusion",
-  "sdxl",
-  "flux",
-  // image gen
-  "moderation",
-  "(?:^|[-_/])guard(?:[-_/]|$)",
-  // moderation / safety
-  "rerank",
-  "(?:^|[-_/])audio(?:[-_/]|$)",
-  "native-audio",
-  "realtime",
-  // audio / realtime
-  "veo",
-  "sora",
-  "(?:^|[-_/])video(?:[-_/]|$)",
-  // video
-  "(?:^|[-_/])aqa(?:[-_/]|$)",
-  // attributed QA
-  "(?:^|[-_/])live(?:[-_/]|$)",
-  // live-audio variants
-  "(?:^|[-_/])(?:davinci|babbage)(?:[-_/]|$)"
-  // legacy completion-only base models
+  ["transcription", ["whisper", "transcrib", "(?:^|[-_/])stt(?:[-_/]|$)"]],
+  ["speech", ["(?:^|[-_/])tts(?:[-_/]|$)", "text-to-speech", "speech"]],
+  ["video", ["veo", "sora", "(?:^|[-_/])video(?:[-_/]|$)"]],
+  ["image", [
+    "dall[-]?e",
+    "imagen",
+    "image-generation",
+    "gpt-image",
+    "(?:^|[-_/])image(?:[-_/]|$)",
+    "stable-diffusion",
+    "sdxl",
+    "flux"
+  ]],
+  ["moderation", ["moderation", "(?:^|[-_/])guard(?:[-_/]|$)"]],
+  ["rerank", ["rerank"]],
+  ["realtime", [
+    "(?:^|[-_/])audio(?:[-_/]|$)",
+    "native-audio",
+    "realtime",
+    "(?:^|[-_/])live(?:[-_/]|$)",
+    // live-audio variants
+    "(?:^|[-_/])aqa(?:[-_/]|$)"
+    // attributed QA
+  ]],
+  ["legacy-completion", ["(?:^|[-_/])(?:davinci|babbage)(?:[-_/]|$)"]]
 ];
-var NON_CHAT = new RegExp(NON_CHAT_PATTERNS.join("|"), "i");
+MODALITY_PATTERNS.map(([m, pats]) => [m, new RegExp(pats.join("|"), "i")]);
+var NON_CHAT = new RegExp(MODALITY_PATTERNS.flatMap(([, p]) => p).join("|"), "i");
 function isChatModel(id, methods) {
   if (methods && methods.length > 0) {
     const canGenerate = methods.some((m) => /generatecontent|generatemessage|chat|completion/i.test(m));
@@ -2971,6 +2962,115 @@ var AzureOpenAIProvider = class extends OpenAIProvider {
     }
   }
 };
+
+// src/providers/gemini-schema.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "format",
+  "title",
+  "description",
+  "nullable",
+  "enum",
+  "items",
+  "properties",
+  "required",
+  "propertyOrdering",
+  "minItems",
+  "maxItems",
+  "minProperties",
+  "maxProperties",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "example",
+  "default",
+  "anyOf"
+]);
+var ALLOWED_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "array", "object"]);
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function normalizeType(value) {
+  if (typeof value === "string") {
+    return ALLOWED_TYPES.has(value) ? { type: value } : {};
+  }
+  if (Array.isArray(value)) {
+    const types = value.filter((t) => typeof t === "string");
+    const nullable = types.includes("null");
+    const concrete = types.find((t) => t !== "null" && ALLOWED_TYPES.has(t));
+    return {
+      ...concrete ? { type: concrete } : {},
+      ...nullable ? { nullable: true } : {}
+    };
+  }
+  return {};
+}
+function normalizeEnum(value) {
+  if (!Array.isArray(value) || value.length === 0) return void 0;
+  return value.map((v) => typeof v === "string" ? v : JSON.stringify(v));
+}
+function sanitizeGeminiSchema(schema) {
+  if (!isPlainObject(schema)) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (!ALLOWED_KEYS.has(key)) continue;
+    switch (key) {
+      case "type": {
+        Object.assign(out, normalizeType(value));
+        break;
+      }
+      case "enum": {
+        const e = normalizeEnum(value);
+        if (e) out["enum"] = e;
+        break;
+      }
+      case "properties": {
+        if (!isPlainObject(value)) break;
+        const props = {};
+        for (const [propName, propSchema] of Object.entries(value)) {
+          const cleaned = sanitizeGeminiSchema(propSchema);
+          props[propName] = cleaned && Object.keys(cleaned).length ? cleaned : { type: "string" };
+        }
+        out["properties"] = props;
+        break;
+      }
+      case "items": {
+        const cleaned = sanitizeGeminiSchema(value);
+        if (cleaned) out["items"] = cleaned;
+        break;
+      }
+      case "anyOf": {
+        if (!Array.isArray(value)) break;
+        const variants = value.map((v) => sanitizeGeminiSchema(v)).filter((v) => !!v && Object.keys(v).length > 0);
+        if (variants.length) out["anyOf"] = variants;
+        break;
+      }
+      case "required": {
+        if (Array.isArray(value)) {
+          out["required"] = value.filter((r) => typeof r === "string");
+        }
+        break;
+      }
+      default:
+        out[key] = value;
+    }
+  }
+  if (!out["type"] && out["properties"]) out["type"] = "object";
+  if (!out["type"] && out["items"]) out["type"] = "array";
+  return out;
+}
+function toGeminiParameters(inputSchema) {
+  const cleaned = sanitizeGeminiSchema(inputSchema);
+  if (!cleaned) return void 0;
+  const props = cleaned["properties"];
+  if (isPlainObject(props) && Object.keys(props).length === 0) return void 0;
+  if (Object.keys(cleaned).length === 0) return void 0;
+  return cleaned;
+}
+
+// src/providers/gemini.ts
 var GeminiProvider = class extends BaseProvider {
   client;
   constructor(config, model) {
@@ -3191,7 +3291,12 @@ var GeminiProvider = class extends BaseProvider {
     return {
       name: tool.name,
       description: tool.description,
-      parameters: tool.inputSchema
+      // 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)
     };
   }
 };
@@ -3219,7 +3324,7 @@ async function nodeHttpFetch(input, init = {}, redirectCount = 0) {
     headers["accept-encoding"] = "gzip, deflate, br";
   }
   const body = init.body == null ? void 0 : typeof init.body === "string" ? init.body : Buffer.from(init.body);
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const req = lib.request(
       {
         hostname: u.hostname,
@@ -3236,7 +3341,7 @@ async function nodeHttpFetch(input, init = {}, redirectCount = 0) {
           const nextUrl = new URL(location, u).href;
           const downgrade = status === 303 || (status === 301 || status === 302) && method !== "GET" && method !== "HEAD";
           const nextInit = downgrade ? { ...init, method: "GET", body: void 0 } : init;
-          resolve(nodeHttpFetch(nextUrl, nextInit, redirectCount + 1));
+          resolve2(nodeHttpFetch(nextUrl, nextInit, redirectCount + 1));
           return;
         }
         const encoding = (res.headers["content-encoding"] ?? "").toLowerCase();
@@ -3251,7 +3356,7 @@ async function nodeHttpFetch(input, init = {}, redirectCount = 0) {
           if (Array.isArray(v)) respHeaders.set(k, v.join(", "));
           else if (typeof v === "string") respHeaders.set(k, v);
         }
-        resolve(new Response(stream$1, {
+        resolve2(new Response(stream$1, {
           status,
           statusText: res.statusMessage ?? "",
           headers: respHeaders
@@ -3896,7 +4001,7 @@ var TpmLimiter = class {
       }
       const deficit = want - bucket.available;
       const waitMs = Math.max(50, Math.ceil(deficit / bucket.tokensPerMinute * 6e4));
-      await new Promise((resolve) => setTimeout(resolve, waitMs));
+      await new Promise((resolve2) => setTimeout(resolve2, waitMs));
     }
   }
   /**
@@ -3959,14 +4064,14 @@ var LocalRequestQueue = class {
       this.active++;
       return this.makeRelease();
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let settled = false;
       let timer;
       const resolver = (release) => {
         if (settled) return;
         settled = true;
         if (timer !== void 0) clearTimeout(timer);
-        resolve(release);
+        resolve2(release);
       };
       if (timeoutMs !== void 0 && timeoutMs > 0) {
         timer = setTimeout(() => {
@@ -4597,6 +4702,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
   tpmLimiter;
   localQueue;
   taskAnalyzer;
+  pendingFeedbackSource;
   worldStateDB;
   privacyPaths;
   guidanceQueue;
@@ -5051,8 +5157,18 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter__default.default {
     return windows.length ? Math.min(...windows) : void 0;
   }
   /** Wire the Cascade Auto task analyzer used for per-subtask model routing. */
+  /**
+   * Feed per-model thumbs counts into Auto routing. Forwarded to the analyzer
+   * because that is where the public benchmark score is combined; the prior
+   * adjusts that number rather than sitting anywhere else in the pipeline.
+   */
+  setFeedbackSource(source) {
+    this.taskAnalyzer?.setFeedbackSource(source);
+    this.pendingFeedbackSource = source;
+  }
   setTaskAnalyzer(analyzer) {
     this.taskAnalyzer = analyzer;
+    if (this.pendingFeedbackSource) analyzer.setFeedbackSource(this.pendingFeedbackSource);
   }
   setWorldStateDB(db) {
     this.worldStateDB = db;
@@ -5507,6 +5623,14 @@ var BaseTier = class extends EventEmitter__default.default {
     this.emit("tier:status", event);
   }
   /** Record the model serving this tier; future status events carry it. */
+  /**
+   * The model actually serving this tier ("provider:id"), once one has been
+   * chosen. The run breaker reads it to attribute a failure to a model rather
+   * than to the subtask that happened to hit it.
+   */
+  getServingModel() {
+    return this.servingModel;
+  }
   setServingModel(model) {
     this.servingModel = model || void 0;
   }
@@ -6138,8 +6262,11 @@ Now execute your subtask using this context where relevant.`
       const result = await this.runAgentLoop(systemPrompt, this.tools);
       output = result.output;
       toolCalls = result.toolCalls;
-      this.sendStatusUpdate({ progressPct: 65, currentAction: "Verifying required artifacts", status: "IN_PROGRESS" });
-      const artifactCheck = await this.verifyArtifacts(assignment);
+      const mustProduceArtifact = this.requiresArtifact();
+      if (mustProduceArtifact) {
+        this.sendStatusUpdate({ progressPct: 65, currentAction: "Verifying required artifacts", status: "IN_PROGRESS" });
+      }
+      const artifactCheck = mustProduceArtifact ? await this.verifyArtifacts(assignment) : { ok: true, issues: [] };
       if (!artifactCheck.ok) {
         correctionAttempts = 1;
         issues.push(...artifactCheck.issues);
@@ -6419,11 +6546,11 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
           if (!wasApproved) return `Tool ${tc.name} was denied by user.`;
         } else {
           const LEGACY_APPROVAL_TIMEOUT_MS = 6e5;
-          const legacyDecision = await new Promise((resolve) => {
+          const legacyDecision = await new Promise((resolve2) => {
             const eventName = `tool:approval-response:${this.id}-${tc.id}`;
             const timer = setTimeout(() => {
               this.removeAllListeners(eventName);
-              resolve({ approved: false });
+              resolve2({ approved: false });
             }, LEGACY_APPROVAL_TIMEOUT_MS);
             timer.unref?.();
             this.emit("tool:approval-request", {
@@ -6436,7 +6563,7 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
             });
             this.once(eventName, (d) => {
               clearTimeout(timer);
-              resolve(d);
+              resolve2(d);
             });
           });
           if (legacyDecision.always) this.sessionApprovals.set(tc.name, legacyDecision.approved);
@@ -6456,6 +6583,9 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         tierId: this.id,
         sessionId: this.taskId,
         requireApproval: false,
+        // Media generation can run for a minute; without this a cancelled run
+        // still pays for an image nobody will see.
+        ...this.signal ? { signal: this.signal } : {},
         saveSnapshot: async (path26, content) => {
           this.store?.addFileSnapshot(this.taskId, path26, content);
         },
@@ -6503,7 +6633,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         const result = await this.toolRegistry.execute(altTool, tc.input, {
           tierId: this.id,
           sessionId: this.taskId,
-          requireApproval: false
+          requireApproval: false,
+          ...this.signal ? { signal: this.signal } : {}
         });
         const str = typeof result === "string" ? result : JSON.stringify(result);
         if (!str.startsWith("Tool error:") && !str.startsWith("Error:")) {
@@ -6525,7 +6656,8 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
           const result = await this.toolRegistry.execute(newToolName, tc.input, {
             tierId: this.id,
             sessionId: this.taskId,
-            requireApproval: false
+            requireApproval: false,
+            ...this.signal ? { signal: this.signal } : {}
           });
           const str = typeof result === "string" ? result : JSON.stringify(result);
           if (!str.startsWith("Tool error:")) return `[Synthesized ${newToolName}]: ${str}`;
@@ -6943,7 +7075,7 @@ var PeerBus = class extends EventEmitter__default.default {
     this.outputs.set(subtaskId, entry);
     this.emit("output:ready", entry);
     const waiting = this.waiters.get(subtaskId) ?? [];
-    for (const resolve of waiting) resolve(entry);
+    for (const resolve2 of waiting) resolve2(entry);
     this.waiters.delete(subtaskId);
   }
   /**
@@ -6974,10 +7106,10 @@ var PeerBus = class extends EventEmitter__default.default {
   waitFor(subtaskId, timeoutMs = 12e4) {
     const existing = this.outputs.get(subtaskId);
     if (existing && !this.retryPending.has(subtaskId)) return Promise.resolve(existing);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const resolver = (output) => {
         clearTimeout(timer);
-        resolve(output);
+        resolve2(output);
       };
       const timer = setTimeout(() => {
         const waiting = this.waiters.get(subtaskId);
@@ -7031,10 +7163,10 @@ var PeerBus = class extends EventEmitter__default.default {
    */
   collect(timeoutMs) {
     const collected = [...this.broadcastLog];
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const timer = setTimeout(() => {
         off();
-        resolve(collected);
+        resolve2(collected);
       }, timeoutMs);
       const handler = (msg) => {
         collected.push({ fromId: msg.fromId, payload: msg.payload, timestamp: msg.timestamp });
@@ -7048,7 +7180,7 @@ var PeerBus = class extends EventEmitter__default.default {
         const broadcasters = new Set(collected.map((m) => m.fromId));
         if (broadcasters.size >= this.members.size) {
           off();
-          resolve(collected);
+          resolve2(collected);
         }
       };
       this.on("broadcast", checkComplete);
@@ -7066,7 +7198,7 @@ var PeerBus = class extends EventEmitter__default.default {
       return;
     }
     this.emitCoordination(tierId, `\u23F3 waiting for ${filePath} (held by ${existing.holderId})`);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         reject(new Error(`File lock timeout for ${filePath} (held by ${existing.holderId})`));
       }, timeoutMs);
@@ -7074,7 +7206,7 @@ var PeerBus = class extends EventEmitter__default.default {
         clearTimeout(timer);
         this.fileLocks.set(filePath, { holderId: tierId, lockedAt: (/* @__PURE__ */ new Date()).toISOString(), waiters: [] });
         this.emitCoordination(tierId, `\u{1F512} locked ${filePath}`);
-        resolve();
+        resolve2();
       });
     });
   }
@@ -7099,11 +7231,11 @@ var PeerBus = class extends EventEmitter__default.default {
    */
   waitForFileRelease(filePath, timeoutMs = 3e4) {
     if (!this.fileLocks.has(filePath)) return Promise.resolve();
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => reject(new Error(`Timeout waiting for file release: ${filePath}`)), timeoutMs);
       this.once(`file:released:${filePath}`, () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
     });
   }
@@ -7169,13 +7301,13 @@ var PeerBus = class extends EventEmitter__default.default {
       this.emit(`barrier:${barrierName}`);
       return;
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         reject(new Error(`Barrier timeout: ${barrierName} (${bar.arrived.size}/${bar.total} arrived)`));
       }, 12e4);
       this.once(`barrier:${barrierName}`, () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
     });
   }
@@ -7242,6 +7374,7 @@ var T2Manager = class extends BaseTier {
   escalations = [];
   peerSyncBuffer = [];
   store;
+  runBreaker;
   t3PeerBus = new PeerBus();
   // ← T3↔T3 bus (local to this T2)
   t2PeerBus;
@@ -7272,6 +7405,15 @@ var T2Manager = class extends BaseTier {
     this.router = router;
     this.toolRegistry = toolRegistry;
   }
+  /**
+   * Share the run-wide circuit breaker. Every T2 in a run gets the SAME
+   * instance: three sections each failing once against a dead model is the
+   * same fact as one section failing three times, and a per-section breaker
+   * would never see it.
+   */
+  setRunBreaker(breaker) {
+    this.runBreaker = breaker;
+  }
   setStore(store) {
     this.store = store;
   }
@@ -7395,7 +7537,8 @@ Guidance (must be followed): ${decision.note}`
       const overallStatus = this.determineStatus(t3Results);
       const isOk = overallStatus === "COMPLETED" || overallStatus === "PARTIAL";
       this.setStatus(isOk ? "COMPLETED" : "FAILED", summary);
-      this.sendStatusUpdate({ progressPct: 100, currentAction: "Section complete", status: "IN_PROGRESS", output: summary });
+      const sectionAction = overallStatus === "COMPLETED" ? "Section complete" : overallStatus === "PARTIAL" ? "Section partially complete \u2014 some subtasks failed" : overallStatus === "ESCALATED" ? "Section escalated \u2014 needs a decision" : "Section failed \u2014 no subtask completed";
+      this.sendStatusUpdate({ progressPct: 100, currentAction: sectionAction, status: "IN_PROGRESS", output: summary });
       const result = {
         sectionId: assignment.sectionId,
         sectionTitle: assignment.sectionTitle,
@@ -7565,6 +7708,24 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
     const reinforceCfg = this.router.getReinforcementsConfig?.() ?? { enabled: false, maxPerSection: 4 };
     let reinforcementsAdded = 0;
     while (remaining.size > 0) {
+      if (this.runBreaker?.isOpen()) {
+        const why = this.runBreaker.skipMessage();
+        this.log(`Run breaker open \u2014 skipping ${remaining.size} remaining subtask(s)`);
+        for (const id of remaining) {
+          this.t3PeerBus.publish(this.id, id, why, "FAILED");
+          resultMap.set(id, {
+            subtaskId: id,
+            status: "FAILED",
+            output: why,
+            testResults: { checksRun: [], passed: [], failed: [] },
+            issues: [why],
+            peerSyncsUsed: [],
+            correctionAttempts: 0
+          });
+        }
+        remaining.clear();
+        break;
+      }
       const runnableIds = [...remaining].filter((id) => (inDegree.get(id) ?? 0) === 0);
       if (runnableIds.length === 0) {
         const fallbackId = [...remaining].sort(
@@ -7667,8 +7828,32 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
         remaining.delete(id);
         const r = waveResults[i];
         if (r.status === "rejected") {
-          this.log(`T3 worker ${id} failed: ${r.reason instanceof Error ? r.reason.message : String(r.reason)} \u2014 retrying once`);
           const assignment = sanitizedAssignments.find((a) => a.subtaskId === id);
+          const failedModel = workerMap.get(id)?.getServingModel();
+          const tripped = this.runBreaker?.record(r.reason, failedModel);
+          if (tripped) {
+            this.log(`Run breaker opened: ${tripped.failures} consecutive ${tripped.kind} failures on ${tripped.modelId} \u2014 stopping`);
+            this.emit("run:breaker", tripped);
+          }
+          if (this.runBreaker?.isOpen()) {
+            const why = this.runBreaker.skipMessage();
+            this.log(`T3 worker ${id} failed and the run breaker is open \u2014 not retrying`);
+            this.t3PeerBus.publish(this.id, id, why, "FAILED");
+            resultMap.set(id, {
+              subtaskId: id,
+              status: "FAILED",
+              output: why,
+              testResults: { checksRun: [], passed: [], failed: [] },
+              issues: [why],
+              peerSyncsUsed: [],
+              correctionAttempts: 0
+            });
+            for (const dependent of adj.get(id) ?? []) {
+              inDegree.set(dependent, Math.max(0, (inDegree.get(dependent) ?? 0) - 1));
+            }
+            continue;
+          }
+          this.log(`T3 worker ${id} failed: ${r.reason instanceof Error ? r.reason.message : String(r.reason)} \u2014 retrying once`);
           try {
             const retried = await this.retryT3(assignment, taskId);
             resultMap.set(id, retried);
@@ -8000,6 +8185,7 @@ var T1Administrator = class extends BaseTier {
   t2Managers = /* @__PURE__ */ new Map();
   escalations = [];
   store;
+  runBreaker;
   t2PeerBus = new PeerBus();
   permissionEscalator;
   toolCreator;
@@ -8014,6 +8200,10 @@ var T1Administrator = class extends BaseTier {
     this.toolRegistry = toolRegistry;
     this.config = config;
   }
+  /** Share the run-wide circuit breaker with every section manager. */
+  setRunBreaker(breaker) {
+    this.runBreaker = breaker;
+  }
   setStore(store) {
     this.store = store;
   }
@@ -8376,6 +8566,7 @@ SPEC RULES \u2014 each subtask is a self-contained spec slice (workers execute f
     };
     const managers = sections.map((section) => {
       const manager = new T2Manager(this.router, this.toolRegistry, this.id);
+      if (this.runBreaker) manager.setRunBreaker(this.runBreaker);
       manager.setHierarchyContext(`You are a T2 Manager for the section "${section.sectionTitle}". You are part of a COMPLEX task overseen by T1 Administrator.`);
       if (this.store) {
         manager.setStore(this.store);
@@ -8661,6 +8852,156 @@ Reply with exactly one word: YES, NO, or UNSURE.
   }
 };
 
+// src/core/multimodal/registry.ts
+var CAPABILITIES = [
+  // ── Image ──
+  {
+    modality: "image",
+    provider: "openai",
+    modelId: "dall-e-3",
+    api: "openai-images"
+  },
+  {
+    modality: "image",
+    provider: "gemini",
+    modelId: "gemini-3-pro-image",
+    api: "gemini-predict"
+  },
+  // ── Speech (text → audio) ──
+  {
+    modality: "speech",
+    provider: "openai",
+    modelId: "tts-1",
+    api: "openai-speech"
+  },
+  {
+    // The only quality claim in this table that needs no leaderboard: OpenAI
+    // ships these as the same voice at two fidelities and charges double for
+    // this one. That is the vendor's own ordering, not an inference.
+    modality: "speech",
+    provider: "openai",
+    modelId: "tts-1-hd",
+    api: "openai-speech",
+    quality: 70,
+    qualityBasis: "OpenAI's own hd variant of tts-1, priced 2x"
+  },
+  // ── Transcription (audio → text) ──
+  {
+    modality: "transcription",
+    provider: "openai",
+    modelId: "whisper-1",
+    api: "openai-transcriptions"
+  },
+  // ── Video ──
+  {
+    // Listed so `describe()` can tell the truth about what exists, and so the
+    // planner is told video is out of reach rather than left to invent a tool.
+    // Veo is a long-running operation: submit, poll, then fetch bytes from a
+    // signed URL. That is a different execution shape from every other entry
+    // here and is not wired up — claiming otherwise would produce a tool that
+    // fails at call time instead of an honest "not yet".
+    modality: "video",
+    provider: "gemini",
+    modelId: "veo-3.1-generate-001",
+    api: "gemini-predict",
+    unsupported: "Veo runs as a long-running operation (submit \u2192 poll \u2192 fetch). Not wired up yet."
+  }
+];
+function capabilityCost(cap) {
+  const match = findPricing(cap.modelId, cap.provider, {
+    fallbackProviders: cap.provider === "gemini" ? ["vertex"] : []
+  });
+  const rate = match?.entry.rates?.[0];
+  if (!rate) return null;
+  const unitLabel = {
+    per_image: "per image",
+    per_second: "per second of video",
+    per_character: "per character",
+    per_audio_minute: "per audio minute"
+  };
+  const unit = unitLabel[rate.unit] ?? rate.unit;
+  const amount = rate.amount;
+  const shown = amount < 1e-3 ? amount.toExponential(2) : amount.toFixed(4);
+  return { label: `$${shown} ${unit}`, amount, unit };
+}
+var MultimodalRegistry = class {
+  /** Provider types the user has actually configured a key for. */
+  available;
+  constructor(availableProviders) {
+    this.available = new Set(availableProviders);
+  }
+  /** Every capability whose provider is configured AND which Cascade can call. */
+  usable(modality) {
+    return CAPABILITIES.filter(
+      (c) => !c.unsupported && this.available.has(c.provider) && (!modality || c.modality === modality)
+    );
+  }
+  /** Modalities this account can actually generate right now. */
+  availableModalities() {
+    return [...new Set(this.usable().map((c) => c.modality))];
+  }
+  /**
+   * Pick a model for a modality.
+   *
+   * Ranked models beat unranked ones, then higher quality, then lower unit
+   * price. An explicit `preferModel` wins outright when it is usable — the user
+   * naming a model is a stronger signal than any prior.
+   */
+  select(modality, opts = {}) {
+    const pool = this.usable(modality);
+    if (!pool.length) return null;
+    if (opts.preferModel) {
+      const wanted = pool.find((c) => c.modelId === opts.preferModel);
+      if (wanted) {
+        return { capability: wanted, cost: capabilityCost(wanted), reason: `Requested explicitly: ${wanted.modelId}.` };
+      }
+    }
+    const scored = pool.map((c) => ({ c, cost: capabilityCost(c) })).sort((a, b) => {
+      const qa = a.c.quality ?? -1;
+      const qb = b.c.quality ?? -1;
+      if (qa !== qb) return qb - qa;
+      const pa = a.cost?.amount ?? Number.POSITIVE_INFINITY;
+      const pb = b.cost?.amount ?? Number.POSITIVE_INFINITY;
+      return pa - pb;
+    });
+    const best = scored[0];
+    const ranked = best.c.quality !== void 0;
+    const reason = ranked ? `${best.c.modelId} (${best.c.provider}) \u2014 ranked highest for ${modality}: ${best.c.qualityBasis}.` + (best.cost ? ` ${best.cost.label}.` : "") : `${best.c.modelId} (${best.c.provider}) \u2014 cheapest usable ${modality} model` + (best.cost ? ` at ${best.cost.label}` : "") + ". No published quality ranking is applied for this modality, so this is a cost choice, not a quality one.";
+    return { capability: best.c, cost: best.cost, reason };
+  }
+  /**
+   * A plain-language account of what this account can and cannot generate —
+   * including the things it cannot, and why. The planner sees this, so being
+   * candid here is what stops it inventing a `generate_music` call.
+   */
+  describe() {
+    const lines = [];
+    const usable = this.usable();
+    if (usable.length) {
+      lines.push("Generation models available on your configured providers:");
+      for (const modality of ["image", "speech", "transcription", "video"]) {
+        const forModality = usable.filter((c) => c.modality === modality);
+        if (!forModality.length) continue;
+        const shown = forModality.map((c) => {
+          const cost = capabilityCost(c);
+          return `${c.modelId}${cost ? ` (${cost.label})` : ""}`;
+        });
+        lines.push(`  ${modality}: ${shown.join(", ")}`);
+      }
+    } else {
+      lines.push("No generation models are available \u2014 none of your configured providers offers one.");
+    }
+    const blocked = CAPABILITIES.filter((c) => c.unsupported && this.available.has(c.provider));
+    for (const c of blocked) {
+      lines.push(`  ${c.modality}: ${c.modelId} exists on your account but is not callable. ${c.unsupported}`);
+    }
+    lines.push(
+      "  music: no supported provider exposes a music-generation API, so Cascade cannot generate music."
+    );
+    return lines.join("\n");
+  }
+};
+
 // src/tools/base.ts
 var BaseTool = class {
   workspaceRoot = process.cwd();
@@ -8679,7 +9020,446 @@ var BaseTool = class {
   }
 };
 
-// src/tools/shell.ts
+// src/core/router/provider-errors.ts
+var SYSTEMIC = /* @__PURE__ */ new Set([
+  "rate_limit",
+  "quota_exhausted",
+  "auth",
+  "model_unavailable"
+]);
+function isSystemicKind(kind) {
+  return SYSTEMIC.has(kind);
+}
+function statusOf(err) {
+  if (!err || typeof err !== "object") return void 0;
+  const e = err;
+  for (const key of ["status", "statusCode", "code"]) {
+    const v = e[key];
+    if (typeof v === "number" && v >= 100 && v < 600) return v;
+  }
+  const resp = e["response"];
+  if (resp && typeof resp["status"] === "number") return resp["status"];
+  const inner = e["error"];
+  if (inner && typeof inner["code"] === "number") return inner["code"];
+  return void 0;
+}
+function messageOf(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  if (err && typeof err === "object") {
+    const e = err;
+    if (typeof e["message"] === "string") return e["message"];
+    const inner = e["error"];
+    if (inner && typeof inner["message"] === "string") return inner["message"];
+    try {
+      return JSON.stringify(err);
+    } catch {
+    }
+  }
+  return String(err);
+}
+function classifyProviderError(err) {
+  const raw = messageOf(err).trim();
+  const status = statusOf(err);
+  const m = raw.toLowerCase();
+  const kind = (() => {
+    if (status === 429) {
+      return /quota|billing|credit|exceeded your current quota|insufficient/.test(m) ? "quota_exhausted" : "rate_limit";
+    }
+    if (status === 401 || status === 403) return "auth";
+    if (status === 404) return "model_unavailable";
+    if (/rate limit|too many requests|resource_exhausted/.test(m)) {
+      return /quota|billing|credit|insufficient/.test(m) ? "quota_exhausted" : "rate_limit";
+    }
+    if (/quota|billing|insufficient_quota|insufficient credit|payment required/.test(m)) return "quota_exhausted";
+    if (/api key|unauthorized|authentication|permission denied|invalid[_ ]api/.test(m)) return "auth";
+    if (/model .*(not found|does not exist|unavailable)|no such model|unknown model|not supported for/.test(m)) {
+      return "model_unavailable";
+    }
+    if (/context length|too many tokens|maximum context|prompt is too long|input too long/.test(m)) return "context_length";
+    if (/safety|content filter|blocked|recitation|prohibited/.test(m)) return "content_filter";
+    if (/econnreset|etimedout|enotfound|socket hang up|network|fetch failed|aborted/.test(m)) return "network";
+    return "unknown";
+  })();
+  return { kind, systemic: isSystemicKind(kind), status, raw };
+}
+function describeProviderError(c, modelId) {
+  const on = modelId ? ` on ${modelId}` : "";
+  const detail = c.raw ? ` Provider said: ${c.raw}` : "";
+  switch (c.kind) {
+    case "rate_limit":
+      return `Rate limit hit${on}. The provider is throttling requests \u2014 lower the number of parallel workers, or use a model with a higher requests-per-minute allowance.${detail}`;
+    case "quota_exhausted":
+      return `Quota or billing limit reached${on}. This will not recover on its own \u2014 check the provider's billing page, or switch this tier to a different provider.${detail}`;
+    case "auth":
+      return `Authentication failed${on}. The API key is missing, expired, or lacks access to this model \u2014 re-check the key in Settings > Providers.${detail}`;
+    case "model_unavailable":
+      return `Model unavailable${on}. The id may be wrong, retired, or not enabled for this API key \u2014 pick a different model for this tier.${detail}`;
+    case "context_length":
+      return `The prompt was too long${on}. Reduce the attached context, or use a model with a larger context window for this tier.${detail}`;
+    case "content_filter":
+      return `The provider's safety filter refused this request${on}.${detail}`;
+    case "network":
+      return `Network error reaching the provider${on}. This is usually transient.${detail}`;
+    default:
+      return `The model call failed${on}.${detail}`;
+  }
+}
+
+// src/core/multimodal/generate.ts
+var DEFAULT_TIMEOUT_MS = 12e4;
+async function callProvider(fn, modelId) {
+  try {
+    return await fn();
+  } catch (err) {
+    const classified = classifyProviderError(err);
+    throw new Error(describeProviderError(classified, modelId));
+  }
+}
+async function postJson(url, body, headers, signal) {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), DEFAULT_TIMEOUT_MS);
+  const onAbort = () => ac.abort();
+  signal?.addEventListener("abort", onAbort);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(body),
+      signal: ac.signal
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw Object.assign(new Error(text || res.statusText), { status: res.status });
+    }
+    return res;
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+function baseUrlFor(cfg, fallback) {
+  return (cfg.baseUrl ?? fallback).replace(/\/+$/, "");
+}
+function stamp(ext) {
+  return `cascade-${Date.now()}.${ext}`;
+}
+async function generateImage(cap, cfg, req, signal) {
+  return callProvider(async () => {
+    if (cap.api === "openai-images") {
+      const url = `${baseUrlFor(cfg, "https://api.openai.com/v1")}/images/generations`;
+      const res = await postJson(url, {
+        model: cap.modelId,
+        prompt: req.prompt,
+        size: req.size ?? "1024x1024",
+        n: 1,
+        // b64 rather than a URL: see the file header — provider URLs expire.
+        response_format: "b64_json"
+      }, { Authorization: `Bearer ${cfg.apiKey ?? ""}` }, signal);
+      const body = await res.json();
+      const first = body.data?.[0];
+      if (!first?.b64_json) throw new Error("Image response contained no image data.");
+      return {
+        data: Buffer.from(first.b64_json, "base64"),
+        mimeType: "image/png",
+        filename: stamp("png"),
+        modelId: cap.modelId,
+        provider: cap.provider,
+        ...first.revised_prompt ? { revisedPrompt: first.revised_prompt } : {}
+      };
+    }
+    if (cap.api === "gemini-predict") {
+      const base = baseUrlFor(cfg, "https://generativelanguage.googleapis.com/v1beta");
+      const url = `${base}/models/${encodeURIComponent(cap.modelId)}:predict`;
+      const res = await postJson(url, {
+        instances: [{ prompt: req.prompt }],
+        parameters: { sampleCount: 1 }
+      }, { "x-goog-api-key": cfg.apiKey ?? "" }, signal);
+      const body = await res.json();
+      const first = body.predictions?.[0];
+      if (!first?.bytesBase64Encoded) throw new Error("Image response contained no image data.");
+      const mimeType = first.mimeType ?? "image/png";
+      return {
+        data: Buffer.from(first.bytesBase64Encoded, "base64"),
+        mimeType,
+        filename: stamp(mimeType.includes("jpeg") ? "jpg" : "png"),
+        modelId: cap.modelId,
+        provider: cap.provider
+      };
+    }
+    throw new Error(`${cap.modelId} is not an image generator.`);
+  }, cap.modelId);
+}
+async function generateSpeech(cap, cfg, req, signal) {
+  return callProvider(async () => {
+    if (cap.api !== "openai-speech") throw new Error(`${cap.modelId} is not a speech model.`);
+    const format = req.format ?? "mp3";
+    const url = `${baseUrlFor(cfg, "https://api.openai.com/v1")}/audio/speech`;
+    const res = await postJson(url, {
+      model: cap.modelId,
+      input: req.text,
+      voice: req.voice ?? "alloy",
+      response_format: format
+    }, { Authorization: `Bearer ${cfg.apiKey ?? ""}` }, signal);
+    const mime = {
+      mp3: "audio/mpeg",
+      opus: "audio/opus",
+      aac: "audio/aac",
+      flac: "audio/flac",
+      wav: "audio/wav"
+    };
+    return {
+      data: Buffer.from(await res.arrayBuffer()),
+      mimeType: mime[format] ?? "application/octet-stream",
+      filename: stamp(format),
+      modelId: cap.modelId,
+      provider: cap.provider
+    };
+  }, cap.modelId);
+}
+async function transcribeAudio(cap, cfg, req, signal) {
+  return callProvider(async () => {
+    if (cap.api !== "openai-transcriptions") throw new Error(`${cap.modelId} is not a transcription model.`);
+    const url = `${baseUrlFor(cfg, "https://api.openai.com/v1")}/audio/transcriptions`;
+    const form = new FormData();
+    form.append("model", cap.modelId);
+    if (req.language) form.append("language", req.language);
+    form.append("file", new Blob([new Uint8Array(req.audio)]), req.filename);
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), DEFAULT_TIMEOUT_MS);
+    const onAbort = () => ac.abort();
+    signal?.addEventListener("abort", onAbort);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${cfg.apiKey ?? ""}` },
+        body: form,
+        signal: ac.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw Object.assign(new Error(text || res.statusText), { status: res.status });
+      }
+      const body = await res.json();
+      return { text: body.text ?? "", modelId: cap.modelId };
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }, cap.modelId);
+}
+
+// src/tools/generate-media.ts
+function resolve(deps, modality, preferModel) {
+  const selected = deps.registry.select(modality, preferModel ? { preferModel } : {});
+  if (!selected) {
+    return { ok: false, error: `No ${modality} model is available on your configured providers.` };
+  }
+  const cfg = deps.lookupProvider(selected.capability.provider);
+  if (!cfg) {
+    return {
+      ok: false,
+      error: `${selected.capability.modelId} needs the ${selected.capability.provider} provider, which is not configured.`
+    };
+  }
+  return { ok: true, selected, cfg };
+}
+var GenerateImageTool = class extends BaseTool {
+  constructor(deps) {
+    super();
+    this.deps = deps;
+  }
+  deps;
+  name = "generate_image";
+  description = "Generate an image from a text description using the best available image model. Returns where the image was saved. Use when the user asks for a picture, illustration, diagram render, logo or any visual asset.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      prompt: { type: "string", description: "What the image should show. Be specific about subject, style and composition." },
+      size: { type: "string", description: 'Pixel size, e.g. "1024x1024" (default), "1792x1024", "1024x1792".' },
+      model: { type: "string", description: "Optional: force a specific image model instead of the automatic choice." }
+    },
+    required: ["prompt"]
+  };
+  async execute(input, options) {
+    const prompt = String(input["prompt"] ?? "").trim();
+    if (!prompt) return 'Provide a "prompt" describing the image.';
+    const r = resolve(this.deps, "image", input["model"] ? String(input["model"]) : void 0);
+    if (!r.ok) return r.error;
+    const size = input["size"] ? String(input["size"]) : void 0;
+    const asset = await generateImage(
+      r.selected.capability,
+      r.cfg,
+      { prompt, ...size ? { size } : {} },
+      options.signal
+    );
+    const location = await this.deps.sink(asset);
+    return [
+      `Image generated and saved to ${location}.`,
+      `Model: ${asset.modelId} \u2014 ${r.selected.reason}`,
+      // DALL·E rewrites the prompt before drawing; the model needs to know what
+      // was actually rendered, not what it asked for, or its description of the
+      // result will not match the image.
+      asset.revisedPrompt ? `The provider rewrote the prompt to: ${asset.revisedPrompt}` : ""
+    ].filter(Boolean).join("\n");
+  }
+};
+var GenerateSpeechTool = class extends BaseTool {
+  constructor(deps) {
+    super();
+    this.deps = deps;
+  }
+  deps;
+  name = "generate_speech";
+  description = "Turn text into spoken audio using the best available text-to-speech model. Returns where the audio was saved. Use when the user asks for narration, a voiceover or an audio version of some text.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      text: { type: "string", description: "The text to speak." },
+      voice: { type: "string", description: "Voice id: alloy, echo, fable, onyx, nova, shimmer. Default alloy." },
+      format: { type: "string", description: "Audio format: mp3 (default), opus, aac, flac, wav." },
+      model: { type: "string", description: "Optional: force a specific speech model." }
+    },
+    required: ["text"]
+  };
+  async execute(input, options) {
+    const text = String(input["text"] ?? "").trim();
+    if (!text) return 'Provide "text" to speak.';
+    const r = resolve(this.deps, "speech", input["model"] ? String(input["model"]) : void 0);
+    if (!r.ok) return r.error;
+    const fmt = String(input["format"] ?? "mp3");
+    const allowed = ["mp3", "opus", "aac", "flac", "wav"];
+    const format = allowed.includes(fmt) ? fmt : "mp3";
+    const asset = await generateSpeech(
+      r.selected.capability,
+      r.cfg,
+      { text, voice: input["voice"] ? String(input["voice"]) : void 0, format },
+      options.signal
+    );
+    const location = await this.deps.sink(asset);
+    return `Speech generated and saved to ${location}.
+Model: ${asset.modelId} \u2014 ${r.selected.reason}`;
+  }
+};
+var TranscribeAudioTool = class extends BaseTool {
+  constructor(deps, readFile) {
+    super();
+    this.deps = deps;
+    this.readFile = readFile;
+  }
+  deps;
+  readFile;
+  name = "transcribe_audio";
+  description = "Transcribe a local audio file to text using the best available speech-to-text model. Use when the user supplies audio and wants its contents in writing.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Path to the audio file to transcribe." },
+      language: { type: "string", description: 'Optional ISO-639-1 language hint, e.g. "en", improves accuracy.' },
+      model: { type: "string", description: "Optional: force a specific transcription model." }
+    },
+    required: ["path"]
+  };
+  async execute(input, options) {
+    const filePath = String(input["path"] ?? "").trim();
+    if (!filePath) return 'Provide a "path" to the audio file.';
+    const r = resolve(this.deps, "transcription", input["model"] ? String(input["model"]) : void 0);
+    if (!r.ok) return r.error;
+    let audio;
+    try {
+      audio = await this.readFile(filePath);
+    } catch {
+      return `Could not read the audio file at ${filePath}.`;
+    }
+    const { text, modelId } = await transcribeAudio(
+      r.selected.capability,
+      r.cfg,
+      {
+        audio,
+        filename: filePath.split(/[\\/]/).pop() || "audio",
+        ...input["language"] ? { language: String(input["language"]) } : {}
+      },
+      options.signal
+    );
+    return text ? `Transcript (${modelId}):
+
+${text}` : `${modelId} returned an empty transcript \u2014 the file may be silent or in an unsupported format.`;
+  }
+};
+function buildMediaTools(deps, readFile) {
+  const tools = [];
+  const modalities = new Set(deps.registry.availableModalities());
+  if (modalities.has("image")) tools.push(new GenerateImageTool(deps));
+  if (modalities.has("speech")) tools.push(new GenerateSpeechTool(deps));
+  if (modalities.has("transcription") && readFile) tools.push(new TranscribeAudioTool(deps, readFile));
+  return tools;
+}
+
+// src/core/run-breaker.ts
+var DEFAULT_FAILURE_THRESHOLD = 3;
+var RunBreaker = class {
+  threshold;
+  /** modelId → consecutive systemic failures of the SAME kind. */
+  counts = /* @__PURE__ */ new Map();
+  trip = null;
+  constructor(threshold = DEFAULT_FAILURE_THRESHOLD) {
+    this.threshold = Math.max(1, threshold);
+  }
+  /**
+   * Record a failed model call. Returns the trip if this failure is the one
+   * that opened the breaker, otherwise null.
+   *
+   * A non-systemic failure RESETS the model's counter: it is evidence the model
+   * is reachable and answering, which is exactly what a systemic streak claims
+   * it is not.
+   */
+  record(err, modelId) {
+    if (this.trip) return null;
+    const id = modelId?.trim() || "unknown-model";
+    const c = classifyProviderError(err);
+    if (!c.systemic) {
+      this.counts.delete(id);
+      return null;
+    }
+    const prev = this.counts.get(id);
+    const n = prev && prev.kind === c.kind ? prev.n + 1 : 1;
+    this.counts.set(id, { kind: c.kind, n, last: c });
+    if (n >= this.threshold) {
+      this.trip = {
+        modelId: id,
+        kind: c.kind,
+        failures: n,
+        message: describeProviderError(c, id)
+      };
+      return this.trip;
+    }
+    return null;
+  }
+  /** True once the run should stop launching work that would fail identically. */
+  isOpen() {
+    return this.trip !== null;
+  }
+  /** Why the breaker opened, or null while it is closed. */
+  reason() {
+    return this.trip;
+  }
+  /**
+   * One line for a worker/section that never ran because the breaker was
+   * already open. Says the work was skipped deliberately — not that it failed
+   * on its own merits, which is what an empty FAILED status would imply.
+   */
+  skipMessage() {
+    const t = this.trip;
+    if (!t) return "Skipped.";
+    return `Skipped \u2014 the run stopped after ${t.failures} consecutive failures on ${t.modelId}. ${t.message}`;
+  }
+  /** Test/diagnostic view of the per-model streaks. */
+  streaks() {
+    const out = {};
+    for (const [k, v] of this.counts) out[k] = { kind: v.kind, n: v.n };
+    return out;
+  }
+};
 var execAsync = util.promisify(child_process.exec);
 var ShellTool = class extends BaseTool {
   name = "shell";
@@ -9375,7 +10155,7 @@ var PDFCreateTool = class extends BaseTool {
     if (!fs23__default.default.existsSync(dir)) {
       fs23__default.default.mkdirSync(dir, { recursive: true });
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       try {
         const doc = new PDFDocument__default.default({ margin: 50 });
         const stream = fs23__default.default.createWriteStream(filePath);
@@ -9393,7 +10173,7 @@ var PDFCreateTool = class extends BaseTool {
         });
         doc.end();
         stream.on("finish", () => {
-          resolve(`Successfully created PDF at ${filePath} (${content.length} characters)`);
+          resolve2(`Successfully created PDF at ${filePath} (${content.length} characters)`);
         });
         stream.on("error", (err) => {
           reject(new Error(`Failed to write PDF: ${err.message}`));
@@ -9465,7 +10245,7 @@ var CodeInterpreterTool = class extends BaseTool {
     const filePath = path24__default.default.join(tmpDir, fileName);
     fs23__default.default.writeFileSync(filePath, code, "utf-8");
     const execArgs = [filePath, ...args];
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const startMs = Date.now();
       child_process.execFile(cmdPrefix, execArgs, { cwd: this.workspaceRoot, timeout: 3e4 }, (error, stdout, stderr) => {
         const duration = Date.now() - startMs;
@@ -9479,17 +10259,17 @@ var CodeInterpreterTool = class extends BaseTool {
         if (error) {
           const timedOut = error.killed && duration >= 3e4;
           if (timedOut) {
-            resolve(`Execution timed out after 30s. Consider breaking the task into smaller pieces.
+            resolve2(`Execution timed out after 30s. Consider breaking the task into smaller pieces.
 Partial stdout: ${stdout}
 Stderr: ${stderr}`);
           } else {
-            resolve(`Execution failed (${duration}ms):
+            resolve2(`Execution failed (${duration}ms):
 Error: ${error.message}
 Stderr: ${stderr}
 Stdout: ${stdout}`);
           }
         } else {
-          resolve(`Execution successful (${duration}ms):
+          resolve2(`Execution successful (${duration}ms):
 Stdout: ${stdout}
 Stderr: ${stderr}`);
         }
@@ -10143,7 +10923,7 @@ var ToolRegistry = class extends EventEmitter__default.default {
    */
   waitForTool(toolName, timeoutMs = 6e4) {
     if (this.tools.has(toolName)) return Promise.resolve();
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.off("tool:added", handler);
         reject(new Error(`Timeout waiting for tool: ${toolName}`));
@@ -10152,7 +10932,7 @@ var ToolRegistry = class extends EventEmitter__default.default {
         if (name === toolName) {
           clearTimeout(timer);
           this.off("tool:added", handler);
-          resolve();
+          resolve2();
         }
       };
       this.on("tool:added", handler);
@@ -10827,20 +11607,20 @@ var PermissionEscalator = class extends EventEmitter__default.default {
     resolver(decision);
   }
   waitForUserDecision(req) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let timer;
       const wrappedResolver = (decision) => {
         if (timer) clearTimeout(timer);
         if (decision.always) {
           this.taskWideCache.set(req.toolName, decision.approved);
         }
-        resolve(decision);
+        resolve2(decision);
       };
       this.pendingUserDecisions.set(req.id, wrappedResolver);
       if (this.approvalTimeoutMs > 0 && Number.isFinite(this.approvalTimeoutMs)) {
         timer = setTimeout(() => {
           if (this.pendingUserDecisions.delete(req.id)) {
-            resolve({
+            resolve2({
               requestId: req.id,
               approved: false,
               decidedBy: "USER",
@@ -11007,6 +11787,14 @@ var BudgetConfigSchema = zod.z.object({
   maxTokensPerRun: zod.z.number().int().positive().default(2e5),
   /** Optional hard per-task cost ceiling (USD). Unset = only the token cap applies. */
   maxCostPerRunUsd: zod.z.number().positive().optional(),
+  /**
+   * Consecutive systemic failures against ONE model before the run stops
+   * launching work that would fail the same way (dead key, wrong model id,
+   * exhausted quota). Lower reacts sooner and wastes less; higher absorbs a
+   * longer transient before giving up. Only failures that will certainly repeat
+   * are counted — see core/run-breaker.ts.
+   */
+  failureThreshold: zod.z.number().int().min(1).max(20).default(3),
   warnAtPct: zod.z.number().default(80)
 });
 var WorkspaceConfigSchema = zod.z.object({
@@ -11294,6 +12082,23 @@ var noopTelemetry = {
   }
 };
 
+// src/core/router/feedback-prior.ts
+var MAX_FEEDBACK_ADJUSTMENT = 0.05;
+var PRIOR_STRENGTH = 10;
+function feedbackAdjustment(counts) {
+  const good = Math.max(0, Math.floor(counts.good));
+  const bad = Math.max(0, Math.floor(counts.bad));
+  const n = good + bad;
+  if (n === 0) return 0;
+  const half = PRIOR_STRENGTH / 2;
+  const shrunk = (good + half) / (n + PRIOR_STRENGTH);
+  return (shrunk - 0.5) * 2 * MAX_FEEDBACK_ADJUSTMENT;
+}
+function applyFeedback(score01, counts) {
+  const adjusted = score01 + feedbackAdjustment(counts);
+  return Math.max(0, Math.min(1, adjusted));
+}
+
 // src/core/router/task-analyzer.ts
 var CODE_SIGNALS = [
   /\b(?:function|class|interface|async|await|import|export|const|let|var|def|return|if|else|for|while|try|catch)\b/,
@@ -11368,6 +12173,8 @@ var TASK_TYPE_TAGS = {
 };
 var TaskAnalyzer = class {
   tracker;
+  /** Per-model thumbs counts, when the host collects them. */
+  feedback;
   bias;
   lastProfile = null;
   lastSelectedModels = /* @__PURE__ */ new Map();
@@ -11375,6 +12182,14 @@ var TaskAnalyzer = class {
     this.tracker = tracker;
     this.bias = bias;
   }
+  /**
+   * Supply per-model rating counts. Optional by design: a host that collects no
+   * feedback (the CLI, a fresh install) scores exactly as it did before, since
+   * feedbackAdjustment returns 0 for an empty record.
+   */
+  setFeedbackSource(source) {
+    this.feedback = source;
+  }
   setTracker(tracker) {
     this.tracker = tracker;
   }
@@ -11458,7 +12273,10 @@ var TaskAnalyzer = class {
     const perf = this.tracker?.performanceScore(model.id, profile.type) ?? 0.5;
     const costEff = this.costEfficiency(model, profile.complexity);
     const match = this.taskMatchScore(model, profile);
-    const benchmark = 0.3 + 0.7 * benchmarkScore01(model, profile.type);
+    const rated = this.feedback?.(model.id);
+    const publicScore = benchmarkScore01(model, profile.type);
+    const adjusted = rated ? applyFeedback(publicScore, rated) : publicScore;
+    const benchmark = 0.3 + 0.7 * adjusted;
     switch (this.bias) {
       case "quality":
         return perf * match * benchmark ** 2 * (0.85 + 0.15 * costEff);
@@ -11860,10 +12678,10 @@ var DynamicTool = class extends BaseTool {
       `;
       const script = await isolate.compileScript(bootstrap);
       const runPromise = script.run(context, { timeout: timeoutMs, promise: true }).then((v) => String(v ?? ""));
-      const timeoutPromise = new Promise((resolve) => {
+      const timeoutPromise = new Promise((resolve2) => {
         const t = setTimeout(() => {
           dispose();
-          resolve(`Dynamic tool "${this.name}" timed out after ${timeoutMs}ms and was terminated.`);
+          resolve2(`Dynamic tool "${this.name}" timed out after ${timeoutMs}ms and was terminated.`);
         }, timeoutMs + 500);
         t.unref?.();
       });
@@ -11881,7 +12699,7 @@ var DynamicTool = class extends BaseTool {
   /** Spawn the worker, service its callTool/fetch bridge, enforce the kill timeout. */
   runInWorker(input, callTool) {
     const timeoutMs = Math.max(200, Number(process.env["CASCADE_DYNAMIC_TOOL_TIMEOUT_MS"]) || DYNAMIC_TOOL_TIMEOUT_MS);
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let settled = false;
       const worker = new worker_threads.Worker(HARNESS_SRC, {
         eval: true,
@@ -11893,7 +12711,7 @@ var DynamicTool = class extends BaseTool {
         settled = true;
         clearTimeout(timer);
         void worker.terminate();
-        resolve(value);
+        resolve2(value);
       };
       const timer = setTimeout(
         () => finish(`Dynamic tool "${this.name}" timed out after ${timeoutMs}ms and was terminated.`),
@@ -13439,6 +14257,7 @@ ${prompt}`;
 var Cascade = class _Cascade extends EventEmitter__default.default {
   router;
   toolRegistry;
+  multimodal;
   mcpClient;
   codeIndex;
   config;
@@ -13477,6 +14296,10 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
       }
     });
     this.toolRegistry = new ToolRegistry(this.config.tools, workspacePath);
+    this.multimodal = new MultimodalRegistry(
+      (this.config.providers ?? []).map((p) => p.type)
+    );
+    this.registerMediaTools(workspacePath);
     this.telemetry = config.telemetry?.enabled ? new Telemetry(config.telemetry, config.telemetry.distinctId ?? "anonymous") : noopTelemetry;
     this.worldStateDB = new WorldStateDB(this.workspacePath, this.config.workspace?.debugWorldState ?? false);
     this.router.setWorldStateDB(this.worldStateDB);
@@ -13530,14 +14353,14 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
     if (this.listenerCount("mcp:approval-required") === 0) {
       return false;
     }
-    return await new Promise((resolve) => {
-      this.pendingMcpApprovals.set(server.name, resolve);
+    return await new Promise((resolve2) => {
+      this.pendingMcpApprovals.set(server.name, resolve2);
       const timeout = setTimeout(() => {
-        if (this.pendingMcpApprovals.delete(server.name)) resolve(false);
+        if (this.pendingMcpApprovals.delete(server.name)) resolve2(false);
       }, 3e4);
       const wrap = (approved) => {
         clearTimeout(timeout);
-        resolve(approved);
+        resolve2(approved);
       };
       this.pendingMcpApprovals.set(server.name, wrap);
       this.emit("mcp:approval-required", { server });
@@ -13611,17 +14434,17 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
     }
     const t2Count = plan.sections.length;
     const t3Count = plan.sections.reduce((sum, s) => sum + (s.t3Subtasks?.length ?? 0), 0);
-    return await new Promise((resolve) => {
+    return await new Promise((resolve2) => {
       const timeout = setTimeout(() => {
         if (this.pendingPlanApproval) {
           this.pendingPlanApproval = void 0;
-          resolve({ approved: true });
+          resolve2({ approved: true });
         }
       }, 12e4);
       this.pendingPlanApproval = (decision) => {
         clearTimeout(timeout);
         this.pendingPlanApproval = void 0;
-        resolve(decision);
+        resolve2(decision);
       };
       this.emit("plan:approval-required", {
         taskId,
@@ -13654,17 +14477,17 @@ var Cascade = class _Cascade extends EventEmitter__default.default {
   }
   async requestContextApproval(info) {
     if (this.listenerCount("context:approval-required") === 0) return true;
-    return await new Promise((resolve) => {
+    return await new Promise((resolve2) => {
       const timeout = setTimeout(() => {
         if (this.pendingContextApproval) {
           this.pendingContextApproval = void 0;
-          resolve(true);
+          resolve2(true);
         }
       }, 12e4);
       this.pendingContextApproval = (approved) => {
         clearTimeout(timeout);
         this.pendingContextApproval = void 0;
-        resolve(approved);
+        resolve2(approved);
       };
       this.emit("context:approval-required", info);
     });
@@ -13744,6 +14567,55 @@ ${input}` }],
     if (this.store) t1.setStore(this.store);
     return t1.previewPlan(prompt);
   }
+  /**
+   * Register image / speech / transcription tools for the modalities this
+   * config can actually serve.
+   *
+   * The sink writes bytes into the workspace, because that is what a desktop or
+   * CLI run wants and it keeps a generated asset indistinguishable from any
+   * other file the run produced. A host with different storage (the cloud
+   * server stores a file row) constructs the tools itself via buildMediaTools
+   * with its own sink.
+   */
+  registerMediaTools(workspacePath) {
+    const allowlist = this.config.tools?.enabledTools;
+    const permitted = (name) => !allowlist || allowlist.includes(name);
+    const tools = buildMediaTools(
+      {
+        registry: this.multimodal,
+        lookupProvider: (provider) => (this.config.providers ?? []).find((p) => p.type === provider),
+        sink: async (asset) => {
+          const fsp = await import('fs/promises');
+          const nodePath = await import('path');
+          const dir = nodePath.join(workspacePath, "generated");
+          await fsp.mkdir(dir, { recursive: true });
+          const dest = nodePath.join(dir, asset.filename);
+          await fsp.writeFile(dest, asset.data);
+          return nodePath.relative(workspacePath, dest);
+        }
+      },
+      async (p) => {
+        const fsp = await import('fs/promises');
+        return fsp.readFile(p);
+      }
+    );
+    for (const tool of tools) {
+      if (!permitted(tool.name)) continue;
+      tool.setWorkspaceRoot(workspacePath);
+      this.toolRegistry.register(tool);
+    }
+  }
+  /**
+   * Supply per-model thumbs-up/down counts so Auto routing can weigh how models
+   * have actually performed for this user, on top of public benchmarks.
+   *
+   * Optional everywhere: with no source, or an empty record, scoring is
+   * byte-identical to before. The adjustment is capped and sample-size shrunk —
+   * see core/router/feedback-prior.ts.
+   */
+  setFeedbackSource(source) {
+    this.router.setFeedbackSource(source);
+  }
   /** True when a task stopped at the budget cap and can be resumed via /continue. */
   hasResumableRun() {
     return this.lastInterruptedRun != null;
@@ -14233,6 +15105,7 @@ ${prompt}` : prompt;
     if (toolCreator) toolCreator.setPermissionEscalator(escalator);
     const rootPrompt = buildContextualPrompt(options.prompt, options.conversationHistory);
     let finalOutput = "";
+    const runBreaker = new RunBreaker(this.config.budget?.failureThreshold);
     let t2Results = [];
     let runError = null;
     let identityPrompt = "";
@@ -14301,6 +15174,7 @@ ${prompt}` : prompt;
         this.emit("tier:status", { tierId: "t3-root", status: "COMPLETED", role: "T3" });
       } else if (complexity === "Moderate") {
         const t2 = new T2Manager(this.router, this.toolRegistry, "root");
+        t2.setRunBreaker(runBreaker);
         t2.setPresenter(true);
         t2.setHierarchyContext("You are the ROOT Manager for this task. There is no T1 Administrator involved in this run. You are responsible for decomposing the task and managing T3 workers directly.");
         if (identityPrompt) {
@@ -14361,6 +15235,7 @@ _(incomplete: ${reasons.join("; ")})_` : partial;
         }
       } else {
         const t1 = new T1Administrator(this.router, this.toolRegistry, this.config);
+        t1.setRunBreaker(runBreaker);
         t1.setPresenter(true);
         t1.setHierarchyContext("You are the top-level Administrator. You are responsible for the overall plan and supervising multiple T2 Managers.");
         if (identityPrompt) {
@@ -14385,6 +15260,20 @@ _(incomplete: ${reasons.join("; ")})_` : partial;
         finalOutput = result.output;
         t2Results = result.t2Results;
       }
+      const trip = runBreaker.reason();
+      if (trip) {
+        finalOutput = [
+          `\u26A0 **Run stopped early \u2014 ${trip.modelId} was failing every request.**`,
+          "",
+          trip.message,
+          "",
+          `Cascade stopped after ${trip.failures} consecutive failures rather than retrying every remaining subtask against the same model, which would have cost more and produced the same result.`,
+          finalOutput ? `
+---
+
+${finalOutput}` : ""
+        ].join("\n").trimEnd();
+      }
     } catch (err) {
       if (err instanceof CascadeCancelledError || err instanceof Error && err.name === "AbortError" || options.signal?.aborted) {
         this.emit("run:cancelled", {
@@ -16389,12 +17278,12 @@ var DashboardServer = class {
         console.warn("\u26A0 Dashboard auth is DISABLED while bound to a non-loopback interface \u2014 this allows unauthenticated remote task execution.");
       }
     }
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const onError = (err) => reject(err);
       this.httpServer.once("error", onError);
       this.httpServer.listen(this.port, this.host, () => {
         this.httpServer.off("error", onError);
-        resolve();
+        resolve2();
       });
     });
     try {
@@ -16418,8 +17307,8 @@ var DashboardServer = class {
     } catch {
     }
     this.globalStore = null;
-    await new Promise((resolve, reject) => {
-      this.httpServer.close((err) => err ? reject(err) : resolve());
+    await new Promise((resolve2, reject) => {
+      this.httpServer.close((err) => err ? reject(err) : resolve2());
     });
   }
   getSocket() {
@@ -16616,8 +17505,8 @@ var DashboardServer = class {
    * timeout denies it.
    */
   makeApprovalCallback(sessionId) {
-    return (request) => new Promise((resolve) => {
-      this.pendingApprovals.set(request.id, { resolve, sessionId });
+    return (request) => new Promise((resolve2) => {
+      this.pendingApprovals.set(request.id, { resolve: resolve2, sessionId });
     });
   }
   /**
@@ -17929,8 +18818,8 @@ var CloudClient = class _CloudClient {
   }
 };
 function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    const t = setTimeout(resolve, ms);
+  return new Promise((resolve2, reject) => {
+    const t = setTimeout(resolve2, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(t);
       reject(new Error("aborted"));