cascade-ai 0.18.0 → 0.19.1

package/dist/index.d.cts

@@ -188,6 +188,13 @@ interface T3SubtaskSpec {
     peerT3Ids: string[];
     dependsOn?: string[];
     executionMode?: 'parallel' | 'sequential';
+    /** Spec slice: the exact file paths this subtask creates or edits. */
+    files?: string[];
+    /** Objectively verifiable acceptance checks for the subtask's output. */
+    acceptance?: string[];
+    /** The ONLY background the worker needs — workers see nothing else, so the
+     * planner must make it self-sufficient (keeps worker context minimal). */
+    contextBrief?: string;
 }
 interface T2ToT3Assignment {
     subtaskId: string;
@@ -200,6 +207,10 @@ interface T2ToT3Assignment {
     sectionTitle?: string;
     dependsOn?: string[];
     executionMode?: 'parallel' | 'sequential';
+    /** Spec slice fields — see T3SubtaskSpec. */
+    files?: string[];
+    acceptance?: string[];
+    contextBrief?: string;
 }
 interface StatusUpdate {
     progressPct: number;
@@ -1557,11 +1568,19 @@ declare abstract class BaseTier extends EventEmitter {
      * which would interleave, are not tagged.
      */
     protected isPresenter: boolean;
+    /**
+     * The model actually serving this tier (`provider:id`), once resolved —
+     * rides on every tier:status event so the desktop can show which model ran
+     * which node (Cockpit node panel / Why panel).
+     */
+    protected servingModel?: string;
     constructor(role: TierRole, id?: string, parentId?: string);
     /** Mark this tier as the run's presenter (root tier). */
     setPresenter(on?: boolean): void;
     getStatus(): TierStatus;
     protected setStatus(status: TierStatus, output?: string): void;
+    /** Record the model serving this tier; future status events carry it. */
+    protected setServingModel(model: string | undefined): void;
     protected setLabel(label: string): void;
     setSystemPromptOverride(prompt: string): void;
     setHierarchyContext(context: string): void;
@@ -1908,7 +1927,18 @@ declare class Cascade extends EventEmitter {
      * explicit multi-part structure, so ordinary single-file asks (handled as
      * Simple/Moderate) don't get over-escalated.
      */
+    /** Shared build/scale signals for the complexity floors below. */
+    private buildSignals;
+    /**
+     * A build prompt with REAL scale: multiple system-level deliverables, or a
+     * deliverable plus explicitly multi-part phrasing. Only these floor to the
+     * full T1→T2→T3 hierarchy — "create a todo app" is a build prompt too, but
+     * flooring every small build to Complex was the #1 token bomb (3-5 managers
+     * × workers for a task one worker handles).
+     */
     private looksClearlyComplex;
+    /** A small single-deliverable build — real work, but one manager's worth. */
+    private looksLikeModerateBuild;
     private static globCache;
     private countWorkspaceFiles;
     private determineComplexity;

package/dist/index.d.ts

@@ -188,6 +188,13 @@ interface T3SubtaskSpec {
     peerT3Ids: string[];
     dependsOn?: string[];
     executionMode?: 'parallel' | 'sequential';
+    /** Spec slice: the exact file paths this subtask creates or edits. */
+    files?: string[];
+    /** Objectively verifiable acceptance checks for the subtask's output. */
+    acceptance?: string[];
+    /** The ONLY background the worker needs — workers see nothing else, so the
+     * planner must make it self-sufficient (keeps worker context minimal). */
+    contextBrief?: string;
 }
 interface T2ToT3Assignment {
     subtaskId: string;
@@ -200,6 +207,10 @@ interface T2ToT3Assignment {
     sectionTitle?: string;
     dependsOn?: string[];
     executionMode?: 'parallel' | 'sequential';
+    /** Spec slice fields — see T3SubtaskSpec. */
+    files?: string[];
+    acceptance?: string[];
+    contextBrief?: string;
 }
 interface StatusUpdate {
     progressPct: number;
@@ -1557,11 +1568,19 @@ declare abstract class BaseTier extends EventEmitter {
      * which would interleave, are not tagged.
      */
     protected isPresenter: boolean;
+    /**
+     * The model actually serving this tier (`provider:id`), once resolved —
+     * rides on every tier:status event so the desktop can show which model ran
+     * which node (Cockpit node panel / Why panel).
+     */
+    protected servingModel?: string;
     constructor(role: TierRole, id?: string, parentId?: string);
     /** Mark this tier as the run's presenter (root tier). */
     setPresenter(on?: boolean): void;
     getStatus(): TierStatus;
     protected setStatus(status: TierStatus, output?: string): void;
+    /** Record the model serving this tier; future status events carry it. */
+    protected setServingModel(model: string | undefined): void;
     protected setLabel(label: string): void;
     setSystemPromptOverride(prompt: string): void;
     setHierarchyContext(context: string): void;
@@ -1908,7 +1927,18 @@ declare class Cascade extends EventEmitter {
      * explicit multi-part structure, so ordinary single-file asks (handled as
      * Simple/Moderate) don't get over-escalated.
      */
+    /** Shared build/scale signals for the complexity floors below. */
+    private buildSignals;
+    /**
+     * A build prompt with REAL scale: multiple system-level deliverables, or a
+     * deliverable plus explicitly multi-part phrasing. Only these floor to the
+     * full T1→T2→T3 hierarchy — "create a todo app" is a build prompt too, but
+     * flooring every small build to Complex was the #1 token bomb (3-5 managers
+     * × workers for a task one worker handles).
+     */
     private looksClearlyComplex;
+    /** A small single-deliverable build — real work, but one manager's worth. */
+    private looksLikeModerateBuild;
     private static globCache;
     private countWorkspaceFiles;
     private determineComplexity;

package/dist/index.js

@@ -190,7 +190,7 @@ var init_audit_logger = __esm({
 });
 
 // src/constants.ts
-var CASCADE_VERSION = "0.18.0";
+var CASCADE_VERSION = "0.19.1";
 var CASCADE_CONFIG_DIR = ".cascade";
 var CASCADE_MD_FILE = "CASCADE.md";
 var CASCADE_IGNORE_FILE = ".cascadeignore";
@@ -993,6 +993,23 @@ var OpenAIProvider = class extends BaseProvider {
 };
 
 // src/providers/azure.ts
+function azureModelForDeployment(cfg) {
+  if (cfg.type !== "azure" || !cfg.deploymentName?.trim()) return null;
+  const id = cfg.deploymentName.trim();
+  return {
+    id,
+    name: cfg.label?.trim() || id,
+    provider: "azure",
+    contextWindow: 128e3,
+    isVisionCapable: false,
+    inputCostPer1kTokens: 25e-4,
+    outputCostPer1kTokens: 0.01,
+    maxOutputTokens: 16e3,
+    supportsStreaming: true,
+    isLocal: false,
+    supportsToolUse: true
+  };
+}
 var AzureOpenAIProvider = class extends OpenAIProvider {
   constructor(config, model) {
     const rawUrl = config.baseUrl ?? AZURE_BASE_URL_TEMPLATE.replace("{resource}", "YOUR_RESOURCE");
@@ -1013,17 +1030,31 @@ var AzureOpenAIProvider = class extends OpenAIProvider {
     });
   }
   async listModels() {
-    return [this.model];
+    const fromDeployment = azureModelForDeployment(this.config);
+    return [fromDeployment ?? this.model];
   }
   async isAvailable() {
+    const params = {
+      model: this.model.id,
+      messages: [{ role: "user", content: "ping" }],
+      max_tokens: 1
+    };
     try {
-      await this.client.chat.completions.create({
-        model: this.model.id,
-        messages: [{ role: "user", content: "ping" }],
-        max_tokens: 1
-      });
+      await this.client.chat.completions.create(params);
       return true;
-    } catch {
+    } catch (err) {
+      if (err?.message && String(err.message).includes("max_completion_tokens")) {
+        try {
+          await this.client.chat.completions.create({
+            model: this.model.id,
+            messages: [{ role: "user", content: "ping" }],
+            max_completion_tokens: 1
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
       return false;
     }
   }
@@ -1765,6 +1796,10 @@ var ModelSelector = class {
         actualId = parts.slice(1).join(":");
       }
     }
+    const registered = this.availableModels.get(actualId);
+    if (registered && (!providerStr || registered.provider === providerStr)) {
+      return registered;
+    }
     if (!providerStr) {
       const lower = actualId.toLowerCase();
       if (lower.includes("claude")) providerStr = "anthropic";
@@ -2522,6 +2557,12 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
       const results = await Promise.all(ocConfigs.map((cfg) => this.discoverOpenAICompatibleModels(cfg)));
       if (results.some(Boolean)) this.selector.markProviderAvailable("openai-compatible");
     }
+    if (availableProviders.has("azure")) {
+      for (const cfg of config.providers) {
+        const model = azureModelForDeployment(cfg);
+        if (model) this.selector.addDynamicModel(model);
+      }
+    }
     for (const tier of ["T1", "T2", "T3"]) {
       const override = tier === "T1" ? config.models.t1 : tier === "T2" ? config.models.t2 : config.models.t3;
       if (!override || override === "auto") continue;
@@ -3128,7 +3169,7 @@ var CascadeRouter = class _CascadeRouter extends EventEmitter {
   ensureProvider(model, configs) {
     const key = `${model.provider}:${model.id}`;
     if (this.providers.has(key)) return;
-    const cfg = configs.find((c) => c.type === model.provider) ?? { type: model.provider };
+    const cfg = (model.provider === "azure" ? configs.find((c) => c.type === "azure" && c.deploymentName === model.id) : void 0) ?? configs.find((c) => c.type === model.provider) ?? { type: model.provider };
     const provider = this.createProvider(cfg, model);
     this.providers.set(key, provider);
   }
@@ -3288,6 +3329,12 @@ var BaseTier = class extends EventEmitter {
    * which would interleave, are not tagged.
    */
   isPresenter = false;
+  /**
+   * The model actually serving this tier (`provider:id`), once resolved —
+   * rides on every tier:status event so the desktop can show which model ran
+   * which node (Cockpit node panel / Why panel).
+   */
+  servingModel;
   constructor(role, id, parentId) {
     super();
     this.role = role;
@@ -3312,11 +3359,16 @@ var BaseTier = class extends EventEmitter {
       label: this.label,
       status,
       timestamp,
-      output
+      output,
+      model: this.servingModel
     };
     this.emit("status", event);
     this.emit("tier:status", event);
   }
+  /** Record the model serving this tier; future status events carry it. */
+  setServingModel(model) {
+    this.servingModel = model || void 0;
+  }
   setLabel(label) {
     this.label = label;
   }
@@ -3339,7 +3391,8 @@ var BaseTier = class extends EventEmitter {
       currentAction: update.currentAction,
       progressPct: update.progressPct,
       timestamp,
-      output: update.output
+      output: update.output,
+      model: this.servingModel
     });
   }
   buildMessage(type, to, payload) {
@@ -3705,6 +3758,21 @@ Available tools: ${tools.map((t) => t.name).join(", ")}.
 When you have enough information, stop calling tools and write your final answer.`;
 }
 
+// src/utils/truncate.ts
+function truncateForContext(text, maxChars = 12e3) {
+  if (text.length <= maxChars) return text;
+  const headLen = Math.floor(maxChars * 0.75);
+  const tailLen = maxChars - headLen;
+  const head = text.slice(0, headLen);
+  const tail = text.slice(-tailLen);
+  const elided = text.length - headLen - tailLen;
+  return `${head}
+
+[... ${elided.toLocaleString()} characters elided to keep context small \u2014 re-read the file with a line range if you need the middle ...]
+
+${tail}`;
+}
+
 // src/core/tiers/t3-worker.ts
 var CriticalToolError = class extends Error {
   constructor(message, toolName) {
@@ -4012,6 +4080,7 @@ Now execute your subtask using this context where relevant.`
     } catch {
     }
     const effectiveModel = subtaskModel ?? this.router.getModelForTier("T3");
+    if (effectiveModel) this.setServingModel(`${effectiveModel.provider}:${effectiveModel.id}`);
     const useTextTools = effectiveModel?.supportsToolUse === false && tools.length > 0;
     let sentFullTextContract = false;
     let textContractSignature = "";
@@ -4109,7 +4178,7 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : "") + textToolSuffix,
         const toolResult = await this.executeTool(tc);
         await this.context.addMessage({
           role: "tool",
-          content: toolResult,
+          content: truncateForContext(toolResult),
           toolCallId: tc.id
         });
       }
@@ -4366,15 +4435,17 @@ ${assignment.expectedOutput}`;
     };
   }
   requiresArtifact() {
+    if (this.assignment?.files?.length) return true;
     const haystack = `${this.assignment?.description ?? ""}
 ${this.assignment?.expectedOutput ?? ""}`;
     return /\b[\w./-]+\.(pdf|md|html|txt|json|csv|py|js|ts|tsx|jsx|docx?|png|jpg|jpeg|svg|gif)\b/i.test(haystack) || /save (?:a|the)? file|create (?:a|the)? file|write (?:a|the)? file/i.test(haystack);
   }
   extractArtifactPaths(assignment) {
+    const declared = (assignment.files ?? []).map((f) => f.trim()).filter((f) => f.includes("."));
     const haystack = `${assignment.description}
 ${assignment.expectedOutput}`;
     const matches = haystack.match(/\b[\w./-]+\.(pdf|md|html|txt|json|csv|py|js|ts|tsx|jsx|docx?|png|jpg|jpeg|svg|gif)\b/gi) ?? [];
-    return [...new Set(matches.map((m) => m.trim()))];
+    return [.../* @__PURE__ */ new Set([...declared, ...matches.map((m) => m.trim())])];
   }
   async verifyArtifacts(assignment) {
     const artifactPaths = this.extractArtifactPaths(assignment);
@@ -4497,7 +4568,9 @@ HIERARCHY CONTEXT: ${this.hierarchyContext}` : ""),
 Assignment: ${assignment.description}
 Expected output: ${assignment.expectedOutput}
 Constraints: ${assignment.constraints.join("; ")}
-
+${assignment.acceptance?.length ? `Acceptance criteria \u2014 ALL must be satisfied for "completeness" to pass:
+${assignment.acceptance.map((a) => `- ${a}`).join("\n")}
+` : ""}
 Output to test:
 ${output}
 
@@ -4586,17 +4659,27 @@ Your subtask:
 - Title: ${assignment.subtaskTitle}
 - Description: ${assignment.description}
 - Expected output: ${assignment.expectedOutput}
-- Constraints: ${assignment.constraints.join("; ")}`;
+- Constraints: ${assignment.constraints.join("; ")}${assignment.files?.length ? `
+- Files you own (create/edit ONLY these): ${assignment.files.join(", ")}` : ""}${assignment.acceptance?.length ? `
+- Definition of done: ${assignment.acceptance.join("; ")}` : ""}`;
   }
   buildInitialPrompt(assignment) {
     return `Execute the following subtask completely:
 
 **${assignment.subtaskTitle}**
-
+${assignment.contextBrief ? `
+Context: ${assignment.contextBrief}
+` : ""}
 ${assignment.description}
 
 Expected output: ${assignment.expectedOutput}
-
+${assignment.files?.length ? `
+Files you own (create or edit exactly these paths):
+${assignment.files.map((f) => `- ${f}`).join("\n")}
+` : ""}${assignment.acceptance?.length ? `
+Definition of done (your output must satisfy ALL of these):
+${assignment.acceptance.map((a) => `- ${a}`).join("\n")}
+` : ""}
 Constraints:
 ${assignment.constraints.map((c) => `- ${c}`).join("\n")}
 
@@ -5077,6 +5160,8 @@ var T2Manager = class extends BaseTier {
     this.assignment = assignment;
     this.taskId = taskId;
     this.setLabel(assignment.sectionTitle);
+    const m = this.router.getModelForTier("T2");
+    if (m) this.setServingModel(`${m.provider}:${m.id}`);
     this.setStatus("ACTIVE");
     this.sendStatusUpdate({
       progressPct: 0,
@@ -5163,7 +5248,7 @@ Guidance (must be followed): ${decision.note}`
   // ── Private ──────────────────────────────────
   async decomposeSection(assignment) {
     const peerPlans = this.peerSyncBuffer.filter((p) => p.content?.type === "T2_PLAN_ANNOUNCEMENT").map((p) => `[Peer ${p.fromId} Plan]: ${p.content.sectionTitle} - ${p.content.subtaskTitles?.join(", ")}`).join("\n");
-    const prompt = `Decompose this section into 2-5 concrete subtasks for T3 workers.
+    const prompt = `Decompose this section into 1-4 concrete subtasks for T3 workers \u2014 the FEWEST that fully cover it (one subtask is the correct answer for a small section).
 
 Section: ${assignment.sectionTitle}
 Description: ${assignment.description}
@@ -5182,6 +5267,9 @@ Return a JSON array of subtask objects, each with:
 - peerT3Ids: string[] (empty for now)
 - dependsOn: string[] (array of subtaskIds this task depends on to start)
 - executionMode: "parallel|sequential" (default is parallel)
+- files: string[] (the EXACT relative paths this subtask creates or edits)
+- acceptance: string[] (1-3 mechanically checkable done-criteria: file exists / contains X / command exits 0)
+- contextBrief: string (1-3 short sentences with ALL the background the worker needs \u2014 it sees nothing else)
 
 Return ONLY the JSON array.`;
     const messages = [{ role: "user", content: prompt }];
@@ -5779,6 +5867,8 @@ var T1Administrator = class extends BaseTier {
     this.signal = signal;
     this.taskId = randomUUID();
     this.setLabel("Administrator");
+    const m = this.router.getModelForTier("T1");
+    if (m) this.setServingModel(`${m.provider}:${m.id}`);
     this.setStatus("ACTIVE");
     this.taskGoal = userPrompt;
     this.sendStatusUpdate({
@@ -6025,10 +6115,13 @@ Return JSON where SECTIONS can declare dependencies on other SECTIONS:
       "description": "Run npm init",
       "expectedOutput": "package.json created",
       "constraints": [],
-      "dependsOn": []
+      "dependsOn": [],
+      "files": ["package.json"],                       // \u2190 exact paths this subtask owns
+      "acceptance": ["package.json exists and parses as JSON"],  // \u2190 objectively checkable
+      "contextBrief": "Fresh Node 20 project; npm available."    // \u2190 ALL the background the worker gets
     }]
   }, {
-    "sectionId": "s2", 
+    "sectionId": "s2",
     "sectionTitle": "Write Tests",
     "description": "Write tests for the project",
     "expectedOutput": "Tests passing",
@@ -6038,7 +6131,13 @@ Return JSON where SECTIONS can declare dependencies on other SECTIONS:
   }]
 }
 Use dependsOn at the SECTION level when a whole T2 Manager needs the output of a previous T2 Manager.
-Leave dependsOn empty for sections that can run immediately in parallel.`;
+Leave dependsOn empty for sections that can run immediately in parallel.
+
+SPEC RULES \u2014 each subtask is a self-contained spec slice (workers execute from their slice ALONE):
+- "files": the exact relative paths the subtask creates or edits. Never vague ("some files"); always concrete.
+- "acceptance": 1-3 checks a reviewer could verify mechanically (file exists / contains X / command exits 0). These define done.
+- "contextBrief": 1-3 short sentences with the ONLY background the worker needs. It sees nothing else about the task, so make the brief self-sufficient \u2014 but never pad it.
+- RIGHT-SIZE the plan: use the FEWEST sections and workers that fully cover the task. One section with 1-2 subtasks is the CORRECT plan for a small task; padding a plan with filler sections wastes the user's money.`;
     const messages = [{ role: "user", content: decompositionPrompt }];
     const result = await this.router.generate("T1", {
       messages,
@@ -7340,30 +7439,56 @@ async function searchTavily(query, apiKey, maxResults) {
     engine: "tavily"
   }));
 }
-async function searchDuckDuckGoLite(query, maxResults) {
-  const resp = await fetch(`https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`, {
-    headers: { "User-Agent": "Mozilla/5.0 (compatible; Cascade-AI/1.0)" },
-    signal: AbortSignal.timeout(1e4)
-  });
-  if (!resp.ok) throw new Error(`DuckDuckGo Lite returned HTTP ${resp.status}`);
-  const html = await resp.text();
-  const linkPattern = /<a[^>]+class="result-link"[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>/g;
-  const snippetPattern = /<td[^>]+class="result-snippet"[^>]*>([\s\S]*?)<\/td>/g;
-  const links = [];
-  const snippets = [];
+var BROWSER_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36";
+function unwrapDdgRedirect(href) {
+  try {
+    const url = new URL(href.startsWith("//") ? `https:${href}` : href, "https://duckduckgo.com");
+    if (/(^|\.)duckduckgo\.com$/i.test(url.hostname) && url.pathname.startsWith("/l/")) {
+      const target = url.searchParams.get("uddg");
+      if (target) return decodeURIComponent(target);
+    }
+    return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : href;
+  } catch {
+    return href;
+  }
+}
+function stripTags(html) {
+  return html.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+}
+function decodeEntities(text) {
+  return text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#x27;|&#39;/g, "'").replace(/&nbsp;/g, " ");
+}
+function parseDdgAnchors(html, anchorClass, snippetClass) {
+  const anchorRe = new RegExp(`<a\\b[^>]*class=["']?[^"'>]*\\b${anchorClass}\\b[^"'>]*["']?[^>]*>([\\s\\S]*?)<\\/a>`, "gi");
+  const snippetRe = new RegExp(`class=["']?[^"'>]*\\b${snippetClass}\\b[^"'>]*["']?[^>]*>([\\s\\S]*?)<\\/(?:td|a|div|span)>`, "gi");
+  const results = [];
   let m;
-  while ((m = linkPattern.exec(html)) !== null) {
-    links.push({ url: m[1], title: m[2].trim() });
+  while ((m = anchorRe.exec(html)) !== null) {
+    const tag = m[0];
+    const href = /href=["']([^"']+)["']/i.exec(tag)?.[1];
+    const title = decodeEntities(stripTags(m[1] ?? ""));
+    if (!href || !title) continue;
+    results.push({ title, url: unwrapDdgRedirect(decodeEntities(href)), snippet: "" });
+  }
+  const snippets = [];
+  while ((m = snippetRe.exec(html)) !== null) {
+    snippets.push(decodeEntities(stripTags(m[1] ?? "")));
   }
-  while ((m = snippetPattern.exec(html)) !== null) {
-    snippets.push(m[1].replace(/<[^>]+>/g, "").trim());
+  for (let i = 0; i < results.length; i++) {
+    if (snippets[i]) results[i].snippet = snippets[i];
   }
-  return links.slice(0, maxResults).map((link, i) => ({
-    title: link.title,
-    url: link.url,
-    snippet: snippets[i] ?? "",
-    engine: "duckduckgo-lite"
-  }));
+  return results;
+}
+async function searchDuckDuckGo(query, maxResults, variant) {
+  const base = variant === "html" ? "https://html.duckduckgo.com/html/?q=" : "https://lite.duckduckgo.com/lite/?q=";
+  const resp = await fetch(`${base}${encodeURIComponent(query)}`, {
+    headers: { "User-Agent": BROWSER_UA, Accept: "text/html" },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!resp.ok) throw new Error(`DuckDuckGo ${variant} returned HTTP ${resp.status}`);
+  const html = await resp.text();
+  const parsed = variant === "html" ? parseDdgAnchors(html, "result__a", "result__snippet") : parseDdgAnchors(html, "result-link", "result-snippet");
+  return parsed.slice(0, maxResults).map((r) => ({ ...r, engine: `duckduckgo-${variant}` }));
 }
 var WebSearchTool = class extends BaseTool {
   name = "web_search";
@@ -7422,12 +7547,14 @@ var WebSearchTool = class extends BaseTool {
         errors.push(`Tavily: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
-    try {
-      results = await searchDuckDuckGoLite(query, maxResults);
-      if (results.length > 0) return this.formatResults(query, results);
-      errors.push("DuckDuckGo Lite: returned 0 results");
-    } catch (err) {
-      errors.push(`DuckDuckGo Lite: ${err instanceof Error ? err.message : String(err)}`);
+    for (const variant of ["html", "lite"]) {
+      try {
+        results = await searchDuckDuckGo(query, maxResults, variant);
+        if (results.length > 0) return this.formatResults(query, results);
+        errors.push(`DuckDuckGo ${variant}: returned 0 results`);
+      } catch (err) {
+        errors.push(`DuckDuckGo ${variant}: ${err instanceof Error ? err.message : String(err)}`);
+      }
     }
     const configHint = !this.config.searxngUrl && !this.config.braveApiKey && !this.config.tavilyApiKey ? "\nTip: Configure a search backend for better results:\n  \u2022 Self-hosted: set SEARXNG_URL in your environment\n  \u2022 Brave Search API: set BRAVE_SEARCH_API_KEY\n  \u2022 Tavily API: set TAVILY_API_KEY" : "";
     return [
@@ -8371,8 +8498,11 @@ var CascadeConfigSchema = z.object({
    * Cascade Auto: when true, the TaskAnalyzer selects the optimal model for each
    * tier based on task type and complexity, overriding the static priority lists.
    * Heuristic-first with AI inference fallback (adds ~0–500ms per task).
+   * ON by default since v0.19.0 — "Auto" without it was just a static priority
+   * list, not the benchmark-value routing the docs describe. Explicit per-tier
+   * model pins are unaffected; disable via config/Settings → Advanced.
    */
-  cascadeAuto: z.boolean().default(false),
+  cascadeAuto: z.boolean().default(true),
   /**
    * Cascade Auto trade-off bias when picking a model for a task:
    *   - 'balanced' (default): quality × cost-efficiency — cheap models win
@@ -10085,13 +10215,30 @@ ${last.partialOutput}` : "");
    * explicit multi-part structure, so ordinary single-file asks (handled as
    * Simple/Moderate) don't get over-escalated.
    */
-  looksClearlyComplex(prompt) {
+  /** Shared build/scale signals for the complexity floors below. */
+  buildSignals(prompt) {
     const p = prompt.trim();
-    if (p.length < 24) return false;
+    if (p.length < 24) return { buildVerb: false, scaleCount: 0, multiPart: false };
     const buildVerb = /\b(?:build|implement|create|develop|design|scaffold|refactor|migrate|architect|set up|integrate)\b/i.test(p);
-    const scaleNoun = /\b(?:app(?:lication)?|system|platform|service|api|backend|frontend|full[- ]?stack|website|dashboard|pipeline|microservices?|database schema|authentication|end[- ]to[- ]end|codebase|project|multiple files|several (?:files|modules|components)|test suite)\b/i.test(p);
+    const scaleCount = (p.match(/\b(?:app(?:lication)?|system|platform|service|api|backend|frontend|full[- ]?stack|website|dashboard|pipeline|microservices?|database schema|authentication|end[- ]to[- ]end|codebase|project|multiple files|several (?:files|modules|components)|test suite)\b/gi) ?? []).length;
     const multiPart = /(?:\b(?:and|then|also|plus|as well as)\b.*\b(?:and|then|also)\b)|(?:^|\n)\s*(?:[-*]|\d+[.)])\s+/i.test(p);
-    return buildVerb && (scaleNoun || multiPart);
+    return { buildVerb, scaleCount, multiPart };
+  }
+  /**
+   * A build prompt with REAL scale: multiple system-level deliverables, or a
+   * deliverable plus explicitly multi-part phrasing. Only these floor to the
+   * full T1→T2→T3 hierarchy — "create a todo app" is a build prompt too, but
+   * flooring every small build to Complex was the #1 token bomb (3-5 managers
+   * × workers for a task one worker handles).
+   */
+  looksClearlyComplex(prompt) {
+    const s = this.buildSignals(prompt);
+    return s.buildVerb && (s.scaleCount >= 2 || s.scaleCount >= 1 && s.multiPart);
+  }
+  /** A small single-deliverable build — real work, but one manager's worth. */
+  looksLikeModerateBuild(prompt) {
+    const s = this.buildSignals(prompt);
+    return s.buildVerb && (s.scaleCount >= 1 || s.multiPart);
   }
   // Cache glob scan results per workspace path to avoid repeated I/O.
   static globCache = /* @__PURE__ */ new Map();
@@ -10179,6 +10326,9 @@ ${prompt}` : prompt;
         if (verdict !== "Complex" && this.looksClearlyComplex(prompt)) {
           this.recordDecision("complexity", `Complex \u2014 heuristic floor over classifier "${verdict}": explicit multi-step build/implementation signals (T1 engaged)`);
           verdict = "Complex";
+        } else if (verdict === "Simple" && this.looksLikeModerateBuild(prompt)) {
+          this.recordDecision("complexity", 'Moderate \u2014 heuristic floor over classifier "Simple": build signals without multi-system scale (single manager)');
+          verdict = "Moderate";
         } else {
           this.recordDecision("complexity", `${verdict} \u2014 classifier: ${reason || "no reason given"}`);
         }